source: trunk/ADOL-C/src/uni5_for.c @ 707

Last change on this file since 707 was 707, checked in by awalther, 3 years ago

bug fixed in eq_plus_prod

  • Property svn:keywords set to Author Date Id Revision
File size: 221.1 KB
Line 
1
2/*----------------------------------------------------------------------------
3 ADOL-C -- Automatic Differentiation by Overloading in C++
4 File:     uni5_for.c
5
6
7 Revision: $Id: uni5_for.c 707 2016-07-10 10:20:52Z awalther $
8
9 Contents: Contains the routines :
10           zos_forward (zero-order-scalar forward mode):      define _ZOS_
11           fos_forward (first-order-scalar forward mode):     define _FOS_
12           hos_forward (higher-order-scalar forward mode):    define _HOS_
13           fov_forward (first-order-vector forward mode):     define _FOV_
14           hov_forward (higher-order-vector forward mode):    define _HOV_
15           hov_wk_forward (higher-order-vector forward mode): define _HOV_WK_
16           int_forward_safe:                                  define _INT_FOR_ and _NTIGHT__
17
18           Uses the preprocessor to compile the 7 different object files
19           with/without "keep" parameter:                     define _KEEP_
20
21 Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
22               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel,
23               Benjamin Letschert, Kshitij Kulshreshtha
24               
25
26 This file is part of ADOL-C. This software is provided as open source.
27 Any use, reproduction, or distribution of the software constitutes
28 recipient's acceptance of the terms of the accompanying license file.
29
30----------------------------------------------------------------------------*/
31
32#include <adolc/interfaces.h>
33#include <adolc/adalloc.h>
34#include <adolc/taping.h>
35#include "taping_p.h"
36#include "oplate.h"
37#include <adolc/externfcts.h>
38#include "externfcts_p.h"
39#include "dvlparms.h"
40
41#include <math.h>
42#include <string.h>
43
44#if defined(ADOLC_DEBUG) || defined(_ZOS_)
45#include <string.h>
46#endif /* ADOLC_DEBUG */
47
48#ifdef ADOLC_AMPI_SUPPORT
49#include "ampisupportAdolc.h"
50#endif
51
52/****************************************************************************/
53/*                                                                   MACROS */
54#undef _ADOLC_VECTOR_
55#undef _HIGHER_ORDER_
56
57
58
59/*--------------------------------------------------------------------------*/
60#if defined(_ZOS_)
61#if defined(_ABS_NORM_)
62#  define GENERATED_FILENAME "zos_pl_forward"
63#elif defined(_ABS_NORM_SIG_)
64#  define GENERATED_FILENAME "zos_pl_sig_forward"
65#else
66#  define GENERATED_FILENAME "zos_forward"
67#endif
68/*--------------------------------------------------------------------------*/
69#else
70#if defined(_FOS_)
71#if defined(_ABS_NORM_)
72#define GENERATED_FILENAME "fos_pl_forward"
73#elif defined(_ABS_NORM_SIG_)
74#define GENERATED_FILENAME "fos_pl_sig_forward"
75#else
76#define GENERATED_FILENAME "fos_forward"
77#endif
78
79#define ARGUMENT(indexi,l,i) argument[indexi]
80#define TAYLORS(indexd,l,i)   taylors[indexd]
81
82/*--------------------------------------------------------------------------*/
83#else
84#if defined(_FOV_)
85#if defined(_ABS_NORM_)
86#define GENERATED_FILENAME "fov_pl_forward"
87#elif defined(_ABS_NORM_SIG_)
88#define GENERATED_FILENAME "fov_pl_sig_forward"
89#if defined(_MSC_VER) && _MSC_VER < 180
90#define fmin __min
91#define fmax __max
92#endif
93#else
94#define GENERATED_FILENAME "fov_forward"
95#endif
96
97#define _ADOLC_VECTOR_
98
99#if defined(_CHUNKED_)
100#define ARGUMENT(indexi,l,i) argument[indexi][l+offset]
101#define TAYLORS(indexd,l,i)   taylors[indexd][l+offset]
102#else
103#define ARGUMENT(indexi,l,i) argument[indexi][l]
104#define TAYLORS(indexd,l,i)   taylors[indexd][l]
105#endif
106
107/*--------------------------------------------------------------------------*/
108#else
109#if defined(_HOS_)
110#define GENERATED_FILENAME "hos_forward"
111
112#define _HIGHER_ORDER_
113
114#define ARGUMENT(indexi,l,i) argument[indexi][i]
115#define TAYLORS(indexd,l,i)   taylors[indexd][i]
116
117/*--------------------------------------------------------------------------*/
118#else
119#if defined(_HOV_)
120#define GENERATED_FILENAME "hov_forward"
121
122#define _ADOLC_VECTOR_
123#define _HIGHER_ORDER_
124
125#define ARGUMENT(indexi,l,i) argument[indexi][l][i]
126#define TAYLORS(indexd,l,i)   taylors[indexd][l][i]
127
128/*--------------------------------------------------------------------------*/
129#else
130#if defined(_HOV_WK_)
131#define GENERATED_FILENAME "hov_wk_forward"
132
133#define _ADOLC_VECTOR_
134#define _HIGHER_ORDER_
135
136#define ARGUMENT(indexi,l,i) argument[indexi][l][i]
137#define TAYLORS(indexd,l,i)   taylors[indexd][l][i]
138
139/*--------------------------------------------------------------------------*/
140#else
141#if defined(_INT_FOR_)
142#if defined(_TIGHT_)
143#define GENERATED_FILENAME "int_forward_t"
144#endif
145#if defined(_NTIGHT_)
146#define GENERATED_FILENAME "int_forward_s"
147#endif
148#define ARGUMENT(indexi,l,i) argument[indexi][l]
149#define TAYLORS(indexd,l,i)   taylors[indexd][l]
150/*--------------------------------------------------------------------------*/
151#else
152#if defined(_INDO_)
153void copy_index_domain(int res, int arg, locint **ind_dom);
154void merge_2_index_domains(int res, int arg, locint **ind_dom);
155void combine_2_index_domains(int res, int arg1, int arg2, locint **ind_dom);
156void merge_3_index_domains(int res, int arg1, int arg2, locint **ind_dom);
157
158#define NUMNNZ 20
159#define FMIN_ADOLC(x,y)  ((y<x)?y:x)
160
161#if defined(_INDOPRO_) && !defined(_NONLIND_OLD_)
162#if defined(_TIGHT_)
163#define GENERATED_FILENAME "indopro_forward_t"
164#endif
165#if defined(_NTIGHT_)
166#if defined(_ABS_NORM_)
167#define GENERATED_FILENAME "indopro_forward_pl"
168#else
169#define GENERATED_FILENAME "indopro_forward_s"
170#endif
171#endif
172#endif
173#if defined(_NONLIND_)
174
175typedef struct IndexElement {
176    locint  entry;
177    struct IndexElement* left;
178    struct IndexElement* right;
179}
180IndexElement;
181
182typedef struct IndexElement_sod {
183    locint  entry;
184    struct IndexElement_sod* left;
185}
186IndexElement_sod;
187
188void free_tree(IndexElement* nlf, int num);
189void traverse_crs(IndexElement* fod2, IndexElement_sod* sod, int num);
190void traverse_unary(IndexElement* fod, IndexElement* nonl_dom,  IndexElement* fodi, int num, int maxopind);
191
192#if defined(_TIGHT_)
193#define GENERATED_FILENAME "nonl_ind_forward_t"
194#elif defined(_NTIGHT_)
195#define GENERATED_FILENAME "nonl_ind_forward_s"
196#endif
197#endif
198#if defined(_NONLIND_OLD_)
199
200/*
201 * This is the type used for the list elements. The entry is either a counter
202 * (first element of the NID list) or the index of an independent variable.
203 */
204
205void extend_nonlinearity_domain_binary_step
206(int arg1, int arg2, locint **ind_dom, locint **nonl_dom);
207void extend_nonlinearity_domain_unary
208(int arg, locint **ind_dom, locint **nonl_dom);
209void extend_nonlinearity_domain_binary
210(int arg1, int arg2, locint **ind_dom, locint **nonl_dom);
211
212
213#if defined(_TIGHT_)
214#define GENERATED_FILENAME "nonl_ind_old_forward_t"
215#endif
216#if defined(_NTIGHT_)
217#define GENERATED_FILENAME "nonl_ind_old_forward_s"
218#endif
219#endif
220
221
222/*--------------------------------------------------------------------------*/
223#else
224#error Error ! Define [_ZOS_ | _FOS_ |\
225   _HOS_ | _FOV_ | _HOV_ | _HOV_WK_  | _INT_FOR_SAFE_ | _INT_FOR_TIGHT_ | _INDOPRO_ | _NONLIND_ ] [{_KEEP_}]
226#endif
227#endif
228#endif
229#endif
230#endif
231#endif
232#endif
233#endif
234
235/*--------------------------------------------------------------------------*/
236/*                                                               KEEP stuff */
237#if defined(_KEEP_)
238
239#if defined(_HOV_WK_) /* keep in this vector mode */
240#define IF_KEEP_TAYLOR_CLOSE \
241if (keep){\
242  fprintf(DIAG_OUT,"Succeeding reverse sweep will fail!\n");\
243  taylor_close(0);\
244}
245#define IF_KEEP_WRITE_TAYLOR(res,keep,k,p) \
246    { \
247        UPDATE_TAYLORWRITTEN(keep * k * p) \
248        if (keep) \
249        { \
250            ADOLC_WRITE_SCAYLOR(dp_T0[res]); \
251            if (keep > 1) \
252            write_taylors(res,(keep-1),k,p); \
253        } \
254    }
255#else
256#if defined(_ADOLC_VECTOR_) /* otherwise no keep */
257#define IF_KEEP_TAYLOR_CLOSE
258#define IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
259#else /* _ZOS_, _FOS_, _HOS_ */
260#define IF_KEEP_TAYLOR_CLOSE \
261if (keep){\
262  fprintf(DIAG_OUT,"Otherwise succeeding reverse sweep will fail!\n");\
263  taylor_close(0);\
264}
265#if defined(_ZOS_)
266#define IF_KEEP_WRITE_TAYLOR(res,keep,k,p) \
267    { \
268        UPDATE_TAYLORWRITTEN(keep) \
269        if (keep) \
270            ADOLC_WRITE_SCAYLOR(dp_T0[res]); \
271    }
272#else
273#if defined(_FOS_)
274#define IF_KEEP_WRITE_TAYLOR(res,keep,k,p) \
275    { \
276        UPDATE_TAYLORWRITTEN(keep) \
277        if (keep) \
278        { \
279            ADOLC_WRITE_SCAYLOR(dp_T0[res]); \
280            if (keep > 1) \
281                ADOLC_WRITE_SCAYLOR(dp_T[res]); \
282        } \
283    }
284#else
285#if defined(_HOS_)
286#define IF_KEEP_WRITE_TAYLOR(res,keep,k,p) \
287    { \
288        UPDATE_TAYLORWRITTEN(keep) \
289        if (keep) \
290        { \
291            ADOLC_WRITE_SCAYLOR(dp_T0[res]); \
292            if (keep > 1) \
293                write_taylor(res,keep-1); \
294        } \
295    }
296#endif
297#endif
298#endif
299#endif
300#endif
301
302#else  /* no _KEEP_ */
303#define IF_KEEP_TAYLOR_CLOSE
304#define IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
305#endif
306
307/*--------------------------------------------------------------------------*/
308/*                                                      access to variables */
309#if !defined(_ZOS_)
310#if defined(_FOS_)
311#define TRES         *Tres
312#define TARG         *Targ
313#define TARG1        *Targ1
314#define TARG2        *Targ2
315#define TQO          *Tqo
316
317#define TRES_INC     *Tres
318#define TARG_INC     *Targ
319#define TARG1_INC    *Targ1
320#define TARG2_INC    *Targ2
321#define TQO_INC      *Tqo
322
323#define TRES_DEC     *Tres
324#define TARG_DEC     *Targ
325#define TARG1_DEC    *Targ1
326#define TARG2_DEC    *Targ2
327#define TQO_DEC      *Tqo
328
329#define TRES_FOINC   *Tres
330#define TARG_FOINC   *Targ
331#define TARG1_FOINC  *Targ1
332#define TARG2_FOINC  *Targ2
333#define TQO_FOINC    *Tqo
334
335#define TRES_FODEC   *Tres
336#define DEC_TRES_FO
337#define TARG_FODEC   *Targ
338#define TARG1_FODEC  *Targ1
339#define TARG2_FODEC  *Targ2
340#define TQO_FODEC    *Tqo
341
342#define ASSIGN_T(a,b)  a = &b;
343
344#else
345#if defined(_INT_FOR_)
346#define TRES         *Tres
347#define TARG         *Targ
348#define TARG1        *Targ1
349#define TARG2        *Targ2
350#define TQO          *Tqo
351
352#define TRES_INC     *Tres++
353#define TARG_INC     *Targ++
354#define TARG1_INC    *Targ1++
355#define TARG2_INC    *Targ2++
356#define TQO_INC      *Tqo++
357
358#define TRES_DEC     *Tres--
359#define TARG_DEC     *Targ--
360#define TARG1_DEC    *Targ1--
361#define TARG2_DEC    *Targ2--
362#define TQO_DEC      *Tqo--
363
364#define TRES_FOINC   *Tres++
365#define TARG_FOINC   *Targ++
366#define TARG1_FOINC  *Targ1++
367#define TARG2_FOINC  *Targ2++
368#define TQO_FOINC    *Tqo++
369
370#define TRES_FODEC   *Tres--
371#define TARG_FODEC   *Targ--
372#define TARG1_FODEC  *Targ1--
373#define TARG2_FODEC  *Targ2--
374#define TQO_FODEC    *Tqo--
375
376
377#define ASSIGN_T(a,b)  a = b;
378
379#else  /* _HOS_, _FOV_, _HOV_, _HOV_WK */
380#define TRES         *Tres
381#define TARG         *Targ
382#define TARG1        *Targ1
383#define TARG2        *Targ2
384#define TQO          *Tqo
385
386#define TRES_INC     *Tres++
387#define TARG_INC     *Targ++
388#define TARG1_INC    *Targ1++
389#define TARG2_INC    *Targ2++
390#define TQO_INC      *Tqo++
391
392#define TRES_DEC     *Tres--
393#define TARG_DEC     *Targ--
394#define TARG1_DEC    *Targ1--
395#define TARG2_DEC    *Targ2--
396#define TQO_DEC      *Tqo--
397
398#if defined(_FOV_)
399#define TRES_FOINC   *Tres++
400#define TARG_FOINC   *Targ++
401#define TARG1_FOINC  *Targ1++
402#define TARG2_FOINC  *Targ2++
403#define TQO_FOINC    *Tqo++
404
405#define TRES_FODEC   *Tres
406#define DEC_TRES_FO  Tres--;
407#define TARG_FODEC   *Targ--
408#define TARG1_FODEC  *Targ1--
409#define TARG2_FODEC  *Targ2--
410#define TQO_FODEC    *Tqo--
411#else /* _HOS_, _HOV_, _HOV_WK */
412#define TRES_FOINC   *Tres
413#define TARG_FOINC   *Targ
414#define TARG1_FOINC  *Targ1
415#define TARG2_FOINC  *Targ2
416#define TQO_FOINC    *Tqo
417
418#define TRES_FODEC   *Tres
419#define DEC_TRES_FO
420#define TARG_FODEC   *Targ
421#define TARG1_FODEC  *Targ1
422#define TARG2_FODEC  *Targ2
423#define TQO_FODEC    *Tqo
424#endif
425#endif
426
427#define ASSIGN_T(a,b)  a = b;
428#endif
429#endif
430
431
432/*--------------------------------------------------------------------------*/
433/*                                                               loop stuff */
434#if defined(_ADOLC_VECTOR_)
435#define FOR_0_LE_l_LT_p for (l=0; l<p; l++)
436#define FOR_p_GT_l_GE_0 for (l=p-1; l>=0; l--)
437#if defined(_ABS_NORM_) || defined(_ABS_NORM_SIG_)
438#define FIRSTSIGN_P(x,y) firstsign(p,&(x),y)
439#define COPYTAYL_P(x,y)  FOR_0_LE_l_LT_p x[l] = y[l]
440#define EXT_FIRSTSIGN_P(sigx,sigd,x,y) ext_firstsign(sigx,sigd,p,&(x),y)
441#define EXT_FIRSTSIGN2_P(sigx,x,y) ext_firstsign2(sigx,p,&(x),y)
442#endif
443#else
444#if defined(_INT_FOR_)
445#define FOR_0_LE_l_LT_p for (l=0; l<p; l++)
446#define FOR_p_GT_l_GE_0 for (l=p-1; l>=0; l--)
447#else
448#define FOR_0_LE_l_LT_p
449#define FOR_p_GT_l_GE_0
450#if defined(_ABS_NORM_) || defined(_ABS_NORM_SIG_)
451#define FIRSTSIGN_P(x,y) firstsign(1,&(x),y)
452#define COPYTAYL_P(x,y)  x = *y
453#define EXT_FIRSTSIGN_P(sigx,sigd,x,y) ext_firstsign(sigx,sigd,1,&(x),y)
454#define EXT_FIRSTSIGN2_P(sigx,x,y) ext_firstsign2(sigx,1,&(x),y)
455#endif
456#endif
457#endif
458
459#if defined(_HIGHER_ORDER_)
460#define FOR_0_LE_i_LT_k for (i=0; i<k; i++)
461#define FOR_k_GT_i_GE_0 for (i=k-1; i>=0; i--)
462#else
463#define FOR_0_LE_i_LT_k
464#define FOR_k_GT_i_GE_0
465#endif
466
467#if defined(_HOV_)
468#define FOR_0_LE_l_LT_pk for (l=0; l<pk; l++)
469#define INC_pk_1(T)      T += pk-1;
470#define VEC_INC(T,inc)   T += inc;
471#define HOV_INC(T,inc)   T += inc;
472#else
473#if defined(_HOV_WK_)
474#define FOR_0_LE_l_LT_pk for (l=0; l<pk; l++)
475#define INC_pk_1(T)      T += pk-1;
476#define VEC_INC(T,inc)   T += inc;
477#define HOV_INC(T,inc)   T += inc;
478#else
479#if defined(_FOV_)
480#define FOR_0_LE_l_LT_pk for (l=0; l<p; l++)
481#define INC_pk_1(T)      T += p-1;
482#define VEC_INC(T,inc)   T++;
483#define HOV_INC(T,inc)
484#else
485#if defined(_HOS_)
486#define FOR_0_LE_l_LT_pk for (l=0; l<k; l++)
487#define INC_pk_1(T)      T += k-1;
488#define VEC_INC(T,inc)
489#define HOV_INC(T,inc)
490#else
491#if defined(_INT_FOR_)
492#define FOR_0_LE_l_LT_pk for (l=0; l<p; l++)
493#define INC_pk_1(T)      T += p-1;
494#define VEC_INC(T,inc)   T++;
495#else
496#define FOR_0_LE_l_LT_pk
497#define INC_pk_1(T)
498#define VEC_INC(T,inc)
499#define HOV_INC(T,inc)
500#endif
501#endif
502#endif
503#endif
504#endif
505
506/*--------------------------------------------------------------------------*/
507/*                                                        higher order case */
508#if defined(_HIGHER_ORDER_)
509#define BREAK_FOR_I break;
510#else
511#define BREAK_FOR_I ;
512#endif
513
514/* END Macros */
515
516BEGIN_C_DECLS
517
518#if defined(_ZOS_)
519/****************************************************************************/
520/* Zero Order Scalar version of the forward mode.                           */
521/****************************************************************************/
522#if defined(_ABS_NORM_)
523int zos_pl_forward(short tnum,
524                  int depcheck,
525                  int indcheck,
526                  int keep,
527                  const double *basepoint,
528                  double *valuepoint,
529                  double *swargs)
530#else
531#if defined(_KEEP_)
532int  zos_forward(
533#else
534int  zos_forward_nk(
535#endif
536    short  tnum,              /* tape id */
537    int    depcheck,          /* consistency chk on # of deps */
538    int    indcheck,          /* consistency chk on # of indeps */
539#if defined(_KEEP_)
540    int    keep,              /* flag for reverse sweep */
541#endif
542    const double *basepoint,  /* independant variable values */
543    double       *valuepoint) /* dependent variable values */
544
545#endif
546
547#else
548#if defined(_FOS_)
549/****************************************************************************/
550/* First Order Scalar version of the forward mode.                          */
551/****************************************************************************/
552#if defined(_ABS_NORM_)
553int  fos_pl_forward(short tnum,
554                    int depcheck,
555                    int indcheck,
556                    const double* basepoint,
557                    double *argument,
558                    double *valuepoint,
559                    double *taylors,
560                    double *swargs,
561                    double *swtaylors)
562#elif defined(_ABS_NORM_SIG_)
563int  fos_pl_sig_forward(short tnum,
564                        int depcheck,
565                        int indcheck,
566                        const double* basepoint,
567                        double *argument,
568                        int swcheck,
569                        short *sigbase,
570                        short *sigdir,
571                        double *valuepoint,
572                        double *taylors,
573                        double *swargs,
574                        double *swtaylors,
575                        short *sigsw)
576#else
577#if defined(_KEEP_)
578int  fos_forward(
579#else
580int  fos_forward_nk(
581#endif
582    short  tnum,        /* tape id */
583    int    depcheck,    /* consistency chk on # of deps */
584    int    indcheck,    /* consistency chk on # of indeps */
585#if defined(_KEEP_)
586    int    keep,        /* flag for reverse sweep */
587#endif
588    const double *basepoint,  /* independent variable values */
589    double *argument,   /* Taylor coefficients (input) */
590    double *valuepoint, /* Taylor coefficients (output) */
591    double *taylors)    /* matrix of coefficient vectors */
592/* the order of the indices in argument and taylors is [var][taylor] */
593#endif
594
595#else
596#if defined(_INT_FOR_)
597#if defined(_TIGHT_)
598/****************************************************************************/
599/* First Order Vector version of the forward mode for bit patterns, tight   */
600/****************************************************************************/
601int int_forward_tight(
602    short               tnum,     /* tape id                              */
603    int                 depcheck, /* consistency chk on # of dependents   */
604    int                 indcheck, /* consistency chk on # of independents */
605    int                 p,        /* # of taylor series, bit pattern      */
606    const double       *basepoint,  /* independent variable values   (in)*/
607    unsigned long int **argument,  /* Taylor coeff.                 (in)*/
608    double             *valuepoint, /* dependent variable values    (out)*/
609    unsigned long int **taylors)   /* matrix of coefficient vectors(out)*/
610
611/* int_forward_tight( tag, m, n, p, x[n], X[n][p], y[m], Y[m][p]),
612
613     nBV = number of Boolean Vectors to be packed
614                      (see Chapter Dependence Analysis, ADOL-C Documentation)
615     bits_per_long = 8*sizeof(unsigned long int)
616     p = nBV / bits_per_long + ( (nBV % bits_per_long) != 0 )
617
618     The order of the indices in argument and taylors is [var][taylor]
619
620     For the full Jacobian matrix set
621     p = indep / bits_per_long + ((indep % bits_per_long) != 0)
622     and pass a bit pattern version of the identity matrix as an argument   */
623
624
625#endif
626#if defined (_NTIGHT_)
627/****************************************************************************/
628/* First Order Vector version of the forward mode, bit pattern, safe        */
629/****************************************************************************/
630int int_forward_safe(
631    short             tnum,     /* tape id                              */
632    int               depcheck, /* consistency chk on # of dependents   */
633    int               indcheck, /* consistency chk on # of independents */
634    int               p,        /* # of taylor series, bit pattern      */
635    unsigned long int **argument, /* Taylor coeff.                  (in)*/
636    unsigned long int **taylors)  /* matrix of coefficient vectors (out)*/
637
638/* int_forward_safe( tag, m, n, p, X[n][p], Y[m][p]),
639
640nBV = number of Boolean Vectors to be packed
641(see Chapter Dependence Analysis, ADOL-C Documentation)
642bits_per_long = 8*sizeof(unsigned long int)
643p = nBV / bits_per_long + ( (nBV % bits_per_long) != 0 )
644
645The order of the indices in argument and taylors is [var][taylor]
646
647For the full Jacobian matrix set
648p = indep / bits_per_long + ((indep % bits_per_long) != 0)
649and pass a bit pattern version of the identity matrix as an argument    */
650#endif
651#else
652#if defined(_INDOPRO_) && !defined(_NONLIND_OLD_)
653#if defined(_TIGHT_)
654/****************************************************************************/
655/* First Order Vector version of the forward mode for bit patterns, tight   */
656/****************************************************************************/
657int indopro_forward_tight(
658    short             tnum,        /* tape id                              */
659    int               depcheck,    /* consistency chk on # of dependents   */
660    int               indcheck,    /* consistency chk on # of independents */
661    const double     *basepoint,  /* independent variable values   (in)   */
662    unsigned int    **crs)        /* returned row index storage (out)     */
663
664/* indopro_forward_tight( tag, m, n, x[n], *crs[m]),
665
666  */
667#endif
668#if defined (_NTIGHT_)
669#if defined(_ABS_NORM_)
670int indopro_forward_absnormal(
671    short             tnum,        /* tape id                              */
672    int               depcheck,    /* consistency chk on # of dependents   */
673    int               indcheck,    /* consistency chk on # of independents */
674    int               swcheck,     /* consistency chk on # of switches    */
675    const double     *basepoint,  /* independent variable values   (in)   */
676    unsigned int    **crs)        /* returned row index storage (out)     */
677
678/* indopro_forward_absnormal( tag, m, n, s, x[n], *crs[s+m]),
679  */
680#else
681/****************************************************************************/
682/* First Order Vector version of the forward mode, bit pattern, safe        */
683/****************************************************************************/
684int indopro_forward_safe(
685    short             tnum,        /* tape id                              */
686    int               depcheck,    /* consistency chk on # of dependents   */
687    int               indcheck,    /* consistency chk on # of independents */
688    const double     *basepoint,   /* independent variable values   (in)   */
689    unsigned int    **crs)         /* returned row index storage (out)     */
690
691/* indopro_forward_safe( tag, m, n, x[n], *crs[m]),
692
693  */
694#endif
695#endif
696#else
697#if defined(_NONLIND_)
698#if defined(_TIGHT_)
699/****************************************************************************/
700/* First Order Vector version of the forward mode for bit patterns, tight   */
701/****************************************************************************/
702int nonl_ind_forward_tight(
703    short             tnum,        /* tape id                              */
704    int               depcheck,    /* consistency chk on # of dependents   */
705    int               indcheck,    /* consistency chk on # of independents */
706    const double     *basepoint,  /* independent variable values   (in)   */
707    unsigned int     **crs)        /* returned row index storage (out)     */
708
709#endif
710#if defined (_NTIGHT_)
711/****************************************************************************/
712/* First Order Vector version of the forward mode, bit pattern, safe        */
713/****************************************************************************/
714int nonl_ind_forward_safe(
715    short             tnum,        /* tape id                              */
716    int               depcheck,    /* consistency chk on # of dependents   */
717    int               indcheck,    /* consistency chk on # of independents */
718    const double      *basepoint,  /* independent variable values   (in)   */
719    unsigned int    **crs)        /* returned row index storage (out)     */
720
721/* indopro_forward_safe( tag, m, n, x[n], *crs[m]),
722
723  */
724#endif
725#else
726#if defined(_NONLIND_OLD_)
727#if defined(_TIGHT_)
728/****************************************************************************/
729/* First Order Vector version of the forward mode for bit patterns, tight   */
730/****************************************************************************/
731int nonl_ind_old_forward_tight(
732    short             tnum,        /* tape id                              */
733    int               depcheck,    /* consistency chk on # of dependents   */
734    int               indcheck,    /* consistency chk on # of independents */
735    const double     *basepoint,  /* independent variable values   (in)   */
736    unsigned int     **crs)        /* returned row index storage (out)     */
737
738#endif
739#if defined (_NTIGHT_)
740/****************************************************************************/
741/* First Order Vector version of the forward mode, bit pattern, safe        */
742/****************************************************************************/
743int nonl_ind_old_forward_safe(
744    short             tnum,        /* tape id                              */
745    int               depcheck,    /* consistency chk on # of dependents   */
746    int               indcheck,    /* consistency chk on # of independents */
747    const double      *basepoint,  /* independent variable values   (in)   */
748    unsigned int    **crs)        /* returned row index storage (out)     */
749
750/* indopro_forward_safe( tag, m, n, x[n], *crs[m]),
751
752  */
753#endif
754#else
755#if defined(_FOV_)
756#if defined(_CHUNKED_)
757/****************************************************************************/
758/* First Order Vector version of the forward mode with p-offset in          */
759/* **argument and **taylors                                                 */
760/****************************************************************************/
761int  fov_offset_forward(
762    short  tnum,        /* tape id */
763    int    depcheck,    /* consistency chk on # of deps */
764    int    indcheck,    /* consistency chk on # of indeps */
765    int    p,           /* # of taylor series */
766    int    offset,      /* offset for assignments */
767    const double *basepoint,  /* independent variable values */
768    double **argument,  /* Taylor coefficients (input) */
769    double *valuepoint, /* Taylor coefficients (output) */
770    double **taylors)   /* matrix of coifficient vectors */
771/* the order of the indices in argument and taylors is [var][taylor] */
772#else
773/****************************************************************************/
774/* First Order Vector version of the forward mode.                          */
775/****************************************************************************/
776#if defined(_ABS_NORM_)
777int  fov_pl_forward(
778    short         tnum,        /* tape id */
779    int           depcheck,    /* consistency chk on # of deps */
780    int           indcheck,    /* consistency chk on # of indeps */
781    int           p,           /* # of taylor series */
782    const double *basepoint,   /* independent variable values */
783    double      **argument,    /* Taylor coefficients (input) */
784    double       *valuepoint,  /* Taylor coefficients (output) */
785    double      **taylors,     /* matrix of coifficient vectors */
786    double       *swargs,
787    double      **swtaylors,
788    short        *sigsw)
789/* the order of the indices in argument and taylors is [var][taylor] */
790#elif defined(_ABS_NORM_SIG_)
791int  fov_pl_sig_forward(
792    short         tnum,        /* tape id */
793    int           depcheck,    /* consistency chk on # of deps */
794    int           indcheck,    /* consistency chk on # of indeps */
795    int           p,           /* # of taylor series */
796    const double *basepoint,   /* independent variable values */
797    double      **argument,    /* Taylor coefficients (input) */
798    int           swcheck,     /* consistency chk in # of switches */
799    short        *sigbase,     /* Signature of basepoint */
800    short        *sigdir,      /* Signature of direction */
801    double       *valuepoint,  /* Taylor coefficients (output) */
802    double      **taylors,     /* matrix of coifficient vectors */
803    double       *swargs,
804    double      **swtaylors,
805    short        *sigsw)
806#else
807int  fov_forward(
808    short         tnum,        /* tape id */
809    int           depcheck,    /* consistency chk on # of deps */
810    int           indcheck,    /* consistency chk on # of indeps */
811    int           p,           /* # of taylor series */
812    const double *basepoint,   /* independent variable values */
813    double      **argument,    /* Taylor coefficients (input) */
814    double       *valuepoint,  /* Taylor coefficients (output) */
815    double      **taylors)     /* matrix of coifficient vectors */
816/* the order of the indices in argument and taylors is [var][taylor] */
817#endif
818#endif
819
820#else
821#if defined(_HOS_)
822/****************************************************************************/
823/* Higher Order Scalar version of the forward mode.                         */
824/****************************************************************************/
825#if defined(_KEEP_)
826int  hos_forward(
827#else
828int  hos_forward_nk(
829#endif
830    short  tnum,        /* tape id */
831    int    depcheck,    /* consistency chk on # of dependents */
832    int    indcheck,    /* consistency chk on # of independents */
833    int    gdegree,     /* highest derivative degree */
834#if defined(_KEEP_)
835    int    keep,        /* flag for reverse sweep */
836#endif
837    const double *basepoint,  /* independent variable values */
838    double **argument,  /* independant variable values */
839    double *valuepoint, /* Taylor coefficients (output) */
840    double **taylors)   /* matrix of coifficient vectors */
841
842
843#else
844/****************************************************************************/
845/* Higher Order Vector version of the forward mode.                         */
846/****************************************************************************/
847#if defined(_KEEP_)
848int  hov_wk_forward(
849#else
850int  hov_forward(
851#endif
852    short  tnum,        /* tape id */
853    int    depcheck,    /* consistency chk on # of deps */
854    int    indcheck,    /* consistency chk on # of indeps */
855    int    gdegree,     /* highest derivative degree */
856#if defined(_KEEP_)
857    int    keep,        /* flag for reverse sweep */
858#endif
859    int    p,           /* # of taylor series */
860    const double *basepoint,  /* independent variable values */
861    double ***argument, /* Taylor coefficients (input) */
862    double *valuepoint, /* Taylor coefficients (output) */
863    double ***taylors)  /* matrix of coifficient vectors */
864/* the order of the indices in argument and taylors is [var][taylor][deriv] */
865
866#endif
867#endif
868#endif
869#endif
870#endif
871#endif
872#endif
873#endif
874{
875    /****************************************************************************/
876    /*                                                            ALL VARIABLES */
877
878    unsigned char operation;   /* operation code */
879    int ret_c =3;              /* return value */
880
881    locint size = 0;
882    locint res  = 0;
883    locint arg  = 0;
884    locint arg1 = 0;
885    locint arg2 = 0;
886
887#if !defined(_NTIGHT_)
888    double coval = 0;
889    double *d=NULL;
890#endif
891
892    int indexi = 0,  indexd = 0;
893
894    /* loop indices */
895#if !defined (_ZOS_)
896#if !defined (_INT_FOR_)
897    int i;
898#if !defined (_INDO_)
899    int ii;
900#endif
901#endif
902#endif
903#if defined (_HIGHER_ORDER_)
904    int j, l=0;
905#endif
906    int ls;
907#if defined(_ADOLC_VECTOR_)
908#if !defined (_HIGHER_ORDER_)
909    int l=0;
910#endif
911#endif
912#if defined (_INT_FOR_)
913    int l=0;
914#endif
915#if defined (_INDO_)
916#if defined(_INDOPRO_)
917    int l=0;
918    int max_ind_dom;
919    /* index domains */
920    locint** ind_dom;
921#endif
922#if defined(_NONLIND_)
923    /* nonlinear interaction domains */
924    locint* arg_index;
925    IndexElement* fod;
926    IndexElement* nonl_dom;
927    IndexElement_sod* sod;
928    IndexElement_sod* temp;
929    IndexElement_sod* temp1;
930    int maxopind;
931    int opind;
932    int ii;
933#endif
934#if defined(_NONLIND_OLD_)
935    /* nonlinear interaction domains */
936    locint** nonl_dom;
937#endif
938#endif
939
940    /* other necessary variables */
941#if !defined (_ZOS_)
942#if !defined (_INDO_)
943#if !defined (_INT_FOR_)
944    double r0=0.0, x, y, divs;
945#if defined(_HIGHER_ORDER_)
946    int even;
947#endif
948#endif
949#endif
950#endif
951
952#if defined(_INT_FOR_)
953#ifdef _TIGHT_
954    double  *dp_T0;
955    double y;
956#endif /* _TIGHT_ */
957
958    /* Taylor stuff */
959    unsigned long int  **up_T;
960
961    unsigned long int         *Tres, *Targ, *Targ1, *Targ2;
962#ifdef _TIGHT_
963    unsigned long int         *Tqo;
964    unsigned long int         *Targ1OP, *Targ2OP;
965#endif
966
967#define T0res  T0temp
968#else
969#if defined(_INDO_)
970#ifdef _TIGHT_
971    double  *dp_T0;
972#endif /* _TIGHT_ */
973#define T0res  T0temp
974#define T0arg  T0temp
975
976#else
977    double *dp_T0;
978#if !defined(_ZOS_)
979#if  defined(_FOS_)
980    double  *dp_T;
981# define T_TEMP Ttemp;
982# else
983    double *dp_Ttemp, **dpp_T;
984#endif
985    double         *Tres, *Targ, *Targ1, *Targ2, *Tqo;
986
987#if defined (_HIGHER_ORDER_)
988    double         *TresOP, *TresOP2, *zOP;
989    double *dp_z;
990#endif
991   double         *TargOP, *Targ1OP, *Targ2OP;
992   double         T0temp;
993#endif
994#define T0res  T0temp
995#define T0arg  T0temp
996#endif
997#endif
998
999#if defined(_HIGHER_ORDER_)
1000    int k = gdegree;
1001#endif
1002
1003#if defined(_KEEP_)
1004    int taylbuf=0;
1005#endif
1006
1007#if defined(_HOV_)
1008    int pk = k*p;
1009#else
1010#if defined(_HOV_WK_)
1011    int pk = k*p;
1012#endif
1013#endif
1014
1015    locint switchnum = 0;
1016#if !defined(_NTIGHT_)
1017    double* signature = NULL;
1018#endif
1019
1020    /* extern diff. function variables */
1021#if defined(_EXTERN_)
1022#  undef (_EXTERN_)
1023#endif
1024    /* ZOS_FORWARD */
1025#if defined(_ZOS_)
1026#   define _EXTERN_ 1
1027#   define ADOLC_EXT_FCT_POINTER zos_forward
1028#   define ADOLC_EXT_FCT_IARR_POINTER zos_forward_iArr
1029#   define ADOLC_EXT_FCT_COMPLETE \
1030    zos_forward(n, edfct->dp_x, m, edfct->dp_y)
1031#   define ADOLC_EXT_FCT_IARR_COMPLETE \
1032    zos_forward_iArr(iArrLength, iArr, n, edfct->dp_x, m, edfct->dp_y)
1033#   define ADOLC_EXT_FCT_V2_COMPLETE \
1034    zos_forward(iArrLength, iArr, nin, nout, insz, edfct2->x, outsz, edfct2->y, edfct2->context)
1035#   define ADOLC_EXT_LOOP
1036#   define ADOLC_EXT_SUBSCRIPT
1037#   define ADOLC_EXT_SUBSCRIPT_START
1038#   define ADOLC_EXT_COPY_TAYLORS(dest,src)
1039#endif
1040    /* FOS_FORWARD */
1041#if defined(_FOS_)
1042#   define _EXTERN_ 1
1043#   define ADOLC_EXT_FCT_POINTER fos_forward
1044#   define ADOLC_EXT_FCT_IARR_POINTER fos_forward_iArr
1045#   define ADOLC_EXT_FCT_COMPLETE \
1046    fos_forward(n, edfct->dp_x, edfct->dp_X, m, edfct->dp_y, edfct->dp_Y)
1047#   define ADOLC_EXT_FCT_IARR_COMPLETE \
1048    fos_forward_iArr(iArrLength, iArr, n, edfct->dp_x, edfct->dp_X, m, edfct->dp_y, edfct->dp_Y)
1049#   define ADOLC_EXT_POINTER_X edfct->dp_X
1050#   define ADOLC_EXT_POINTER_Y edfct->dp_Y
1051#   define ADOLC_EXT_FCT_V2_COMPLETE \
1052    fos_forward(iArrLength, iArr, nin, nout, insz, edfct2->x, edfct2->xp, outsz, edfct2->y, edfct2->yp, edfct2->context)
1053#   define ADOLC_EXT_V2_POINTER_X edfct2->xp
1054#   define ADOLC_EXT_V2_POINTER_Y edfct2->yp
1055#   define ADOLC_EXT_LOOP
1056#   define ADOLC_EXT_SUBSCRIPT
1057#   define ADOLC_EXT_COPY_TAYLORS(dest,src) dest=src
1058#   define ADOLC_EXT_COPY_TAYLORS_BACK(dest,src) src=dest
1059#endif
1060    /* FOV_FORWARD */
1061#if defined(_FOV_)
1062#   define _EXTERN_ 1
1063#   define ADOLC_EXT_FCT_POINTER fov_forward
1064#   define ADOLC_EXT_FCT_IARR_POINTER fov_forward_iArr
1065#   define ADOLC_EXT_FCT_COMPLETE \
1066    fov_forward(n, edfct->dp_x,p, edfct->dpp_X, m, edfct->dp_y, edfct->dpp_Y)
1067#   define ADOLC_EXT_FCT_IARR_COMPLETE \
1068    fov_forward_iArr(iArrLength, iArr, n, edfct->dp_x,p, edfct->dpp_X, m, edfct->dp_y, edfct->dpp_Y)
1069#   define ADOLC_EXT_POINTER_X edfct->dpp_X
1070#   define ADOLC_EXT_POINTER_Y edfct->dpp_Y
1071#   define ADOLC_EXT_FCT_V2_COMPLETE \
1072    fov_forward(iArrLength, iArr, nin, nout, insz, edfct2->x, p, edfct2->Xp, outsz, edfct2->y, edfct2->Yp, edfct2->context)
1073#   define ADOLC_EXT_V2_POINTER_X edfct2->Xp
1074#   define ADOLC_EXT_V2_POINTER_Y edfct2->Yp
1075#   define ADOLC_EXT_LOOP for (loop2 = 0; loop2 < p; ++loop2)
1076#   define ADOLC_EXT_SUBSCRIPT [loop2]
1077#   define ADOLC_EXT_COPY_TAYLORS(dest,src) dest=src
1078#   define ADOLC_EXT_COPY_TAYLORS_BACK(dest,src)
1079#endif
1080
1081#if defined(_EXTERN_)
1082    locint n, m;
1083    ext_diff_fct *edfct;
1084    ext_diff_fct_v2 *edfct2;
1085    int loop,oloop;
1086    int iArrLength;
1087    int *iArr;
1088#   if defined(_FOV_)
1089        int loop2;
1090#   endif
1091    int ext_retc;
1092    int nin, nout;
1093    locint *insz, *outsz;
1094#endif
1095
1096#if defined(_ABS_NORM_)
1097    short sig;
1098#endif
1099
1100#ifdef ADOLC_AMPI_SUPPORT
1101    MPI_Op op;
1102    void *buf, *rbuf;
1103    int count, rcount;
1104    MPI_Datatype datatype, rtype;
1105    int src;
1106    int tag;
1107    enum AMPI_PairedWith_E pairedWith;
1108    MPI_Comm comm;
1109    MPI_Status status;
1110    struct AMPI_Request_S request;
1111#endif
1112    locint qq;
1113
1114    ADOLC_OPENMP_THREAD_NUMBER;
1115
1116#if defined(ADOLC_DEBUG)
1117    /****************************************************************************/
1118    /*                                                           DEBUG MESSAGES */
1119    fprintf(DIAG_OUT,"Call of %s(..) with tag: %d, n: %d, m %d,\n",
1120            GENERATED_FILENAME, tnum, indcheck, depcheck);
1121#if defined(_KEEP_)
1122    fprintf(DIAG_OUT,"                    keep: %d\n", keep);
1123#endif
1124#if defined(_HIGHER_ORDER_)
1125    fprintf(DIAG_OUT,"                    degree: %d\n",gdegree);
1126#endif
1127#if defined(_ADOLC_VECTOR_)
1128    fprintf(DIAG_OUT,"                    p: %d\n\n",p);
1129#endif
1130
1131#endif
1132
1133    /****************************************************************************/
1134    /*                                                                    INITs */
1135
1136   /* Set up stuff for the tape */
1137    ADOLC_OPENMP_GET_THREAD_NUMBER;
1138
1139    /* Initialize the Forward Sweep */
1140
1141    init_for_sweep(tnum);
1142
1143      if ( (depcheck != ADOLC_CURRENT_TAPE_INFOS.stats[NUM_DEPENDENTS]) ||
1144            (indcheck != ADOLC_CURRENT_TAPE_INFOS.stats[NUM_INDEPENDENTS]) ) {
1145        fprintf(DIAG_OUT,"ADOL-C error: forward sweep on tape %d  aborted!\n"
1146                "Number of dependent(%u) and/or independent(%u) variables passed"
1147                " to forward is\ninconsistent with number "
1148                "recorded on tape (%zu, %zu) \n", tnum,
1149                depcheck, indcheck,
1150                ADOLC_CURRENT_TAPE_INFOS.stats[NUM_DEPENDENTS],
1151                ADOLC_CURRENT_TAPE_INFOS.stats[NUM_INDEPENDENTS]);
1152        adolc_exit(-1,"",__func__,__FILE__,__LINE__);
1153    }
1154#if defined(_ABS_NORM_) || defined(_ABS_NORM_SIG_)
1155      if (! ADOLC_CURRENT_TAPE_INFOS.stats[NO_MIN_MAX] ) {
1156          fprintf(DIAG_OUT,"ADOL-C error: tape %d was not created compatible "
1157                  "with %s\n              Please call enableMinMaxUsingAbs() "
1158                  "before trace_on(%d)\n", tnum, __FUNCTION__, tnum);
1159          adolc_exit(-1,"",__func__,__FILE__,__LINE__);
1160      }
1161#if defined(_ABS_NORM_SIG_) || defined(_INDOPRO_)
1162      if (swcheck != ADOLC_CURRENT_TAPE_INFOS.stats[NUM_SWITCHES]) {
1163        fprintf(DIAG_OUT,"ADOL-C error: forward sweep on tape %d  aborted!\n"
1164                "Number of switches(%u) passed"
1165                " to forward is\ninconsistent with number "
1166                "recorded on tape (%zu) \n", tnum,
1167                swcheck,
1168                ADOLC_CURRENT_TAPE_INFOS.stats[NUM_SWITCHES]);
1169        adolc_exit(-1,"",__func__,__FILE__,__LINE__);
1170      }
1171#endif
1172#endif
1173    /****************************************************************************/
1174    /*                                                        MEMORY ALLOCATION */
1175    /* olvo 980626 has to be revised for common blocks */
1176
1177    /*--------------------------------------------------------------------------*/
1178#if !defined(_NTIGHT_)
1179    dp_T0 = myalloc1(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]);
1180    ADOLC_CURRENT_TAPE_INFOS.dp_T0 = dp_T0;
1181
1182    if(ADOLC_CURRENT_TAPE_INFOS.stats[NO_MIN_MAX]) {
1183        if (ADOLC_CURRENT_TAPE_INFOS.signature == NULL) {
1184            signature = myalloc1(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_SWITCHES]);
1185            ADOLC_CURRENT_TAPE_INFOS.signature = signature;
1186        } else
1187            signature = ADOLC_CURRENT_TAPE_INFOS.signature;
1188    }
1189
1190    ADOLC_CURRENT_TAPE_INFOS.dpp_T = &dp_T0;
1191    ADOLC_CURRENT_TAPE_INFOS.numTay = 0;
1192    ADOLC_CURRENT_TAPE_INFOS.gDegree = 0;
1193    ADOLC_CURRENT_TAPE_INFOS.workMode = ADOLC_ZOS_FORWARD;
1194#endif /* !_NTIGHT_ */
1195#if defined(_ZOS_)                                                   /* ZOS */
1196
1197#if defined(_KEEP_)
1198    if (keep>1) {
1199        fprintf(DIAG_OUT,"\n ADOL-C error: zero order scalar forward cannot save"
1200                " more\nthan zero order taylor coefficients!\n");
1201        adolc_exit(-1,"",__func__,__FILE__,__LINE__);
1202    }
1203#endif
1204#if defined(_KEEP_)
1205    if (keep) {
1206      taylbuf = ADOLC_CURRENT_TAPE_INFOS.stats[TAY_BUFFER_SIZE];
1207
1208        taylor_begin(taylbuf,keep-1);
1209    }
1210#endif
1211
1212    /*--------------------------------------------------------------------------*/
1213#else                                                                /* FOS */
1214#if defined(_FOS_)
1215#if defined(_KEEP_)
1216    if (keep>2) {
1217        fprintf(DIAG_OUT,"\n ADOL-C error: first order scalar forward cannot save"
1218                " more  \nthan first order taylor coefficients!\n");
1219        adolc_exit(-1,"",__func__,__FILE__,__LINE__);
1220    }
1221#endif
1222    dp_T = myalloc1(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]);
1223    ADOLC_CURRENT_TAPE_INFOS.dpp_T = &dp_T;
1224    ADOLC_CURRENT_TAPE_INFOS.numTay = 1;
1225    ADOLC_CURRENT_TAPE_INFOS.gDegree = 1;
1226    ADOLC_CURRENT_TAPE_INFOS.workMode = ADOLC_FOS_FORWARD;
1227# define TAYLOR_BUFFER dp_T
1228#if defined(_KEEP_)
1229    if (keep) {
1230        taylbuf = ADOLC_CURRENT_TAPE_INFOS.stats[TAY_BUFFER_SIZE];
1231        taylor_begin(taylbuf,keep-1);
1232    }
1233#endif
1234
1235    /*--------------------------------------------------------------------------*/
1236#else                                                                /* INF_FOR */
1237#if defined(_INT_FOR_)
1238        up_T     = myalloc2_ulong(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES],p);
1239#define TAYLOR_BUFFER up_T
1240
1241    /*--------------------------------------------------------------------------*/
1242#else                                                                /* INDOPRO */
1243#if defined(_INDO_)
1244#if defined(_INDOPRO_)
1245    /* index domains */
1246    ind_dom = (locint **)  malloc(sizeof(locint*) * ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]);
1247    max_ind_dom = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES];
1248
1249    for(i=0;i<max_ind_dom;i++)
1250    {
1251        ind_dom[i] = (locint *)  malloc(sizeof(locint) * (NUMNNZ+2));
1252        ind_dom[i][0] = 0;
1253        ind_dom[i][1] = NUMNNZ;
1254    }
1255#if defined(_ABS_NORM_)
1256    indexd = swcheck;
1257#endif
1258#endif
1259#if defined(_NONLIND_)
1260        maxopind=ADOLC_CURRENT_TAPE_INFOS.stats[NUM_OPERATIONS]+ADOLC_CURRENT_TAPE_INFOS.stats[NUM_EQ_PROD];
1261        fod = (struct IndexElement*) malloc(sizeof(struct IndexElement) * maxopind);
1262        nonl_dom = (struct IndexElement*) malloc(sizeof(struct IndexElement) * indcheck);
1263        arg_index = (locint *)  malloc(sizeof(locint) * (ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]));
1264        opind = 0;
1265        sod = (struct IndexElement_sod*) malloc(sizeof(struct IndexElement_sod) * indcheck);
1266
1267        for(i=0;i<indcheck;i++)
1268          {
1269            sod[i].entry = 0;
1270            sod[i].left = NULL;
1271            nonl_dom[i].entry = indcheck+2;
1272            nonl_dom[i].left = NULL;
1273            nonl_dom[i].right = NULL;
1274          }
1275#endif
1276#if defined(_NONLIND_OLD_)
1277
1278    nonl_dom = (locint**) malloc(sizeof(locint*) * indcheck);
1279    for(i=0;i<indcheck;i++){
1280          nonl_dom[i] = (locint*) malloc(sizeof(locint)*(NUMNNZ+2));
1281          nonl_dom[i][0]=0;
1282          nonl_dom[i][1]=NUMNNZ;
1283       }
1284#endif
1285
1286    /*--------------------------------------------------------------------------*/
1287#else                                                                /* FOV */
1288#if defined(_FOV_)
1289    dpp_T = myalloc2(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES],p);
1290    ADOLC_CURRENT_TAPE_INFOS.dpp_T = dpp_T;
1291    ADOLC_CURRENT_TAPE_INFOS.numTay = p;
1292    ADOLC_CURRENT_TAPE_INFOS.gDegree = 1;
1293    ADOLC_CURRENT_TAPE_INFOS.workMode = ADOLC_FOV_FORWARD;
1294# define TAYLOR_BUFFER dpp_T
1295    dp_Ttemp = myalloc1(p);
1296# define T_TEMP dp_Ttemp;
1297
1298    /*--------------------------------------------------------------------------*/
1299#else                                                                /* HOS */
1300#if defined(_HOS_)
1301    dpp_T = myalloc2(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES],k);
1302    ADOLC_CURRENT_TAPE_INFOS.dpp_T = dpp_T;
1303    ADOLC_CURRENT_TAPE_INFOS.numTay = 1;
1304    ADOLC_CURRENT_TAPE_INFOS.gDegree = k;
1305    ADOLC_CURRENT_TAPE_INFOS.workMode = ADOLC_HOS_FORWARD;
1306# define TAYLOR_BUFFER dpp_T
1307    dp_z  = myalloc1(k);
1308    dp_Ttemp = myalloc1(k);
1309# define T_TEMP dp_Ttemp;
1310#if defined(_KEEP_)
1311    if (keep) {
1312        taylbuf = ADOLC_CURRENT_TAPE_INFOS.stats[TAY_BUFFER_SIZE];
1313        taylor_begin(taylbuf,keep-1);
1314    }
1315#endif
1316
1317    /*--------------------------------------------------------------------------*/
1318#else                                                     /* HOV and HOV_WK */
1319    dpp_T = myalloc2(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES],p*k);
1320    ADOLC_CURRENT_TAPE_INFOS.dpp_T = dpp_T;
1321    ADOLC_CURRENT_TAPE_INFOS.numTay = p;
1322    ADOLC_CURRENT_TAPE_INFOS.gDegree = k;
1323    ADOLC_CURRENT_TAPE_INFOS.workMode = ADOLC_HOV_FORWARD;
1324# define TAYLOR_BUFFER dpp_T
1325    dp_z  = myalloc1(k);
1326    dp_Ttemp = myalloc1(p*k);
1327# define T_TEMP dp_Ttemp;
1328#if defined(_KEEP_)
1329    if (keep) {
1330        taylbuf = ADOLC_CURRENT_TAPE_INFOS.stats[TAY_BUFFER_SIZE];
1331        taylor_begin(taylbuf,keep-1);
1332    }
1333#endif
1334#endif
1335#endif
1336#endif
1337#endif
1338#endif
1339#endif
1340    /****************************************************************************/
1341    /*                                                            FORWARD SWEEP */
1342
1343#if defined(ADOLC_DEBUG)
1344/* #include <string.h> */
1345    int v = 0;
1346    unsigned int countPerOperation[256], taylorPerOperation[256];
1347    memset(countPerOperation, 0, 1024);
1348    memset(taylorPerOperation, 0, 1024);
1349#   define UPDATE_TAYLORWRITTEN(X) taylorPerOperation[operation] += X;
1350#else
1351#   define UPDATE_TAYLORWRITTEN(X)
1352#endif /* ADOLC_DEBUG */
1353
1354    operation=get_op_f();
1355#if defined(ADOLC_DEBUG)
1356    ++countPerOperation[operation];
1357#endif /* ADOLC_DEBUG */
1358
1359    while (operation !=end_of_tape) {
1360     
1361      switch (operation) {
1362
1363
1364                /****************************************************************************/
1365                /*                                                                  MARKERS */
1366
1367                /*--------------------------------------------------------------------------*/
1368            case end_of_op:                                          /* end_of_op */
1369                get_op_block_f();
1370                operation=get_op_f();
1371                /* Skip next operation, it's another end_of_op */
1372                break;
1373
1374                /*--------------------------------------------------------------------------*/
1375            case end_of_int:                                        /* end_of_int */
1376                get_loc_block_f();
1377                break;
1378
1379                /*--------------------------------------------------------------------------*/
1380            case end_of_val:                                        /* end_of_val */
1381               get_val_block_f();
1382                break;
1383                /*--------------------------------------------------------------------------*/
1384            case start_of_tape:                                  /* start_of_tape */
1385            case end_of_tape:                                      /* end_of_tape */
1386                break;
1387
1388
1389                /****************************************************************************/
1390                /*                                                               COMPARISON */
1391
1392                /*--------------------------------------------------------------------------*/
1393            case eq_zero:                                              /* eq_zero */
1394                arg = get_locint_f();
1395
1396#if !defined(_NTIGHT_)
1397                if (dp_T0[arg] != 0) {
1398                    if (ADOLC_GLOBAL_TAPE_VARS.branchSwitchWarning)
1399                        fprintf(DIAG_OUT,
1400                                "ADOL-C Warning: Branch switch detected in comparison "
1401                                "(operator eq_zero).\n"
1402                                "Forward sweep aborted! Retaping recommended!\n");
1403                    ret_c = -1;
1404                    operation = end_of_tape;
1405                    continue;
1406                }
1407                ret_c = 0;
1408#endif /* !_NTIGHT_ */
1409                break;
1410
1411                /*--------------------------------------------------------------------------*/
1412            case neq_zero:                                            /* neq_zero */
1413                arg = get_locint_f();
1414
1415#if !defined(_NTIGHT_)
1416                if (dp_T0[arg] == 0) {
1417                    if (ADOLC_GLOBAL_TAPE_VARS.branchSwitchWarning)
1418                        fprintf(DIAG_OUT,
1419                                "ADOL-C Warning: Branch switch detected in comparison "
1420                                "(operator neq_zero).\n"
1421                                "Forward sweep aborted! Retaping recommended!\n");
1422                    ret_c = -1;
1423                    operation = end_of_tape;
1424                    continue;
1425                }
1426#endif /* !_NTIGHT_ */
1427                break;
1428
1429                /*--------------------------------------------------------------------------*/
1430            case le_zero:                                              /* le_zero */
1431                arg = get_locint_f();
1432
1433#if !defined(_NTIGHT_)
1434                if (dp_T0[arg] > 0) {
1435                    if (ADOLC_GLOBAL_TAPE_VARS.branchSwitchWarning)
1436                        fprintf(DIAG_OUT,
1437                                "ADOL-C Warning: Branch switch detected in comparison "
1438                                "(operator le_zero).\n"
1439                                "Forward sweep aborted! Retaping recommended!\n");
1440                    ret_c = -1;
1441                    operation = end_of_tape;
1442                    continue;
1443                }
1444                if (dp_T0[arg] == 0)
1445                    ret_c = 0;
1446#endif /* !_NTIGHT_ */
1447                break;
1448
1449                /*--------------------------------------------------------------------------*/
1450            case gt_zero:                                              /* gt_zero */
1451                arg = get_locint_f();
1452
1453#if !defined(_NTIGHT_)
1454                if (dp_T0[arg] <= 0) {
1455                    if (ADOLC_GLOBAL_TAPE_VARS.branchSwitchWarning)
1456                        fprintf(DIAG_OUT,
1457                                "ADOL-C Warning: Branch switch detected in comparison "
1458                                "(operator gt_zero).\n"
1459                                "Forward sweep aborted! Retaping recommended!\n");
1460                    ret_c = -1;
1461                    operation = end_of_tape;
1462                    continue;
1463                }
1464#endif /* !_NTIGHT_ */
1465                break;
1466
1467                /*--------------------------------------------------------------------------*/
1468            case ge_zero:                                              /* ge_zero */
1469                arg = get_locint_f();
1470
1471#if !defined(_NTIGHT_)
1472                if (dp_T0[arg] < 0) {
1473                    if (ADOLC_GLOBAL_TAPE_VARS.branchSwitchWarning)
1474                        fprintf(DIAG_OUT,
1475                                "ADOL-C Warning: Branch switch detected in comparison "
1476                                "(operator ge_zero).\n"
1477                                "Forward sweep aborted! Retaping recommended!\n");
1478                    ret_c = -1;
1479                    operation = end_of_tape;
1480                    continue;
1481                }
1482                if (dp_T0[arg] == 0)
1483                    ret_c = 0;
1484#endif /* !_NTIGHT_ */
1485                break;
1486
1487                /*--------------------------------------------------------------------------*/
1488            case lt_zero:                                              /* lt_zero */
1489                arg = get_locint_f();
1490
1491#if !defined(_NTIGHT_)
1492                if (dp_T0[arg] >= 0) {
1493                    if (ADOLC_GLOBAL_TAPE_VARS.branchSwitchWarning)
1494                        fprintf(DIAG_OUT,
1495                                "ADOL-C Warning: Branch switch detected in comparison "
1496                                "(operator lt_zero).\n"
1497                                "Forward sweep aborted! Retaping recommended!\n");
1498                    ret_c = -1;
1499                    operation = end_of_tape;
1500                    continue;
1501                }
1502#endif /* !_NTIGHT_ */
1503                break;
1504
1505
1506                /****************************************************************************/
1507                /*                                                              ASSIGNMENTS */
1508
1509                /*--------------------------------------------------------------------------*/
1510            case assign_a:           /* assign an adouble variable an    assign_a */
1511                /* adouble value. (=) */
1512                arg = get_locint_f();
1513                res = get_locint_f();
1514
1515                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1516
1517
1518#if !defined(_NTIGHT_)
1519                dp_T0[res] = dp_T0[arg];
1520#endif /* !_NTIGHT_ */
1521
1522#if defined(_INDO_)
1523#if defined(_INDOPRO_)
1524                copy_index_domain(res, arg, ind_dom);
1525#endif
1526#if defined(_NONLIND_)
1527                arg_index[res] = arg_index[arg];               
1528#endif           
1529#else
1530#if !defined(_ZOS_) /* BREAK_ZOS */
1531                ASSIGN_T(Targ,TAYLOR_BUFFER[arg])
1532                ASSIGN_T(Tres,TAYLOR_BUFFER[res])
1533
1534                FOR_0_LE_l_LT_pk
1535                TRES_INC = TARG_INC;
1536#endif
1537#endif /* ALL_TOGETHER_AGAIN */
1538                break;
1539
1540                /*--------------------------------------------------------------------------*/
1541            case assign_d:            /* assign an adouble variable a    assign_d */
1542                /* double value. (=) */
1543                res   = get_locint_f();
1544#if !defined(_NTIGHT_)
1545                coval = 
1546#endif
1547                get_val_f();
1548
1549                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1550
1551#if !defined(_NTIGHT_)
1552                dp_T0[res] = coval;
1553#endif /* !_NTIGHT_ */
1554
1555#if defined(_INDO_)
1556#if defined(_INDOPRO_)
1557                ind_dom[res][0]=0;
1558#endif
1559#if defined(_NONLIND_)
1560                fod[opind].entry = maxopind+2;
1561                fod[opind].left = NULL;
1562                fod[opind].right = NULL;
1563                arg_index[res] = opind++;               
1564#endif
1565#else
1566#if !defined(_ZOS_) /* BREAK_ZOS */
1567                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
1568
1569                FOR_0_LE_l_LT_pk
1570                TRES_INC = 0;
1571#endif
1572#endif /* ALL_TOGETHER_AGAIN */
1573                break;
1574
1575                /*--------------------------------------------------------------------------*/
1576            case neg_sign_p:
1577            case recipr_p:
1578            case assign_p:            /* assign an adouble variable a    assign_d */
1579                /* double value. (=) */
1580                res   = get_locint_f();
1581                arg   = get_locint_f();
1582#if !defined(_NTIGHT_)
1583                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
1584#endif
1585
1586                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1587
1588#if !defined(_NTIGHT_)
1589                if (operation == recipr_p) 
1590                    coval = 1.0/coval;
1591                else if (operation == neg_sign_p)
1592                    coval = - coval;
1593                dp_T0[res] = coval;
1594#endif /* !_NTIGHT_ */
1595
1596#if defined(_INDO_)
1597#if defined(_INDOPRO_)
1598                ind_dom[res][0]=0;
1599#endif
1600#if defined(_NONLIND_)
1601                fod[opind].entry = maxopind+2;
1602                fod[opind].left = NULL;
1603                fod[opind].right = NULL;
1604                arg_index[res] = opind++;               
1605#endif
1606#else
1607#if !defined(_ZOS_) /* BREAK_ZOS */
1608                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
1609
1610                FOR_0_LE_l_LT_pk
1611                TRES_INC = 0;
1612#endif
1613#endif /* ALL_TOGETHER_AGAIN */
1614                break;
1615
1616                /*--------------------------------------------------------------------------*/
1617            case assign_d_zero:  /* assign an adouble variable a    assign_d_zero */
1618                /* double value. (0) (=) */
1619                res   = get_locint_f();
1620
1621                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1622
1623#if !defined(_NTIGHT_)
1624                dp_T0[res] = 0.0;
1625#endif /* !_NTIGHT_ */
1626
1627#if defined(_INDO_)
1628#if defined(_INDOPRO_)
1629                ind_dom[res][0]=0;
1630#endif
1631#if defined(_NONLIND_)
1632                fod[opind].entry = maxopind+2;
1633                fod[opind].left = NULL;
1634                fod[opind].right = NULL;
1635                arg_index[res] = opind++;               
1636#endif
1637#else
1638#if !defined(_ZOS_) /* BREAK_ZOS */
1639                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
1640
1641                FOR_0_LE_l_LT_pk
1642                TRES_INC = 0;
1643#endif
1644#endif /* ALL_TOGETHER_AGAIN */
1645                break;
1646
1647                /*--------------------------------------------------------------------------*/
1648            case assign_d_one:    /* assign an adouble variable a    assign_d_one */
1649                /* double value. (1) (=) */
1650                res   = get_locint_f();
1651
1652                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1653
1654#if !defined(_NTIGHT_)
1655                dp_T0[res] = 1.0;
1656#endif /* !_NTIGHT_ */
1657
1658#if defined(_INDO_)
1659#if defined(_INDOPRO_)
1660                ind_dom[res][0]=0;
1661#endif
1662#if defined(_NONLIND_)
1663                fod[opind].entry = maxopind+2;
1664                fod[opind].left = NULL;
1665                fod[opind].right = NULL;
1666                arg_index[res] = opind++;               
1667#endif
1668#else
1669#if !defined(_ZOS_) /* BREAK_ZOS */
1670                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
1671
1672                FOR_0_LE_l_LT_pk
1673                TRES_INC = 0;
1674
1675#endif
1676#endif /* ALL_TOGETHER_AGAIN */
1677                break;
1678
1679                /*--------------------------------------------------------------------------*/
1680            case assign_ind:       /* assign an adouble variable an    assign_ind */
1681                /* independent double value (<<=) */
1682                res = get_locint_f();
1683
1684                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1685
1686#if !defined(_NTIGHT_)
1687                dp_T0[res] = basepoint[indexi];
1688#endif /* !_NTIGHT_ */
1689
1690#if defined(_INDO_)
1691#if defined(_INDOPRO_)
1692                ind_dom[res][0] = 1;
1693                ind_dom[res][2] = indexi;
1694#endif         
1695#if defined(_NONLIND_)
1696                fod[opind].entry = indexi;
1697                fod[opind].left = NULL;
1698                fod[opind].right = NULL;
1699                arg_index[res] = opind++;               
1700#endif         
1701#else
1702#if !defined(_ZOS_) /* BREAK_ZOS */
1703                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
1704
1705#ifdef _INT_FOR_
1706                FOR_0_LE_l_LT_p
1707                TRES_INC = ARGUMENT(indexi,l,i);
1708#else
1709                FOR_0_LE_l_LT_p
1710                FOR_0_LE_i_LT_k
1711                TRES_INC = ARGUMENT(indexi,l,i);
1712#endif
1713#endif
1714#endif /* ALL_TOGETHER_AGAIN */
1715                ++indexi;
1716                break;
1717
1718                /*--------------------------------------------------------------------------*/
1719            case assign_dep:           /* assign a float variable a    assign_dep */
1720                /* dependent adouble value. (>>=) */
1721                res = get_locint_f();
1722
1723#if !defined(_INDO_)
1724#if !defined(_NTIGHT_)
1725                if ( valuepoint != NULL )
1726                  valuepoint[indexd] = dp_T0[res];
1727#endif /* !_NTIGHT_ */
1728#endif
1729
1730#if defined(_INDO_)
1731#if defined(_INDOPRO_) && !defined(_NONLIND_OLD_)
1732          if (ind_dom[res][0] != 0) {
1733            crs[indexd] = (unsigned int*) malloc(sizeof(unsigned int) * (ind_dom[res][0]+1));
1734            crs[indexd][0] = ind_dom[res][0];
1735            for(l=1;l<=crs[indexd][0];l++) {
1736              crs[indexd][l] = ind_dom[res][l+1];
1737            }
1738          }
1739          else {
1740            crs[indexd] = (unsigned int*) malloc(sizeof(unsigned int));
1741            crs[indexd][0] =0;
1742          }
1743#endif
1744#else
1745#if !defined(_ZOS_) /* BREAK_ZOS */
1746                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
1747
1748#ifdef _INT_FOR_
1749                if (taylors != 0 )  /* ??? question: why here? */
1750                    FOR_0_LE_l_LT_p
1751                    TAYLORS(indexd,l,i) = TRES_INC;
1752#else
1753                if (taylors != 0 )  /* ??? question: why here? */
1754                    FOR_0_LE_l_LT_p
1755                    FOR_0_LE_i_LT_k
1756                    TAYLORS(indexd,l,i) = TRES_INC;
1757#endif
1758#endif
1759#endif /* ALL_TOGETHER_AGAIN */
1760                indexd++;
1761                break;
1762
1763
1764                /****************************************************************************/
1765                /*                                                   OPERATION + ASSIGNMENT */
1766
1767                /*--------------------------------------------------------------------------*/
1768            case eq_plus_d:            /* Add a floating point to an    eq_plus_d */
1769                /* adouble. (+=) */
1770                res   = get_locint_f();
1771#if !defined(_NTIGHT_)
1772                coval = 
1773#endif
1774                get_val_f();
1775
1776                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1777
1778#if !defined(_NTIGHT_)
1779                dp_T0[res] += coval;
1780#endif /* !_NTIGHT_ */
1781                break;
1782
1783                /*--------------------------------------------------------------------------*/
1784            case eq_plus_p:            /* Add a floating point to an    eq_plus_p */
1785                /* adouble. (+=) */
1786                res   = get_locint_f();
1787                arg   = get_locint_f();
1788#if !defined(_NTIGHT_)
1789                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
1790#endif
1791                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1792
1793#if !defined(_NTIGHT_)
1794                dp_T0[res] += coval;
1795#endif /* !_NTIGHT_ */
1796                break;
1797
1798                /*--------------------------------------------------------------------------*/
1799            case eq_plus_a:             /* Add an adouble to another    eq_plus_a */
1800                /* adouble. (+=) */
1801                arg = get_locint_f();
1802                res = get_locint_f();
1803
1804                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1805
1806#if !defined(_NTIGHT_)
1807                dp_T0[res] += dp_T0[arg];
1808#endif /* !_NTIGHT_ */
1809
1810#if defined(_INDO_)
1811#if defined(_INDOPRO_)
1812                merge_2_index_domains(res, arg, ind_dom);
1813#endif
1814#if defined(_NONLIND_)
1815                fod[opind].entry = maxopind+2;
1816                fod[opind].left = &fod[arg_index[res]];
1817                fod[opind].right = &fod[arg_index[arg]];
1818                arg_index[res] = opind++;               
1819#endif
1820#else
1821#if !defined(_ZOS_) /* BREAK_ZOS */
1822                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
1823                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
1824
1825#ifdef _INT_FOR_
1826                FOR_0_LE_l_LT_pk
1827                TRES_INC |= TARG_INC;
1828#else
1829                FOR_0_LE_l_LT_pk
1830                TRES_INC += TARG_INC;
1831#endif
1832#endif
1833#endif /* ALL_TOGETHER_AGAIN */
1834                break;
1835
1836                /*--------------------------------------------------------------------------*/
1837            case eq_min_d:       /* Subtract a floating point from an    eq_min_d */
1838                /* adouble. (-=) */
1839                res = get_locint_f();
1840#if !defined(_NTIGHT_)
1841                coval = 
1842#endif
1843                get_val_f();
1844
1845                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1846
1847#if !defined(_NTIGHT_)
1848                dp_T0[res] -= coval;
1849#endif /* !_NTIGHT_ */
1850                break;
1851
1852                /*--------------------------------------------------------------------------*/
1853            case eq_min_p:       /* Subtract a floating point from an    eq_min_p */
1854                /* adouble. (-=) */
1855                res = get_locint_f();
1856                arg = get_locint_f();
1857#if !defined(_NTIGHT_)
1858                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
1859#endif
1860
1861                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1862
1863#if !defined(_NTIGHT_)
1864                dp_T0[res] -= coval;
1865#endif /* !_NTIGHT_ */
1866                break;
1867
1868                /*--------------------------------------------------------------------------*/
1869            case eq_min_a:        /* Subtract an adouble from another    eq_min_a */
1870                /* adouble. (-=) */
1871                arg = get_locint_f();
1872                res = get_locint_f();
1873
1874                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1875
1876#if !defined(_NTIGHT_)
1877                dp_T0[res] -= dp_T0[arg];
1878#endif /* !_NTIGHT_ */
1879
1880#if defined(_INDO_)
1881#if defined(_INDOPRO_)
1882                merge_2_index_domains(res, arg, ind_dom);
1883#endif
1884#if defined(_NONLIND_)
1885                fod[opind].entry = maxopind+2;
1886                fod[opind].left = &fod[arg_index[res]];
1887                fod[opind].right = &fod[arg_index[arg]];
1888                arg_index[res] = opind++;               
1889#endif
1890#else
1891#if !defined(_ZOS_) /* BREAK_ZOS */
1892                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
1893                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
1894
1895#ifdef _INT_FOR_
1896                FOR_0_LE_l_LT_pk
1897                TRES_INC |= TARG_INC;
1898#else
1899                FOR_0_LE_l_LT_pk
1900                TRES_INC -= TARG_INC;
1901#endif
1902#endif
1903#endif /* ALL_TOGETHER_AGAIN */
1904                break;
1905
1906                /*--------------------------------------------------------------------------*/
1907            case eq_mult_d:              /* Multiply an adouble by a    eq_mult_d */
1908                /* flaoting point. (*=) */
1909                res   = get_locint_f();
1910#if !defined(_NTIGHT_)
1911                coval = 
1912#endif
1913                get_val_f();
1914
1915                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1916
1917#if !defined(_NTIGHT_)
1918                dp_T0[res] *= coval;
1919#endif /* !_NTIGHT_ */
1920
1921#if !defined(_INDO_)
1922#if !defined(_ZOS_) /* BREAK_ZOS */
1923#if !defined( _INT_FOR_)
1924
1925                FOR_0_LE_l_LT_pk
1926                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
1927
1928                FOR_0_LE_l_LT_pk
1929                TRES_INC *= coval;
1930#endif
1931#endif
1932#endif /* ALL_TOGETHER_AGAIN */
1933                break;
1934
1935                /*--------------------------------------------------------------------------*/
1936            case eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
1937                /* flaoting point. (*=) */
1938                res   = get_locint_f();
1939                arg   = get_locint_f();
1940#if !defined(_NTIGHT_)
1941                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
1942#endif
1943
1944                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1945
1946#if !defined(_NTIGHT_)
1947                dp_T0[res] *= coval;
1948#endif /* !_NTIGHT_ */
1949
1950#if !defined(_INDO_)
1951#if !defined(_ZOS_) /* BREAK_ZOS */
1952#if !defined( _INT_FOR_)
1953
1954                FOR_0_LE_l_LT_pk
1955                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
1956
1957                FOR_0_LE_l_LT_pk
1958                TRES_INC *= coval;
1959#endif
1960#endif
1961#endif /* ALL_TOGETHER_AGAIN */
1962                break;
1963
1964                /*--------------------------------------------------------------------------*/
1965            case eq_mult_a:       /* Multiply one adouble by another    eq_mult_a */
1966                /* (*=) */
1967                arg = get_locint_f();
1968                res = get_locint_f();
1969
1970                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
1971
1972#if defined(_INDO_)
1973#if defined(_INDOPRO_)
1974                merge_2_index_domains(res, arg, ind_dom);
1975#endif
1976#if defined(_NONLIND_)
1977                fod[opind].entry = maxopind+2;
1978                fod[opind].left = &fod[arg_index[res]];
1979                fod[opind].right = &fod[arg_index[arg]];
1980                traverse_unary(&fod[arg_index[res]], nonl_dom, &fod[arg_index[arg]], indcheck+1,maxopind+2);
1981                traverse_unary(&fod[arg_index[arg]], nonl_dom, &fod[arg_index[res]], indcheck+1,maxopind+2);
1982                arg_index[res] = opind++;               
1983#endif
1984#if defined(_NONLIND_OLD_)
1985                extend_nonlinearity_domain_binary(res, arg, ind_dom, nonl_dom);
1986#endif
1987#else
1988#if !defined(_ZOS_) /* BREAK_ZOS */
1989                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
1990                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
1991
1992                INC_pk_1(Tres)
1993                INC_pk_1(Targ)
1994
1995#ifdef _INT_FOR_
1996                FOR_p_GT_l_GE_0
1997                TRES_FODEC |= TARG_DEC;
1998#else
1999                FOR_p_GT_l_GE_0
2000                FOR_k_GT_i_GE_0
2001                { TRES_FODEC = dp_T0[res]*TARG_DEC +
2002                               TRES*dp_T0[arg];
2003                  DEC_TRES_FO
2004#ifdef _HIGHER_ORDER_
2005                  TresOP = Tres-i;
2006                  TargOP = Targ;
2007
2008                  for (j=0;j<i;j++)
2009                  *Tres += (*TresOP++) * (*TargOP--);
2010                  Tres--;
2011#endif /* _HIGHER_ORDER_ */
2012                }
2013#endif
2014#endif
2015#endif /* ALL_TOGETHER_AGAIN */
2016#if !defined(_NTIGHT_)
2017               dp_T0[res] *= dp_T0[arg];
2018#endif /* !_NTIGHT_ */
2019                break;
2020
2021                /*--------------------------------------------------------------------------*/
2022            case incr_a:                        /* Increment an adouble    incr_a */
2023                res   = get_locint_f();
2024
2025                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2026
2027#if !defined(_NTIGHT_)
2028                dp_T0[res]++;
2029#endif /* !_NTIGHT_ */
2030                break;
2031
2032                /*--------------------------------------------------------------------------*/
2033            case decr_a:                        /* Increment an adouble    decr_a */
2034                res   = get_locint_f();
2035
2036                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2037
2038#if !defined(_NTIGHT_)
2039                dp_T0[res]--;
2040#endif /* !_NTIGHT_ */
2041                break;
2042
2043
2044                /****************************************************************************/
2045                /*                                                        BINARY OPERATIONS */
2046
2047                /*--------------------------------------------------------------------------*/
2048            case plus_a_a:                 /* : Add two adoubles. (+)    plus a_a */
2049                arg1 = get_locint_f();
2050                arg2 = get_locint_f();
2051                res  = get_locint_f();
2052
2053                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2054
2055                 
2056#if !defined(_NTIGHT_)
2057                dp_T0[res] = dp_T0[arg1] + dp_T0[arg2];
2058#endif /* !_NTIGHT_ */
2059
2060#if defined(_INDO_)
2061#if defined(_INDOPRO_)
2062                combine_2_index_domains(res, arg1, arg2, ind_dom);
2063#endif     
2064#if defined(_NONLIND_)
2065                fod[opind].entry = maxopind+2;
2066                fod[opind].left = &fod[arg_index[arg1]];
2067                fod[opind].right = &fod[arg_index[arg2]];
2068                arg_index[res] = opind++;               
2069#endif
2070#else
2071#if !defined(_ZOS_) /* BREAK_ZOS */
2072                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
2073                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
2074                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
2075
2076#ifdef _INT_FOR_
2077                FOR_0_LE_l_LT_pk
2078                TRES_INC = TARG1_INC | TARG2_INC;
2079#else
2080                FOR_0_LE_l_LT_pk
2081                TRES_INC = TARG1_INC + TARG2_INC;
2082#endif
2083#endif
2084#endif /* ALL_TOGETHER_AGAIN */
2085                break;
2086
2087                /*--------------------------------------------------------------------------*/
2088            case plus_d_a:             /* Add an adouble and a double    plus_d_a */
2089                /* (+) */
2090                arg   = get_locint_f();
2091                res   = get_locint_f();
2092#if !defined(_NTIGHT_)
2093                coval = 
2094#endif
2095                get_val_f();
2096
2097                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2098
2099#if !defined(_NTIGHT_)
2100                dp_T0[res] = dp_T0[arg] + coval;
2101#endif /* !_NTIGHT_ */
2102
2103#if defined(_INDO_)
2104#if defined(_INDOPRO_)
2105                copy_index_domain(res, arg, ind_dom);
2106#endif
2107#if defined(_NONLIND_)
2108                arg_index[res] = arg_index[arg];
2109#endif               
2110#else
2111#if !defined(_ZOS_) /* BREAK_ZOS */
2112                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
2113                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
2114
2115                FOR_0_LE_l_LT_pk
2116                TRES_INC = TARG_INC;
2117#endif
2118#endif /* ALL_TOGETHER_AGAIN */
2119                break;
2120
2121                /*--------------------------------------------------------------------------*/
2122            case plus_a_p:             /* Add an adouble and a double    plus_a_p */
2123            case min_a_p:                /* Subtract an adouble from a    min_a_p */
2124                /* (+) */
2125                arg   = get_locint_f();
2126                res   = get_locint_f();
2127                arg1  = get_locint_f();
2128#if !defined(_NTIGHT_)
2129                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
2130#endif
2131
2132                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2133
2134#if !defined(_NTIGHT_)
2135                if (operation == plus_a_p)
2136                    dp_T0[res] = dp_T0[arg] + coval;
2137                else if (operation == min_a_p)
2138                    dp_T0[res] = dp_T0[arg] - coval;
2139#endif /* !_NTIGHT_ */
2140
2141#if defined(_INDO_)
2142#if defined(_INDOPRO_)
2143                copy_index_domain(res, arg, ind_dom);
2144#endif
2145#if defined(_NONLIND_)
2146                arg_index[res] = arg_index[arg];
2147#endif               
2148#else
2149#if !defined(_ZOS_) /* BREAK_ZOS */
2150                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
2151                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
2152
2153                FOR_0_LE_l_LT_pk
2154                TRES_INC = TARG_INC;
2155#endif
2156#endif /* ALL_TOGETHER_AGAIN */
2157                break;
2158
2159                /*--------------------------------------------------------------------------*/
2160            case min_a_a:              /* Subtraction of two adoubles     min_a_a */
2161                /* (-) */
2162                arg1 = get_locint_f();
2163                arg2 = get_locint_f();
2164                res  = get_locint_f();
2165
2166                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2167
2168#if !defined(_NTIGHT_)
2169                dp_T0[res] = dp_T0[arg1] -
2170                                               dp_T0[arg2];
2171#endif /* !_NTIGHT_ */
2172
2173
2174#if defined(_INDO_)   
2175#if defined(_INDOPRO_)
2176                combine_2_index_domains(res, arg1, arg2, ind_dom);
2177#endif
2178#if defined(_NONLIND_)
2179                fod[opind].entry = maxopind+2;
2180                fod[opind].left = &fod[arg_index[arg1]];
2181                fod[opind].right = &fod[arg_index[arg2]];
2182                arg_index[res] = opind++;               
2183#endif
2184#else
2185#if !defined(_ZOS_) /* BREAK_ZOS */
2186                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
2187                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
2188                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
2189
2190#ifdef _INT_FOR_
2191                FOR_0_LE_l_LT_pk
2192                TRES_INC = TARG1_INC | TARG2_INC;
2193#else
2194                 FOR_0_LE_l_LT_pk
2195                TRES_INC = TARG1_INC - TARG2_INC;
2196#endif
2197#endif
2198#endif /* ALL_TOGETHER_AGAIN */
2199                break;
2200
2201                /*--------------------------------------------------------------------------*/
2202            case min_d_a:                /* Subtract an adouble from a    min_d_a */
2203                /* double (-) */
2204                arg =get_locint_f();
2205                res = get_locint_f();
2206#if !defined(_NTIGHT_)
2207                coval = 
2208#endif
2209                get_val_f();
2210
2211                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2212
2213#if !defined(_NTIGHT_)
2214                dp_T0[res] = coval - dp_T0[arg];
2215#endif /* !_NTIGHT_ */
2216
2217#if defined(_INDO_)
2218#if defined(_INDOPRO_)
2219                copy_index_domain(res, arg, ind_dom);
2220#endif
2221#if defined(_NONLIND_)
2222                arg_index[res] = arg_index[arg];               
2223#endif
2224#else
2225#if !defined(_ZOS_) /* BREAK_ZOS */
2226                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
2227                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
2228
2229#ifdef _INT_FOR_
2230                FOR_0_LE_l_LT_pk
2231                TRES_INC = TARG_INC;
2232#else
2233                FOR_0_LE_l_LT_pk
2234                TRES_INC = -TARG_INC;
2235#endif
2236#endif
2237#endif /* ALL_TOGETHER_AGAIN */
2238                break;
2239
2240                /*--------------------------------------------------------------------------*/
2241            case mult_a_a:               /* Multiply two adoubles (*)    mult_a_a */
2242                arg1 = get_locint_f();
2243                arg2 = get_locint_f();
2244                res  = get_locint_f();
2245
2246                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2247
2248#if defined(_INDO_)
2249#if defined(_INDOPRO_)
2250                combine_2_index_domains(res, arg1, arg2, ind_dom);
2251#endif
2252#if defined(_NONLIND_)
2253                fod[opind].entry = maxopind+2;
2254                fod[opind].left = &fod[arg_index[arg1]];
2255                fod[opind].right = &fod[arg_index[arg2]];
2256                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[arg_index[arg2]], indcheck+1,maxopind+2);
2257                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[arg_index[arg1]], indcheck+1,maxopind+2);
2258                arg_index[res] = opind++;               
2259#endif
2260#if defined(_NONLIND_OLD_)
2261                extend_nonlinearity_domain_binary(arg1, arg2, ind_dom, nonl_dom);
2262#endif
2263#else
2264#if !defined(_ZOS_) /* BREAK_ZOS */
2265                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
2266                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
2267                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
2268
2269#ifdef _INT_FOR_
2270                FOR_0_LE_l_LT_p
2271                TRES_FOINC = TARG2_INC | TARG1_INC;
2272#else
2273                /* olvo 980915 now in reverse order to allow x = x*x etc. */
2274                INC_pk_1(Tres)
2275                INC_pk_1(Targ1)
2276                INC_pk_1(Targ2)
2277
2278                FOR_p_GT_l_GE_0
2279                FOR_k_GT_i_GE_0
2280                { TRES_FODEC = dp_T0[arg1]*TARG2_DEC +
2281                               TARG1_DEC*dp_T0[arg2];
2282                  DEC_TRES_FO
2283#if defined(_HIGHER_ORDER_)
2284                  Targ1OP = Targ1-i+1;
2285                  Targ2OP = Targ2;
2286
2287                  for (j=0;j<i;j++) {
2288                  *Tres += (*Targ1OP++) * (*Targ2OP--);
2289                  }
2290                  Tres--;
2291#endif /* _HIGHER_ORDER_ */
2292            }
2293#endif
2294#endif
2295#endif /* ALL_TOGETHER_AGAIN */
2296#if !defined(_NTIGHT_)
2297                dp_T0[res] = dp_T0[arg1] *
2298                                               dp_T0[arg2];
2299#endif /* !_NTIGHT_ */
2300                break;
2301
2302                /*--------------------------------------------------------------------------*/
2303                /* olvo 991122: new op_code with recomputation */
2304            case eq_plus_prod:   /* increment a product of           eq_plus_prod */
2305                /* two adoubles (*) */
2306                arg1 = get_locint_f();
2307                arg2 = get_locint_f();
2308                res  = get_locint_f();
2309
2310#if defined(_INDO_)
2311#if defined(_INDOPRO_)
2312                merge_3_index_domains(res, arg1, arg2, ind_dom);
2313#endif
2314#if defined(_NONLIND_)
2315                // operation: v = v+u*w
2316                // first step: z = u*w, index domains
2317                fod[opind].entry = maxopind+2;
2318                fod[opind].left = &fod[arg_index[arg1]];
2319                fod[opind].right = &fod[arg_index[arg2]];
2320                // first step: z = u*w,
2321                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[arg_index[arg2]], indcheck+1,maxopind+2);
2322                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[arg_index[arg1]], indcheck+1,maxopind+2);
2323                opind++;
2324                // second step: v = v+z, index domains
2325                fod[opind].entry = maxopind+2;
2326                fod[opind].left = &fod[arg_index[res]];
2327                fod[opind].right = &fod[opind-1];
2328                // second step: v = v+z,
2329                arg_index[res] = opind++;               
2330#endif
2331#if defined(_NONLIND_OLD_)
2332                extend_nonlinearity_domain_binary(arg1, arg2, ind_dom, nonl_dom);
2333#endif
2334#else
2335#if !defined(_ZOS_) /* BREAK_ZOS */
2336                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
2337                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
2338                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
2339
2340#ifdef _INT_FOR_
2341                FOR_0_LE_l_LT_p
2342                TRES_FOINC |= TARG2_INC | TARG1_INC;
2343#else
2344                /* olvo 980915 now in reverse order to allow x = x*x etc. */
2345                INC_pk_1(Tres)
2346                INC_pk_1(Targ1)
2347                INC_pk_1(Targ2)
2348
2349                FOR_p_GT_l_GE_0
2350                FOR_k_GT_i_GE_0
2351                { TRES_FODEC += dp_T0[arg1]*TARG2_DEC +
2352                                TARG1_DEC*dp_T0[arg2];
2353                  DEC_TRES_FO
2354#if defined(_HIGHER_ORDER_)
2355                  Targ1OP = Targ1-i+1;
2356                  Targ2OP = Targ2;
2357
2358                  for (j=0;j<i;j++)
2359                  *Tres += (*Targ1OP++) * (*Targ2OP--);
2360                  Tres--;
2361#endif /* _HIGHER_ORDER_ */
2362                }
2363#endif
2364#endif
2365#endif /* ALL_TOGETHER_AGAIN */
2366#if !defined(_NTIGHT_)
2367                dp_T0[res] += dp_T0[arg1] *
2368                                                    dp_T0[arg2];
2369#endif /* !_NTIGHT_ */
2370                break;
2371
2372                /*--------------------------------------------------------------------------*/
2373                /* olvo 991122: new op_code with recomputation */
2374            case eq_min_prod:    /* decrement a product of            eq_min_prod */
2375                /* two adoubles (*) */
2376                arg1 = get_locint_f();
2377                arg2 = get_locint_f();
2378                res  = get_locint_f();
2379
2380#if defined(_INDO_)
2381#if defined(_INDOPRO_)
2382                merge_3_index_domains(res, arg1, arg2, ind_dom);
2383#endif
2384#if defined(_NONLIND_)
2385                // operation: v = v-u*w
2386                // first step: z = u*w, index domains
2387                fod[opind].entry = maxopind+2;
2388                fod[opind].left = &fod[arg_index[arg1]];
2389                fod[opind].right = &fod[arg_index[arg2]];
2390                // first step: z = u*w,
2391                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
2392                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
2393                opind++;
2394                // second step: v = v-z, index domains
2395                fod[opind].entry = maxopind+2;
2396                fod[opind].left = &fod[arg_index[res]];
2397                fod[opind].right = &fod[opind-1];
2398                // second step: v = v-z,
2399                arg_index[res] = opind++;       
2400#endif
2401#if defined(_NONLIND_OLD_)
2402                extend_nonlinearity_domain_binary(arg1, arg2, ind_dom, nonl_dom);
2403#endif
2404#else
2405#if !defined(_ZOS_) /* BREAK_ZOS */
2406                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
2407                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
2408                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
2409
2410#ifdef _INT_FOR_
2411                FOR_0_LE_l_LT_p
2412                TRES_FOINC |= TARG2_INC | TARG1_INC;
2413#else
2414                /* olvo 980915 now in reverse order to allow x = x*x etc. */
2415                INC_pk_1(Tres)
2416                INC_pk_1(Targ1)
2417                INC_pk_1(Targ2)
2418
2419                FOR_p_GT_l_GE_0
2420                FOR_k_GT_i_GE_0
2421                { TRES_FODEC -= dp_T0[arg1]*TARG2_DEC +
2422                                TARG1_DEC*dp_T0[arg2];
2423                  DEC_TRES_FO
2424#if defined(_HIGHER_ORDER_)
2425                  Targ1OP = Targ1-i+1;
2426                  Targ2OP = Targ2;
2427
2428                  for (j=0;j<i;j++)
2429                  *Tres -= (*Targ1OP++) * (*Targ2OP--);
2430                  Tres--;
2431#endif /* _HIGHER_ORDER_ */
2432                }
2433#endif
2434#endif
2435#endif /* ALL_TOGETHER_AGAIN */
2436
2437#if !defined(_NTIGHT_)
2438                dp_T0[res] -= dp_T0[arg1] *
2439                                                    dp_T0[arg2];
2440#endif /* !_NTIGHT_ */
2441                break;
2442
2443                /*--------------------------------------------------------------------------*/
2444            case mult_d_a:         /* Multiply an adouble by a double    mult_d_a */
2445                /* (*) */
2446                arg   = get_locint_f();
2447                res   = get_locint_f();
2448#if !defined(_NTIGHT_)
2449                coval = 
2450#endif
2451                get_val_f();
2452
2453                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2454
2455#if !defined(_NTIGHT_)
2456                dp_T0[res] = dp_T0[arg] * coval;
2457#endif /* !_NTIGHT_ */
2458
2459#if defined(_INDO_)
2460#if defined(_INDOPRO_)
2461                copy_index_domain(res, arg, ind_dom);
2462#endif
2463#if defined(_NONLIND_)
2464                arg_index[res] = arg_index[arg];               
2465#endif
2466#else
2467#if !defined(_ZOS_) /* BREAK_ZOS */
2468                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
2469                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
2470
2471#ifdef _INT_FOR_
2472                FOR_0_LE_l_LT_pk
2473                TRES_INC = TARG_INC;
2474#else
2475                FOR_0_LE_l_LT_pk
2476                TRES_INC = TARG_INC * coval;
2477#endif
2478#endif
2479#endif /* ALL_TOGETHER_AGAIN */
2480                break;
2481
2482                /*--------------------------------------------------------------------------*/
2483            case mult_a_p:         /* Multiply an adouble by a double    mult_a_p */
2484                /* (*) */
2485                arg   = get_locint_f();
2486                res   = get_locint_f();
2487                arg1  = get_locint_f();
2488#if !defined(_NTIGHT_)
2489                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
2490#endif
2491
2492                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2493
2494#if !defined(_NTIGHT_)
2495                dp_T0[res] = dp_T0[arg] * coval;
2496#endif /* !_NTIGHT_ */
2497
2498#if defined(_INDO_)
2499#if defined(_INDOPRO_)
2500                copy_index_domain(res, arg, ind_dom);
2501#endif
2502#if defined(_NONLIND_)
2503                arg_index[res] = arg_index[arg];               
2504#endif
2505#else
2506#if !defined(_ZOS_) /* BREAK_ZOS */
2507                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
2508                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
2509
2510#ifdef _INT_FOR_
2511                FOR_0_LE_l_LT_pk
2512                TRES_INC = TARG_INC;
2513#else
2514                FOR_0_LE_l_LT_pk
2515                TRES_INC = TARG_INC * coval;
2516#endif
2517#endif
2518#endif /* ALL_TOGETHER_AGAIN */
2519                break;
2520
2521                /*--------------------------------------------------------------------------*/
2522            case div_a_a:           /* Divide an adouble by an adouble    div_a_a */
2523                /* (/) */
2524                arg1 = get_locint_f();
2525                arg2 = get_locint_f();
2526                res  = get_locint_f();
2527
2528                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2529
2530#if !defined(_NTIGHT_)
2531#if !defined(_ZOS_) && !defined(_INT_FOR_) && !defined(_INDO_)
2532                divs = 1.0 / dp_T0[arg2];
2533#endif /* ALL_TOGETHER_AGAIN */
2534
2535                dp_T0[res] = dp_T0[arg1] /
2536                                               dp_T0[arg2];
2537#endif /* !_NTIGHT_ */
2538
2539#if defined(_INDO_)
2540#if defined(_INDOPRO_)
2541                combine_2_index_domains(res, arg1, arg2, ind_dom);
2542#endif
2543#if defined(_NONLIND_)
2544                fod[opind].entry = maxopind+2;
2545                fod[opind].left = &fod[arg_index[arg1]];
2546                fod[opind].right = &fod[arg_index[arg2]];
2547                traverse_unary(&fod[arg_index[arg1]], nonl_dom, &fod[arg_index[arg2]], indcheck+1,maxopind+2);
2548                traverse_unary(&fod[arg_index[arg2]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
2549                arg_index[res] = opind++;               
2550#endif
2551#if defined(_NONLIND_OLD_)
2552                extend_nonlinearity_domain_binary(arg1, arg2, ind_dom, nonl_dom);
2553                extend_nonlinearity_domain_unary(arg2, ind_dom, nonl_dom);
2554#endif
2555#else
2556#if !defined(_ZOS_) /* BREAK_ZOS */
2557                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
2558                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
2559                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
2560
2561#ifdef _INT_FOR_
2562                FOR_0_LE_l_LT_p
2563                TRES_FOINC = TARG1_INC | TARG2_FOINC;
2564#else
2565                FOR_0_LE_l_LT_p
2566                FOR_0_LE_i_LT_k
2567                { /* olvo 980922 changed order to allow x = y/x */
2568#if defined(_HIGHER_ORDER_)
2569                    zOP      = dp_z+i;
2570                    (*zOP--) = -(*Targ2) * divs;
2571#endif /* _HIGHER_ORDER_ */
2572
2573                    TRES_FOINC = TARG1_INC * divs + dp_T0[res] *
2574                                 (-TARG2_INC * divs);
2575
2576#if defined(_HIGHER_ORDER_)
2577                    TresOP = Tres-i;
2578
2579                    for (j=0;j<i;j++)
2580                    *Tres += (*TresOP++) * (*zOP--);
2581                    Tres++;
2582#endif /* _HIGHER_ORDER_ */
2583                }
2584#endif
2585#endif
2586#endif /* ALL_TOGETHER_AGAIN */
2587                break;
2588
2589            /*--------------------------------------------------------------------------*/
2590        case div_d_a:             /* Division double - adouble (/)    div_d_a */
2591            arg   = get_locint_f();
2592                res   = get_locint_f();
2593#if !defined(_NTIGHT_)
2594                coval = 
2595#endif
2596                get_val_f();
2597
2598                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2599
2600                /* olvo 980922 necessary for reverse
2601                   kk 20140508 I don't think so
2602                if (arg == res) {
2603                    IF_KEEP_WRITE_TAYLOR(arg,keep,k,p)
2604                } */
2605
2606#if !defined(_NTIGHT_)
2607#if !defined(_ZOS_) && !defined(_INT_FOR_) && !defined(_INDO_)
2608                divs = 1.0 / dp_T0[arg];
2609#endif /* ALL_TOGETHER_AGAIN */
2610
2611                dp_T0[res] = coval / dp_T0[arg];
2612#endif /* !_NTIGHT_ */
2613
2614#if defined(_INDO_)
2615#if defined(_INDOPRO_)
2616                copy_index_domain(res, arg, ind_dom);
2617#endif
2618#if defined(_NONLIND_)
2619                fod[opind].entry = maxopind+2;
2620                fod[opind].left = &fod[arg_index[arg]];
2621                fod[opind].right = NULL;
2622                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
2623                arg_index[res] = opind++;               
2624#endif
2625#if defined(_NONLIND_OLD_)
2626                extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
2627#endif
2628#else
2629#if !defined(_ZOS_) /* BREAK_ZOS */
2630                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
2631                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
2632
2633#ifdef _INT_FOR_
2634                FOR_0_LE_l_LT_p
2635                TRES_FOINC = TARG_FOINC;
2636#else
2637                FOR_0_LE_l_LT_p
2638                FOR_0_LE_i_LT_k
2639                { /* olvo 980922 changed order to allow x = d/x */
2640#if defined(_HIGHER_ORDER_)
2641                    zOP      = dp_z+i;
2642                    (*zOP--) = -(*Targ) * divs;
2643#endif /* _HIGHER_ORDER_ */
2644
2645                    TRES_FOINC = dp_T0[res] * (-TARG_INC * divs);
2646
2647#if defined(_HIGHER_ORDER_)
2648                    TresOP = Tres-i;
2649
2650                    for (j=0;j<i;j++)
2651                    *Tres += (*TresOP++) * (*zOP--);
2652                    Tres++;
2653#endif /* _HIGHER_ORDER_ */
2654                }
2655#endif
2656#endif
2657#endif /* ALL_TOGETHER_AGAIN */
2658                break;
2659
2660
2661            /****************************************************************************/
2662            /*--------------------------------------------------------------------------*/
2663        case div_p_a:             /* Division double - adouble (/)    div_p_a */
2664                arg   = get_locint_f();
2665                res   = get_locint_f();
2666                arg1  = get_locint_f();
2667#if !defined(_NTIGHT_)
2668                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
2669#endif
2670
2671                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2672
2673                /* olvo 980922 necessary for reverse
2674                   kk 20140508 I don't think so
2675                if (arg == res) {
2676                    IF_KEEP_WRITE_TAYLOR(arg,keep,k,p)
2677                } */
2678
2679#if !defined(_NTIGHT_)
2680#if !defined(_ZOS_) && !defined(_INT_FOR_) && !defined(_INDO_)
2681                divs = 1.0 / dp_T0[arg];
2682#endif /* ALL_TOGETHER_AGAIN */
2683
2684                dp_T0[res] = coval / dp_T0[arg];
2685#endif /* !_NTIGHT_ */
2686
2687#if defined(_INDO_)
2688#if defined(_INDOPRO_)
2689                copy_index_domain(res, arg, ind_dom);
2690#endif
2691#if defined(_NONLIND_)
2692                fod[opind].entry = maxopind+2;
2693                fod[opind].left = &fod[arg_index[arg]];
2694                fod[opind].right = NULL;
2695                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
2696                arg_index[res] = opind++;               
2697#endif
2698#if defined(_NONLIND_OLD_)
2699                extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
2700#endif
2701#else
2702#if !defined(_ZOS_) /* BREAK_ZOS */
2703                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
2704                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
2705
2706#ifdef _INT_FOR_
2707                FOR_0_LE_l_LT_p
2708                TRES_FOINC = TARG_FOINC;
2709#else
2710                FOR_0_LE_l_LT_p
2711                FOR_0_LE_i_LT_k
2712                { /* olvo 980922 changed order to allow x = d/x */
2713#if defined(_HIGHER_ORDER_)
2714                    zOP      = dp_z+i;
2715                    (*zOP--) = -(*Targ) * divs;
2716#endif /* _HIGHER_ORDER_ */
2717
2718                    TRES_FOINC = dp_T0[res] * (-TARG_INC * divs);
2719
2720#if defined(_HIGHER_ORDER_)
2721                    TresOP = Tres-i;
2722
2723                    for (j=0;j<i;j++)
2724                    *Tres += (*TresOP++) * (*zOP--);
2725                    Tres++;
2726#endif /* _HIGHER_ORDER_ */
2727                }
2728#endif
2729#endif
2730#endif /* ALL_TOGETHER_AGAIN */
2731                break;
2732
2733
2734            /****************************************************************************/
2735            /*                                                         SIGN  OPERATIONS */
2736
2737            /*--------------------------------------------------------------------------*/
2738        case pos_sign_a:                                        /* pos_sign_a */
2739            arg   = get_locint_f();
2740                res   = get_locint_f();
2741
2742                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2743
2744#if !defined(_NTIGHT_)
2745                dp_T0[res] = dp_T0[arg];
2746#endif /* !_NTIGHT_ */
2747
2748#if defined(_INDO_)
2749#if defined(_INDOPRO_)
2750                copy_index_domain(res, arg, ind_dom);
2751#endif
2752#if defined(_NONLIND_)
2753                arg_index[res] = arg_index[arg];                           
2754#endif 
2755#else
2756#if !defined(_ZOS_) /* BREAK_ZOS */
2757                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
2758                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
2759
2760                FOR_0_LE_l_LT_pk
2761                TRES_INC = TARG_INC;
2762#endif
2763#endif /* ALL_TOGETHER_AGAIN */
2764                break;
2765
2766                /*--------------------------------------------------------------------------*/
2767            case neg_sign_a:                                        /* neg_sign_a */
2768                arg   = get_locint_f();
2769                res   = get_locint_f();
2770
2771                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2772
2773#if !defined(_NTIGHT_)
2774                dp_T0[res] = -dp_T0[arg];
2775#endif /* !_NTIGHT_ */
2776
2777#if defined(_INDO_)
2778#if defined(_INDOPRO_)
2779                copy_index_domain(res, arg, ind_dom);
2780#endif
2781#if defined(_NONLIND_)
2782                arg_index[res] = arg_index[arg];                           
2783#endif
2784#else
2785#if !defined(_ZOS_) /* BREAK_ZOS */
2786                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
2787                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
2788
2789#ifdef _INT_FOR_
2790                FOR_0_LE_l_LT_pk
2791                TRES_INC = TARG_INC;
2792#else
2793                FOR_0_LE_l_LT_pk
2794                TRES_INC = -TARG_INC;
2795#endif
2796#endif
2797#endif /* ALL_TOGETHER_AGAIN */
2798                break;
2799
2800
2801                /****************************************************************************/
2802                /*                                                         UNARY OPERATIONS */
2803
2804                /*--------------------------------------------------------------------------*/
2805            case exp_op:                          /* exponent operation    exp_op */
2806                arg = get_locint_f();
2807                res = get_locint_f();
2808
2809                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2810
2811#if !defined(_NTIGHT_)
2812                dp_T0[res] = exp(dp_T0[arg]);
2813#endif /* !_NTIGHT_ */
2814
2815                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2816
2817#if defined(_INDO_)
2818#if defined(_INDOPRO_)
2819                copy_index_domain(res, arg, ind_dom);
2820#endif
2821#if defined(_NONLIND_)
2822                fod[opind].entry = maxopind+2;
2823                fod[opind].left = &fod[arg_index[arg]];
2824                fod[opind].right = NULL;
2825                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
2826                arg_index[res] = opind++;               
2827#endif
2828#if defined(_NONLIND_OLD_)
2829                extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
2830#endif
2831#else
2832#if !defined(_ZOS_) /* BREAK_ZOS */
2833                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
2834                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
2835
2836#ifdef _INT_FOR_
2837                FOR_0_LE_l_LT_p
2838                TRES_FOINC = TARG_FOINC;
2839#else
2840                FOR_0_LE_l_LT_p
2841                FOR_0_LE_i_LT_k
2842                { /* olvo 980915 changed order to allow x = exp(x) */
2843#if defined(_HIGHER_ORDER_)
2844                    zOP      = dp_z+i;
2845                    (*zOP--) = (i+1) * (*Targ);
2846#endif /* _HIGHER_ORDER_ */
2847
2848                    TRES_FOINC = dp_T0[res] * TARG_INC;
2849
2850#if defined(_HIGHER_ORDER_)
2851                    TresOP = Tres-i;
2852
2853                    *Tres *= (i+1);
2854                    for (j=0;j<i;j++)
2855                    *Tres += (*TresOP++) * (*zOP--);
2856                    *Tres++ /= (i+1); /* important only for i>0 */
2857#endif /* _HIGHER_ORDER_ */
2858                }
2859
2860#endif
2861#endif
2862#endif /* ALL_TOGETHER_AGAIN */
2863                break;
2864
2865            /*--------------------------------------------------------------------------*/
2866        case sin_op:                              /* sine operation    sin_op */
2867                arg1 = get_locint_f();
2868                arg2 = get_locint_f();
2869                res  = get_locint_f();
2870
2871                IF_KEEP_WRITE_TAYLOR(arg2,keep,k,p) /* olvo 980710 covalue */
2872                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2873
2874#if !defined(_NTIGHT_)
2875                /* Note: always arg2 != arg1 */
2876                dp_T0[arg2] = cos(dp_T0[arg1]);
2877                dp_T0[res]  = sin(dp_T0[arg1]);
2878#endif /* !_NTIGHT_ */
2879
2880                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2881
2882#if defined(_INDO_)
2883#if defined(_INDOPRO_)
2884                copy_index_domain(res, arg1, ind_dom);
2885#endif
2886#if defined(_NONLIND_)
2887                fod[opind].entry = maxopind+2;
2888                fod[opind].left = &fod[arg_index[arg1]];
2889                fod[opind].right = NULL;
2890                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
2891                arg_index[res] = opind++;               
2892#endif
2893#if defined(_NONLIND_OLD_)
2894                extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
2895#endif
2896#else
2897#if !defined(_ZOS_) /* BREAK_ZOS */
2898                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
2899                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
2900                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
2901
2902#ifdef _INT_FOR_
2903                FOR_0_LE_l_LT_p
2904                { /* olvo 980923 changed order to allow x = sin(x) */
2905                    TARG2_FOINC =  TARG1;
2906                    TRES_FOINC  =  TARG1_FOINC;
2907            }
2908#else
2909                FOR_0_LE_l_LT_p
2910                FOR_0_LE_i_LT_k
2911                { /* olvo 980921 changed order to allow x = sin(x) */
2912#if defined(_HIGHER_ORDER_)
2913                    zOP      = dp_z+i;
2914                    (*zOP--) = (i+1) * (*Targ1);
2915#endif /* _HIGHER_ORDER_ */
2916
2917                    /* Note: always arg2 != arg1 */
2918                    TARG2_FOINC = -dp_T0[res]  * TARG1;
2919                    TRES_FOINC  =  dp_T0[arg2] * TARG1_INC;
2920
2921#if defined(_HIGHER_ORDER_)
2922                    TresOP  = Tres-i;
2923                    Targ2OP = Targ2-i;
2924
2925                    *Tres  *= (i+1);
2926                    *Targ2 *= (i+1);
2927                    for (j=0;j<i;j++) {
2928                    *Tres  += (*Targ2OP++) * (*zOP);
2929                        *Targ2 -= (*TresOP++)  * (*zOP--);
2930                    }
2931                    *Targ2++ /= (i+1);
2932                    *Tres++  /= (i+1);
2933#endif /* _HIGHER_ORDER_ */
2934            }
2935#endif
2936#endif
2937#endif /* ALL_TOGETHER_AGAIN */
2938                break;
2939
2940                /*--------------------------------------------------------------------------*/
2941            case cos_op:                            /* cosine operation    cos_op */
2942                arg1 = get_locint_f();
2943                arg2 = get_locint_f();
2944                res  = get_locint_f();
2945
2946                IF_KEEP_WRITE_TAYLOR(arg2,keep,k,p) /* olvo 980710 covalue */
2947                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
2948
2949#if !defined(_NTIGHT_)
2950                /* Note: always arg2 != arg1 */
2951                dp_T0[arg2] = sin(dp_T0[arg1]);
2952                dp_T0[res]  = cos(dp_T0[arg1]);
2953#endif /* !_NTIGHT_ */
2954
2955                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2956
2957#if defined(_INDO_)
2958#if defined(_INDOPRO_)
2959                copy_index_domain(res, arg1, ind_dom);
2960#endif
2961#if defined(_NONLIND_)
2962                fod[opind].entry = maxopind+2;
2963                fod[opind].left = &fod[arg_index[arg1]];
2964                fod[opind].right = NULL;
2965                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
2966                arg_index[res] = opind++;               
2967#endif
2968#if defined(_NONLIND_OLD_)
2969                extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
2970#endif
2971
2972#else
2973#if !defined(_ZOS_) /* BREAK_ZOS */
2974                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
2975                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
2976                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
2977
2978#ifdef _INT_FOR_
2979                FOR_0_LE_l_LT_p
2980                { /* olvo 980923 changed order to allow x = cos(x) */
2981                    TARG2_FOINC = TARG1;
2982                    TRES_FOINC  = TARG1_FOINC;
2983            }
2984#else
2985                FOR_0_LE_l_LT_p
2986                FOR_0_LE_i_LT_k
2987                { /* olvo 980921 changed order to allow x = cos(x) */
2988#if defined(_HIGHER_ORDER_)
2989                    zOP      = dp_z+i;
2990                    (*zOP--) = (i+1) * (*Targ1);
2991#endif /* _HIGHER_ORDER_ */
2992
2993                    /* Note: always arg2 != arg1 */
2994                    TARG2_FOINC =  dp_T0[res]  * TARG1;
2995                    TRES_FOINC  = -dp_T0[arg2] * TARG1_INC;
2996
2997#if defined(_HIGHER_ORDER_)
2998                    TresOP  = Tres-i;
2999                    Targ2OP = Targ2-i;
3000
3001                    *Tres  *= (i+1);
3002                    *Targ2 *= (i+1);
3003                    for (j=0;j<i;j++) {
3004                    *Tres  -= (*Targ2OP++) * (*zOP);
3005                        *Targ2 += (*TresOP++)  * (*zOP--);
3006                    }
3007                    *Targ2++ /= (i+1);
3008                    *Tres++  /= (i+1);
3009#endif /* _HIGHER_ORDER_ */
3010            }
3011#endif
3012#endif
3013#endif /* ALL_TOGETHER_AGAIN */
3014                break;
3015
3016                /*--------------------------------------------------------------------------*/
3017            case atan_op:                                              /* atan_op */
3018                arg1 = get_locint_f();
3019                arg2 = get_locint_f();
3020                res  = get_locint_f();
3021
3022                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
3023
3024#if !defined(_NTIGHT_)
3025                dp_T0[res]=atan(dp_T0[arg1]);
3026#endif /* !_NTIGHT_ */
3027
3028                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
3029
3030#if defined(_INDO_)
3031#if defined(_INDOPRO_)
3032                copy_index_domain(res, arg1, ind_dom);
3033#endif
3034#if defined(_NONLIND_)
3035                fod[opind].entry = maxopind+2;
3036                fod[opind].left = &fod[arg_index[arg1]];
3037                fod[opind].right = NULL;
3038                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
3039                arg_index[res] = opind++;               
3040#endif
3041#if defined(_NONLIND_OLD_)
3042                extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
3043#endif
3044#else
3045#if !defined(_ZOS_) /* BREAK_ZOS */
3046                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
3047                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
3048#ifdef _INT_FOR_
3049                FOR_0_LE_l_LT_p
3050                TRES_FOINC = TARG1_FOINC;
3051#else
3052                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
3053
3054                FOR_0_LE_l_LT_p
3055                { FOR_0_LE_i_LT_k
3056                  { /* olvo 980921 changed order to allow x = atan(x) */
3057#if defined(_HIGHER_ORDER_)
3058                      zOP      = dp_z+i;
3059                      (*zOP--) = (i+1) * (*Targ1);
3060#endif /* _HIGHER_ORDER_ */
3061
3062                      TRES_FOINC = dp_T0[arg2] * TARG1_INC;
3063
3064#if defined(_HIGHER_ORDER_)
3065                      Targ2OP = Targ2;
3066
3067                      *Tres *= (i+1);
3068                      for (j=0;j<i;j++)
3069                      *Tres  += (*Targ2OP++) * (*zOP--);
3070                      *Tres++ /= (i+1);
3071#endif /* _HIGHER_ORDER_ */
3072                  }
3073                  HOV_INC(Targ2, k)
3074                }
3075#endif
3076#endif
3077#endif /* ALL_TOGETHER_AGAIN */
3078                break;
3079
3080            /*--------------------------------------------------------------------------*/
3081        case asin_op:                                              /* asin_op */
3082            arg1 = get_locint_f();
3083                arg2 = get_locint_f();
3084                res  = get_locint_f();
3085
3086                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
3087
3088#if !defined(_NTIGHT_)
3089                dp_T0[res] = asin(dp_T0[arg1]);
3090#endif /* !_NTIGHT_ */
3091
3092                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
3093
3094#if defined(_INDO_)
3095#if defined(_INDOPRO_)
3096                copy_index_domain(res, arg1, ind_dom);
3097#endif
3098#if defined(_NONLIND_)
3099                fod[opind].entry = maxopind+2;
3100                fod[opind].left = &fod[arg_index[arg1]];
3101                fod[opind].right = NULL;
3102                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
3103                arg_index[res] = opind++;               
3104#endif
3105#if defined(_NONLIND_OLD_)
3106                extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
3107#endif
3108#else
3109#if !defined(_ZOS_) /* BREAK_ZOS */
3110                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
3111                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
3112#ifdef _INT_FOR_
3113                FOR_0_LE_l_LT_p
3114                TRES_FOINC = TARG1_FOINC;
3115#else
3116                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
3117
3118                if (dp_T0[arg1] == 1.0)
3119                    FOR_0_LE_l_LT_p
3120                    { FOR_0_LE_i_LT_k
3121                      if (TARG1 > 0.0) {
3122                      r0 = make_nan();
3123                          VEC_INC(Targ1, k-i)
3124                          BREAK_FOR_I
3125                      } else
3126                          if (TARG1 < 0.0) {
3127                          r0 = make_inf();
3128                              VEC_INC(Targ1, k-i)
3129                              BREAK_FOR_I
3130                          } else {
3131                              r0 = 0.0;
3132                              Targ1++;
3133                          }
3134                  TRES = r0;
3135                  VEC_INC(Tres, k)
3136            } else
3137                    if (dp_T0[arg1] == -1.0)
3138                        FOR_0_LE_l_LT_p
3139                        { FOR_0_LE_i_LT_k
3140                          if (TARG1 > 0.0) {
3141                          r0 = make_inf();
3142                              VEC_INC(Targ1, k-i)
3143                              BREAK_FOR_I
3144                          } else
3145                              if (TARG1 < 0.0) {
3146                              r0 = make_nan();
3147                                  VEC_INC(Targ1, k-i)
3148                                  BREAK_FOR_I
3149                              } else {
3150                                  r0 = 0.0;
3151                                  Targ1++;
3152                              }
3153                  TRES = r0;
3154                  VEC_INC(Tres, k)
3155                } else
3156                        FOR_0_LE_l_LT_p {
3157                            FOR_0_LE_i_LT_k
3158                            { /* olvo 980921 changed order to allow x = asin(x) */
3159#if defined(_HIGHER_ORDER_)
3160                                zOP      = dp_z+i;
3161                                (*zOP--) = (i+1) * (*Targ1);
3162#endif /* _HIGHER_ORDER_ */
3163
3164                                TRES_FOINC = dp_T0[arg2] * TARG1_INC;
3165
3166#if defined(_HIGHER_ORDER_)
3167                                Targ2OP = Targ2;
3168
3169                                *Tres *= (i+1);
3170                                for (j=0;j<i;j++)
3171                                *Tres += (*Targ2OP++) * (*zOP--);
3172                                *Tres++ /= (i+1);
3173#endif /* _HIGHER_ORDER_ */
3174                            }
3175                            HOV_INC(Targ2, k)
3176                        }
3177#endif
3178#endif
3179#endif /* ALL_TOGETHER_AGAIN */
3180                        break;
3181
3182            /*--------------------------------------------------------------------------*/
3183        case acos_op:                                              /* acos_op */
3184                arg1 = get_locint_f();
3185                arg2 = get_locint_f();
3186                res  = get_locint_f();
3187
3188                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
3189
3190#if !defined(_NTIGHT_)
3191                dp_T0[res] = acos(dp_T0[arg1]);
3192#endif /* !_NTIGHT_ */
3193
3194                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
3195
3196#if defined(_INDO_)
3197#if defined(_INDOPRO_)
3198                copy_index_domain(res, arg1, ind_dom);
3199#endif
3200#if defined(_NONLIND_)
3201                fod[opind].entry = maxopind+2;
3202                fod[opind].left = &fod[arg_index[arg1]];
3203                fod[opind].right = NULL;
3204                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
3205                arg_index[res] = opind++;               
3206#endif
3207#if defined(_NONLIND_OLD_)
3208                extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
3209#endif
3210#else
3211#if !defined(_ZOS_) /* BREAK_ZOS */
3212                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
3213                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
3214#ifdef _INT_FOR_
3215                FOR_0_LE_l_LT_p
3216                TRES_FOINC = TARG1_FOINC;
3217#else
3218                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
3219
3220                if (dp_T0[arg1] == 1.0)
3221                    FOR_0_LE_l_LT_p
3222                    { FOR_0_LE_i_LT_k
3223                      if (TARG1 > 0.0) {
3224                      r0 = make_nan();
3225                          VEC_INC(Targ1, k-i)
3226                          BREAK_FOR_I
3227                      } else
3228                          if (TARG1 < 0.0) {
3229                          r0 = -make_inf();
3230                              VEC_INC(Targ1, k-i)
3231                              BREAK_FOR_I
3232                          } else {
3233                              r0 = 0.0;
3234                              Targ1++;
3235                          }
3236                  TRES = r0;
3237                  VEC_INC(Tres, k)
3238            } else
3239                    if (dp_T0[arg1] == -1.0)
3240                        FOR_0_LE_l_LT_p
3241                        { FOR_0_LE_i_LT_k
3242                          if (TARG1 > 0.0) {
3243                          r0 = -make_inf();
3244                              VEC_INC(Targ1, k-i)
3245                              BREAK_FOR_I
3246                          } else
3247                              if (TARG1 < 0.0) {
3248                              r0 = make_nan();
3249                                  VEC_INC(Targ1, k-i)
3250                                  BREAK_FOR_I
3251                              } else {
3252                                  r0 = 0.0;
3253                                  Targ1++;
3254                              }
3255                  TRES = r0;
3256                  VEC_INC(Tres, k)
3257                } else
3258                        FOR_0_LE_l_LT_p {
3259                            FOR_0_LE_i_LT_k
3260                            { /* olvo 980921 changed order to allow x = acos(x) */
3261#if defined(_HIGHER_ORDER_)
3262                                zOP      = dp_z+i;
3263                                (*zOP--) = (i+1) * (*Targ1);
3264#endif /* _HIGHER_ORDER_ */
3265
3266                                TRES_FOINC = dp_T0[arg2] * TARG1_INC;
3267
3268#if defined(_HIGHER_ORDER_)
3269                                Targ2OP = Targ2;
3270
3271                                *Tres *= (i+1);
3272                                for (j=0;j<i;j++)
3273                                *Tres += (*Targ2OP++) * (*zOP--);
3274                                *Tres++ /= (i+1);
3275#endif /* _HIGHER_ORDER_ */
3276                            }
3277                            HOV_INC(Targ2, k)
3278                        }
3279#endif
3280#endif
3281#endif /* ALL_TOGETHER_AGAIN */
3282                        break;
3283
3284#ifdef ATRIG_ERF
3285
3286            /*--------------------------------------------------------------------------*/
3287        case asinh_op:                                            /* asinh_op */
3288                arg1 = get_locint_f();
3289                arg2 = get_locint_f();
3290                res  = get_locint_f();
3291
3292                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
3293
3294#if !defined(_NTIGHT_)
3295                dp_T0[res] = asinh(dp_T0[arg1]);
3296#endif /* !_NTIGHT_ */
3297
3298                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
3299
3300#if defined(_INDO_)
3301#if defined(_INDOPRO_)
3302                copy_index_domain(res, arg1, ind_dom);
3303#endif
3304#if defined(_NONLIND_)
3305                fod[opind].entry = maxopind+2;
3306                fod[opind].left = &fod[arg_index[arg1]];
3307                fod[opind].right = NULL;
3308                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
3309                arg_index[res] = opind++;               
3310#endif
3311#if defined(_NONLIND_OLD_)
3312                extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
3313#endif
3314#else
3315#if !defined(_ZOS_) /* BREAK_ZOS */
3316                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
3317                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
3318#ifdef _INT_FOR_
3319                FOR_0_LE_l_LT_p
3320                TRES_FOINC = TARG1_FOINC;
3321#else
3322                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
3323
3324                FOR_0_LE_l_LT_p
3325                { FOR_0_LE_i_LT_k
3326                  { /* olvo 980921 changed order to allow x = asinh(x) */
3327#if defined(_HIGHER_ORDER_)
3328                      zOP      = dp_z+i;
3329                      (*zOP--) = (i+1) * (*Targ1);
3330#endif /* _HIGHER_ORDER_ */
3331
3332                      TRES_FOINC = dp_T0[arg2] * TARG1_INC;
3333
3334#if defined(_HIGHER_ORDER_)
3335                      Targ2OP = Targ2;
3336
3337                      *Tres *= (i+1);
3338                      for (j=0;j<i;j++)
3339                      *Tres += (*Targ2OP++) * (*zOP--);
3340                      *Tres++ /= (i+1);
3341#endif /* _HIGHER_ORDER_ */
3342                  }
3343                  HOV_INC(Targ2, k)
3344                }
3345#endif
3346#endif
3347#endif /* ALL_TOGETHER_AGAIN */
3348                break;
3349
3350            /*--------------------------------------------------------------------------*/
3351        case acosh_op:                                           /* acosh_op */
3352                arg1 = get_locint_f();
3353                arg2 = get_locint_f();
3354                res  = get_locint_f();
3355
3356                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
3357
3358#if !defined(_NTIGHT_)
3359                dp_T0[res] = acosh(dp_T0[arg1]);
3360#endif /* !_NTIGHT_ */
3361
3362                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
3363
3364#if defined(_INDO_)
3365#if defined(_INDOPRO_)
3366                copy_index_domain(res, arg1, ind_dom);
3367#endif
3368#if defined(_NONLIND_)
3369                fod[opind].entry = maxopind+2;
3370                fod[opind].left = &fod[arg_index[arg1]];
3371                fod[opind].right = NULL;
3372                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
3373                arg_index[res] = opind++;               
3374#endif
3375#if defined(_NONLIND_OLD_)
3376                extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
3377#endif
3378#else
3379#if !defined(_ZOS_) /* BREAK_ZOS */
3380                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
3381                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
3382#ifdef _INT_FOR_
3383                FOR_0_LE_l_LT_p
3384                TRES_FOINC = TARG1_FOINC;
3385#else
3386                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
3387
3388                if (dp_T0[arg1] == 1.0)
3389                    FOR_0_LE_l_LT_p
3390                    { FOR_0_LE_i_LT_k
3391                      if (TARG1 > 0.0) {
3392                      r0 = make_inf();
3393                          VEC_INC(Targ1, k-i)
3394                          BREAK_FOR_I
3395                      } else
3396                          if (TARG1 < 0.0) {
3397                          r0 = make_nan();
3398                              VEC_INC(Targ1, k-i)
3399                              BREAK_FOR_I
3400                          } else {
3401                              r0 = 0.0;
3402                              Targ1++;
3403                          }
3404                  TRES_INC = r0;
3405#if defined(_HIGHER_ORDER_)
3406                  for (i=1;i<k;i++)
3407                  *Tres++ = make_nan();
3408#endif /* _HIGHER_ORDER_ */
3409                } else
3410                    FOR_0_LE_l_LT_p {
3411                        FOR_0_LE_i_LT_k
3412                        { /* olvo 980921 changed order to allow x = acosh(x) */
3413#if defined(_HIGHER_ORDER_)
3414                            zOP      = dp_z+i;
3415                            (*zOP--) = (i+1) * (*Targ1);
3416#endif /* _HIGHER_ORDER_ */
3417
3418                            TRES_FOINC = dp_T0[arg2] * TARG1_INC;
3419
3420#if defined(_HIGHER_ORDER_)
3421                            Targ2OP = Targ2;
3422
3423                            *Tres *= (i+1);
3424                            for (j=0;j<i;j++)
3425                                *Tres += (*Targ2OP++) * (*zOP--);
3426                                *Tres++ /= (i+1);
3427#endif /* _HIGHER_ORDER_ */
3428                            }
3429                            HOV_INC(Targ2, k)
3430                        }
3431#endif
3432#endif
3433#endif /* ALL_TOGETHER_AGAIN */
3434                        break;
3435
3436            /*--------------------------------------------------------------------------*/
3437        case atanh_op:                                            /* atanh_op */
3438                arg1 = get_locint_f();
3439                arg2 = get_locint_f();
3440                res  = get_locint_f();
3441
3442                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
3443
3444#if !defined(_NTIGHT_)
3445                dp_T0[res] = atanh(dp_T0[arg1]);
3446#endif /* !_NTIGHT_ */
3447
3448                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
3449
3450#if defined(_INDO_)
3451#if defined(_INDOPRO_)
3452                copy_index_domain(res, arg1, ind_dom);
3453#endif
3454#if defined(_NONLIND_)
3455                fod[opind].entry = maxopind+2;
3456                fod[opind].left = &fod[arg_index[arg1]];
3457                fod[opind].right = NULL;
3458                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
3459                arg_index[res] = opind++;               
3460#endif
3461#if defined(_NONLIND_OLD_)
3462                extend_nonlinearity_domain_unary(arg1, ind_dom, nonl_dom);
3463#endif
3464#else
3465#if !defined(_ZOS_) /* BREAK_ZOS */
3466                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
3467                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
3468#ifdef _INT_FOR_
3469                FOR_0_LE_l_LT_p
3470                TRES_FOINC = TARG1_FOINC;
3471#else
3472                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
3473
3474                if (dp_T0[arg1] == 1.0)
3475                    FOR_0_LE_l_LT_p
3476                    { FOR_0_LE_i_LT_k
3477                      if (TARG1 > 0.0) {
3478                      r0 = make_nan();
3479                          VEC_INC(Targ1, k-i)
3480                          BREAK_FOR_I
3481                      } else
3482                          if (TARG1 < 0.0) {
3483                          r0 = make_inf();
3484                              VEC_INC(Targ1, k-i)
3485                              BREAK_FOR_I
3486                          } else {
3487                              r0 = 0.0;
3488                              Targ1++;
3489                          }
3490                  TRES_INC = r0;
3491#if defined(_HIGHER_ORDER_)
3492                  for (i=1;i<k;i++)
3493                  *Tres++ = make_nan();
3494#endif /* _HIGHER_ORDER_ */
3495                } else
3496                    if (dp_T0[arg1] == -1.0)
3497                            FOR_0_LE_l_LT_p
3498                            { FOR_0_LE_i_LT_k
3499                              if (TARG1 > 0.0) {
3500                              r0 = make_inf();
3501                                  VEC_INC(Targ1, k-i)
3502                                  BREAK_FOR_I
3503                              } else
3504                                  if (TARG1 < 0.0) {
3505                                  r0 = make_nan();
3506                                      VEC_INC(Targ1, k-i)
3507                                      BREAK_FOR_I
3508                                  } else {
3509                                      r0 = 0.0;
3510                                      Targ1++;
3511                                  }
3512                  TRES_INC = r0;
3513#if defined(_HIGHER_ORDER_)
3514                  for (i=1;i<k;i++)
3515                  *Tres++ = make_nan();
3516#endif /* _HIGHER_ORDER_ */
3517                        } else
3518                            FOR_0_LE_l_LT_p {
3519                                FOR_0_LE_i_LT_k
3520                                { /* olvo 980921 changed order to allow x = atanh(x) */
3521#if defined(_HIGHER_ORDER_)
3522                                    zOP      = dp_z+i;
3523                                    (*zOP--) = (i+1) * (*Targ1);
3524#endif /* _HIGHER_ORDER_ */
3525
3526                                    TRES_FOINC = dp_T0[arg2] * TARG1_INC;
3527
3528#if defined(_HIGHER_ORDER_)
3529                                    Targ2OP = Targ2;
3530
3531                                    *Tres *= (i+1);
3532                                    for (j=0;j<i;j++)
3533                                        *Tres += (*Targ2OP++) * (*zOP--);
3534                                        *Tres++ /= (i+1);
3535#endif /* _HIGHER_ORDER_ */
3536                                    }
3537                                    HOV_INC(Targ2, k)
3538                                }
3539#endif
3540#endif
3541#endif /* ALL_TOGETHER_AGAIN */
3542                                break;
3543
3544            /*--------------------------------------------------------------------------*/
3545        case erf_op:                                                /* erf_op */
3546                arg1 = get_locint_f();
3547                arg2 = get_locint_f();
3548                res  = get_locint_f();
3549
3550                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
3551
3552#if !defined(_NTIGHT_)
3553                dp_T0[res] = erf(dp_T0[arg1]);
3554#endif /* !_NTIGHT_ */
3555
3556                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
3557#if defined(_INDO_)
3558#if defined(_INDOPRO_)
3559                copy_index_domain(res, arg1, ind_dom);
3560#endif
3561#if defined(_NONLIND_)
3562                fod[opind].entry = maxopind+2;
3563                fod[opind].left = &fod[arg_index[arg1]];
3564                fod[opind].right = NULL;
3565                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
3566                arg_index[res] = opind++;               
3567#endif       
3568#else
3569#if !defined(_ZOS_) /* BREAK_ZOS */
3570                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
3571                ASSIGN_T(Targ1,TAYLOR_BUFFER[arg1])
3572#ifdef _INT_FOR_
3573                FOR_0_LE_l_LT_p
3574                TRES_FOINC = TARG1_FOINC;
3575#else
3576                ASSIGN_T(Targ2,TAYLOR_BUFFER[arg2])
3577
3578                FOR_0_LE_l_LT_p
3579                { FOR_0_LE_i_LT_k
3580                  { /* olvo 980921 changed order to allow x = erf(x) */
3581#if defined(_HIGHER_ORDER_)
3582                      zOP      = dp_z+i;
3583                      (*zOP--) = (i+1) * (*Targ1);
3584#endif /* _HIGHER_ORDER_ */
3585
3586                      TRES_FOINC = dp_T0[arg2] * TARG1_INC;
3587
3588#if defined(_HIGHER_ORDER_)
3589                      Targ2OP = Targ2;
3590
3591                      *Tres *= (i+1);
3592                      for (j=0;j<i;j++)
3593                      *Tres += (*Targ2OP++) * (*zOP--);
3594                      *Tres++ /= (i+1);
3595#endif /* _HIGHER_ORDER_ */
3596                  }
3597                  HOV_INC(Targ2, k)
3598                }
3599#endif
3600#endif
3601#endif /* ALL_TOGETHER_AGAIN */
3602                break;
3603
3604#endif
3605
3606            /*--------------------------------------------------------------------------*/
3607        case log_op:                                                /* log_op */
3608                arg = get_locint_f();
3609                res = get_locint_f();
3610
3611                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
3612
3613#if defined(_INDO_)
3614#if defined(_INDOPRO_)
3615                copy_index_domain(res, arg, ind_dom);
3616#endif
3617#if defined(_NONLIND_)
3618                fod[opind].entry = maxopind+2;
3619                fod[opind].left = &fod[arg_index[arg]];
3620                fod[opind].right = NULL;
3621                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
3622                arg_index[res] = opind++;               
3623#endif
3624#if defined(_NONLIND_OLD_)
3625                extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
3626#endif
3627#else
3628#if !defined(_ZOS_) /* BREAK_ZOS */
3629                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
3630                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
3631
3632#ifdef _INT_FOR_
3633                FOR_0_LE_l_LT_p
3634                TRES_FOINC = TARG_INC;
3635#else
3636                divs = 1.0 / dp_T0[arg];
3637                FOR_0_LE_l_LT_p
3638                { if (dp_T0[arg] == 0.0) {
3639                  TargOP = Targ;
3640                  FOR_0_LE_i_LT_k
3641                  { if (*TargOP++ < 0.0) {
3642                        divs = make_nan();
3643                            BREAK_FOR_I
3644                        }
3645                      }
3646                  }
3647
3648                  /* olvo 980921 changed order to allow x = log(x) */
3649                  FOR_0_LE_i_LT_k
3650                  { TRES_FOINC = TARG_INC * divs;
3651#if defined(_HIGHER_ORDER_)
3652                    TresOP = Tres - i;
3653                    zOP    = dp_z+i;
3654
3655                    (*zOP--) = *Tres;
3656                    (*Tres) *= i+1;
3657                    for (j=0;j<i;j++)
3658                    (*Tres) -= (*zOP--) * (*TresOP++) * (j+1);
3659                    *Tres++ /= i+1;
3660#endif /* _HIGHER_ORDER_ */
3661                  }
3662                }
3663#endif
3664#endif
3665#endif /* ALL_TOGETHER_AGAIN */
3666#if !defined(_NTIGHT_)
3667                dp_T0[res] = log(dp_T0[arg]);
3668#endif /* !_NTIGHT_ */
3669
3670                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
3671                break;
3672
3673                /*--------------------------------------------------------------------------*/
3674            case pow_op:                                                /* pow_op */
3675                arg   = get_locint_f();
3676                res   = get_locint_f();
3677
3678#if !defined(_NTIGHT_)
3679                coval = 
3680#endif
3681                get_val_f();
3682
3683                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
3684
3685                /* olvo 980921 necessary for reverse */
3686                if (arg == res) {
3687                    IF_KEEP_WRITE_TAYLOR(arg,keep,k,p)
3688                }
3689
3690#if !defined(_NTIGHT_)
3691
3692#ifndef _ZOS_ /* BREAK_ZOS */
3693#if !defined(_INT_FOR_) && !defined(_INDO_)
3694                T0arg   = dp_T0[arg];
3695#endif
3696#endif /* ALL_TOGETHER_AGAIN */
3697
3698                dp_T0[res] =
3699                    pow(dp_T0[arg], coval);
3700#endif /* !_NTIGHT_ */
3701
3702                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
3703#if defined(_INDO_)
3704#if defined(_INDOPRO_)
3705                copy_index_domain(res, arg, ind_dom);
3706#endif
3707#if defined(_NONLIND_)
3708                fod[opind].entry = maxopind+2;
3709                fod[opind].left = &fod[arg_index[arg]];
3710                fod[opind].right = NULL;
3711                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
3712                arg_index[res] = opind++;               
3713#endif
3714#if defined(_NONLIND_OLD_)
3715                extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
3716#endif
3717#else
3718#ifndef _ZOS_ /* BREAK_ZOS */
3719                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
3720                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
3721
3722#ifdef _INT_FOR_
3723                FOR_0_LE_l_LT_p
3724                TRES_FOINC = TARG_INC;
3725#else
3726                if (T0arg == 0.0) {
3727                    if (coval <= 0.0)
3728                        FOR_0_LE_l_LT_pk
3729                        TRES_INC = make_nan();
3730                    else {
3731                        /* coval not a whole number */
3732                        if (coval - floor(coval) != 0) {
3733                            FOR_0_LE_l_LT_p
3734                            {
3735                                i = 0;
3736                                FOR_0_LE_i_LT_k
3737                                {
3738                                    if (coval - i > 1)
3739                                    TRES_INC = 0;
3740                                    if ((coval - i < 1) && (coval - i > 0))
3741                                        TRES_INC = make_inf();
3742                                        if (coval - i < 0)
3743                                            TRES_INC = make_nan();
3744                                        }
3745                                    }
3746                                } else {
3747                        if (coval == 1) {
3748                                FOR_0_LE_l_LT_pk
3749                                TRES_INC = TARG_INC;
3750                            } else
3751                                /* coval is an int > 1 */
3752                                /* the following is not efficient but at least it works */
3753                                /* it reformulates x^n into x* ... *x n times */
3754                            {
3755                                INC_pk_1(Targ)
3756                                INC_pk_1(Tres)
3757
3758                                FOR_p_GT_l_GE_0
3759                                {
3760                                    FOR_k_GT_i_GE_0
3761                                    {
3762                                        *Tres = 0;
3763                                        DEC_TRES_FO
3764#if defined(_HIGHER_ORDER_)
3765                                        if (i == k-1) {
3766                                        zOP = dp_z+k-1;
3767                                        for(j=k-1;j>=0;j--) {
3768                                                (*zOP--) = (*Targ--);
3769                                            }
3770                                        }
3771                                        for (j=0;j<i;j++) {
3772                                        *Tres += dp_z[j] *
3773                                                     dp_z[i-j-1];
3774                                        }
3775                                        Tres--;
3776#endif /* _HIGHER_ORDER_ */
3777                                    }
3778                                }
3779                                for(ii=3;ii<=coval;ii++) {
3780                                    ASSIGN_T(Tres, TAYLOR_BUFFER[res])
3781                                    ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
3782                                    INC_pk_1(Targ)
3783                                    INC_pk_1(Tres)
3784
3785                                    FOR_p_GT_l_GE_0
3786                                    {
3787                                        FOR_k_GT_i_GE_0
3788                                        {
3789                                            *Tres = 0;
3790                                            DEC_TRES_FO
3791#if defined(_HIGHER_ORDER_)
3792                                            TresOP = Tres-i;
3793                                            for (j=0;j<i;j++)
3794                                            *Tres += TresOP[j] * dp_z[i-j-1];
3795                                            Tres--;
3796#endif /* _HIGHER_ORDER_ */
3797                                        }
3798                                    }
3799                                }
3800                        }
3801                    }
3802                }
3803            } else {
3804                r0 = 1.0 / T0arg;
3805                FOR_0_LE_l_LT_p
3806                FOR_0_LE_i_LT_k
3807                { /* olvo 980921 changed order to allow x = pow(x,n) */
3808#ifdef _HIGHER_ORDER_
3809                    zOP      = dp_z+i;
3810                    (*zOP--) = (*Targ) * r0;
3811#endif /* _HIGHER_ORDER_ */
3812
3813                    TRES_FOINC = dp_T0[res] *
3814                                 TARG_INC * coval * r0;
3815
3816#ifdef _HIGHER_ORDER_
3817                    TresOP = Tres-i;
3818
3819                    (*Tres) *= i+1;
3820                    y = coval*i -1;
3821                    for (j=0;j<i;j++) {
3822                        *Tres += (*TresOP++) * (*zOP--) * y;
3823                            y -= coval + 1;
3824                        }
3825                        *Tres++ /= (i+1);
3826#endif /* _HIGHER_ORDER_ */
3827                    }
3828                }
3829#endif
3830#endif
3831#endif /* ALL_TOGETHER_AGAIN */
3832                break;
3833
3834                /*--------------------------------------------------------------------------*/
3835            case pow_op_p:                                                /* pow_op_p */
3836                arg   = get_locint_f();
3837                res   = get_locint_f();
3838                arg1  = get_locint_f();
3839#if !defined(_NTIGHT_)
3840                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
3841#endif
3842
3843                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
3844
3845                /* olvo 980921 necessary for reverse */
3846                if (arg == res) {
3847                    IF_KEEP_WRITE_TAYLOR(arg,keep,k,p)
3848                }
3849
3850#if !defined(_NTIGHT_)
3851
3852#ifndef _ZOS_ /* BREAK_ZOS */
3853#if !defined(_INT_FOR_) && !defined(_INDO_)
3854                T0arg   = dp_T0[arg];
3855#endif
3856#endif /* ALL_TOGETHER_AGAIN */
3857
3858                dp_T0[res] =
3859                    pow(dp_T0[arg], coval);
3860#endif /* !_NTIGHT_ */
3861
3862                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
3863#if defined(_INDO_)
3864#if defined(_INDOPRO_)
3865                copy_index_domain(res, arg, ind_dom);
3866#endif
3867#if defined(_NONLIND_)
3868                fod[opind].entry = maxopind+2;
3869                fod[opind].left = &fod[arg_index[arg]];
3870                fod[opind].right = NULL;
3871                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
3872                arg_index[res] = opind++;               
3873#endif
3874#if defined(_NONLIND_OLD_)
3875                extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
3876#endif
3877#else
3878#ifndef _ZOS_ /* BREAK_ZOS */
3879                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
3880                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
3881
3882#ifdef _INT_FOR_
3883                FOR_0_LE_l_LT_p
3884                TRES_FOINC = TARG_INC;
3885#else
3886                if (T0arg == 0.0) {
3887                    if (coval <= 0.0)
3888                        FOR_0_LE_l_LT_pk
3889                        TRES_INC = make_nan();
3890                    else {
3891                        /* coval not a whole number */
3892                        if (coval - floor(coval) != 0) {
3893                            FOR_0_LE_l_LT_p
3894                            {
3895                                i = 0;
3896                                FOR_0_LE_i_LT_k
3897                                {
3898                                    if (coval - i > 1)
3899                                    TRES_INC = 0;
3900                                    if ((coval - i < 1) && (coval - i > 0))
3901                                        TRES_INC = make_inf();
3902                                        if (coval - i < 0)
3903                                            TRES_INC = make_nan();
3904                                        }
3905                                    }
3906                                } else {
3907                        if (coval == 1) {
3908                                FOR_0_LE_l_LT_pk
3909                                TRES_INC = TARG_INC;
3910                            } else
3911                                /* coval is an int > 1 */
3912                                /* the following is not efficient but at least it works */
3913                                /* it reformulates x^n into x* ... *x n times */
3914                            {
3915                                INC_pk_1(Targ)
3916                                INC_pk_1(Tres)
3917
3918                                FOR_p_GT_l_GE_0
3919                                {
3920                                    FOR_k_GT_i_GE_0
3921                                    {
3922                                        *Tres = 0;
3923                                        DEC_TRES_FO
3924#if defined(_HIGHER_ORDER_)
3925                                        if (i == k-1) {
3926                                        zOP = dp_z+k-1;
3927                                        for(j=k-1;j>=0;j--) {
3928                                                (*zOP--) = (*Targ--);
3929                                            }
3930                                        }
3931                                        for (j=0;j<i;j++) {
3932                                        *Tres += dp_z[j] *
3933                                                     dp_z[i-j-1];
3934                                        }
3935                                        Tres--;
3936#endif /* _HIGHER_ORDER_ */
3937                                    }
3938                                }
3939                                for(ii=3;ii<=coval;ii++) {
3940                                    ASSIGN_T(Tres, TAYLOR_BUFFER[res])
3941                                    ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
3942                                    INC_pk_1(Targ)
3943                                    INC_pk_1(Tres)
3944
3945                                    FOR_p_GT_l_GE_0
3946                                    {
3947                                        FOR_k_GT_i_GE_0
3948                                        {
3949                                            *Tres = 0;
3950                                            DEC_TRES_FO
3951#if defined(_HIGHER_ORDER_)
3952                                            TresOP = Tres-i;
3953                                            for (j=0;j<i;j++)
3954                                            *Tres += TresOP[j] * dp_z[i-j-1];
3955                                            Tres--;
3956#endif /* _HIGHER_ORDER_ */
3957                                        }
3958                                    }
3959                                }
3960                        }
3961                    }
3962                }
3963            } else {
3964                r0 = 1.0 / T0arg;
3965                FOR_0_LE_l_LT_p
3966                FOR_0_LE_i_LT_k
3967                { /* olvo 980921 changed order to allow x = pow(x,n) */
3968#ifdef _HIGHER_ORDER_
3969                    zOP      = dp_z+i;
3970                    (*zOP--) = (*Targ) * r0;
3971#endif /* _HIGHER_ORDER_ */
3972
3973                    TRES_FOINC = dp_T0[res] *
3974                                 TARG_INC * coval * r0;
3975
3976#ifdef _HIGHER_ORDER_
3977                    TresOP = Tres-i;
3978
3979                    (*Tres) *= i+1;
3980                    y = coval*i -1;
3981                    for (j=0;j<i;j++) {
3982                        *Tres += (*TresOP++) * (*zOP--) * y;
3983                            y -= coval + 1;
3984                        }
3985                        *Tres++ /= (i+1);
3986#endif /* _HIGHER_ORDER_ */
3987                    }
3988                }
3989#endif
3990#endif
3991#endif /* ALL_TOGETHER_AGAIN */
3992                break;
3993
3994                /*--------------------------------------------------------------------------*/
3995            case sqrt_op:                                              /* sqrt_op */
3996                arg = get_locint_f();
3997                res = get_locint_f();
3998
3999                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
4000
4001#if !defined(_NTIGHT_)
4002                dp_T0[res] = sqrt(dp_T0[arg]);
4003#endif /* !_NTIGHT_ */
4004
4005                ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
4006
4007#if defined(_INDO_)
4008#if defined(_INDOPRO_)
4009                copy_index_domain(res, arg, ind_dom);
4010#endif
4011#if defined(_NONLIND_)
4012                fod[opind].entry = maxopind+2;
4013                fod[opind].left = &fod[arg_index[arg]];
4014                fod[opind].right = NULL;
4015                traverse_unary(&fod[opind], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
4016                arg_index[res] = opind++;               
4017#endif
4018#if defined(_NONLIND_OLD_)
4019                extend_nonlinearity_domain_unary(arg, ind_dom, nonl_dom);
4020#endif
4021#else
4022#if !defined(_ZOS_) /* BREAK_ZOS */
4023                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
4024                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
4025
4026#ifdef _INT_FOR_
4027                FOR_0_LE_l_LT_p
4028                TRES_FOINC = TARG_INC;
4029#else
4030                FOR_0_LE_l_LT_p
4031                { TargOP = Targ;
4032                  if (dp_T0[arg] == 0.0)
4033                  /* Note: <=> dp_T0[res] == 0.0 */
4034              { r0 = 0.0;
4035                  FOR_0_LE_i_LT_k
4036                  { if (TARG>0.0) {
4037                        r0 = make_inf();
4038                            VEC_INC(Targ, k-i)
4039                            BREAK_FOR_I
4040                        } else
4041                            if (TARG<0.0) {
4042                            r0 = make_nan();
4043                                VEC_INC(Targ, k-i)
4044                                BREAK_FOR_I
4045                            } else
4046                                Targ++;
4047                              }
4048                          }
4049                  else {
4050                      r0 = 0.5/dp_T0[res];
4051                  }
4052                  Targ = TargOP;
4053
4054#if defined(_HIGHER_ORDER_)
4055                  even = 1;
4056#endif
4057                  FOR_0_LE_i_LT_k
4058                  { TRES_FOINC = r0 * TARG_INC;
4059#if defined(_HIGHER_ORDER_)
4060                    TresOP  = Tres-i;
4061                    TresOP2 = Tres-1;
4062
4063                    x = 0;
4064                    for (j=1;2*j-1<i;j++)
4065                    x += (*TresOP++) * (*TresOP2--);
4066                    x *= 2;
4067                    if (!even)
4068                        x += (*TresOP) * (*TresOP2); /* !!! */
4069                        even = !even;
4070                        *Tres++ -= r0*x;
4071#endif /* _HIGHER_ORDER_ */
4072                      }
4073                    }
4074#endif
4075#endif
4076#endif /* ALL_TOGETHER_AGAIN */
4077                    break;
4078
4079            /*--------------------------------------------------------------------------*/
4080        case gen_quad:                                            /* gen_quad */
4081            arg1 = get_locint_f();
4082                arg2 = get_locint_f();
4083                res  = get_locint_f();
4084
4085#if !defined(_NTIGHT_)
4086                if (get_val_f()!=dp_T0[arg1]) {
4087                    fprintf(DIAG_OUT,
4088                            "ADOL-C Warning: forward sweep aborted; tape invalid!\n");
4089                    IF_KEEP_TAYLOR_CLOSE
4090                    end_sweep();
4091                    return -2;
4092                }
4093#endif /* !_NTIGHT_ */
4094
4095#if !defined(_NTIGHT_)
4096                coval =
4097#endif
4098                get_val_f();
4099
4100                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
4101
4102#if !defined(_NTIGHT_)
4103                dp_T0[res] = coval;
4104#endif /* !_NTIGHT_ */
4105
4106#if defined(_INDO_)
4107               fprintf(DIAG_OUT,
4108                    "ADOL-C Warning: forward sweep aborted; sparse mode not available for gen_quad!\n");
4109               end_sweep();
4110               return -2;
4111#else
4112#if !defined(_ZOS_) /* BREAK_ZOS */
4113                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
4114                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
4115#ifdef _INT_FOR_
4116                FOR_0_LE_l_LT_p
4117                TRES_FOINC = TARG1_FOINC;
4118#else
4119                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
4120
4121                FOR_0_LE_l_LT_p
4122                { FOR_0_LE_i_LT_k
4123                  { /* olvo 980922 changed order to allow x = gen_quad(x) */
4124#if defined(_HIGHER_ORDER_)
4125                      zOP      = dp_z+i;
4126                      (*zOP--) = (i+1) * (*Targ1);
4127#endif /* _HIGHER_ORDER_ */
4128
4129                      TRES_FOINC = dp_T0[arg2] * TARG1_INC;
4130
4131#if defined(_HIGHER_ORDER_)
4132                      Targ2OP = Targ2;
4133
4134                      *Tres *= (i+1);
4135                      for (j=0;j<i;j++)
4136                      *Tres += (*Targ2OP++) * (*zOP--);
4137                      *Tres++ /= (i+1);
4138#endif /* _HIGHER_ORDER_ */
4139                  }
4140                  HOV_INC(Targ2, k)
4141                }
4142#endif
4143#endif
4144#endif /* ALL_TOGETHER_AGAIN */
4145                break;
4146
4147            /*--------------------------------------------------------------------------*/
4148        case min_op:                                                /* min_op */
4149            arg1  = get_locint_f();
4150                arg2  = get_locint_f();
4151                res   = get_locint_f();
4152#if !defined(_NTIGHT_)
4153                coval = 
4154#endif
4155                get_val_f();
4156
4157                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
4158
4159#if !defined(_NTIGHT_)
4160                /* olvo 980923 changed order to allow x = min(x,y) etc. */
4161
4162                /* olvo/mitev 980721 return value (taken from below) */
4163                if (dp_T0[arg1] > dp_T0[arg2]) {
4164                    if (coval)
4165                        MINDEC(ret_c,2);
4166                } else
4167                    if (dp_T0[arg1] < dp_T0[arg2]) {
4168                        if (!coval)
4169                            MINDEC(ret_c,2);
4170                    } else
4171                        if (arg1 != arg2)
4172                            MINDEC(ret_c,1);
4173#endif /* !_NTIGHT_ */
4174
4175#if defined (_INDO_)
4176#if defined (_INDOPRO_)
4177#if defined (_TIGHT_)
4178                    if (dp_T0[arg1] < dp_T0[arg2])
4179                        copy_index_domain(res, arg1, ind_dom);
4180                    else {
4181                        if (dp_T0[arg1] > dp_T0[arg2])
4182                            copy_index_domain(res, arg2, ind_dom);
4183                        else
4184                            combine_2_index_domains(res, arg1, arg2, ind_dom);
4185                    }
4186#else
4187                    combine_2_index_domains(res, arg1, arg2, ind_dom);
4188#endif
4189#endif
4190#if defined(_NONLIND_)
4191#ifdef _TIGHT_
4192                    if (dp_T0[arg1] < dp_T0[arg2])
4193                      {
4194                        fod[opind].entry = maxopind+2;
4195                        fod[opind].left = &fod[arg_index[arg1]];
4196                        fod[opind].right = NULL;
4197                        arg_index[res] = opind++;               
4198                      }           
4199                    else {
4200                        if (dp_T0[arg1] > dp_T0[arg2])
4201                          {
4202                            fod[opind].entry = maxopind+2;
4203                            fod[opind].left = &fod[arg_index[arg2]];
4204                            fod[opind].right = NULL;
4205                            arg_index[res] = opind++;           
4206
4207                          }               
4208                        else
4209                          {
4210                            fod[opind].entry = maxopind+2;
4211                            fod[opind].left = &fod[arg_index[arg1]];
4212                            fod[opind].right = &fod[arg_index[arg2]];
4213                            arg_index[res] = opind++;           
4214                          }
4215                    }
4216#else
4217                    fod[opind].entry = maxopind+2;
4218                    fod[opind].left = &fod[arg_index[arg1]];
4219                    fod[opind].right = &fod[arg_index[arg2]];
4220                    arg_index[res] = opind++;           
4221                    arg_index[res] = opind++;           
4222#endif
4223#endif
4224#else
4225#if !defined(_ZOS_) /* BREAK_ZOS */
4226                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
4227                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
4228                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
4229
4230#ifdef _INT_FOR_
4231#ifdef _TIGHT_
4232                Tqo = NULL;
4233                if (dp_T0[arg1] > dp_T0[arg2])
4234                    Tqo = Targ2;
4235                else
4236                    if (dp_T0[arg1] < dp_T0[arg2])
4237                        Tqo = Targ1;
4238
4239                FOR_0_LE_l_LT_p
4240                { Targ = Tqo;
4241                  if (Targ == NULL) /* e.g. T0[arg1] == T0[arg2] */
4242                    { Targ1OP = Targ1;
4243                      Targ2OP = Targ2;
4244                      if (TARG1 > TARG2)
4245                          Targ = Targ2OP;
4246                      else
4247                          if (TARG1 < TARG2)
4248                              Targ = Targ1OP;
4249                      Targ1++;
4250                      Targ2++;
4251                      if (Targ == NULL) /* e.g. both are equal */
4252                          Targ = Targ1OP;
4253                  }
4254
4255                  TRES_INC = TARG_INC;
4256
4257                  if (Tqo)
4258                    Tqo++;
4259                }
4260
4261                dp_T0[res] = MIN_ADOLC(dp_T0[arg1], dp_T0[arg2]);
4262#endif /* _TIGHT_ */
4263#ifdef _NTIGHT_
4264                TRES_INC = TARG1_INC | TARG2_INC;
4265#endif /* _NTIGHT_ */
4266#else
4267                Tqo = NULL;
4268                if (dp_T0[arg1] > dp_T0[arg2])
4269                    Tqo = Targ2;
4270                else
4271                    if (dp_T0[arg1] < dp_T0[arg2])
4272                        Tqo = Targ1;
4273
4274                FOR_0_LE_l_LT_p
4275                { Targ = Tqo;
4276                  if (Targ == NULL) /* e.g. dp_T0[arg1] ==
4277                                                                                 dp_T0[arg2] */
4278              { Targ1OP = Targ1;
4279                  Targ2OP = Targ2;
4280                  FOR_0_LE_i_LT_k
4281                  { if (TARG1 > TARG2) {
4282                        Targ = Targ2OP;
4283                        VEC_INC(Targ1, k-i)
4284                            VEC_INC(Targ2, k-i)
4285                            BREAK_FOR_I
4286                        } else
4287                            if (TARG1 < TARG2) {
4288                            Targ = Targ1OP;
4289                            VEC_INC(Targ1, k-i)
4290                                VEC_INC(Targ2, k-i)
4291                                BREAK_FOR_I
4292                            }
4293                        Targ1++;
4294                        Targ2++;
4295                      }
4296                      if (Targ == NULL) /* e.g. both are equal */
4297                          Targ = Targ1OP;
4298                  }
4299
4300                  FOR_0_LE_i_LT_k
4301                  TRES_INC = TARG_INC;
4302
4303                  if (Tqo) {
4304                  VEC_INC(Tqo, k)
4305                  }
4306            }
4307#endif
4308#endif
4309#endif /* ALL_TOGETHER_AGAIN */
4310#if !defined(_NTIGHT_)
4311                dp_T0[res] =
4312                    MIN_ADOLC( dp_T0[arg1],
4313                               dp_T0[arg2] );
4314#endif /* !_NTIGHT_ */
4315                break;
4316
4317                /*--------------------------------------------------------------------------*/
4318            case abs_val:                                              /* abs_val */
4319                arg   = get_locint_f();
4320                res   = get_locint_f();
4321#if !defined(_NTIGHT_)
4322                coval = 
4323#endif
4324                get_val_f();
4325
4326                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
4327
4328#if !defined(_NTIGHT_)
4329                /* olvo 980923 changed order to allow x = min(x,y) etc. */
4330
4331                /* olvo/mitev 980721 ec n3l (taken from below) */
4332                if (dp_T0[arg] < 0.0) {
4333                    if (coval)
4334                        MINDEC(ret_c,2);
4335                } else
4336                    if (dp_T0[arg] > 0.0) {
4337                        if (!coval)
4338                            MINDEC(ret_c,2);
4339                    }
4340                if (ADOLC_CURRENT_TAPE_INFOS.stats[NO_MIN_MAX]) {
4341                    signature[switchnum] = dp_T0[arg];
4342#if defined(_ABS_NORM_) || defined(_ABS_NORM_SIG_)
4343                    swargs[switchnum] = dp_T0[arg];
4344#endif
4345                }
4346#endif /* !_NTIGHT_ */
4347
4348#if defined(_INDO_)
4349#if defined(_INDOPRO_)
4350#if defined(_ABS_NORM_)
4351                if (ind_dom[arg][0] != 0) {
4352                    crs[switchnum] = (unsigned int*) malloc(sizeof(unsigned int)* (ind_dom[arg][0]+1));
4353                    crs[switchnum][0] = ind_dom[arg][0];
4354                    for(l=1;l<crs[switchnum][0];i++) {
4355                        crs[switchnum][l] = ind_dom[arg][l+1];
4356                    }
4357                } else {
4358                    crs[switchnum] = (unsigned int*) malloc(sizeof(unsigned int));
4359                    crs[switchnum][0] = 0;
4360                }
4361                ind_dom[res][0] = 1;
4362                ind_dom[res][2] = indcheck+switchnum;
4363#else
4364                copy_index_domain(res, arg, ind_dom);
4365#endif
4366#endif
4367#if defined(_NONLIND_)
4368                arg_index[res] = arg_index[arg];               
4369#endif
4370#else
4371#if !defined(_ZOS_) /* BREAK_ZOS */
4372                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
4373                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
4374
4375#ifdef _INT_FOR_
4376#ifdef _TIGHT_
4377                y = 0.0;
4378                if (dp_T0[arg] != 0.0) {
4379                    if (dp_T0[arg] < 0.0)
4380                        y = -1.0;
4381                    else
4382                        y = 1.0;
4383                }
4384                FOR_0_LE_l_LT_p
4385                { if ((y == 0.0) && (TARG != 0.0))
4386                  MINDEC(ret_c,1);
4387
4388                  TRES_INC = TARG_INC;
4389                }
4390
4391                dp_T0[res] = fabs(dp_T0[arg]);
4392#endif /* _TIGHT_ */
4393#ifdef _NTIGHT_
4394                FOR_0_LE_l_LT_p
4395                TRES_INC = TARG_INC;
4396#endif /* _NTIGHT_ */
4397#else
4398#ifdef _ABS_NORM_
4399                sig = FIRSTSIGN_P(dp_T0[arg],Targ);
4400#if defined(_FOV_)
4401                sigsw[switchnum] = sig;
4402#endif
4403                COPYTAYL_P(swtaylors[switchnum],Targ);
4404                FOR_0_LE_l_LT_p
4405                    TRES_INC = fabs(dp_T0[arg]+TARG_INC)-fabs(dp_T0[arg]);
4406#elif defined(_ABS_NORM_SIG_)
4407                if (sigdir == NULL)
4408                    y = EXT_FIRSTSIGN2_P(sigbase[switchnum],dp_T0[arg],Targ);
4409                else
4410                    y = EXT_FIRSTSIGN_P(sigbase[switchnum],sigdir[switchnum],dp_T0[arg],Targ);
4411                COPYTAYL_P(swtaylors[switchnum],Targ);
4412                sigsw[switchnum] = y;
4413                FOR_0_LE_l_LT_p
4414                    TRES_INC = y * TARG_INC;
4415#else
4416                y = 0.0;
4417                if (dp_T0[arg] != 0.0) {
4418                    if (dp_T0[arg] < 0.0)
4419                        y = -1.0;
4420                    else
4421                        y = 1.0;
4422                }
4423
4424                FOR_0_LE_l_LT_p
4425                { x = y;
4426                  FOR_0_LE_i_LT_k
4427                  { if ((x == 0.0) && (TARG != 0.0)) {
4428                    MINDEC(ret_c,1);
4429                        if (TARG < 0.0)
4430                            x = -1.0;
4431                        else
4432                            x = 1.0;
4433                    }
4434                    TRES_INC = x * TARG_INC;
4435                  }
4436                }
4437#endif
4438#endif
4439#endif
4440#endif /* ALL_TOGETHER_AGAIN */
4441#if !defined(_NTIGHT_)
4442                dp_T0[res] = fabs(dp_T0[arg]);
4443#endif /* !_NTIGHT_ */
4444                if (ADOLC_CURRENT_TAPE_INFOS.stats[NO_MIN_MAX])
4445                    switchnum++;
4446                break;
4447
4448                /*--------------------------------------------------------------------------*/
4449            case ceil_op:                                              /* ceil_op */
4450                arg   = get_locint_f();
4451                res   = get_locint_f();
4452#if !defined(_NTIGHT_)
4453                coval = 
4454#endif
4455                get_val_f();
4456
4457                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
4458
4459#if !defined(_NTIGHT_)
4460                dp_T0[res]=ceil(dp_T0[arg]);
4461                /* olvo/mitev 980721 ec n2l (taken from below) */
4462                if (coval != dp_T0[res])
4463                    MINDEC(ret_c,2);
4464#endif /* !_NTIGHT_ */
4465
4466#if defined(_INDO_)
4467#if defined(_INDOPRO_)
4468#ifdef _TIGHT_
4469                ind_dom[res][0] = 0;
4470#else
4471                copy_index_domain(res, arg, ind_dom);
4472#endif /* _TIGHT_ */
4473#endif
4474#if defined(_NONLIND_)
4475                arg_index[res] = arg_index[arg];               
4476#endif
4477#else
4478#if !defined(_ZOS_) /* BREAK_ZOS */
4479                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
4480
4481                FOR_0_LE_l_LT_pk
4482                TRES_INC = 0.0;
4483#endif
4484#endif /* ALL_TOGETHER_AGAIN */
4485                break;
4486
4487                /*--------------------------------------------------------------------------*/
4488            case floor_op:                 /* Compute ceil of adouble    floor_op */
4489                arg   = get_locint_f();
4490                res   = get_locint_f();
4491#if !defined(_NTIGHT_)
4492                coval = 
4493#endif
4494                get_val_f();
4495
4496                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
4497
4498#if !defined(_NTIGHT_)
4499                dp_T0[res] = floor(dp_T0[arg]);
4500                /* olvo/mitev 980721 ec n2l (taken from below) */
4501                if (coval != dp_T0[res])
4502                    MINDEC(ret_c,2);
4503#endif /* !_NTIGHT_ */
4504
4505#if defined(_INDO_)
4506#if defined(_INDOPRO_)
4507#ifdef _TIGHT_
4508                ind_dom[res][0] = 0;
4509#else
4510                copy_index_domain(res, arg, ind_dom);
4511#endif /* _TIGHT_ */
4512#endif
4513#if defined(_NONLIND_)
4514                arg_index[res] = arg_index[arg];               
4515#endif
4516#else
4517#if !defined(_ZOS_) /* BREAK_ZOS */
4518                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
4519
4520                FOR_0_LE_l_LT_pk
4521                TRES_INC = 0.0;
4522#endif
4523#endif /* ALL_TOGETHER_AGAIN */
4524                break;
4525
4526
4527                /****************************************************************************/
4528                /*                                                             CONDITIONALS */
4529
4530                /*--------------------------------------------------------------------------*/
4531            case cond_assign:                                      /* cond_assign */
4532                arg   = get_locint_f();
4533                arg1  = get_locint_f();
4534                arg2  = get_locint_f();
4535                res   = get_locint_f();
4536#if !defined(_NTIGHT_)
4537                coval = 
4538#endif
4539                get_val_f();
4540
4541                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
4542
4543                /* olvo 980924 changed order to allow reflexive ops */
4544#if defined (_INDO_)
4545#if defined (_INDOPRO_)
4546#if defined (_TIGHT_)
4547                if (dp_T0[arg] > 0) {
4548                    if (coval <= 0.0)
4549                        MINDEC(ret_c,2);
4550                    dp_T0[res] = dp_T0[arg1];
4551
4552                    copy_index_domain(res, arg1, ind_dom);
4553
4554                } else {
4555                    if (coval > 0.0)
4556                        MINDEC(ret_c,2);
4557                    if (dp_T0[arg] == 0)
4558                        MINDEC(ret_c,0);
4559                    dp_T0[res] = dp_T0[arg2];
4560                    copy_index_domain(res, arg2, ind_dom);
4561                }
4562#else
4563                    combine_2_index_domains(res, arg1, arg2, ind_dom);
4564#endif
4565#endif
4566#if defined (_NONLIND_)
4567#ifdef _TIGHT_
4568                if (dp_T0[arg] > 0) {
4569                    if (coval <= 0.0)
4570                        MINDEC(ret_c,2);
4571                    dp_T0[res] = dp_T0[arg1];
4572
4573                    arg_index[res] = arg_index[arg1];           
4574                } else {
4575                    if (coval > 0.0)
4576                        MINDEC(ret_c,2);
4577                    if (dp_T0[arg] == 0)
4578                        MINDEC(ret_c,0);
4579                    dp_T0[res] = dp_T0[arg2];
4580
4581                    arg_index[res] = arg_index[arg2];           
4582                }
4583
4584#else
4585               arg_index[res] = opind++;               
4586#endif
4587#endif
4588#else
4589#if !defined(_ZOS_) /* BREAK_ZOS */
4590                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
4591                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
4592                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
4593#endif /* ALL_TOGETHER_AGAIN */
4594
4595#ifdef _INT_FOR_
4596#ifdef _TIGHT_
4597                coval = get_val_f();
4598
4599                if (dp_T0[arg] > 0)
4600                    FOR_0_LE_l_LT_pk
4601                    TRES_INC = TARG1_INC;
4602                else
4603                    FOR_0_LE_l_LT_pk
4604                    TRES_INC = TARG2_INC;
4605
4606                if (dp_T0[arg] > 0) {
4607                    if (coval <= 0.0)
4608                        MINDEC(ret_c,2);
4609                    dp_T0[res] = dp_T0[arg1];
4610                } else {
4611                    if (coval > 0.0)
4612                        MINDEC(ret_c,2);
4613                    if (dp_T0[arg] == 0)
4614                        MINDEC(ret_c,0);
4615                    dp_T0[res] = dp_T0[arg2];
4616                }
4617#endif /* _TIGHT_ */
4618#ifdef _NTIGHT_
4619                FOR_0_LE_l_LT_pk
4620                TRES_INC = TARG1_INC | TARG2_INC;
4621#endif /* _NTIGHT_ */
4622#else
4623#if !defined(_ZOS_) /* BREAK_ZOS */
4624                if (dp_T0[arg] > 0)
4625                    FOR_0_LE_l_LT_pk
4626                    TRES_INC = TARG1_INC;
4627                else
4628                    FOR_0_LE_l_LT_pk
4629                    TRES_INC = TARG2_INC;
4630#endif
4631
4632                if (dp_T0[arg] > 0) {
4633                    if (coval <= 0.0)
4634                        MINDEC(ret_c,2);
4635                    dp_T0[res] = dp_T0[arg1];
4636                } else {
4637                    if (coval > 0.0)
4638                        MINDEC(ret_c,2);
4639                    if (dp_T0[arg] == 0)
4640                        MINDEC(ret_c,0);
4641                    dp_T0[res] = dp_T0[arg2];
4642                }
4643#endif
4644#endif /* ALL_TOGETHER_AGAIN */
4645                break;
4646
4647            case cond_eq_assign:                                      /* cond_eq_assign */
4648                arg   = get_locint_f();
4649                arg1  = get_locint_f();
4650                arg2  = get_locint_f();
4651                res   = get_locint_f();
4652#if !defined(_NTIGHT_)
4653                coval = 
4654#endif
4655                get_val_f();
4656
4657                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
4658
4659                /* olvo 980924 changed order to allow reflexive ops */
4660#if defined (_INDO_)
4661#if defined (_INDOPRO_)
4662#if defined (_TIGHT_)
4663                if (dp_T0[arg] >= 0) {
4664                    if (coval < 0.0)
4665                        MINDEC(ret_c,2);
4666                    dp_T0[res] = dp_T0[arg1];
4667
4668                    copy_index_domain(res, arg1, ind_dom);
4669
4670                } else {
4671                    if (coval >= 0.0)
4672                        MINDEC(ret_c,2);
4673                    dp_T0[res] = dp_T0[arg2];
4674                    copy_index_domain(res, arg2, ind_dom);
4675                }
4676#else
4677                    combine_2_index_domains(res, arg1, arg2, ind_dom);
4678#endif
4679#endif
4680#if defined (_NONLIND_)
4681#ifdef _TIGHT_
4682                if (dp_T0[arg] >= 0) {
4683                    if (coval < 0.0)
4684                        MINDEC(ret_c,2);
4685                    dp_T0[res] = dp_T0[arg1];
4686
4687                    arg_index[res] = arg_index[arg1];           
4688                } else {
4689                    if (coval >= 0.0)
4690                        MINDEC(ret_c,2);
4691                    dp_T0[res] = dp_T0[arg2];
4692
4693                    arg_index[res] = arg_index[arg2];           
4694                }
4695
4696#else
4697               arg_index[res] = opind++;               
4698#endif
4699#endif
4700#else
4701#if !defined(_ZOS_) /* BREAK_ZOS */
4702                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
4703                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
4704                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
4705#endif /* ALL_TOGETHER_AGAIN */
4706
4707#ifdef _INT_FOR_
4708#ifdef _TIGHT_
4709                coval = get_val_f();
4710
4711                if (dp_T0[arg] >= 0)
4712                    FOR_0_LE_l_LT_pk
4713                    TRES_INC = TARG1_INC;
4714                else
4715                    FOR_0_LE_l_LT_pk
4716                    TRES_INC = TARG2_INC;
4717
4718                if (dp_T0[arg] >= 0) {
4719                    if (coval < 0.0)
4720                        MINDEC(ret_c,2);
4721                    dp_T0[res] = dp_T0[arg1];
4722                } else {
4723                    if (coval >= 0.0)
4724                        MINDEC(ret_c,2);
4725                    dp_T0[res] = dp_T0[arg2];
4726                }
4727#endif /* _TIGHT_ */
4728#ifdef _NTIGHT_
4729                FOR_0_LE_l_LT_pk
4730                TRES_INC = TARG1_INC | TARG2_INC;
4731#endif /* _NTIGHT_ */
4732#else
4733#if !defined(_ZOS_) /* BREAK_ZOS */
4734                if (dp_T0[arg] >= 0)
4735                    FOR_0_LE_l_LT_pk
4736                    TRES_INC = TARG1_INC;
4737                else
4738                    FOR_0_LE_l_LT_pk
4739                    TRES_INC = TARG2_INC;
4740#endif
4741
4742                if (dp_T0[arg] >= 0) {
4743                    if (coval < 0.0)
4744                        MINDEC(ret_c,2);
4745                    dp_T0[res] = dp_T0[arg1];
4746                } else {
4747                    if (coval >= 0.0)
4748                        MINDEC(ret_c,2);
4749                    dp_T0[res] = dp_T0[arg2];
4750                }
4751#endif
4752#endif /* ALL_TOGETHER_AGAIN */
4753                break;
4754
4755                /*--------------------------------------------------------------------------*/
4756            case cond_assign_s:                                  /* cond_assign_s */
4757                arg   = get_locint_f();
4758                arg1  = get_locint_f();
4759                res   = get_locint_f();
4760#if !defined(_NTIGHT_)
4761                coval = 
4762#endif
4763                get_val_f();
4764
4765                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
4766
4767                /* olvo 980924 changed order to allow reflexive ops */
4768#if defined(_INDO_)
4769#if defined(_INDOPRO_)
4770#ifdef _TIGHT_
4771                if (dp_T0[arg] > 0)
4772                    copy_index_domain(res, arg1, ind_dom);
4773#else
4774                merge_2_index_domains(res, arg1, ind_dom);
4775#endif
4776#endif
4777#if defined(_NONLIND_)
4778                arg_index[res] = arg_index[arg1];               
4779#endif
4780#else
4781#if !defined(_ZOS_) /* BREAK_ZOS */
4782                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
4783                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
4784#endif /* ALL_TOGETHER_AGAIN */
4785
4786#ifdef _INT_FOR_
4787#ifdef _TIGHT_
4788                coval = get_val_f();
4789
4790                if (dp_T0[arg] > 0)
4791#endif /* _TIGHT_ */
4792                    FOR_0_LE_l_LT_pk
4793                    TRES_INC = TARG1_INC;
4794
4795#ifdef _TIGHT_
4796                if (dp_T0[arg] > 0) {
4797                    if (coval <= 0.0)
4798                        MINDEC(ret_c,2);
4799                    dp_T0[res] = dp_T0[arg1];
4800                } else
4801                    if (dp_T0[arg] == 0)
4802                        MINDEC(ret_c,0);
4803#endif /* _TIGHT_ */
4804#else
4805#if !defined(_ZOS_) /* BREAK_ZOS */
4806                if (dp_T0[arg] > 0)
4807                    FOR_0_LE_l_LT_pk
4808                    TRES_INC = TARG1_INC;
4809#endif
4810                if (dp_T0[arg] > 0) {
4811                    if (coval <= 0.0)
4812                        MINDEC(ret_c,2);
4813                    dp_T0[res] = dp_T0[arg1];
4814                } else
4815                    if (dp_T0[arg] == 0)
4816                        MINDEC(ret_c,0);
4817#endif
4818#endif /* ALL_TOGETHER_AGAIN */
4819                break;
4820
4821
4822            case cond_eq_assign_s:                                  /* cond_eq_assign_s */
4823                arg   = get_locint_f();
4824                arg1  = get_locint_f();
4825                res   = get_locint_f();
4826#if !defined(_NTIGHT_)
4827                coval = 
4828#endif
4829                get_val_f();
4830
4831                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
4832
4833                /* olvo 980924 changed order to allow reflexive ops */
4834#if defined(_INDO_)
4835#if defined(_INDOPRO_)
4836#ifdef _TIGHT_
4837                if (dp_T0[arg] >= 0)
4838                    copy_index_domain(res, arg1, ind_dom);
4839#else
4840                merge_2_index_domains(res, arg1, ind_dom);
4841#endif
4842#endif
4843#if defined(_NONLIND_)
4844                arg_index[res] = arg_index[arg1];               
4845#endif
4846#else
4847#if !defined(_ZOS_) /* BREAK_ZOS */
4848                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
4849                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
4850#endif /* ALL_TOGETHER_AGAIN */
4851
4852#ifdef _INT_FOR_
4853#ifdef _TIGHT_
4854                coval = get_val_f();
4855
4856                if (dp_T0[arg] >= 0)
4857#endif /* _TIGHT_ */
4858                    FOR_0_LE_l_LT_pk
4859                    TRES_INC = TARG1_INC;
4860
4861#ifdef _TIGHT_
4862                if (dp_T0[arg] >= 0) {
4863                    if (coval < 0.0)
4864                        MINDEC(ret_c,2);
4865                    dp_T0[res] = dp_T0[arg1];
4866                }
4867#endif /* _TIGHT_ */
4868#else
4869#if !defined(_ZOS_) /* BREAK_ZOS */
4870                if (dp_T0[arg] >= 0)
4871                    FOR_0_LE_l_LT_pk
4872                    TRES_INC = TARG1_INC;
4873#endif
4874                if (dp_T0[arg] >= 0) {
4875                    if (coval < 0.0)
4876                        MINDEC(ret_c,2);
4877                    dp_T0[res] = dp_T0[arg1];
4878                }
4879#endif
4880#endif /* ALL_TOGETHER_AGAIN */
4881                break;
4882
4883                /*--------------------------------------------------------------------------*/
4884                /* NEW CONDITIONALS */
4885                /*--------------------------------------------------------------------------*/
4886#if defined(ADOLC_ADVANCED_BRANCHING)
4887            case neq_a_a:
4888            case eq_a_a:
4889            case le_a_a:
4890            case ge_a_a:
4891            case lt_a_a:
4892            case gt_a_a:
4893            case neq_a_p:
4894            case eq_a_p:
4895            case le_a_p:
4896            case ge_a_p:
4897            case lt_a_p:
4898            case gt_a_p:
4899#if !defined(_NTIGHT_)
4900                coval = 
4901#endif
4902                get_val_f();
4903                arg = get_locint_f();
4904                arg1 = get_locint_f();
4905                res = get_locint_f();
4906#if !defined(_NTIGHT_)
4907                {
4908                    revreal retval = -1;
4909                    const char* opname = "";
4910                    switch (operation) {
4911                    case neq_a_a:
4912                        retval = (revreal)(dp_T0[arg] != dp_T0[arg1]);
4913                        opname = "neq_a_a";
4914                        break;
4915                    case eq_a_a:
4916                        retval = (revreal)(dp_T0[arg] == dp_T0[arg1]);
4917                        opname = "eq_a_a";
4918                        break;
4919                    case ge_a_a:
4920                        retval = (revreal)(dp_T0[arg] >= dp_T0[arg1]);
4921                        opname = "ge_a_a";
4922                        break;
4923                    case le_a_a:
4924                        retval = (revreal)(dp_T0[arg] <= dp_T0[arg1]);
4925                        opname = "le_a_a";
4926                        break;
4927                    case gt_a_a:
4928                        retval = (revreal)(dp_T0[arg] > dp_T0[arg1]);
4929                        opname = "gt_a_a";
4930                        break;
4931                    case lt_a_a:
4932                        retval = (revreal)(dp_T0[arg] < dp_T0[arg1]);
4933                        opname = "lt_a_a";
4934                        break;
4935                    case neq_a_p:
4936                        retval = (revreal)(dp_T0[arg] != ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1]);
4937                        opname = "neq_a_p";
4938                        break;
4939                    case eq_a_p:
4940                        retval = (revreal)(dp_T0[arg] == ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1]);
4941                        opname = "eq_a_p";
4942                        break;
4943                    case ge_a_p:
4944                        retval = (revreal)(dp_T0[arg] >= ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1]);
4945                        opname = "ge_a_p";
4946                        break;
4947                    case le_a_p:
4948                        retval = (revreal)(dp_T0[arg] <= ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1]);
4949                        opname = "le_a_p";
4950                        break;
4951                    case gt_a_p:
4952                        retval = (revreal)(dp_T0[arg] > ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1]);
4953                        opname = "gt_a_p";
4954                        break;
4955                    case lt_a_p:
4956                        retval = (revreal)(dp_T0[arg] < ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1]);
4957                        opname = "lt_a_p";
4958                        break;
4959                    }
4960                    if (retval != coval && ADOLC_GLOBAL_TAPE_VARS.branchSwitchWarning)
4961                        fprintf(DIAG_OUT,
4962                                "ADOL-C Warning: Branch switch detected in comparison "
4963                                "(operator %s).\n"
4964                                "Results may be unpredictable! Retaping recommended!\n",opname);
4965                    IF_KEEP_WRITE_TAYLOR(res,keep,k,p);
4966                    dp_T0[res] = retval;
4967                }
4968#endif
4969#if defined(_INDO_)
4970#if defined(_INDOPRO_)
4971                ind_dom[res][0]=0;
4972#endif
4973#if defined(_NONLIND_)
4974                fod[opind].entry = maxopind+2;
4975                fod[opind].left = NULL;
4976                fod[opind].right = NULL;
4977                arg_index[res] = opind++;
4978#endif
4979#else
4980#if !defined(_ZOS_) /* BREAK_ZOS */
4981                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
4982
4983                FOR_0_LE_l_LT_pk
4984                TRES_INC = 0;
4985#endif
4986#endif /* ALL_TOGETHER_AGAIN */
4987
4988                break;
4989#endif /* ADVANCED_BRANCHING */
4990
4991                /*--------------------------------------------------------------------------*/
4992            case subscript:
4993#if !defined(_NTIGHT_)
4994                coval = 
4995#endif
4996                get_val_f();
4997                arg = get_locint_f();
4998                res = get_locint_f();
4999                {
5000#if !defined(_NTIGHT_)
5001                    size_t idx, numvar = (size_t)trunc(fabs(coval));
5002                    locint vectorloc;
5003                    vectorloc = 
5004#endif
5005                    get_locint_f();
5006#if !defined(_NTIGHT_)
5007                    idx = (size_t)trunc(fabs(dp_T0[arg]));
5008                    if (idx >= numvar)
5009                        fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting n=%zu, idx=%zu\n", numvar, idx);
5010                    arg1 = vectorloc+idx;
5011                    IF_KEEP_WRITE_TAYLOR(res,keep,k,p);
5012                    dp_T0[res] = dp_T0[arg1];
5013#if defined(_INDO_)
5014#if defined(_INDOPRO_)
5015                    copy_index_domain(res, arg1, ind_dom);
5016#endif
5017#if defined(_NONLIND_)
5018                    arg_index[res] = arg_index[arg1];
5019#endif
5020#else
5021#if !defined(_ZOS_) /* BREAK_ZOS */
5022                    ASSIGN_T(Targ1,TAYLOR_BUFFER[arg1])
5023                    ASSIGN_T(Tres,TAYLOR_BUFFER[res])
5024
5025                    FOR_0_LE_l_LT_pk
5026                    TRES_INC = TARG1_INC;
5027#endif
5028#endif
5029#else
5030                    fprintf(DIAG_OUT, "ADOL-C error: active subscripting does not work in safe mode, please use tight mode\n");
5031                    adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5032#endif /* ALL_TOGETHER_AGAIN */
5033                }
5034                break;
5035
5036            case subscript_ref:
5037#if !defined(_NTIGHT_)
5038                coval = 
5039#endif
5040                get_val_f();
5041                arg = get_locint_f();
5042                res = get_locint_f();
5043                {
5044#if !defined(_NTIGHT_)
5045                    size_t idx, numvar = (size_t)trunc(fabs(coval));
5046                    locint vectorloc;
5047                    vectorloc = 
5048#endif
5049                    get_locint_f();
5050#if !defined(_NTIGHT_)
5051                    idx = (size_t)trunc(fabs(dp_T0[arg]));
5052                    if (idx >= numvar)
5053                        fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting (ref) n=%zu, idx=%zu\n", numvar, idx);
5054                    arg1 = vectorloc+idx;
5055                    IF_KEEP_WRITE_TAYLOR(res,keep,k,p);
5056                    dp_T0[res] = arg1;
5057#else
5058                    fprintf(DIAG_OUT, "ADOL-C error: active subscripting does not work in safe mode, please use tight mode\n");
5059                    adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5060#endif
5061                }
5062                break;
5063
5064            case ref_copyout:
5065                arg = get_locint_f();
5066                res = get_locint_f();
5067#if !defined(_NTIGHT_)
5068                arg1 = (size_t)trunc(fabs(dp_T0[arg]));
5069                IF_KEEP_WRITE_TAYLOR(res,keep,k,p);
5070                dp_T0[res] = dp_T0[arg1];
5071#if defined(_INDO_)
5072#if defined(_INDOPRO_)
5073                copy_index_domain(res, arg1, ind_dom);
5074#endif
5075#if defined(_NONLIND_)
5076                arg_index[res] = arg_index[arg1];
5077#endif
5078#else
5079#if !defined(_ZOS_) /* BREAK_ZOS */
5080                ASSIGN_T(Targ1,TAYLOR_BUFFER[arg1])
5081                ASSIGN_T(Tres,TAYLOR_BUFFER[res])
5082
5083                FOR_0_LE_l_LT_pk
5084                TRES_INC = TARG1_INC;
5085#endif
5086#endif
5087#else
5088                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5089                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5090#endif /* ALL_TOGETHER_AGAIN */
5091                break;
5092
5093            case ref_incr_a:
5094                arg = get_locint_f();
5095#if !defined(_NTIGHT_)
5096                arg1 = (size_t)trunc(fabs(dp_T0[arg]));
5097                IF_KEEP_WRITE_TAYLOR(arg1,keep,k,p);
5098                dp_T0[arg1]++;
5099#else
5100                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5101                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5102#endif
5103                break;
5104
5105            case ref_decr_a:
5106                arg = get_locint_f();
5107#if !defined(_NTIGHT_)
5108                arg1 = (size_t)trunc(fabs(dp_T0[arg]));
5109                IF_KEEP_WRITE_TAYLOR(arg1,keep,k,p);
5110                dp_T0[arg1]--;
5111#else
5112                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5113                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5114#endif
5115                break;
5116
5117            case ref_assign_d:
5118                arg = get_locint_f();
5119#if !defined(_NTIGHT_)
5120                coval = 
5121#endif
5122                get_val_f();
5123               
5124#if !defined(_NTIGHT_)
5125                arg1 = (size_t)trunc(fabs(dp_T0[arg]));
5126                IF_KEEP_WRITE_TAYLOR(arg1,keep,k,p)
5127                dp_T0[arg1] = coval;
5128#if defined(_INDO_)
5129#if defined(_INDOPRO_)
5130                ind_dom[arg1][0] = 0;
5131#endif
5132#if defined(_NONLIND_)
5133                fod[opind].entry = maxopind+2;
5134                fod[opind].left = NULL;
5135                fod[opind].right = NULL;
5136                arg_index[arg1] = opind++;
5137#endif
5138#else
5139#if !defined(_ZOS_)
5140                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
5141
5142                FOR_0_LE_l_LT_pk
5143                TARG1_INC = 0;
5144#endif
5145#endif
5146#else
5147                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5148                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5149#endif
5150                break;
5151
5152            case ref_assign_p:
5153                arg = get_locint_f();
5154                res = get_locint_f();
5155#if !defined(_NTIGHT_)
5156                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[res];
5157#endif
5158               
5159#if !defined(_NTIGHT_)
5160                arg1 = (size_t)trunc(fabs(dp_T0[arg]));
5161                IF_KEEP_WRITE_TAYLOR(arg1,keep,k,p)
5162                dp_T0[arg1] = coval;
5163#if defined(_INDO_)
5164#if defined(_INDOPRO_)
5165                ind_dom[arg1][0] = 0;
5166#endif
5167#if defined(_NONLIND_)
5168                fod[opind].entry = maxopind+2;
5169                fod[opind].left = NULL;
5170                fod[opind].right = NULL;
5171                arg_index[arg1] = opind++;
5172#endif
5173#else
5174#if !defined(_ZOS_)
5175                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
5176
5177                FOR_0_LE_l_LT_pk
5178                TARG1_INC = 0;
5179#endif
5180#endif
5181#else
5182                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5183                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5184#endif
5185                break;
5186
5187            case ref_assign_d_zero:
5188                arg = get_locint_f();
5189
5190#if !defined(_NTIGHT_)
5191                arg1 = (size_t)trunc(fabs(dp_T0[arg]));
5192                IF_KEEP_WRITE_TAYLOR(arg1,keep,k,p)
5193                dp_T0[arg1] = 0.0;
5194#if defined(_INDO_)
5195#if defined(_INDOPRO_)
5196                ind_dom[arg1][0] = 0;
5197#endif
5198#if defined(_NONLIND_)
5199                fod[opind].entry = maxopind+2;
5200                fod[opind].left = NULL;
5201                fod[opind].right = NULL;
5202                arg_index[arg1] = opind++;
5203#endif
5204#else
5205#if !defined(_ZOS_)
5206                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
5207
5208                FOR_0_LE_l_LT_pk
5209                TARG1_INC = 0;
5210#endif
5211#endif
5212#else
5213                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5214                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5215#endif
5216                break;
5217
5218            case ref_assign_d_one:
5219                arg = get_locint_f();
5220
5221#if !defined(_NTIGHT_)
5222                arg1 = (size_t)trunc(fabs(dp_T0[arg]));
5223                IF_KEEP_WRITE_TAYLOR(arg1,keep,k,p)
5224                dp_T0[arg1] = 1.0;
5225#if defined(_INDO_)
5226#if defined(_INDOPRO_)
5227                ind_dom[arg1][0] = 0;
5228#endif
5229#if defined(_NONLIND_)
5230                fod[opind].entry = maxopind+2;
5231                fod[opind].left = NULL;
5232                fod[opind].right = NULL;
5233                arg_index[arg1] = opind++;
5234#endif
5235#else
5236#if !defined(_ZOS_)
5237                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
5238
5239                FOR_0_LE_l_LT_pk
5240                TARG1_INC = 0;
5241#endif
5242#endif
5243#else
5244                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5245                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5246#endif
5247                break;
5248
5249            case ref_assign_a:           /* assign an adouble variable an    assign_a */
5250                /* adouble value. (=) */
5251                arg = get_locint_f();
5252                res = get_locint_f();
5253
5254#if !defined(_NTIGHT_)
5255                arg1 = (size_t)trunc(fabs(dp_T0[res]));
5256                IF_KEEP_WRITE_TAYLOR(arg1,keep,k,p)
5257                dp_T0[arg1] = dp_T0[arg];
5258#if defined(_INDO_)
5259#if defined(_INDOPRO_)
5260                copy_index_domain(arg1, arg, ind_dom);
5261#endif
5262#if defined(_NONLIND_)
5263                arg_index[arg1] = arg_index[arg];
5264#endif
5265#else
5266#if !defined(_ZOS_) /* BREAK_ZOS */
5267                ASSIGN_T(Targ,TAYLOR_BUFFER[arg])
5268                ASSIGN_T(Targ1,TAYLOR_BUFFER[arg1])
5269
5270                FOR_0_LE_l_LT_pk
5271                TARG1_INC = TARG_INC;
5272#endif
5273#endif
5274#else
5275                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5276                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5277#endif /* ALL_TOGETHER_AGAIN */
5278                break;
5279
5280            case ref_assign_ind:       /* assign an adouble variable an    assign_ind */
5281                /* independent double value (<<=) */
5282                arg = get_locint_f();
5283
5284
5285#if !defined(_NTIGHT_)
5286                res = (size_t)trunc(fabs(dp_T0[arg]));
5287                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
5288                dp_T0[res] = basepoint[indexi];
5289#if defined(_INDO_)
5290#if defined(_INDOPRO_)
5291                ind_dom[res][0] = 1;
5292                ind_dom[res][2] = indexi;
5293#endif
5294#if defined(_NONLIND_)
5295                fod[opind].entry = indexi;
5296                fod[opind].left = NULL;
5297                fod[opind].right = NULL;
5298                arg_index[res] = opind++;
5299#endif
5300#else
5301#if !defined(_ZOS_) /* BREAK_ZOS */
5302                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
5303
5304#ifdef _INT_FOR_
5305                FOR_0_LE_l_LT_p
5306                TRES_INC = ARGUMENT(indexi,l,i);
5307#else
5308                FOR_0_LE_l_LT_p
5309                FOR_0_LE_i_LT_k
5310                TRES_INC = ARGUMENT(indexi,l,i);
5311#endif
5312#endif
5313#endif
5314#else
5315                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5316                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5317#endif /* ALL_TOGETHER_AGAIN */
5318                ++indexi;
5319                break;
5320
5321            case ref_eq_plus_d:            /* Add a floating point to an    eq_plus_d */
5322                /* adouble. (+=) */
5323                arg  = get_locint_f();
5324#if !defined(_NTIGHT_)
5325                coval = 
5326#endif
5327                get_val_f();
5328
5329
5330#if !defined(_NTIGHT_)
5331                res = (size_t)trunc(fabs(dp_T0[arg]));
5332                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
5333                dp_T0[res] += coval;
5334#else
5335                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5336                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5337#endif /* !_NTIGHT_ */
5338                break;
5339
5340                /*--------------------------------------------------------------------------*/
5341            case ref_eq_plus_p:            /* Add a floating point to an    eq_plus_p */
5342                /* adouble. (+=) */
5343                arg  = get_locint_f();
5344                arg1  = get_locint_f();
5345#if !defined(_NTIGHT_)
5346                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
5347#endif
5348
5349#if !defined(_NTIGHT_)
5350                res = (size_t)trunc(fabs(dp_T0[arg]));
5351                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
5352                dp_T0[res] += coval;
5353#else
5354                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5355                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5356#endif /* !_NTIGHT_ */
5357                break;
5358
5359                /*--------------------------------------------------------------------------*/
5360            case ref_eq_plus_a:             /* Add an adouble to another    eq_plus_a */
5361                /* adouble. (+=) */
5362                arg = get_locint_f();
5363                arg1 = get_locint_f();
5364
5365#if !defined(_NTIGHT_)
5366                res = (size_t)trunc(fabs(dp_T0[arg1]));
5367                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
5368                dp_T0[res] += dp_T0[arg];
5369#if defined(_INDO_)
5370#if defined(_INDOPRO_)
5371                merge_2_index_domains(res, arg, ind_dom);
5372#endif
5373#if defined(_NONLIND_)
5374                fod[opind].entry = maxopind+2;
5375                fod[opind].left = &fod[arg_index[res]];
5376                fod[opind].right = &fod[arg_index[arg]];
5377                arg_index[res] = opind++;
5378#endif
5379#else
5380#if !defined(_ZOS_) /* BREAK_ZOS */
5381                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
5382                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
5383
5384#ifdef _INT_FOR_
5385                FOR_0_LE_l_LT_pk
5386                TRES_INC |= TARG_INC;
5387#else
5388                FOR_0_LE_l_LT_pk
5389                TRES_INC += TARG_INC;
5390#endif
5391#endif
5392#endif
5393#else
5394                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5395                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5396#endif /* ALL_TOGETHER_AGAIN */
5397                break;
5398
5399            case ref_eq_min_d:       /* Subtract a floating point from an    eq_min_d */
5400                /* adouble. (-=) */
5401                arg = get_locint_f();
5402#if !defined(_NTIGHT_)
5403                coval = 
5404#endif
5405                get_val_f();
5406
5407#if !defined(_NTIGHT_)
5408                res = (size_t)trunc(fabs(dp_T0[arg]));
5409                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
5410                dp_T0[res] -= coval;
5411#else
5412                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5413                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5414#endif /* !_NTIGHT_ */
5415                break;
5416
5417            case ref_eq_min_p:       /* Subtract a floating point from an    eq_min_p */
5418                /* adouble. (-=) */
5419                arg = get_locint_f();
5420                arg1 = get_locint_f();
5421#if !defined(_NTIGHT_)
5422                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
5423#endif
5424
5425#if !defined(_NTIGHT_)
5426                res = (size_t)trunc(fabs(dp_T0[arg]));
5427                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
5428                dp_T0[res] -= coval;
5429#else
5430                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5431                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5432#endif /* !_NTIGHT_ */
5433                break;
5434
5435                /*--------------------------------------------------------------------------*/
5436            case ref_eq_min_a:        /* Subtract an adouble from another    eq_min_a */
5437                /* adouble. (-=) */
5438                arg = get_locint_f();
5439                arg1 = get_locint_f();
5440
5441#if !defined(_NTIGHT_)
5442                res = (size_t)trunc(fabs(dp_T0[arg1]));
5443                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
5444                dp_T0[res] -= dp_T0[arg];
5445#if defined(_INDO_)
5446#if defined(_INDOPRO_)
5447                merge_2_index_domains(res, arg, ind_dom);
5448#endif
5449#if defined(_NONLIND_)
5450                fod[opind].entry = maxopind+2;
5451                fod[opind].left = &fod[arg_index[res]];
5452                fod[opind].right = &fod[arg_index[arg]];
5453                arg_index[res] = opind++;
5454#endif
5455#else
5456#if !defined(_ZOS_) /* BREAK_ZOS */
5457                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
5458                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
5459
5460#ifdef _INT_FOR_
5461                FOR_0_LE_l_LT_pk
5462                TRES_INC |= TARG_INC;
5463#else
5464                FOR_0_LE_l_LT_pk
5465                TRES_INC -= TARG_INC;
5466#endif
5467#endif
5468#endif
5469#else
5470                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5471                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5472#endif /* ALL_TOGETHER_AGAIN */
5473                break;
5474
5475            case ref_eq_mult_d:              /* Multiply an adouble by a    eq_mult_d */
5476                /* flaoting point. (*=) */
5477                arg = get_locint_f();
5478#if !defined(_NTIGHT_)
5479                coval = 
5480#endif
5481                get_val_f();
5482
5483#if !defined(_NTIGHT_)
5484                res = (size_t)trunc(fabs(dp_T0[arg]));
5485                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
5486                dp_T0[res] *= coval;
5487#if !defined(_INDO_)
5488#if !defined(_ZOS_) /* BREAK_ZOS */
5489#if !defined( _INT_FOR_)
5490
5491                FOR_0_LE_l_LT_pk
5492                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
5493
5494                FOR_0_LE_l_LT_pk
5495                TRES_INC *= coval;
5496#endif
5497#endif
5498#endif
5499#else
5500                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5501                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5502#endif /* ALL_TOGETHER_AGAIN */
5503                break;
5504
5505            case ref_eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
5506                /* flaoting point. (*=) */
5507                arg = get_locint_f();
5508                arg1 = get_locint_f();
5509#if !defined(_NTIGHT_)
5510                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
5511#endif
5512
5513#if !defined(_NTIGHT_)
5514                res = (size_t)trunc(fabs(dp_T0[arg]));
5515                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
5516                dp_T0[res] *= coval;
5517#if !defined(_INDO_)
5518#if !defined(_ZOS_) /* BREAK_ZOS */
5519#if !defined( _INT_FOR_)
5520
5521                FOR_0_LE_l_LT_pk
5522                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
5523
5524                FOR_0_LE_l_LT_pk
5525                TRES_INC *= coval;
5526#endif
5527#endif
5528#endif
5529#else
5530                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5531                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5532#endif /* ALL_TOGETHER_AGAIN */
5533                break;
5534
5535            case ref_eq_mult_a:       /* Multiply one adouble by another    eq_mult_a */
5536                /* (*=) */
5537                arg = get_locint_f();
5538                arg1 = get_locint_f();
5539
5540#if !defined(_NTIGHT_)
5541                res = (size_t)trunc(fabs(dp_T0[arg1]));
5542                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
5543#if defined(_INDO_)
5544#if defined(_INDOPRO_)
5545                merge_2_index_domains(res, arg, ind_dom);
5546#endif
5547#if defined(_NONLIND_)
5548                fod[opind].entry = maxopind+2;
5549                fod[opind].left = &fod[arg_index[res]];
5550                fod[opind].right = &fod[arg_index[arg]];
5551                traverse_unary(&fod[arg_index[res]], nonl_dom, &fod[arg_index[arg]], indcheck+1,maxopind+2);
5552                traverse_unary(&fod[arg_index[arg]], nonl_dom, &fod[arg_index[res]], indcheck+1,maxopind+2);
5553                arg_index[res] = opind++;
5554#endif
5555#if defined(_NONLIND_OLD_)
5556                extend_nonlinearity_domain_binary(res, arg, ind_dom, nonl_dom);
5557#endif
5558#else
5559#if !defined(_ZOS_) /* BREAK_ZOS */
5560                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
5561                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
5562
5563                INC_pk_1(Tres)
5564                INC_pk_1(Targ)
5565
5566#ifdef _INT_FOR_
5567                FOR_p_GT_l_GE_0
5568                TRES_FODEC |= TARG_DEC;
5569#else
5570                FOR_p_GT_l_GE_0
5571                FOR_k_GT_i_GE_0
5572                { TRES_FODEC = dp_T0[res]*TARG_DEC +
5573                               TRES*dp_T0[arg];
5574                  DEC_TRES_FO
5575#ifdef _HIGHER_ORDER_
5576                  TresOP = Tres-i;
5577                  TargOP = Targ;
5578
5579                  for (j=0;j<i;j++)
5580                  *Tres += (*TresOP++) * (*TargOP--);
5581                  Tres--;
5582#endif /* _HIGHER_ORDER_ */
5583                }
5584#endif
5585#endif
5586#endif
5587                dp_T0[res] *= dp_T0[arg];
5588#else
5589                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5590                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5591#endif /* !_NTIGHT_ */
5592                break;
5593
5594            case vec_copy:
5595                res = get_locint_f();
5596                arg = get_locint_f();
5597                size = get_locint_f();
5598
5599                for(qq=0;qq<size;qq++) {
5600                    IF_KEEP_WRITE_TAYLOR(res+qq,keep,k,p);
5601#if !defined(_NTIGHT_)
5602                    dp_T0[res+qq] = dp_T0[arg+qq];
5603#endif /* !_NTIGHT_ */
5604
5605#if defined(_INDO_)
5606#if defined(_INDOPRO_)
5607                    copy_index_domain(res+qq, arg+qq, ind_dom);
5608#endif
5609#if defined(_NONLIND_)
5610                    arg_index[res+qq] = arg_index[arg+qq];
5611#endif
5612#else
5613#if !defined(_ZOS_) /* BREAK_ZOS */
5614                    ASSIGN_T(Targ,TAYLOR_BUFFER[arg+qq])
5615                    ASSIGN_T(Tres,TAYLOR_BUFFER[res+qq])
5616
5617                    FOR_0_LE_l_LT_pk
5618                    TRES_INC = TARG_INC;
5619#endif
5620#endif /* ALL_TOGETHER_AGAIN */
5621                }
5622
5623                break;
5624
5625            case vec_dot:
5626                res = get_locint_f();
5627                arg1 = get_locint_f();
5628                arg2 = get_locint_f();
5629                size = get_locint_f();
5630                IF_KEEP_WRITE_TAYLOR(res,keep,k,p);
5631#if !defined(_NTIGHT_)
5632                dp_T0[res] = 0;
5633#endif
5634#if defined(_INDO_)
5635#if defined(_INDOPRO_)
5636                ind_dom[res][0]=0;
5637#endif
5638#if defined(_NONLIND_)
5639                fod[opind].entry = maxopind+2;
5640                fod[opind].left = NULL;
5641                fod[opind].right = NULL;
5642                arg_index[res] = opind++;               
5643#endif
5644#else
5645#if !defined(_ZOS_) /* BREAK_ZOS */
5646                ASSIGN_T(Tres, TAYLOR_BUFFER[res])
5647
5648                FOR_0_LE_l_LT_pk
5649                TRES_INC = 0;
5650#endif
5651#endif /* ALL_TOGETHER_AGAIN */
5652                for(qq=0;qq<size;qq++) {
5653#if defined(_INDO_)
5654#if defined(_INDOPRO_)
5655                merge_3_index_domains(res, arg1+qq, arg2+qq, ind_dom);
5656#endif
5657#if defined(_NONLIND_)
5658                // operation: v = v+u*w
5659                // first step: z = u*w, index domains
5660                fod[opind].entry = maxopind+2;
5661                fod[opind].left = &fod[arg_index[arg1+qq]];
5662                fod[opind].right = &fod[arg_index[arg2+qq]];
5663                // first step: z = u*w,
5664                traverse_unary(&fod[arg_index[arg1+qq]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
5665                traverse_unary(&fod[arg_index[arg2+qq]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
5666                opind++;
5667                // second step: v = v+z, index domains
5668                fod[opind].entry = maxopind+2;
5669                fod[opind].left = &fod[arg_index[res]];
5670                fod[opind].right = &fod[opind-1];
5671                // second step: v = v+z,
5672                arg_index[res] = opind++;
5673#endif
5674#if defined(_NONLIND_OLD_)
5675                extend_nonlinearity_domain_binary(arg1+qq, arg2+qq, ind_dom, nonl_dom);
5676#endif
5677#else
5678#if !defined(_ZOS_) /* BREAK_ZOS */
5679                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
5680                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1+qq])
5681                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2+qq])
5682
5683#ifdef _INT_FOR_
5684                FOR_0_LE_l_LT_p
5685                TRES_FOINC |= TARG2_INC | TARG1_INC;
5686#else
5687                /* olvo 980915 now in reverse order to allow x = x*x etc. */
5688                INC_pk_1(Tres)
5689                INC_pk_1(Targ1)
5690                INC_pk_1(Targ2)
5691
5692                FOR_p_GT_l_GE_0
5693                FOR_k_GT_i_GE_0
5694                { TRES_FODEC += dp_T0[arg1+qq]*TARG2_DEC +
5695                                TARG1_DEC*dp_T0[arg2+qq];
5696                  DEC_TRES_FO
5697#if defined(_HIGHER_ORDER_)
5698                  Targ1OP = Targ1-i+1;
5699                  Targ2OP = Targ2;
5700
5701                  for (j=0;j<i;j++)
5702                  *Tres += (*Targ1OP++) * (*Targ2OP--);
5703                  Tres--;
5704#endif /* _HIGHER_ORDER_ */
5705                }
5706#endif
5707#endif
5708#endif /* ALL_TOGETHER_AGAIN */
5709#if !defined(_NTIGHT_)
5710                dp_T0[res] += dp_T0[arg1+qq] *  dp_T0[arg2+qq];
5711#endif /* !_NTIGHT_ */
5712                }
5713                break;
5714
5715            case vec_axpy:
5716                res = get_locint_f();
5717                arg = get_locint_f();
5718                arg1 = get_locint_f();
5719                arg2 = get_locint_f();
5720                size = get_locint_f();
5721               
5722                for(qq=0;qq<size;qq++) {
5723                    IF_KEEP_WRITE_TAYLOR(res+qq,keep,k,p);
5724#if defined(_INDO_)
5725#if defined(_INDOPRO_)
5726                combine_2_index_domains(res+qq, arg, arg1+qq, ind_dom);
5727                merge_2_index_domains(res+qq, arg2+qq, ind_dom);
5728#endif
5729#if defined(_NONLIND_)
5730                // operation: v = u*w + y
5731                // first step: z = u*w, index domains
5732                fod[opind].entry = maxopind+2;
5733                fod[opind].left = &fod[arg_index[arg]];
5734                fod[opind].right = &fod[arg_index[arg1+qq]];
5735                // first step: z = u*w,
5736                traverse_unary(&fod[arg_index[arg]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
5737                traverse_unary(&fod[arg_index[arg1+qq]], nonl_dom, &fod[opind], indcheck+1,maxopind+2);
5738                opind++;
5739                // second step: v = z+y, index domains
5740                fod[opind].entry = maxopind+2;
5741                fod[opind].left = &fod[opind-1];
5742                fod[opind].right = &fod[arg_index[arg2+qq]];
5743                // second step: v = v+z,
5744                arg_index[res+qq] = opind++;
5745#endif
5746#if defined(_NONLIND_OLD_)
5747                extend_nonlinearity_domain_binary(arg, arg1+qq, ind_dom, nonl_dom);
5748#endif
5749#else
5750#if !defined(_ZOS_) /* BREAK_ZOS */
5751                ASSIGN_T(Targ, TAYLOR_BUFFER[arg])
5752                ASSIGN_T(Tres,  TAYLOR_BUFFER[res+qq])
5753                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1+qq])
5754                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2+qq])
5755#ifdef _INT_FOR_
5756                FOR_0_LE_l_LT_p
5757                TRES_FOINC = TARG2_INC | TARG1_INC | TARG_INC;
5758#else
5759                INC_pk_1(Tres)
5760                INC_pk_1(Targ)
5761                INC_pk_1(Targ1)
5762                INC_pk_1(Targ2)
5763                FOR_p_GT_l_GE_0
5764                FOR_k_GT_i_GE_0
5765                { 
5766                    TRES_FODEC = dp_T0[arg] * TARG1_DEC + TARG_DEC * dp_T0[arg1+qq] + TARG2_DEC;
5767                    DEC_TRES_FO
5768#if defined(_HIGHER_ORDER_)
5769                    Targ1OP = Targ - i + 1;
5770                    Targ2OP = Targ1;
5771
5772                    for (j=0;j<i;j++) {
5773                        *Tres += (*Targ1OP++) * (*Targ2OP--);
5774                    }
5775                    Tres--;
5776#endif /* _HIGHER_ORDER_ */
5777                }
5778#endif
5779#endif
5780#endif /* ALL_TOGETHER_AGAIN */
5781#if !defined(_NTIGHT_)
5782                dp_T0[res+qq] = dp_T0[arg] * dp_T0[arg1+qq] + dp_T0[arg2+qq];
5783#endif /* !_NTIGHT_ */
5784
5785                }
5786                break;
5787
5788            case ref_cond_assign:                                      /* cond_assign */
5789                arg   = get_locint_f();
5790                arg1  = get_locint_f();
5791                arg2  = get_locint_f();
5792                { 
5793#if !defined(_NTIGHT_)
5794                    locint ref = 
5795#endif
5796                    get_locint_f();
5797#if !defined(_NTIGHT_)
5798                    coval = 
5799#endif
5800                    get_val_f();
5801#if !defined(_NTIGHT_)
5802                    res   = (size_t)trunc(fabs(dp_T0[ref]));
5803
5804                    IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
5805
5806                /* olvo 980924 changed order to allow reflexive ops */
5807#if defined(_INDO_)
5808                if (dp_T0[arg] > 0) {
5809                    if (coval <= 0.0)
5810                        MINDEC(ret_c,2);
5811                    dp_T0[res] = dp_T0[arg1];
5812
5813#if defined(_INDOPRO_)
5814                    copy_index_domain(res, arg1, ind_dom);
5815#endif
5816#if defined(_NONLIND_)
5817                    arg_index[res] = arg_index[arg1];
5818#endif
5819                } else {
5820                    if (coval > 0.0)
5821                        MINDEC(ret_c,2);
5822                    if (dp_T0[arg] == 0)
5823                        MINDEC(ret_c,0);
5824                    dp_T0[res] = dp_T0[arg2];
5825
5826#if defined(_INDOPRO_)
5827                    copy_index_domain(res, arg2, ind_dom);
5828#endif
5829#if defined(_NONLIND_)
5830                    arg_index[res] = arg_index[arg2];
5831#endif
5832                }
5833#else
5834#if !defined(_ZOS_) /* BREAK_ZOS */
5835                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
5836                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
5837                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
5838#endif /* ALL_TOGETHER_AGAIN */
5839
5840#ifdef _INT_FOR_
5841                coval = get_val_f();
5842
5843                if (dp_T0[arg] > 0)
5844                    FOR_0_LE_l_LT_pk
5845                    TRES_INC = TARG1_INC;
5846                else
5847                    FOR_0_LE_l_LT_pk
5848                    TRES_INC = TARG2_INC;
5849
5850                if (dp_T0[arg] > 0) {
5851                    if (coval <= 0.0)
5852                        MINDEC(ret_c,2);
5853                    dp_T0[res] = dp_T0[arg1];
5854                } else {
5855                    if (coval > 0.0)
5856                        MINDEC(ret_c,2);
5857                    if (dp_T0[arg] == 0)
5858                        MINDEC(ret_c,0);
5859                    dp_T0[res] = dp_T0[arg2];
5860                }
5861                FOR_0_LE_l_LT_pk
5862                TRES_INC = TARG1_INC | TARG2_INC;
5863#else
5864#if !defined(_ZOS_) /* BREAK_ZOS */
5865                if (dp_T0[arg] > 0)
5866                    FOR_0_LE_l_LT_pk
5867                    TRES_INC = TARG1_INC;
5868                else
5869                    FOR_0_LE_l_LT_pk
5870                    TRES_INC = TARG2_INC;
5871#endif
5872
5873                if (dp_T0[arg] > 0) {
5874                    if (coval <= 0.0)
5875                        MINDEC(ret_c,2);
5876                    dp_T0[res] = dp_T0[arg1];
5877                } else {
5878                    if (coval > 0.0)
5879                        MINDEC(ret_c,2);
5880                    if (dp_T0[arg] == 0)
5881                        MINDEC(ret_c,0);
5882                    dp_T0[res] = dp_T0[arg2];
5883                }
5884#endif
5885#endif
5886#else
5887                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5888                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5889#endif /* ALL_TOGETHER_AGAIN */
5890                }
5891                break;
5892
5893            case ref_cond_eq_assign:                                      /* cond_eq_assign */
5894                arg   = get_locint_f();
5895                arg1  = get_locint_f();
5896                arg2  = get_locint_f();
5897                { 
5898#if !defined(_NTIGHT_)
5899                    locint ref = 
5900#endif
5901                    get_locint_f();
5902#if !defined(_NTIGHT_)
5903                    coval = 
5904#endif
5905                    get_val_f();
5906#if !defined(_NTIGHT_)
5907                    res   = (size_t)trunc(fabs(dp_T0[ref]));
5908
5909                    IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
5910
5911                /* olvo 980924 changed order to allow reflexive ops */
5912#if defined(_INDO_)
5913                if (dp_T0[arg] >= 0) {
5914                    if (coval < 0.0)
5915                        MINDEC(ret_c,2);
5916                    dp_T0[res] = dp_T0[arg1];
5917
5918#if defined(_INDOPRO_)
5919                    copy_index_domain(res, arg1, ind_dom);
5920#endif
5921#if defined(_NONLIND_)
5922                    arg_index[res] = arg_index[arg1];
5923#endif
5924                } else {
5925                    if (coval >= 0.0)
5926                        MINDEC(ret_c,2);
5927                    dp_T0[res] = dp_T0[arg2];
5928
5929#if defined(_INDOPRO_)
5930                    copy_index_domain(res, arg2, ind_dom);
5931#endif
5932#if defined(_NONLIND_)
5933                    arg_index[res] = arg_index[arg2];
5934#endif
5935                }
5936#else
5937#if !defined(_ZOS_) /* BREAK_ZOS */
5938                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
5939                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
5940                ASSIGN_T(Targ2, TAYLOR_BUFFER[arg2])
5941#endif /* ALL_TOGETHER_AGAIN */
5942
5943#ifdef _INT_FOR_
5944                coval = get_val_f();
5945
5946                if (dp_T0[arg] >= 0)
5947                    FOR_0_LE_l_LT_pk
5948                    TRES_INC = TARG1_INC;
5949                else
5950                    FOR_0_LE_l_LT_pk
5951                    TRES_INC = TARG2_INC;
5952
5953                if (dp_T0[arg] >= 0) {
5954                    if (coval < 0.0)
5955                        MINDEC(ret_c,2);
5956                    dp_T0[res] = dp_T0[arg1];
5957                } else {
5958                    if (coval >= 0.0)
5959                        MINDEC(ret_c,2);
5960                    dp_T0[res] = dp_T0[arg2];
5961                }
5962                FOR_0_LE_l_LT_pk
5963                TRES_INC = TARG1_INC | TARG2_INC;
5964#else
5965#if !defined(_ZOS_) /* BREAK_ZOS */
5966                if (dp_T0[arg] >= 0)
5967                    FOR_0_LE_l_LT_pk
5968                    TRES_INC = TARG1_INC;
5969                else
5970                    FOR_0_LE_l_LT_pk
5971                    TRES_INC = TARG2_INC;
5972#endif
5973
5974                if (dp_T0[arg] >= 0) {
5975                    if (coval < 0.0)
5976                        MINDEC(ret_c,2);
5977                    dp_T0[res] = dp_T0[arg1];
5978                } else {
5979                    if (coval >= 0.0)
5980                        MINDEC(ret_c,2);
5981                    dp_T0[res] = dp_T0[arg2];
5982                }
5983#endif
5984#endif
5985#else
5986                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
5987                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
5988#endif /* ALL_TOGETHER_AGAIN */
5989                }
5990                break;
5991
5992            case ref_cond_assign_s:                                  /* cond_assign_s */
5993                arg   = get_locint_f();
5994                arg1  = get_locint_f();
5995                arg2   = get_locint_f();
5996#if !defined(_NTIGHT_)
5997                coval = 
5998#endif
5999                get_val_f();
6000
6001#if !defined(_NTIGHT_)
6002                res = (size_t)trunc(fabs(dp_T0[arg2]));
6003                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
6004
6005                /* olvo 980924 changed order to allow reflexive ops */
6006#if defined(_INDO_)
6007                if (dp_T0[arg] > 0) {
6008#if defined(_INDOPRO_)
6009                    copy_index_domain(res, arg1, ind_dom);
6010#endif
6011#if defined(_NONLIND_)
6012                    arg_index[res] = arg_index[arg1];
6013#endif
6014                }
6015#else
6016#if !defined(_ZOS_) /* BREAK_ZOS */
6017                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
6018                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
6019#endif /* ALL_TOGETHER_AGAIN */
6020
6021#ifdef _INT_FOR_
6022                coval = get_val_f();
6023
6024                if (dp_T0[arg] > 0)
6025                    FOR_0_LE_l_LT_pk
6026                    TRES_INC = TARG1_INC;
6027
6028                if (dp_T0[arg] > 0) {
6029                    if (coval <= 0.0)
6030                        MINDEC(ret_c,2);
6031                    dp_T0[res] = dp_T0[arg1];
6032                } else
6033                    if (dp_T0[arg] == 0)
6034                        MINDEC(ret_c,0);
6035#else
6036#if !defined(_ZOS_) /* BREAK_ZOS */
6037                if (dp_T0[arg] > 0)
6038                    FOR_0_LE_l_LT_pk
6039                    TRES_INC = TARG1_INC;
6040#endif
6041                if (dp_T0[arg] > 0) {
6042                    if (coval <= 0.0)
6043                        MINDEC(ret_c,2);
6044                    dp_T0[res] = dp_T0[arg1];
6045                } else
6046                    if (dp_T0[arg] == 0)
6047                        MINDEC(ret_c,0);
6048#endif
6049#endif
6050#else
6051                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
6052                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
6053#endif /* ALL_TOGETHER_AGAIN */
6054                break;
6055
6056            case ref_cond_eq_assign_s:                                  /* cond_eq_assign_s */
6057                arg   = get_locint_f();
6058                arg1  = get_locint_f();
6059                arg2   = get_locint_f();
6060#if !defined(_NTIGHT_)
6061                coval = 
6062#endif
6063                get_val_f();
6064
6065#if !defined(_NTIGHT_)
6066                res = (size_t)trunc(fabs(dp_T0[arg2]));
6067                IF_KEEP_WRITE_TAYLOR(res,keep,k,p)
6068
6069                /* olvo 980924 changed order to allow reflexive ops */
6070#if defined(_INDO_)
6071                if (dp_T0[arg] >= 0) {
6072#if defined(_INDOPRO_)
6073                    copy_index_domain(res, arg1, ind_dom);
6074#endif
6075#if defined(_NONLIND_)
6076                    arg_index[res] = arg_index[arg1];
6077#endif
6078                }
6079#else
6080#if !defined(_ZOS_) /* BREAK_ZOS */
6081                ASSIGN_T(Tres,  TAYLOR_BUFFER[res])
6082                ASSIGN_T(Targ1, TAYLOR_BUFFER[arg1])
6083#endif /* ALL_TOGETHER_AGAIN */
6084
6085#ifdef _INT_FOR_
6086                coval = get_val_f();
6087
6088                if (dp_T0[arg] >= 0)
6089                    FOR_0_LE_l_LT_pk
6090                    TRES_INC = TARG1_INC;
6091
6092                if (dp_T0[arg] >= 0) {
6093                    if (coval < 0.0)
6094                        MINDEC(ret_c,2);
6095                    dp_T0[res] = dp_T0[arg1];
6096                }
6097#else
6098#if !defined(_ZOS_) /* BREAK_ZOS */
6099                if (dp_T0[arg] >= 0)
6100                    FOR_0_LE_l_LT_pk
6101                    TRES_INC = TARG1_INC;
6102#endif
6103                if (dp_T0[arg] >= 0) {
6104                    if (coval < 0.0)
6105                        MINDEC(ret_c,2);
6106                    dp_T0[res] = dp_T0[arg1];
6107                }
6108#endif
6109#endif
6110#else
6111                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
6112                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
6113#endif /* ALL_TOGETHER_AGAIN */
6114                break;
6115
6116                /****************************************************************************/
6117                /*                                                          REMAINING STUFF */
6118
6119                /*--------------------------------------------------------------------------*/
6120            case take_stock_op:                                  /* take_stock_op */
6121                size = get_locint_f();
6122                res  = get_locint_f();
6123#if !defined(_NTIGHT_)
6124                d =
6125#endif
6126                get_val_v_f(size);
6127
6128                for (ls=0;ls<size;ls++) {
6129#if !defined(_NTIGHT_)
6130                    dp_T0[res]=*d;
6131#endif /* !_NTIGHT_ */
6132#if !defined(_INDO_)
6133#if !defined(_ZOS_) /* BREAK_ZOS */
6134                    ASSIGN_T(Tres,TAYLOR_BUFFER[res])
6135
6136                    FOR_0_LE_l_LT_pk
6137                    TRES_INC = 0;
6138
6139#endif /* ALL_TOGETHER_AGAIN */
6140                    res++;
6141#if !defined(_NTIGHT_)
6142                    d++;
6143#endif /* !_NTIGHT_ */
6144#endif
6145                }
6146                break;
6147
6148                /*--------------------------------------------------------------------------*/
6149            case death_not:                                          /* death_not */
6150                arg1=get_locint_f();
6151                arg2=get_locint_f();
6152
6153#ifdef _KEEP_
6154                if (keep) {
6155                    do {
6156                        IF_KEEP_WRITE_TAYLOR(arg2,keep,k,p)
6157                    } while(arg1 < arg2-- );
6158                }
6159#endif
6160                break;
6161
6162                /*--------------------------------------------------------------------------*/
6163#if defined(_EXTERN_) /* ZOS,  FOS, FOV up to now */
6164            case ext_diff:                       /* extern differntiated function */
6165                ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index=get_locint_f();
6166                n=get_locint_f();
6167                m=get_locint_f();
6168                ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_for = get_locint_f();
6169                ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_for = get_locint_f();
6170                ADOLC_CURRENT_TAPE_INFOS.cpIndex = get_locint_f();
6171                edfct=get_ext_diff_fct(ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index);
6172
6173                if (edfct->ADOLC_EXT_FCT_POINTER==NULL)
6174                    fail(ADOLC_EXT_DIFF_NULLPOINTER_DIFFFUNC);
6175                if (n>0) {
6176                    if (edfct->dp_x==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
6177#if !defined(_ZOS_)
6178                    if (ADOLC_EXT_POINTER_X==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
6179#endif
6180                }
6181                if (m>0) {
6182                    if (edfct->dp_y==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
6183#if !defined(_ZOS_)
6184                    if (ADOLC_EXT_POINTER_Y==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
6185#endif
6186                }
6187
6188                arg = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_for;
6189                for (loop=0; loop<n; ++loop) {
6190                    if (edfct->dp_x_changes) {
6191                      IF_KEEP_WRITE_TAYLOR(arg, keep, k, p);
6192                    }
6193                    edfct->dp_x[loop]=dp_T0[arg];
6194#if !defined(_ZOS_)
6195                    ADOLC_EXT_COPY_TAYLORS(ADOLC_EXT_POINTER_X[loop],TAYLOR_BUFFER[arg]);
6196#endif
6197                    ++arg;
6198                }
6199                arg = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_for;
6200                for (loop=0; loop<m; ++loop) {
6201                    if (edfct->dp_y_priorRequired) {
6202                      IF_KEEP_WRITE_TAYLOR(arg, keep, k, p);
6203                    }
6204                    edfct->dp_y[loop]=dp_T0[arg];
6205#if !defined(_ZOS_)
6206                    ADOLC_EXT_COPY_TAYLORS(ADOLC_EXT_POINTER_Y[loop],TAYLOR_BUFFER[arg]);
6207#endif
6208                    ++arg;
6209                }
6210
6211                ext_retc = edfct->ADOLC_EXT_FCT_COMPLETE;
6212                MINDEC(ret_c, ext_retc);
6213
6214                res = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_for;
6215                for (loop=0; loop<n; ++loop) {
6216                    dp_T0[res]=edfct->dp_x[loop];
6217#if !defined(_ZOS_)
6218                    ADOLC_EXT_COPY_TAYLORS_BACK(ADOLC_EXT_POINTER_X[loop],TAYLOR_BUFFER[res]);
6219#endif
6220                    ++res;
6221                }
6222                res = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_for;
6223                for (loop=0; loop<m; ++loop) {
6224                    dp_T0[res]=edfct->dp_y[loop];
6225#if !defined(_ZOS_)
6226                    ADOLC_EXT_COPY_TAYLORS_BACK(ADOLC_EXT_POINTER_Y[loop],TAYLOR_BUFFER[res]);
6227#endif
6228                    ++res;
6229                }
6230
6231                break;
6232
6233            case ext_diff_iArr:                 /* extern differntiated function */
6234                iArrLength=get_locint_f();
6235                iArr=malloc(iArrLength*sizeof(int));
6236                for (loop=0;loop<iArrLength;++loop) iArr[loop]=get_locint_f();
6237                get_locint_f(); /* iArrLength again */
6238                ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index=get_locint_f();
6239                n=get_locint_f();
6240                m=get_locint_f();
6241                ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_for = get_locint_f();
6242                ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_for = get_locint_f();
6243                ADOLC_CURRENT_TAPE_INFOS.cpIndex = get_locint_f();
6244                edfct=get_ext_diff_fct(ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index);
6245
6246                if (edfct->ADOLC_EXT_FCT_IARR_POINTER==NULL)
6247                    fail(ADOLC_EXT_DIFF_NULLPOINTER_DIFFFUNC);
6248                if (n>0) {
6249                    if (edfct->dp_x==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
6250#if !defined(_ZOS_)
6251                    if (ADOLC_EXT_POINTER_X==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
6252#endif
6253                }
6254                if (m>0) {
6255                    if (edfct->dp_y==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
6256#if !defined(_ZOS_)
6257                    if (ADOLC_EXT_POINTER_Y==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
6258#endif
6259                }
6260
6261                arg = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_for;
6262                for (loop=0; loop<n; ++loop) {
6263                    if (edfct->dp_x_changes) {
6264                      IF_KEEP_WRITE_TAYLOR(arg, keep, k, p);
6265                    }
6266                    edfct->dp_x[loop]=dp_T0[arg];
6267#if !defined(_ZOS_)
6268                    ADOLC_EXT_COPY_TAYLORS(ADOLC_EXT_POINTER_X[loop],TAYLOR_BUFFER[arg]);
6269#endif
6270                    ++arg;
6271                }
6272                arg = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_for;
6273                for (loop=0; loop<m; ++loop) {
6274                    if (edfct->dp_y_priorRequired) {
6275                      IF_KEEP_WRITE_TAYLOR(arg, keep, k, p);
6276                    }
6277                    edfct->dp_y[loop]=dp_T0[arg];
6278#if !defined(_ZOS_)
6279                    ADOLC_EXT_COPY_TAYLORS(ADOLC_EXT_POINTER_Y[loop],TAYLOR_BUFFER[arg]);
6280#endif
6281                    ++arg;
6282                }
6283
6284                ext_retc = edfct->ADOLC_EXT_FCT_IARR_COMPLETE;
6285                MINDEC(ret_c, ext_retc);
6286
6287                res = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_for;
6288                for (loop=0; loop<n; ++loop) {
6289                    dp_T0[res]=edfct->dp_x[loop];
6290#if !defined(_ZOS_)
6291                    ADOLC_EXT_COPY_TAYLORS_BACK(ADOLC_EXT_POINTER_X[loop],TAYLOR_BUFFER[res]);
6292#endif
6293                    ++res;
6294                }
6295                res = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_for;
6296                for (loop=0; loop<m; ++loop) {
6297                    dp_T0[res]=edfct->dp_y[loop];
6298#if !defined(_ZOS_)
6299                    ADOLC_EXT_COPY_TAYLORS_BACK(ADOLC_EXT_POINTER_Y[loop],TAYLOR_BUFFER[res]);
6300#endif
6301                    ++res;
6302                }
6303                free((void*)iArr); iArr=0;
6304                break;
6305            case ext_diff_v2:
6306                ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index=get_locint_f();
6307                iArrLength = get_locint_f();
6308                iArr = malloc(iArrLength*sizeof(int));
6309                for (loop=0;loop<iArrLength;++loop) iArr[loop] = get_locint_f();
6310                get_locint_f(); /* iArrLength again */
6311                nin = get_locint_f();
6312                nout = get_locint_f();
6313                insz = malloc(2*(nin+nout)*sizeof(locint));
6314                outsz = insz + nin;
6315                ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_ext_v2 = outsz + nout;
6316                ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_ext_v2 = outsz + nout + nin;
6317                for (loop=0;loop<nin;++loop) {
6318                    insz[loop] = get_locint_f();
6319                    ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_ext_v2[loop] = get_locint_f();
6320                }
6321                for (loop=0;loop<nout;++loop) {
6322                    outsz[loop] = get_locint_f();
6323                    ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_ext_v2[loop] = get_locint_f();
6324                }
6325                get_locint_f(); /* nin again */
6326                get_locint_f(); /* nout again */
6327                edfct2 = get_ext_diff_fct_v2(ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index);
6328                if (edfct2->ADOLC_EXT_FCT_POINTER==NULL)
6329                    fail(ADOLC_EXT_DIFF_NULLPOINTER_DIFFFUNC);
6330                if (nin>0) {
6331                    if (edfct2->x == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
6332#if !defined(_ZOS_)
6333                    if (ADOLC_EXT_V2_POINTER_X==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
6334#endif
6335                }
6336                if (nout>0) {
6337                    if (edfct2->y == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
6338#if !defined(_ZOS_)
6339                    if (ADOLC_EXT_V2_POINTER_Y == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
6340#endif
6341                }
6342
6343                for<