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

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

use the option --enable-advanced-branching for new comparison operations

the configure option --enable-advanced-branching sets ADOLC_ADVANCED_BRANCHING
and this is unset by default. The new comparison operators that can
handle branching in conjunction with condassign and advectors will only
be compiled if this option is used.

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

  • Property svn:keywords set to Author Date Id Revision
File size: 75.3 KB
Line 
1/*----------------------------------------------------------------------------
2 ADOL-C -- Automatic Differentiation by Overloading in C++
3 File:     fo_rev.c
4 Revision: $Id: fo_rev.c 376 2012-12-14 11:22:56Z 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#define GENERATED_FILENAME "fos_reverse"
67
68#define RESULTS(l,indexi)  results[indexi]
69#define LAGRANGE(l,indexd) lagrange[indexd]
70
71/*--------------------------------------------------------------------------*/
72#elif _FOV_
73#define GENERATED_FILENAME "fov_reverse"
74
75#define _ADOLC_VECTOR_
76
77#define RESULTS(l,indexi)  results[l][indexi]
78#define LAGRANGE(l,indexd) lagrange[l][indexd]
79
80#else
81#if defined(_INT_REV_)
82#if defined(_TIGHT_)
83#define GENERATED_FILENAME "int_reverse_t"
84#endif
85#if defined(_NTIGHT_)
86#define GENERATED_FILENAME "int_reverse_s"
87#endif
88#define RESULTS(l,indexi)  results[l][indexi]
89#define LAGRANGE(l,indexd) lagrange[l][indexd]
90#else
91#error Error ! Define [_FOS_ | _FOV_ | _INT_REV_SAFE_ | _INT_REV_TIGHT_ ]
92#endif
93#endif
94/*--------------------------------------------------------------------------*/
95/*                                                     access to variables  */
96
97#ifdef _FOS_
98#define ARES       *Ares
99#define AARG       *Aarg
100#define AARG1      *Aarg1
101#define AARG2      *Aarg2
102
103#define ARES_INC   *Ares
104#define AARG_INC   *Aarg
105#define AARG1_INC  *Aarg1
106#define AARG2_INC  *Aarg2
107
108#define ARES_INC_O  Ares
109#define AARG_INC_O  /adAarg
110#define AARG1_INC_O Aarg1
111#define AARG2_INC_O Aarg2
112
113#define ASSIGN_A(a,b)  a = &b;
114
115#else  /* _FOV_ */
116#ifdef _FOV_
117#define ARES       *Ares
118#define AARG       *Aarg
119#define AARG1      *Aarg1
120#define AARG2      *Aarg2
121
122#define ARES_INC   *Ares++
123#define AARG_INC   *Aarg++
124#define AARG1_INC  *Aarg1++
125#define AARG2_INC  *Aarg2++
126
127#define ARES_INC_O  Ares++
128#define AARG_INC_O  Aarg++
129#define AARG1_INC_O Aarg1++
130#define AARG2_INC_O Aarg2++
131
132#define ASSIGN_A(a,b)  a = b;
133#else
134#ifdef _INT_REV_
135#define ARES       *Ares
136#define AARG       *Aarg
137#define AARG1      *Aarg1
138#define AARG2      *Aarg2
139
140#define ARES_INC   *Ares++
141#define AARG_INC   *Aarg++
142#define AARG1_INC  *Aarg1++
143#define AARG2_INC  *Aarg2++
144
145#define ARES_INC_O  Ares++
146#define AARG_INC_O  Aarg++
147#define AARG1_INC_O Aarg1++
148#define AARG2_INC_O Aarg2++
149
150#define ASSIGN_A(a,b)  a = b;
151#endif
152#endif
153#endif
154
155#define TRES       rp_T[res]
156#define TARG       rp_T[arg]
157#define TARG1      rp_T[arg1]
158#define TARG2      rp_T[arg2]
159
160/*--------------------------------------------------------------------------*/
161/*                                                              loop stuff  */
162#ifdef _ADOLC_VECTOR_
163#define FOR_0_LE_l_LT_p for (l=0; l<p; l++)
164#define FOR_p_GT_l_GE_0 for (l=p-1; l>=0; l--)
165#else
166#ifdef _INT_REV_
167#define FOR_0_LE_l_LT_p for (l=0; l<p; l++)
168#define FOR_p_GT_l_GE_0 for (l=p-1; l>=0; l--)
169#else
170#define FOR_0_LE_l_LT_p
171#define FOR_p_GT_l_GE_0
172#endif
173#endif
174
175#ifdef _FOV_
176#define FOR_0_LE_l_LT_pk1 for (l=0; l<p; l++)
177#else
178#ifdef _INT_REV_
179#define FOR_0_LE_l_LT_pk1 for (l=0; l<p; l++)
180#else
181#define FOR_0_LE_l_LT_pk1
182#endif
183#endif
184
185/* END Macros */
186
187
188/****************************************************************************/
189/*                                                       NECESSARY INCLUDES */
190#include <adolc/interfaces.h>
191#include <adolc/adalloc.h>
192#include "oplate.h"
193#include "taping_p.h"
194#include <adolc/externfcts.h>
195#include "externfcts_p.h"
196
197#include <math.h>
198
199BEGIN_C_DECLS
200
201/****************************************************************************/
202/*                                                             NOW THE CODE */
203
204#ifdef _FOS_
205/****************************************************************************/
206/* First-Order Scalar Reverse Pass.                                         */
207/****************************************************************************/
208int fos_reverse(short   tnum,       /* tape id */
209                int     depen,      /* consistency chk on # of deps */
210                int     indep,      /* consistency chk on # of indeps */
211                double  *lagrange,
212                double  *results)   /*  coefficient vectors */
213
214#else
215#if _FOV_
216/****************************************************************************/
217/* First-Order Vector Reverse Pass.                                         */
218/****************************************************************************/
219
220int fov_reverse(short   tnum,        /* tape id */
221                int     depen,       /* consistency chk on # of deps */
222                int     indep,       /* consistency chk on # of indeps */
223                int     nrows,       /* # of Jacobian rows being calculated */
224                double  **lagrange,  /* domain weight vector */
225                double  **results)   /* matrix of coefficient vectors */
226
227#else
228#if defined(_INT_REV_)
229#if defined(_TIGHT_)
230/****************************************************************************/
231/* First Order Vector version of the reverse mode for bit patterns, tight   */
232/****************************************************************************/
233int int_reverse_tight(
234        short             tnum,  /* tape id                               */
235        int               depen, /* consistency chk on # of deps          */
236        int               indep, /* consistency chk on # of indeps        */
237        int               nrows, /* # of Jacobian rows being calculated   */
238        unsigned long int **lagrange,/* domain weight vector[var][row](in)*/
239        unsigned long int **results) /* matrix of coeff. vectors[var][row]*/
240
241#endif
242#if defined(_NTIGHT_)
243/****************************************************************************/
244/* First Order Vector version of the reverse mode, bit pattern, safe        */
245/****************************************************************************/
246int int_reverse_safe(
247        short             tnum,  /* tape id                               */
248        int               depen, /* consistency chk on # of deps          */
249        int               indep, /* consistency chk on # of indeps        */
250        int               nrows, /* # of Jacobian rows being calculated   */
251        unsigned long int **lagrange,/* domain weight vector[var][row](in)*/
252        unsigned long int **results) /* matrix of coeff. vectors[var][row]*/
253#endif
254#endif
255#endif
256#endif
257{
258    /****************************************************************************/
259    /*                                                           ALL VARIABLES  */
260    unsigned char operation;   /* operation code */
261    int ret_c = 3;             /* return value */
262
263    locint size = 0;
264    locint res  = 0;
265    locint arg  = 0;
266    locint arg1 = 0;
267    locint arg2 = 0;
268
269#if !defined (_NTIGHT_)
270    double coval = 0, *d = 0;
271#endif
272
273    int indexi = 0,  indexd = 0;
274
275    /* loop indices */
276#if defined(_FOV_)
277    int l;
278#endif
279#if defined(_INT_REV_)
280    int l;
281#endif
282    int j, ls;
283
284    /* other necessary variables */
285#if !defined (_NTIGHT_)
286    double r0, r_0;
287    int taycheck;
288    int numdep,numind;
289#endif
290
291    /*--------------------------------------------------------------------------*/
292    /* Adjoint stuff */
293#ifdef _FOS_
294    revreal *rp_A;
295    revreal aTmp;
296#endif
297#ifdef _FOV_
298    revreal **rpp_A, *Aqo;
299    revreal aTmp;
300#endif
301#if !defined(_NTIGHT_)
302    revreal *rp_T;
303#endif /* !_NTIGHT_ */
304#if !defined _INT_REV_
305    revreal  *Ares, *Aarg, *Aarg1, *Aarg2;
306#else
307    unsigned long int **upp_A;
308    unsigned long int *Ares, *Aarg, *Aarg1, *Aarg2;
309    unsigned long int aTmp;
310#endif
311
312    /*--------------------------------------------------------------------------*/
313
314#ifdef _ADOLC_VECTOR_
315    int p = nrows;
316#endif
317#ifdef _INT_REV_
318    int p = nrows;
319#endif
320
321#if !defined(ADOLC_USE_CALLOC)
322    char * c_Ptr;
323#endif
324
325    /****************************************************************************/
326    /*                                          extern diff. function variables */
327#if defined(_FOS_)
328# define ADOLC_EXT_FCT_U edfct->dp_U
329# define ADOLC_EXT_FCT_Z edfct->dp_Z
330# define ADOLC_EXT_FCT_POINTER fos_reverse
331# define ADOLC_EXT_FCT_COMPLETE \
332  fos_reverse(m, edfct->dp_U, n, edfct->dp_Z, edfct->dp_x, edfct->dp_y)
333# define ADOLC_EXT_FCT_SAVE_NUMDIRS
334#else
335# define ADOLC_EXT_FCT_U edfct->dpp_U
336# define ADOLC_EXT_FCT_Z edfct->dpp_Z
337# define ADOLC_EXT_FCT_POINTER fov_reverse
338# define ADOLC_EXT_FCT_COMPLETE \
339  fov_reverse(m, p, edfct->dpp_U, n, edfct->dpp_Z, edfct->dp_x, edfct->dp_y)
340# define ADOLC_EXT_FCT_SAVE_NUMDIRS ADOLC_CURRENT_TAPE_INFOS.numDirs_rev = nrows
341#endif
342#if !defined(_INT_REV_)
343    locint n, m;
344    ext_diff_fct *edfct;
345    int loop;
346    int ext_retc;
347    int oldTraceFlag;
348#endif
349
350
351    ADOLC_OPENMP_THREAD_NUMBER;
352    ADOLC_OPENMP_GET_THREAD_NUMBER;
353
354#if defined(ADOLC_DEBUG)
355    /****************************************************************************/
356    /*                                                           DEBUG MESSAGES */
357    fprintf(DIAG_OUT,"Call of %s(..) with tag: %d, n: %d, m %d,\n",
358            GENERATED_FILENAME, tnum, indep, depen);
359#ifdef _ADOLC_VECTOR_
360    fprintf(DIAG_OUT,"                    p: %d\n\n",nrows);
361#endif
362
363#endif
364
365    /****************************************************************************/
366    /*                                                                    INITs */
367
368    /*------------------------------------------------------------------------*/
369    /* Set up stuff for the tape */
370
371    /* Initialize the Reverse Sweep */
372    init_rev_sweep(tnum);
373
374    failAdditionalInfo3 = depen;
375    failAdditionalInfo4 = indep;
376    if ( (depen != ADOLC_CURRENT_TAPE_INFOS.stats[NUM_DEPENDENTS]) ||
377            (indep != ADOLC_CURRENT_TAPE_INFOS.stats[NUM_INDEPENDENTS]) )
378        fail(ADOLC_REVERSE_COUNTS_MISMATCH);
379
380    indexi = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_INDEPENDENTS] - 1;
381    indexd = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_DEPENDENTS] - 1;
382
383
384    /****************************************************************************/
385    /*                                                  MEMORY ALLOCATION STUFF */
386
387    /*--------------------------------------------------------------------------*/
388#ifdef _FOS_                                                         /* FOS */
389    rp_A = (revreal*) malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] * sizeof(revreal));
390    if (rp_A == NULL) fail(ADOLC_MALLOC_FAILED);
391    ADOLC_CURRENT_TAPE_INFOS.rp_A = rp_A;
392    rp_T = (revreal *)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] *
393            sizeof(revreal));
394    if (rp_T == NULL) fail(ADOLC_MALLOC_FAILED);
395#if !defined(ADOLC_USE_CALLOC)
396    c_Ptr = (char *) ADOLC_GLOBAL_TAPE_VARS.rp_A;
397    *c_Ptr = 0;
398    memcpy(c_Ptr + 1, c_Ptr, sizeof(double) *
399            ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] - 1);
400#endif
401# define ADJOINT_BUFFER rp_A
402# define ADJOINT_BUFFER_ARG_L rp_A[arg]
403# define ADJOINT_BUFFER_RES_L rp_A[res]
404# define ADOLC_EXT_FCT_U_L_LOOP edfct->dp_U[loop]
405# define ADOLC_EXT_FCT_Z_L_LOOP edfct->dp_Z[loop]
406
407    /*--------------------------------------------------------------------------*/
408#else
409#if defined _FOV_                                                          /* FOV */
410    rpp_A = (revreal**)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] *
411            sizeof(revreal*));
412    if (rpp_A == NULL) fail(ADOLC_MALLOC_FAILED);
413    Aqo = (revreal*)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] * p *
414            sizeof(revreal));
415    if (Aqo == NULL) fail(ADOLC_MALLOC_FAILED);
416    for (j=0; j<ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]; j++) {
417        rpp_A[j] = Aqo;
418        Aqo += p;
419    }
420    ADOLC_CURRENT_TAPE_INFOS.rpp_A = rpp_A;
421    rp_T = (revreal *)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] *
422            sizeof(revreal));
423    if (rp_T == NULL) fail(ADOLC_MALLOC_FAILED);
424#if !defined(ADOLC_USE_CALLOC)
425    c_Ptr = (char *) ADOLC_GLOBAL_TAPE_VARS.dpp_A;
426    *c_Ptr = 0;
427    memcpy(c_Ptr + 1, c_Ptr, sizeof(double) * p *
428            ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] - 1);
429#endif
430# define ADJOINT_BUFFER rpp_A
431# define ADJOINT_BUFFER_ARG_L rpp_A[arg][l]
432# define ADJOINT_BUFFER_RES_L rpp_A[res][l]
433# define ADOLC_EXT_FCT_U_L_LOOP edfct->dpp_U[l][loop]
434# define ADOLC_EXT_FCT_Z_L_LOOP edfct->dpp_Z[l][loop]
435#else
436#if defined _INT_REV_
437    upp_A = myalloc2_ulong(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES], p);
438#if defined _TIGHT_
439    ADOLC_CURRENT_TAPE_INFOS.upp_A = upp_A;
440    rp_T = (revreal *)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] *
441                             sizeof(revreal));
442    if (rp_T == NULL) fail(ADOLC_MALLOC_FAILED);
443#endif
444# define ADJOINT_BUFFER upp_A
445# define ADJOINT_BUFFER_ARG_L upp_A[arg][l]
446# define ADJOINT_BUFFER_RES_L upp_A[res][l]
447#endif
448#endif
449#endif
450
451    /****************************************************************************/
452    /*                                                    TAYLOR INITIALIZATION */
453
454#if !defined(_NTIGHT_)
455    ADOLC_CURRENT_TAPE_INFOS.rp_T = rp_T;
456
457    taylor_back(tnum, &numdep, &numind, &taycheck);
458
459    if (taycheck < 0) {
460        fprintf(DIAG_OUT,"\n ADOL-C error: reverse fails because it was not"
461                " preceded\nby a forward sweep with degree>0, keep=1!\n");
462        exit(-2);
463    };
464
465    if((numdep != depen)||(numind != indep))
466        fail(ADOLC_REVERSE_TAYLOR_COUNTS_MISMATCH);
467
468#endif /* !_NTIGHT_ */
469
470
471    /****************************************************************************/
472    /*                                                            REVERSE SWEEP */
473    operation=get_op_r();
474    while (operation != start_of_tape) { /* Switch statement to execute the operations in Reverse */
475
476        switch (operation) {
477
478
479                /****************************************************************************/
480                /*                                                                  MARKERS */
481
482                /*--------------------------------------------------------------------------*/
483            case end_of_op:                                          /* end_of_op */
484                get_op_block_r();
485                operation = get_op_r();
486                /* Skip next operation, it's another end_of_op */
487                break;
488
489                /*--------------------------------------------------------------------------*/
490            case end_of_int:                                        /* end_of_int */
491                get_loc_block_r(); /* Get the next int block */
492                break;
493
494                /*--------------------------------------------------------------------------*/
495            case end_of_val:                                        /* end_of_val */
496                get_val_block_r(); /* Get the next val block */
497                break;
498
499                /*--------------------------------------------------------------------------*/
500            case start_of_tape:                                  /* start_of_tape */
501            case end_of_tape:                                      /* end_of_tape */
502                break;
503
504
505                /****************************************************************************/
506                /*                                                               COMPARISON */
507
508                /*--------------------------------------------------------------------------*/
509            case eq_zero  :                                            /* eq_zero */
510                arg   = get_locint_r();
511
512#if !defined(_NTIGHT_)
513                ret_c = 0;
514#endif /* !_NTIGHT_ */
515                break;
516
517                /*--------------------------------------------------------------------------*/
518            case neq_zero :                                           /* neq_zero */
519            case gt_zero  :                                            /* gt_zero */
520            case lt_zero :                                             /* lt_zero */
521                arg   = get_locint_r();
522                break;
523
524                /*--------------------------------------------------------------------------*/
525            case ge_zero :                                             /* ge_zero */
526            case le_zero :                                             /* le_zero */
527                arg   = get_locint_r();
528
529#if !defined(_NTIGHT_)
530                if (TARG == 0)
531                    ret_c = 0;
532#endif /* !_NTIGHT_ */
533                break;
534
535
536                /****************************************************************************/
537                /*                                                              ASSIGNMENTS */
538
539                /*--------------------------------------------------------------------------*/
540            case assign_a:           /* assign an adouble variable an    assign_a */
541                /* adouble value. (=) */
542                res = get_locint_r();
543                arg = get_locint_r();
544
545                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
546                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
547
548                FOR_0_LE_l_LT_p
549                {
550#if defined(_INT_REV_)                 
551                  AARG_INC |= ARES;
552                  ARES_INC = 0;
553#else
554                  AARG_INC += ARES;
555                  ARES_INC = 0.0;
556#endif
557            }
558
559#if !defined(_NTIGHT_)
560                ADOLC_GET_TAYLOR(res);
561#endif /* !_NTIGHT_ */
562                break;
563
564                /*--------------------------------------------------------------------------*/
565            case assign_d:            /* assign an adouble variable a    assign_d */
566                /* double value. (=) */
567                res   = get_locint_r();
568#if !defined(_NTIGHT_)
569                coval = get_val_r();
570#endif /* !_NTIGHT_ */
571
572                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
573
574                FOR_0_LE_l_LT_p
575#if defined(_INT_REV_)                 
576                ARES_INC = 0;
577#else
578                ARES_INC = 0.0;
579#endif
580
581#if !defined(_NTIGHT_)
582                ADOLC_GET_TAYLOR(res);
583#endif /* !_NTIGHT_ */
584                break;
585
586                /*--------------------------------------------------------------------------*/
587            case assign_d_zero:  /* assign an adouble variable a    assign_d_zero */
588            case assign_d_one:   /* double value (0 or 1). (=)       assign_d_one */
589                res   = get_locint_r();
590
591                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
592
593                FOR_0_LE_l_LT_p
594#if defined(_INT_REV_)                 
595                ARES_INC = 0;
596#else
597                ARES_INC = 0.0;
598#endif
599
600#if !defined(_NTIGHT_)
601                ADOLC_GET_TAYLOR(res);
602#endif /* !_NTIGHT_ */
603                break;
604
605                /*--------------------------------------------------------------------------*/
606            case assign_ind:       /* assign an adouble variable an    assign_ind */
607                /* independent double value (<<=) */
608                res = get_locint_r();
609
610                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
611
612                FOR_0_LE_l_LT_p
613                    RESULTS(l,indexi) = ARES_INC;
614
615#if !defined(_NTIGHT_)
616                ADOLC_GET_TAYLOR(res);
617#endif /* !_NTIGHT_ */
618                indexi--;
619                break;
620
621                /*--------------------------------------------------------------------------*/
622            case assign_dep:           /* assign a float variable a    assign_dep */
623                /* dependent adouble value. (>>=) */
624                res = get_locint_r();
625
626                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
627
628                FOR_0_LE_l_LT_p
629                ARES_INC = LAGRANGE(l,indexd);
630
631                indexd--;
632                break;
633
634
635                /****************************************************************************/
636                /*                                                   OPERATION + ASSIGNMENT */
637
638                /*--------------------------------------------------------------------------*/
639            case eq_plus_d:            /* Add a floating point to an    eq_plus_d */
640                /* adouble. (+=) */
641                res   = get_locint_r();
642#if !defined(_NTIGHT_)
643                coval = get_val_r();
644
645                ADOLC_GET_TAYLOR(res);
646#endif /* !_NTIGHT_ */
647                break;
648
649                /*--------------------------------------------------------------------------*/
650            case eq_plus_a:             /* Add an adouble to another    eq_plus_a */
651                /* adouble. (+=) */
652                res = get_locint_r();
653                arg = get_locint_r();
654
655                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
656                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg]);
657
658                FOR_0_LE_l_LT_p
659#if defined(_INT_REV_)
660                AARG_INC |= ARES_INC;
661#else
662                AARG_INC += ARES_INC;
663#endif
664
665#if !defined(_NTIGHT_)
666                ADOLC_GET_TAYLOR(res);
667#endif /* !_NTIGHT_ */
668                break;
669
670                /*--------------------------------------------------------------------------*/
671            case eq_min_d:       /* Subtract a floating point from an    eq_min_d */
672                /* adouble. (-=) */
673                res   = get_locint_r();
674#if !defined(_NTIGHT_)
675                coval = get_val_r();
676
677                ADOLC_GET_TAYLOR(res);
678#endif /* !_NTIGHT_ */
679               break;
680
681                /*--------------------------------------------------------------------------*/
682            case eq_min_a:        /* Subtract an adouble from another    eq_min_a */
683                /* adouble. (-=) */
684                res = get_locint_r();
685                arg = get_locint_r();
686
687                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
688                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
689
690                FOR_0_LE_l_LT_p
691#if defined(_INT_REV_)
692                AARG_INC |= ARES_INC;
693#else
694                AARG_INC -= ARES_INC;
695#endif
696
697#if !defined(_NTIGHT_)
698               ADOLC_GET_TAYLOR(res);
699#endif /* !_NTIGHT_ */
700                break;
701
702                /*--------------------------------------------------------------------------*/
703            case eq_mult_d:              /* Multiply an adouble by a    eq_mult_d */
704                /* flaoting point. (*=) */
705                res   = get_locint_r();
706#if !defined(_NTIGHT_)
707                coval = get_val_r();
708#endif /* !_NTIGHT_ */
709
710#if!defined(_INT_REV_)
711                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
712
713                FOR_0_LE_l_LT_p
714                ARES_INC *= coval;
715#endif
716
717#if !defined(_NTIGHT_)
718                ADOLC_GET_TAYLOR(res);
719#endif /* !_NTIGHT_ */
720                break;
721
722                /*--------------------------------------------------------------------------*/
723            case eq_mult_a:       /* Multiply one adouble by another    eq_mult_a */
724                /* (*=) */
725                res = get_locint_r();
726                arg = get_locint_r();
727
728#if !defined(_NTIGHT_)
729                ADOLC_GET_TAYLOR(res);
730#endif /* !_NTIGHT_ */
731
732                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
733                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
734
735                FOR_0_LE_l_LT_p
736#if defined(_INT_REV_)
737                AARG_INC |= ARES_INC;
738#else
739                { aTmp = ARES;
740                  /* olvo 980713 nn: ARES = 0.0; */
741                  ARES_INC =  (aTmp==0)?0:(aTmp * TARG);
742                  AARG_INC += (aTmp==0)?0:(aTmp * TRES);
743                }
744#endif     
745                break;
746
747                /*--------------------------------------------------------------------------*/
748            case incr_a:                        /* Increment an adouble    incr_a */
749            case decr_a:                        /* Increment an adouble    decr_a */
750                res   = get_locint_r();
751
752#if !defined(_NTIGHT_)
753                ADOLC_GET_TAYLOR(res);
754#endif /* !_NTIGHT_ */
755                break;
756
757
758                /****************************************************************************/
759                /*                                                        BINARY OPERATIONS */
760
761                /*--------------------------------------------------------------------------*/
762            case plus_a_a:                 /* : Add two adoubles. (+)    plus a_a */
763                res  = get_locint_r();
764                arg2 = get_locint_r();
765                arg1 = get_locint_r();
766
767                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
768                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
769                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
770
771                FOR_0_LE_l_LT_p
772                { aTmp = ARES;
773#if defined(_INT_REV_)
774                  ARES_INC = 0;
775                  AARG1_INC |= aTmp;
776                  AARG2_INC |= aTmp;
777#else
778                  ARES_INC = 0.0;
779                  AARG1_INC += aTmp;
780                  AARG2_INC += aTmp;
781#endif
782            }
783
784#if !defined(_NTIGHT_)
785                ADOLC_GET_TAYLOR(res);
786#endif /* !_NTIGHT_ */
787                break;
788
789                /*--------------------------------------------------------------------------*/
790            case plus_d_a:             /* Add an adouble and a double    plus_d_a */
791                /* (+) */
792                res   = get_locint_r();
793                arg   = get_locint_r();
794#if !defined(_NTIGHT_)
795                coval = get_val_r();
796#endif /* !_NTIGHT_ */
797
798                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
799                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
800
801                FOR_0_LE_l_LT_p
802                { aTmp = ARES;
803#if defined(_INT_REV_)
804                  ARES_INC = 0;
805                  AARG_INC |= aTmp;
806#else
807                  ARES_INC = 0.0;
808                  AARG_INC += aTmp;
809#endif
810            }
811
812#if !defined(_NTIGHT_)
813                ADOLC_GET_TAYLOR(res);
814#endif /* !_NTIGHT_ */
815                break;
816
817                /*--------------------------------------------------------------------------*/
818            case min_a_a:              /* Subtraction of two adoubles    min_a_a */
819                /* (-) */
820                res  = get_locint_r();
821                arg2 = get_locint_r();
822                arg1 = get_locint_r();
823
824                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
825                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
826                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
827
828                FOR_0_LE_l_LT_p
829                { aTmp = ARES;
830#if defined(_INT_REV_)
831                  ARES_INC = 0;
832                  AARG1_INC |= aTmp;
833                  AARG2_INC |= aTmp;
834#else
835                  ARES_INC = 0.0;
836                  AARG1_INC += aTmp;
837                  AARG2_INC -= aTmp;
838#endif
839            }
840
841#if !defined(_NTIGHT_)
842                ADOLC_GET_TAYLOR(res);
843#endif /* !_NTIGHT_ */
844                break;
845
846                /*--------------------------------------------------------------------------*/
847            case min_d_a:                /* Subtract an adouble from a    min_d_a */
848                /* double (-) */
849                res   = get_locint_r();
850                arg   = get_locint_r();
851#if !defined(_NTIGHT_)
852                coval = get_val_r();
853#endif /* !_NTIGHT_ */
854
855                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
856                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
857
858                FOR_0_LE_l_LT_p
859                { aTmp = ARES;
860#if defined(_INT_REV_)
861                  ARES_INC = 0;
862                  AARG_INC |= aTmp;
863#else
864                  ARES_INC = 0.0;
865                  AARG_INC -= aTmp;
866#endif
867            }
868
869#if !defined(_NTIGHT_)
870                ADOLC_GET_TAYLOR(res);
871#endif /* !_NTIGHT_ */
872                break;
873
874                /*--------------------------------------------------------------------------*/
875            case mult_a_a:               /* Multiply two adoubles (*)    mult_a_a */
876                res  = get_locint_r();
877                arg2 = get_locint_r();
878                arg1 = get_locint_r();
879
880#if !defined(_NTIGHT_)
881                ADOLC_GET_TAYLOR(res);
882#endif /* !_NTIGHT_ */
883
884                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
885                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
886                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
887
888                FOR_0_LE_l_LT_p
889                { aTmp = ARES;
890#if defined(_INT_REV_)
891                  ARES_INC = 0;
892                  AARG2_INC |= aTmp;
893                  AARG1_INC |= aTmp;
894#else
895                  ARES_INC = 0.0;
896                  AARG2_INC += (aTmp==0)?0:(aTmp * TARG1);
897                  AARG1_INC += (aTmp==0)?0:(aTmp * TARG2);
898#endif
899            }
900                break;
901
902                /*--------------------------------------------------------------------------*/
903                /* olvo 991122: new op_code with recomputation */
904            case eq_plus_prod:   /* increment a product of           eq_plus_prod */
905                /* two adoubles (*) */
906                res  = get_locint_r();
907                arg2 = get_locint_r();
908                arg1 = get_locint_r();
909
910                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
911                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
912                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
913
914#if !defined(_NTIGHT_)
915                /* RECOMPUTATION */
916                TRES -= TARG1*TARG2;
917#endif /* !_NTIGHT_ */
918
919                FOR_0_LE_l_LT_p
920                { 
921#if defined(_INT_REV_)
922                  AARG2_INC |= ARES;
923                  AARG1_INC |= ARES_INC;
924#else
925                  AARG2_INC += ARES    * TARG1;
926                  AARG1_INC += ARES_INC * TARG2;
927#endif
928            }
929                break;
930
931                /*--------------------------------------------------------------------------*/
932                /* olvo 991122: new op_code with recomputation */
933            case eq_min_prod:    /* decrement a product of            eq_min_prod */
934                /* two adoubles (*) */
935                res  = get_locint_r();
936                arg2 = get_locint_r();
937                arg1 = get_locint_r();
938
939                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
940                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
941                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
942
943#if !defined(_NTIGHT_)
944                /* RECOMPUTATION */
945                TRES += TARG1*TARG2;
946#endif /* !_NTIGHT_ */
947
948                FOR_0_LE_l_LT_p
949                { 
950#if defined(_INT_REV_)
951                  AARG2_INC |= ARES;
952                  AARG1_INC |= ARES_INC;
953#else                 
954                  AARG2_INC -= ARES    * TARG1;
955                  AARG1_INC -= ARES_INC * TARG2;
956#endif
957            }
958                break;
959
960                /*--------------------------------------------------------------------------*/
961            case mult_d_a:         /* Multiply an adouble by a double    mult_d_a */
962                /* (*) */
963                res   = get_locint_r();
964                arg   = get_locint_r();
965#if !defined(_NTIGHT_)
966                coval = get_val_r();
967#endif /* !_NTIGHT_ */
968
969                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
970                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
971
972                FOR_0_LE_l_LT_p
973                { aTmp = ARES;
974#if defined(_INT_REV_)
975                  ARES_INC = 0;
976                  AARG_INC |= aTmp;
977#else
978                  ARES_INC = 0.0;
979                  AARG_INC += (aTmp==0)?0:(coval * aTmp);
980#endif
981            }
982
983#if !defined(_NTIGHT_)
984                ADOLC_GET_TAYLOR(res);
985#endif /* !_NTIGHT_ */
986                break;
987
988                /*--------------------------------------------------------------------------*/
989            case div_a_a:           /* Divide an adouble by an adouble    div_a_a */
990                /* (/) */
991                res  = get_locint_r();
992                arg2 = get_locint_r();
993                arg1 = get_locint_r();
994
995                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
996                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
997                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
998
999                /* olvo 980922 changed order to allow x=y/x */
1000#if !defined(_NTIGHT_)
1001                r_0 = -TRES;
1002                ADOLC_GET_TAYLOR(res);
1003                r0  = 1.0 / TARG2;
1004                r_0 *= r0;
1005#endif /* !_NTIGHT_ */
1006
1007                FOR_0_LE_l_LT_p
1008                { aTmp = ARES;
1009#if defined(_INT_REV_)
1010                  ARES_INC = 0;
1011                  AARG1_INC |= aTmp;
1012                  AARG2_INC |= aTmp;
1013#else
1014                  ARES_INC = 0.0;
1015                  AARG1_INC += (aTmp==0)?0:(aTmp * r0);
1016                  AARG2_INC += (aTmp==0)?0:(aTmp * r_0);
1017#endif
1018            }
1019
1020                break;
1021
1022                /*--------------------------------------------------------------------------*/
1023            case div_d_a:             /* Division double - adouble (/)    div_d_a */
1024                res   = get_locint_r();
1025                arg   = get_locint_r();
1026
1027#if !defined(_NTIGHT_)
1028                coval = get_val_r();
1029#endif /* !_NTIGHT_ */
1030
1031                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1032                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1033
1034#if !defined(_NTIGHT_)
1035                /* olvo 980922 changed order to allow x=d/x */
1036                r0 = -TRES;
1037                if (arg == res)
1038                    ADOLC_GET_TAYLOR(arg);
1039                r0 /= TARG;
1040#endif /* !_NTIGHT_ */
1041
1042                FOR_0_LE_l_LT_p
1043                { aTmp = ARES;
1044#if defined(_INT_REV_)
1045                  ARES_INC = 0;
1046                  AARG_INC |= aTmp;
1047#else
1048                  ARES_INC = 0.0;
1049                  AARG_INC += (aTmp==0)?0:(aTmp * r0);
1050#endif
1051                }
1052
1053#if !defined(_NTIGHT_)
1054                ADOLC_GET_TAYLOR(res);
1055#endif /* !_NTIGHT_ */
1056                break;
1057
1058
1059                /****************************************************************************/
1060                /*                                                         SIGN  OPERATIONS */
1061
1062                /*--------------------------------------------------------------------------*/
1063            case pos_sign_a:                                        /* pos_sign_a */
1064                res   = get_locint_r();
1065                arg   = get_locint_r();
1066
1067                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1068                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1069
1070                FOR_0_LE_l_LT_p
1071                { aTmp = ARES;
1072#if defined(_INT_REV_)
1073                  ARES_INC = 0;
1074                  AARG_INC |= aTmp;
1075#else
1076                  ARES_INC = 0.0;
1077                  AARG_INC += aTmp;
1078#endif
1079            }
1080
1081#if !defined(_NTIGHT_)
1082                ADOLC_GET_TAYLOR(res);
1083#endif /* !_NTIGHT_ */
1084                break;
1085
1086                /*--------------------------------------------------------------------------*/
1087            case neg_sign_a:                                        /* neg_sign_a */
1088                res   = get_locint_r();
1089                arg   = get_locint_r();
1090
1091                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1092                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1093
1094                FOR_0_LE_l_LT_p
1095                { aTmp = ARES;
1096#if defined(_INT_REV_)
1097                  ARES_INC = 0;
1098                  AARG_INC |= aTmp;
1099#else
1100                  ARES_INC = 0.0;
1101                  AARG_INC -= aTmp;
1102#endif
1103            }
1104
1105#if !defined(_NTIGHT_)
1106                ADOLC_GET_TAYLOR(res);
1107#endif /* !_NTIGHT_ */
1108                break;
1109
1110
1111                /****************************************************************************/
1112                /*                                                         UNARY OPERATIONS */
1113
1114                /*--------------------------------------------------------------------------*/
1115            case exp_op:                          /* exponent operation    exp_op */
1116                res = get_locint_r();
1117                arg = get_locint_r();
1118
1119                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1120                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1121
1122                FOR_0_LE_l_LT_p
1123                { aTmp = ARES;
1124#if defined(_INT_REV_)
1125                  ARES_INC = 0;
1126                  AARG_INC |= aTmp;
1127#else
1128                  ARES_INC = 0.0;
1129                  AARG_INC += (aTmp==0)?0:(aTmp*TRES);
1130#endif
1131            }
1132
1133#if !defined(_NTIGHT_)
1134                ADOLC_GET_TAYLOR(res);
1135#endif /* !_NTIGHT_ */
1136                break;
1137
1138                /*--------------------------------------------------------------------------*/
1139            case sin_op:                              /* sine operation    sin_op */
1140                res  = get_locint_r();
1141                arg2 = get_locint_r();
1142                arg1 = get_locint_r();
1143
1144                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1145                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1146
1147                FOR_0_LE_l_LT_p
1148                { aTmp = ARES;
1149#if defined(_INT_REV_)
1150                  ARES_INC = 0;
1151                  AARG1_INC |= aTmp;
1152#else
1153                  ARES_INC = 0.0;
1154                  AARG1_INC += (aTmp==0)?0:(aTmp * TARG2);
1155#endif
1156            }
1157
1158#if !defined(_NTIGHT_)
1159                ADOLC_GET_TAYLOR(res);
1160                ADOLC_GET_TAYLOR(arg2); /* olvo 980710 covalue */
1161                /* NOTE: ADJOINT_BUFFER[arg2] should be 0 already */
1162#endif /* !_NTIGHT_ */
1163                break;
1164
1165                /*--------------------------------------------------------------------------*/
1166            case cos_op:                            /* cosine operation    cos_op */
1167                res  = get_locint_r();
1168                arg2 = get_locint_r();
1169                arg1 = get_locint_r();
1170
1171                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1172                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1173
1174                FOR_0_LE_l_LT_p
1175                { aTmp = ARES;
1176#if defined(_INT_REV_)
1177                  ARES_INC = 0;
1178                  AARG1_INC |= aTmp;
1179#else
1180                  ARES_INC = 0.0;
1181                  AARG1_INC -= (aTmp==0)?0:(aTmp * TARG2);
1182#endif
1183            }
1184
1185#if !defined(_NTIGHT_)
1186                ADOLC_GET_TAYLOR(res);
1187                ADOLC_GET_TAYLOR(arg2); /* olvo 980710 covalue */
1188                /* NOTE ADJOINT_BUFFER[arg2] should be 0 already */
1189#endif /* !_NTIGHT_ */
1190                break;
1191
1192                /*--------------------------------------------------------------------------*/
1193            case atan_op:                                             /* atan_op  */
1194            case asin_op:                                             /* asin_op  */
1195            case acos_op:                                             /* acos_op  */
1196            case asinh_op:                                            /* asinh_op */
1197            case acosh_op:                                            /* acosh_op */
1198            case atanh_op:                                            /* atanh_op */
1199            case erf_op:                                              /* erf_op   */
1200                res  = get_locint_r();
1201                arg2 = get_locint_r();
1202                arg1 = get_locint_r();
1203
1204#if !defined(_NTIGHT_)
1205                ADOLC_GET_TAYLOR(res);
1206#endif /* !_NTIGHT_ */
1207
1208                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1209                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1210
1211                FOR_0_LE_l_LT_p
1212                { aTmp = ARES;
1213#if defined(_INT_REV_)
1214                  ARES_INC = 0;
1215                  AARG1_INC |= aTmp;
1216#else
1217                  ARES_INC = 0.0;
1218                  AARG1_INC += (aTmp==0)?0:(aTmp * TARG2);
1219#endif
1220                }
1221                break;
1222
1223                /*--------------------------------------------------------------------------*/
1224            case log_op:                                                /* log_op */
1225                res = get_locint_r();
1226                arg = get_locint_r();
1227
1228#if !defined(_NTIGHT_)
1229                ADOLC_GET_TAYLOR(res);
1230#endif /* !_NTIGHT_ */
1231
1232                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1233                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1234
1235#if !defined(_INT_REV_)
1236                r0 = 1.0/TARG;
1237#endif
1238
1239                FOR_0_LE_l_LT_p
1240                { aTmp = ARES;
1241#if defined(_INT_REV_)
1242                  ARES_INC = 0;
1243                  AARG_INC |= aTmp;
1244#else
1245                  ARES_INC = 0.0;
1246                  AARG_INC += (aTmp==0)?0:(aTmp * r0);
1247#endif
1248            }
1249                break;
1250
1251                /*--------------------------------------------------------------------------*/
1252            case pow_op:                                                /* pow_op */
1253                res   = get_locint_r();
1254                arg   = get_locint_r();
1255#if !defined(_NTIGHT_)
1256                coval = get_val_r();
1257#endif /* !_NTIGHT_ */
1258
1259                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1260                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1261
1262#if !defined(_NTIGHT_)
1263                /* olvo 980921 changed order to allow x=pow(x,n) */
1264                r0 = TRES;
1265                if (arg == res)
1266                    ADOLC_GET_TAYLOR(arg);
1267                if (TARG == 0.0)
1268                    r0 = 0.0;
1269                else
1270                    r0 *= coval/TARG;
1271#endif /* !_NTIGHT_ */
1272
1273                FOR_0_LE_l_LT_p {
1274                    aTmp = ARES;
1275#if defined(_INT_REV_)
1276                    ARES_INC = 0;
1277                    AARG_INC |= aTmp;
1278#else
1279                    ARES_INC = 0.0;
1280                    AARG_INC += (aTmp==0)?0:(aTmp * r0);
1281#endif
1282            }
1283
1284#if !defined(_NTIGHT_)
1285                ADOLC_GET_TAYLOR(res);
1286#endif /* !_NTIGHT_ */
1287                break;
1288
1289                /*--------------------------------------------------------------------------*/
1290            case sqrt_op:                                              /* sqrt_op */
1291                res = get_locint_r();
1292                arg = get_locint_r();
1293
1294                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1295                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1296
1297#if !defined(_NTIGHT_)
1298                if (TRES == 0.0)
1299                    r0 = 0.0;
1300                else
1301                    r0 = 0.5 / TRES;
1302#endif /* !_NTIGHT_ */
1303
1304                FOR_0_LE_l_LT_p {
1305                    aTmp = ARES;
1306#if defined(_INT_REV_)
1307                    ARES_INC = 0;
1308                    AARG_INC |= aTmp;
1309#else
1310                    ARES_INC = 0.0;
1311                    AARG_INC += (aTmp==0)?0:(aTmp * r0);
1312#endif
1313                }
1314
1315#if !defined(_NTIGHT_)
1316                ADOLC_GET_TAYLOR(res);
1317#endif /* !_NTIGHT_ */
1318              break;
1319
1320                /*--------------------------------------------------------------------------*/
1321            case gen_quad:                                            /* gen_quad */
1322                res   = get_locint_r();
1323                arg2  = get_locint_r();
1324                arg1  = get_locint_r();
1325#if !defined(_NTIGHT_)
1326                coval = get_val_r();
1327                coval = get_val_r();
1328#endif /* !_NTIGHT_ */
1329
1330                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1331                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1332
1333                FOR_0_LE_l_LT_p
1334                { aTmp = ARES;
1335#if defined(_INT_REV_)
1336                  ARES_INC = 0;
1337                  AARG1_INC |= aTmp;
1338#else
1339                  ARES_INC = 0.0;
1340                  AARG1_INC += (aTmp==0)?0:(aTmp * TARG2);
1341#endif
1342            }
1343
1344#if !defined(_NTIGHT_)
1345                ADOLC_GET_TAYLOR(res);
1346#endif /* !_NTIGHT_ */
1347                break;
1348
1349                /*--------------------------------------------------------------------------*/
1350            case min_op:                                                /* min_op */
1351                res   = get_locint_r();
1352                arg2  = get_locint_r();
1353                arg1  = get_locint_r();
1354#if !defined(_NTIGHT_)
1355                coval = get_val_r();
1356
1357                ADOLC_GET_TAYLOR(res);
1358#endif /* !_NTIGHT_ */
1359
1360                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1361                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
1362                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1363
1364#if !defined(_NTIGHT_)
1365                if (TARG1 > TARG2)
1366                    FOR_0_LE_l_LT_p
1367                    { aTmp = ARES;
1368#if defined(_INT_REV_)
1369                      ARES_INC = 0;
1370#else
1371                      ARES_INC = 0.0;
1372#endif
1373                      if ((coval) && (aTmp))
1374                      MINDEC(ret_c,2);
1375#if defined(_INT_REV_)
1376                      AARG2_INC |= aTmp;
1377#else
1378                      AARG2_INC += aTmp;
1379#endif
1380                    } else
1381                        if (TARG1 < TARG2)
1382                                FOR_0_LE_l_LT_p
1383                                { aTmp = ARES;
1384#if defined(_INT_REV_)
1385                                  ARES_INC = 0;
1386#else
1387                                  ARES_INC = 0.0;
1388#endif
1389                                  if ((!coval) && (aTmp))
1390                                  MINDEC(ret_c,2);
1391#if defined(_INT_REV_)
1392                                  AARG1_INC |= aTmp;
1393#else
1394                                  AARG1_INC += aTmp;
1395#endif
1396                                } else { /* both are equal */
1397                                    FOR_0_LE_l_LT_p
1398                                    { 
1399#if defined(_INT_REV_)
1400                                      aTmp = ARES;
1401                                      ARES_INC = 0;
1402                                      AARG2_INC |= aTmp;
1403                                      AARG1_INC |= aTmp;
1404#else
1405                                      aTmp = ARES / 2.0;
1406                                      ARES_INC = 0.0;
1407                                      AARG2_INC += aTmp;
1408                                      AARG1_INC += aTmp;
1409#endif
1410                                    }
1411                                    if (arg1 != arg2)
1412                                            MINDEC(ret_c,1);
1413                                    }
1414#else
1415                    FOR_0_LE_l_LT_p
1416                    { aTmp = ARES;
1417                      ARES_INC = 0;
1418                      AARG1_INC |= aTmp;
1419                      AARG2_INC |= aTmp;
1420                    }
1421#endif /* !_NTIGHT_ */
1422                break;
1423
1424                /*--------------------------------------------------------------------------*/
1425            case abs_val:                                              /* abs_val */
1426                res   = get_locint_r();
1427                arg   = get_locint_r();
1428#if !defined(_NTIGHT_)
1429                coval = get_val_r();
1430
1431                ADOLC_GET_TAYLOR(res);
1432#endif /* !_NTIGHT_ */
1433
1434                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1435                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1436
1437#if !defined(_NTIGHT_)
1438                if (TARG < 0.0)
1439                    FOR_0_LE_l_LT_p
1440                    { aTmp = ARES;
1441#if defined(_INT_REV_)
1442                      ARES_INC = 0;
1443#else
1444                      ARES_INC = 0.0;
1445#endif
1446                      if ((coval) && (aTmp))
1447                      MINDEC(ret_c,2);
1448#if defined(_INT_REV_)
1449                      AARG_INC |= aTmp;
1450#else
1451                      AARG_INC -= aTmp;
1452#endif
1453                    } else
1454                        if (TARG > 0.0)
1455                                FOR_0_LE_l_LT_p
1456                                { aTmp = ARES;
1457#if defined(_INT_REV_)
1458                                  ARES_INC = 0;
1459#else
1460                                  ARES_INC = 0.0;
1461#endif
1462                                  if ((!coval) && (aTmp))
1463                                  MINDEC(ret_c,2);
1464#if defined(_INT_REV_)
1465                                  AARG_INC |= aTmp;
1466#else
1467                                  AARG_INC += aTmp;
1468#endif
1469                                } else
1470                                    FOR_0_LE_l_LT_p {
1471                                        aTmp = ARES;
1472#if defined(_INT_REV_)
1473                                        ARES_INC = 0;
1474#else
1475                                        ARES_INC = 0.0;
1476#endif
1477                                        if (aTmp)
1478                                            MINDEC(ret_c,1);
1479                                        }
1480#else
1481                                            FOR_0_LE_l_LT_p
1482                                            { aTmp = ARES;
1483                                              ARES_INC = 0;
1484                                              AARG_INC |= aTmp;
1485                                            }
1486#endif /* !_NTIGHT_ */
1487             break;
1488
1489            /*--------------------------------------------------------------------------*/
1490        case ceil_op:                                              /* ceil_op */
1491               res   = get_locint_r();
1492                arg   = get_locint_r();
1493#if !defined(_NTIGHT_)
1494                coval = get_val_r();
1495
1496                ADOLC_GET_TAYLOR(res);
1497#endif /* !_NTIGHT_ */
1498
1499                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1500
1501#if !defined(_NTIGHT_)
1502                coval = (coval != ceil(TARG) );
1503#endif /* !_NTIGHT_ */
1504
1505                FOR_0_LE_l_LT_p
1506                {
1507#if !defined(_NTIGHT_)
1508                  if ((coval) && (ARES))
1509                  MINDEC(ret_c,2);
1510#endif /* !_NTIGHT_ */
1511#if defined(_INT_REV_)
1512                  ARES_INC = 0;
1513#else
1514                  ARES_INC = 0.0;
1515#endif
1516                }
1517                break;
1518
1519            /*--------------------------------------------------------------------------*/
1520        case floor_op:                                            /* floor_op */
1521                res   = get_locint_r();
1522                arg   = get_locint_r();
1523#if !defined(_NTIGHT_)
1524                coval = get_val_r();
1525
1526                ADOLC_GET_TAYLOR(res);
1527#endif /* !_NTIGHT_ */
1528
1529                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1530                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1531
1532#if !defined(_NTIGHT_)
1533                coval = ( coval != floor(TARG1) );
1534#endif /* !_NTIGHT_ */
1535
1536                FOR_0_LE_l_LT_p
1537                {
1538#if !defined(_NTIGHT_)
1539                  if ( (coval) && (ARES) )
1540                  MINDEC(ret_c,2);
1541#endif /* !_NTIGHT_ */
1542#if defined(_INT_REV_)
1543                  ARES_INC = 0;
1544#else
1545                  ARES_INC = 0.0;
1546#endif
1547                }
1548                break;
1549
1550
1551            /****************************************************************************/
1552            /*                                                             CONDITIONALS */
1553
1554            /*--------------------------------------------------------------------------*/
1555        case cond_assign:                                      /* cond_assign */
1556            res    = get_locint_r();
1557                arg2   = get_locint_r();
1558                arg1   = get_locint_r();
1559                arg    = get_locint_r();
1560#if !defined(_NTIGHT_)
1561                coval  = get_val_r();
1562
1563                ADOLC_GET_TAYLOR(res);
1564#endif /* !_NTIGHT_ */
1565
1566                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1567                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1568                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
1569
1570#if !defined(_NTIGHT_)
1571                /* olvo 980924 changed code a little bit */
1572                if (TARG > 0.0) {
1573                    if (res != arg1)
1574                        FOR_0_LE_l_LT_p
1575                        { if ((coval <= 0.0) && (ARES))
1576                          MINDEC(ret_c,2);
1577#if defined(_INT_REV_)
1578                              AARG1_INC |= ARES;
1579                              ARES_INC = 0;
1580#else
1581                          AARG1_INC += ARES;
1582                          ARES_INC = 0.0;
1583#endif
1584                        } else
1585                            FOR_0_LE_l_LT_p
1586                            if ((coval <= 0.0) && (ARES_INC))
1587                                    MINDEC(ret_c,2);
1588                } else {
1589                    if (res != arg2)
1590                        FOR_0_LE_l_LT_p
1591                        { if ((coval <= 0.0) && (ARES))
1592                          MINDEC(ret_c,2);
1593#if defined(_INT_REV_)
1594                          AARG2_INC |= ARES;
1595                          ARES_INC = 0;
1596#else
1597                          AARG2_INC += ARES;
1598                          ARES_INC = 0.0;
1599#endif
1600                        } else
1601                            FOR_0_LE_l_LT_p
1602                            if ((coval <= 0.0) && (ARES_INC))
1603                                    MINDEC(ret_c,2);
1604                }
1605#else
1606                    if (res != arg1) {
1607                        FOR_0_LE_l_LT_p
1608                        AARG1_INC |= ARES_INC;
1609                        ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1610                    }
1611                    if (res != arg2) {
1612                        FOR_0_LE_l_LT_p
1613                        AARG2_INC |= ARES_INC;
1614                        ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1615                    }
1616                    if ((res != arg1) && (res != arg2))
1617                        FOR_0_LE_l_LT_p
1618                        ARES_INC = 0;
1619#endif /* !_NTIGHT_ */
1620                break;
1621
1622                /*--------------------------------------------------------------------------*/
1623            case cond_assign_s:                                  /* cond_assign_s */
1624                res   = get_locint_r();
1625                arg1  = get_locint_r();
1626                arg   = get_locint_r();
1627#if !defined(_NTIGHT_)
1628                coval = get_val_r();
1629
1630                ADOLC_GET_TAYLOR(res);
1631#endif /* !_NTIGHT_ */
1632
1633                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1634                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1635
1636#if !defined(_NTIGHT_)
1637                /* olvo 980924 changed code a little bit */
1638                if (TARG > 0.0) {
1639                    if (res != arg1)
1640                        FOR_0_LE_l_LT_p
1641                        { if ((coval <= 0.0) && (ARES))
1642                          MINDEC(ret_c,2);
1643#if defined(_INT_REV_)
1644                          AARG1_INC |= ARES;
1645                          ARES_INC = 0.0;
1646#else
1647                          AARG1_INC += ARES;
1648                          ARES_INC = 0.0;
1649#endif
1650                        } else
1651                            FOR_0_LE_l_LT_p
1652                            if ((coval <= 0.0) && (ARES_INC))
1653                                    MINDEC(ret_c,2);
1654                } else
1655                    if (TARG == 0.0) /* we are at the tie */
1656                        FOR_0_LE_l_LT_p
1657                        if (ARES_INC)
1658                            MINDEC(ret_c,0);
1659#else
1660                    if (res != arg1)
1661                        FOR_0_LE_l_LT_p
1662                        { AARG1 |= ARES;
1663                          ARES_INC = 0;
1664                        }
1665#endif /* !_NTIGHT_ */
1666                break;
1667
1668                /*--------------------------------------------------------------------------*/
1669                /* NEW CONDITIONALS */
1670                /*--------------------------------------------------------------------------*/
1671#if defined(ADOLC_ADVANCED_BRANCHING)
1672            case neq_a_a:
1673            case eq_a_a:
1674            case le_a_a:
1675            case ge_a_a:
1676            case lt_a_a:
1677            case gt_a_a:
1678                res = get_locint_r();
1679                arg1 = get_locint_r();
1680                arg = get_locint_r();
1681#if !defined(_NTIGHT_)
1682                coval = get_val_r();
1683#endif
1684                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1685
1686                FOR_0_LE_l_LT_p
1687#if defined(_INT_REV_)
1688                ARES_INC = 0;
1689#else
1690                ARES_INC = 0.0;
1691#endif
1692
1693#if !defined(_NTIGHT_)
1694                ADOLC_GET_TAYLOR(res);
1695#endif /* !_NTIGHT_ */
1696
1697                break;
1698#endif
1699                /*--------------------------------------------------------------------------*/
1700            case subscript:
1701                {
1702                    double val = get_val_r();
1703                    size_t cnt, idx, numval = (size_t)trunc(fabs(val));
1704                    locint vectorloc;
1705                    vectorloc = get_locint_r();
1706                    res = get_locint_r();
1707                    arg = get_locint_r();
1708#if !defined(_NTIGHT_)
1709                    idx = (size_t)trunc(fabs(TARG));
1710                    if (idx >= numval)
1711                        fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting n=%z, idx=%z\n", numval, idx);
1712                    arg1 = vectorloc+idx;
1713                    ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1714                    ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1715                    FOR_0_LE_l_LT_p
1716                    {
1717#if defined(_INT_REV_)
1718                        AARG1_INC |= ARES;
1719                        ARES_INC = 0;
1720#else
1721                        AARG1_INC += ARES;
1722                        ARES = 0.0;
1723#endif
1724                    }
1725                    ADOLC_GET_TAYLOR(res);
1726#else
1727                    fprintf(DIAG_OUT, "ADOL-C error: active subscripting does not work in safe mode, please use tight mode\n");
1728                    exit(-2);
1729#endif /* !_NTIGHT_ */
1730                }
1731                break;
1732
1733            case subscript_ref:
1734                {
1735                    double val = get_val_r();
1736                    size_t cnt, idx, numval = (size_t)trunc(fabs(val));
1737                    locint vectorloc;
1738                    vectorloc = get_locint_r();
1739                    res = get_locint_r();
1740                    arg = get_locint_r();
1741#if !defined(_NTIGHT_)
1742                    idx = (size_t)trunc(fabs(TARG));
1743                    if (idx >= numval)
1744                        fprintf(DIAG_OUT, "ADOL-C warning: index out of bounds while subscripting (ref) n=%z, idx=%z\n", numval, idx);
1745                    arg1 = (size_t)trunc(fabs(TRES));
1746                    // This is actually NOP
1747                    // basically all we need is that arg1 == vectorloc+idx
1748                    // so doing a check here is probably good
1749                    if (arg1 != vectorloc+idx) {
1750                        fprintf(DIAG_OUT, "ADOL-C error: indexed active position does not match referenced position\nindexed = %d, referenced = %d\n", vectorloc+idx, arg1);
1751                        exit(-2);
1752                    }
1753                    ADOLC_GET_TAYLOR(res);
1754#else
1755                    fprintf(DIAG_OUT, "ADOL-C error: active subscripting does not work in safe mode, please use tight mode\n");
1756                    exit(-2);
1757#endif /* !_NTIGHT_ */
1758                }
1759                break;
1760
1761            case ref_copyout:
1762                res = get_locint_r();
1763                arg1 = get_locint_r();
1764#if !defined(_NTIGHT_)
1765                arg = (size_t)trunc(fabs(TARG1));
1766                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1767                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1768               
1769                FOR_0_LE_l_LT_p
1770                {
1771#if defined(_INT_REV_)                 
1772                  AARG_INC |= ARES;
1773                  ARES_INC = 0;
1774#else
1775                  AARG_INC += ARES;
1776                  ARES_INC = 0.0;
1777#endif
1778                }
1779                ADOLC_GET_TAYLOR(res);
1780#else
1781                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
1782                exit(-2);
1783#endif
1784                break;
1785
1786
1787            case ref_incr_a:                        /* Increment an adouble    incr_a */
1788            case ref_decr_a:                        /* Increment an adouble    decr_a */
1789                arg1   = get_locint_r();
1790
1791#if !defined(_NTIGHT_)
1792                res = (size_t)trunc(fabs(TARG1));
1793                ADOLC_GET_TAYLOR(res);
1794#else
1795                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
1796                exit(-2);
1797#endif /* !_NTIGHT_ */
1798                break;
1799
1800            case ref_assign_d:            /* assign an adouble variable a    assign_d */
1801                /* double value. (=) */
1802                arg1   = get_locint_r();
1803#if !defined(_NTIGHT_)
1804                res = (size_t)trunc(fabs(TARG1));
1805                coval = get_val_r();
1806
1807                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1808
1809                FOR_0_LE_l_LT_p
1810#if defined(_INT_REV_)                 
1811                ARES_INC = 0;
1812#else
1813                ARES_INC = 0.0;
1814#endif
1815
1816                ADOLC_GET_TAYLOR(res);
1817#else
1818                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
1819                exit(-2);
1820#endif /* !_NTIGHT_ */
1821                break;
1822
1823            case ref_assign_d_zero:  /* assign an adouble variable a    assign_d_zero */
1824            case ref_assign_d_one:   /* double value (0 or 1). (=)       assign_d_one */
1825                arg1 = get_locint_r();
1826
1827#if !defined(_NTIGHT_)
1828                res = (size_t)trunc(fabs(TARG1));
1829
1830                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1831
1832                FOR_0_LE_l_LT_p
1833#if defined(_INT_REV_)                 
1834                ARES_INC = 0;
1835#else
1836                ARES_INC = 0.0;
1837#endif
1838                ADOLC_GET_TAYLOR(res);
1839#else
1840                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
1841                exit(-2);
1842#endif /* !_NTIGHT_ */
1843                break;
1844
1845            case ref_assign_a:           /* assign an adouble variable an    assign_a */
1846                /* adouble value. (=) */
1847                arg1 = get_locint_r();
1848                arg = get_locint_r();
1849
1850#if !defined(_NTIGHT_)
1851                res = (size_t)trunc(fabs(TARG1));
1852
1853                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1854                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1855
1856                FOR_0_LE_l_LT_p
1857                {
1858#if defined(_INT_REV_)                 
1859                  AARG_INC |= ARES;
1860                  ARES_INC = 0;
1861#else
1862                  AARG_INC += ARES;
1863                  ARES_INC = 0.0;
1864#endif
1865                }
1866
1867                ADOLC_GET_TAYLOR(res);
1868#else
1869                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
1870                exit(-2);
1871#endif /* !_NTIGHT_ */
1872                break;
1873
1874            case ref_assign_ind:       /* assign an adouble variable an    assign_ind */
1875                /* independent double value (<<=) */
1876                arg1 = get_locint_r();
1877
1878#if !defined(_NTIGHT_)
1879                res = (size_t)trunc(fabs(TARG1));
1880
1881                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1882
1883                FOR_0_LE_l_LT_p
1884                    RESULTS(l,indexi) = ARES_INC;
1885
1886                ADOLC_GET_TAYLOR(res);
1887#else
1888                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
1889                exit(-2);
1890#endif /* !_NTIGHT_ */
1891                indexi--;
1892                break;
1893
1894            case ref_eq_plus_d:            /* Add a floating point to an    eq_plus_d */
1895                /* adouble. (+=) */
1896                arg1   = get_locint_r();
1897#if !defined(_NTIGHT_)
1898                res = (size_t)trunc(fabs(TARG1));
1899                coval = get_val_r();
1900
1901                ADOLC_GET_TAYLOR(res);
1902#else
1903                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
1904                exit(-2);
1905#endif /* !_NTIGHT_ */
1906                break;
1907
1908            case ref_eq_plus_a:             /* Add an adouble to another    eq_plus_a */
1909                /* adouble. (+=) */
1910                arg1 = get_locint_r();
1911                arg = get_locint_r();
1912
1913#if !defined(_NTIGHT_)
1914                res = (size_t)trunc(fabs(TARG1));
1915
1916                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1917                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg]);
1918
1919                FOR_0_LE_l_LT_p
1920#if defined(_INT_REV_)
1921                AARG_INC |= ARES_INC;
1922#else
1923                AARG_INC += ARES_INC;
1924#endif
1925
1926                ADOLC_GET_TAYLOR(res);
1927#else
1928                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
1929                exit(-2);
1930#endif /* !_NTIGHT_ */
1931                break;
1932
1933            case ref_eq_min_d:       /* Subtract a floating point from an    eq_min_d */
1934                /* adouble. (-=) */
1935                arg1   = get_locint_r();
1936#if !defined(_NTIGHT_)
1937                res = (size_t)trunc(fabs(TARG1));
1938                coval = get_val_r();
1939
1940                ADOLC_GET_TAYLOR(res);
1941#else
1942                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
1943                exit(-2);
1944#endif /* !_NTIGHT_ */
1945               break;
1946
1947            case ref_eq_min_a:        /* Subtract an adouble from another    eq_min_a */
1948                /* adouble. (-=) */
1949                arg1 = get_locint_r();
1950                arg = get_locint_r();
1951
1952#if !defined(_NTIGHT_)
1953                res = (size_t)trunc(fabs(TARG1));
1954                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1955                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1956
1957                FOR_0_LE_l_LT_p
1958#if defined(_INT_REV_)
1959                AARG_INC |= ARES_INC;
1960#else
1961                AARG_INC -= ARES_INC;
1962#endif
1963
1964               ADOLC_GET_TAYLOR(res);
1965#else
1966                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
1967                exit(-2);
1968#endif /* !_NTIGHT_ */
1969                break;
1970
1971            case ref_eq_mult_d:              /* Multiply an adouble by a    eq_mult_d */
1972                /* flaoting point. (*=) */
1973                arg1   = get_locint_r();
1974#if !defined(_NTIGHT_)
1975                res = (size_t)trunc(fabs(TARG1));
1976                coval = get_val_r();
1977
1978#if !defined(_INT_REV_)
1979                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1980
1981                FOR_0_LE_l_LT_p
1982                ARES_INC *= coval;
1983#endif
1984
1985                ADOLC_GET_TAYLOR(res);
1986#else
1987                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
1988                exit(-2);
1989#endif /* !_NTIGHT_ */
1990                break;
1991
1992            case ref_eq_mult_a:       /* Multiply one adouble by another    eq_mult_a */
1993                /* (*=) */
1994                arg1 = get_locint_r();
1995                arg = get_locint_r();
1996
1997#if !defined(_NTIGHT_)
1998                res = (size_t)trunc(fabs(TARG1));
1999                ADOLC_GET_TAYLOR(res);
2000
2001                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2002                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
2003
2004                FOR_0_LE_l_LT_p
2005#if defined(_INT_REV_)
2006                AARG_INC |= ARES_INC;
2007#else
2008                { aTmp = ARES;
2009                  /* olvo 980713 nn: ARES = 0.0; */
2010                    ARES_INC =  (aTmp==0)?0:(aTmp * TARG);
2011                    AARG_INC += (aTmp==0)?0:(aTmp * TRES);
2012                }
2013#endif     
2014#else
2015                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2016                exit(-2);
2017#endif /* !_NTIGHT_ */
2018                break;
2019
2020        case ref_cond_assign:                                      /* cond_assign */
2021           {
2022                locint ref    = get_locint_r();
2023                arg2   = get_locint_r();
2024                arg1   = get_locint_r();
2025                arg    = get_locint_r();
2026#if !defined(_NTIGHT_)
2027                coval  = get_val_r();
2028                res = (size_t)trunc(fabs(rp_T[ref]));
2029
2030                ADOLC_GET_TAYLOR(res);
2031
2032                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
2033                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
2034                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
2035
2036                /* olvo 980924 changed code a little bit */
2037                if (TARG > 0.0) {
2038                    if (res != arg1)
2039                        FOR_0_LE_l_LT_p
2040                        { if ((coval <= 0.0) && (ARES))
2041                          MINDEC(ret_c,2);
2042#if defined(_INT_REV_)
2043                              AARG1_INC |= ARES;
2044                              ARES_INC = 0;
2045#else
2046                          AARG1_INC += ARES;
2047                          ARES_INC = 0.0;
2048#endif
2049                        } else
2050                            FOR_0_LE_l_LT_p
2051                            if ((coval <= 0.0) && (ARES_INC))
2052                                    MINDEC(ret_c,2);
2053                } else {
2054                    if (res != arg2)
2055                        FOR_0_LE_l_LT_p
2056                        { if ((coval <= 0.0) && (ARES))
2057                          MINDEC(ret_c,2);
2058#if defined(_INT_REV_)
2059                          AARG2_INC |= ARES;
2060                          ARES_INC = 0;
2061#else
2062                          AARG2_INC += ARES;
2063                          ARES_INC = 0.0;
2064#endif
2065                        } else
2066                            FOR_0_LE_l_LT_p
2067                            if ((coval <= 0.0) && (ARES_INC))
2068                                    MINDEC(ret_c,2);
2069                }
2070#else
2071                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2072                exit(-2);
2073#endif /* !_NTIGHT_ */
2074                }
2075                break;
2076
2077            case ref_cond_assign_s:                                  /* cond_assign_s */
2078                arg2   = get_locint_r();
2079                arg1  = get_locint_r();
2080                arg   = get_locint_r();
2081#if !defined(_NTIGHT_)
2082                coval = get_val_r();
2083                res = (size_t)trunc(fabs(TARG2));
2084                ADOLC_GET_TAYLOR(res);
2085
2086                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
2087                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
2088
2089                /* olvo 980924 changed code a little bit */
2090                if (TARG > 0.0) {
2091                    if (res != arg1)
2092                        FOR_0_LE_l_LT_p
2093                        { if ((coval <= 0.0) && (ARES))
2094                          MINDEC(ret_c,2);
2095#if defined(_INT_REV_)
2096                          AARG1_INC |= ARES;
2097                          ARES_INC = 0.0;
2098#else
2099                          AARG1_INC += ARES;
2100                          ARES_INC = 0.0;
2101#endif
2102                        } else
2103                            FOR_0_LE_l_LT_p
2104                            if ((coval <= 0.0) && (ARES_INC))
2105                                    MINDEC(ret_c,2);
2106                } else
2107                    if (TARG == 0.0) /* we are at the tie */
2108                        FOR_0_LE_l_LT_p
2109                        if (ARES_INC)
2110                            MINDEC(ret_c,0);
2111#else
2112                fprintf(DIAG_OUT, "ADOL-C error: active vector element referencing does not work in safe mode, please use tight mode\n");
2113                exit(-2);
2114#endif /* !_NTIGHT_ */
2115                break;
2116
2117
2118                /****************************************************************************/
2119                /*                                                          REMAINING STUFF */
2120
2121                /*--------------------------------------------------------------------------*/
2122            case take_stock_op:                                  /* take_stock_op */
2123                res  = get_locint_r();
2124                size = get_locint_r();
2125#if !defined(_NTIGHT_)
2126                d    = get_val_v_r(size);
2127#endif /* !_NTIGHT_ */
2128
2129                res += size;
2130                for (ls=size; ls>0; ls--) {
2131                    res--;
2132
2133                    ASSIGN_A( Ares, ADJOINT_BUFFER[res])
2134
2135                    FOR_0_LE_l_LT_p
2136                    ARES_INC = 0.0;
2137                }
2138                break;
2139
2140                /*--------------------------------------------------------------------------*/
2141            case death_not:                                          /* death_not */
2142                arg2 = get_locint_r();
2143                arg1 = get_locint_r();
2144
2145                for (j=arg1;j<=arg2;j++) {
2146                    ASSIGN_A(Aarg1, ADJOINT_BUFFER[j])
2147
2148                    FOR_0_LE_l_LT_p
2149                    AARG1_INC = 0.0;
2150                }
2151
2152#if !defined(_NTIGHT_)
2153                for (j=arg1;j<=arg2;j++)
2154                    ADOLC_GET_TAYLOR(j);
2155#endif /* !_NTIGHT_ */
2156                break;
2157
2158#if !defined(_INT_REV_)
2159                /*--------------------------------------------------------------------------*/
2160            case ext_diff:                       /* extern differntiated function */
2161                ADOLC_CURRENT_TAPE_INFOS.cpIndex = get_locint_r();
2162                ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev = get_locint_r();
2163                ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev = get_locint_r();
2164                m = get_locint_r();
2165                n = get_locint_r();
2166                ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index = get_locint_r();
2167                ADOLC_EXT_FCT_SAVE_NUMDIRS;
2168                edfct = get_ext_diff_fct(ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index);
2169
2170                oldTraceFlag = ADOLC_CURRENT_TAPE_INFOS.traceFlag;
2171                ADOLC_CURRENT_TAPE_INFOS.traceFlag = 0;
2172
2173                if (edfct->ADOLC_EXT_FCT_POINTER == NULL)
2174                    fail(ADOLC_EXT_DIFF_NULLPOINTER_FUNCTION);
2175                if (m>0) {
2176                    if (ADOLC_EXT_FCT_U == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
2177                    if (edfct->dp_y==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
2178                }
2179                if (n>0) {
2180                    if (ADOLC_EXT_FCT_Z == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
2181                    if (edfct->dp_x==NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
2182                }
2183                arg = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev;
2184                for (loop = 0; loop < m; ++loop) {
2185                    FOR_0_LE_l_LT_p {
2186                        ADOLC_EXT_FCT_U_L_LOOP = ADJOINT_BUFFER_ARG_L;
2187                    }
2188                    ++arg;
2189                }
2190
2191                arg = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev;
2192                for (loop = 0; loop < n; ++loop) {
2193                    FOR_0_LE_l_LT_p {
2194                        ADOLC_EXT_FCT_Z_L_LOOP = ADJOINT_BUFFER_ARG_L;
2195                    }
2196                    ++arg;
2197                }
2198                arg = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev;
2199                for (loop = 0; loop < n; ++loop,++arg) {
2200                  edfct->dp_x[loop]=TARG;
2201                }
2202                arg = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev;
2203                for (loop = 0; loop < m; ++loop,++arg) {
2204                  edfct->dp_y[loop]=TARG;
2205                }
2206                ext_retc = edfct->ADOLC_EXT_FCT_COMPLETE;
2207                MINDEC(ret_c, ext_retc);
2208
2209                res = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev;
2210                for (loop = 0; loop < m; ++loop) {
2211                    FOR_0_LE_l_LT_p {
2212                        ADJOINT_BUFFER_RES_L = 0.; /* \bar{v}_i = 0 !!! */
2213                    }
2214                    ++res;
2215                }
2216                res = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev;
2217                for (loop = 0; loop < n; ++loop) {
2218                    FOR_0_LE_l_LT_p {
2219                        ADJOINT_BUFFER_RES_L = ADOLC_EXT_FCT_Z_L_LOOP;
2220                    }
2221                    ++res;
2222                }
2223                if (edfct->dp_y_priorRequired) {
2224                  arg = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev+m-1;
2225                  for (loop = 0; loop < m; ++loop,--arg) {
2226                    ADOLC_GET_TAYLOR(arg);
2227                  }
2228                }
2229                if (edfct->dp_x_changes) {
2230                  arg = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev+n-1;
2231                  for (loop = 0; loop < n; ++loop,--arg) {
2232                    ADOLC_GET_TAYLOR(arg);
2233                  }
2234                }
2235                ADOLC_CURRENT_TAPE_INFOS.traceFlag = oldTraceFlag;
2236
2237                break;
2238#endif /* !_INT_REV_ */
2239                /*--------------------------------------------------------------------------*/
2240            default:                                                   /* default */
2241                /*             Die here, we screwed up     */
2242
2243                fprintf(DIAG_OUT,"ADOL-C fatal error in " GENERATED_FILENAME " ("
2244                        __FILE__
2245                        ") : no such operation %d\n", operation);
2246                exit(-1);
2247                break;
2248        } /* endswitch */
2249
2250        /* Get the next operation */
2251        operation=get_op_r();
2252    } /* endwhile */
2253
2254    /* clean up */
2255#if !defined(_INT_REV_)
2256    free(rp_T);
2257#endif
2258#ifdef _FOS_
2259    free(rp_A);
2260#endif
2261#ifdef _FOV_
2262    myfree2(rpp_A);
2263#endif
2264#ifdef _INT_REV_
2265    free(upp_A);
2266#endif
2267
2268    end_sweep();
2269
2270    return ret_c;
2271}
2272
2273
2274/****************************************************************************/
2275/*                                                               THAT'S ALL */
2276
2277END_C_DECLS
Note: See TracBrowser for help on using the repository browser.