source: trunk/ADOL-C/src/adouble.cpp @ 748

Last change on this file since 748 was 748, checked in by kulshres, 17 months ago

Merge branch 'activity' of 'gitclone' into 'svn'

The following commits were merged:
commit fc84dcabde90416ff32e8b08a06b7dad775e06bf
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Aug 4 10:36:17 2017 +0200

more debugging activity analysis

sign of coval is important in all cases, so I can't change it only
in one case.

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

commit b5f80a477d085d84c67ee71e2cf84ce6d926b858
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Aug 3 18:24:40 2017 +0200

correct some sign changes

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

commit e8642818244e33f0a4204fdffa936cc7195fc5bc
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Thu Aug 3 14:57:46 2017 +0200

add activity tracking to parameters

parameters are always active since they can be changed after tracing
is complete using set_param_vec, just like independent variables.

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

commit ae9f196ebbf225cd9a5e62e26266c2cbbbc8a5b2
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Wed Aug 2 17:58:15 2017 +0200

add activity tracking to conditional assignments

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

commit c4b610de2500e949271d3bf60f04b5d34a229807
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Jul 31 13:50:05 2017 +0200

simplify some operations during activity tracking

especially assignment from adub. make that equivalent to construction
from adub, by stealing rhs location. The problem with not stealing that
location would be to restore rhs previous activity before rhs was created
so that we can replace lhs into the previous operation. Since we don't have
a way of recreating activities from before, it's better to steal the
location of rhs and free the lhs location for reuse later.

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

commit 8e2ad08100254ee4309209d6c807928d6cab94ee
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Jul 28 14:06:30 2017 +0200

add activity checking code in the operators and functions for adouble

conditional assignments do not track activity at the moment. Next step
is to make the parameters active too.

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

commit b8b6411ba29892d10d36bfe7a4d2abcbeb59ff67
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Jul 28 13:59:36 2017 +0200

add a buffer in globalTapeVars to track activity of live variables

it is managed by the StoreManager? class for allocation and deallocation

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

commit 569a7f28227991f8029e89b989c6f04415e8bd1a
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Fri Jul 28 13:58:32 2017 +0200

Add option to enable activity tracking in adouble class

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

  • Property svn:keywords set to Author Date Id Revision
File size: 128.0 KB
Line 
1/*----------------------------------------------------------------------------
2 ADOL-C -- Automatic Differentiation by Overloading in C++
3 File:     adouble.cpp
4 Revision: $Id: adouble.cpp 748 2018-02-28 12:16:05Z kulshres $
5 Contents: adouble.C contains that definitions of procedures used to
6           define various badouble, adub, and adouble operations.
7           These operations actually have two purposes.
8           The first purpose is to actual compute the function, just as
9           the same code written for double precision (single precision -
10           complex - interval) arithmetic would.  The second purpose is
11           to write a transcript of the computation for the reverse pass
12           of automatic differentiation.
13 
14 Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
15               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel,
16               Kshitij Kulshreshtha
17 
18 This file is part of ADOL-C. This software is provided as open source.
19 Any use, reproduction, or distribution of the software constitutes
20 recipient's acceptance of the terms of the accompanying license file.
21   
22----------------------------------------------------------------------------*/
23
24#include "taping_p.h"
25#include <adolc/adouble.h>
26#include "oplate.h"
27#include "dvlparms.h"
28
29using namespace std;
30
31/****************************************************************************/
32/*                                                        HELPFUL FUNCTIONS */
33
34/*--------------------------------------------------------------------------*/
35void condassign( double &res, const double &cond,
36                 const double &arg1, const double &arg2 ) {
37    res = cond > 0 ? arg1 : arg2;
38}
39
40/*--------------------------------------------------------------------------*/
41void condassign( double &res, const double &cond,
42                 const double &arg) {
43    res = cond > 0 ? arg : res;
44}
45
46/*--------------------------------------------------------------------------*/
47void condeqassign( double &res, const double &cond,
48                   const double &arg1, const double &arg2 ) {
49    res = cond >= 0 ? arg1 : arg2;
50}
51
52/*--------------------------------------------------------------------------*/
53void condeqassign( double &res, const double &cond,
54                   const double &arg) {
55    res = cond >= 0 ? arg : res;
56}
57/*--------------------------------------------------------------------------*/
58/* The remaining routines define the badouble, adub and adouble routines.   */
59/*--------------------------------------------------------------------------*/
60
61/****************************************************************************/
62/*                                                             CONSTRUCTORS */
63
64/*--------------------------------------------------------------------------*/
65#if defined(ADOLC_ADOUBLE_LATEINIT)
66void adouble::initInternal(void) {
67  if (isInit)
68    return;
69  location = next_loc();
70  ADOLC_OPENMP_THREAD_NUMBER;
71  ADOLC_OPENMP_GET_THREAD_NUMBER;
72
73#if defined(ADOLC_ADOUBLE_STDCZERO)
74    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
75#if defined(ADOLC_TRACK_ACTIVITY)
76      if (ADOLC_GLOBAL_TAPE_VARS.actStore[location]) {
77#endif
78        put_op(assign_d_zero);
79        ADOLC_PUT_LOCINT(location);   // = res
80
81        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
82        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
83            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
84#if defined(ADOLC_TRACK_ACTIVITY)
85      }
86#endif
87  }
88
89  ADOLC_GLOBAL_TAPE_VARS.store[location] = 0.;
90#if defined(ADOLC_TRACK_ACTIVITY)
91  ADOLC_GLOBAL_TAPE_VARS.actStore[location] = false;
92#endif
93#endif
94  isInit = true;
95}
96#else
97void adouble::initInternal(void) {}
98#endif
99
100/*--------------------------------------------------------------------------*/
101adouble::adouble() {
102    location = next_loc();
103    isInit = true;
104    ADOLC_OPENMP_THREAD_NUMBER;
105    ADOLC_OPENMP_GET_THREAD_NUMBER;
106
107#if defined(ADOLC_ADOUBLE_STDCZERO)
108    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
109#if defined(ADOLC_TRACK_ACTIVITY)
110      if (ADOLC_GLOBAL_TAPE_VARS.actStore[location]) {
111#endif
112        put_op(assign_d_zero);
113        ADOLC_PUT_LOCINT(location);   // = res
114
115        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
116        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
117            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
118#if defined(ADOLC_TRACK_ACTIVITY)
119      }
120#endif
121    }
122   
123    ADOLC_GLOBAL_TAPE_VARS.store[location] = 0.;
124#if defined(ADOLC_TRACK_ACTIVITY)
125    ADOLC_GLOBAL_TAPE_VARS.actStore[location] = false;
126#endif
127#endif
128}
129
130/*--------------------------------------------------------------------------*/
131adouble::adouble( double coval ) {
132    location = next_loc();
133    isInit = true;
134    ADOLC_OPENMP_THREAD_NUMBER;
135    ADOLC_OPENMP_GET_THREAD_NUMBER;
136
137    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { 
138#if defined(ADOLC_TRACK_ACTIVITY)
139      if (ADOLC_GLOBAL_TAPE_VARS.actStore[location]) {
140#endif
141        if (coval == 0) {
142            put_op(assign_d_zero);
143            ADOLC_PUT_LOCINT(location);   // = res
144        } else
145            if (coval == 1.0) {
146                put_op(assign_d_one);
147                ADOLC_PUT_LOCINT(location); // = res
148            } else {
149                put_op(assign_d);
150                ADOLC_PUT_LOCINT(location); // = res
151                ADOLC_PUT_VAL(coval);       // = coval
152            }
153
154        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
155        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
156            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
157#if defined(ADOLC_TRACK_ACTIVITY)
158      }
159#endif
160    }
161
162    ADOLC_GLOBAL_TAPE_VARS.store[location] = coval;
163#if defined(ADOLC_TRACK_ACTIVITY)
164    ADOLC_GLOBAL_TAPE_VARS.actStore[location] = false;
165#endif
166}
167
168/*--------------------------------------------------------------------------*/
169adouble::adouble( const adouble& a ) {
170    location = next_loc();
171    isInit = true;
172    ADOLC_OPENMP_THREAD_NUMBER;
173    ADOLC_OPENMP_GET_THREAD_NUMBER;
174
175
176    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { 
177#if defined(ADOLC_TRACK_ACTIVITY)
178     if (ADOLC_GLOBAL_TAPE_VARS.actStore[a.location]) {
179#endif
180        put_op(assign_a);
181        ADOLC_PUT_LOCINT(a.location);   // = arg
182        ADOLC_PUT_LOCINT(location);     // = res
183
184       ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
185       if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
186           ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
187
188#if defined(ADOLC_TRACK_ACTIVITY)
189     } else {
190         if (ADOLC_GLOBAL_TAPE_VARS.actStore[location]) {
191             double coval = ADOLC_GLOBAL_TAPE_VARS.store[a.location];
192             if (coval == 0) {
193                 put_op(assign_d_zero);
194                 ADOLC_PUT_LOCINT(location);   // = res
195             } else if (coval == 1.0) {
196                 put_op(assign_d_one);
197                 ADOLC_PUT_LOCINT(location); // = res
198             } else {
199                 put_op(assign_d);
200                 ADOLC_PUT_LOCINT(location); // = res
201                 ADOLC_PUT_VAL(coval);       // = coval
202             }
203
204             ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
205             if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
206                 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
207
208         }
209     }
210#endif
211    }
212
213    ADOLC_GLOBAL_TAPE_VARS.store[location] = ADOLC_GLOBAL_TAPE_VARS.store[a.location];
214#if defined(ADOLC_TRACK_ACTIVITY)
215    ADOLC_GLOBAL_TAPE_VARS.actStore[location] = ADOLC_GLOBAL_TAPE_VARS.actStore[a.location];
216#endif
217}
218
219/*--------------------------------------------------------------------------*/
220adouble::adouble( const adub& a ) {
221    location = next_loc();
222    isInit = true;
223    locint a_loc = a.loc();
224    ADOLC_OPENMP_THREAD_NUMBER;
225    ADOLC_OPENMP_GET_THREAD_NUMBER;
226    int upd = 0;
227    /* 981020 olvo  skip upd_resloc(..) if no tracing performed */
228    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag)
229        upd = upd_resloc_check(a_loc,loc());
230    if (upd) { /* olvo 980708 new n2l & 980921 changed interface */
231        free_loc(location);
232        location = a_loc;
233        const_cast<adub&>(a).isInit = false;
234    } else {
235        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(loc(),a_loc);
236#if defined(ADOLC_TRACK_ACTIVITY)
237          if (ADOLC_GLOBAL_TAPE_VARS.actStore[a_loc]) {
238#endif
239            put_op(assign_a);
240            ADOLC_PUT_LOCINT(a_loc);    // = arg
241            ADOLC_PUT_LOCINT(loc()); // = res
242
243            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
244            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
245                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
246#if defined(ADOLC_TRACK_ACTIVITY)
247          } else {
248            if (ADOLC_GLOBAL_TAPE_VARS.actStore[location]) {
249              double coval = ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
250              if (coval == 0) {
251                 put_op(assign_d_zero);
252                 ADOLC_PUT_LOCINT(location);   // = res
253              } else if (coval == 1.0) {
254                 put_op(assign_d_one);
255                 ADOLC_PUT_LOCINT(location); // = res
256              } else {
257                 put_op(assign_d);
258                 ADOLC_PUT_LOCINT(location); // = res
259                 ADOLC_PUT_VAL(coval);       // = coval
260              }
261
262              ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
263              if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
264                  ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
265            }
266          }
267#endif
268        }
269        ADOLC_GLOBAL_TAPE_VARS.store[loc()] = ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
270#if defined(ADOLC_TRACK_ACTIVITY)
271        ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[a_loc];
272#endif
273    }
274}
275
276/****************************************************************************/
277/*                                                              DESTRUCTORS */
278
279/*--------------------------------------------------------------------------*/
280adouble::~adouble() {
281#ifdef adolc_overwrite
282    if (isInit) {
283        free_loc(location);
284    }
285#endif
286}
287
288/*--------------------------------------------------------------------------*/
289adub::~adub() {
290#ifdef adolc_overwrite
291    if (isInit) {
292        free_loc(location);
293    }
294#endif
295}
296
297
298/****************************************************************************/
299/*                                                                  HELPERS */
300
301adub* adubp_from_adub(const adub& a) {
302    locint locat = a.loc();
303    const_cast<adub&>(a).isInit = false;
304    adub *retp = new adub(locat);
305    return retp;
306}
307
308
309/****************************************************************************/
310/*                                                                   VALUE */
311
312/*--------------------------------------------------------------------------*/
313double badouble::getValue() const {
314    ADOLC_OPENMP_THREAD_NUMBER;
315    ADOLC_OPENMP_GET_THREAD_NUMBER;
316    return ADOLC_GLOBAL_TAPE_VARS.store[loc()];
317}
318
319badouble::operator double const&() const {
320    ADOLC_OPENMP_THREAD_NUMBER;
321    ADOLC_OPENMP_GET_THREAD_NUMBER;
322    return ADOLC_GLOBAL_TAPE_VARS.store[loc()];
323}
324
325badouble::operator double&&() {
326    ADOLC_OPENMP_THREAD_NUMBER;
327    ADOLC_OPENMP_GET_THREAD_NUMBER;
328    return (double&&)ADOLC_GLOBAL_TAPE_VARS.store[loc()];
329}
330
331badouble::operator double() {
332    ADOLC_OPENMP_THREAD_NUMBER;
333    ADOLC_OPENMP_GET_THREAD_NUMBER;
334    return ADOLC_GLOBAL_TAPE_VARS.store[loc()];
335}
336
337void badouble::setValue( const double x ) {
338    ADOLC_OPENMP_THREAD_NUMBER;
339    ADOLC_OPENMP_GET_THREAD_NUMBER;
340    ADOLC_GLOBAL_TAPE_VARS.store[loc()]=x;
341}
342
343/****************************************************************************/
344/*                                                              ASSIGNMENTS */
345
346/*--------------------------------------------------------------------------*/
347/* Assign an adouble variable a constant value. */
348badouble& badouble::operator = ( double coval ) {
349    ADOLC_OPENMP_THREAD_NUMBER;
350    ADOLC_OPENMP_GET_THREAD_NUMBER;
351    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
352#if defined(ADOLC_TRACK_ACTIVITY)
353      if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
354#endif
355        if (coval == 0) {
356            put_op(assign_d_zero);
357            ADOLC_PUT_LOCINT(loc());   // = res
358        } else
359            if (coval == 1.0) {
360                put_op(assign_d_one);
361                ADOLC_PUT_LOCINT(loc()); // = res
362            } else {
363                put_op(assign_d);
364                ADOLC_PUT_LOCINT(loc()); // = res
365                ADOLC_PUT_VAL(coval);       // = coval
366            }
367
368        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
369        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
370            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
371#if defined(ADOLC_TRACK_ACTIVITY)
372      }
373#endif
374    }
375
376    ADOLC_GLOBAL_TAPE_VARS.store[loc()] = coval;
377#if defined(ADOLC_TRACK_ACTIVITY)
378    ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] = false;
379#endif
380   return *this;
381}
382
383/*--------------------------------------------------------------------------*/
384/* Assign an adouble variable a constant value. */
385adouble& adouble::operator = ( double coval ) {
386    this->loc();  // call for late init
387    (*this).badouble::operator=(coval);
388    return (*this);
389}
390
391/*--------------------------------------------------------------------------*/
392/* Assign an adouble variable to an independent value. */
393badouble& badouble::operator <<= ( double coval ) {
394    ADOLC_OPENMP_THREAD_NUMBER;
395    ADOLC_OPENMP_GET_THREAD_NUMBER;
396    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { 
397        ADOLC_CURRENT_TAPE_INFOS.numInds++;
398
399        put_op(assign_ind);
400        ADOLC_PUT_LOCINT(loc()); // = res
401
402        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
403        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
404            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
405    }
406
407    ADOLC_GLOBAL_TAPE_VARS.store[loc()] = coval;
408#if defined(ADOLC_TRACK_ACTIVITY)
409    ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] = true;
410#endif
411    return *this;
412}
413
414void badouble::declareIndependent() {
415    ADOLC_OPENMP_THREAD_NUMBER;
416    ADOLC_OPENMP_GET_THREAD_NUMBER;
417
418    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
419        ADOLC_CURRENT_TAPE_INFOS.numInds++;
420
421        put_op(assign_ind);
422        ADOLC_PUT_LOCINT(loc()); // = res
423
424        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
425        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
426            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
427    }
428#if defined(ADOLC_TRACK_ACTIVITY)
429    ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] = true;
430#endif
431}
432
433/*--------------------------------------------------------------------------*/
434/* Assign a float variable from a dependent adouble value. */
435badouble& badouble::operator >>= ( double& coval ) {
436    ADOLC_OPENMP_THREAD_NUMBER;
437    ADOLC_OPENMP_GET_THREAD_NUMBER;
438#if defined(ADOLC_TRACK_ACTIVITY)
439    if ( ! ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
440        fprintf(DIAG_OUT, "ADOL-C warning: marking an inactive variable (constant) as dependent.\n");
441        locint tmploc = loc();
442        double temp = ADOLC_GLOBAL_TAPE_VARS.store[loc()];
443        if (temp == 0.0) {
444            put_op(assign_d_zero);
445            ADOLC_PUT_LOCINT(tmploc);
446        } else if (temp == 1.0) {
447            put_op(assign_d_one);
448            ADOLC_PUT_LOCINT(tmploc);
449        } else {
450            put_op(assign_d);
451            ADOLC_PUT_LOCINT(tmploc);
452            ADOLC_PUT_VAL(temp);
453        }
454
455        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
456        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
457            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
458    }
459#endif
460    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { 
461        ADOLC_CURRENT_TAPE_INFOS.numDeps++;
462
463        put_op(assign_dep);
464        ADOLC_PUT_LOCINT(loc()); // = res
465    }
466
467    coval = double (ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
468    return *this;
469}
470
471void badouble::declareDependent() {
472    ADOLC_OPENMP_THREAD_NUMBER;
473    ADOLC_OPENMP_GET_THREAD_NUMBER;
474#if defined(ADOLC_TRACK_ACTIVITY)
475    if ( ! ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
476        fprintf(DIAG_OUT, "ADOL-C warning: marking an inactive variable (constant) as dependent.\n");
477        locint tmploc = loc();
478        double temp = ADOLC_GLOBAL_TAPE_VARS.store[loc()];
479        if (temp == 0.0) {
480            put_op(assign_d_zero);
481            ADOLC_PUT_LOCINT(tmploc);
482        } else if (temp == 1.0) {
483            put_op(assign_d_one);
484            ADOLC_PUT_LOCINT(tmploc);
485        } else {
486            put_op(assign_d);
487            ADOLC_PUT_LOCINT(tmploc);
488            ADOLC_PUT_VAL(temp);
489        }
490
491        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
492        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
493            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
494    }
495#endif
496    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
497        ADOLC_CURRENT_TAPE_INFOS.numDeps++;
498
499        put_op(assign_dep);
500        ADOLC_PUT_LOCINT(loc()); // = res
501    }
502}
503
504/*--------------------------------------------------------------------------*/
505/* Assign an Badouble variable an Badouble value. */
506badouble& badouble::operator = ( const badouble& x ) {
507    ADOLC_OPENMP_THREAD_NUMBER;
508    ADOLC_OPENMP_GET_THREAD_NUMBER;
509    locint x_loc = x.loc();
510    if (loc()!=x_loc)
511        /* test this to avoid for x=x statements adjoint(x)=0 in reverse mode */
512    { if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old:  write_assign_a(loc(),x.loc());
513#if defined(ADOLC_TRACK_ACTIVITY)
514          if (ADOLC_GLOBAL_TAPE_VARS.actStore[x_loc]) {
515#endif
516            put_op(assign_a);
517            ADOLC_PUT_LOCINT(x_loc);    // = arg
518            ADOLC_PUT_LOCINT(loc());   // = res
519
520            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
521            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
522                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
523#if defined(ADOLC_TRACK_ACTIVITY)
524          } else {
525            if (ADOLC_GLOBAL_TAPE_VARS.actStore[location]) {
526              double coval = ADOLC_GLOBAL_TAPE_VARS.store[x_loc];
527              if (coval == 0) {
528                 put_op(assign_d_zero);
529                 ADOLC_PUT_LOCINT(location);   // = res
530              } else if (coval == 1.0) {
531                 put_op(assign_d_one);
532                 ADOLC_PUT_LOCINT(location); // = res
533              } else {
534                 put_op(assign_d);
535                 ADOLC_PUT_LOCINT(location); // = res
536                 ADOLC_PUT_VAL(coval);       // = coval
537              }
538
539              ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
540              if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
541                  ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
542            }
543          }
544#endif
545        }
546
547        ADOLC_GLOBAL_TAPE_VARS.store[loc()]=ADOLC_GLOBAL_TAPE_VARS.store[x_loc];
548#if defined(ADOLC_TRACK_ACTIVITY)
549        ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[x_loc];
550#endif
551    }
552    return *this;
553}
554
555/*--------------------------------------------------------------------------*/
556/* Assign an Badouble variable an Badouble value. */
557adouble& adouble::operator = ( const badouble& x ) {
558    this->loc();  // call for late init
559    (*this).badouble::operator=(x);
560    return (*this);
561}
562
563/*--------------------------------------------------------------------------*/
564/* Assign an adouble variable an adouble value. */
565adouble& adouble::operator = ( const adouble& x ) {
566    this->loc();  // call for late init
567    x.loc(); // cal for late init
568    (*this).badouble::operator=(x);
569    return (*this);
570}
571/*--------------------------------------------------------------------------*/
572/* Assign an adouble an adub */
573/* olvo 980517 new version griewank */
574badouble& badouble::operator = ( const adub& a ) {
575    locint a_loc = a.loc();
576    ADOLC_OPENMP_THREAD_NUMBER;
577    ADOLC_OPENMP_GET_THREAD_NUMBER;
578    int upd = 0;
579    /* 981020 olvo  skip upd_resloc(..) if no tracing performed */
580    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag)
581#if defined(ADOLC_TRACK_ACTIVITY)
582        upd = upd_resloc_check(a_loc,loc());
583#else
584        upd = upd_resloc(a_loc,loc());
585#endif
586    if (upd) { /* olvo 980708 new n2l & 980921 changed interface */
587#if defined(ADOLC_TRACK_ACTIVITY)
588        free_loc(location);
589        location = a_loc;
590        const_cast<adub&>(a).isInit = false;
591#else
592        revreal tempVal = ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
593        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
594            ADOLC_OVERWRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()],&ADOLC_GLOBAL_TAPE_VARS.store[a_loc]);
595        ADOLC_GLOBAL_TAPE_VARS.store[loc()] = tempVal;
596#endif
597    } else {
598        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(loc(),a_loc);
599#if defined(ADOLC_TRACK_ACTIVITY)
600          if (ADOLC_GLOBAL_TAPE_VARS.actStore[a_loc]) {
601#endif
602            put_op(assign_a);
603            ADOLC_PUT_LOCINT(a_loc);    // = arg
604            ADOLC_PUT_LOCINT(loc()); // = res
605
606            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
607            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
608                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
609#if defined(ADOLC_TRACK_ACTIVITY)
610          } else {
611            if (ADOLC_GLOBAL_TAPE_VARS.actStore[location]) {
612              double coval = ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
613              if (coval == 0) {
614                 put_op(assign_d_zero);
615                 ADOLC_PUT_LOCINT(location);   // = res
616              } else if (coval == 1.0) {
617                 put_op(assign_d_one);
618                 ADOLC_PUT_LOCINT(location); // = res
619              } else {
620                 put_op(assign_d);
621                 ADOLC_PUT_LOCINT(location); // = res
622                 ADOLC_PUT_VAL(coval);       // = coval
623              }
624
625              ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
626              if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
627                  ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
628            }
629          }
630#endif
631        }
632        ADOLC_GLOBAL_TAPE_VARS.store[loc()] = ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
633#if defined(ADOLC_TRACK_ACTIVITY)
634        ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[a_loc];
635#endif
636    }
637
638    return *this;
639}
640
641/*--------------------------------------------------------------------------*/
642/* Assign an adouble an adub */
643/* olvo 980517 new version griewank */
644adouble& adouble::operator = ( const adub& a ) {
645    this->loc();  // call for late init
646    (*this).badouble::operator=(a);
647    return (*this);
648}
649
650
651/****************************************************************************/
652/*                                                           INPUT / OUTPUT */
653
654/*--------------------------------------------------------------------------*/
655/* Output an adouble value !!! No tracing of this action */
656std::ostream& operator << ( std::ostream& out, const badouble& y ) {
657    ADOLC_OPENMP_THREAD_NUMBER;
658    ADOLC_OPENMP_GET_THREAD_NUMBER;
659    return out << ADOLC_GLOBAL_TAPE_VARS.store[y.loc()] << "(a)" ;
660}
661
662/*--------------------------------------------------------------------------*/
663/* Input adouble value */
664std::istream& operator >> ( std::istream& in, const badouble& y ) {
665    double coval;
666    ADOLC_OPENMP_THREAD_NUMBER;
667    ADOLC_OPENMP_GET_THREAD_NUMBER;
668    in >> coval;
669    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_d(y.loc(),coval);
670#if defined(ADOLC_TRACK_ACTIVITY)
671      if (ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
672#endif
673        if (coval == 0) {
674            put_op(assign_d_zero);
675            ADOLC_PUT_LOCINT(y.loc());   // = res
676        } else
677            if (coval == 1.0) {
678                put_op(assign_d_one);
679                ADOLC_PUT_LOCINT(y.loc()); // = res
680            } else {
681                put_op(assign_d);
682                ADOLC_PUT_LOCINT(y.loc());   // = res
683                ADOLC_PUT_VAL(coval);         // = coval
684            }
685
686        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
687        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
688            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.loc()]);
689#if defined(ADOLC_TRACK_ACTIVITY)
690      }
691#endif
692    }
693
694    ADOLC_GLOBAL_TAPE_VARS.store[y.loc()] = coval;
695#if defined(ADOLC_TRACK_ACTIVITY)
696    ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()] = false;
697#endif
698    return in;
699}
700
701/****************************************************************************/
702/*                                                    INCREMENT / DECREMENT */
703
704/*--------------------------------------------------------------------------*/
705/* Postfix increment */
706adub adouble::operator++( int ) {
707    locint locat = next_loc();
708    ADOLC_OPENMP_THREAD_NUMBER;
709    ADOLC_OPENMP_GET_THREAD_NUMBER;
710
711    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(locat,loc());
712#if defined(ADOLC_TRACK_ACTIVITY)
713      if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
714#endif
715        put_op(assign_a);
716        ADOLC_PUT_LOCINT(loc()); // = arg
717        ADOLC_PUT_LOCINT(locat);    // = res
718
719        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
720        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
721            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
722#if defined(ADOLC_TRACK_ACTIVITY)
723      } else {
724         if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
725             double coval = ADOLC_GLOBAL_TAPE_VARS.store[loc()];
726             if (coval == 0) {
727                 put_op(assign_d_zero);
728                 ADOLC_PUT_LOCINT(locat);   // = res
729             } else if (coval == 1.0) {
730                 put_op(assign_d_one);
731                 ADOLC_PUT_LOCINT(locat); // = res
732             } else {
733                 put_op(assign_d);
734                 ADOLC_PUT_LOCINT(locat); // = res
735                 ADOLC_PUT_VAL(coval);       // = coval
736             }
737
738             ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
739             if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
740                 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
741         }
742      }
743#endif
744    }
745
746    ADOLC_GLOBAL_TAPE_VARS.store[locat]=ADOLC_GLOBAL_TAPE_VARS.store[loc()];
747#if defined(ADOLC_TRACK_ACTIVITY)
748    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[loc()];
749#endif
750
751    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_incr_decr_a(incr_a,loc());
752#if defined(ADOLC_TRACK_ACTIVITY)
753      if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
754#endif
755        put_op(incr_a);
756        ADOLC_PUT_LOCINT(loc()); // = res
757
758        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
759        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
760            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
761#if defined(ADOLC_TRACK_ACTIVITY)
762      }
763#endif
764    }
765
766    ADOLC_GLOBAL_TAPE_VARS.store[loc()]++;
767    return locat;
768}
769
770/*--------------------------------------------------------------------------*/
771/* Postfix decrement */
772adub adouble::operator--( int ) {
773    locint locat = next_loc();
774    ADOLC_OPENMP_THREAD_NUMBER;
775    ADOLC_OPENMP_GET_THREAD_NUMBER;
776
777    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(locat,loc());
778#if defined(ADOLC_TRACK_ACTIVITY)
779      if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
780#endif
781        put_op(assign_a);
782        ADOLC_PUT_LOCINT(loc()); // = arg
783        ADOLC_PUT_LOCINT(locat);    // = res
784
785        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
786        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
787            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
788#if defined(ADOLC_TRACK_ACTIVITY)
789      } else {
790         if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
791             double coval = ADOLC_GLOBAL_TAPE_VARS.store[loc()];
792             if (coval == 0) {
793                 put_op(assign_d_zero);
794                 ADOLC_PUT_LOCINT(locat);   // = res
795             } else if (coval == 1.0) {
796                 put_op(assign_d_one);
797                 ADOLC_PUT_LOCINT(locat); // = res
798             } else {
799                 put_op(assign_d);
800                 ADOLC_PUT_LOCINT(locat); // = res
801                 ADOLC_PUT_VAL(coval);       // = coval
802             }
803
804             ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
805             if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
806                 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
807         }
808      }
809#endif
810    }
811
812    ADOLC_GLOBAL_TAPE_VARS.store[locat]=ADOLC_GLOBAL_TAPE_VARS.store[loc()];
813#if defined(ADOLC_TRACK_ACTIVITY)
814    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[loc()];
815#endif
816    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_incr_decr_a(decr_a,loc());
817#if defined(ADOLC_TRACK_ACTIVITY)
818      if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
819#endif
820        put_op(decr_a);
821        ADOLC_PUT_LOCINT(loc()); // = res
822
823        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
824        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
825            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
826#if defined(ADOLC_TRACK_ACTIVITY)
827      }
828#endif
829    }
830
831    ADOLC_GLOBAL_TAPE_VARS.store[loc()]--;
832    return locat;
833}
834
835/*--------------------------------------------------------------------------*/
836/* Prefix increment */
837badouble& adouble::operator++() {
838    ADOLC_OPENMP_THREAD_NUMBER;
839    ADOLC_OPENMP_GET_THREAD_NUMBER;
840    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_incr_decr_a(incr_a,loc());
841#if defined(ADOLC_TRACK_ACTIVITY)
842      if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
843#endif
844        put_op(incr_a);
845        ADOLC_PUT_LOCINT(loc()); // = res
846
847        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
848        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
849            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
850#if defined(ADOLC_TRACK_ACTIVITY)
851      }
852#endif
853    }
854
855    ADOLC_GLOBAL_TAPE_VARS.store[loc()]++;
856    return *this;
857}
858
859/*--------------------------------------------------------------------------*/
860/* Prefix decrement */
861badouble& adouble::operator--() {
862    ADOLC_OPENMP_THREAD_NUMBER;
863    ADOLC_OPENMP_GET_THREAD_NUMBER;
864    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_incr_decr_a(decr_a,loc());
865#if defined(ADOLC_TRACK_ACTIVITY)
866      if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
867#endif
868        put_op(decr_a);
869        ADOLC_PUT_LOCINT(loc()); // = res
870
871        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
872        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
873            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
874#if defined(ADOLC_TRACK_ACTIVITY)
875      }
876#endif
877    }
878
879    ADOLC_GLOBAL_TAPE_VARS.store[loc()]--;
880    return *this;
881}
882
883/****************************************************************************/
884/*                                                   OPERATION + ASSIGNMENT */
885
886/*--------------------------------------------------------------------------*/
887/* Adding a floating point to an adouble */
888badouble& badouble::operator += ( double coval ) {
889    ADOLC_OPENMP_THREAD_NUMBER;
890    ADOLC_OPENMP_GET_THREAD_NUMBER;
891    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_plus_d,loc(),coval);
892#if defined(ADOLC_TRACK_ACTIVITY)
893      if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
894#endif
895        put_op(eq_plus_d);
896        ADOLC_PUT_LOCINT(loc()); // = res
897        ADOLC_PUT_VAL(coval);       // = coval
898
899        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
900        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
901            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
902#if defined(ADOLC_TRACK_ACTIVITY)
903      }
904#endif
905    }
906
907    ADOLC_GLOBAL_TAPE_VARS.store[loc()] += coval;
908    return *this;
909}
910
911
912/*--------------------------------------------------------------------------*/
913/* Subtracting a floating point from an adouble */
914badouble& badouble::operator -= ( double coval ) {
915    ADOLC_OPENMP_THREAD_NUMBER;
916    ADOLC_OPENMP_GET_THREAD_NUMBER;
917    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_min_d,loc(),coval);
918#if defined(ADOLC_TRACK_ACTIVITY)
919      if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
920#endif
921        put_op(eq_min_d);
922        ADOLC_PUT_LOCINT(loc()); // = res
923        ADOLC_PUT_VAL(coval);       // = coval
924
925        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
926        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
927            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
928#if defined(ADOLC_TRACK_ACTIVITY)
929      }
930#endif
931    }
932
933    ADOLC_GLOBAL_TAPE_VARS.store[loc()] -= coval;
934    return *this;
935}
936
937/*--------------------------------------------------------------------------*/
938/* Add an adouble to another adouble */
939badouble& badouble::operator += ( const badouble& y ) {
940    ADOLC_OPENMP_THREAD_NUMBER;
941    ADOLC_OPENMP_GET_THREAD_NUMBER;
942    locint y_loc = y.loc();
943    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_a_same_arg(eq_plus_a,loc(),y.loc());
944#if defined(ADOLC_TRACK_ACTIVITY)
945      if (ADOLC_GLOBAL_TAPE_VARS.actStore[y_loc] && ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
946#endif
947        put_op(eq_plus_a);
948        ADOLC_PUT_LOCINT(y_loc); // = arg
949        ADOLC_PUT_LOCINT(loc());   // = res
950
951        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
952        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
953            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
954#if defined(ADOLC_TRACK_ACTIVITY)
955      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[y_loc]) {
956          double coval = ADOLC_GLOBAL_TAPE_VARS.store[loc()];
957          if (coval) {
958              put_op(plus_d_a);
959              ADOLC_PUT_LOCINT(y_loc); // = arg
960              ADOLC_PUT_LOCINT(loc()); // = res
961              ADOLC_PUT_VAL(coval);
962          } else {
963              put_op(assign_a);
964              ADOLC_PUT_LOCINT(y_loc); // = arg
965              ADOLC_PUT_LOCINT(loc());      // = res
966          }
967
968          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
969          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
970              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
971
972      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
973          double coval = ADOLC_GLOBAL_TAPE_VARS.store[y_loc];
974          if (coval) {
975              put_op(eq_plus_d);
976              ADOLC_PUT_LOCINT(loc()); // = res
977              ADOLC_PUT_VAL(coval);       // = coval
978
979              ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
980              if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
981                  ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
982          }
983      }
984#endif
985    }
986
987    ADOLC_GLOBAL_TAPE_VARS.store[loc()] += ADOLC_GLOBAL_TAPE_VARS.store[y_loc];
988#if defined(ADOLC_TRACK_ACTIVITY)
989    ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] = (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] || ADOLC_GLOBAL_TAPE_VARS.actStore[y_loc]);
990#endif
991    return *this;
992}
993
994/*--------------------------------------------------------------------------*/
995/* olvo 991122 new version for y += x1 * x2; */
996badouble& badouble::operator += ( const adub& a ) {
997    locint a_loc = a.loc();
998    ADOLC_OPENMP_THREAD_NUMBER;
999    ADOLC_OPENMP_GET_THREAD_NUMBER;
1000    int upd = 0;
1001    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag)
1002#if defined(ADOLC_TRACK_ACTIVITY)
1003     if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()])
1004#endif
1005      {
1006        upd = upd_resloc_inc_prod(a_loc,loc(),eq_plus_prod);
1007      }
1008    if (upd) {
1009        /* kk 20170720 Activity Tracking: This case only happens if both
1010           lhs and rhs have true in actStore, since previous operation
1011           that created rhs is mult_a_a and we checked lhs above.
1012           So no change is needed */
1013        ADOLC_GLOBAL_TAPE_VARS.store[loc()] += ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
1014        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1015            ADOLC_DELETE_SCAYLOR(&ADOLC_GLOBAL_TAPE_VARS.store[a_loc]);
1016        --ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1017        ++ADOLC_CURRENT_TAPE_INFOS.num_eq_prod; 
1018    } else {
1019        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(loc(),a_loc);
1020#if defined(ADOLC_TRACK_ACTIVITY)
1021          if (ADOLC_GLOBAL_TAPE_VARS.actStore[a_loc] && ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
1022#endif
1023            put_op(eq_plus_a);
1024            ADOLC_PUT_LOCINT(a_loc);    // = arg
1025            ADOLC_PUT_LOCINT(loc()); // = res
1026
1027            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1028            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1029                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
1030#if defined(ADOLC_TRACK_ACTIVITY)
1031          } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[a_loc]) {
1032              double coval = ADOLC_GLOBAL_TAPE_VARS.store[loc()];
1033              if (coval) {
1034                  put_op(plus_d_a);
1035                  ADOLC_PUT_LOCINT(a_loc); // = arg
1036                  ADOLC_PUT_LOCINT(loc()); // = res
1037                  ADOLC_PUT_VAL(coval);
1038              } else {
1039                  put_op(assign_a);
1040                  ADOLC_PUT_LOCINT(a_loc); // = arg
1041                  ADOLC_PUT_LOCINT(loc());      // = res
1042              }
1043
1044              ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1045              if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1046                  ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
1047
1048          } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
1049              double coval = ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
1050              if (coval) {
1051                  put_op(eq_plus_d);
1052                  ADOLC_PUT_LOCINT(loc()); // = res
1053                  ADOLC_PUT_VAL(coval);       // = coval
1054
1055                  ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1056                  if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1057                      ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
1058              }
1059          }
1060#endif
1061        }
1062        ADOLC_GLOBAL_TAPE_VARS.store[loc()] += ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
1063#if defined(ADOLC_TRACK_ACTIVITY)
1064        ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] = (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] || ADOLC_GLOBAL_TAPE_VARS.actStore[a_loc]);
1065#endif
1066    }
1067
1068    return *this;
1069}
1070
1071/*--------------------------------------------------------------------------*/
1072/* Subtract an adouble from another adouble */
1073badouble& badouble::operator -= ( const badouble& y ) {
1074    ADOLC_OPENMP_THREAD_NUMBER;
1075    ADOLC_OPENMP_GET_THREAD_NUMBER;
1076    locint y_loc = y.loc();
1077    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_a_same_arg(eq_min_a,loc(),y.loc());
1078#if defined(ADOLC_TRACK_ACTIVITY)
1079      if (ADOLC_GLOBAL_TAPE_VARS.actStore[y_loc] && ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
1080#endif
1081        put_op(eq_min_a);
1082        ADOLC_PUT_LOCINT(y_loc); // = arg
1083        ADOLC_PUT_LOCINT(loc());   // = res
1084
1085        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1086        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1087            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
1088#if defined(ADOLC_TRACK_ACTIVITY)
1089      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[y_loc]) {
1090          double coval = ADOLC_GLOBAL_TAPE_VARS.store[loc()];
1091          if (coval) {
1092              put_op(min_d_a);
1093              ADOLC_PUT_LOCINT(y_loc); // = arg
1094              ADOLC_PUT_LOCINT(loc()); // = res
1095              ADOLC_PUT_VAL(coval);
1096          } else {
1097              put_op(neg_sign_a);
1098              ADOLC_PUT_LOCINT(y_loc); // = arg
1099              ADOLC_PUT_LOCINT(loc());      // = res
1100          }
1101
1102          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1103          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1104              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
1105
1106      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
1107          double coval = ADOLC_GLOBAL_TAPE_VARS.store[y_loc];
1108          if (coval) {
1109              put_op(eq_min_d);
1110              ADOLC_PUT_LOCINT(loc()); // = res
1111              ADOLC_PUT_VAL(coval);       // = coval
1112
1113              ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1114              if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1115                  ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
1116          }
1117      }
1118#endif
1119    }
1120
1121    ADOLC_GLOBAL_TAPE_VARS.store[loc()] -= ADOLC_GLOBAL_TAPE_VARS.store[y_loc];
1122#if defined(ADOLC_TRACK_ACTIVITY)
1123    ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] = (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] || ADOLC_GLOBAL_TAPE_VARS.actStore[y_loc]);
1124#endif
1125    return *this;
1126}
1127
1128/*--------------------------------------------------------------------------*/
1129/* olvo 991122 new version for y -= x1 * x2; */
1130badouble& badouble::operator -= ( const adub& a ) {
1131    ADOLC_OPENMP_THREAD_NUMBER;
1132    ADOLC_OPENMP_GET_THREAD_NUMBER;
1133    locint a_loc = a.loc();
1134    int upd = 0;
1135    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag)
1136#if defined(ADOLC_TRACK_ACTIVITY)
1137     if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()])
1138#endif
1139      {
1140        upd = upd_resloc_inc_prod(a_loc,loc(),eq_min_prod);
1141      }
1142    if (upd) {
1143        /* kk 20170720 Activity Tracking: This case only happens if both
1144           lhs and rhs have true in actStore, since previous operation
1145           that created rhs is mult_a_a and we checked lhs above.
1146           So no change is needed */
1147        ADOLC_GLOBAL_TAPE_VARS.store[loc()] -= ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
1148        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1149            ADOLC_DELETE_SCAYLOR(&ADOLC_GLOBAL_TAPE_VARS.store[a_loc]);
1150        --ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1151        ++ADOLC_CURRENT_TAPE_INFOS.num_eq_prod;
1152    } else {
1153        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_assign_a(loc(),a_loc);
1154#if defined(ADOLC_TRACK_ACTIVITY)
1155          if (ADOLC_GLOBAL_TAPE_VARS.actStore[a_loc] && ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
1156#endif
1157            put_op(eq_min_a);
1158            ADOLC_PUT_LOCINT(a_loc);    // = arg
1159            ADOLC_PUT_LOCINT(loc()); // = res
1160
1161            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1162            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1163                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
1164#if defined(ADOLC_TRACK_ACTIVITY)
1165          } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[a_loc]) {
1166              double coval = ADOLC_GLOBAL_TAPE_VARS.store[loc()];
1167              if (coval) {
1168                  put_op(min_d_a);
1169                  ADOLC_PUT_LOCINT(a_loc); // = arg
1170                  ADOLC_PUT_LOCINT(loc()); // = res
1171                  ADOLC_PUT_VAL(coval);
1172              } else {
1173                  put_op(neg_sign_a);
1174                  ADOLC_PUT_LOCINT(a_loc); // = arg
1175                  ADOLC_PUT_LOCINT(loc());      // = res
1176              }
1177
1178              ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1179              if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1180                  ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
1181
1182          } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
1183              double coval = ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
1184              if (coval) {
1185                  put_op(eq_min_d);
1186                  ADOLC_PUT_LOCINT(loc()); // = res
1187                  ADOLC_PUT_VAL(coval);       // = coval
1188
1189                  ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1190                  if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1191                      ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
1192              }
1193          }
1194#endif
1195        }
1196        ADOLC_GLOBAL_TAPE_VARS.store[loc()] -= ADOLC_GLOBAL_TAPE_VARS.store[a_loc];
1197#if defined(ADOLC_TRACK_ACTIVITY)
1198        ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] = (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] || ADOLC_GLOBAL_TAPE_VARS.actStore[a_loc]);
1199#endif
1200    }
1201
1202    return *this;
1203}
1204
1205/*--------------------------------------------------------------------------*/
1206/* Multiply an adouble by a floating point */
1207badouble& badouble::operator *= ( double coval ) {
1208    ADOLC_OPENMP_THREAD_NUMBER;
1209    ADOLC_OPENMP_GET_THREAD_NUMBER;
1210    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_mult_d,loc(),coval);
1211#if defined(ADOLC_TRACK_ACTIVITY)
1212      if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
1213#endif
1214        put_op(eq_mult_d);
1215        ADOLC_PUT_LOCINT(loc()); // = res
1216        ADOLC_PUT_VAL(coval);       // = coval
1217
1218        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1219        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1220            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
1221#if defined(ADOLC_TRACK_ACTIVITY)
1222      }
1223#endif
1224    }
1225
1226    ADOLC_GLOBAL_TAPE_VARS.store[loc()] *= coval;
1227    return *this;
1228}
1229
1230/*--------------------------------------------------------------------------*/
1231/* Multiply one adouble by another adouble*/
1232badouble& badouble::operator *= ( const badouble& y ) {
1233    ADOLC_OPENMP_THREAD_NUMBER;
1234    ADOLC_OPENMP_GET_THREAD_NUMBER;
1235    locint y_loc = y.loc();
1236    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_a_same_arg(eq_mult_a,loc(),y.loc());
1237#if defined(ADOLC_TRACK_ACTIVITY)
1238      if (ADOLC_GLOBAL_TAPE_VARS.actStore[y_loc] && ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
1239#endif
1240        put_op(eq_mult_a);
1241        ADOLC_PUT_LOCINT(y_loc); // = arg
1242        ADOLC_PUT_LOCINT(loc());   // = res
1243
1244        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1245        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1246            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
1247#if defined(ADOLC_TRACK_ACTIVITY)
1248      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[y_loc]) {
1249          double coval = ADOLC_GLOBAL_TAPE_VARS.store[loc()];
1250          if (coval == -1.0) {
1251              put_op(neg_sign_a);
1252              ADOLC_PUT_LOCINT(y.loc()); // = arg
1253              ADOLC_PUT_LOCINT(loc()); // = res
1254          } else if (coval == 1.0) {
1255              put_op(pos_sign_a);
1256              ADOLC_PUT_LOCINT(y.loc()); // = arg
1257              ADOLC_PUT_LOCINT(loc()); // = res
1258          } else {
1259              put_op(mult_d_a);
1260              ADOLC_PUT_LOCINT(y_loc); // = arg
1261              ADOLC_PUT_LOCINT(loc()); // = res
1262              ADOLC_PUT_VAL(coval);
1263          }
1264
1265          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1266          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1267              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
1268
1269      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()]) {
1270          double coval = ADOLC_GLOBAL_TAPE_VARS.store[y_loc];
1271          put_op(eq_mult_d);
1272          ADOLC_PUT_LOCINT(loc()); // = res
1273          ADOLC_PUT_VAL(coval);       // = coval
1274
1275          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1276          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1277              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
1278      }
1279#endif
1280    }
1281
1282    ADOLC_GLOBAL_TAPE_VARS.store[loc()] *= ADOLC_GLOBAL_TAPE_VARS.store[y_loc];
1283#if defined(ADOLC_TRACK_ACTIVITY)
1284    ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] = (ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] || ADOLC_GLOBAL_TAPE_VARS.actStore[y_loc]);
1285#endif
1286    return *this;
1287}
1288
1289/*--------------------------------------------------------------------------*/
1290badouble& badouble::operator /= (double y) {
1291    *this = *this/y;
1292    return *this;
1293}
1294
1295/*--------------------------------------------------------------------------*/
1296badouble& badouble::operator /= (const badouble& y) {
1297    *this = *this * (1.0/y);
1298    return *this;
1299}
1300
1301/****************************************************************************/
1302/*                                                               COMPARISON */
1303/*--------------------------------------------------------------------------*/
1304/*   The Not Equal Operator (!=) */
1305int operator != ( const badouble& v, double coval ) {
1306    ADOLC_OPENMP_THREAD_NUMBER;
1307    ADOLC_OPENMP_GET_THREAD_NUMBER;
1308    if (coval)
1309        return (-coval+v != 0);
1310    else {
1311        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
1312#if defined(ADOLC_TRACK_ACTIVITY)
1313          if (ADOLC_GLOBAL_TAPE_VARS.actStore[v.loc()]) {
1314#endif
1315            put_op(ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] ? neq_zero : eq_zero);
1316            ADOLC_PUT_LOCINT(v.loc());
1317#if defined(ADOLC_TRACK_ACTIVITY)
1318          }
1319#endif
1320        }
1321        return (ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] != 0);
1322    }
1323}
1324
1325/*--------------------------------------------------------------------------*/
1326/*   The Equal Operator (==) */
1327int operator == ( const badouble& v, double coval) {
1328    ADOLC_OPENMP_THREAD_NUMBER;
1329    ADOLC_OPENMP_GET_THREAD_NUMBER;
1330    if (coval)
1331        return (-coval+v == 0);
1332    else {
1333        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
1334#if defined(ADOLC_TRACK_ACTIVITY)
1335          if (ADOLC_GLOBAL_TAPE_VARS.actStore[v.loc()]) {
1336#endif
1337            put_op(ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] ? neq_zero : eq_zero);
1338            ADOLC_PUT_LOCINT(v.loc());
1339#if defined(ADOLC_TRACK_ACTIVITY)
1340          }
1341#endif
1342        }
1343        return (ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] == 0);
1344    }
1345}
1346
1347/*--------------------------------------------------------------------------*/
1348/*   The Less than or Equal Operator (<=)      */
1349int operator <= ( const badouble& v, double coval ) {
1350    ADOLC_OPENMP_THREAD_NUMBER;
1351    ADOLC_OPENMP_GET_THREAD_NUMBER;
1352    if (coval)
1353        return (-coval+v <= 0);
1354    else {
1355        int b = (ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] <= 0);
1356        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
1357#if defined(ADOLC_TRACK_ACTIVITY)
1358          if (ADOLC_GLOBAL_TAPE_VARS.actStore[v.loc()]) {
1359#endif
1360            put_op(b ? le_zero : gt_zero);
1361            ADOLC_PUT_LOCINT(v.loc());
1362#if defined(ADOLC_TRACK_ACTIVITY)
1363          }
1364#endif
1365        }
1366        return b;
1367    }
1368}
1369
1370/*--------------------------------------------------------------------------*/
1371/*   The Greater than or Equal Operator (>=)      */
1372int operator >= ( const badouble& v, double coval ) {
1373    ADOLC_OPENMP_THREAD_NUMBER;
1374    ADOLC_OPENMP_GET_THREAD_NUMBER;
1375    if (coval)
1376        return (-coval+v >= 0);
1377    else {
1378        int b = (ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] >= 0);
1379        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
1380#if defined(ADOLC_TRACK_ACTIVITY)
1381          if (ADOLC_GLOBAL_TAPE_VARS.actStore[v.loc()]) {
1382#endif
1383            put_op(b ? ge_zero : lt_zero);
1384            ADOLC_PUT_LOCINT(v.loc());
1385#if defined(ADOLC_TRACK_ACTIVITY)
1386          }
1387#endif
1388        }
1389        return b;
1390    }
1391}
1392
1393/*--------------------------------------------------------------------------*/
1394/*   The Greater than Operator (>)      */
1395int operator > ( const badouble& v, double coval ) {
1396    ADOLC_OPENMP_THREAD_NUMBER;
1397    ADOLC_OPENMP_GET_THREAD_NUMBER;
1398    if (coval)
1399        return (-coval+v > 0);
1400    else {
1401        int b = (ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] > 0);
1402        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
1403#if defined(ADOLC_TRACK_ACTIVITY)
1404          if (ADOLC_GLOBAL_TAPE_VARS.actStore[v.loc()]) {
1405#endif
1406            put_op(b ? gt_zero : le_zero);
1407            ADOLC_PUT_LOCINT(v.loc());
1408#if defined(ADOLC_TRACK_ACTIVITY)
1409          }
1410#endif
1411        }
1412        return b;
1413    }
1414}
1415
1416/*--------------------------------------------------------------------------*/
1417/*   The Less than Operator (<)      */
1418int operator < ( const badouble& v, double coval ) {
1419    ADOLC_OPENMP_THREAD_NUMBER;
1420    ADOLC_OPENMP_GET_THREAD_NUMBER;
1421    if (coval)
1422        return (-coval+v < 0);
1423    else {
1424        int b = (ADOLC_GLOBAL_TAPE_VARS.store[v.loc()] < 0);
1425        if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
1426#if defined(ADOLC_TRACK_ACTIVITY)
1427          if (ADOLC_GLOBAL_TAPE_VARS.actStore[v.loc()]) {
1428#endif
1429            put_op(b ? lt_zero : ge_zero);
1430            ADOLC_PUT_LOCINT(v.loc());
1431#if defined(ADOLC_TRACK_ACTIVITY)
1432          }
1433#endif
1434        }
1435        return b;
1436    }
1437}
1438
1439
1440/****************************************************************************/
1441/*                                                          SIGN  OPERATORS */
1442
1443/*--------------------------------------------------------------------------*/
1444/* olvo 980709 modified positive sign operator
1445   ??? possibly there is a better way */
1446adub operator + ( const badouble& x ) {
1447    ADOLC_OPENMP_THREAD_NUMBER;
1448    ADOLC_OPENMP_GET_THREAD_NUMBER;
1449    locint locat = next_loc();
1450    double coval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
1451
1452    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_pos_sign_a(locat,x.loc());
1453#if defined(ADOLC_TRACK_ACTIVITY)
1454      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
1455#endif
1456        put_op(pos_sign_a);
1457        ADOLC_PUT_LOCINT(x.loc()); // = arg
1458        ADOLC_PUT_LOCINT(locat);      // = res
1459
1460        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1461        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1462            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1463#if defined(ADOLC_TRACK_ACTIVITY)
1464      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
1465          if (coval == 0.0) {
1466              put_op(assign_d_zero);
1467              ADOLC_PUT_LOCINT(locat);
1468          } else if (coval == 1.0) {
1469              put_op(assign_d_one);
1470              ADOLC_PUT_LOCINT(locat);
1471          } else {
1472              put_op(assign_d);
1473              ADOLC_PUT_LOCINT(locat);
1474              ADOLC_PUT_VAL(coval);
1475          }
1476
1477          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1478          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1479              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1480      }
1481#endif
1482    }
1483
1484    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
1485#if defined(ADOLC_TRACK_ACTIVITY)
1486    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
1487#endif
1488    return locat;
1489}
1490
1491/*--------------------------------------------------------------------------*/
1492/* olvo 980709 modified negative sign operator */
1493adub operator - ( const badouble& x ) {
1494    ADOLC_OPENMP_THREAD_NUMBER;
1495    ADOLC_OPENMP_GET_THREAD_NUMBER;
1496    locint locat = next_loc();
1497    double coval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
1498
1499    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_neg_sign_a(locat,x.loc());
1500#if defined(ADOLC_TRACK_ACTIVITY)
1501      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
1502#endif
1503        put_op(neg_sign_a);
1504        ADOLC_PUT_LOCINT(x.loc()); // = arg
1505        ADOLC_PUT_LOCINT(locat);      // = res
1506
1507        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1508        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1509            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1510#if defined(ADOLC_TRACK_ACTIVITY)
1511      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
1512          if (- coval == 0.0) {
1513              put_op(assign_d_zero);
1514              ADOLC_PUT_LOCINT(locat);
1515          } else if (- coval == 1.0) {
1516              put_op(assign_d_one);
1517              ADOLC_PUT_LOCINT(locat);
1518          } else {
1519              put_op(assign_d);
1520              ADOLC_PUT_LOCINT(locat);
1521              ADOLC_PUT_VAL(- coval);
1522          }
1523
1524          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1525          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1526              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1527      }
1528#endif
1529    }
1530
1531    ADOLC_GLOBAL_TAPE_VARS.store[locat] = - coval;
1532#if defined(ADOLC_TRACK_ACTIVITY)
1533    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
1534#endif
1535    return locat;
1536}
1537
1538
1539/****************************************************************************/
1540/*                                                         BINARY OPERATORS */
1541
1542/* NOTE: each operator calculates address of temporary  and returns
1543         an adub */
1544
1545/*--------------------------------------------------------------------------*/
1546/* Adding two adoubles */
1547adub operator + ( const badouble& x, const badouble& y ) {
1548    ADOLC_OPENMP_THREAD_NUMBER;
1549    ADOLC_OPENMP_GET_THREAD_NUMBER;
1550    locint locat = next_loc();
1551    double coval2 = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()] + ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
1552
1553    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_two_a_rec(plus_a_a,locat,x.loc(),y.loc());
1554#if defined(ADOLC_TRACK_ACTIVITY)
1555      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] && ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
1556#endif
1557        put_op(plus_a_a);
1558        ADOLC_PUT_LOCINT(x.loc()); // = arg1
1559        ADOLC_PUT_LOCINT(y.loc()); // = arg2
1560        ADOLC_PUT_LOCINT(locat);      // = res
1561
1562        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1563        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1564            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1565#if defined(ADOLC_TRACK_ACTIVITY)
1566      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
1567          put_op(plus_d_a);
1568          ADOLC_PUT_LOCINT(x.loc()); // = arg
1569          ADOLC_PUT_LOCINT(locat); // = res
1570          ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[y.loc()]);
1571
1572        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1573        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1574            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1575      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
1576          double coval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
1577          if (coval) {
1578              put_op(plus_d_a);
1579              ADOLC_PUT_LOCINT(y.loc()); // = arg
1580              ADOLC_PUT_LOCINT(locat); // = res
1581              ADOLC_PUT_VAL(coval);
1582          } else {
1583              put_op(pos_sign_a);
1584              ADOLC_PUT_LOCINT(y.loc()); // = arg
1585              ADOLC_PUT_LOCINT(locat); // = res
1586          }
1587
1588        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1589        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1590            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1591      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
1592          if (coval2 == 0.0) {
1593              put_op(assign_d_zero);
1594              ADOLC_PUT_LOCINT(locat);
1595          } else if (coval2 == 1.0) {
1596              put_op(assign_d_one);
1597              ADOLC_PUT_LOCINT(locat);
1598          } else {
1599              put_op(assign_d);
1600              ADOLC_PUT_LOCINT(locat);
1601              ADOLC_PUT_VAL(coval2);
1602          }
1603
1604          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1605          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1606              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1607      }
1608#endif
1609    }
1610
1611    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval2;
1612#if defined(ADOLC_TRACK_ACTIVITY)
1613    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] || ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]);
1614#endif
1615    return locat;
1616}
1617
1618/*--------------------------------------------------------------------------*/
1619/* Adding a adouble and a floating point */
1620adub operator + ( double coval, const badouble& y ) {
1621    ADOLC_OPENMP_THREAD_NUMBER;
1622    ADOLC_OPENMP_GET_THREAD_NUMBER;
1623    locint locat = next_loc();
1624    double coval2 = coval + ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
1625
1626    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(plus_d_a,locat,coval,y.loc());
1627#if defined(ADOLC_TRACK_ACTIVITY)
1628      if (ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
1629#endif
1630         /* olvo 980708 test coval to be zero */
1631         if (coval) {
1632            put_op(plus_d_a);
1633            ADOLC_PUT_LOCINT(y.loc()); // = arg
1634            ADOLC_PUT_LOCINT(locat);      // = res
1635            ADOLC_PUT_VAL(coval);         // = coval
1636         } else {
1637            put_op(pos_sign_a);
1638            ADOLC_PUT_LOCINT(y.loc()); // = arg
1639            ADOLC_PUT_LOCINT(locat);      // = res
1640         }
1641
1642         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1643         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1644             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1645#if defined(ADOLC_TRACK_ACTIVITY)
1646      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
1647          if (coval2 == 0.0) {
1648              put_op(assign_d_zero);
1649              ADOLC_PUT_LOCINT(locat);
1650          } else if (coval2 == 1.0) {
1651              put_op(assign_d_one);
1652              ADOLC_PUT_LOCINT(locat);
1653          } else {
1654              put_op(assign_d);
1655              ADOLC_PUT_LOCINT(locat);
1656              ADOLC_PUT_VAL(coval2);
1657          }
1658
1659          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1660          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1661              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1662      }
1663#endif
1664    }
1665
1666    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval2;
1667#if defined(ADOLC_TRACK_ACTIVITY)
1668    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()];
1669#endif
1670
1671    return locat;
1672}
1673
1674/*--------------------------------------------------------------------------*/
1675/* Subtraction of two adoubles */
1676adub operator - ( const badouble& x, const badouble& y ) {
1677    ADOLC_OPENMP_THREAD_NUMBER;
1678    ADOLC_OPENMP_GET_THREAD_NUMBER;
1679    locint locat = next_loc();
1680    double coval2 = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()] - ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
1681
1682    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_two_a_rec(min_a_a,locat,x.loc(),y.loc());
1683#if defined(ADOLC_TRACK_ACTIVITY)
1684      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] && ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
1685#endif
1686        put_op(min_a_a);
1687        ADOLC_PUT_LOCINT(x.loc()); // = arg1
1688        ADOLC_PUT_LOCINT(y.loc()); // = arg2
1689        ADOLC_PUT_LOCINT(locat);      // = res
1690
1691        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1692        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1693            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1694#if defined(ADOLC_TRACK_ACTIVITY)
1695      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
1696          double coval = - ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
1697          put_op(plus_d_a);
1698          ADOLC_PUT_LOCINT(x.loc()); // = arg
1699          ADOLC_PUT_LOCINT(locat); // = res
1700          ADOLC_PUT_VAL(coval);
1701
1702        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1703        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1704            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1705      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
1706          double coval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
1707          if (coval) {
1708              put_op(min_d_a);
1709              ADOLC_PUT_LOCINT(y.loc()); // = arg
1710              ADOLC_PUT_LOCINT(locat);  // = res
1711              ADOLC_PUT_VAL(coval);
1712          } else {
1713              put_op(neg_sign_a);
1714              ADOLC_PUT_LOCINT(y.loc()); // = arg
1715              ADOLC_PUT_LOCINT(locat); // = res
1716          }
1717
1718          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1719          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1720              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1721      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
1722          if (coval2 == 0.0) {
1723              put_op(assign_d_zero);
1724              ADOLC_PUT_LOCINT(locat);
1725          } else if (coval2 == 1.0) {
1726              put_op(assign_d_one);
1727              ADOLC_PUT_LOCINT(locat);
1728          } else {
1729              put_op(assign_d);
1730              ADOLC_PUT_LOCINT(locat);
1731              ADOLC_PUT_VAL(coval2);
1732          }
1733
1734          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1735          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1736              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1737      }
1738#endif
1739    }
1740
1741    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval2;
1742#if defined(ADOLC_TRACK_ACTIVITY)
1743    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] || ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]);
1744#endif
1745    return locat;
1746}
1747
1748
1749/*--------------------------------------------------------------------------*/
1750/* Subtract an adouble from a floating point */
1751adub operator - ( double coval, const badouble& y ) {
1752    ADOLC_OPENMP_THREAD_NUMBER;
1753    ADOLC_OPENMP_GET_THREAD_NUMBER;
1754    locint locat = next_loc();
1755    double coval2 = coval - ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
1756
1757    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(min_d_a,locat,coval,y.loc());
1758#if defined(ADOLC_TRACK_ACTIVITY)
1759      if (ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
1760#endif
1761         /* olvo 980708 test coval to be zero */
1762         if (coval) {
1763            put_op(min_d_a);
1764            ADOLC_PUT_LOCINT(y.loc()); // = arg
1765            ADOLC_PUT_LOCINT(locat);      // = res
1766            ADOLC_PUT_VAL(coval);         // = coval
1767         } else {
1768            put_op(neg_sign_a);
1769            ADOLC_PUT_LOCINT(y.loc()); // = arg
1770            ADOLC_PUT_LOCINT(locat);      // = res
1771         }
1772
1773         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1774         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1775             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1776#if defined(ADOLC_TRACK_ACTIVITY)
1777      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
1778          if (coval2 == 0.0) {
1779              put_op(assign_d_zero);
1780              ADOLC_PUT_LOCINT(locat);
1781          } else if (coval2 == 1.0) {
1782              put_op(assign_d_one);
1783              ADOLC_PUT_LOCINT(locat);
1784          } else {
1785              put_op(assign_d);
1786              ADOLC_PUT_LOCINT(locat);
1787              ADOLC_PUT_VAL(coval2);
1788          }
1789
1790          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1791          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1792              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1793      }
1794#endif
1795    }
1796
1797    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval2;
1798#if defined(ADOLC_TRACK_ACTIVITY)
1799    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()];
1800#endif
1801
1802    return locat;
1803}
1804
1805/*--------------------------------------------------------------------------*/
1806/* Multiply two adoubles */
1807adub operator * ( const badouble& x, const badouble& y ) {
1808    ADOLC_OPENMP_THREAD_NUMBER;
1809    ADOLC_OPENMP_GET_THREAD_NUMBER;
1810    locint locat = next_loc();
1811    double coval2 = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()] * ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
1812
1813    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_two_a_rec(mult_a_a,locat,x.loc(),y.loc());
1814#if defined(ADOLC_TRACK_ACTIVITY)
1815      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] && ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
1816#endif
1817        put_op(mult_a_a);
1818        ADOLC_PUT_LOCINT(x.loc()); // = arg1
1819        ADOLC_PUT_LOCINT(y.loc()); // = arg2
1820        ADOLC_PUT_LOCINT(locat);      // = res
1821
1822        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1823        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1824            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1825#if defined(ADOLC_TRACK_ACTIVITY)
1826      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
1827          double coval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
1828          put_op(mult_d_a);
1829          ADOLC_PUT_LOCINT(x.loc()); // = arg
1830          ADOLC_PUT_LOCINT(locat); // = res
1831          ADOLC_PUT_VAL(coval);
1832
1833        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1834        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1835            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1836      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
1837          double coval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
1838          if (coval == -1.0) {
1839              put_op(neg_sign_a);
1840              ADOLC_PUT_LOCINT(y.loc()); // = arg
1841              ADOLC_PUT_LOCINT(locat); // = res
1842          } else if (coval == 1.0) {
1843              put_op(pos_sign_a);
1844              ADOLC_PUT_LOCINT(y.loc()); // = arg
1845              ADOLC_PUT_LOCINT(locat); // = res
1846          } else {
1847              put_op(mult_d_a);
1848              ADOLC_PUT_LOCINT(y.loc()); // = arg
1849              ADOLC_PUT_LOCINT(locat); // = res
1850              ADOLC_PUT_VAL(coval);
1851          }
1852
1853        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1854        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1855            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1856      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
1857          if (coval2 == 0.0) {
1858              put_op(assign_d_zero);
1859              ADOLC_PUT_LOCINT(locat);
1860          } else if (coval2 == 1.0) {
1861              put_op(assign_d_one);
1862              ADOLC_PUT_LOCINT(locat);
1863          } else {
1864              put_op(assign_d);
1865              ADOLC_PUT_LOCINT(locat);
1866              ADOLC_PUT_VAL(coval2);
1867          }
1868
1869          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1870          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1871              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1872      }
1873#endif
1874    }
1875
1876    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval2;
1877#if defined(ADOLC_TRACK_ACTIVITY)
1878    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] || ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]);
1879#endif
1880    return locat;
1881}
1882
1883/*--------------------------------------------------------------------------*/
1884/* Multiply an adouble by a floating point */
1885/* olvo 980709 modified */
1886adub operator * ( double coval, const badouble& y ) {
1887    ADOLC_OPENMP_THREAD_NUMBER;
1888    ADOLC_OPENMP_GET_THREAD_NUMBER;
1889    locint locat = next_loc();
1890    double coval2 = coval * ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
1891
1892    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_pos_sign_a(locat,y.loc());
1893#if defined(ADOLC_TRACK_ACTIVITY)
1894      if (ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
1895#endif
1896         if ( coval == 1.0 ) {
1897            put_op(pos_sign_a);
1898            ADOLC_PUT_LOCINT(y.loc()); // = arg
1899            ADOLC_PUT_LOCINT(locat);      // = res
1900         } else if ( coval == -1.0 ) {
1901             put_op(neg_sign_a);
1902             ADOLC_PUT_LOCINT(y.loc()); // = arg
1903             ADOLC_PUT_LOCINT(locat);      // = res
1904         } else {
1905             put_op(mult_d_a);
1906             ADOLC_PUT_LOCINT(y.loc()); // = arg
1907             ADOLC_PUT_LOCINT(locat);      // = res
1908             ADOLC_PUT_VAL(coval);         // = coval
1909         }
1910
1911         ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1912         if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1913             ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1914#if defined(ADOLC_TRACK_ACTIVITY)
1915      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
1916          if (coval2 == 0.0) {
1917              put_op(assign_d_zero);
1918              ADOLC_PUT_LOCINT(locat);
1919          } else if (coval2 == 1.0) {
1920              put_op(assign_d_one);
1921              ADOLC_PUT_LOCINT(locat);
1922          } else {
1923              put_op(assign_d);
1924              ADOLC_PUT_LOCINT(locat);
1925              ADOLC_PUT_VAL(coval2);
1926          }
1927
1928          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1929          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1930              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1931      }
1932#endif
1933    }
1934
1935    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval2;
1936#if defined(ADOLC_TRACK_ACTIVITY)
1937    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()];
1938#endif
1939
1940    return locat;
1941}
1942
1943/*--------------------------------------------------------------------------*/
1944/* Divide an adouble by another adouble */
1945adub operator / ( const badouble& x, const badouble& y ) {
1946    ADOLC_OPENMP_THREAD_NUMBER;
1947    ADOLC_OPENMP_GET_THREAD_NUMBER;
1948    locint locat = next_loc();
1949    double coval2 = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()] / ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
1950
1951    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_two_a_rec(div_a_a,locat,x.loc(),y.loc());
1952#if defined(ADOLC_TRACK_ACTIVITY)
1953      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] && ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
1954#endif
1955        put_op(div_a_a);
1956        ADOLC_PUT_LOCINT(x.loc()); // = arg1
1957        ADOLC_PUT_LOCINT(y.loc()); // = arg2
1958        ADOLC_PUT_LOCINT(locat);      // = res
1959
1960        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1961        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1962            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1963#if defined(ADOLC_TRACK_ACTIVITY)
1964      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
1965          double coval = 1.0/ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
1966          if (coval == -1.0) {
1967              put_op(neg_sign_a);
1968              ADOLC_PUT_LOCINT(y.loc()); // = arg
1969              ADOLC_PUT_LOCINT(locat); // = res
1970          } else if (coval == 1.0) {
1971              put_op(pos_sign_a);
1972              ADOLC_PUT_LOCINT(y.loc()); // = arg
1973              ADOLC_PUT_LOCINT(locat); // = res
1974          } else {
1975              put_op(mult_d_a);
1976              ADOLC_PUT_LOCINT(x.loc()); // = arg
1977              ADOLC_PUT_LOCINT(locat); // = res
1978              ADOLC_PUT_VAL(coval);
1979          }
1980
1981        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1982        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1983            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1984      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
1985          double coval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
1986          put_op(div_d_a);
1987          ADOLC_PUT_LOCINT(y.loc()); // = arg
1988          ADOLC_PUT_LOCINT(locat); // = res
1989          ADOLC_PUT_VAL(coval);
1990
1991        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
1992        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
1993            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
1994      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
1995          if (coval2 == 0.0) {
1996              put_op(assign_d_zero);
1997              ADOLC_PUT_LOCINT(locat);
1998          } else if (coval2 == 1.0) {
1999              put_op(assign_d_one);
2000              ADOLC_PUT_LOCINT(locat);
2001          } else {
2002              put_op(assign_d);
2003              ADOLC_PUT_LOCINT(locat);
2004              ADOLC_PUT_VAL(coval2);
2005          }
2006
2007          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2008          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2009              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2010      }
2011#endif
2012    }
2013
2014    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval2;
2015#if defined(ADOLC_TRACK_ACTIVITY)
2016    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] || ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]);
2017#endif
2018    return locat;
2019}
2020
2021/*--------------------------------------------------------------------------*/
2022/* Division floating point - adouble */
2023adub operator / ( double coval, const badouble& y ) {
2024    ADOLC_OPENMP_THREAD_NUMBER;
2025    ADOLC_OPENMP_GET_THREAD_NUMBER;
2026    locint locat = next_loc();
2027    double coval2 = coval / ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
2028
2029    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(div_d_a,locat,coval,y.loc());
2030#if defined(ADOLC_TRACK_ACTIVITY)
2031      if (ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
2032#endif
2033        put_op(div_d_a);
2034        ADOLC_PUT_LOCINT(y.loc()); // = arg
2035        ADOLC_PUT_LOCINT(locat);      // = res
2036        ADOLC_PUT_VAL(coval);         // = coval
2037
2038        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2039        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2040            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2041#if defined(ADOLC_TRACK_ACTIVITY)
2042      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2043          if (coval2 == 0.0) {
2044              put_op(assign_d_zero);
2045              ADOLC_PUT_LOCINT(locat);
2046          } else if (coval2 == 1.0) {
2047              put_op(assign_d_one);
2048              ADOLC_PUT_LOCINT(locat);
2049          } else {
2050              put_op(assign_d);
2051              ADOLC_PUT_LOCINT(locat);
2052              ADOLC_PUT_VAL(coval2);
2053          }
2054
2055          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2056          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2057              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2058      }
2059#endif
2060    }
2061
2062    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval2;
2063#if defined(ADOLC_TRACK_ACTIVITY)
2064    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()];
2065#endif
2066    return locat;
2067}
2068
2069
2070/****************************************************************************/
2071/*                                                        SINGLE OPERATIONS */
2072
2073/*--------------------------------------------------------------------------*/
2074/* Compute exponential of adouble */
2075adub exp ( const badouble& x ) {
2076    ADOLC_OPENMP_THREAD_NUMBER;
2077    ADOLC_OPENMP_GET_THREAD_NUMBER;
2078    locint locat = next_loc();
2079    double coval = ADOLC_MATH_NSP::exp(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2080
2081    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_single_op(exp_op,locat,x.loc());
2082#if defined(ADOLC_TRACK_ACTIVITY)
2083      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2084#endif
2085        put_op(exp_op);
2086        ADOLC_PUT_LOCINT(x.loc()); // = arg
2087        ADOLC_PUT_LOCINT(locat);      // = res
2088
2089        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2090        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2091            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2092#if defined(ADOLC_TRACK_ACTIVITY)
2093      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2094          if (coval == 0.0) {
2095              put_op(assign_d_zero);
2096              ADOLC_PUT_LOCINT(locat);
2097          } else if (coval == 1.0) {
2098              put_op(assign_d_one);
2099              ADOLC_PUT_LOCINT(locat);
2100          } else {
2101              put_op(assign_d);
2102              ADOLC_PUT_LOCINT(locat);
2103              ADOLC_PUT_VAL(coval);
2104          }
2105
2106          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2107          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2108              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2109      }
2110#endif
2111    }
2112
2113    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2114#if defined(ADOLC_TRACK_ACTIVITY)
2115    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2116#endif
2117
2118    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2119    return locat;
2120}
2121
2122/*--------------------------------------------------------------------------*/
2123/* Compute logarithm of adouble */
2124adub log ( const badouble& x ) {
2125    ADOLC_OPENMP_THREAD_NUMBER;
2126    ADOLC_OPENMP_GET_THREAD_NUMBER;
2127    locint locat = next_loc();
2128    double coval = ADOLC_MATH_NSP::log(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2129
2130    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_single_op(log_op,locat,x.loc());
2131#if defined(ADOLC_TRACK_ACTIVITY)
2132      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2133#endif
2134        put_op(log_op);
2135        ADOLC_PUT_LOCINT(x.loc()); // = arg
2136        ADOLC_PUT_LOCINT(locat);      // = res
2137
2138        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2139        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2140            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2141#if defined(ADOLC_TRACK_ACTIVITY)
2142      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2143          if (coval == 0.0) {
2144              put_op(assign_d_zero);
2145              ADOLC_PUT_LOCINT(locat);
2146          } else if (coval == 1.0) {
2147              put_op(assign_d_one);
2148              ADOLC_PUT_LOCINT(locat);
2149          } else {
2150              put_op(assign_d);
2151              ADOLC_PUT_LOCINT(locat);
2152              ADOLC_PUT_VAL(coval);
2153          }
2154
2155          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2156          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2157              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2158      }
2159#endif
2160    }
2161
2162    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2163#if defined(ADOLC_TRACK_ACTIVITY)
2164    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2165#endif
2166    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2167    return locat;
2168}
2169
2170/*--------------------------------------------------------------------------*/
2171/* Compute sqrt of adouble */
2172adub sqrt ( const badouble& x ) {
2173    ADOLC_OPENMP_THREAD_NUMBER;
2174    ADOLC_OPENMP_GET_THREAD_NUMBER;
2175    locint locat = next_loc();
2176    double coval = ADOLC_MATH_NSP::sqrt(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2177
2178    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_single_op(sqrt_op,locat,x.loc());
2179#if defined(ADOLC_TRACK_ACTIVITY)
2180      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2181#endif
2182        put_op(sqrt_op);
2183        ADOLC_PUT_LOCINT(x.loc()); // = arg
2184        ADOLC_PUT_LOCINT(locat);      // = res
2185
2186        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2187        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2188            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2189#if defined(ADOLC_TRACK_ACTIVITY)
2190      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2191          if (coval == 0.0) {
2192              put_op(assign_d_zero);
2193              ADOLC_PUT_LOCINT(locat);
2194          } else if (coval == 1.0) {
2195              put_op(assign_d_one);
2196              ADOLC_PUT_LOCINT(locat);
2197          } else {
2198              put_op(assign_d);
2199              ADOLC_PUT_LOCINT(locat);
2200              ADOLC_PUT_VAL(coval);
2201          }
2202
2203          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2204          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2205              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2206      }
2207#endif
2208    }
2209
2210    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2211#if defined(ADOLC_TRACK_ACTIVITY)
2212    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2213#endif
2214    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2215    return locat;
2216}
2217
2218/****************************************************************************/
2219/*                                                          QUAD OPERATIONS */
2220
2221/*--------------------------------------------------------------------------*/
2222/* Compute sin of adouble
2223   !!! Sin and Cos are always evaluated together
2224*/
2225adub sin ( const badouble& x ) {
2226    ADOLC_OPENMP_THREAD_NUMBER;
2227    ADOLC_OPENMP_GET_THREAD_NUMBER;
2228    locint locat = next_loc();
2229    double coval1 = ADOLC_MATH_NSP::sin(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2230    double coval2 = ADOLC_MATH_NSP::cos(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2231
2232    adouble y;
2233
2234    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(sin_op,locat,x.loc(),y.loc());
2235#if defined(ADOLC_TRACK_ACTIVITY)
2236      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2237#endif
2238        put_op(sin_op);
2239        ADOLC_PUT_LOCINT(x.loc()); // = arg1
2240        ADOLC_PUT_LOCINT(y.loc()); // = arg2
2241        ADOLC_PUT_LOCINT(locat);      // = res
2242
2243        ADOLC_CURRENT_TAPE_INFOS.numTays_Tape += 2;
2244        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors) { /* olvo 980921 changed order */
2245            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.loc()]);
2246            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2247        }
2248#if defined(ADOLC_TRACK_ACTIVITY)
2249      } else {
2250          if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2251              if (coval1 == 0.0) {
2252                  put_op(assign_d_zero);
2253                  ADOLC_PUT_LOCINT(locat);
2254              } else if (coval1 == 1.0) {
2255                  put_op(assign_d_one);
2256                  ADOLC_PUT_LOCINT(locat);
2257              } else {
2258                  put_op(assign_d);
2259                  ADOLC_PUT_LOCINT(locat);
2260                  ADOLC_PUT_VAL(coval1);
2261              }
2262
2263              ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2264              if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2265                  ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2266          }
2267          if (ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
2268              if (coval2 == 0.0) {
2269                  put_op(assign_d_zero);
2270                  ADOLC_PUT_LOCINT(y.loc());
2271              } else if (coval1 == 1.0) {
2272                  put_op(assign_d_one);
2273                  ADOLC_PUT_LOCINT(y.loc());
2274              } else {
2275                  put_op(assign_d);
2276                  ADOLC_PUT_LOCINT(y.loc());
2277                  ADOLC_PUT_VAL(coval2);
2278              }
2279
2280              ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2281              if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2282                  ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.loc()]);
2283          }
2284      }
2285#endif
2286    }
2287
2288    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval1;
2289    ADOLC_GLOBAL_TAPE_VARS.store[y.loc()] = coval2;
2290#if defined(ADOLC_TRACK_ACTIVITY)
2291    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2292#endif
2293
2294    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2295    return locat;
2296}
2297
2298/*--------------------------------------------------------------------------*/
2299/* Compute cos of adouble */
2300adub cos ( const badouble& x ) {
2301    ADOLC_OPENMP_THREAD_NUMBER;
2302    ADOLC_OPENMP_GET_THREAD_NUMBER;
2303    locint locat = next_loc();
2304    double coval1 = ADOLC_MATH_NSP::cos(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2305    double coval2 = ADOLC_MATH_NSP::sin(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2306
2307    adouble y;
2308
2309    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(cos_op, locat,x.loc(),y.loc());
2310#if defined(ADOLC_TRACK_ACTIVITY)
2311      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2312#endif
2313        put_op(cos_op);
2314        ADOLC_PUT_LOCINT(x.loc()); // = arg1
2315        ADOLC_PUT_LOCINT(y.loc()); // = arg2
2316        ADOLC_PUT_LOCINT(locat);      // = res
2317
2318        ADOLC_CURRENT_TAPE_INFOS.numTays_Tape += 2;
2319        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors) { /* olvo 980921 changed order */
2320            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.loc()]);
2321            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2322        }
2323#if defined(ADOLC_TRACK_ACTIVITY)
2324      } else {
2325          if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2326              if (coval1 == 0.0) {
2327                  put_op(assign_d_zero);
2328                  ADOLC_PUT_LOCINT(locat);
2329              } else if (coval1 == 1.0) {
2330                  put_op(assign_d_one);
2331                  ADOLC_PUT_LOCINT(locat);
2332              } else {
2333                  put_op(assign_d);
2334                  ADOLC_PUT_LOCINT(locat);
2335                  ADOLC_PUT_VAL(coval1);
2336              }
2337
2338              ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2339              if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2340                  ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2341          }
2342          if (ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
2343              if (coval2 == 0.0) {
2344                  put_op(assign_d_zero);
2345                  ADOLC_PUT_LOCINT(y.loc());
2346              } else if (coval1 == 1.0) {
2347                  put_op(assign_d_one);
2348                  ADOLC_PUT_LOCINT(y.loc());
2349              } else {
2350                  put_op(assign_d);
2351                  ADOLC_PUT_LOCINT(y.loc());
2352                  ADOLC_PUT_VAL(coval2);
2353              }
2354
2355              ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2356              if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2357                  ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.loc()]);
2358          }
2359      }
2360#endif
2361    }
2362
2363    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval1;
2364    ADOLC_GLOBAL_TAPE_VARS.store[y.loc()] = coval2;
2365#if defined(ADOLC_TRACK_ACTIVITY)
2366    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2367#endif
2368
2369    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2370    return locat;
2371}
2372
2373/*--------------------------------------------------------------------------*/
2374/* Compute tan of adouble */
2375adub tan ( const badouble& x ) {
2376    return sin(x) / cos(x);
2377}
2378
2379/*--------------------------------------------------------------------------*/
2380/* Asin value -- really a quadrature */
2381adub asin ( const badouble& x ) {
2382    ADOLC_OPENMP_THREAD_NUMBER;
2383    ADOLC_OPENMP_GET_THREAD_NUMBER;
2384    locint locat = next_loc();
2385    double coval = ADOLC_MATH_NSP::asin(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2386
2387    adouble y = 1.0 / sqrt(1.0 - x*x);
2388
2389    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old:  write_quad(asin_op,locat,x.loc(),y.loc());
2390#if defined(ADOLC_TRACK_ACTIVITY)
2391      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) { // y will have same activity as x and can be considered as second input here
2392#endif
2393        put_op(asin_op);
2394        ADOLC_PUT_LOCINT(x.loc()); // = arg1
2395        ADOLC_PUT_LOCINT(y.loc()); // = arg2
2396        ADOLC_PUT_LOCINT(locat);      // = res
2397
2398        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2399        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2400            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2401#if defined(ADOLC_TRACK_ACTIVITY)
2402      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2403          if (coval == 0.0) {
2404              put_op(assign_d_zero);
2405              ADOLC_PUT_LOCINT(locat);
2406          } else if (coval == 1.0) {
2407              put_op(assign_d_one);
2408              ADOLC_PUT_LOCINT(locat);
2409          } else {
2410              put_op(assign_d);
2411              ADOLC_PUT_LOCINT(locat);
2412              ADOLC_PUT_VAL(coval);
2413          }
2414
2415          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2416          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2417              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2418      }
2419#endif
2420    }
2421
2422    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2423#if defined(ADOLC_TRACK_ACTIVITY)
2424    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2425#endif
2426    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2427    return locat;
2428}
2429
2430/*--------------------------------------------------------------------------*/
2431/* Acos value -- really a quadrature */
2432adub acos ( const badouble& x ) {
2433    ADOLC_OPENMP_THREAD_NUMBER;
2434    ADOLC_OPENMP_GET_THREAD_NUMBER;
2435    locint locat = next_loc();
2436    double coval = ADOLC_MATH_NSP::acos(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2437
2438    adouble y = -1.0 / sqrt(1.0 - x*x);
2439
2440    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(acos_op,locat,x.loc(),y.loc());
2441#if defined(ADOLC_TRACK_ACTIVITY)
2442      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) { // y will have same activity as x and can be considered as second input here
2443#endif
2444        put_op(acos_op);
2445        ADOLC_PUT_LOCINT(x.loc()); // = arg1
2446        ADOLC_PUT_LOCINT(y.loc()); // = arg2
2447        ADOLC_PUT_LOCINT(locat);      // = res
2448
2449        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2450        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2451            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2452#if defined(ADOLC_TRACK_ACTIVITY)
2453      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2454          if (coval == 0.0) {
2455              put_op(assign_d_zero);
2456              ADOLC_PUT_LOCINT(locat);
2457          } else if (coval == 1.0) {
2458              put_op(assign_d_one);
2459              ADOLC_PUT_LOCINT(locat);
2460          } else {
2461              put_op(assign_d);
2462              ADOLC_PUT_LOCINT(locat);
2463              ADOLC_PUT_VAL(coval);
2464          }
2465
2466          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2467          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2468              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2469      }
2470#endif
2471    }
2472
2473    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2474#if defined(ADOLC_TRACK_ACTIVITY)
2475    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2476#endif
2477    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2478    return locat;
2479}
2480
2481/*--------------------------------------------------------------------------*/
2482/* Atan value -- really a quadrature */
2483adub atan ( const badouble& x ) {
2484    ADOLC_OPENMP_THREAD_NUMBER;
2485    ADOLC_OPENMP_GET_THREAD_NUMBER;
2486    locint locat = next_loc();
2487    double coval = ADOLC_MATH_NSP::atan(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2488
2489    adouble y = 1.0 / (1.0 + x*x);
2490
2491    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(atan_op,locat,x.loc(),y.loc());
2492#if defined(ADOLC_TRACK_ACTIVITY)
2493      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) { // y will have same activity as x and can be considered as second input here
2494#endif
2495        put_op(atan_op);
2496        ADOLC_PUT_LOCINT(x.loc()); // = arg1
2497        ADOLC_PUT_LOCINT(y.loc()); // = arg2
2498        ADOLC_PUT_LOCINT(locat);      // = res
2499
2500        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2501        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2502            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2503#if defined(ADOLC_TRACK_ACTIVITY)
2504      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2505          if (coval == 0.0) {
2506              put_op(assign_d_zero);
2507              ADOLC_PUT_LOCINT(locat);
2508          } else if (coval == 1.0) {
2509              put_op(assign_d_one);
2510              ADOLC_PUT_LOCINT(locat);
2511          } else {
2512              put_op(assign_d);
2513              ADOLC_PUT_LOCINT(locat);
2514              ADOLC_PUT_VAL(coval);
2515          }
2516
2517          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2518          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2519              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2520      }
2521#endif
2522    }
2523
2524    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2525#if defined(ADOLC_TRACK_ACTIVITY)
2526    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2527#endif
2528    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2529    return locat;
2530}
2531
2532/*--------------------------------------------------------------------------*/
2533adouble atan2( const badouble& y, const badouble& x) {
2534    adouble a1, a2, ret, sy;
2535    const double pihalf = ADOLC_MATH_NSP::asin(1.0);
2536    /* y+0.0 is a hack since condassign is currently not defined for
2537       badoubles */
2538    condassign( sy,  y,  (adouble)1.0 , (adouble)-1.0 );
2539    condassign( a1,  x,  atan(y/x),  atan(y/x)+sy*2*pihalf);
2540    condassign( a2,  fabs(y), sy*pihalf-atan(x/y), (adouble) 0.0 );
2541    condassign( ret, fabs(x) - fabs(y), a1, a2 );
2542    return ret;
2543}
2544
2545/*--------------------------------------------------------------------------*/
2546/* power value -- adouble ^ floating point */
2547adub pow ( const badouble& x, double coval ) {
2548    ADOLC_OPENMP_THREAD_NUMBER;
2549    ADOLC_OPENMP_GET_THREAD_NUMBER;
2550    locint locat = next_loc();
2551    double coval2 = ADOLC_MATH_NSP::pow(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()],coval);
2552
2553    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(pow_op,locat,cocval,x.loc());
2554#if defined(ADOLC_TRACK_ACTIVITY)
2555      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2556#endif
2557        put_op(pow_op);
2558        ADOLC_PUT_LOCINT(x.loc()); // = arg
2559        ADOLC_PUT_LOCINT(locat);      // = res
2560        ADOLC_PUT_VAL(coval);         // = coval
2561
2562        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2563        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2564            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2565#if defined(ADOLC_TRACK_ACTIVITY)
2566      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2567          if (coval2 == 0.0) {
2568              put_op(assign_d_zero);
2569              ADOLC_PUT_LOCINT(locat);
2570          } else if (coval2 == 1.0) {
2571              put_op(assign_d_one);
2572              ADOLC_PUT_LOCINT(locat);
2573          } else {
2574              put_op(assign_d);
2575              ADOLC_PUT_LOCINT(locat);
2576              ADOLC_PUT_VAL(coval2);
2577          }
2578
2579          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2580          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2581              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2582      }
2583#endif
2584    }
2585
2586    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval2;
2587#if defined(ADOLC_TRACK_ACTIVITY)
2588    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2589#endif
2590    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2591    return locat;
2592}
2593
2594/*--------------------------------------------------------------------------*/
2595/* power value --- floating point ^ adouble */
2596adouble pow ( double coval, const badouble& y ) {
2597    adouble ret;
2598
2599    if (coval <= 0) {
2600        fprintf(DIAG_OUT,"\nADOL-C message:  exponent at zero/negative constant basis deactivated\n");
2601    }
2602
2603    condassign (ret, (adouble) coval, exp(y*ADOLC_MATH_NSP::log(coval)),
2604                (adouble) ADOLC_MATH_NSP::pow(coval,y.getValue()) );
2605
2606    return ret;
2607}
2608
2609/*--------------------------------------------------------------------------*/
2610/* power value --- adouble ^ adouble */
2611adouble pow ( const badouble& x, const badouble& y) {
2612    adouble a1, a2, ret;
2613    double vx = x.getValue();
2614    double vy = y.getValue();
2615
2616    if (!(vx > 0)) { 
2617        if (vx < 0 || vy >= 0)
2618            fprintf(DIAG_OUT,"\nADOL-C message: exponent of zero/negative basis deactivated\n");
2619        else
2620            fprintf(DIAG_OUT,"\nADOL-C message: negative exponent and zero basis deactivated\n");
2621    }
2622    condassign(a1, -y, (adouble) ADOLC_MATH_NSP::pow(vx,vy), pow(x,vy));
2623    condassign(a2, fabs(x), pow(x, vy), a1);
2624    condassign(ret, x, exp(y*log(x)),a2);
2625
2626    return ret;
2627}
2628
2629/*--------------------------------------------------------------------------*/
2630/* log base 10 of an adouble */
2631adub log10 ( const badouble& x ) {
2632    return log(x) / ADOLC_MATH_NSP::log(10.0);
2633}
2634
2635/*--------------------------------------------------------------------------*/
2636/* Hyperbolic Sine of an adouble */
2637/* 981119 olvo changed as J.M. Aparicio suggested */
2638adub sinh ( const badouble& x ) {
2639    if (x.getValue() < 0.0) {
2640        adouble temp = exp(x);
2641        return  0.5*(temp - 1.0/temp);
2642    } else {
2643        adouble temp = exp(-x);
2644        return 0.5*(1.0/temp - temp);
2645    }
2646}
2647
2648/*--------------------------------------------------------------------------*/
2649/* Hyperbolic Cosine of an adouble */
2650/* 981119 olvo changed as J.M. Aparicio suggested */
2651adub cosh ( const badouble& x ) {
2652    adouble temp = (x.getValue() < 0.0) ? exp(x) : exp(-x);
2653    return 0.5*(temp + 1.0/temp);
2654}
2655
2656/*--------------------------------------------------------------------------*/
2657/*
2658  Hyperbolic Tangent of an adouble value.
2659*/
2660/* 981119 olvo changed as J.M. Aparicio suggested */
2661adub tanh ( const badouble& x ) {
2662    if (x.getValue() < 0.0) {
2663        adouble temp = exp(2.0*x);
2664        return (temp - 1.0)/(temp + 1.0);
2665    } else {
2666        adouble temp = exp((-2.0)*x);
2667        return (1.0 - temp)/(temp + 1.0);
2668    }
2669}
2670
2671/*--------------------------------------------------------------------------*/
2672/* Ceiling function (NOTE: This function is nondifferentiable) */
2673adub ceil ( const badouble& x ) {
2674    ADOLC_OPENMP_THREAD_NUMBER;
2675    ADOLC_OPENMP_GET_THREAD_NUMBER;
2676    locint locat=next_loc();
2677
2678    double coval = ADOLC_MATH_NSP::ceil(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2679
2680    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(ceil_op,locat,coval,x.loc());
2681#if defined(ADOLC_TRACK_ACTIVITY)
2682      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2683#endif
2684        put_op(ceil_op);
2685        ADOLC_PUT_LOCINT(x.loc()); // = arg
2686        ADOLC_PUT_LOCINT(locat);      // = res
2687        ADOLC_PUT_VAL(coval);         // = coval
2688
2689        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2690        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2691            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2692#if defined(ADOLC_TRACK_ACTIVITY)
2693      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2694          if (coval == 0.0) {
2695              put_op(assign_d_zero);
2696              ADOLC_PUT_LOCINT(locat);
2697          } else if (coval == 1.0) {
2698              put_op(assign_d_one);
2699              ADOLC_PUT_LOCINT(locat);
2700          } else {
2701              put_op(assign_d);
2702              ADOLC_PUT_LOCINT(locat);
2703              ADOLC_PUT_VAL(coval);
2704          }
2705
2706          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2707          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2708              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2709      }
2710#endif
2711    }
2712
2713    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2714#if defined(ADOLC_TRACK_ACTIVITY)
2715    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2716#endif
2717    return locat;
2718}
2719
2720/*--------------------------------------------------------------------------*/
2721/* Floor function (NOTE: This function is nondifferentiable) */
2722adub floor ( const badouble& x ) {
2723    ADOLC_OPENMP_THREAD_NUMBER;
2724    ADOLC_OPENMP_GET_THREAD_NUMBER;
2725    locint locat=next_loc();
2726
2727    double coval =
2728        ADOLC_MATH_NSP::floor(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2729
2730    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(floor_op,locat,coval,x.loc());
2731#if defined(ADOLC_TRACK_ACTIVITY)
2732      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2733#endif
2734        put_op(floor_op);
2735        ADOLC_PUT_LOCINT(x.loc()); // = arg
2736        ADOLC_PUT_LOCINT(locat);      // = res
2737        ADOLC_PUT_VAL(coval);         // = coval
2738
2739        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2740        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2741            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2742#if defined(ADOLC_TRACK_ACTIVITY)
2743      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2744          if (coval == 0.0) {
2745              put_op(assign_d_zero);
2746              ADOLC_PUT_LOCINT(locat);
2747          } else if (coval == 1.0) {
2748              put_op(assign_d_one);
2749              ADOLC_PUT_LOCINT(locat);
2750          } else {
2751              put_op(assign_d);
2752              ADOLC_PUT_LOCINT(locat);
2753              ADOLC_PUT_VAL(coval);
2754          }
2755
2756          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2757          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2758              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2759      }
2760#endif
2761    }
2762
2763    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2764#if defined(ADOLC_TRACK_ACTIVITY)
2765    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2766#endif
2767    return locat;
2768}
2769
2770#ifdef ATRIG_ERF
2771/* NOTE: enable if your compiler knows asinh, acosh, atanh, erf */
2772
2773/*--------------------------------------------------------------------------*/
2774/* Asinh value -- really a quadrature */
2775adub asinh ( const badouble& x ) {
2776    ADOLC_OPENMP_THREAD_NUMBER;
2777    ADOLC_OPENMP_GET_THREAD_NUMBER;
2778    locint locat = next_loc();
2779    double coval = ADOLC_MATH_NSP_ERF::asinh(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2780
2781    adouble y = 1.0 / sqrt(1.0 + x*x);
2782
2783    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(asinh_op,locat,x.loc(),y.loc());
2784#if defined(ADOLC_TRACK_ACTIVITY)
2785      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) { // y will have same activity as x and can be considered as second input here
2786#endif
2787        put_op(asinh_op);
2788        ADOLC_PUT_LOCINT(x.loc()); // = arg1
2789        ADOLC_PUT_LOCINT(y.loc()); // = arg2
2790        ADOLC_PUT_LOCINT(locat);      // = res
2791
2792        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2793        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2794            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2795#if defined(ADOLC_TRACK_ACTIVITY)
2796      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2797          if (coval == 0.0) {
2798              put_op(assign_d_zero);
2799              ADOLC_PUT_LOCINT(locat);
2800          } else if (coval == 1.0) {
2801              put_op(assign_d_one);
2802              ADOLC_PUT_LOCINT(locat);
2803          } else {
2804              put_op(assign_d);
2805              ADOLC_PUT_LOCINT(locat);
2806              ADOLC_PUT_VAL(coval);
2807          }
2808
2809          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2810          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2811              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2812      }
2813#endif
2814    }
2815
2816    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2817#if defined(ADOLC_TRACK_ACTIVITY)
2818    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2819#endif
2820    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2821    return locat;
2822}
2823
2824/*--------------------------------------------------------------------------*/
2825/* Acosh value -- really a quadrature */
2826adub acosh ( const badouble& x ) {
2827    ADOLC_OPENMP_THREAD_NUMBER;
2828    ADOLC_OPENMP_GET_THREAD_NUMBER;
2829    locint locat = next_loc();
2830    double coval = ADOLC_MATH_NSP_ERF::acosh(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2831
2832    adouble y = 1.0 / sqrt(x*x-1.0);
2833
2834    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(acosh_op,locat,x.loc(),y.loc());
2835#if defined(ADOLC_TRACK_ACTIVITY)
2836      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) { // y will have same activity as x and can be considered as second input here
2837#endif
2838        put_op(acosh_op);
2839        ADOLC_PUT_LOCINT(x.loc()); // = arg1
2840        ADOLC_PUT_LOCINT(y.loc()); // = arg2
2841        ADOLC_PUT_LOCINT(locat);      // = res
2842
2843        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2844        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2845            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2846#if defined(ADOLC_TRACK_ACTIVITY)
2847      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2848          if (coval == 0.0) {
2849              put_op(assign_d_zero);
2850              ADOLC_PUT_LOCINT(locat);
2851          } else if (coval == 1.0) {
2852              put_op(assign_d_one);
2853              ADOLC_PUT_LOCINT(locat);
2854          } else {
2855              put_op(assign_d);
2856              ADOLC_PUT_LOCINT(locat);
2857              ADOLC_PUT_VAL(coval);
2858          }
2859
2860          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2861          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2862              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2863      }
2864#endif
2865    }
2866
2867    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2868#if defined(ADOLC_TRACK_ACTIVITY)
2869    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2870#endif
2871    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2872    return locat;
2873}
2874
2875/*--------------------------------------------------------------------------*/
2876/* Atanh value -- really a quadrature */
2877adub atanh ( const badouble& x ) {
2878    ADOLC_OPENMP_THREAD_NUMBER;
2879    ADOLC_OPENMP_GET_THREAD_NUMBER;
2880    locint locat = next_loc();
2881    double coval = ADOLC_MATH_NSP_ERF::atanh(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2882
2883    adouble y = 1.0 / (1.0 - x*x);
2884
2885    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(atanh_op,locat,x.loc(),y.loc());
2886#if defined(ADOLC_TRACK_ACTIVITY)
2887      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) { // y will have same activity as x and can be considered as second input here
2888#endif
2889        put_op(atanh_op);
2890        ADOLC_PUT_LOCINT(x.loc()); // = arg1
2891        ADOLC_PUT_LOCINT(y.loc()); // = arg2
2892        ADOLC_PUT_LOCINT(locat);      // = res
2893
2894        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2895        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2896            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2897#if defined(ADOLC_TRACK_ACTIVITY)
2898      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2899          if (coval == 0.0) {
2900              put_op(assign_d_zero);
2901              ADOLC_PUT_LOCINT(locat);
2902          } else if (coval == 1.0) {
2903              put_op(assign_d_one);
2904              ADOLC_PUT_LOCINT(locat);
2905          } else {
2906              put_op(assign_d);
2907              ADOLC_PUT_LOCINT(locat);
2908              ADOLC_PUT_VAL(coval);
2909          }
2910
2911          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2912          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2913              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2914      }
2915#endif
2916    }
2917
2918    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2919#if defined(ADOLC_TRACK_ACTIVITY)
2920    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2921#endif
2922    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2923    return locat;
2924}
2925
2926/*--------------------------------------------------------------------------*/
2927/*  The error function erf */
2928adub erf( const badouble& x ) {
2929    ADOLC_OPENMP_THREAD_NUMBER;
2930    ADOLC_OPENMP_GET_THREAD_NUMBER;
2931    locint locat = next_loc();
2932    double coval = ADOLC_MATH_NSP_ERF::erf(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2933
2934    adouble y = 2.0 /
2935        ADOLC_MATH_NSP_ERF::sqrt(ADOLC_MATH_NSP::acos(-1.0))*exp(-x*x);
2936
2937    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(erf_op,locat,x.loc(),y.loc());
2938#if defined(ADOLC_TRACK_ACTIVITY)
2939      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) { // y will have same activity as x and can be considered as second input here
2940#endif
2941        put_op(erf_op);
2942        ADOLC_PUT_LOCINT(x.loc()); // = arg1
2943        ADOLC_PUT_LOCINT(y.loc()); // = arg2
2944        ADOLC_PUT_LOCINT(locat);      // = res
2945
2946        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2947        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2948            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2949#if defined(ADOLC_TRACK_ACTIVITY)
2950      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2951          if (coval == 0.0) {
2952              put_op(assign_d_zero);
2953              ADOLC_PUT_LOCINT(locat);
2954          } else if (coval == 1.0) {
2955              put_op(assign_d_one);
2956              ADOLC_PUT_LOCINT(locat);
2957          } else {
2958              put_op(assign_d);
2959              ADOLC_PUT_LOCINT(locat);
2960              ADOLC_PUT_VAL(coval);
2961          }
2962
2963          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2964          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2965              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2966      }
2967#endif
2968    }
2969
2970    ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2971#if defined(ADOLC_TRACK_ACTIVITY)
2972    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2973#endif
2974    ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2975    return locat;
2976}
2977
2978#endif
2979
2980/*--------------------------------------------------------------------------*/
2981/* Fabs Function (NOTE: This function is also nondifferentiable at x=0) */
2982adub fabs ( const badouble& x ) {
2983    ADOLC_OPENMP_THREAD_NUMBER;
2984    ADOLC_OPENMP_GET_THREAD_NUMBER;
2985    locint locat = next_loc();
2986
2987    double coval = 1.0;
2988    double temp  = ADOLC_MATH_NSP::fabs(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2989    if (temp != ADOLC_GLOBAL_TAPE_VARS.store[x.loc()])
2990        coval = 0.0;
2991
2992    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { /*  write_args_d_a(abs_val,locat,coval,x.loc()); */
2993#if defined(ADOLC_TRACK_ACTIVITY)
2994      if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2995#endif
2996        put_op(abs_val);
2997        ADOLC_PUT_LOCINT(x.loc());   /* arg */
2998        ADOLC_PUT_LOCINT(locat);        /* res */
2999        ADOLC_PUT_VAL(coval);           /* coval */
3000
3001        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3002        if (ADOLC_CURRENT_TAPE_INFOS.stats[NO_MIN_MAX])
3003            ++ADOLC_CURRENT_TAPE_INFOS.numSwitches;
3004        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3005            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3006#if defined(ADOLC_TRACK_ACTIVITY)
3007      } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
3008          if (temp == 0.0) {
3009              put_op(assign_d_zero);
3010              ADOLC_PUT_LOCINT(locat);
3011          } else if (temp == 1.0) {
3012              put_op(assign_d_one);
3013              ADOLC_PUT_LOCINT(locat);
3014          } else {
3015              put_op(assign_d);
3016              ADOLC_PUT_LOCINT(locat);
3017              ADOLC_PUT_VAL(temp);
3018          }
3019
3020          ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3021          if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3022              ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3023      }
3024#endif
3025    }
3026    ADOLC_GLOBAL_TAPE_VARS.store[locat] = temp;
3027#if defined(ADOLC_TRACK_ACTIVITY)
3028    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
3029#endif
3030    return locat;
3031}
3032
3033/*--------------------------------------------------------------------------*/
3034/* max and min functions  (changed : 11/15/95) */
3035adub fmin ( const badouble& x, const badouble& y ) { /* olvo 980702 tested: return 0.5*fabs(x+y-fabs(x-y)); */
3036    ADOLC_OPENMP_THREAD_NUMBER;
3037    ADOLC_OPENMP_GET_THREAD_NUMBER;
3038    if (ADOLC_CURRENT_TAPE_INFOS.stats[NO_MIN_MAX])
3039        return ((x + y - fabs(x - y))/2.0);
3040
3041#if defined(ADOLC_TRACK_ACTIVITY)
3042  if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
3043    if ( ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()] && ! ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] ) {
3044        locint tmploc = x.loc();
3045        double temp = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3046        if (temp == 0.0) {
3047            put_op(assign_d_zero);
3048            ADOLC_PUT_LOCINT(tmploc);
3049        } else if (temp == 1.0) {
3050            put_op(assign_d_one);
3051            ADOLC_PUT_LOCINT(tmploc);
3052        } else {
3053            put_op(assign_d);
3054            ADOLC_PUT_LOCINT(tmploc);
3055            ADOLC_PUT_VAL(temp);
3056        }
3057
3058        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3059        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3060            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3061    }
3062    if ( ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] && ! ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()] ) {
3063        locint tmploc = y.loc();
3064        double temp = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3065        if (temp == 0.0) {
3066            put_op(assign_d_zero);
3067            ADOLC_PUT_LOCINT(tmploc);
3068        } else if (temp == 1.0) {
3069            put_op(assign_d_one);
3070            ADOLC_PUT_LOCINT(tmploc);
3071        } else {
3072            put_op(assign_d);
3073            ADOLC_PUT_LOCINT(tmploc);
3074            ADOLC_PUT_VAL(temp);
3075        }
3076
3077        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3078        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3079            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3080    }
3081  }
3082#endif
3083
3084    locint locat = next_loc();
3085    double coval, temp;
3086
3087    if (ADOLC_GLOBAL_TAPE_VARS.store[y.loc()] < ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]) {
3088        coval = 0.0;
3089        temp = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3090    } else {
3091        coval = 1.0;
3092        temp = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3093    }
3094
3095    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_min_op(x.loc(),y.loc(),locat,0.0);
3096#if defined(ADOLC_TRACK_ACTIVITY)
3097        if ( ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] || ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()] ) {
3098#endif
3099            put_op(min_op);
3100            ADOLC_PUT_LOCINT(x.loc()); // = arg1
3101            ADOLC_PUT_LOCINT(y.loc()); // = arg2
3102            ADOLC_PUT_LOCINT(locat);      // = res
3103            ADOLC_PUT_VAL(coval);           // = coval
3104
3105            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3106            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3107                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3108#if defined(ADOLC_TRACK_ACTIVITY)
3109          } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
3110              if (temp == 0.0) {
3111                  put_op(assign_d_zero);
3112                  ADOLC_PUT_LOCINT(locat);
3113              } else if (temp == 1.0) {
3114                  put_op(assign_d_one);
3115                  ADOLC_PUT_LOCINT(locat);
3116              } else {
3117                  put_op(assign_d);
3118                  ADOLC_PUT_LOCINT(locat);
3119                  ADOLC_PUT_VAL(temp);
3120              }
3121
3122              ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3123              if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3124                  ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3125          }
3126#endif
3127    }
3128
3129    ADOLC_GLOBAL_TAPE_VARS.store[locat]=temp;
3130#if defined(ADOLC_TRACK_ACTIVITY)
3131    ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] || ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]);
3132#endif
3133    return locat;
3134}
3135
3136/*--------------------------------------------------------------------------*/
3137/*21.8.96*/
3138adub fmin ( double d, const badouble& y ) {
3139    adouble x = d;
3140    return (fmin (x,y));
3141}
3142
3143/*--------------------------------------------------------------------------*/
3144adub fmin ( const badouble& x, double d ) {
3145    adouble y = d;
3146    return (fmin (x,y));
3147}
3148
3149/*--------------------------------------------------------------------------*/
3150adub fmax ( const badouble& x, const badouble& y ) {
3151    return (-fmin(-x,-y));
3152}
3153
3154/*--------------------------------------------------------------------------*/
3155/*21.8.96*/
3156adub fmax ( double d, const badouble& y ) {
3157    adouble x = d;
3158    return (-fmin(-x,-y));
3159}
3160
3161/*--------------------------------------------------------------------------*/
3162adub fmax ( const badouble& x, double d ) {
3163    adouble y = d;
3164    return (-fmin(-x,-y));
3165}
3166
3167/*--------------------------------------------------------------------------*/
3168/* Ldexp Function */
3169adub ldexp ( const badouble& x, int exp ) {
3170    return x*ldexp(1.0,exp);
3171}
3172/*--------------------------------------------------------------------------*/
3173/* frexp Function */
3174adub frexp ( const badouble& x, int* n) {
3175    double v = frexp(x.value(), n);
3176    adouble r = x - v;
3177    adouble z = r - double(*n);
3178    if (z == 0) {
3179        return (x - double(*n));
3180    } else {
3181        fprintf(stderr,"ADOL-C warning: std::frexp() returned inconsistent results\n");
3182        return (r - double(*n));
3183    }
3184}
3185
3186/*--------------------------------------------------------------------------*/
3187/* Macro for user defined quadratures, example myquad is below.*/
3188/* the forward sweep tests if the tape is executed exactly at  */
3189/* the same argument point otherwise it stops with a returnval */
3190#define extend_quad(func,integrand)\
3191adouble func ( const badouble& arg )\
3192{  adouble temp; \
3193    adouble val; \
3194    integrand; \
3195    ADOLC_OPENMP_THREAD_NUMBER; \
3196    ADOLC_OPENMP_GET_THREAD_NUMBER; \
3197    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) \
3198    { put_op(gen_quad); \
3199      ADOLC_PUT_LOCINT(arg.loc()); \
3200      ADOLC_PUT_LOCINT(val.loc()); \
3201      ADOLC_PUT_LOCINT(temp.loc()); \
3202      ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape; \
3203      if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors) \
3204        ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[temp.loc()]); \
3205    } \
3206    ADOLC_GLOBAL_TAPE_VARS.store[temp.loc()]=func(ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()]); \
3207    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) \
3208    { ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()]); \
3209      ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[temp.loc()]); \
3210    } \
3211    return temp; }
3212
3213double myquad(double& x) {
3214    double res;
3215    res = ADOLC_MATH_NSP::log(x);
3216    return res;
3217}
3218
3219/* This defines the natural logarithm as a quadrature */
3220
3221extend_quad(myquad,val = 1/arg)
3222
3223
3224/****************************************************************************/
3225/*                                                             CONDITIONALS */
3226/*--------------------------------------------------------------------------*/
3227#if defined(ADOLC_ADVANCED_BRANCHING)
3228adub operator != (const badouble& x, const badouble& y) {
3229    ADOLC_OPENMP_THREAD_NUMBER;
3230    ADOLC_OPENMP_GET_THREAD_NUMBER;
3231    double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3232    double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3233    double res = (double)(xval != yval);
3234    locint locat = next_loc();
3235    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
3236        put_op(neq_a_a);
3237        ADOLC_PUT_LOCINT(x.loc()); // arg
3238        ADOLC_PUT_LOCINT(y.loc()); // arg1
3239        ADOLC_PUT_VAL(res);           // check for branch switch
3240        ADOLC_PUT_LOCINT(locat);      // res
3241
3242        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3243        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3244            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3245    }
3246    ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
3247    return locat;
3248}
3249/*--------------------------------------------------------------------------*/
3250adub operator == (const badouble& x, const badouble& y) {
3251    ADOLC_OPENMP_THREAD_NUMBER;
3252    ADOLC_OPENMP_GET_THREAD_NUMBER;
3253    double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3254    double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3255    double res = (double)(xval == yval);
3256    locint locat = next_loc();
3257    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
3258        put_op(eq_a_a);
3259        ADOLC_PUT_LOCINT(x.loc()); // arg
3260        ADOLC_PUT_LOCINT(y.loc()); // arg1
3261        ADOLC_PUT_VAL(res);           // check for branch switch
3262        ADOLC_PUT_LOCINT(locat);      // res
3263
3264        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3265        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3266            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3267    }
3268    ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
3269    return locat;
3270}
3271/*--------------------------------------------------------------------------*/
3272adub operator <= (const badouble& x, const badouble& y) {
3273    ADOLC_OPENMP_THREAD_NUMBER;
3274    ADOLC_OPENMP_GET_THREAD_NUMBER;
3275    double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3276    double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3277    double res = (double)(xval <= yval);
3278    locint locat = next_loc();
3279    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
3280        put_op(le_a_a);
3281        ADOLC_PUT_LOCINT(x.loc()); // arg
3282        ADOLC_PUT_LOCINT(y.loc()); // arg1
3283        ADOLC_PUT_VAL(res);           // check for branch switch
3284        ADOLC_PUT_LOCINT(locat);      // res
3285
3286        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3287        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3288            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3289    }
3290    ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
3291    return locat;
3292}
3293/*--------------------------------------------------------------------------*/
3294adub operator >= (const badouble& x, const badouble& y) {
3295    ADOLC_OPENMP_THREAD_NUMBER;
3296    ADOLC_OPENMP_GET_THREAD_NUMBER;
3297    double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3298    double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3299    double res = (double)(xval >= yval);
3300    locint locat = next_loc();
3301    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
3302        put_op(ge_a_a);
3303        ADOLC_PUT_LOCINT(x.loc()); // arg
3304        ADOLC_PUT_LOCINT(y.loc()); // arg1
3305        ADOLC_PUT_VAL(res);           // check for branch switch
3306        ADOLC_PUT_LOCINT(locat);      // res
3307
3308        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3309        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3310            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3311    }
3312    ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
3313    return locat;
3314}
3315/*--------------------------------------------------------------------------*/
3316adub operator > (const badouble& x, const badouble& y) {
3317    ADOLC_OPENMP_THREAD_NUMBER;
3318    ADOLC_OPENMP_GET_THREAD_NUMBER;
3319    double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3320    double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3321    double res = (double)(xval > yval);
3322    locint locat = next_loc();
3323    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
3324        put_op(gt_a_a);
3325        ADOLC_PUT_LOCINT(x.loc()); // arg
3326        ADOLC_PUT_LOCINT(y.loc()); // arg1
3327        ADOLC_PUT_VAL(res);           // check for branch switch
3328        ADOLC_PUT_LOCINT(locat);      // res
3329
3330        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3331        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3332            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3333    }
3334    ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
3335    return locat;
3336}
3337/*--------------------------------------------------------------------------*/
3338adub operator < (const badouble& x, const badouble& y) {
3339    ADOLC_OPENMP_THREAD_NUMBER;
3340    ADOLC_OPENMP_GET_THREAD_NUMBER;
3341    double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3342    double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3343    double res = (double)(xval < yval);
3344    locint locat = next_loc();
3345    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
3346        put_op(lt_a_a);
3347        ADOLC_PUT_LOCINT(x.loc()); // arg
3348        ADOLC_PUT_LOCINT(y.loc()); // arg1
3349        ADOLC_PUT_VAL(res);           // check for branch switch
3350        ADOLC_PUT_LOCINT(locat);      // res
3351
3352        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3353        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3354            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3355    }
3356    ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
3357    return locat;
3358}
3359#endif
3360/*--------------------------------------------------------------------------*/
3361/*--------------------------------------------------------------------------*/
3362void condassign( adouble &res,         const badouble &cond,
3363                 const badouble &arg1, const badouble &arg2 ) {
3364    ADOLC_OPENMP_THREAD_NUMBER;
3365    ADOLC_OPENMP_GET_THREAD_NUMBER;
3366    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign(res.loc(),cond.loc(),arg1.loc(),
3367        //                   arg2.loc());
3368#if defined(ADOLC_TRACK_ACTIVITY)
3369      if ( ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3370        if (! ADOLC_GLOBAL_TAPE_VARS.actStore[arg1.loc()] ) {
3371            locint tmploc = arg1.loc();
3372            double temp = ADOLC_GLOBAL_TAPE_VARS.store[arg1.loc()];
3373            if (temp == 0.0) {
3374                put_op(assign_d_zero);
3375                ADOLC_PUT_LOCINT(tmploc);
3376            } else if (temp == 1.0) {
3377                put_op(assign_d_one);
3378                ADOLC_PUT_LOCINT(tmploc);
3379            } else {
3380                put_op(assign_d);
3381                ADOLC_PUT_LOCINT(tmploc);
3382                ADOLC_PUT_VAL(temp);
3383            }
3384
3385            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3386            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3387                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3388        }
3389        if (! ADOLC_GLOBAL_TAPE_VARS.actStore[arg2.loc()] ) {
3390            locint tmploc = arg2.loc();
3391            double temp = ADOLC_GLOBAL_TAPE_VARS.store[arg2.loc()];
3392            if (temp == 0.0) {
3393                put_op(assign_d_zero);
3394                ADOLC_PUT_LOCINT(tmploc);
3395            } else if (temp == 1.0) {
3396                put_op(assign_d_one);
3397                ADOLC_PUT_LOCINT(tmploc);
3398            } else {
3399                put_op(assign_d);
3400                ADOLC_PUT_LOCINT(tmploc);
3401                ADOLC_PUT_VAL(temp);
3402            }
3403
3404            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3405            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3406                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3407        }
3408#endif
3409        put_op(cond_assign);
3410        ADOLC_PUT_LOCINT(cond.loc()); // = arg
3411        ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()]);
3412        ADOLC_PUT_LOCINT(arg1.loc()); // = arg1
3413        ADOLC_PUT_LOCINT(arg2.loc()); // = arg2
3414        ADOLC_PUT_LOCINT(res.loc());  // = res
3415
3416        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3417        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3418            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3419#if defined(ADOLC_TRACK_ACTIVITY)
3420      } else {
3421          locint x_loc;
3422          if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3423              x_loc = arg1.loc();
3424          else
3425              x_loc = arg2.loc();
3426
3427          if (ADOLC_GLOBAL_TAPE_VARS.actStore[x_loc]) {
3428              put_op(assign_a);
3429              ADOLC_PUT_LOCINT(x_loc);    // = arg
3430              ADOLC_PUT_LOCINT(res.loc());   // = res
3431
3432              ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3433              if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3434                  ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3435          } else {
3436              if (ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()]) {
3437                  double coval = ADOLC_GLOBAL_TAPE_VARS.store[x_loc];
3438                  if (coval == 0) {
3439                      put_op(assign_d_zero);
3440                      ADOLC_PUT_LOCINT(res.loc());   // = res
3441                  } else if (coval == 1.0) {
3442                      put_op(assign_d_one);
3443                      ADOLC_PUT_LOCINT(res.loc()); // = res
3444                  } else {
3445                      put_op(assign_d);
3446                      ADOLC_PUT_LOCINT(res.loc()); // = res
3447                      ADOLC_PUT_VAL(coval);       // = coval
3448                  }
3449
3450                  ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3451                  if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3452                      ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3453              }
3454          }
3455      }
3456#endif
3457    }
3458
3459    if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3460        ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg1.loc()];
3461    else
3462        ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg2.loc()];
3463#if defined(ADOLC_TRACK_ACTIVITY)
3464    if ( ! ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3465        if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3466            ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] =  ADOLC_GLOBAL_TAPE_VARS.actStore[arg1.loc()];
3467        else
3468            ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] =  ADOLC_GLOBAL_TAPE_VARS.actStore[arg2.loc()];
3469    } else
3470        ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()];
3471#endif
3472}
3473
3474/*--------------------------------------------------------------------------*/
3475void condassign( adouble &res, const badouble &cond, const badouble &arg ) {
3476    ADOLC_OPENMP_THREAD_NUMBER;
3477    ADOLC_OPENMP_GET_THREAD_NUMBER;
3478    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign2(res.loc(),cond.loc(),arg.loc());
3479#if defined(ADOLC_TRACK_ACTIVITY)
3480      if ( ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3481        if (! ADOLC_GLOBAL_TAPE_VARS.actStore[arg.loc()] ) {
3482            locint tmploc = arg.loc();
3483            double temp = ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()];
3484            if (temp == 0.0) {
3485                put_op(assign_d_zero);
3486                ADOLC_PUT_LOCINT(tmploc);
3487            } else if (temp == 1.0) {
3488                put_op(assign_d_one);
3489                ADOLC_PUT_LOCINT(tmploc);
3490            } else {
3491                put_op(assign_d);
3492                ADOLC_PUT_LOCINT(tmploc);
3493                ADOLC_PUT_VAL(temp);
3494            }
3495
3496            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3497            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3498                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3499        }
3500#endif
3501        put_op(cond_assign_s);
3502        ADOLC_PUT_LOCINT(cond.loc()); // = arg
3503        ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()]);
3504        ADOLC_PUT_LOCINT(arg.loc());  // = arg1
3505        ADOLC_PUT_LOCINT(res.loc());  // = res
3506
3507        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3508        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3509            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3510#if defined(ADOLC_TRACK_ACTIVITY)
3511      } else {
3512          locint x_loc;
3513          if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0) {
3514              x_loc = arg.loc();
3515              if (ADOLC_GLOBAL_TAPE_VARS.actStore[x_loc]) {
3516                  put_op(assign_a);
3517                  ADOLC_PUT_LOCINT(x_loc);    // = arg
3518                  ADOLC_PUT_LOCINT(res.loc());   // = res
3519
3520                  ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3521                  if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3522                      ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3523              } else {
3524                  if (ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()]) {
3525                      double coval = ADOLC_GLOBAL_TAPE_VARS.store[x_loc];
3526                      if (coval == 0) {
3527                          put_op(assign_d_zero);
3528                          ADOLC_PUT_LOCINT(res.loc());   // = res
3529                      } else if (coval == 1.0) {
3530                          put_op(assign_d_one);
3531                          ADOLC_PUT_LOCINT(res.loc()); // = res
3532                      } else {
3533                          put_op(assign_d);
3534                          ADOLC_PUT_LOCINT(res.loc()); // = res
3535                          ADOLC_PUT_VAL(coval);       // = coval
3536                      }
3537
3538                      ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3539                      if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3540                          ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3541                  }
3542              }
3543          }
3544      }
3545#endif
3546    }
3547
3548    if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3549        ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()];
3550#if defined(ADOLC_TRACK_ACTIVITY)
3551    if ( ! ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3552        if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3553            ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] =  ADOLC_GLOBAL_TAPE_VARS.actStore[arg.loc()];
3554    } else
3555        ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()];
3556#endif
3557}
3558/*--------------------------------------------------------------------------*/
3559void condeqassign( adouble &res,         const badouble &cond,
3560                   const badouble &arg1, const badouble &arg2 ) {
3561    ADOLC_OPENMP_THREAD_NUMBER;
3562    ADOLC_OPENMP_GET_THREAD_NUMBER;
3563    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign(res.loc(),cond.loc(),arg1.loc(),
3564        //                   arg2.loc());
3565#if defined(ADOLC_TRACK_ACTIVITY)
3566      if ( ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3567        if (! ADOLC_GLOBAL_TAPE_VARS.actStore[arg1.loc()] ) {
3568            locint tmploc = arg1.loc();
3569            double temp = ADOLC_GLOBAL_TAPE_VARS.store[arg1.loc()];
3570            if (temp == 0.0) {
3571                put_op(assign_d_zero);
3572                ADOLC_PUT_LOCINT(tmploc);
3573            } else if (temp == 1.0) {
3574                put_op(assign_d_one);
3575                ADOLC_PUT_LOCINT(tmploc);
3576            } else {
3577                put_op(assign_d);
3578                ADOLC_PUT_LOCINT(tmploc);
3579                ADOLC_PUT_VAL(temp);
3580            }
3581
3582            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3583            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3584                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3585        }
3586        if (! ADOLC_GLOBAL_TAPE_VARS.actStore[arg2.loc()] ) {
3587            locint tmploc = arg2.loc();
3588            double temp = ADOLC_GLOBAL_TAPE_VARS.store[arg2.loc()];
3589            if (temp == 0.0) {
3590                put_op(assign_d_zero);
3591                ADOLC_PUT_LOCINT(tmploc);
3592            } else if (temp == 1.0) {
3593                put_op(assign_d_one);
3594                ADOLC_PUT_LOCINT(tmploc);
3595            } else {
3596                put_op(assign_d);
3597                ADOLC_PUT_LOCINT(tmploc);
3598                ADOLC_PUT_VAL(temp);
3599            }
3600
3601            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3602            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3603                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3604        }
3605#endif
3606        put_op(cond_eq_assign);
3607        ADOLC_PUT_LOCINT(cond.loc()); // = arg
3608        ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()]);
3609        ADOLC_PUT_LOCINT(arg1.loc()); // = arg1
3610        ADOLC_PUT_LOCINT(arg2.loc()); // = arg2
3611        ADOLC_PUT_LOCINT(res.loc());  // = res
3612
3613        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3614        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3615            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3616#if defined(ADOLC_TRACK_ACTIVITY)
3617      } else {
3618          locint x_loc;
3619          if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3620              x_loc = arg1.loc();
3621          else
3622              x_loc = arg2.loc();
3623
3624          if (ADOLC_GLOBAL_TAPE_VARS.actStore[x_loc]) {
3625              put_op(assign_a);
3626              ADOLC_PUT_LOCINT(x_loc);    // = arg
3627              ADOLC_PUT_LOCINT(res.loc());   // = res
3628
3629              ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3630              if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3631                  ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3632          } else {
3633              if (ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()]) {
3634                  double coval = ADOLC_GLOBAL_TAPE_VARS.store[x_loc];
3635                  if (coval == 0) {
3636                      put_op(assign_d_zero);
3637                      ADOLC_PUT_LOCINT(res.loc());   // = res
3638                  } else if (coval == 1.0) {
3639                      put_op(assign_d_one);
3640                      ADOLC_PUT_LOCINT(res.loc()); // = res
3641                  } else {
3642                      put_op(assign_d);
3643                      ADOLC_PUT_LOCINT(res.loc()); // = res
3644                      ADOLC_PUT_VAL(coval);       // = coval
3645                  }
3646
3647                  ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3648                  if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3649                      ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3650              }
3651          }
3652      }
3653#endif
3654    }
3655
3656    if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] >= 0)
3657        ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg1.loc()];
3658    else
3659        ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg2.loc()];
3660#if defined(ADOLC_TRACK_ACTIVITY)
3661    if ( ! ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3662        if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3663            ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] =  ADOLC_GLOBAL_TAPE_VARS.actStore[arg1.loc()];
3664        else
3665            ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] =  ADOLC_GLOBAL_TAPE_VARS.actStore[arg2.loc()];
3666    } else
3667        ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()];
3668#endif
3669}
3670
3671/*--------------------------------------------------------------------------*/
3672void condeqassign( adouble &res, const badouble &cond, const badouble &arg ) {
3673    ADOLC_OPENMP_THREAD_NUMBER;
3674    ADOLC_OPENMP_GET_THREAD_NUMBER;
3675    if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign2(res.loc(),cond.loc(),arg.loc());
3676#if defined(ADOLC_TRACK_ACTIVITY)
3677      if ( ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3678        if (! ADOLC_GLOBAL_TAPE_VARS.actStore[arg.loc()] ) {
3679            locint tmploc = arg.loc();
3680            double temp = ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()];
3681            if (temp == 0.0) {
3682                put_op(assign_d_zero);
3683                ADOLC_PUT_LOCINT(tmploc);
3684            } else if (temp == 1.0) {
3685                put_op(assign_d_one);
3686                ADOLC_PUT_LOCINT(tmploc);
3687            } else {
3688                put_op(assign_d);
3689                ADOLC_PUT_LOCINT(tmploc);
3690                ADOLC_PUT_VAL(temp);
3691            }
3692
3693            ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3694            if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3695                ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3696        }
3697#endif
3698        put_op(cond_eq_assign_s);
3699        ADOLC_PUT_LOCINT(cond.loc()); // = arg
3700        ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()]);
3701        ADOLC_PUT_LOCINT(arg.loc());  // = arg1
3702        ADOLC_PUT_LOCINT(res.loc());  // = res
3703
3704        ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3705        if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3706            ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3707#if defined(ADOLC_TRACK_ACTIVITY)
3708      } else {
3709          locint x_loc;
3710          if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0) {
3711              x_loc = arg.loc();
3712              if (ADOLC_GLOBAL_TAPE_VARS.actStore[x_loc]) {
3713                  put_op(assign_a);
3714                  ADOLC_PUT_LOCINT(x_loc);    // = arg
3715                  ADOLC_PUT_LOCINT(res.loc());   // = res
3716
3717                  ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3718                  if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3719                      ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3720              } else {
3721                  if (ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()]) {
3722                      double coval = ADOLC_GLOBAL_TAPE_VARS.store[x_loc];
3723                      if (coval == 0) {
3724                          put_op(assign_d_zero);
3725                          ADOLC_PUT_LOCINT(res.loc());   // = res
3726                      } else if (coval == 1.0) {
3727                          put_op(assign_d_one);
3728                          ADOLC_PUT_LOCINT(res.loc()); // = res
3729                      } else {
3730                          put_op(assign_d);
3731                          ADOLC_PUT_LOCINT(res.loc()); // = res
3732                          ADOLC_PUT_VAL(coval);       // = coval
3733                      }
3734
3735                      ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3736                      if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3737                          ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3738                  }
3739              }
3740          }
3741      }
3742#endif
3743    }
3744
3745    if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] >= 0)
3746        ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()];
3747#if defined(ADOLC_TRACK_ACTIVITY)
3748    if ( ! ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3749        if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3750            ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] =  ADOLC_GLOBAL_TAPE_VARS.actStore[arg.loc()];
3751    } else
3752        ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()];
3753#endif
3754}
3755
3756/****************************************************************************/
3757/*                                                                THAT'S ALL*/
Note: See TracBrowser for help on using the repository browser.