source: trunk/ADOL-C/src/fo_rev.c @ 743

Last change on this file since 743 was 743, checked in by kulshres, 2 years ago

match mallocs with frees in fo_rev.c

myfree2 cannot be used unless paired with myalloc2

  • Property svn:keywords set to Author Date Id Revision
File size: 111.9 KB
Line 
1/*----------------------------------------------------------------------------
2 ADOL-C -- Automatic Differentiation by Overloading in C++
3 File:     fo_rev.c
4 Revision: $Id: fo_rev.c 743 2017-06-20 11:06:40Z kulshres $
5 Contents: Contains the routines :
6           fos_reverse (first-order-scalar reverse mode)  : define _FOS_
7           fov_reverse (first-order-vector reverse mode)  : define _FOV_
8           int_reverse_tight,
9                ( first-order-vector reverse mode for bit patterns,
10                  checks all dependences on taylors and real values,
11                  more precize)
12           int_reverse_safe,
13                ( first-order-vector reverse mode for bit patterns,
14                  return always 3,
15                  no dependences on taylors and real values,
16                  faster than tight)
17
18 Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
19               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel,
20               Kshitij Kulshreshtha
21
22 This file is part of ADOL-C. This software is provided as open source.
23 Any use, reproduction, or distribution of the software constitutes
24 recipient's acceptance of the terms of the accompanying license file.
25         
26----------------------------------------------------------------------------*/
27
28/*****************************************************************************
29 
30  There are four basic versions of the procedure `reverse', which
31  are optimized for the cases of scalar or vector reverse sweeps
32  with first or higher derivatives, respectively. In the calling
33  sequence this distinction is apparent from the type of the
34  parameters `lagrange' and `results'. The former may be left out
35  and the integer parameters `depen', `indep', `degre', and `nrows'
36  must be set or default according to the following matrix of
37  calling cases.
38 
39           no lagrange         double* lagrange     double** lagrange
40 
41double*   gradient of scalar   weight vector times    infeasible
42results   valued function      Jacobian product       combination
43 
44          ( depen = 1 ,         ( depen > 0 ,         
45            degre = 0 ,           degre = 0 ,              ------
46            nrows = 1 )           nrows = 1 )
47 
48double**  Jacobian of vector   weight vector times     weight matrix
49results   valued function      Taylor-Jacobians        times Jacobian
50           
51          ( 0 < depen           ( depen > 0 ,          ( depen > 0 ,
52              = nrows ,           degre > 0 ,            degre = 0 ,
53            degre = 0 )           nrows = 1 )            nrows > 0 )
54 
55double*** full family of         ------------          weigth matrix x
56results   Taylor-Jacobians       ------------          Taylor Jacobians
57 
58*****************************************************************************/
59
60/****************************************************************************/
61/*                                                                   MACROS */
62#undef _ADOLC_VECTOR_
63
64/*--------------------------------------------------------------------------*/
65#ifdef _FOS_
66#ifdef _ABS_NORM_
67#define GENERATED_FILENAME "fos_pl_reverse"
68#else
69#ifdef _ABS_NORM_SIG_
70#define GENERATED_FILENAME "fos_pl_sig_reverse"
71#else
72#define GENERATED_FILENAME "fos_reverse"
73#endif
74#endif
75
76#define RESULTS(l,indexi)  results[indexi]
77#define LAGRANGE(l,indexd) lagrange[indexd]
78#define RESULTSTRANS(l,indexi)  results[indexi]
79#define LAGRANGETRANS(l,indexd) lagrange[indexd]
80
81/*--------------------------------------------------------------------------*/
82#elif _FOV_
83#define GENERATED_FILENAME "fov_reverse"
84
85#define _ADOLC_VECTOR_
86
87#define RESULTS(l,indexi) results[l][indexi]
88#define LAGRANGE(l,indexd) lagrange[l][indexd]
89#define RESULTSTRANS(l,indexi) results[indexi][l]
90#define LAGRANGETRANS(l,indexd) lagrange[indexd][l]
91
92#else
93#if defined(_INT_REV_)
94#if defined(_TIGHT_)
95#define GENERATED_FILENAME "int_reverse_t"
96#endif
97#if defined(_NTIGHT_)
98#define GENERATED_FILENAME "int_reverse_s"
99#endif
100#define RESULTS(l,indexi)  results[l][indexi]
101#define LAGRANGE(l,indexd) lagrange[l][indexd]
102#define RESULTSTRANS(l,indexi) results[indexi][l]
103#define LAGRANGETRANS(l,indexd) lagrange[indexd][l]
104#else
105#error Error ! Define [_FOS_ | _FOV_ | _INT_REV_SAFE_ | _INT_REV_TIGHT_ ]
106#endif
107#endif
108/*--------------------------------------------------------------------------*/
109/*                                                     access to variables  */
110
111#ifdef _FOS_
112#define ARES       *Ares
113#define AARG       *Aarg
114#define AARG1      *Aarg1
115#define AARG2      *Aarg2
116
117#define ARES_INC   *Ares
118#define AARG_INC   *Aarg
119#define AARG1_INC  *Aarg1
120#define AARG2_INC  *Aarg2
121
122#define ARES_INC_O  Ares
123#define AARG_INC_O  /adAarg
124#define AARG1_INC_O Aarg1
125#define AARG2_INC_O Aarg2
126
127#define ASSIGN_A(a,b)  a = &b;
128
129#else  /* _FOV_ */
130#ifdef _FOV_
131#define ARES       *Ares
132#define AARG       *Aarg
133#define AARG1      *Aarg1
134#define AARG2      *Aarg2
135
136#define ARES_INC   *Ares++
137#define AARG_INC   *Aarg++
138#define AARG1_INC  *Aarg1++
139#define AARG2_INC  *Aarg2++
140
141#define ARES_INC_O  Ares++
142#define AARG_INC_O  Aarg++
143#define AARG1_INC_O Aarg1++
144#define AARG2_INC_O Aarg2++
145
146#define ASSIGN_A(a,b)  a = b;
147#else
148#ifdef _INT_REV_
149#define ARES       *Ares
150#define AARG       *Aarg
151#define AARG1      *Aarg1
152#define AARG2      *Aarg2
153
154#define ARES_INC   *Ares++
155#define AARG_INC   *Aarg++
156#define AARG1_INC  *Aarg1++
157#define AARG2_INC  *Aarg2++
158
159#define ARES_INC_O  Ares++
160#define AARG_INC_O  Aarg++
161#define AARG1_INC_O Aarg1++
162#define AARG2_INC_O Aarg2++
163
164#define ASSIGN_A(a,b)  a = b;
165#endif
166#endif
167#endif
168
169#define TRES       rp_T[res]
170#define TARG       rp_T[arg]
171#define TARG1      rp_T[arg1]
172#define TARG2      rp_T[arg2]
173
174/*--------------------------------------------------------------------------*/
175/*                                                              loop stuff  */
176#ifdef _ADOLC_VECTOR_
177#define FOR_0_LE_l_LT_p for (l=0; l<p; l++)
178#define FOR_p_GT_l_GE_0 for (l=p-1; l>=0; l--)
179#else
180#ifdef _INT_REV_
181#define FOR_0_LE_l_LT_p for (l=0; l<p; l++)
182#define FOR_p_GT_l_GE_0 for (l=p-1; l>=0; l--)
183#else
184#define FOR_0_LE_l_LT_p
185#define FOR_p_GT_l_GE_0
186#endif
187#endif
188
189#ifdef _FOV_
190#define FOR_0_LE_l_LT_pk1 for (l=0; l<p; l++)
191#else
192#ifdef _INT_REV_
193#define FOR_0_LE_l_LT_pk1 for (l=0; l<p; l++)
194#else
195#define FOR_0_LE_l_LT_pk1
196#endif
197#endif
198
199/* END Macros */
200
201
202/****************************************************************************/
203/*                                                       NECESSARY INCLUDES */
204#include <adolc/interfaces.h>
205#include <adolc/adalloc.h>
206#include "oplate.h"
207#include "taping_p.h"
208#include <adolc/externfcts.h>
209#include "externfcts_p.h"
210#include "dvlparms.h"
211
212#include <math.h>
213#include <string.h>
214
215#ifdef ADOLC_AMPI_SUPPORT
216#include "ampi/ampi.h"
217#include "ampi/libCommon/modified.h"
218#endif
219
220BEGIN_C_DECLS
221
222/****************************************************************************/
223/*                                                             NOW THE CODE */
224
225#ifdef _FOS_
226/****************************************************************************/
227/* First-Order Scalar Reverse Pass.                                         */
228/****************************************************************************/
229#ifdef _ABS_NORM_
230/****************************************************************************/
231/* Abs-Normal extended adjoint row computation.                             */
232/****************************************************************************/
233int fos_pl_reverse(short  tnum,     /* tape id */
234                   int    depen,     /* consistency chk on # of deps */
235                   int    indep,     /* consistency chk on # of indeps */
236                   int    swchk,    /* consistency chk on # of switches */
237                   int    rownum,   /* required row no. of abs-normal form */
238                   double *results) /*  coefficient vectors */
239#elif defined(_ABS_NORM_SIG_)
240/****************************************************************************/
241/* Abs-Normal extended adjoint row computation.                             */
242/****************************************************************************/
243int fos_pl_sig_reverse(short  tnum,     /* tape id */
244                   int    depen,     /* consistency chk on # of deps */
245                   int    indep,     /* consistency chk on # of indeps */
246                   int    swchk,    /* consistency chk on # of switches */
247                   short   *siggrad,
248                   double  *lagrange,
249                   double *results) /*  coefficient vectors */
250#else
251int fos_reverse(short   tnum,       /* tape id */
252                int     depen,      /* consistency chk on # of deps */
253                int     indep,      /* consistency chk on # of indeps */
254                double  *lagrange,
255                double  *results)   /*  coefficient vectors */
256
257#endif
258#else
259#if _FOV_
260/****************************************************************************/
261/* First-Order Vector Reverse Pass.                                         */
262/****************************************************************************/
263
264int fov_reverse(short   tnum,        /* tape id */
265                int     depen,       /* consistency chk on # of deps */
266                int     indep,       /* consistency chk on # of indeps */
267                int     nrows,       /* # of Jacobian rows being calculated */
268                double  **lagrange,  /* domain weight vector */
269                double  **results)   /* matrix of coefficient vectors */
270
271#else
272#if defined(_INT_REV_)
273#if defined(_TIGHT_)
274/****************************************************************************/
275/* First Order Vector version of the reverse mode for bit patterns, tight   */
276/****************************************************************************/
277int int_reverse_tight(
278        short             tnum,  /* tape id                               */
279        int               depen, /* consistency chk on # of deps          */
280        int               indep, /* consistency chk on # of indeps        */
281        int               nrows, /* # of Jacobian rows being calculated   */
282        unsigned long int **lagrange,/* domain weight vector[var][row](in)*/
283        unsigned long int **results) /* matrix of coeff. vectors[var][row]*/
284
285#endif
286#if defined(_NTIGHT_)
287/****************************************************************************/
288/* First Order Vector version of the reverse mode, bit pattern, safe        */
289/****************************************************************************/
290int int_reverse_safe(
291        short             tnum,  /* tape id                               */
292        int               depen, /* consistency chk on # of deps          */
293        int               indep, /* consistency chk on # of indeps        */
294        int               nrows, /* # of Jacobian rows being calculated   */
295        unsigned long int **lagrange,/* domain weight vector[var][row](in)*/
296        unsigned long int **results) /* matrix of coeff. vectors[var][row]*/
297#endif
298#endif
299#endif
300#endif
301{
302    /****************************************************************************/
303    /*                                                           ALL VARIABLES  */
304    unsigned char operation;   /* operation code */
305    int ret_c = 3;             /* return value */
306
307    locint size = 0;
308    locint res  = 0;
309    locint arg  = 0;
310    locint arg1 = 0;
311    locint arg2 = 0;
312
313#if !defined (_NTIGHT_)
314    double coval = 0;
315#endif
316
317    int indexi = 0,  indexd = 0;
318#if defined(_ABS_NORM_) || defined(_ABS_NORM_SIG_)
319    int switchnum;
320#endif
321
322    /* loop indices */
323#if defined(_FOV_)
324    int l;
325#endif
326#if defined(_INT_REV_)
327    int l;
328#endif
329    int j, ls;
330
331    /* other necessary variables */
332#if !defined (_NTIGHT_)
333    double r0, r_0;
334    int taycheck;
335    int numdep,numind;
336#endif
337
338    /*--------------------------------------------------------------------------*/
339    /* Adjoint stuff */
340#ifdef _FOS_
341    revreal *rp_A;
342    revreal aTmp;
343#endif
344#ifdef _FOV_
345    revreal **rpp_A, *Aqo;
346    revreal aTmp;
347#endif
348#if !defined(_NTIGHT_)
349    revreal *rp_T;
350#endif /* !_NTIGHT_ */
351#if !defined _INT_REV_
352    revreal  *Ares, *Aarg, *Aarg1, *Aarg2;
353#else
354    unsigned long int **upp_A;
355    unsigned long int *Ares, *Aarg, *Aarg1, *Aarg2;
356    unsigned long int aTmp;
357#endif
358
359    /*--------------------------------------------------------------------------*/
360
361#ifdef _ADOLC_VECTOR_
362    int p = nrows;
363#endif
364#ifdef _INT_REV_
365    int p = nrows;
366#endif
367
368    /****************************************************************************/
369    /*                                          extern diff. function variables */
370#if defined(_FOS_)
371# define ADOLC_EXT_FCT_U edfct->dp_U
372# define ADOLC_EXT_FCT_Z edfct->dp_Z
373# define ADOLC_EXT_FCT_POINTER fos_reverse
374# define ADOLC_EXT_FCT_IARR_POINTER fos_reverse_iArr
375# define ADOLC_EXT_FCT_COMPLETE \
376  fos_reverse(m, edfct->dp_U, n, edfct->dp_Z, edfct->dp_x, edfct->dp_y)
377# define ADOLC_EXT_FCT_IARR_COMPLETE \
378  fos_reverse_iArr(iArrLength,iArr, m, edfct->dp_U, n, edfct->dp_Z, edfct->dp_x, edfct->dp_y)
379# define ADOLC_EXT_FCT_SAVE_NUMDIRS
380# define ADOLC_EXT_FCT_V2_U edfct2->up
381# define ADOLC_EXT_FCT_V2_Z edfct2->zp
382# define ADOLC_EXT_FCT_V2_COMPLETE \
383    fos_reverse(iArrLength,iArr,nout,nin,outsz,edfct2->up,insz,edfct2->zp,edfct2->x,edfct2->y,edfct2->context)
384#else
385# define ADOLC_EXT_FCT_U edfct->dpp_U
386# define ADOLC_EXT_FCT_Z edfct->dpp_Z
387# define ADOLC_EXT_FCT_POINTER fov_reverse
388# define ADOLC_EXT_FCT_IARR_POINTER fov_reverse_iArr
389# define ADOLC_EXT_FCT_COMPLETE \
390  fov_reverse(m, p, edfct->dpp_U, n, edfct->dpp_Z, edfct->dp_x, edfct->dp_y)
391# define ADOLC_EXT_FCT_IARR_COMPLETE \
392  fov_reverse_iArr(iArrLength, iArr, m, p, edfct->dpp_U, n, edfct->dpp_Z, edfct->dp_x, edfct->dp_y)
393# define ADOLC_EXT_FCT_SAVE_NUMDIRS ADOLC_CURRENT_TAPE_INFOS.numDirs_rev = nrows
394# define ADOLC_EXT_FCT_V2_U edfct2->Up
395# define ADOLC_EXT_FCT_V2_Z edfct2->Zp
396# define ADOLC_EXT_FCT_V2_COMPLETE \
397  fov_reverse(iArrLength,iArr,nout,nin,outsz,p,edfct2->Up,insz,edfct2->Zp,edfct2->x,edfct2->y, edfct2->context)
398#endif
399#if !defined(_INT_REV_)
400    locint n, m;
401    ext_diff_fct *edfct;
402    ext_diff_fct_v2 *edfct2;
403    int iArrLength;
404    int *iArr;
405    int loop,oloop;
406    int ext_retc;
407    int oldTraceFlag;
408    locint *insz, *outsz, nin, nout;
409#endif
410#ifdef ADOLC_AMPI_SUPPORT
411    MPI_Op op;
412    void *buf, *rbuf;
413    int count, rcount;
414    MPI_Datatype datatype, rtype;
415    int src; 
416    int tag;
417    enum AMPI_PairedWith_E pairedWith;
418    MPI_Comm comm;
419    MPI_Status* status;
420    struct AMPI_Request_S request;
421#endif
422        locint qq;
423
424        ADOLC_OPENMP_THREAD_NUMBER;
425    ADOLC_OPENMP_GET_THREAD_NUMBER;
426
427#if defined(ADOLC_DEBUG)
428    /****************************************************************************/
429    /*                                                           DEBUG MESSAGES */
430    fprintf(DIAG_OUT,"Call of %s(..) with tag: %d, n: %d, m %d,\n",
431            GENERATED_FILENAME, tnum, indep, depen);
432#ifdef _ADOLC_VECTOR_
433    fprintf(DIAG_OUT,"                    p: %d\n\n",nrows);
434#endif
435
436#endif
437
438    /****************************************************************************/
439    /*                                                                    INITs */
440
441    /*------------------------------------------------------------------------*/
442    /* Set up stuff for the tape */
443
444    /* Initialize the Reverse Sweep */
445    init_rev_sweep(tnum);
446
447    failAdditionalInfo3 = depen;
448    failAdditionalInfo4 = indep;
449    if ( (depen != ADOLC_CURRENT_TAPE_INFOS.stats[NUM_DEPENDENTS]) ||
450            (indep != ADOLC_CURRENT_TAPE_INFOS.stats[NUM_INDEPENDENTS]) )
451        fail(ADOLC_REVERSE_COUNTS_MISMATCH);
452
453    indexi = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_INDEPENDENTS] - 1;
454    indexd = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_DEPENDENTS] - 1;
455
456#if defined(_ABS_NORM_) || defined(_ABS_NORM_SIG_)
457    if (! ADOLC_CURRENT_TAPE_INFOS.stats[NO_MIN_MAX] ) {
458        fprintf(DIAG_OUT, "ADOL-C error: Tape %d was not created compatible "
459                "with %s(..)\n              Please call enableMinMaxUsingAbs() "
460                "before trace_on(%d)\n", tnum, GENERATED_FILENAME, tnum);
461        adolc_exit(-1,"",__func__,__FILE__,__LINE__);
462    }
463    else if (swchk != ADOLC_CURRENT_TAPE_INFOS.stats[NUM_SWITCHES]) {
464        fprintf(DIAG_OUT, "ADOL-C error: Number of switches passed %d does not "
465                "match with the one recorded on tape %d (%zu)\n",swchk,tnum,
466                ADOLC_CURRENT_TAPE_INFOS.stats[NUM_SWITCHES]);
467        adolc_exit(-1,"",__func__,__FILE__,__LINE__);
468    }
469    else
470        switchnum = swchk - 1;
471#endif
472
473   
474    /****************************************************************************/
475    /*                                                  MEMORY ALLOCATION STUFF */
476
477    /*--------------------------------------------------------------------------*/
478#ifdef _FOS_                                                         /* FOS */
479    rp_A = (revreal*) calloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES], sizeof(revreal));
480    if (rp_A == NULL) fail(ADOLC_MALLOC_FAILED);
481    ADOLC_CURRENT_TAPE_INFOS.rp_A = rp_A;
482    rp_T = (revreal *)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] *
483            sizeof(revreal));
484    if (rp_T == NULL) fail(ADOLC_MALLOC_FAILED);
485    ADOLC_CURRENT_TAPE_INFOS.workMode = ADOLC_FOS_REVERSE;
486#ifdef _ABS_NORM_
487    memset(results,0,sizeof(double)*(indep+swchk));
488#endif
489# define ADJOINT_BUFFER rp_A
490# define ADJOINT_BUFFER_ARG_L rp_A[arg]
491# define ADJOINT_BUFFER_RES_L rp_A[res]
492# define ADJOINT_BUFFER_ARG rp_A[arg]
493# define ADJOINT_BUFFER_RES rp_A[res]
494# define ADOLC_EXT_FCT_U_L_LOOP edfct->dp_U[loop]
495# define ADOLC_EXT_FCT_Z_L_LOOP edfct->dp_Z[loop]
496# define ADOLC_EXT_FCT_V2_U_LOOP edfct2->up[oloop][loop]
497# define ADOLC_EXT_FCT_V2_Z_LOOP edfct2->zp[oloop][loop]
498# define ADOLC_EXT_FCT_COPY_ADJOINTS(dest,src) dest=src
499# define ADOLC_EXT_FCT_COPY_ADJOINTS_BACK(dest,src) src=dest
500
501    /*--------------------------------------------------------------------------*/
502#else
503#if defined _FOV_                                                          /* FOV */
504    rpp_A = (revreal**)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] *
505            sizeof(revreal*));
506    if (rpp_A == NULL) fail(ADOLC_MALLOC_FAILED);
507    Aqo = (revreal*)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] * p *
508            sizeof(revreal));
509    if (Aqo == NULL) fail(ADOLC_MALLOC_FAILED);
510    for (j=0; j<ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]; j++) {
511        rpp_A[j] = Aqo + j*p;
512    }
513    ADOLC_CURRENT_TAPE_INFOS.rpp_A = rpp_A;
514    rp_T = (revreal *)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] *
515            sizeof(revreal));
516    if (rp_T == NULL) fail(ADOLC_MALLOC_FAILED);
517    ADOLC_CURRENT_TAPE_INFOS.workMode = ADOLC_FOV_REVERSE;
518#if !defined(ADOLC_USE_CALLOC)
519    c_Ptr = (char *) ADOLC_GLOBAL_TAPE_VARS.dpp_A;
520    *c_Ptr = 0;
521    memcpy(c_Ptr + 1, c_Ptr, sizeof(double) * p *
522            ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] - 1);
523#endif
524# define ADJOINT_BUFFER rpp_A
525# define ADJOINT_BUFFER_ARG_L rpp_A[arg][l]
526# define ADJOINT_BUFFER_RES_L rpp_A[res][l]
527# define ADJOINT_BUFFER_ARG rpp_A[arg]
528# define ADJOINT_BUFFER_RES rpp_A[res]
529# define ADOLC_EXT_FCT_U_L_LOOP edfct->dpp_U[l][loop]
530# define ADOLC_EXT_FCT_Z_L_LOOP edfct->dpp_Z[l][loop]
531# define ADOLC_EXT_FCT_V2_U_LOOP edfct2->Up[oloop][loop]
532# define ADOLC_EXT_FCT_V2_Z_LOOP edfct2->Zp[oloop][loop]
533# define ADOLC_EXT_FCT_COPY_ADJOINTS(dest,src) dest=src
534# define ADOLC_EXT_FCT_COPY_ADJOINTS_BACK(dest,src)
535#else
536#if defined _INT_REV_
537    upp_A = myalloc2_ulong(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES], p);
538#if defined _TIGHT_
539    ADOLC_CURRENT_TAPE_INFOS.upp_A = upp_A;
540    rp_T = (revreal *)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] *
541                             sizeof(revreal));
542    if (rp_T == NULL) fail(ADOLC_MALLOC_FAILED);
543#endif
544# define ADJOINT_BUFFER upp_A
545# define ADJOINT_BUFFER_ARG_L upp_A[arg][l]
546# define ADJOINT_BUFFER_RES_L upp_A[res][l]
547#endif
548#endif
549#endif
550
551    /****************************************************************************/
552    /*                                                    TAYLOR INITIALIZATION */
553
554#if !defined(_NTIGHT_)
555
556    ADOLC_CURRENT_TAPE_INFOS.rp_T = rp_T;
557
558    taylor_back(tnum, &numdep, &numind, &taycheck);
559
560    if (taycheck < 0) {
561        fprintf(DIAG_OUT,"\n ADOL-C error: reverse fails because it was not"
562                " preceded\nby a forward sweep with degree>0, keep=1!\n");
563        adolc_exit(-2,"",__func__,__FILE__,__LINE__);
564    };
565
566    if((numdep != depen)||(numind != indep))
567        fail(ADOLC_REVERSE_TAYLOR_COUNTS_MISMATCH);
568
569#endif /* !_NTIGHT_ */
570
571
572    /****************************************************************************/
573    /*                                                            REVERSE SWEEP */
574    operation=get_op_r();
575    while (operation != start_of_tape) { /* Switch statement to execute the operations in Reverse */
576
577        switch (operation) {
578
579
580                /****************************************************************************/
581                /*                                                                  MARKERS */
582
583                /*--------------------------------------------------------------------------*/
584            case end_of_op:                                          /* end_of_op */
585                get_op_block_r();
586                operation = get_op_r();
587                /* Skip next operation, it's another end_of_op */
588                break;
589
590                /*--------------------------------------------------------------------------*/
591            case end_of_int:                                        /* end_of_int */
592                get_loc_block_r(); /* Get the next int block */
593                break;
594
595                /*--------------------------------------------------------------------------*/
596            case end_of_val:                                        /* end_of_val */
597                get_val_block_r(); /* Get the next val block */
598                break;
599
600                /*--------------------------------------------------------------------------*/
601            case start_of_tape:                                  /* start_of_tape */
602                break;
603            case end_of_tape:                                      /* end_of_tape */
604                discard_params_r();
605                break;
606
607
608                /****************************************************************************/
609                /*                                                               COMPARISON */
610
611                /*--------------------------------------------------------------------------*/
612            case eq_zero  :                                            /* eq_zero */
613                arg   = get_locint_r();
614
615#if !defined(_NTIGHT_)
616                ret_c = 0;
617#endif /* !_NTIGHT_ */
618                break;
619
620                /*--------------------------------------------------------------------------*/
621            case neq_zero :                                           /* neq_zero */
622            case gt_zero  :                                            /* gt_zero */
623            case lt_zero :                                             /* lt_zero */
624                arg   = get_locint_r();
625                break;
626
627                /*--------------------------------------------------------------------------*/
628            case ge_zero :                                             /* ge_zero */
629            case le_zero :                                             /* le_zero */
630                arg   = get_locint_r();
631
632#if !defined(_NTIGHT_)
633                if (TARG == 0)
634                    ret_c = 0;
635#endif /* !_NTIGHT_ */
636                break;
637
638
639                /****************************************************************************/
640                /*                                                              ASSIGNMENTS */
641
642                /*--------------------------------------------------------------------------*/
643            case assign_a:           /* assign an adouble variable an    assign_a */
644                /* adouble value. (=) */
645                res = get_locint_r();
646                arg = get_locint_r();
647
648                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
649                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
650
651                FOR_0_LE_l_LT_p
652                {
653#if defined(_INT_REV_)                 
654                  AARG_INC |= ARES;
655                  ARES_INC = 0;
656#else
657                  AARG_INC += ARES;
658                  ARES_INC = 0.0;
659#endif
660            }
661
662#if !defined(_NTIGHT_)
663                ADOLC_GET_TAYLOR(res);
664#endif /* !_NTIGHT_ */
665                break;
666
667                /*--------------------------------------------------------------------------*/
668            case assign_d:            /* assign an adouble variable a    assign_d */
669                /* double value. (=) */
670                res   = get_locint_r();
671#if !defined(_NTIGHT_)
672                coval = get_val_r();
673#endif /* !_NTIGHT_ */
674
675                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
676
677                FOR_0_LE_l_LT_p
678#if defined(_INT_REV_)                 
679                ARES_INC = 0;
680#else
681                ARES_INC = 0.0;
682#endif
683
684#if !defined(_NTIGHT_)
685                ADOLC_GET_TAYLOR(res);
686#endif /* !_NTIGHT_ */
687                break;
688
689                /*--------------------------------------------------------------------------*/
690            case neg_sign_p:
691            case recipr_p:
692            case assign_p:            /* assign an adouble variable a    assign_d */
693                /* double value. (=) */
694                res   = get_locint_r();
695                arg   = get_locint_r();
696#if !defined(_NTIGHT_)
697                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
698#endif /* !_NTIGHT_ */
699
700                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
701
702                FOR_0_LE_l_LT_p
703#if defined(_INT_REV_)                 
704                ARES_INC = 0;
705#else
706                ARES_INC = 0.0;
707#endif
708
709#if !defined(_NTIGHT_)
710                ADOLC_GET_TAYLOR(res);
711#endif /* !_NTIGHT_ */
712                break;
713                /*--------------------------------------------------------------------------*/
714            case assign_d_zero:  /* assign an adouble variable a    assign_d_zero */
715            case assign_d_one:   /* double value (0 or 1). (=)       assign_d_one */
716                res   = get_locint_r();
717
718                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
719
720                FOR_0_LE_l_LT_p
721#if defined(_INT_REV_)                 
722                ARES_INC = 0;
723#else
724                ARES_INC = 0.0;
725#endif
726
727#if !defined(_NTIGHT_)
728                ADOLC_GET_TAYLOR(res);
729#endif /* !_NTIGHT_ */
730                break;
731
732                /*--------------------------------------------------------------------------*/
733            case assign_ind:       /* assign an adouble variable an    assign_ind */
734                /* independent double value (<<=) */
735                res = get_locint_r();
736
737                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
738
739                if (ADOLC_CURRENT_TAPE_INFOS.in_nested_ctx) {
740                FOR_0_LE_l_LT_p
741                    RESULTSTRANS(l,indexi) += ARES_INC;
742                } else {
743                FOR_0_LE_l_LT_p
744                    RESULTS(l,indexi) = ARES_INC;
745                }
746#if !defined(_NTIGHT_)
747                ADOLC_GET_TAYLOR(res);
748#endif /* !_NTIGHT_ */
749                indexi--;
750                break;
751
752                /*--------------------------------------------------------------------------*/
753            case assign_dep:           /* assign a float variable a    assign_dep */
754                /* dependent adouble value. (>>=) */
755                res = get_locint_r();
756
757                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
758
759#if defined(_ABS_NORM_)
760                if (indexd + swchk == rownum)
761                    ARES = 1.0;
762                else
763                    ARES = 0.0;
764#else
765                if (ADOLC_CURRENT_TAPE_INFOS.in_nested_ctx) {
766                    FOR_0_LE_l_LT_p {
767                        ARES_INC = LAGRANGETRANS(l,indexd);
768                        LAGRANGETRANS(l,indexd) = 0.0;
769                    }
770                } else {
771                FOR_0_LE_l_LT_p
772                    ARES_INC = LAGRANGE(l,indexd);
773                }
774#endif
775                indexd--;
776                break;
777
778
779                /****************************************************************************/
780                /*                                                   OPERATION + ASSIGNMENT */
781
782                /*--------------------------------------------------------------------------*/
783            case eq_plus_d:            /* Add a floating point to an    eq_plus_d */
784                /* adouble. (+=) */
785                res   = get_locint_r();
786#if !defined(_NTIGHT_)
787                coval = get_val_r();
788
789                ADOLC_GET_TAYLOR(res);
790#endif /* !_NTIGHT_ */
791                break;
792
793                /*--------------------------------------------------------------------------*/
794            case eq_plus_p:            /* Add a floating point to an    eq_plus_d */
795                /* adouble. (+=) */
796                res   = get_locint_r();
797                arg   = get_locint_r();
798#if !defined(_NTIGHT_)
799                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
800
801                ADOLC_GET_TAYLOR(res);
802#endif /* !_NTIGHT_ */
803                break;
804
805                /*--------------------------------------------------------------------------*/
806            case eq_plus_a:             /* Add an adouble to another    eq_plus_a */
807                /* adouble. (+=) */
808                res = get_locint_r();
809                arg = get_locint_r();
810
811                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
812                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg]);
813
814                FOR_0_LE_l_LT_p
815#if defined(_INT_REV_)
816                AARG_INC |= ARES_INC;
817#else
818                AARG_INC += ARES_INC;
819#endif
820
821#if !defined(_NTIGHT_)
822                ADOLC_GET_TAYLOR(res);
823#endif /* !_NTIGHT_ */
824                break;
825
826                /*--------------------------------------------------------------------------*/
827            case eq_min_d:       /* Subtract a floating point from an    eq_min_d */
828                /* adouble. (-=) */
829                res   = get_locint_r();
830#if !defined(_NTIGHT_)
831                coval = get_val_r();
832
833                ADOLC_GET_TAYLOR(res);
834#endif /* !_NTIGHT_ */
835               break;
836
837                /*--------------------------------------------------------------------------*/
838            case eq_min_p:       /* Subtract a floating point from an    eq_min_d */
839                /* adouble. (-=) */
840                res   = get_locint_r();
841                arg   = get_locint_r();
842#if !defined(_NTIGHT_)
843                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
844
845                ADOLC_GET_TAYLOR(res);
846#endif /* !_NTIGHT_ */
847               break;
848
849                /*--------------------------------------------------------------------------*/
850            case eq_min_a:        /* Subtract an adouble from another    eq_min_a */
851                /* adouble. (-=) */
852                res = get_locint_r();
853                arg = get_locint_r();
854
855                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
856                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
857
858                FOR_0_LE_l_LT_p
859#if defined(_INT_REV_)
860                AARG_INC |= ARES_INC;
861#else
862                AARG_INC -= ARES_INC;
863#endif
864
865#if !defined(_NTIGHT_)
866               ADOLC_GET_TAYLOR(res);
867#endif /* !_NTIGHT_ */
868                break;
869
870                /*--------------------------------------------------------------------------*/
871            case eq_mult_d:              /* Multiply an adouble by a    eq_mult_d */
872                /* flaoting point. (*=) */
873                res   = get_locint_r();
874#if !defined(_NTIGHT_)
875                coval = get_val_r();
876#endif /* !_NTIGHT_ */
877
878#if!defined(_INT_REV_)
879                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
880
881                FOR_0_LE_l_LT_p
882                ARES_INC *= coval;
883#endif
884
885#if !defined(_NTIGHT_)
886                ADOLC_GET_TAYLOR(res);
887#endif /* !_NTIGHT_ */
888                break;
889
890                /*--------------------------------------------------------------------------*/
891            case eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
892                /* flaoting point. (*=) */
893                res   = get_locint_r();
894                arg   = get_locint_r();
895#if !defined(_NTIGHT_)
896                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
897#endif /* !_NTIGHT_ */
898
899#if!defined(_INT_REV_)
900                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
901
902                FOR_0_LE_l_LT_p
903                ARES_INC *= coval;
904#endif
905
906#if !defined(_NTIGHT_)
907                ADOLC_GET_TAYLOR(res);
908#endif /* !_NTIGHT_ */
909                break;
910
911                /*--------------------------------------------------------------------------*/
912            case eq_mult_a:       /* Multiply one adouble by another    eq_mult_a */
913                /* (*=) */
914                res = get_locint_r();
915                arg = get_locint_r();
916
917#if !defined(_NTIGHT_)
918                ADOLC_GET_TAYLOR(res);
919#endif /* !_NTIGHT_ */
920
921                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
922                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
923
924                FOR_0_LE_l_LT_p
925#if defined(_INT_REV_)
926                AARG_INC |= ARES_INC;
927#else
928                { aTmp = ARES;
929                  /* olvo 980713 nn: ARES = 0.0; */
930                  ARES_INC =  (aTmp==0)?0:(aTmp * TARG);
931                  AARG_INC += (aTmp==0)?0:(aTmp * TRES);
932                }
933#endif     
934                break;
935
936                /*--------------------------------------------------------------------------*/
937            case incr_a:                        /* Increment an adouble    incr_a */
938            case decr_a:                        /* Increment an adouble    decr_a */
939                res   = get_locint_r();
940
941#if !defined(_NTIGHT_)
942                ADOLC_GET_TAYLOR(res);
943#endif /* !_NTIGHT_ */
944                break;
945
946
947                /****************************************************************************/
948                /*                                                        BINARY OPERATIONS */
949
950                /*--------------------------------------------------------------------------*/
951            case plus_a_a:                 /* : Add two adoubles. (+)    plus a_a */
952                res  = get_locint_r();
953                arg2 = get_locint_r();
954                arg1 = get_locint_r();
955
956                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
957                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
958                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
959
960                FOR_0_LE_l_LT_p
961                { aTmp = ARES;
962#if defined(_INT_REV_)
963                  ARES_INC = 0;
964                  AARG1_INC |= aTmp;
965                  AARG2_INC |= aTmp;
966#else
967                  ARES_INC = 0.0;
968                  AARG1_INC += aTmp;
969                  AARG2_INC += aTmp;
970#endif
971            }
972
973#if !defined(_NTIGHT_)
974                ADOLC_GET_TAYLOR(res);
975#endif /* !_NTIGHT_ */
976                break;
977
978                /*--------------------------------------------------------------------------*/
979            case plus_d_a:             /* Add an adouble and a double    plus_d_a */
980                /* (+) */
981                res   = get_locint_r();
982                arg   = get_locint_r();
983#if !defined(_NTIGHT_)
984                coval = get_val_r();
985#endif /* !_NTIGHT_ */
986
987                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
988                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
989
990                FOR_0_LE_l_LT_p
991                { aTmp = ARES;
992#if defined(_INT_REV_)
993                  ARES_INC = 0;
994                  AARG_INC |= aTmp;
995#else
996                  ARES_INC = 0.0;
997                  AARG_INC += aTmp;
998#endif
999            }
1000
1001#if !defined(_NTIGHT_)
1002                ADOLC_GET_TAYLOR(res);
1003#endif /* !_NTIGHT_ */
1004                break;
1005
1006                /*--------------------------------------------------------------------------*/
1007            case plus_a_p:             /* Add an adouble and a double    plus_a_p */
1008            case min_a_p:                /* Subtract an adouble from a    min_d_a */
1009                /* (+) */
1010                res   = get_locint_r();
1011                arg1  = get_locint_r();
1012                arg   = get_locint_r();
1013#if !defined(_NTIGHT_)
1014                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
1015#endif /* !_NTIGHT_ */
1016
1017                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1018                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1019
1020                FOR_0_LE_l_LT_p
1021                { aTmp = ARES;
1022#if defined(_INT_REV_)
1023                  ARES_INC = 0;
1024                  AARG_INC |= aTmp;
1025#else
1026                  ARES_INC = 0.0;
1027                  AARG_INC += aTmp;
1028#endif
1029            }
1030
1031#if !defined(_NTIGHT_)
1032                ADOLC_GET_TAYLOR(res);
1033#endif /* !_NTIGHT_ */
1034                break;
1035
1036                /*--------------------------------------------------------------------------*/
1037            case min_a_a:              /* Subtraction of two adoubles    min_a_a */
1038                /* (-) */
1039                res  = get_locint_r();
1040                arg2 = get_locint_r();
1041                arg1 = get_locint_r();
1042
1043                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1044                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1045                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
1046
1047                FOR_0_LE_l_LT_p
1048                { aTmp = ARES;
1049#if defined(_INT_REV_)
1050                  ARES_INC = 0;
1051                  AARG1_INC |= aTmp;
1052                  AARG2_INC |= aTmp;
1053#else
1054                  ARES_INC = 0.0;
1055                  AARG1_INC += aTmp;
1056                  AARG2_INC -= aTmp;
1057#endif
1058            }
1059
1060#if !defined(_NTIGHT_)
1061                ADOLC_GET_TAYLOR(res);
1062#endif /* !_NTIGHT_ */
1063                break;
1064
1065                /*--------------------------------------------------------------------------*/
1066            case min_d_a:                /* Subtract an adouble from a    min_d_a */
1067                /* double (-) */
1068                res   = get_locint_r();
1069                arg   = get_locint_r();
1070#if !defined(_NTIGHT_)
1071                coval = get_val_r();
1072#endif /* !_NTIGHT_ */
1073
1074                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1075                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1076
1077                FOR_0_LE_l_LT_p
1078                { aTmp = ARES;
1079#if defined(_INT_REV_)
1080                  ARES_INC = 0;
1081                  AARG_INC |= aTmp;
1082#else
1083                  ARES_INC = 0.0;
1084                  AARG_INC -= aTmp;
1085#endif
1086            }
1087
1088#if !defined(_NTIGHT_)
1089                ADOLC_GET_TAYLOR(res);
1090#endif /* !_NTIGHT_ */
1091                break;
1092
1093                /*--------------------------------------------------------------------------*/
1094            case mult_a_a:               /* Multiply two adoubles (*)    mult_a_a */
1095                res  = get_locint_r();
1096                arg2 = get_locint_r();
1097                arg1 = get_locint_r();
1098
1099#if !defined(_NTIGHT_)
1100                ADOLC_GET_TAYLOR(res);
1101#endif /* !_NTIGHT_ */
1102
1103                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1104                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
1105                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1106
1107                FOR_0_LE_l_LT_p
1108                { aTmp = ARES;
1109#if defined(_INT_REV_)
1110                  ARES_INC = 0;
1111                  AARG2_INC |= aTmp;
1112                  AARG1_INC |= aTmp;
1113#else
1114                  ARES_INC = 0.0;
1115                  AARG2_INC += (aTmp==0)?0:(aTmp * TARG1);
1116                  AARG1_INC += (aTmp==0)?0:(aTmp * TARG2);
1117#endif
1118            }
1119                break;
1120
1121                /*--------------------------------------------------------------------------*/
1122                /* olvo 991122: new op_code with recomputation */
1123            case eq_plus_prod:   /* increment a product of           eq_plus_prod */
1124                /* two adoubles (*) */
1125                res  = get_locint_r();
1126                arg2 = get_locint_r();
1127                arg1 = get_locint_r();
1128
1129                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1130                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
1131                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1132
1133#if !defined(_NTIGHT_)
1134                /* RECOMPUTATION */
1135                TRES -= TARG1*TARG2;
1136#endif /* !_NTIGHT_ */
1137
1138                FOR_0_LE_l_LT_p
1139                { 
1140#if defined(_INT_REV_)
1141                  AARG2_INC |= ARES;
1142                  AARG1_INC |= ARES_INC;
1143#else
1144                  AARG2_INC += ARES    * TARG1;
1145                  AARG1_INC += ARES_INC * TARG2;
1146#endif
1147            }
1148                break;
1149
1150                /*--------------------------------------------------------------------------*/
1151                /* olvo 991122: new op_code with recomputation */
1152            case eq_min_prod:    /* decrement a product of            eq_min_prod */
1153                /* two adoubles (*) */
1154                res  = get_locint_r();
1155                arg2 = get_locint_r();
1156                arg1 = get_locint_r();
1157
1158                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1159                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
1160                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1161
1162#if !defined(_NTIGHT_)
1163                /* RECOMPUTATION */
1164                TRES += TARG1*TARG2;
1165#endif /* !_NTIGHT_ */
1166
1167                FOR_0_LE_l_LT_p
1168                { 
1169#if defined(_INT_REV_)
1170                  AARG2_INC |= ARES;
1171                  AARG1_INC |= ARES_INC;
1172#else                 
1173                  AARG2_INC -= ARES    * TARG1;
1174                  AARG1_INC -= ARES_INC * TARG2;
1175#endif
1176            }
1177                break;
1178
1179                /*--------------------------------------------------------------------------*/
1180            case mult_d_a:         /* Multiply an adouble by a double    mult_d_a */
1181                /* (*) */
1182                res   = get_locint_r();
1183                arg   = get_locint_r();
1184#if !defined(_NTIGHT_)
1185                coval = get_val_r();
1186#endif /* !_NTIGHT_ */
1187
1188                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1189                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1190
1191                FOR_0_LE_l_LT_p
1192                { aTmp = ARES;
1193#if defined(_INT_REV_)
1194                  ARES_INC = 0;
1195                  AARG_INC |= aTmp;
1196#else
1197                  ARES_INC = 0.0;
1198                  AARG_INC += (aTmp==0)?0:(coval * aTmp);
1199#endif
1200            }
1201
1202#if !defined(_NTIGHT_)
1203                ADOLC_GET_TAYLOR(res);
1204#endif /* !_NTIGHT_ */
1205                break;
1206
1207                /*--------------------------------------------------------------------------*/
1208            case mult_a_p:         /* Multiply an adouble by a double    mult_a_p */
1209                /* (*) */
1210                res   = get_locint_r();
1211                arg1  = get_locint_r();
1212                arg   = get_locint_r();
1213#if !defined(_NTIGHT_)
1214                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
1215#endif /* !_NTIGHT_ */
1216
1217                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1218                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1219
1220                FOR_0_LE_l_LT_p
1221                { aTmp = ARES;
1222#if defined(_INT_REV_)
1223                  ARES_INC = 0;
1224                  AARG_INC |= aTmp;
1225#else
1226                  ARES_INC = 0.0;
1227                  AARG_INC += (aTmp==0)?0:(coval * aTmp);
1228#endif
1229            }
1230
1231#if !defined(_NTIGHT_)
1232                ADOLC_GET_TAYLOR(res);
1233#endif /* !_NTIGHT_ */
1234                break;
1235
1236                /*--------------------------------------------------------------------------*/
1237            case div_a_a:           /* Divide an adouble by an adouble    div_a_a */
1238                /* (/) */
1239                res  = get_locint_r();
1240                arg2 = get_locint_r();
1241                arg1 = get_locint_r();
1242
1243                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1244                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
1245                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1246
1247                /* olvo 980922 changed order to allow x=y/x */
1248#if !defined(_NTIGHT_)
1249                r_0 = -TRES;
1250                ADOLC_GET_TAYLOR(res);
1251                r0  = 1.0 / TARG2;
1252                r_0 *= r0;
1253#endif /* !_NTIGHT_ */
1254
1255                FOR_0_LE_l_LT_p
1256                { aTmp = ARES;
1257#if defined(_INT_REV_)
1258                  ARES_INC = 0;
1259                  AARG1_INC |= aTmp;
1260                  AARG2_INC |= aTmp;
1261#else
1262                  ARES_INC = 0.0;
1263                  AARG1_INC += (aTmp==0)?0:(aTmp * r0);
1264                  AARG2_INC += (aTmp==0)?0:(aTmp * r_0);
1265#endif
1266            }
1267
1268                break;
1269
1270                /*--------------------------------------------------------------------------*/
1271            case div_d_a:             /* Division double - adouble (/)    div_d_a */
1272                res   = get_locint_r();
1273                arg   = get_locint_r();
1274
1275#if !defined(_NTIGHT_)
1276                coval = get_val_r();
1277#endif /* !_NTIGHT_ */
1278
1279                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1280                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1281
1282#if !defined(_NTIGHT_)
1283                /* olvo 980922 changed order to allow x=d/x */
1284                r0 = -TRES;
1285                if (arg == res)
1286                    ADOLC_GET_TAYLOR(arg);
1287                r0 /= TARG;
1288#endif /* !_NTIGHT_ */
1289
1290                FOR_0_LE_l_LT_p
1291                { aTmp = ARES;
1292#if defined(_INT_REV_)
1293                  ARES_INC = 0;
1294                  AARG_INC |= aTmp;
1295#else
1296                  ARES_INC = 0.0;
1297                  AARG_INC += (aTmp==0)?0:(aTmp * r0);
1298#endif
1299                }
1300
1301#if !defined(_NTIGHT_)
1302                if (arg != res)
1303                ADOLC_GET_TAYLOR(res);
1304#endif /* !_NTIGHT_ */
1305                break;
1306
1307
1308                /****************************************************************************/
1309            case div_p_a:             /* Division double - adouble (/)    div_p_a */
1310                res   = get_locint_r();
1311                arg1  = get_locint_r();
1312                arg   = get_locint_r();
1313
1314#if !defined(_NTIGHT_)
1315                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
1316#endif /* !_NTIGHT_ */
1317
1318                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1319                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1320
1321#if !defined(_NTIGHT_)
1322                /* olvo 980922 changed order to allow x=d/x */
1323                r0 = -TRES;
1324                if (arg == res)
1325                    ADOLC_GET_TAYLOR(arg);
1326                r0 /= TARG;
1327#endif /* !_NTIGHT_ */
1328
1329                FOR_0_LE_l_LT_p
1330                { aTmp = ARES;
1331#if defined(_INT_REV_)
1332                  ARES_INC = 0;
1333                  AARG_INC |= aTmp;
1334#else
1335                  ARES_INC = 0.0;
1336                  AARG_INC += (aTmp==0)?0:(aTmp * r0);
1337#endif
1338                }
1339
1340#if !defined(_NTIGHT_)
1341                if (arg != res)
1342                ADOLC_GET_TAYLOR(res);
1343#endif /* !_NTIGHT_ */
1344                break;
1345
1346
1347                /****************************************************************************/
1348                /*                                                         SIGN  OPERATIONS */
1349
1350                /*--------------------------------------------------------------------------*/
1351            case pos_sign_a:                                        /* pos_sign_a */
1352                res   = get_locint_r();
1353                arg   = get_locint_r();
1354
1355                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1356                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1357
1358                FOR_0_LE_l_LT_p
1359                { aTmp = ARES;
1360#if defined(_INT_REV_)
1361                  ARES_INC = 0;
1362                  AARG_INC |= aTmp;
1363#else
1364                  ARES_INC = 0.0;
1365                  AARG_INC += aTmp;
1366#endif
1367            }
1368
1369#if !defined(_NTIGHT_)
1370                ADOLC_GET_TAYLOR(res);
1371#endif /* !_NTIGHT_ */
1372                break;
1373
1374                /*--------------------------------------------------------------------------*/
1375            case neg_sign_a:                                        /* neg_sign_a */
1376                res   = get_locint_r();
1377                arg   = get_locint_r();
1378
1379                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1380                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1381
1382                FOR_0_LE_l_LT_p
1383                { aTmp = ARES;
1384#if defined(_INT_REV_)
1385                  ARES_INC = 0;
1386                  AARG_INC |= aTmp;
1387#else
1388                  ARES_INC = 0.0;
1389                  AARG_INC -= aTmp;
1390#endif
1391            }
1392
1393#if !defined(_NTIGHT_)
1394                ADOLC_GET_TAYLOR(res);
1395#endif /* !_NTIGHT_ */
1396                break;
1397
1398
1399                /****************************************************************************/
1400                /*                                                         UNARY OPERATIONS */
1401
1402                /*--------------------------------------------------------------------------*/
1403            case exp_op:                          /* exponent operation    exp_op */
1404                res = get_locint_r();
1405                arg = get_locint_r();
1406
1407                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1408                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1409
1410                FOR_0_LE_l_LT_p
1411                { aTmp = ARES;
1412#if defined(_INT_REV_)
1413                  ARES_INC = 0;
1414                  AARG_INC |= aTmp;
1415#else
1416                  ARES_INC = 0.0;
1417                  AARG_INC += (aTmp==0)?0:(aTmp*TRES);
1418#endif
1419            }
1420
1421#if !defined(_NTIGHT_)
1422                ADOLC_GET_TAYLOR(res);
1423#endif /* !_NTIGHT_ */
1424                break;
1425
1426                /*--------------------------------------------------------------------------*/
1427            case sin_op:                              /* sine operation    sin_op */
1428                res  = get_locint_r();
1429                arg2 = get_locint_r();
1430                arg1 = get_locint_r();
1431
1432                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1433                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1434
1435                FOR_0_LE_l_LT_p
1436                { aTmp = ARES;
1437#if defined(_INT_REV_)
1438                  ARES_INC = 0;
1439                  AARG1_INC |= aTmp;
1440#else
1441                  ARES_INC = 0.0;
1442                  AARG1_INC += (aTmp==0)?0:(aTmp * TARG2);
1443#endif
1444            }
1445
1446#if !defined(_NTIGHT_)
1447                ADOLC_GET_TAYLOR(res);
1448                ADOLC_GET_TAYLOR(arg2); /* olvo 980710 covalue */
1449                /* NOTE: ADJOINT_BUFFER[arg2] should be 0 already */
1450#endif /* !_NTIGHT_ */
1451                break;
1452
1453                /*--------------------------------------------------------------------------*/
1454            case cos_op:                            /* cosine operation    cos_op */
1455                res  = get_locint_r();
1456                arg2 = get_locint_r();
1457                arg1 = get_locint_r();
1458
1459                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1460                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1461
1462                FOR_0_LE_l_LT_p
1463                { aTmp = ARES;
1464#if defined(_INT_REV_)
1465                  ARES_INC = 0;
1466                  AARG1_INC |= aTmp;
1467#else
1468                  ARES_INC = 0.0;
1469                  AARG1_INC -= (aTmp==0)?0:(aTmp * TARG2);
1470#endif
1471            }
1472
1473#if !defined(_NTIGHT_)
1474                ADOLC_GET_TAYLOR(res);
1475                ADOLC_GET_TAYLOR(arg2); /* olvo 980710 covalue */
1476                /* NOTE ADJOINT_BUFFER[arg2] should be 0 already */
1477#endif /* !_NTIGHT_ */
1478                break;
1479
1480                /*--------------------------------------------------------------------------*/
1481            case atan_op:                                             /* atan_op  */
1482            case asin_op:                                             /* asin_op  */
1483            case acos_op:                                             /* acos_op  */
1484            case asinh_op:                                            /* asinh_op */
1485            case acosh_op:                                            /* acosh_op */
1486            case atanh_op:                                            /* atanh_op */
1487            case erf_op:                                              /* erf_op   */
1488                res  = get_locint_r();
1489                arg2 = get_locint_r();
1490                arg1 = get_locint_r();
1491
1492#if !defined(_NTIGHT_)
1493                ADOLC_GET_TAYLOR(res);
1494#endif /* !_NTIGHT_ */
1495
1496                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1497                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1498
1499                FOR_0_LE_l_LT_p
1500                { aTmp = ARES;
1501#if defined(_INT_REV_)
1502                  ARES_INC = 0;
1503                  AARG1_INC |= aTmp;
1504#else
1505                  ARES_INC = 0.0;
1506                  AARG1_INC += (aTmp==0)?0:(aTmp * TARG2);
1507#endif
1508                }
1509                break;
1510
1511                /*--------------------------------------------------------------------------*/
1512            case log_op:                                                /* log_op */
1513                res = get_locint_r();
1514                arg = get_locint_r();
1515
1516#if !defined(_NTIGHT_)
1517                ADOLC_GET_TAYLOR(res);
1518#endif /* !_NTIGHT_ */
1519
1520                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1521                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1522
1523#if !defined(_INT_REV_)
1524                r0 = 1.0/TARG;
1525#endif
1526
1527                FOR_0_LE_l_LT_p
1528                { aTmp = ARES;
1529#if defined(_INT_REV_)
1530                  ARES_INC = 0;
1531                  AARG_INC |= aTmp;
1532#else
1533                  ARES_INC = 0.0;
1534                  AARG_INC += (aTmp==0)?0:(aTmp * r0);
1535#endif
1536            }
1537                break;
1538
1539                /*--------------------------------------------------------------------------*/
1540            case pow_op:                                                /* pow_op */
1541                res   = get_locint_r();
1542                arg   = get_locint_r();
1543#if !defined(_NTIGHT_)
1544                coval = get_val_r();
1545#endif /* !_NTIGHT_ */
1546
1547                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1548                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1549
1550#if !defined(_NTIGHT_)
1551                /* olvo 980921 changed order to allow x=pow(x,n) */
1552                r0 = TRES;
1553                if (arg == res)
1554                    ADOLC_GET_TAYLOR(arg);
1555                if (TARG == 0.0)
1556                    r0 = 0.0;
1557                else
1558                    r0 *= coval/TARG;
1559#endif /* !_NTIGHT_ */
1560
1561                FOR_0_LE_l_LT_p {
1562                    aTmp = ARES;
1563#if defined(_INT_REV_)
1564                    ARES_INC = 0;
1565                    AARG_INC |= aTmp;
1566#else
1567                    ARES_INC = 0.0;
1568                    AARG_INC += (aTmp==0)?0:(aTmp * r0);
1569#endif
1570            }
1571
1572#if !defined(_NTIGHT_)
1573                ADOLC_GET_TAYLOR(res);
1574#endif /* !_NTIGHT_ */
1575                break;
1576
1577                /*--------------------------------------------------------------------------*/
1578            case pow_op_p:                                                /* pow_op_p */
1579                res   = get_locint_r();
1580                arg1  = get_locint_r();
1581                arg   = get_locint_r();
1582#if !defined(_NTIGHT_)
1583                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg1];
1584#endif /* !_NTIGHT_ */
1585
1586                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1587                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1588
1589#if !defined(_NTIGHT_)
1590                /* olvo 980921 changed order to allow x=pow(x,n) */
1591                r0 = TRES;
1592                if (arg == res)
1593                    ADOLC_GET_TAYLOR(arg);
1594                if (TARG == 0.0)
1595                    r0 = 0.0;
1596                else
1597                    r0 *= coval/TARG;
1598#endif /* !_NTIGHT_ */
1599
1600                FOR_0_LE_l_LT_p {
1601                    aTmp = ARES;
1602#if defined(_INT_REV_)
1603                    ARES_INC = 0;
1604                    AARG_INC |= aTmp;
1605#else
1606                    ARES_INC = 0.0;
1607                    AARG_INC += (aTmp==0)?0:(aTmp * r0);
1608#endif
1609            }
1610
1611#if !defined(_NTIGHT_)
1612                ADOLC_GET_TAYLOR(res);
1613#endif /* !_NTIGHT_ */
1614                break;
1615
1616                /*--------------------------------------------------------------------------*/
1617            case sqrt_op:                                              /* sqrt_op */
1618                res = get_locint_r();
1619                arg = get_locint_r();
1620
1621                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1622                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1623
1624#if !defined(_NTIGHT_)
1625                if (TRES == 0.0)
1626                    r0 = 0.0;
1627                else
1628                    r0 = 0.5 / TRES;
1629#endif /* !_NTIGHT_ */
1630
1631                FOR_0_LE_l_LT_p {
1632                    aTmp = ARES;
1633#if defined(_INT_REV_)
1634                    ARES_INC = 0;
1635                    AARG_INC |= aTmp;
1636#else
1637                    ARES_INC = 0.0;
1638                    AARG_INC += (aTmp==0)?0:(aTmp * r0);
1639#endif
1640                }
1641
1642#if !defined(_NTIGHT_)
1643                ADOLC_GET_TAYLOR(res);
1644#endif /* !_NTIGHT_ */
1645              break;
1646
1647                /*--------------------------------------------------------------------------*/
1648            case gen_quad:                                            /* gen_quad */
1649                res   = get_locint_r();
1650                arg2  = get_locint_r();
1651                arg1  = get_locint_r();
1652#if !defined(_NTIGHT_)
1653                coval = get_val_r();
1654                coval = get_val_r();
1655#endif /* !_NTIGHT_ */
1656
1657                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1658                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1659
1660                FOR_0_LE_l_LT_p
1661                { aTmp = ARES;
1662#if defined(_INT_REV_)
1663                  ARES_INC = 0;
1664                  AARG1_INC |= aTmp;
1665#else
1666                  ARES_INC = 0.0;
1667                  AARG1_INC += (aTmp==0)?0:(aTmp * TARG2);
1668#endif
1669            }
1670
1671#if !defined(_NTIGHT_)
1672                ADOLC_GET_TAYLOR(res);
1673#endif /* !_NTIGHT_ */
1674                break;
1675
1676                /*--------------------------------------------------------------------------*/
1677            case min_op:                                                /* min_op */
1678                res   = get_locint_r();
1679                arg2  = get_locint_r();
1680                arg1  = get_locint_r();
1681#if !defined(_NTIGHT_)
1682                coval = get_val_r();
1683
1684                ADOLC_GET_TAYLOR(res);
1685#endif /* !_NTIGHT_ */
1686
1687                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1688                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
1689                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1690
1691#if !defined(_NTIGHT_)
1692                if (TARG1 > TARG2)
1693                    FOR_0_LE_l_LT_p
1694                    { aTmp = ARES;
1695#if defined(_INT_REV_)
1696                      ARES_INC = 0;
1697#else
1698                      ARES_INC = 0.0;
1699#endif
1700                      if ((coval) && (aTmp))
1701                      MINDEC(ret_c,2);
1702#if defined(_INT_REV_)
1703                      AARG2_INC |= aTmp;
1704#else
1705                      AARG2_INC += aTmp;
1706#endif
1707                    } else
1708                        if (TARG1 < TARG2)
1709                                FOR_0_LE_l_LT_p
1710                                { aTmp = ARES;
1711#if defined(_INT_REV_)
1712                                  ARES_INC = 0;
1713#else
1714                                  ARES_INC = 0.0;
1715#endif
1716                                  if ((!coval) && (aTmp))
1717                                  MINDEC(ret_c,2);
1718#if defined(_INT_REV_)
1719                                  AARG1_INC |= aTmp;
1720#else
1721                                  AARG1_INC += aTmp;
1722#endif
1723                                } else { /* both are equal */
1724                                    FOR_0_LE_l_LT_p
1725                                    { 
1726#if defined(_INT_REV_)
1727                                      aTmp = ARES;
1728                                      ARES_INC = 0;
1729                                      AARG2_INC |= aTmp;
1730                                      AARG1_INC |= aTmp;
1731#else
1732                                      aTmp = ARES / 2.0;
1733                                      ARES_INC = 0.0;
1734                                      AARG2_INC += aTmp;
1735                                      AARG1_INC += aTmp;
1736#endif
1737                                    }
1738                                    if (arg1 != arg2)
1739                                            MINDEC(ret_c,1);
1740                                    }
1741#else
1742                    FOR_0_LE_l_LT_p
1743                    { aTmp = ARES;
1744                      ARES_INC = 0;
1745                      AARG1_INC |= aTmp;
1746                      AARG2_INC |= aTmp;
1747                    }
1748#endif /* !_NTIGHT_ */
1749                break;
1750
1751                /*--------------------------------------------------------------------------*/
1752            case abs_val:                                                        /* abs_val */
1753                res   = get_locint_r();
1754                arg   = get_locint_r();
1755#if !defined(_NTIGHT_)
1756                coval = get_val_r();
1757
1758                ADOLC_GET_TAYLOR(res);
1759#endif /* !_NTIGHT_ */
1760
1761                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1762                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1763
1764#if defined(_ABS_NORM_)
1765                    if (rownum == switchnum) {
1766                        AARG = 1.0;
1767                    } else {
1768                        results[indep+switchnum] = ARES;
1769                        AARG = 0.0;
1770                        ARES = 0.0;
1771                    }
1772                    switchnum--;
1773#elif defined(_ABS_NORM_SIG_)
1774                    aTmp = ARES;
1775                    ARES_INC = 0.0;
1776                    AARG_INC += siggrad[switchnum]*aTmp;
1777                    switchnum--;
1778#else
1779#if !defined(_NTIGHT_)
1780                if (TARG < 0.0)
1781                    FOR_0_LE_l_LT_p
1782                    { aTmp = ARES;
1783#if defined(_INT_REV_)
1784                      ARES_INC = 0;
1785#else
1786                      ARES_INC = 0.0;
1787#endif
1788                      if ((coval) && (aTmp))
1789                      MINDEC(ret_c,2);
1790#if defined(_INT_REV_)
1791                      AARG_INC |= aTmp;
1792#else
1793                      AARG_INC -= aTmp;
1794#endif
1795                    } else
1796                        if (TARG > 0.0)
1797                                FOR_0_LE_l_LT_p
1798                                { aTmp = ARES;
1799#if defined(_INT_REV_)
1800                                  ARES_INC = 0;
1801#else
1802                                  ARES_INC = 0.0;
1803#endif
1804                                  if ((!coval) && (aTmp))
1805                                  MINDEC(ret_c,2);
1806#if defined(_INT_REV_)
1807                                  AARG_INC |= aTmp;
1808#else
1809                                  AARG_INC += aTmp;
1810#endif
1811                                } else
1812                                    FOR_0_LE_l_LT_p {
1813                                        aTmp = ARES;
1814#if defined(_INT_REV_)
1815                                        ARES_INC = 0;
1816#else
1817                                        ARES_INC = 0.0;
1818#endif
1819                                        if (aTmp)
1820                                            MINDEC(ret_c,1);
1821                                        }
1822#else
1823                                            FOR_0_LE_l_LT_p
1824                                            { aTmp = ARES;
1825                                              ARES_INC = 0;
1826                                              AARG_INC |= aTmp;
1827                                            }
1828#endif /* !_NTIGHT_ */
1829#endif /* _ABS_NORM */
1830             break;
1831
1832            /*--------------------------------------------------------------------------*/
1833        case ceil_op:                                              /* ceil_op */
1834               res   = get_locint_r();
1835                arg   = get_locint_r();
1836#if !defined(_NTIGHT_)
1837                coval = get_val_r();
1838
1839                ADOLC_GET_TAYLOR(res);
1840#endif /* !_NTIGHT_ */
1841
1842                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1843
1844#if !defined(_NTIGHT_)
1845                coval = (coval != ceil(TARG) );
1846#endif /* !_NTIGHT_ */
1847
1848                FOR_0_LE_l_LT_p
1849                {
1850#if !defined(_NTIGHT_)
1851                  if ((coval) && (ARES))
1852                  MINDEC(ret_c,2);
1853#endif /* !_NTIGHT_ */
1854#if defined(_INT_REV_)
1855                  ARES_INC = 0;
1856#else
1857                  ARES_INC = 0.0;
1858#endif
1859                }
1860                break;
1861
1862            /*--------------------------------------------------------------------------*/
1863        case floor_op:                                            /* floor_op */
1864                res   = get_locint_r();
1865                arg   = get_locint_r();
1866#if !defined(_NTIGHT_)
1867                coval = get_val_r();
1868
1869                ADOLC_GET_TAYLOR(res);
1870#endif /* !_NTIGHT_ */
1871
1872                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1873                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1874
1875#if !defined(_NTIGHT_)
1876                coval = ( coval != floor(TARG1) );
1877#endif /* !_NTIGHT_ */
1878
1879                FOR_0_LE_l_LT_p
1880                {
1881#if !defined(_NTIGHT_)
1882                  if ( (coval) && (ARES) )
1883                  MINDEC(ret_c,2);
1884#endif /* !_NTIGHT_ */
1885#if defined(_INT_REV_)
1886                  ARES_INC = 0;
1887#else
1888                  ARES_INC = 0.0;
1889#endif
1890                }
1891                break;
1892
1893
1894            /****************************************************************************/
1895            /*                                                             CONDITIONALS */
1896
1897            /*--------------------------------------------------------------------------*/
1898        case cond_assign:                                      /* cond_assign */
1899            res    = get_locint_r();
1900                arg2   = get_locint_r();
1901                arg1   = get_locint_r();
1902                arg    = get_locint_r();
1903#if !defined(_NTIGHT_)
1904                coval  = get_val_r();
1905
1906                ADOLC_GET_TAYLOR(res);
1907#endif /* !_NTIGHT_ */
1908
1909                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1910                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1911                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
1912
1913#if !defined(_NTIGHT_)
1914                /* olvo 980924 changed code a little bit */
1915                if (TARG > 0.0) {
1916                    if (res != arg1)
1917                        FOR_0_LE_l_LT_p
1918                        { if ((coval <= 0.0) && (ARES))
1919                          MINDEC(ret_c,2);
1920#if defined(_INT_REV_)
1921                              AARG1_INC |= ARES;
1922                              ARES_INC = 0;
1923#else
1924                          AARG1_INC += ARES;
1925                          ARES_INC = 0.0;
1926#endif
1927                        } else
1928                            FOR_0_LE_l_LT_p
1929                            if ((coval <= 0.0) && (ARES_INC))
1930                                    MINDEC(ret_c,2);
1931                } else {
1932                    if (res != arg2)
1933                        FOR_0_LE_l_LT_p
1934                        { if ((coval <= 0.0) && (ARES))
1935                          MINDEC(ret_c,2);
1936#if defined(_INT_REV_)
1937                          AARG2_INC |= ARES;
1938                          ARES_INC = 0;
1939#else
1940                          AARG2_INC += ARES;
1941                          ARES_INC = 0.0;
1942#endif
1943                        } else
1944                            FOR_0_LE_l_LT_p
1945                            if ((coval <= 0.0) && (ARES_INC))
1946                                    MINDEC(ret_c,2);
1947                }
1948#else
1949                    if (res != arg1) {
1950                        FOR_0_LE_l_LT_p
1951                        AARG1_INC |= ARES_INC;
1952                        ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1953                    }
1954                    if (res != arg2) {
1955                        FOR_0_LE_l_LT_p
1956                        AARG2_INC |= ARES_INC;
1957                        ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1958                    }
1959                    if ((res != arg1) && (res != arg2))
1960                        FOR_0_LE_l_LT_p
1961                        ARES_INC = 0;
1962#endif /* !_NTIGHT_ */
1963                break;
1964
1965        case cond_eq_assign:                                      /* cond_assign */
1966            res    = get_locint_r();
1967                arg2   = get_locint_r();
1968                arg1   = get_locint_r();
1969                arg    = get_locint_r();
1970#if !defined(_NTIGHT_)
1971                coval  = get_val_r();
1972
1973                ADOLC_GET_TAYLOR(res);
1974#endif /* !_NTIGHT_ */
1975
1976                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1977                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1978                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
1979
1980#if !defined(_NTIGHT_)
1981                /* olvo 980924 changed code a little bit */
1982                if (TARG >= 0.0) {
1983                    if (res != arg1)
1984                        FOR_0_LE_l_LT_p
1985                        { if ((coval < 0.0) && (ARES))
1986                          MINDEC(ret_c,2);
1987#if defined(_INT_REV_)
1988                              AARG1_INC |= ARES;
1989                              ARES_INC = 0;
1990#else
1991                          AARG1_INC += ARES;
1992                          ARES_INC = 0.0;
1993#endif
1994                        } else
1995                            FOR_0_LE_l_LT_p
1996                            if ((coval < 0.0) && (ARES_INC))
1997                                    MINDEC(ret_c,2);
1998                } else {
1999                    if (res != arg2)
2000                        FOR_0_LE_l_LT_p
2001                        { if ((coval < 0.0) && (ARES))
2002                          MINDEC(ret_c,2);
2003#if defined(_INT_REV_)
2004                          AARG2_INC |= ARES;
2005                          ARES_INC = 0;
2006#else
2007                          AARG2_INC += ARES;
2008                          ARES_INC = 0.0;
2009#endif
2010                        } else
2011                            FOR_0_LE_l_LT_p
2012                            if ((coval < 0.0) && (ARES_INC))
2013                                    MINDEC(ret_c,2);
2014                }
2015#else
2016                    if (res != arg1) {
2017                        FOR_0_LE_l_LT_p
2018                        AARG1_INC |= ARES_INC;
2019                        ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
2020                    }
2021                    if (res != arg2) {
2022                        FOR_0_LE_l_LT_p
2023                        AARG2_INC |= ARES_INC;
2024                        ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
2025                    }
2026                    if ((res != arg1) && (res != arg2))
2027                        FOR_0_LE_l_LT_p
2028                        ARES_INC = 0;
2029#endif /* !_NTIGHT_ */
2030                break;
2031
2032                /*--------------------------------------------------------------------------*/
2033            case cond_assign_s:                                  /* cond_assign_s */
2034                res   = get_locint_r();
2035                arg1  = get_locint_r();
2036                arg   = get_locint_r();
2037#if !defined(_NTIGHT_)
2038                coval = get_val_r();
2039
2040                ADOLC_GET_TAYLOR(res);
2041#endif /* !_NTIGHT_ */
2042
2043                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
2044                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
2045
2046#if !defined(_NTIGHT_)
2047                /* olvo 980924 changed code a little bit */
2048                if (TARG > 0.0) {
2049                    if (res != arg1)
2050                        FOR_0_LE_l_LT_p
2051                        { if ((coval <= 0.0) && (ARES))
2052                          MINDEC(ret_c,2);
2053#if defined(_INT_REV_)
2054                          AARG1_INC |= ARES;
2055                          ARES_INC = 0.0;
2056#else
2057                          AARG1_INC += ARES;
2058                          ARES_INC = 0.0;
2059#endif
2060                        } else
2061                            FOR_0_LE_l_LT_p
2062                            if ((coval <= 0.0) && (ARES_INC))
2063                                    MINDEC(ret_c,2);
2064                } else
2065                    if (TARG == 0.0) /* we are at the tie */
2066                        FOR_0_LE_l_LT_p
2067                        if (ARES_INC)
2068                            MINDEC(ret_c,0);
2069#else
2070                    if (res != arg1)
2071                        FOR_0_LE_l_LT_p
2072                        { AARG1 |= ARES;
2073                          ARES_INC = 0;
2074                        }
2075#endif /* !_NTIGHT_ */
2076                break;
2077
2078            case cond_eq_assign_s:                                  /* cond_eq_assign_s */
2079                res   = get_locint_r();
2080                arg1  = get_locint_r();
2081                arg   = get_locint_r();
2082#if !defined(_NTIGHT_)
2083                coval = get_val_r();
2084
2085                ADOLC_GET_TAYLOR(res);
2086#endif /* !_NTIGHT_ */
2087
2088                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
2089                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
2090
2091#if !defined(_NTIGHT_)
2092                /* olvo 980924 changed code a little bit */
2093                if (TARG >= 0.0) {
2094                    if (res != arg1)
2095                        FOR_0_LE_l_LT_p
2096                        { if ((coval < 0.0) && (ARES))
2097                          MINDEC(ret_c,2);
2098#if defined(_INT_REV_)
2099                          AARG1_INC |= ARES;
2100                          ARES_INC = 0.0;
2101#else
2102                          AARG1_INC += ARES;
2103                          ARES_INC = 0.0;
2104#endif
2105                        } else
2106                            FOR_0_LE_l_LT_p
2107                            if ((coval < 0.0) && (ARES_INC))
2108                                    MINDEC(ret_c,2);
2109                }
2110#else
2111                    if (res != arg1)
2112                        FOR_0_LE_l_LT_p
2113                        { AARG1 |= ARES;
2114                          ARES_INC = 0;
2115                        }
2116#endif /* !_NTIGHT_ */
2117                break;
2118
2119                /*--------------------------------------------------------------------------*/
2120                /* NEW CONDITIONALS */
2121                /*--------------------------------------------------------------------------*/
2122#if defined(ADOLC_ADVANCED_BRANCHING)
2123            case neq_a_a:
2124            case eq_a_a:
2125            case le_a_a:
2126            case ge_a_a:
2127            case lt_a_a:
2128            case gt_a_a:
2129            case neq_a_p:
2130            case eq_a_p:
2131            case le_a_p:
2132            case ge_a_p:
2133            case lt_a_p:
2134            case gt_a_p:
2135                res = get_locint_r();
2136                arg1 = get_locint_r();
2137                arg = get_locint_r();
2138#if !defined(_NTIGHT_)
2139                coval = get_val_r();
2140#endif
2141                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2142
2143                FOR_0_LE_l_LT_p
2144#if defined(_INT_REV_)
2145                ARES_INC = 0;
2146#else
2147                ARES_INC = 0.0;
2148#endif
2149
2150#if !defined(_NTIGHT_)
2151                ADOLC_GET_TAYLOR(res);
2152#endif /* !_NTIGHT_ */
2153
2154                break;
2155#endif
2156                /*--------------------------------------------------------------------------*/
2157            case subscript:
2158                {
2159#if !defined(_NTIGHT_)
2160                    double val = 
2161#endif
2162                    get_val_r();
2163                    res = get_locint_r();
2164#if !defined(_NTIGHT_)
2165                    size_t idx, numval = (size_t)trunc(fabs(val));
2166                    locint vectorloc;
2167                    vectorloc = 
2168#endif
2169                    get_locint_r();
2170                    arg = get_locint_r();
2171#if !defined(_NTIGHT_)
2172                    idx = (size_t)trunc(fabs(TARG));
2173                    if (idx >= numval)
2174                        fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting n=%zu, idx=%zu\n", numval, idx);
2175                    arg1 = vectorloc+idx;
2176                    ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
2177                    ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2178                    FOR_0_LE_l_LT_p
2179                    {
2180#if defined(_INT_REV_)
2181                        AARG1_INC |= ARES;
2182                        ARES_INC = 0;
2183#else
2184                        AARG1_INC += ARES;
2185                        ARES = 0.0;
2186#endif
2187                    }
2188                    ADOLC_GET_TAYLOR(res);
2189#else
2190                    fprintf(DIAG_OUT, "ADOL-C error: active subscripting does not work in safe mode, please use tight mode\n");
2191                    adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2192#endif /* !_NTIGHT_ */
2193                }
2194                break;
2195
2196            case subscript_ref:
2197                {
2198#if !defined(_NTIGHT_)
2199                    double val = 
2200#endif
2201                    get_val_r();
2202                    res = get_locint_r();
2203#if !defined(_NTIGHT_)
2204                    size_t idx, numval = (size_t)trunc(fabs(val));
2205                    locint vectorloc;
2206                    vectorloc = 
2207#endif
2208                    get_locint_r();
2209                    arg = get_locint_r();
2210#if !defined(_NTIGHT_)
2211                    idx = (size_t)trunc(fabs(TARG));
2212                    if (idx >= numval)
2213                        fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting (ref) n=%zu, idx=%zu\n", numval, idx);
2214                    arg1 = (size_t)trunc(fabs(TRES));
2215                    /*
2216                     * This is actually NOP
2217                     * basically all we need is that arg1 == vectorloc+idx
2218                     * so doing a check here is probably good
2219                     */
2220                    if (arg1 != vectorloc+idx) {
2221                        fprintf(DIAG_OUT, "ADOL-C error: indexed active position does not match referenced position\nindexed = %zu, referenced = %d\n", vectorloc+idx, arg1);
2222                        adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2223                    }
2224                    ADOLC_GET_TAYLOR(res);
2225#else
2226                    fprintf(DIAG_OUT, "ADOL-C error: active subscripting does not work in safe mode, please use tight mode\n");
2227                    adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2228#endif /* !_NTIGHT_ */
2229                }
2230                break;
2231
2232            case ref_copyout:
2233                res = get_locint_r();
2234                arg1 = get_locint_r();
2235#if !defined(_NTIGHT_)
2236                arg = (size_t)trunc(fabs(TARG1));
2237                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2238                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
2239               
2240                FOR_0_LE_l_LT_p
2241                {
2242#if defined(_INT_REV_)                 
2243                  AARG_INC |= ARES;
2244                  ARES_INC = 0;
2245#else
2246                  AARG_INC += ARES;
2247                  ARES_INC = 0.0;
2248#endif
2249                }
2250                ADOLC_GET_TAYLOR(res);
2251#else
2252                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2253                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2254#endif
2255                break;
2256
2257
2258            case ref_incr_a:                        /* Increment an adouble    incr_a */
2259            case ref_decr_a:                        /* Increment an adouble    decr_a */
2260                arg1   = get_locint_r();
2261
2262#if !defined(_NTIGHT_)
2263                res = (size_t)trunc(fabs(TARG1));
2264                ADOLC_GET_TAYLOR(res);
2265#else
2266                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2267                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2268#endif /* !_NTIGHT_ */
2269                break;
2270
2271            case ref_assign_d:            /* assign an adouble variable a    assign_d */
2272                /* double value. (=) */
2273                arg1   = get_locint_r();
2274#if !defined(_NTIGHT_)
2275                res = (size_t)trunc(fabs(TARG1));
2276                coval = get_val_r();
2277
2278                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2279
2280                FOR_0_LE_l_LT_p
2281#if defined(_INT_REV_)                 
2282                ARES_INC = 0;
2283#else
2284                ARES_INC = 0.0;
2285#endif
2286
2287                ADOLC_GET_TAYLOR(res);
2288#else
2289                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2290                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2291#endif /* !_NTIGHT_ */
2292                break;
2293
2294            case ref_assign_p:            /* assign an adouble variable a    assign_p */
2295                arg    = get_locint_r();
2296                arg1   = get_locint_r();
2297#if !defined(_NTIGHT_)
2298                res = (size_t)trunc(fabs(TARG1));
2299                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
2300
2301                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2302
2303                FOR_0_LE_l_LT_p
2304#if defined(_INT_REV_)                 
2305                ARES_INC = 0;
2306#else
2307                ARES_INC = 0.0;
2308#endif
2309
2310                ADOLC_GET_TAYLOR(res);
2311#else
2312                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2313                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2314#endif /* !_NTIGHT_ */
2315                break;
2316
2317            case ref_assign_d_zero:  /* assign an adouble variable a    assign_d_zero */
2318            case ref_assign_d_one:   /* double value (0 or 1). (=)       assign_d_one */
2319                arg1 = get_locint_r();
2320
2321#if !defined(_NTIGHT_)
2322                res = (size_t)trunc(fabs(TARG1));
2323
2324                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2325
2326                FOR_0_LE_l_LT_p
2327#if defined(_INT_REV_)                 
2328                ARES_INC = 0;
2329#else
2330                ARES_INC = 0.0;
2331#endif
2332                ADOLC_GET_TAYLOR(res);
2333#else
2334                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2335                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2336#endif /* !_NTIGHT_ */
2337                break;
2338
2339            case ref_assign_a:           /* assign an adouble variable an    assign_a */
2340                /* adouble value. (=) */
2341                arg1 = get_locint_r();
2342                arg = get_locint_r();
2343
2344#if !defined(_NTIGHT_)
2345                res = (size_t)trunc(fabs(TARG1));
2346
2347                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
2348                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2349
2350                FOR_0_LE_l_LT_p
2351                {
2352#if defined(_INT_REV_)                 
2353                  AARG_INC |= ARES;
2354                  ARES_INC = 0;
2355#else
2356                  AARG_INC += ARES;
2357                  ARES_INC = 0.0;
2358#endif
2359                }
2360
2361                ADOLC_GET_TAYLOR(res);
2362#else
2363                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2364                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2365#endif /* !_NTIGHT_ */
2366                break;
2367
2368            case ref_assign_ind:       /* assign an adouble variable an    assign_ind */
2369                /* independent double value (<<=) */
2370                arg1 = get_locint_r();
2371
2372#if !defined(_NTIGHT_)
2373                res = (size_t)trunc(fabs(TARG1));
2374
2375                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2376
2377                FOR_0_LE_l_LT_p
2378                    RESULTS(l,indexi) = ARES_INC;
2379
2380                ADOLC_GET_TAYLOR(res);
2381#else
2382                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2383                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2384#endif /* !_NTIGHT_ */
2385                indexi--;
2386                break;
2387
2388            case ref_eq_plus_d:            /* Add a floating point to an    eq_plus_d */
2389                /* adouble. (+=) */
2390                arg1   = get_locint_r();
2391#if !defined(_NTIGHT_)
2392                res = (size_t)trunc(fabs(TARG1));
2393                coval = get_val_r();
2394
2395                ADOLC_GET_TAYLOR(res);
2396#else
2397                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2398                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2399#endif /* !_NTIGHT_ */
2400                break;
2401
2402            case ref_eq_plus_p:            /* Add a floating point to an    eq_plus_d */
2403                /* adouble. (+=) */
2404                arg1   = get_locint_r();
2405                arg    = get_locint_r();
2406#if !defined(_NTIGHT_)
2407                res = (size_t)trunc(fabs(TARG1));
2408                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
2409
2410                ADOLC_GET_TAYLOR(res);
2411#else
2412                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2413                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2414#endif /* !_NTIGHT_ */
2415                break;
2416
2417            case ref_eq_plus_a:             /* Add an adouble to another    eq_plus_a */
2418                /* adouble. (+=) */
2419                arg1 = get_locint_r();
2420                arg = get_locint_r();
2421
2422#if !defined(_NTIGHT_)
2423                res = (size_t)trunc(fabs(TARG1));
2424
2425                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2426                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg]);
2427
2428                FOR_0_LE_l_LT_p
2429#if defined(_INT_REV_)
2430                AARG_INC |= ARES_INC;
2431#else
2432                AARG_INC += ARES_INC;
2433#endif
2434
2435                ADOLC_GET_TAYLOR(res);
2436#else
2437                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2438                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2439#endif /* !_NTIGHT_ */
2440                break;
2441
2442            case ref_eq_min_d:       /* Subtract a floating point from an    eq_min_d */
2443                /* adouble. (-=) */
2444                arg1   = get_locint_r();
2445#if !defined(_NTIGHT_)
2446                res = (size_t)trunc(fabs(TARG1));
2447                coval = get_val_r();
2448
2449                ADOLC_GET_TAYLOR(res);
2450#else
2451                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2452                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2453#endif /* !_NTIGHT_ */
2454               break;
2455
2456            case ref_eq_min_p:       /* Subtract a floating point from an    eq_min_p */
2457                /* adouble. (-=) */
2458                arg1   = get_locint_r();
2459                arg    = get_locint_r();
2460#if !defined(_NTIGHT_)
2461                res = (size_t)trunc(fabs(TARG1));
2462                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
2463
2464                ADOLC_GET_TAYLOR(res);
2465#else
2466                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2467                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2468#endif /* !_NTIGHT_ */
2469               break;
2470
2471            case ref_eq_min_a:        /* Subtract an adouble from another    eq_min_a */
2472                /* adouble. (-=) */
2473                arg1 = get_locint_r();
2474                arg = get_locint_r();
2475
2476#if !defined(_NTIGHT_)
2477                res = (size_t)trunc(fabs(TARG1));
2478                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2479                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
2480
2481                FOR_0_LE_l_LT_p
2482#if defined(_INT_REV_)
2483                AARG_INC |= ARES_INC;
2484#else
2485                AARG_INC -= ARES_INC;
2486#endif
2487
2488               ADOLC_GET_TAYLOR(res);
2489#else
2490                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2491                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2492#endif /* !_NTIGHT_ */
2493                break;
2494
2495            case ref_eq_mult_d:              /* Multiply an adouble by a    eq_mult_d */
2496                /* flaoting point. (*=) */
2497                arg1   = get_locint_r();
2498#if !defined(_NTIGHT_)
2499                res = (size_t)trunc(fabs(TARG1));
2500                coval = get_val_r();
2501
2502#if !defined(_INT_REV_)
2503                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2504
2505                FOR_0_LE_l_LT_p
2506                ARES_INC *= coval;
2507#endif
2508
2509                ADOLC_GET_TAYLOR(res);
2510#else
2511                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2512                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2513#endif /* !_NTIGHT_ */
2514                break;
2515
2516            case ref_eq_mult_p:              /* Multiply an adouble by a    eq_mult_p */
2517                /* flaoting point. (*=) */
2518                arg1   = get_locint_r();
2519                arg    = get_locint_r();
2520#if !defined(_NTIGHT_)
2521                res = (size_t)trunc(fabs(TARG1));
2522                coval = ADOLC_CURRENT_TAPE_INFOS.pTapeInfos.paramstore[arg];
2523
2524#if !defined(_INT_REV_)
2525                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2526
2527                FOR_0_LE_l_LT_p
2528                ARES_INC *= coval;
2529#endif
2530
2531                ADOLC_GET_TAYLOR(res);
2532#else
2533                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2534                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2535#endif /* !_NTIGHT_ */
2536                break;
2537
2538            case ref_eq_mult_a:       /* Multiply one adouble by another    eq_mult_a */
2539                /* (*=) */
2540                arg1 = get_locint_r();
2541                arg = get_locint_r();
2542
2543#if !defined(_NTIGHT_)
2544                res = (size_t)trunc(fabs(TARG1));
2545                ADOLC_GET_TAYLOR(res);
2546
2547                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2548                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
2549
2550                FOR_0_LE_l_LT_p
2551#if defined(_INT_REV_)
2552                AARG_INC |= ARES_INC;
2553#else
2554                { aTmp = ARES;
2555                  /* olvo 980713 nn: ARES = 0.0; */
2556                    ARES_INC =  (aTmp==0)?0:(aTmp * TARG);
2557                    AARG_INC += (aTmp==0)?0:(aTmp * TRES);
2558                }
2559#endif     
2560#else
2561                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2562                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2563#endif /* !_NTIGHT_ */
2564                break;
2565
2566        case vec_copy:
2567                res = get_locint_r();
2568                size = get_locint_r();
2569                arg = get_locint_r();
2570                for (qq=0;qq<size;qq++) {
2571
2572                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg+qq])
2573                ASSIGN_A( Ares, ADJOINT_BUFFER[res+qq])
2574
2575                FOR_0_LE_l_LT_p
2576                {
2577#if defined(_INT_REV_)
2578                  AARG_INC |= ARES;
2579                  ARES_INC = 0;
2580#else
2581                  AARG_INC += ARES;
2582                  ARES_INC = 0.0;
2583#endif
2584                }
2585
2586#if !defined(_NTIGHT_)
2587                ADOLC_GET_TAYLOR(res+qq);
2588#endif /* !_NTIGHT_ */
2589                }
2590
2591                break;
2592
2593        case vec_dot:
2594                res = get_locint_r();
2595                size = get_locint_r();
2596                arg2 = get_locint_r();
2597                arg1 = get_locint_r();
2598                for (qq=0;qq<size;qq++) {
2599                    ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
2600                    ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
2601                    ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
2602                    FOR_0_LE_l_LT_p
2603                    { 
2604#if defined(_INT_REV_)
2605                        AARG2_INC |= ARES;
2606                        AARG1_INC |= ARES_INC;
2607#else
2608                        AARG2_INC += ARES    * TARG1;
2609                        AARG1_INC += ARES_INC * TARG2;
2610#endif
2611                    }
2612                    arg2++;
2613                    arg1++;
2614                }
2615#if !defined(_NTIGHT_)
2616                ADOLC_GET_TAYLOR(res);
2617#endif /* !_NTIGHT_ */
2618                break;
2619
2620        case vec_axpy:
2621                res = get_locint_r();
2622                size = get_locint_r();
2623                arg2 = get_locint_r();
2624                arg1 = get_locint_r();
2625                arg = get_locint_r();
2626                for (qq=0;qq<size;qq++) {
2627                    ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
2628                    ASSIGN_A( Aarg,  ADJOINT_BUFFER[arg])
2629                    ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
2630                    ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
2631                    FOR_0_LE_l_LT_p
2632                    { 
2633#if defined(_INT_REV_)
2634                        AARG_INC |= ARES;
2635                        AARG2_INC |= ARES;
2636                        AARG1_INC |= ARES_INC;
2637#else
2638                        AARG2_INC += ARES;
2639                        AARG1_INC += ARES * TARG;
2640                        AARG_INC += ARES_INC * TARG1;
2641#endif
2642                    }
2643#if !defined(_NTIGHT_)
2644                    ADOLC_GET_TAYLOR(res);
2645#endif /* !_NTIGHT_ */
2646                    arg2++;
2647                    arg1++;
2648                    res++;
2649                }
2650                break;
2651
2652        case ref_cond_assign:                                      /* cond_assign */
2653           {
2654#if !defined(_NTIGHT_)
2655                locint ref    = 
2656#endif
2657                get_locint_r();
2658                arg2   = get_locint_r();
2659                arg1   = get_locint_r();
2660                arg    = get_locint_r();
2661#if !defined(_NTIGHT_)
2662                coval  = get_val_r();
2663                res = (size_t)trunc(fabs(rp_T[ref]));
2664
2665                ADOLC_GET_TAYLOR(res);
2666
2667                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
2668                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
2669                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
2670
2671                /* olvo 980924 changed code a little bit */
2672                if (TARG > 0.0) {
2673                    if (res != arg1)
2674                        FOR_0_LE_l_LT_p
2675                        { if ((coval <= 0.0) && (ARES))
2676                          MINDEC(ret_c,2);
2677#if defined(_INT_REV_)
2678                              AARG1_INC |= ARES;
2679                              ARES_INC = 0;
2680#else
2681                          AARG1_INC += ARES;
2682                          ARES_INC = 0.0;
2683#endif
2684                        } else
2685                            FOR_0_LE_l_LT_p
2686                            if ((coval <= 0.0) && (ARES_INC))
2687                                    MINDEC(ret_c,2);
2688                } else {
2689                    if (res != arg2)
2690                        FOR_0_LE_l_LT_p
2691                        { if ((coval <= 0.0) && (ARES))
2692                          MINDEC(ret_c,2);
2693#if defined(_INT_REV_)
2694                          AARG2_INC |= ARES;
2695                          ARES_INC = 0;
2696#else
2697                          AARG2_INC += ARES;
2698                          ARES_INC = 0.0;
2699#endif
2700                        } else
2701                            FOR_0_LE_l_LT_p
2702                            if ((coval <= 0.0) && (ARES_INC))
2703                                    MINDEC(ret_c,2);
2704                }
2705#else
2706                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2707                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2708#endif /* !_NTIGHT_ */
2709                }
2710                break;
2711
2712        case ref_cond_eq_assign:                                      /* cond_eq_assign */
2713           {
2714#if !defined(_NTIGHT_)
2715                locint ref    = 
2716#endif
2717                get_locint_r();
2718                arg2   = get_locint_r();
2719                arg1   = get_locint_r();
2720                arg    = get_locint_r();
2721#if !defined(_NTIGHT_)
2722                coval  = get_val_r();
2723                res = (size_t)trunc(fabs(rp_T[ref]));
2724
2725                ADOLC_GET_TAYLOR(res);
2726
2727                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
2728                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
2729                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
2730
2731                /* olvo 980924 changed code a little bit */
2732                if (TARG >= 0.0) {
2733                    if (res != arg1)
2734                        FOR_0_LE_l_LT_p
2735                        { if ((coval < 0.0) && (ARES))
2736                          MINDEC(ret_c,2);
2737#if defined(_INT_REV_)
2738                              AARG1_INC |= ARES;
2739                              ARES_INC = 0;
2740#else
2741                          AARG1_INC += ARES;
2742                          ARES_INC = 0.0;
2743#endif
2744                        } else
2745                            FOR_0_LE_l_LT_p
2746                            if ((coval < 0.0) && (ARES_INC))
2747                                    MINDEC(ret_c,2);
2748                } else {
2749                    if (res != arg2)
2750                        FOR_0_LE_l_LT_p
2751                        { if ((coval < 0.0) && (ARES))
2752                          MINDEC(ret_c,2);
2753#if defined(_INT_REV_)
2754                          AARG2_INC |= ARES;
2755                          ARES_INC = 0;
2756#else
2757                          AARG2_INC += ARES;
2758                          ARES_INC = 0.0;
2759#endif
2760                        } else
2761                            FOR_0_LE_l_LT_p
2762                            if ((coval < 0.0) && (ARES_INC))
2763                                    MINDEC(ret_c,2);
2764                }
2765#else
2766                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2767                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2768#endif /* !_NTIGHT_ */
2769                }
2770                break;
2771
2772            case ref_cond_assign_s:                                  /* cond_assign_s */
2773                arg2   = get_locint_r();
2774                arg1  = get_locint_r();
2775                arg   = get_locint_r();
2776#if !defined(_NTIGHT_)
2777                coval = get_val_r();
2778                res = (size_t)trunc(fabs(TARG2));
2779                ADOLC_GET_TAYLOR(res);
2780
2781                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
2782                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
2783
2784                /* olvo 980924 changed code a little bit */
2785                if (TARG > 0.0) {
2786                    if (res != arg1)
2787                        FOR_0_LE_l_LT_p
2788                        { if ((coval <= 0.0) && (ARES))
2789                          MINDEC(ret_c,2);
2790#if defined(_INT_REV_)
2791                          AARG1_INC |= ARES;
2792                          ARES_INC = 0.0;
2793#else
2794                          AARG1_INC += ARES;
2795                          ARES_INC = 0.0;
2796#endif
2797                        } else
2798                            FOR_0_LE_l_LT_p
2799                            if ((coval <= 0.0) && (ARES_INC))
2800                                    MINDEC(ret_c,2);
2801                } else
2802                    if (TARG == 0.0) /* we are at the tie */
2803                        FOR_0_LE_l_LT_p
2804                        if (ARES_INC)
2805                            MINDEC(ret_c,0);
2806#else
2807                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2808                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2809#endif /* !_NTIGHT_ */
2810                break;
2811
2812            case ref_cond_eq_assign_s:                                  /* cond_eq_assign_s */
2813                arg2   = get_locint_r();
2814                arg1  = get_locint_r();
2815                arg   = get_locint_r();
2816#if !defined(_NTIGHT_)
2817                coval = get_val_r();
2818                res = (size_t)trunc(fabs(TARG2));
2819                ADOLC_GET_TAYLOR(res);
2820
2821                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
2822                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
2823
2824                /* olvo 980924 changed code a little bit */
2825                if (TARG >= 0.0) {
2826                    if (res != arg1)
2827                        FOR_0_LE_l_LT_p
2828                        { if ((coval < 0.0) && (ARES))
2829                          MINDEC(ret_c,2);
2830#if defined(_INT_REV_)
2831                          AARG1_INC |= ARES;
2832                          ARES_INC = 0.0;
2833#else
2834                          AARG1_INC += ARES;
2835                          ARES_INC = 0.0;
2836#endif
2837                        } else
2838                            FOR_0_LE_l_LT_p
2839                            if ((coval < 0.0) && (ARES_INC))
2840                                    MINDEC(ret_c,2);
2841                }
2842#else
2843                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2844                adolc_exit(-2,"",__func__,__FILE__,__LINE__);
2845#endif /* !_NTIGHT_ */
2846                break;
2847
2848
2849                /****************************************************************************/
2850                /*                                                          REMAINING STUFF */
2851
2852                /*--------------------------------------------------------------------------*/
2853            case take_stock_op:                                  /* take_stock_op */
2854                res  = get_locint_r();
2855                size = get_locint_r();
2856#if !defined(_NTIGHT_)
2857                get_val_v_r(size);
2858#endif /* !_NTIGHT_ */
2859
2860                res += size;
2861                for (ls=size; ls>0; ls--) {
2862                    res--;
2863
2864                    ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2865
2866                    FOR_0_LE_l_LT_p
2867                    ARES_INC = 0.0;
2868                }
2869                break;
2870
2871                /*--------------------------------------------------------------------------*/
2872            case death_not:                                          /* death_not */
2873                arg2 = get_locint_r();
2874                arg1 = get_locint_r();
2875
2876                for (j=arg1;j<=arg2;j++) {
2877                    ASSIGN_A(Aarg1, ADJOINT_BUFFER[j])
2878
2879                    FOR_0_LE_l_LT_p
2880                    AARG1_INC = 0.0;
2881                }
2882
2883#if !defined(_NTIGHT_)
2884                for (j=arg1;j<=arg2;j++)
2885                    ADOLC_GET_TAYLOR(j);
2886#endif /* !_NTIGHT_ */
2887                break;
2888
2889#if !defined(_INT_REV_)
2890                /*--------------------------------------------------------------------------*/
2891            case ext_diff:                       /* extern differntiated function */
2892                ADOLC_CURRENT_TAPE_INFOS.cpIndex = get_locint_r();
2893                ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev = get_locint_r();
2894                ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev = get_locint_r();
2895                m = get_locint_r();
2896                n = get_locint_r();
2897                ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index = get_locint_r();
2898                ADOLC_EXT_FCT_SAVE_NUMDIRS;
2899                edfct = get_ext_diff_fct(ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index);
2900
2901                oldTraceFlag = ADOLC_CURRENT_TAPE_INFOS.traceFlag;
2902                ADOLC_CURRENT_TAPE_INFOS.traceFlag = 0;
2903
2904                if (edfct->ADOLC_EXT_FCT_POINTER == NULL)
2905                    fail(ADOLC_EXT_DIFF_NULLPOINTER_FUNCTION);
2906                if (m>0) {
2907                    if (ADOLC_EXT_FCT_U == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
2908                    if (edfct->dp_y==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
2909                }
2910                if (n>0) {
2911                    if (ADOLC_EXT_FCT_Z == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
2912                    if (edfct->dp_x==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
2913                }
2914                arg = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev;
2915                for (loop = 0; loop < m; ++loop) {
2916                    ADOLC_EXT_FCT_COPY_ADJOINTS(ADOLC_EXT_FCT_U[loop],ADJOINT_BUFFER_ARG);
2917                    ++arg;
2918                }
2919
2920                arg = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev;
2921                for (loop = 0; loop < n; ++loop) {
2922                    ADOLC_EXT_FCT_COPY_ADJOINTS(ADOLC_EXT_FCT_Z[loop],ADJOINT_BUFFER_ARG);
2923                    ++arg;
2924                }
2925                arg = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev;
2926                for (loop = 0; loop < n; ++loop,++arg) {
2927                  edfct->dp_x[loop]=TARG;
2928                }
2929                arg = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev;
2930                for (loop = 0; loop < m; ++loop,++arg) {
2931                  edfct->dp_y[loop]=TARG;
2932                }
2933                ext_retc = edfct->ADOLC_EXT_FCT_COMPLETE;
2934                MINDEC(ret_c, ext_retc);
2935
2936                res = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev;
2937                for (loop = 0; loop < m; ++loop) {
2938                    FOR_0_LE_l_LT_p {
2939                        ADJOINT_BUFFER_RES_L = 0.; /* \bar{v}_i = 0 !!! */
2940                    }
2941                    ++res;
2942                }
2943                res = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev;
2944                for (loop = 0; loop < n; ++loop) {
2945                    ADOLC_EXT_FCT_COPY_ADJOINTS_BACK(ADOLC_EXT_FCT_Z[loop],ADJOINT_BUFFER_RES);
2946                    ++res;
2947                }
2948                if (edfct->dp_y_priorRequired) {
2949                  arg = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev+m-1;
2950                  for (loop = 0; loop < m; ++loop,--arg) {
2951                    ADOLC_GET_TAYLOR(arg);
2952                  }
2953                }
2954                if (edfct->dp_x_changes) {
2955                  arg = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev+n-1;
2956                  for (loop = 0; loop < n; ++loop,--arg) {
2957                    ADOLC_GET_TAYLOR(arg);
2958                  }
2959                }
2960                ADOLC_CURRENT_TAPE_INFOS.traceFlag = oldTraceFlag;
2961
2962                break;
2963            case ext_diff_iArr:                       /* extern differntiated function */
2964                ADOLC_CURRENT_TAPE_INFOS.cpIndex = get_locint_r();
2965                ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev = get_locint_r();
2966                ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev = get_locint_r();
2967                m = get_locint_r();
2968                n = get_locint_r();
2969                ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index = get_locint_r();
2970                iArrLength=get_locint_r();
2971                iArr=(int*)malloc(iArrLength*sizeof(int));
2972                for (loop=iArrLength-1;loop>=0;--loop) iArr[loop]=get_locint_r();
2973                get_locint_r(); /* get it again */
2974                ADOLC_EXT_FCT_SAVE_NUMDIRS;
2975                edfct = get_ext_diff_fct(ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index);
2976
2977                oldTraceFlag = ADOLC_CURRENT_TAPE_INFOS.traceFlag;
2978                ADOLC_CURRENT_TAPE_INFOS.traceFlag = 0;
2979
2980                if (edfct->ADOLC_EXT_FCT_IARR_POINTER == NULL)
2981                    fail(ADOLC_EXT_DIFF_NULLPOINTER_FUNCTION);
2982                if (m>0) {
2983                    if (ADOLC_EXT_FCT_U == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
2984                    if (edfct->dp_y==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
2985                }
2986                if (n>0) {
2987                    if (ADOLC_EXT_FCT_Z == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
2988                    if (edfct->dp_x==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
2989                }
2990                arg = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev;
2991                for (loop = 0; loop < m; ++loop) {
2992                    ADOLC_EXT_FCT_COPY_ADJOINTS(ADOLC_EXT_FCT_U[loop],ADJOINT_BUFFER_ARG);
2993                    ++arg;
2994                }
2995
2996                arg = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev;
2997                for (loop = 0; loop < n; ++loop) {
2998                    ADOLC_EXT_FCT_COPY_ADJOINTS(ADOLC_EXT_FCT_Z[loop],ADJOINT_BUFFER_ARG);
2999                    ++arg;
3000                }
3001                arg = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev;
3002                for (loop = 0; loop < n; ++loop,++arg) {
3003                  edfct->dp_x[loop]=TARG;
3004                }
3005                arg = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev;
3006                for (loop = 0; loop < m; ++loop,++arg) {
3007                  edfct->dp_y[loop]=TARG;
3008                }
3009                ext_retc = edfct->ADOLC_EXT_FCT_IARR_COMPLETE;
3010                MINDEC(ret_c, ext_retc);
3011
3012                res = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev;
3013                for (loop = 0; loop < m; ++loop) {
3014                    FOR_0_LE_l_LT_p {
3015                        ADJOINT_BUFFER_RES_L = 0.; /* \bar{v}_i = 0 !!! */
3016                    }
3017                    ++res;
3018                }
3019                res = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev;
3020                for (loop = 0; loop < n; ++loop) {
3021                    ADOLC_EXT_FCT_COPY_ADJOINTS_BACK(ADOLC_EXT_FCT_Z[loop],ADJOINT_BUFFER_RES);
3022                    ++res;
3023                }
3024                if (edfct->dp_y_priorRequired) {
3025                  arg = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev+m-1;
3026                  for (loop = 0; loop < m; ++loop,--arg) {
3027                    ADOLC_GET_TAYLOR(arg);
3028                  }
3029                }
3030                if (edfct->dp_x_changes) {
3031                  arg = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev+n-1;
3032                  for (loop = 0; loop < n; ++loop,--arg) {
3033                    ADOLC_GET_TAYLOR(arg);
3034                  }
3035                }
3036                ADOLC_CURRENT_TAPE_INFOS.traceFlag = oldTraceFlag;
3037
3038                break;
3039            case ext_diff_v2:
3040                nout = get_locint_r();
3041                nin = get_locint_r();
3042                insz = malloc(2*(nin+nout)*sizeof(locint));
3043                outsz = insz + nin;
3044                ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_ext_v2 = outsz + nout;
3045                ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_ext_v2 = outsz + nout + nin;
3046                for (loop=nout-1;loop>=0;--loop) {
3047                    ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_ext_v2[loop] = get_locint_r();
3048                    outsz[loop] = get_locint_r();
3049                }
3050                for (loop=nin-1;loop>=0;--loop) {
3051                    ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_ext_v2[loop] = get_locint_r();
3052                    insz[loop] = get_locint_r();
3053                }
3054                get_locint_r(); /* nout again */
3055                get_locint_r(); /* nin again */
3056                iArrLength = get_locint_r();
3057                iArr = malloc(iArrLength*sizeof(int));
3058                for (loop=iArrLength-1;loop>=0;--loop) iArr[loop] = get_locint_r();
3059                get_locint_r(); /* iArrLength again */
3060                ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index=get_locint_r();
3061                ADOLC_EXT_FCT_SAVE_NUMDIRS;
3062                edfct2 = get_ext_diff_fct_v2(ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index);
3063                oldTraceFlag = ADOLC_CURRENT_TAPE_INFOS.traceFlag;
3064                ADOLC_CURRENT_TAPE_INFOS.traceFlag = 0;
3065               
3066                if (edfct2->ADOLC_EXT_FCT_POINTER == NULL)
3067                    fail(ADOLC_EXT_DIFF_NULLPOINTER_FUNCTION);
3068                if (nout>0) {
3069                    if (ADOLC_EXT_FCT_V2_U == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
3070                    if (edfct2->y == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
3071                }
3072                if (nin>0) {
3073                    if (ADOLC_EXT_FCT_V2_Z == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
3074                    if (edfct2->x == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
3075                }
3076                for (oloop=0;oloop<nout;++oloop) {
3077                    arg = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_ext_v2[oloop];
3078                    for (loop = 0; loop < outsz[oloop]; ++loop) {
3079                        ADOLC_EXT_FCT_COPY_ADJOINTS(ADOLC_EXT_FCT_V2_U_LOOP,ADJOINT_BUFFER_ARG);
3080                        edfct2->y[oloop][loop]=TARG;
3081                        ++arg;
3082                    }
3083                }
3084                for (oloop=0;oloop<nin;++oloop) {
3085                    arg = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_ext_v2[oloop];
3086                    for (loop =0; loop < insz[oloop]; ++loop) {
3087                        ADOLC_EXT_FCT_COPY_ADJOINTS(ADOLC_EXT_FCT_V2_Z_LOOP, ADJOINT_BUFFER_ARG);
3088                        edfct2->x[oloop][loop]=TARG;
3089                        ++arg;
3090                    }
3091                }
3092                ext_retc = edfct2->ADOLC_EXT_FCT_V2_COMPLETE;
3093                MINDEC(ret_c, ext_retc);
3094                for (oloop=0;oloop<nout;++oloop) {
3095                    res = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_ext_v2[oloop];
3096                    for (loop =0; loop < outsz[oloop]; ++loop) {
3097                        FOR_0_LE_l_LT_p {
3098                            ADJOINT_BUFFER_RES_L = 0.0; /* \bar{v}_i = 0 !!! */
3099                        }
3100                        ++res;
3101                    }
3102                }
3103                for (oloop=0;oloop<nin;++oloop) {
3104                    res = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_ext_v2[oloop];
3105                    for(loop = 0; loop<insz[oloop]; ++loop) {
3106                        ADOLC_EXT_FCT_COPY_ADJOINTS_BACK(ADOLC_EXT_FCT_V2_Z_LOOP,ADJOINT_BUFFER_RES);
3107                        ++res;
3108                    }
3109                }
3110                if (edfct2->dp_y_priorRequired) {
3111                    for(oloop=nout-1;oloop>=0;--oloop) {
3112                        arg = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_ext_v2[oloop]+outsz[oloop]-1;
3113                        for (loop=outsz[oloop]-1; loop>=0; --loop) {
3114                            ADOLC_GET_TAYLOR(arg);
3115                            --arg;
3116                        }
3117                    }
3118                }
3119                if (edfct2->dp_x_changes) {
3120                    for(oloop=nin-1;oloop>=0;--oloop) {
3121                        arg = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_ext_v2[oloop]+insz[oloop]-1;
3122                        for (loop=insz[oloop]-1; loop>=0; --loop) {
3123                            ADOLC_GET_TAYLOR(arg);
3124                            --arg;
3125                        }
3126                    }
3127                }
3128                ADOLC_CURRENT_TAPE_INFOS.traceFlag = oldTraceFlag;
3129                free(iArr);
3130                free(insz);
3131                insz = 0;
3132                iArr = 0;
3133                outsz = 0;
3134                ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_ext_v2 = 0;
3135                ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_ext_v2 = 0;
3136                break;
3137
3138#ifdef ADOLC_AMPI_SUPPORT
3139                /*--------------------------------------------------------------------------*/
3140            case ampi_send: {
3141              BW_AMPI_Send(buf,
3142                           count,
3143                           datatype,
3144                           src,
3145                           tag,
3146                           pairedWith,
3147                           comm);
3148              break;
3149            }
3150            case ampi_recv: {
3151              BW_AMPI_Recv(buf,
3152                           count,
3153                           datatype,
3154                           src,
3155                           tag,
3156                           pairedWith,
3157                           comm,
3158                           status);
3159              break;
3160            }
3161          case ampi_isend: { 
3162            BW_AMPI_Isend(buf,
3163                          count,
3164                          datatype,
3165                          src,
3166                          tag,
3167                          pairedWith,
3168                          comm,
3169                          &request);
3170            break;
3171          }
3172          case ampi_irecv: {
3173            BW_AMPI_Irecv(buf,
3174                          count,
3175                          datatype,
3176                          src,
3177                          tag,
3178                          pairedWith,
3179                          comm,
3180                          &request);
3181            break;
3182          }
3183          case ampi_wait: { 
3184            BW_AMPI_Wait(&request,
3185                         status);
3186            break;
3187          }
3188          case ampi_barrier: {
3189            BW_AMPI_Barrier(comm);
3190            break;
3191          }
3192          case ampi_gather: { 
3193            BW_AMPI_Gather(buf,
3194                           count,
3195                           datatype,
3196                           rbuf,
3197                           rcount,
3198                           rtype,
3199                           src,
3200                           comm);
3201            break;
3202          }
3203          case ampi_scatter: {
3204            BW_AMPI_Scatter(rbuf,
3205                            rcount,
3206                            rtype,
3207                            buf,
3208                            count,
3209                            datatype,
3210                            src,
3211                            comm);
3212            break;
3213          }
3214          case ampi_allgather: {
3215            BW_AMPI_Allgather(buf,
3216                              count,
3217                              datatype,
3218                              rbuf,
3219                              rcount,
3220                              rtype,
3221                              comm);
3222            break;
3223          }
3224          case ampi_gatherv: {
3225            BW_AMPI_Gatherv(buf,
3226                            count,
3227                            datatype,
3228                            rbuf,
3229                            NULL,
3230                            NULL,
3231                            rtype,
3232                            src,
3233                            comm);
3234            break;
3235          }
3236          case ampi_scatterv: { 
3237            BW_AMPI_Scatterv(rbuf,
3238                             NULL,
3239                             NULL,
3240                             rtype,
3241                             buf,
3242                             count,
3243                             datatype,
3244                             src,
3245                             comm);
3246            break;
3247          }
3248          case ampi_allgatherv: {
3249            BW_AMPI_Allgatherv(buf,
3250                               count,
3251                               datatype,
3252                               rbuf,
3253                               NULL,
3254                               NULL,
3255                               rtype,
3256                               comm);
3257            break;
3258          }
3259          case ampi_bcast: {
3260            BW_AMPI_Bcast(buf,
3261                          count,
3262                          datatype,
3263                          src,
3264                          comm);
3265            break;
3266          }
3267          case ampi_reduce: {
3268            BWB_AMPI_Reduce(buf,
3269                           rbuf,
3270                           count,
3271                           datatype,
3272                           op,
3273                           src,
3274                           comm);
3275            break;
3276          }
3277          case ampi_allreduce: {
3278            BW_AMPI_Allreduce(buf,
3279                              rbuf,
3280                              count,
3281                              datatype,
3282                              op,
3283                              comm);
3284            break;
3285          }
3286#endif
3287#endif /* !_INT_REV_ */
3288                /*--------------------------------------------------------------------------*/
3289            default:                                                   /* default */
3290                /*             Die here, we screwed up     */
3291
3292                fprintf(DIAG_OUT,"ADOL-C fatal error in " GENERATED_FILENAME " ("
3293                        __FILE__
3294                        ") : no such operation %d\n", operation);
3295                adolc_exit(-1,"",__func__,__FILE__,__LINE__);
3296                break;
3297        } /* endswitch */
3298
3299        /* Get the next operation */
3300        operation=get_op_r();
3301    } /* endwhile */
3302
3303    /* clean up */
3304#if !defined(_INT_REV_)
3305    free(rp_T);
3306#endif
3307#ifdef _FOS_
3308    free(rp_A);
3309#endif
3310#ifdef _FOV_
3311    free(Aqo);
3312    free(rpp_A);
3313#endif
3314#ifdef _INT_REV_
3315    free(upp_A);
3316#endif
3317
3318    ADOLC_CURRENT_TAPE_INFOS.workMode = ADOLC_NO_MODE;
3319    end_sweep();
3320
3321    return ret_c;
3322}
3323
3324
3325/****************************************************************************/
3326/*                                                               THAT'S ALL */
3327
3328END_C_DECLS
Note: See TracBrowser for help on using the repository browser.