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

Last change on this file since 708 was 708, checked in by kulshres, 3 years ago

Merge branch 'master' of 'gitclone' into 'svn'

The following changes have been merged:

commit e2291bde44a282a133894b0db350aeb0b92a87db
Author: Mladen Banovic <mladenbanovic2705@…>
Date: Fri Jul 8 10:15:51 2016 +0200

Add methods getNumLiveVar and getNumDir in adtl.h, change counter type in FOR_I_EQ_0_LT_NUMDIR macro to size_t (instead of int). Update chunk size of BOOST pool in adouble_tl.cpp according to adouble::numDir.

commit 2ffb294465b973bfd4bf1f73d84478f8233c0d2f
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Jun 23 12:32:14 2016 +0200

implement missing ref_eq_mult_p und ref_eq_min_p in ho_rev.c

somehow these were left out when parameters were being implemented.

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

commit 8cf0e5c1bd36f1dcf3be72cd67de631b2e1d0ee6
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Jun 23 12:31:04 2016 +0200

make sure the result is the last locint written in trace for each operation

since we're trying to generate ascii traces in the future, we'll need this
convention that the last location is the result, and previous locations
are arguments. This has been the case for almost all operations anyway
except for a few new one's that I wrote without keeping this in mind.

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

commit 9ae0ff220f37463f2ed85cafc8a626c24e472f2f
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue Jun 21 14:16:27 2016 +0200

on some compilers newer boost interferes with AC_FUNC_MALLOC test

so do AC_FUNC_MALLOC and AC_FUNC_REALLOC as usual and check for boost
library later.

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

commit b746f620772cc8cce53e8f350adc6281279caf72
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Jun 20 15:32:22 2016 +0200

make Klaus Röbenack's name UTF-8 instead of ISO-8859-1

These are the only places where we're not simple ASCII or UTF-8 already

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

commit 1171aa3961b5eb46a5d2ee64751c02a393a8a6f5
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Jun 17 10:42:39 2016 +0200

correct short_ref document about include file

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

commit 2c6b2aac2ef04431ece2c6ff80e574aa2e58814b
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Jun 17 10:40:34 2016 +0200

correct error message to new semantics

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

commit 506cde73451740bf0a15eff7d4abb158ee719ab0
Author: mflehmig <martin.flehmig@…>
Date: Fri Jun 17 10:14:26 2016 +0200

Fixed include of ADOL-C header.

ADOL-C header was included in old fashion (without adolc directory) for this example.

commit 2a023d3281d3d6d9824bad724a5768e3ee2fff94
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Jun 16 13:50:39 2016 +0200

Try to use boost::pool for allocating advals in traceless vector mode

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

commit 80f1e2019ac1faab96fe06f3e9da47efcc1bcd23
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon May 23 15:13:22 2016 +0200

correct a reference in doc and rebuild

commit d7ab5283afe58bacb2e8739d72ede4e17f4c8081
Author: Mladen Banovic <mladenbanovic2705@…>
Date: Fri May 20 16:42:13 2016 +0200

Update section 7 of adolc-manual related to the Traceless forward differentiation.

commit bedb8e36f959c5272e4610fe504acc83208e5e9d
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue May 17 16:09:36 2016 +0200

macro name correction

commit 92ff596a0331776901df7f172ca347572e3daafd
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Tue May 17 15:56:17 2016 +0200

Add a warning about using static build of ADOL-C

static build of ADOL-C does not call constructors
for internal global objects, thereby causing
segmentation faults.

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

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