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

Last change on this file since 270 was 249, checked in by awalther, 9 years ago

correct typos

  • Property svn:keywords set to Author Date Id Revision
File size: 60.1 KB
Line 
1/*----------------------------------------------------------------------------
2 ADOL-C -- Automatic Differentiation by Overloading in C++
3 File:     fo_rev.c
4 Revision: $Id: fo_rev.c 249 2011-06-13 18:57:34Z 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 
21 This file is part of ADOL-C. This software is provided as open source.
22 Any use, reproduction, or distribution of the software constitutes
23 recipient's acceptance of the terms of the accompanying license file.
24           
25----------------------------------------------------------------------------*/
26
27/*****************************************************************************
28 
29  There are four basic versions of the procedure `reverse', which
30  are optimized for the cases of scalar or vector reverse sweeps
31  with first or higher derivatives, respectively. In the calling
32  sequence this distinction is apparent from the type of the
33  parameters `lagrange' and `results'. The former may be left out
34  and the integer parameters `depen', `indep', `degre', and `nrows'
35  must be set or default according to the following matrix of
36  calling cases.
37 
38           no lagrange         double* lagrange     double** lagrange
39 
40double*   gradient of scalar   weight vector times    infeasible
41results   valued function      Jacobian product       combination
42 
43          ( depen = 1 ,         ( depen > 0 ,         
44            degre = 0 ,           degre = 0 ,              ------
45            nrows = 1 )           nrows = 1 )
46 
47double**  Jacobian of vector   weight vector times     weight matrix
48results   valued function      Taylor-Jacobians        times Jacobian
49           
50          ( 0 < depen           ( depen > 0 ,          ( depen > 0 ,
51              = nrows ,           degre > 0 ,            degre = 0 ,
52            degre = 0 )           nrows = 1 )            nrows > 0 )
53 
54double*** full family of         ------------          weigth matrix x
55results   Taylor-Jacobians       ------------          Taylor Jacobians
56 
57*****************************************************************************/
58
59/****************************************************************************/
60/*                                                                   MACROS */
61#undef _ADOLC_VECTOR_
62
63/*--------------------------------------------------------------------------*/
64#ifdef _FOS_
65#define GENERATED_FILENAME "fos_reverse"
66
67#define RESULTS(l,indexi)  results[indexi]
68#define LAGRANGE(l,indexd) lagrange[indexd]
69
70/*--------------------------------------------------------------------------*/
71#elif _FOV_
72#define GENERATED_FILENAME "fov_reverse"
73
74#define _ADOLC_VECTOR_
75
76#define RESULTS(l,indexi)  results[l][indexi]
77#define LAGRANGE(l,indexd) lagrange[l][indexd]
78
79#else
80#if defined(_INT_REV_)
81#if defined(_TIGHT_)
82#define GENERATED_FILENAME "int_reverse_t"
83#endif
84#if defined(_NTIGHT_)
85#define GENERATED_FILENAME "int_reverse_s"
86#endif
87#define RESULTS(l,indexi)  results[l][indexi]
88#define LAGRANGE(l,indexd) lagrange[l][indexd]
89#else
90#error Error ! Define [_FOS_ | _FOV_ | _INT_REV_SAFE_ | _INT_REV_TIGHT_ ]
91#endif
92#endif
93/*--------------------------------------------------------------------------*/
94/*                                                     access to variables  */
95
96#ifdef _FOS_
97#define ARES       *Ares
98#define AARG       *Aarg
99#define AARG1      *Aarg1
100#define AARG2      *Aarg2
101
102#define ARES_INC   *Ares
103#define AARG_INC   *Aarg
104#define AARG1_INC  *Aarg1
105#define AARG2_INC  *Aarg2
106
107#define ARES_INC_O  Ares
108#define AARG_INC_O  /adAarg
109#define AARG1_INC_O Aarg1
110#define AARG2_INC_O Aarg2
111
112#define ASSIGN_A(a,b)  a = &b;
113
114#else  /* _FOV_ */
115#ifdef _FOV_
116#define ARES       *Ares
117#define AARG       *Aarg
118#define AARG1      *Aarg1
119#define AARG2      *Aarg2
120
121#define ARES_INC   *Ares++
122#define AARG_INC   *Aarg++
123#define AARG1_INC  *Aarg1++
124#define AARG2_INC  *Aarg2++
125
126#define ARES_INC_O  Ares++
127#define AARG_INC_O  Aarg++
128#define AARG1_INC_O Aarg1++
129#define AARG2_INC_O Aarg2++
130
131#define ASSIGN_A(a,b)  a = b;
132#else
133#ifdef _INT_REV_
134#define ARES       *Ares
135#define AARG       *Aarg
136#define AARG1      *Aarg1
137#define AARG2      *Aarg2
138
139#define ARES_INC   *Ares++
140#define AARG_INC   *Aarg++
141#define AARG1_INC  *Aarg1++
142#define AARG2_INC  *Aarg2++
143
144#define ARES_INC_O  Ares++
145#define AARG_INC_O  Aarg++
146#define AARG1_INC_O Aarg1++
147#define AARG2_INC_O Aarg2++
148
149#define ASSIGN_A(a,b)  a = b;
150#endif
151#endif
152#endif
153
154#define TRES       rp_T[res]
155#define TARG       rp_T[arg]
156#define TARG1      rp_T[arg1]
157#define TARG2      rp_T[arg2]
158
159/*--------------------------------------------------------------------------*/
160/*                                                              loop stuff  */
161#ifdef _ADOLC_VECTOR_
162#define FOR_0_LE_l_LT_p for (l=0; l<p; l++)
163#define FOR_p_GT_l_GE_0 for (l=p-1; l>=0; l--)
164#else
165#ifdef _INT_REV_
166#define FOR_0_LE_l_LT_p for (l=0; l<p; l++)
167#define FOR_p_GT_l_GE_0 for (l=p-1; l>=0; l--)
168#else
169#define FOR_0_LE_l_LT_p
170#define FOR_p_GT_l_GE_0
171#endif
172#endif
173
174#ifdef _FOV_
175#define FOR_0_LE_l_LT_pk1 for (l=0; l<p; l++)
176#else
177#ifdef _INT_REV_
178#define FOR_0_LE_l_LT_pk1 for (l=0; l<p; l++)
179#else
180#define FOR_0_LE_l_LT_pk1
181#endif
182#endif
183
184/* END Macros */
185
186
187/****************************************************************************/
188/*                                                       NECESSARY INCLUDES */
189#include <adolc/interfaces.h>
190#include <adolc/adalloc.h>
191#include <adolc/oplate.h>
192#include "taping_p.h"
193#include <adolc/externfcts.h>
194#include "externfcts_p.h"
195
196#include <math.h>
197
198BEGIN_C_DECLS
199
200/****************************************************************************/
201/*                                                             NOW THE CODE */
202
203#ifdef _FOS_
204/****************************************************************************/
205/* First-Order Scalar Reverse Pass.                                         */
206/****************************************************************************/
207int fos_reverse(short   tnum,       /* tape id */
208                int     depen,      /* consistency chk on # of deps */
209                int     indep,      /* consistency chk on # of indeps */
210                double  *lagrange,
211                double  *results)   /*  coefficient vectors */
212
213#else
214#if _FOV_
215/****************************************************************************/
216/* First-Order Vector Reverse Pass.                                         */
217/****************************************************************************/
218
219int fov_reverse(short   tnum,        /* tape id */
220                int     depen,       /* consistency chk on # of deps */
221                int     indep,       /* consistency chk on # of indeps */
222                int     nrows,       /* # of Jacobian rows being calculated */
223                double  **lagrange,  /* domain weight vector */
224                double  **results)   /* matrix of coefficient vectors */
225
226#else
227#if defined(_INT_REV_)
228#if defined(_TIGHT_)
229/****************************************************************************/
230/* First Order Vector version of the reverse mode for bit patterns, tight   */
231/****************************************************************************/
232int int_reverse_tight(
233        short             tnum,  /* tape id                               */
234        int               depen, /* consistency chk on # of deps          */
235        int               indep, /* consistency chk on # of indeps        */
236        int               nrows, /* # of Jacobian rows being calculated   */
237        unsigned long int **lagrange,/* domain weight vector[var][row](in)*/
238        unsigned long int **results) /* matrix of coeff. vectors[var][row]*/
239
240#endif
241#if defined(_NTIGHT_)
242/****************************************************************************/
243/* First Order Vector version of the reverse mode, bit pattern, safe        */
244/****************************************************************************/
245int int_reverse_safe(
246        short             tnum,  /* tape id                               */
247        int               depen, /* consistency chk on # of deps          */
248        int               indep, /* consistency chk on # of indeps        */
249        int               nrows, /* # of Jacobian rows being calculated   */
250        unsigned long int **lagrange,/* domain weight vector[var][row](in)*/
251        unsigned long int **results) /* matrix of coeff. vectors[var][row]*/
252#endif
253#endif
254#endif
255#endif
256{
257    /****************************************************************************/
258    /*                                                           ALL VARIABLES  */
259    unsigned char operation;   /* operation code */
260    int ret_c = 3;             /* return value */
261
262    locint size = 0;
263    locint res  = 0;
264    locint arg  = 0;
265    locint arg1 = 0;
266    locint arg2 = 0;
267
268#if !defined (_NTIGHT_)
269    double coval = 0, *d = 0;
270#endif
271
272    int indexi = 0,  indexd = 0;
273
274    /* loop indices */
275#if defined(_FOV_)
276    int l;
277#endif
278#if defined(_INT_REV_)
279    int l;
280#endif
281    int j, ls;
282
283    /* other necessary variables */
284#if !defined (_NTIGHT_)
285    double r0, r_0;
286    int taycheck;
287    int numdep,numind;
288#endif
289
290    /*--------------------------------------------------------------------------*/
291    /* Adjoint stuff */
292#ifdef _FOS_
293    revreal *rp_A;
294    revreal aTmp;
295#endif
296#ifdef _FOV_
297    revreal **rpp_A, *Aqo;
298    revreal aTmp;
299#endif
300#if !defined(_NTIGHT_)
301    revreal *rp_T;
302#endif /* !_NTIGHT_ */
303#if !defined _INT_REV_
304    revreal  *Ares, *Aarg, *Aarg1, *Aarg2;
305#else
306    unsigned long int **upp_A;
307    unsigned long int *Ares, *Aarg, *Aarg1, *Aarg2;
308    unsigned long int aTmp;
309#endif
310
311    /*--------------------------------------------------------------------------*/
312
313#ifdef _ADOLC_VECTOR_
314    int p = nrows;
315#endif
316#ifdef _INT_REV_
317    int p = nrows;
318#endif
319
320#if !defined(ADOLC_USE_CALLOC)
321    char * c_Ptr;
322#endif
323
324    /****************************************************************************/
325    /*                                          extern diff. function variables */
326#if defined(_FOS_)
327# define ADOLC_EXT_FCT_U edfct->dp_U
328# define ADOLC_EXT_FCT_Z edfct->dp_Z
329# define ADOLC_EXT_FCT_POINTER fos_reverse
330# define ADOLC_EXT_FCT_COMPLETE \
331  fos_reverse(m, edfct->dp_U, n, edfct->dp_Z)
332# define ADOLC_EXT_FCT_SAVE_NUMDIRS
333#else
334# define ADOLC_EXT_FCT_U edfct->dpp_U
335# define ADOLC_EXT_FCT_Z edfct->dpp_Z
336# define ADOLC_EXT_FCT_POINTER fov_reverse
337# define ADOLC_EXT_FCT_COMPLETE \
338  fov_reverse(m, edfct->dpp_U, n, edfct->dpp_Z)
339# define ADOLC_EXT_FCT_SAVE_NUMDIRS ADOLC_CURRENT_TAPE_INFOS.numDirs_rev = nrows
340#endif
341#if !defined(_INT_REV_)
342    locint n, m;
343    ext_diff_fct *edfct;
344    int loop;
345    int ext_retc;
346    int oldTraceFlag;
347#endif
348
349
350    ADOLC_OPENMP_THREAD_NUMBER;
351    ADOLC_OPENMP_GET_THREAD_NUMBER;
352
353#if defined(ADOLC_DEBUG)
354    /****************************************************************************/
355    /*                                                           DEBUG MESSAGES */
356    fprintf(DIAG_OUT,"Call of %s(..) with tag: %d, n: %d, m %d,\n",
357            GENERATED_FILENAME, tnum, indep, depen);
358#ifdef _ADOLC_VECTOR_
359    fprintf(DIAG_OUT,"                    p: %d\n\n",nrows);
360#endif
361
362#endif
363
364    /****************************************************************************/
365    /*                                                                    INITs */
366
367    /*------------------------------------------------------------------------*/
368    /* Set up stuff for the tape */
369
370    /* Initialize the Reverse Sweep */
371    init_rev_sweep(tnum);
372
373    failAdditionalInfo3 = depen;
374    failAdditionalInfo4 = indep;
375    if ( (depen != ADOLC_CURRENT_TAPE_INFOS.stats[NUM_DEPENDENTS]) ||
376            (indep != ADOLC_CURRENT_TAPE_INFOS.stats[NUM_INDEPENDENTS]) )
377        fail(ADOLC_REVERSE_COUNTS_MISMATCH);
378
379    indexi = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_INDEPENDENTS] - 1;
380    indexd = ADOLC_CURRENT_TAPE_INFOS.stats[NUM_DEPENDENTS] - 1;
381
382
383    /****************************************************************************/
384    /*                                                  MEMORY ALLOCATION STUFF */
385
386    /*--------------------------------------------------------------------------*/
387#ifdef _FOS_                                                         /* FOS */
388    rp_A = (revreal*) malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] * sizeof(revreal));
389    if (rp_A == NULL) fail(ADOLC_MALLOC_FAILED);
390    ADOLC_CURRENT_TAPE_INFOS.rp_A = rp_A;
391    rp_T = (revreal *)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] *
392            sizeof(revreal));
393    if (rp_T == NULL) fail(ADOLC_MALLOC_FAILED);
394#if !defined(ADOLC_USE_CALLOC)
395    c_Ptr = (char *) ADOLC_GLOBAL_TAPE_VARS.rp_A;
396    *c_Ptr = 0;
397    memcpy(c_Ptr + 1, c_Ptr, sizeof(double) *
398            ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] - 1);
399#endif
400# define ADJOINT_BUFFER rp_A
401# define ADJOINT_BUFFER_ARG_L rp_A[arg]
402# define ADJOINT_BUFFER_RES_L rp_A[res]
403# define ADOLC_EXT_FCT_U_L_LOOP edfct->dp_U[loop]
404# define ADOLC_EXT_FCT_Z_L_LOOP edfct->dp_Z[loop]
405
406    /*--------------------------------------------------------------------------*/
407#else
408#if defined _FOV_                                                          /* FOV */
409    rpp_A = (revreal**)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] *
410            sizeof(revreal*));
411    if (rpp_A == NULL) fail(ADOLC_MALLOC_FAILED);
412    Aqo = (revreal*)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] * p *
413            sizeof(revreal));
414    if (Aqo == NULL) fail(ADOLC_MALLOC_FAILED);
415    for (j=0; j<ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES]; j++) {
416        rpp_A[j] = Aqo;
417        Aqo += p;
418    }
419    ADOLC_CURRENT_TAPE_INFOS.rpp_A = rpp_A;
420    rp_T = (revreal *)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] *
421            sizeof(revreal));
422    if (rp_T == NULL) fail(ADOLC_MALLOC_FAILED);
423#if !defined(ADOLC_USE_CALLOC)
424    c_Ptr = (char *) ADOLC_GLOBAL_TAPE_VARS.dpp_A;
425    *c_Ptr = 0;
426    memcpy(c_Ptr + 1, c_Ptr, sizeof(double) * p *
427            ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] - 1);
428#endif
429# define ADJOINT_BUFFER rpp_A
430# define ADJOINT_BUFFER_ARG_L rpp_A[arg][l]
431# define ADJOINT_BUFFER_RES_L rpp_A[res][l]
432# define ADOLC_EXT_FCT_U_L_LOOP edfct->dpp_U[l][loop]
433# define ADOLC_EXT_FCT_Z_L_LOOP edfct->dpp_Z[l][loop]
434#else
435#if defined _INT_REV_
436    upp_A = myalloc2_ulong(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES], p);
437#if defined _TIGHT_
438    ADOLC_CURRENT_TAPE_INFOS.upp_A = upp_A;
439    rp_T = (revreal *)malloc(ADOLC_CURRENT_TAPE_INFOS.stats[NUM_MAX_LIVES] *
440                             sizeof(revreal));
441    if (rp_T == NULL) fail(ADOLC_MALLOC_FAILED);
442#endif
443# define ADJOINT_BUFFER upp_A
444# define ADJOINT_BUFFER_ARG_L upp_A[arg][l]
445# define ADJOINT_BUFFER_RES_L upp_A[res][l]
446#endif
447#endif
448#endif
449
450    /****************************************************************************/
451    /*                                                    TAYLOR INITIALIZATION */
452
453#if !defined(_NTIGHT_)
454    ADOLC_CURRENT_TAPE_INFOS.rp_T = rp_T;
455
456    taylor_back(tnum, &numdep, &numind, &taycheck);
457
458    if (taycheck < 0) {
459        fprintf(DIAG_OUT,"\n ADOL-C error: reverse fails because it was not"
460                " preceded\nby a forward sweep with degree>0, keep=1!\n");
461        exit(-2);
462    };
463
464    if((numdep != depen)||(numind != indep))
465        fail(ADOLC_REVERSE_TAYLOR_COUNTS_MISMATCH);
466
467#endif /* !_NTIGHT_ */
468
469
470    /****************************************************************************/
471    /*                                                            REVERSE SWEEP */
472
473    operation=get_op_r();
474    while (operation != start_of_tape) { /* Switch statement to execute the operations in Reverse */
475        switch (operation) {
476
477
478                /****************************************************************************/
479                /*                                                                  MARKERS */
480
481                /*--------------------------------------------------------------------------*/
482            case end_of_op:                                          /* end_of_op */
483                get_op_block_r();
484                operation = get_op_r();
485                /* Skip next operation, it's another end_of_op */
486                break;
487
488                /*--------------------------------------------------------------------------*/
489            case end_of_int:                                        /* end_of_int */
490                get_loc_block_r(); /* Get the next int block */
491                break;
492
493                /*--------------------------------------------------------------------------*/
494            case end_of_val:                                        /* end_of_val */
495                get_val_block_r(); /* Get the next val block */
496                break;
497
498                /*--------------------------------------------------------------------------*/
499            case start_of_tape:                                  /* start_of_tape */
500            case end_of_tape:                                      /* end_of_tape */
501                break;
502
503
504                /****************************************************************************/
505                /*                                                               COMPARISON */
506
507                /*--------------------------------------------------------------------------*/
508            case eq_zero  :                                            /* eq_zero */
509                arg   = get_locint_r();
510
511#if !defined(_NTIGHT_)
512                ret_c = 0;
513#endif /* !_NTIGHT_ */
514                break;
515
516                /*--------------------------------------------------------------------------*/
517            case neq_zero :                                           /* neq_zero */
518            case gt_zero  :                                            /* gt_zero */
519            case lt_zero :                                             /* lt_zero */
520                arg   = get_locint_r();
521                break;
522
523                /*--------------------------------------------------------------------------*/
524            case ge_zero :                                             /* ge_zero */
525            case le_zero :                                             /* le_zero */
526                arg   = get_locint_r();
527
528#if !defined(_NTIGHT_)
529                if (TARG == 0)
530                    ret_c = 0;
531#endif /* !_NTIGHT_ */
532                break;
533
534
535                /****************************************************************************/
536                /*                                                              ASSIGNMENTS */
537
538                /*--------------------------------------------------------------------------*/
539            case assign_a:           /* assign an adouble variable an    assign_a */
540                /* adouble value. (=) */
541                res = get_locint_r();
542                arg = get_locint_r();
543
544                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
545                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
546
547                FOR_0_LE_l_LT_p
548                {
549#if defined(_INT_REV_)                 
550                  AARG_INC |= ARES;
551                  ARES_INC = 0;
552#else
553                  AARG_INC += ARES;
554                  ARES_INC = 0.0;
555#endif
556            }
557
558#if !defined(_NTIGHT_)
559                ADOLC_GET_TAYLOR(res);
560#endif /* !_NTIGHT_ */
561                break;
562
563                /*--------------------------------------------------------------------------*/
564            case assign_d:            /* assign an adouble variable a    assign_d */
565                /* double value. (=) */
566                res   = get_locint_r();
567#if !defined(_NTIGHT_)
568                coval = get_val_r();
569#endif /* !_NTIGHT_ */
570
571                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
572
573                FOR_0_LE_l_LT_p
574#if defined(_INT_REV_)                 
575                ARES_INC = 0;
576#else
577                ARES_INC = 0.0;
578#endif
579
580#if !defined(_NTIGHT_)
581                ADOLC_GET_TAYLOR(res);
582#endif /* !_NTIGHT_ */
583                break;
584
585                /*--------------------------------------------------------------------------*/
586            case assign_d_zero:  /* assign an adouble variable a    assign_d_zero */
587            case assign_d_one:   /* double value (0 or 1). (=)       assign_d_one */
588                res   = get_locint_r();
589
590                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
591
592                FOR_0_LE_l_LT_p
593#if defined(_INT_REV_)                 
594                ARES_INC = 0;
595#else
596                ARES_INC = 0.0;
597#endif
598
599#if !defined(_NTIGHT_)
600                ADOLC_GET_TAYLOR(res);
601#endif /* !_NTIGHT_ */
602                break;
603
604                /*--------------------------------------------------------------------------*/
605            case assign_ind:       /* assign an adouble variable an    assign_ind */
606                /* independent double value (<<=) */
607                res = get_locint_r();
608
609                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
610
611                FOR_0_LE_l_LT_p
612                    RESULTS(l,indexi) = ARES_INC;
613
614#if !defined(_NTIGHT_)
615                ADOLC_GET_TAYLOR(res);
616#endif /* !_NTIGHT_ */
617                indexi--;
618                break;
619
620                /*--------------------------------------------------------------------------*/
621            case assign_dep:           /* assign a float variable a    assign_dep */
622                /* dependent adouble value. (>>=) */
623                res = get_locint_r();
624
625                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
626
627                FOR_0_LE_l_LT_p
628                ARES_INC = LAGRANGE(l,indexd);
629
630                indexd--;
631                break;
632
633
634                /****************************************************************************/
635                /*                                                   OPERATION + ASSIGNMENT */
636
637                /*--------------------------------------------------------------------------*/
638            case eq_plus_d:            /* Add a floating point to an    eq_plus_d */
639                /* adouble. (+=) */
640                res   = get_locint_r();
641#if !defined(_NTIGHT_)
642                coval = get_val_r();
643
644                ADOLC_GET_TAYLOR(res);
645#endif /* !_NTIGHT_ */
646                break;
647
648                /*--------------------------------------------------------------------------*/
649            case eq_plus_a:             /* Add an adouble to another    eq_plus_a */
650                /* adouble. (+=) */
651                res = get_locint_r();
652                arg = get_locint_r();
653
654                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
655                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg]);
656
657                FOR_0_LE_l_LT_p
658#if defined(_INT_REV_)
659                AARG_INC |= ARES_INC;
660#else
661                AARG_INC += ARES_INC;
662#endif
663
664#if !defined(_NTIGHT_)
665                ADOLC_GET_TAYLOR(res);
666#endif /* !_NTIGHT_ */
667                break;
668
669                /*--------------------------------------------------------------------------*/
670            case eq_min_d:       /* Subtract a floating point from an    eq_min_d */
671                /* adouble. (-=) */
672                res   = get_locint_r();
673#if !defined(_NTIGHT_)
674                coval = get_val_r();
675
676                ADOLC_GET_TAYLOR(res);
677#endif /* !_NTIGHT_ */
678               break;
679
680                /*--------------------------------------------------------------------------*/
681            case eq_min_a:        /* Subtract an adouble from another    eq_min_a */
682                /* adouble. (-=) */
683                res = get_locint_r();
684                arg = get_locint_r();
685
686                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
687                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
688
689                FOR_0_LE_l_LT_p
690#if defined(_INT_REV_)
691                AARG_INC |= ARES_INC;
692#else
693                AARG_INC -= ARES_INC;
694#endif
695
696#if !defined(_NTIGHT_)
697               ADOLC_GET_TAYLOR(res);
698#endif /* !_NTIGHT_ */
699                break;
700
701                /*--------------------------------------------------------------------------*/
702            case eq_mult_d:              /* Multiply an adouble by a    eq_mult_d */
703                /* flaoting point. (*=) */
704                res   = get_locint_r();
705#if !defined(_NTIGHT_)
706                coval = get_val_r();
707#endif /* !_NTIGHT_ */
708
709#if!defined(_INT_REV_)
710                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
711
712                FOR_0_LE_l_LT_p
713                ARES_INC *= coval;
714#endif
715
716#if !defined(_NTIGHT_)
717                ADOLC_GET_TAYLOR(res);
718#endif /* !_NTIGHT_ */
719                break;
720
721                /*--------------------------------------------------------------------------*/
722            case eq_mult_a:       /* Multiply one adouble by another    eq_mult_a */
723                /* (*=) */
724                res = get_locint_r();
725                arg = get_locint_r();
726
727#if !defined(_NTIGHT_)
728                ADOLC_GET_TAYLOR(res);
729#endif /* !_NTIGHT_ */
730
731                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
732                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
733
734                FOR_0_LE_l_LT_p
735#if defined(_INT_REV_)
736                AARG_INC |= ARES_INC;
737#else
738                { aTmp = ARES;
739                  /* olvo 980713 nn: ARES = 0.0; */
740                  ARES_INC =  aTmp * TARG;
741                  AARG_INC += aTmp * TRES;
742                }
743#endif     
744                break;
745
746                /*--------------------------------------------------------------------------*/
747            case incr_a:                        /* Increment an adouble    incr_a */
748            case decr_a:                        /* Increment an adouble    decr_a */
749                res   = get_locint_r();
750
751#if !defined(_NTIGHT_)
752                ADOLC_GET_TAYLOR(res);
753#endif /* !_NTIGHT_ */
754                break;
755
756
757                /****************************************************************************/
758                /*                                                        BINARY OPERATIONS */
759
760                /*--------------------------------------------------------------------------*/
761            case plus_a_a:                 /* : Add two adoubles. (+)    plus a_a */
762                res  = get_locint_r();
763                arg2 = get_locint_r();
764                arg1 = get_locint_r();
765
766                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
767                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
768                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
769
770                FOR_0_LE_l_LT_p
771                { aTmp = ARES;
772#if defined(_INT_REV_)
773                  ARES_INC = 0;
774                  AARG1_INC |= aTmp;
775                  AARG2_INC |= aTmp;
776#else
777                  ARES_INC = 0.0;
778                  AARG1_INC += aTmp;
779                  AARG2_INC += aTmp;
780#endif
781            }
782
783#if !defined(_NTIGHT_)
784                ADOLC_GET_TAYLOR(res);
785#endif /* !_NTIGHT_ */
786                break;
787
788                /*--------------------------------------------------------------------------*/
789            case plus_d_a:             /* Add an adouble and a double    plus_d_a */
790                /* (+) */
791                res   = get_locint_r();
792                arg   = get_locint_r();
793#if !defined(_NTIGHT_)
794                coval = get_val_r();
795#endif /* !_NTIGHT_ */
796
797                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
798                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
799
800                FOR_0_LE_l_LT_p
801                { aTmp = ARES;
802#if defined(_INT_REV_)
803                  ARES_INC = 0;
804                  AARG_INC |= aTmp;
805#else
806                  ARES_INC = 0.0;
807                  AARG_INC += aTmp;
808#endif
809            }
810
811#if !defined(_NTIGHT_)
812                ADOLC_GET_TAYLOR(res);
813#endif /* !_NTIGHT_ */
814                break;
815
816                /*--------------------------------------------------------------------------*/
817            case min_a_a:              /* Subtraction of two adoubles    min_a_a */
818                /* (-) */
819                res  = get_locint_r();
820                arg2 = get_locint_r();
821                arg1 = get_locint_r();
822
823                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
824                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
825                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
826
827                FOR_0_LE_l_LT_p
828                { aTmp = ARES;
829#if defined(_INT_REV_)
830                  ARES_INC = 0;
831                  AARG1_INC |= aTmp;
832                  AARG2_INC |= aTmp;
833#else
834                  ARES_INC = 0.0;
835                  AARG1_INC += aTmp;
836                  AARG2_INC -= aTmp;
837#endif
838            }
839
840#if !defined(_NTIGHT_)
841                ADOLC_GET_TAYLOR(res);
842#endif /* !_NTIGHT_ */
843                break;
844
845                /*--------------------------------------------------------------------------*/
846            case min_d_a:                /* Subtract an adouble from a    min_d_a */
847                /* double (-) */
848                res   = get_locint_r();
849                arg   = get_locint_r();
850#if !defined(_NTIGHT_)
851                coval = get_val_r();
852#endif /* !_NTIGHT_ */
853
854                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
855                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
856
857                FOR_0_LE_l_LT_p
858                { aTmp = ARES;
859#if defined(_INT_REV_)
860                  ARES_INC = 0;
861                  AARG_INC |= aTmp;
862#else
863                  ARES_INC = 0.0;
864                  AARG_INC -= aTmp;
865#endif
866            }
867
868#if !defined(_NTIGHT_)
869                ADOLC_GET_TAYLOR(res);
870#endif /* !_NTIGHT_ */
871                break;
872
873                /*--------------------------------------------------------------------------*/
874            case mult_a_a:               /* Multiply two adoubles (*)    mult_a_a */
875                res  = get_locint_r();
876                arg2 = get_locint_r();
877                arg1 = get_locint_r();
878
879#if !defined(_NTIGHT_)
880                ADOLC_GET_TAYLOR(res);
881#endif /* !_NTIGHT_ */
882
883                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
884                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
885                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
886
887                FOR_0_LE_l_LT_p
888                { aTmp = ARES;
889#if defined(_INT_REV_)
890                  ARES_INC = 0;
891                  AARG2_INC |= aTmp;
892                  AARG1_INC |= aTmp;
893#else
894                  ARES_INC = 0.0;
895                  AARG2_INC += aTmp * TARG1;
896                  AARG1_INC += aTmp * TARG2;
897#endif
898            }
899                break;
900
901                /*--------------------------------------------------------------------------*/
902                /* olvo 991122: new op_code with recomputation */
903            case eq_plus_prod:   /* increment a product of           eq_plus_prod */
904                /* two adoubles (*) */
905                res  = get_locint_r();
906                arg2 = get_locint_r();
907                arg1 = get_locint_r();
908
909                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
910                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
911                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
912
913#if !defined(_NTIGHT_)
914                /* RECOMPUTATION */
915                TRES -= TARG1*TARG2;
916#endif /* !_NTIGHT_ */
917
918                FOR_0_LE_l_LT_p
919                { 
920#if defined(_INT_REV_)
921                  AARG2_INC |= ARES;
922                  AARG1_INC |= ARES_INC;
923#else
924                  AARG2_INC += ARES    * TARG1;
925                  AARG1_INC += ARES_INC * TARG2;
926#endif
927            }
928                break;
929
930                /*--------------------------------------------------------------------------*/
931                /* olvo 991122: new op_code with recomputation */
932            case eq_min_prod:    /* decrement a product of            eq_min_prod */
933                /* two adoubles (*) */
934                res  = get_locint_r();
935                arg2 = get_locint_r();
936                arg1 = get_locint_r();
937
938                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
939                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
940                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
941
942#if !defined(_NTIGHT_)
943                /* RECOMPUTATION */
944                TRES += TARG1*TARG2;
945#endif /* !_NTIGHT_ */
946
947                FOR_0_LE_l_LT_p
948                { 
949#if defined(_INT_REV_)
950                  AARG2_INC |= ARES;
951                  AARG1_INC |= ARES_INC;
952#else                 
953                  AARG2_INC -= ARES    * TARG1;
954                  AARG1_INC -= ARES_INC * TARG2;
955#endif
956            }
957                break;
958
959                /*--------------------------------------------------------------------------*/
960            case mult_d_a:         /* Multiply an adouble by a double    mult_d_a */
961                /* (*) */
962                res   = get_locint_r();
963                arg   = get_locint_r();
964#if !defined(_NTIGHT_)
965                coval = get_val_r();
966#endif /* !_NTIGHT_ */
967
968                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
969                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
970
971                FOR_0_LE_l_LT_p
972                { aTmp = ARES;
973#if defined(_INT_REV_)
974                  ARES_INC = 0;
975                  AARG_INC |= aTmp;
976#else
977                  ARES_INC = 0.0;
978                  AARG_INC += coval * aTmp;
979#endif
980            }
981
982#if !defined(_NTIGHT_)
983                ADOLC_GET_TAYLOR(res);
984#endif /* !_NTIGHT_ */
985                break;
986
987                /*--------------------------------------------------------------------------*/
988            case div_a_a:           /* Divide an adouble by an adouble    div_a_a */
989                /* (/) */
990                res  = get_locint_r();
991                arg2 = get_locint_r();
992                arg1 = get_locint_r();
993
994                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
995                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
996                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
997
998                /* olvo 980922 changed order to allow x=y/x */
999#if !defined(_NTIGHT_)
1000                r_0 = -TRES;
1001                ADOLC_GET_TAYLOR(res);
1002                r0  = 1.0 / TARG2;
1003                r_0 *= r0;
1004#endif /* !_NTIGHT_ */
1005
1006                FOR_0_LE_l_LT_p
1007                { aTmp = ARES;
1008#if defined(_INT_REV_)
1009                  ARES_INC = 0;
1010                  AARG1_INC |= aTmp;
1011                  AARG2_INC |= aTmp;
1012#else
1013                  ARES_INC = 0.0;
1014                  AARG1_INC += aTmp * r0;
1015                  AARG2_INC += aTmp * r_0;
1016#endif
1017            }
1018
1019                break;
1020
1021                /*--------------------------------------------------------------------------*/
1022            case div_d_a:             /* Division double - adouble (/)    div_d_a */
1023                res   = get_locint_r();
1024                arg   = get_locint_r();
1025
1026#if !defined(_NTIGHT_)
1027                coval = get_val_r();
1028#endif /* !_NTIGHT_ */
1029
1030                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1031                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1032
1033#if !defined(_NTIGHT_)
1034                /* olvo 980922 changed order to allow x=d/x */
1035                r0 = -TRES;
1036                if (arg == res)
1037                    ADOLC_GET_TAYLOR(arg);
1038                r0 /= TARG;
1039#endif /* !_NTIGHT_ */
1040
1041                FOR_0_LE_l_LT_p
1042                { aTmp = ARES;
1043#if defined(_INT_REV_)
1044                  ARES_INC = 0;
1045                  AARG_INC |= aTmp;
1046#else
1047                  ARES_INC = 0.0;
1048                  AARG_INC += aTmp * r0;
1049#endif
1050                }
1051
1052#if !defined(_NTIGHT_)
1053                ADOLC_GET_TAYLOR(res);
1054#endif /* !_NTIGHT_ */
1055                break;
1056
1057
1058                /****************************************************************************/
1059                /*                                                         SIGN  OPERATIONS */
1060
1061                /*--------------------------------------------------------------------------*/
1062            case pos_sign_a:                                        /* pos_sign_a */
1063                res   = get_locint_r();
1064                arg   = get_locint_r();
1065
1066                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1067                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1068
1069                FOR_0_LE_l_LT_p
1070                { aTmp = ARES;
1071#if defined(_INT_REV_)
1072                  ARES_INC = 0;
1073                  AARG_INC |= aTmp;
1074#else
1075                  ARES_INC = 0.0;
1076                  AARG_INC += aTmp;
1077#endif
1078            }
1079
1080#if !defined(_NTIGHT_)
1081                ADOLC_GET_TAYLOR(res);
1082#endif /* !_NTIGHT_ */
1083                break;
1084
1085                /*--------------------------------------------------------------------------*/
1086            case neg_sign_a:                                        /* neg_sign_a */
1087                res   = get_locint_r();
1088                arg   = get_locint_r();
1089
1090                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1091                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1092
1093                FOR_0_LE_l_LT_p
1094                { aTmp = ARES;
1095#if defined(_INT_REV_)
1096                  ARES_INC = 0;
1097                  AARG_INC |= aTmp;
1098#else
1099                  ARES_INC = 0.0;
1100                  AARG_INC -= aTmp;
1101#endif
1102            }
1103
1104#if !defined(_NTIGHT_)
1105                ADOLC_GET_TAYLOR(res);
1106#endif /* !_NTIGHT_ */
1107                break;
1108
1109
1110                /****************************************************************************/
1111                /*                                                         UNARY OPERATIONS */
1112
1113                /*--------------------------------------------------------------------------*/
1114            case exp_op:                          /* exponent operation    exp_op */
1115                res = get_locint_r();
1116                arg = get_locint_r();
1117
1118                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1119                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1120
1121                FOR_0_LE_l_LT_p
1122                { aTmp = ARES;
1123#if defined(_INT_REV_)
1124                  ARES_INC = 0;
1125                  AARG_INC |= aTmp;
1126#else
1127                  ARES_INC = 0.0;
1128                  AARG_INC += aTmp * TRES;
1129#endif
1130            }
1131
1132#if !defined(_NTIGHT_)
1133                ADOLC_GET_TAYLOR(res);
1134#endif /* !_NTIGHT_ */
1135                break;
1136
1137                /*--------------------------------------------------------------------------*/
1138            case sin_op:                              /* sine operation    sin_op */
1139                res  = get_locint_r();
1140                arg2 = get_locint_r();
1141                arg1 = get_locint_r();
1142
1143                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1144                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1145
1146                FOR_0_LE_l_LT_p
1147                { aTmp = ARES;
1148#if defined(_INT_REV_)
1149                  ARES_INC = 0;
1150                  AARG1_INC |= aTmp;
1151#else
1152                  ARES_INC = 0.0;
1153                  AARG1_INC += aTmp * TARG2;
1154#endif
1155            }
1156
1157#if !defined(_NTIGHT_)
1158                ADOLC_GET_TAYLOR(res);
1159                ADOLC_GET_TAYLOR(arg2); /* olvo 980710 covalue */
1160                /* NOTE: ADJOINT_BUFFER[arg2] should be 0 already */
1161#endif /* !_NTIGHT_ */
1162                break;
1163
1164                /*--------------------------------------------------------------------------*/
1165            case cos_op:                            /* cosine operation    cos_op */
1166                res  = get_locint_r();
1167                arg2 = get_locint_r();
1168                arg1 = get_locint_r();
1169
1170                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1171                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1172
1173                FOR_0_LE_l_LT_p
1174                { aTmp = ARES;
1175#if defined(_INT_REV_)
1176                  ARES_INC = 0;
1177                  AARG1_INC |= aTmp;
1178#else
1179                  ARES_INC = 0.0;
1180                  AARG1_INC -= aTmp * TARG2;
1181#endif
1182            }
1183
1184#if !defined(_NTIGHT_)
1185                ADOLC_GET_TAYLOR(res);
1186                ADOLC_GET_TAYLOR(arg2); /* olvo 980710 covalue */
1187                /* NOTE ADJOINT_BUFFER[arg2] should be 0 already */
1188#endif /* !_NTIGHT_ */
1189                break;
1190
1191                /*--------------------------------------------------------------------------*/
1192            case atan_op:                                             /* atan_op  */
1193            case asin_op:                                             /* asin_op  */
1194            case acos_op:                                             /* acos_op  */
1195            case asinh_op:                                            /* asinh_op */
1196            case acosh_op:                                            /* acosh_op */
1197            case atanh_op:                                            /* atanh_op */
1198            case erf_op:                                              /* erf_op   */
1199                res  = get_locint_r();
1200                arg2 = get_locint_r();
1201                arg1 = get_locint_r();
1202
1203#if !defined(_NTIGHT_)
1204                ADOLC_GET_TAYLOR(res);
1205#endif /* !_NTIGHT_ */
1206
1207                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1208                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1209
1210                FOR_0_LE_l_LT_p
1211                { aTmp = ARES;
1212#if defined(_INT_REV_)
1213                  ARES_INC = 0;
1214                  AARG1_INC |= aTmp;
1215#else
1216                  ARES_INC = 0.0;
1217                  AARG1_INC += aTmp * TARG2;
1218#endif
1219                }
1220                break;
1221
1222                /*--------------------------------------------------------------------------*/
1223            case log_op:                                                /* log_op */
1224                res = get_locint_r();
1225                arg = get_locint_r();
1226
1227#if !defined(_NTIGHT_)
1228                ADOLC_GET_TAYLOR(res);
1229#endif /* !_NTIGHT_ */
1230
1231                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1232                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1233
1234#if !defined(_INT_REV_)
1235                r0 = 1.0/TARG;
1236#endif
1237
1238                FOR_0_LE_l_LT_p
1239                { aTmp = ARES;
1240#if defined(_INT_REV_)
1241                  ARES_INC = 0;
1242                  AARG_INC |= aTmp;
1243#else
1244                  ARES_INC = 0.0;
1245                  AARG_INC += aTmp * r0;
1246#endif
1247            }
1248                break;
1249
1250                /*--------------------------------------------------------------------------*/
1251            case pow_op:                                                /* pow_op */
1252                res   = get_locint_r();
1253                arg   = get_locint_r();
1254#if !defined(_NTIGHT_)
1255                coval = get_val_r();
1256#endif /* !_NTIGHT_ */
1257
1258                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1259                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1260
1261#if !defined(_NTIGHT_)
1262                /* olvo 980921 changed order to allow x=pow(x,n) */
1263                r0 = TRES;
1264                if (arg == res)
1265                    ADOLC_GET_TAYLOR(arg);
1266                if (TARG == 0.0)
1267                    r0 = 0.0;
1268                else
1269                    r0 *= coval/TARG;
1270#endif /* !_NTIGHT_ */
1271
1272                FOR_0_LE_l_LT_p {
1273                    aTmp = ARES;
1274#if defined(_INT_REV_)
1275                    ARES_INC = 0;
1276                    AARG_INC |= aTmp;
1277#else
1278                    ARES_INC = 0.0;
1279                    AARG_INC += aTmp * r0;
1280#endif
1281            }
1282
1283#if !defined(_NTIGHT_)
1284                ADOLC_GET_TAYLOR(res);
1285#endif /* !_NTIGHT_ */
1286                break;
1287
1288                /*--------------------------------------------------------------------------*/
1289            case sqrt_op:                                              /* sqrt_op */
1290                res = get_locint_r();
1291                arg = get_locint_r();
1292
1293                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1294                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1295
1296#if !defined(_NTIGHT_)
1297                if (TRES == 0.0)
1298                    r0 = 0.0;
1299                else
1300                    r0 = 0.5 / TRES;
1301#endif /* !_NTIGHT_ */
1302
1303                FOR_0_LE_l_LT_p {
1304                    aTmp = ARES;
1305#if defined(_INT_REV_)
1306                    ARES_INC = 0;
1307                    AARG_INC |= aTmp;
1308#else
1309                    ARES_INC = 0.0;
1310                    AARG_INC += aTmp * r0;
1311#endif
1312                }
1313
1314#if !defined(_NTIGHT_)
1315                ADOLC_GET_TAYLOR(res);
1316#endif /* !_NTIGHT_ */
1317              break;
1318
1319                /*--------------------------------------------------------------------------*/
1320            case gen_quad:                                            /* gen_quad */
1321                res   = get_locint_r();
1322                arg2  = get_locint_r();
1323                arg1  = get_locint_r();
1324#if !defined(_NTIGHT_)
1325                coval = get_val_r();
1326                coval = get_val_r();
1327#endif /* !_NTIGHT_ */
1328
1329                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1330                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1331
1332                FOR_0_LE_l_LT_p
1333                { aTmp = ARES;
1334#if defined(_INT_REV_)
1335                  ARES_INC = 0;
1336                  AARG1_INC |= aTmp;
1337#else
1338                  ARES_INC = 0.0;
1339                  AARG1_INC += aTmp * TARG2;
1340#endif
1341            }
1342
1343#if !defined(_NTIGHT_)
1344                ADOLC_GET_TAYLOR(res);
1345#endif /* !_NTIGHT_ */
1346                break;
1347
1348                /*--------------------------------------------------------------------------*/
1349            case min_op:                                                /* min_op */
1350                res   = get_locint_r();
1351                arg2  = get_locint_r();
1352                arg1  = get_locint_r();
1353#if !defined(_NTIGHT_)
1354                coval = get_val_r();
1355
1356                ADOLC_GET_TAYLOR(res);
1357#endif /* !_NTIGHT_ */
1358
1359                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1360                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
1361                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1362
1363#if !defined(_NTIGHT_)
1364                if (TARG1 > TARG2)
1365                    FOR_0_LE_l_LT_p
1366                    { aTmp = ARES;
1367#if defined(_INT_REV_)
1368                      ARES_INC = 0;
1369#else
1370                      ARES_INC = 0.0;
1371#endif
1372                      if ((coval) && (aTmp))
1373                      MINDEC(ret_c,2);
1374#if defined(_INT_REV_)
1375                      AARG2_INC |= aTmp;
1376#else
1377                      AARG2_INC += aTmp;
1378#endif
1379                    } else
1380                        if (TARG1 < TARG2)
1381                                FOR_0_LE_l_LT_p
1382                                { aTmp = ARES;
1383#if defined(_INT_REV_)
1384                                  ARES_INC = 0;
1385#else
1386                                  ARES_INC = 0.0;
1387#endif
1388                                  if ((!coval) && (aTmp))
1389                                  MINDEC(ret_c,2);
1390#if defined(_INT_REV_)
1391                                  AARG1_INC |= aTmp;
1392#else
1393                                  AARG1_INC += aTmp;
1394#endif
1395                                } else { /* both are equal */
1396                                    FOR_0_LE_l_LT_p
1397                                    { 
1398#if defined(_INT_REV_)
1399                                      aTmp = ARES;
1400                                      ARES_INC = 0;
1401                                      AARG2_INC |= aTmp;
1402                                      AARG1_INC |= aTmp;
1403#else
1404                                      aTmp = ARES / 2.0;
1405                                      ARES_INC = 0.0;
1406                                      AARG2_INC += aTmp;
1407                                      AARG1_INC += aTmp;
1408#endif
1409                                    }
1410                                    if (arg1 != arg2)
1411                                            MINDEC(ret_c,1);
1412                                    }
1413#else
1414                    FOR_0_LE_l_LT_p
1415                    { aTmp = ARES;
1416                      ARES_INC = 0;
1417                      AARG1_INC |= aTmp;
1418                      AARG2_INC |= aTmp;
1419                    }
1420#endif /* !_NTIGHT_ */
1421                break;
1422
1423                /*--------------------------------------------------------------------------*/
1424            case abs_val:                                              /* abs_val */
1425                res   = get_locint_r();
1426                arg   = get_locint_r();
1427#if !defined(_NTIGHT_)
1428                coval = get_val_r();
1429
1430                ADOLC_GET_TAYLOR(res);
1431#endif /* !_NTIGHT_ */
1432
1433                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1434                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1435
1436#if !defined(_NTIGHT_)
1437                if (TARG < 0.0)
1438                    FOR_0_LE_l_LT_p
1439                    { aTmp = ARES;
1440#if defined(_INT_REV_)
1441                      ARES_INC = 0;
1442#else
1443                      ARES_INC = 0.0;
1444#endif
1445                      if ((coval) && (aTmp))
1446                      MINDEC(ret_c,2);
1447#if defined(_INT_REV_)
1448                      AARG_INC |= aTmp;
1449#else
1450                      AARG_INC -= aTmp;
1451#endif
1452                    } else
1453                        if (TARG > 0.0)
1454                                FOR_0_LE_l_LT_p
1455                                { aTmp = ARES;
1456#if defined(_INT_REV_)
1457                                  ARES_INC = 0;
1458#else
1459                                  ARES_INC = 0.0;
1460#endif
1461                                  if ((!coval) && (aTmp))
1462                                  MINDEC(ret_c,2);
1463#if defined(_INT_REV_)
1464                                  AARG_INC |= aTmp;
1465#else
1466                                  AARG_INC += aTmp;
1467#endif
1468                                } else
1469                                    FOR_0_LE_l_LT_p {
1470                                        aTmp = ARES;
1471#if defined(_INT_REV_)
1472                                        ARES_INC = 0;
1473#else
1474                                        ARES_INC = 0.0;
1475#endif
1476                                        if (aTmp)
1477                                            MINDEC(ret_c,1);
1478                                        }
1479#else
1480                                            FOR_0_LE_l_LT_p
1481                                            { aTmp = ARES;
1482                                              ARES_INC = 0;
1483                                              AARG_INC |= aTmp;
1484                                            }
1485#endif /* !_NTIGHT_ */
1486             break;
1487
1488            /*--------------------------------------------------------------------------*/
1489        case ceil_op:                                              /* ceil_op */
1490               res   = get_locint_r();
1491                arg   = get_locint_r();
1492#if !defined(_NTIGHT_)
1493                coval = get_val_r();
1494
1495                ADOLC_GET_TAYLOR(res);
1496#endif /* !_NTIGHT_ */
1497
1498                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1499
1500#if !defined(_NTIGHT_)
1501                coval = (coval != ceil(TARG) );
1502#endif /* !_NTIGHT_ */
1503
1504                FOR_0_LE_l_LT_p
1505                {
1506#if !defined(_NTIGHT_)
1507                  if ((coval) && (ARES))
1508                  MINDEC(ret_c,2);
1509#endif /* !_NTIGHT_ */
1510#if defined(_INT_REV_)
1511                  ARES_INC = 0;
1512#else
1513                  ARES_INC = 0.0;
1514#endif
1515                }
1516                break;
1517
1518            /*--------------------------------------------------------------------------*/
1519        case floor_op:                                            /* floor_op */
1520                res   = get_locint_r();
1521                arg   = get_locint_r();
1522#if !defined(_NTIGHT_)
1523                coval = get_val_r();
1524
1525                ADOLC_GET_TAYLOR(res);
1526#endif /* !_NTIGHT_ */
1527
1528                ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1529                ASSIGN_A( Aarg, ADJOINT_BUFFER[arg])
1530
1531#if !defined(_NTIGHT_)
1532                coval = ( coval != floor(TARG1) );
1533#endif /* !_NTIGHT_ */
1534
1535                FOR_0_LE_l_LT_p
1536                {
1537#if !defined(_NTIGHT_)
1538                  if ( (coval) && (ARES) )
1539                  MINDEC(ret_c,2);
1540#endif /* !_NTIGHT_ */
1541#if defined(_INT_REV_)
1542                  ARES_INC = 0;
1543#else
1544                  ARES_INC = 0.0;
1545#endif
1546                }
1547                break;
1548
1549
1550            /****************************************************************************/
1551            /*                                                             CONDITIONALS */
1552
1553            /*--------------------------------------------------------------------------*/
1554        case cond_assign:                                      /* cond_assign */
1555            res    = get_locint_r();
1556                arg2   = get_locint_r();
1557                arg1   = get_locint_r();
1558                arg    = get_locint_r();
1559#if !defined(_NTIGHT_)
1560                coval  = get_val_r();
1561
1562                ADOLC_GET_TAYLOR(res);
1563#endif /* !_NTIGHT_ */
1564
1565                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1566                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1567                ASSIGN_A( Aarg2, ADJOINT_BUFFER[arg2])
1568
1569#if !defined(_NTIGHT_)
1570                /* olvo 980924 changed code a little bit */
1571                if (TARG > 0.0) {
1572                    if (res != arg1)
1573                        FOR_0_LE_l_LT_p
1574                        { if ((coval <= 0.0) && (ARES))
1575                          MINDEC(ret_c,2);
1576#if defined(_INT_REV_)
1577                              AARG1_INC |= ARES;
1578                              ARES_INC = 0;
1579#else
1580                          AARG1_INC += ARES;
1581                          ARES_INC = 0.0;
1582#endif
1583                        } else
1584                            FOR_0_LE_l_LT_p
1585                            if ((coval <= 0.0) && (ARES_INC))
1586                                    MINDEC(ret_c,2);
1587                } else {
1588                    if (res != arg2)
1589                        FOR_0_LE_l_LT_p
1590                        { if ((coval <= 0.0) && (ARES))
1591                          MINDEC(ret_c,2);
1592#if defined(_INT_REV_)
1593                          AARG2_INC |= ARES;
1594                          ARES_INC = 0;
1595#else
1596                          AARG2_INC += ARES;
1597                          ARES_INC = 0.0;
1598#endif
1599                        } else
1600                            FOR_0_LE_l_LT_p
1601                            if ((coval <= 0.0) && (ARES_INC))
1602                                    MINDEC(ret_c,2);
1603                }
1604#else
1605                    if (res != arg1) {
1606                        FOR_0_LE_l_LT_p
1607                        AARG1_INC |= ARES_INC;
1608                        ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1609                    }
1610                    if (res != arg2) {
1611                        FOR_0_LE_l_LT_p
1612                        AARG2_INC |= ARES_INC;
1613                        ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1614                    }
1615                    if ((res != arg1) && (res != arg2))
1616                        FOR_0_LE_l_LT_p
1617                        ARES_INC = 0;
1618#endif /* !_NTIGHT_ */
1619                break;
1620
1621                /*--------------------------------------------------------------------------*/
1622            case cond_assign_s:                                  /* cond_assign_s */
1623                res   = get_locint_r();
1624                arg1  = get_locint_r();
1625                arg   = get_locint_r();
1626#if !defined(_NTIGHT_)
1627                coval = get_val_r();
1628
1629                ADOLC_GET_TAYLOR(res);
1630#endif /* !_NTIGHT_ */
1631
1632                ASSIGN_A( Aarg1, ADJOINT_BUFFER[arg1])
1633                ASSIGN_A( Ares,  ADJOINT_BUFFER[res])
1634
1635#if !defined(_NTIGHT_)
1636                /* olvo 980924 changed code a little bit */
1637                if (TARG > 0.0) {
1638                    if (res != arg1)
1639                        FOR_0_LE_l_LT_p
1640                        { if ((coval <= 0.0) && (ARES))
1641                          MINDEC(ret_c,2);
1642#if defined(_INT_REV_)
1643                          AARG1_INC |= ARES;
1644                          ARES_INC = 0.0;
1645#else
1646                          AARG1_INC += ARES;
1647                          ARES_INC = 0.0;
1648#endif
1649                        } else
1650                            FOR_0_LE_l_LT_p
1651                            if ((coval <= 0.0) && (ARES_INC))
1652                                    MINDEC(ret_c,2);
1653                } else
1654                    if (TARG == 0.0) /* we are at the tie */
1655                        FOR_0_LE_l_LT_p
1656                        if (ARES_INC)
1657                            MINDEC(ret_c,0);
1658#else
1659                    if (res != arg1)
1660                        FOR_0_LE_l_LT_p
1661                        { AARG1 |= ARES;
1662                          ARES_INC = 0;
1663                        }
1664#endif /* !_NTIGHT_ */
1665                break;
1666
1667                /****************************************************************************/
1668                /*                                                          REMAINING STUFF */
1669
1670                /*--------------------------------------------------------------------------*/
1671            case take_stock_op:                                  /* take_stock_op */
1672                res  = get_locint_r();
1673                size = get_locint_r();
1674#if !defined(_NTIGHT_)
1675                d    = get_val_v_r(size);
1676#endif /* !_NTIGHT_ */
1677
1678                res += size;
1679                for (ls=size; ls>0; ls--) {
1680                    res--;
1681
1682                    ASSIGN_A( Ares, ADJOINT_BUFFER[res])
1683
1684                    FOR_0_LE_l_LT_p
1685                    ARES_INC = 0.0;
1686                }
1687                break;
1688
1689                /*--------------------------------------------------------------------------*/
1690            case death_not:                                          /* death_not */
1691                arg2 = get_locint_r();
1692                arg1 = get_locint_r();
1693
1694                for (j=arg1;j<=arg2;j++) {
1695                    ASSIGN_A(Aarg1, ADJOINT_BUFFER[j])
1696
1697                    FOR_0_LE_l_LT_p
1698                    AARG1_INC = 0.0;
1699                }
1700
1701#if !defined(_NTIGHT_)
1702                for (j=arg1;j<=arg2;j++)
1703                    ADOLC_GET_TAYLOR(j);
1704#endif /* !_NTIGHT_ */
1705                break;
1706
1707#if !defined(_INT_REV_)
1708                /*--------------------------------------------------------------------------*/
1709            case ext_diff:                       /* extern differntiated function */
1710                ADOLC_CURRENT_TAPE_INFOS.cpIndex = get_locint_r();
1711                ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev = get_locint_r();
1712                ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev = get_locint_r();
1713                m = get_locint_r();
1714                n = get_locint_r();
1715                ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index = get_locint_r();
1716                ADOLC_EXT_FCT_SAVE_NUMDIRS;
1717                edfct = get_ext_diff_fct(ADOLC_CURRENT_TAPE_INFOS.ext_diff_fct_index);
1718
1719                oldTraceFlag = ADOLC_CURRENT_TAPE_INFOS.traceFlag;
1720                ADOLC_CURRENT_TAPE_INFOS.traceFlag = 0;
1721
1722                if (edfct->ADOLC_EXT_FCT_POINTER == NULL)
1723                    fail(ADOLC_EXT_DIFF_NULLPOINTER_FUNCTION);
1724                if (m>0)
1725                    if (ADOLC_EXT_FCT_U == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
1726                if (n>0)
1727                    if (ADOLC_EXT_FCT_Z == NULL) fail(ADOLC_EXT_DIFF_NULLPOINTER_ARGUMENT);
1728
1729                arg = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev;
1730                for (loop = 0; loop < m; ++loop) {
1731                    FOR_0_LE_l_LT_p {
1732                        ADOLC_EXT_FCT_U_L_LOOP = ADJOINT_BUFFER_ARG_L;
1733                    }
1734                    ++arg;
1735                }
1736                for (loop = 0; loop < m; ++loop) {
1737                    --arg;
1738                    ADOLC_GET_TAYLOR(arg);
1739                }
1740                arg = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev;
1741                for (loop = 0; loop < n; ++loop) {
1742                    FOR_0_LE_l_LT_p {
1743                        ADOLC_EXT_FCT_Z_L_LOOP = ADJOINT_BUFFER_ARG_L;
1744                    }
1745                    ++arg;
1746                }
1747                for (loop = 0; loop < n; ++loop) {
1748                    --arg;
1749                    ADOLC_GET_TAYLOR(arg);
1750                }
1751
1752                ext_retc = edfct->ADOLC_EXT_FCT_COMPLETE;
1753                MINDEC(ret_c, ext_retc);
1754
1755                res = ADOLC_CURRENT_TAPE_INFOS.lowestYLoc_rev;
1756                for (loop = 0; loop < m; ++loop) {
1757                    FOR_0_LE_l_LT_p {
1758                        ADJOINT_BUFFER_RES_L = 0.; /* \bar{v}_i = 0 !!! */
1759                    }
1760                    ++res;
1761                }
1762                res = ADOLC_CURRENT_TAPE_INFOS.lowestXLoc_rev;
1763                for (loop = 0; loop < n; ++loop) {
1764                    FOR_0_LE_l_LT_p {
1765                        ADJOINT_BUFFER_RES_L = ADOLC_EXT_FCT_Z_L_LOOP;
1766                    }
1767                    ++res;
1768                }
1769
1770                ADOLC_CURRENT_TAPE_INFOS.traceFlag = oldTraceFlag;
1771
1772                break;
1773#endif /* !_INT_REV_ */
1774                /*--------------------------------------------------------------------------*/
1775            default:                                                   /* default */
1776                /*             Die here, we screwed up     */
1777
1778                fprintf(DIAG_OUT,"ADOL-C fatal error in " GENERATED_FILENAME " ("
1779                        __FILE__
1780                        ") : no such operation %d\n", operation);
1781                exit(-1);
1782                break;
1783        } /* endswitch */
1784
1785        /* Get the next operation */
1786        operation=get_op_r();
1787    } /* endwhile */
1788
1789    /* clean up */
1790#if !defined(_INT_REV_)
1791    free(rp_T);
1792#endif
1793#ifdef _FOS_
1794    free(rp_A);
1795#endif
1796#ifdef _FOV_
1797    myfree2(rpp_A);
1798#endif
1799#ifdef _INT_REV_
1800    free(upp_A);
1801#endif
1802
1803    end_sweep();
1804
1805    return ret_c;
1806}
1807
1808
1809/****************************************************************************/
1810/*                                                               THAT'S ALL */
1811
1812END_C_DECLS
Note: See TracBrowser for help on using the repository browser.