source: branches/MPI/ADOL-C/src/uni5_for.c @ 424

Last change on this file since 424 was 424, checked in by kulshres, 9 years ago

update with 'mpi' branch from 'gitclone'

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

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