1 /*----------------------------------------------------------------------------
2 ADOL-C -- Automatic Differentiation by Overloading in C++
3 File: adouble.cpp
4 Revision: $Id: adouble.cpp 775 2020-01-25 14:09:12Z mbanovic $
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
29 using namespace std;
30
31 /****************************************************************************/
32 /* HELPFUL FUNCTIONS */
33
34 /*--------------------------------------------------------------------------*/
condassign(double & res,const double & cond,const double & arg1,const double & arg2)35 void condassign( double &res, const double &cond,
36 const double &arg1, const double &arg2 ) {
37 res = cond > 0 ? arg1 : arg2;
38 }
39
40 /*--------------------------------------------------------------------------*/
condassign(double & res,const double & cond,const double & arg)41 void condassign( double &res, const double &cond,
42 const double &arg) {
43 res = cond > 0 ? arg : res;
44 }
45
46 /*--------------------------------------------------------------------------*/
condeqassign(double & res,const double & cond,const double & arg1,const double & arg2)47 void condeqassign( double &res, const double &cond,
48 const double &arg1, const double &arg2 ) {
49 res = cond >= 0 ? arg1 : arg2;
50 }
51
52 /*--------------------------------------------------------------------------*/
condeqassign(double & res,const double & cond,const double & arg)53 void 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)
initInternal(void)66 void 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
initInternal(void)97 void adouble::initInternal(void) {}
98 #endif
99
100 /*--------------------------------------------------------------------------*/
adouble()101 adouble::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 /*--------------------------------------------------------------------------*/
adouble(double coval)131 adouble::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 /*--------------------------------------------------------------------------*/
adouble(const adouble & a)169 adouble::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 /*--------------------------------------------------------------------------*/
adouble(const adub & a)220 adouble::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 /*--------------------------------------------------------------------------*/
~adouble()280 adouble::~adouble() {
281 #ifdef adolc_overwrite
282 if (isInit) {
283 free_loc(location);
284 }
285 #endif
286 }
287
288 /*--------------------------------------------------------------------------*/
~adub()289 adub::~adub() {
290 #ifdef adolc_overwrite
291 if (isInit) {
292 free_loc(location);
293 }
294 #endif
295 }
296
297
298 /****************************************************************************/
299 /* HELPERS */
300
adubp_from_adub(const adub & a)301 adub* 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 /*--------------------------------------------------------------------------*/
getValue() const313 double badouble::getValue() const {
314 ADOLC_OPENMP_THREAD_NUMBER;
315 ADOLC_OPENMP_GET_THREAD_NUMBER;
316 return ADOLC_GLOBAL_TAPE_VARS.store[loc()];
317 }
318
operator double const&() const319 badouble::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
operator double&&()325 badouble::operator double&&() {
326 ADOLC_OPENMP_THREAD_NUMBER;
327 ADOLC_OPENMP_GET_THREAD_NUMBER;
328 return (double&&)ADOLC_GLOBAL_TAPE_VARS.store[loc()];
329 }
330
operator double()331 badouble::operator double() {
332 ADOLC_OPENMP_THREAD_NUMBER;
333 ADOLC_OPENMP_GET_THREAD_NUMBER;
334 return ADOLC_GLOBAL_TAPE_VARS.store[loc()];
335 }
336
setValue(const double x)337 void 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. */
operator =(double coval)348 badouble& 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. */
operator =(double coval)385 adouble& 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. */
operator <<=(double coval)393 badouble& 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
declareIndependent()414 void 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. */
operator >>=(double & coval)435 badouble& 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
declareDependent()471 void 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. */
operator =(const badouble & x)506 badouble& 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. */
operator =(const badouble & x)557 adouble& 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. */
operator =(const adouble & x)565 adouble& 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 */
operator =(const adub & a)574 badouble& 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 */
operator =(const adub & a)644 adouble& 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 */
operator <<(std::ostream & out,const badouble & y)656 std::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 */
operator >>(std::istream & in,const badouble & y)664 std::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 */
operator ++(int)706 adub 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 */
operator --(int)772 adub 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 */
operator ++()837 badouble& 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 */
operator --()861 badouble& 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 */
operator +=(double coval)888 badouble& 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 */
operator -=(double coval)914 badouble& 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 */
operator +=(const badouble & y)939 badouble& 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; */
operator +=(const adub & a)996 badouble& 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 */
operator -=(const badouble & y)1073 badouble& 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; */
operator -=(const adub & a)1130 badouble& 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 */
operator *=(double coval)1207 badouble& 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*/
operator *=(const badouble & y)1232 badouble& 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 /*--------------------------------------------------------------------------*/
operator /=(double y)1290 badouble& badouble::operator /= (double y) {
1291 *this = *this/y;
1292 return *this;
1293 }
1294
1295 /*--------------------------------------------------------------------------*/
operator /=(const badouble & y)1296 badouble& 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 (!=) */
operator !=(const badouble & v,double coval)1305 bool 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 (==) */
operator ==(const badouble & v,double coval)1327 bool 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 (<=) */
operator <=(const badouble & v,double coval)1349 bool 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 bool 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 (>=) */
operator >=(const badouble & v,double coval)1372 bool 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 bool 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 (>) */
operator >(const badouble & v,double coval)1395 bool 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 bool 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 (<) */
operator <(const badouble & v,double coval)1418 bool 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 bool 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 */
operator +(const badouble & x)1446 adub 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 */
operator -(const badouble & x)1493 adub 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 */
operator +(const badouble & x,const badouble & y)1547 adub 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 */
operator +(double coval,const badouble & y)1620 adub 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 */
operator -(const badouble & x,const badouble & y)1676 adub 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 */
operator -(double coval,const badouble & y)1751 adub 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 */
operator *(const badouble & x,const badouble & y)1807 adub 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 */
operator *(double coval,const badouble & y)1886 adub 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 */
operator /(const badouble & x,const badouble & y)1945 adub 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 */
operator /(double coval,const badouble & y)2023 adub 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 */
exp(const badouble & x)2075 adub 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 */
log(const badouble & x)2124 adub 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 */
sqrt(const badouble & x)2172 adub 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 /* Compute cbrt of adouble */
cbrt(const badouble & x)2220 adub cbrt ( const badouble& x ) {
2221 ADOLC_OPENMP_THREAD_NUMBER;
2222 ADOLC_OPENMP_GET_THREAD_NUMBER;
2223 locint locat = next_loc();
2224 double coval = ADOLC_MATH_NSP::cbrt(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2225
2226 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
2227 #if defined(ADOLC_TRACK_ACTIVITY)
2228 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2229 #endif
2230 put_op(cbrt_op);
2231 ADOLC_PUT_LOCINT(x.loc()); // = arg
2232 ADOLC_PUT_LOCINT(locat); // = res
2233
2234 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2235 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2236 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2237 #if defined(ADOLC_TRACK_ACTIVITY)
2238 } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2239 if (coval == 0.0) {
2240 put_op(assign_d_zero);
2241 ADOLC_PUT_LOCINT(locat);
2242 } else if (coval == 1.0) {
2243 put_op(assign_d_one);
2244 ADOLC_PUT_LOCINT(locat);
2245 } else {
2246 put_op(assign_d);
2247 ADOLC_PUT_LOCINT(locat);
2248 ADOLC_PUT_VAL(coval);
2249 }
2250
2251 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2252 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2253 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2254 }
2255 #endif
2256 }
2257
2258 ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2259 #if defined(ADOLC_TRACK_ACTIVITY)
2260 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2261 #endif
2262 ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2263 return locat;
2264 }
2265
2266 /****************************************************************************/
2267 /* QUAD OPERATIONS */
2268
2269 /*--------------------------------------------------------------------------*/
2270 /* Compute sin of adouble
2271 !!! Sin and Cos are always evaluated together
2272 */
sin(const badouble & x)2273 adub sin ( const badouble& x ) {
2274 ADOLC_OPENMP_THREAD_NUMBER;
2275 ADOLC_OPENMP_GET_THREAD_NUMBER;
2276 locint locat = next_loc();
2277 double coval1 = ADOLC_MATH_NSP::sin(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2278 double coval2 = ADOLC_MATH_NSP::cos(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2279
2280 adouble y;
2281
2282 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(sin_op,locat,x.loc(),y.loc());
2283 #if defined(ADOLC_TRACK_ACTIVITY)
2284 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2285 #endif
2286 put_op(sin_op);
2287 ADOLC_PUT_LOCINT(x.loc()); // = arg1
2288 ADOLC_PUT_LOCINT(y.loc()); // = arg2
2289 ADOLC_PUT_LOCINT(locat); // = res
2290
2291 ADOLC_CURRENT_TAPE_INFOS.numTays_Tape += 2;
2292 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors) { /* olvo 980921 changed order */
2293 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.loc()]);
2294 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2295 }
2296 #if defined(ADOLC_TRACK_ACTIVITY)
2297 } else {
2298 if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2299 if (coval1 == 0.0) {
2300 put_op(assign_d_zero);
2301 ADOLC_PUT_LOCINT(locat);
2302 } else if (coval1 == 1.0) {
2303 put_op(assign_d_one);
2304 ADOLC_PUT_LOCINT(locat);
2305 } else {
2306 put_op(assign_d);
2307 ADOLC_PUT_LOCINT(locat);
2308 ADOLC_PUT_VAL(coval1);
2309 }
2310
2311 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2312 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2313 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2314 }
2315 if (ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
2316 if (coval2 == 0.0) {
2317 put_op(assign_d_zero);
2318 ADOLC_PUT_LOCINT(y.loc());
2319 } else if (coval1 == 1.0) {
2320 put_op(assign_d_one);
2321 ADOLC_PUT_LOCINT(y.loc());
2322 } else {
2323 put_op(assign_d);
2324 ADOLC_PUT_LOCINT(y.loc());
2325 ADOLC_PUT_VAL(coval2);
2326 }
2327
2328 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2329 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2330 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.loc()]);
2331 }
2332 }
2333 #endif
2334 }
2335
2336 ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval1;
2337 ADOLC_GLOBAL_TAPE_VARS.store[y.loc()] = coval2;
2338 #if defined(ADOLC_TRACK_ACTIVITY)
2339 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2340 #endif
2341
2342 ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2343 return locat;
2344 }
2345
2346 /*--------------------------------------------------------------------------*/
2347 /* Compute cos of adouble */
cos(const badouble & x)2348 adub cos ( const badouble& x ) {
2349 ADOLC_OPENMP_THREAD_NUMBER;
2350 ADOLC_OPENMP_GET_THREAD_NUMBER;
2351 locint locat = next_loc();
2352 double coval1 = ADOLC_MATH_NSP::cos(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2353 double coval2 = ADOLC_MATH_NSP::sin(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2354
2355 adouble y;
2356
2357 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(cos_op, locat,x.loc(),y.loc());
2358 #if defined(ADOLC_TRACK_ACTIVITY)
2359 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2360 #endif
2361 put_op(cos_op);
2362 ADOLC_PUT_LOCINT(x.loc()); // = arg1
2363 ADOLC_PUT_LOCINT(y.loc()); // = arg2
2364 ADOLC_PUT_LOCINT(locat); // = res
2365
2366 ADOLC_CURRENT_TAPE_INFOS.numTays_Tape += 2;
2367 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors) { /* olvo 980921 changed order */
2368 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.loc()]);
2369 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2370 }
2371 #if defined(ADOLC_TRACK_ACTIVITY)
2372 } else {
2373 if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2374 if (coval1 == 0.0) {
2375 put_op(assign_d_zero);
2376 ADOLC_PUT_LOCINT(locat);
2377 } else if (coval1 == 1.0) {
2378 put_op(assign_d_one);
2379 ADOLC_PUT_LOCINT(locat);
2380 } else {
2381 put_op(assign_d);
2382 ADOLC_PUT_LOCINT(locat);
2383 ADOLC_PUT_VAL(coval1);
2384 }
2385
2386 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2387 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2388 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2389 }
2390 if (ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]) {
2391 if (coval2 == 0.0) {
2392 put_op(assign_d_zero);
2393 ADOLC_PUT_LOCINT(y.loc());
2394 } else if (coval1 == 1.0) {
2395 put_op(assign_d_one);
2396 ADOLC_PUT_LOCINT(y.loc());
2397 } else {
2398 put_op(assign_d);
2399 ADOLC_PUT_LOCINT(y.loc());
2400 ADOLC_PUT_VAL(coval2);
2401 }
2402
2403 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2404 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2405 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[y.loc()]);
2406 }
2407 }
2408 #endif
2409 }
2410
2411 ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval1;
2412 ADOLC_GLOBAL_TAPE_VARS.store[y.loc()] = coval2;
2413 #if defined(ADOLC_TRACK_ACTIVITY)
2414 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2415 #endif
2416
2417 ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2418 return locat;
2419 }
2420
2421 /*--------------------------------------------------------------------------*/
2422 /* Compute tan of adouble */
tan(const badouble & x)2423 adub tan ( const badouble& x ) {
2424 return sin(x) / cos(x);
2425 }
2426
2427 /*--------------------------------------------------------------------------*/
2428 /* Asin value -- really a quadrature */
asin(const badouble & x)2429 adub asin ( const badouble& x ) {
2430 ADOLC_OPENMP_THREAD_NUMBER;
2431 ADOLC_OPENMP_GET_THREAD_NUMBER;
2432 locint locat = next_loc();
2433 double coval = ADOLC_MATH_NSP::asin(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2434
2435 adouble y = 1.0 / sqrt(1.0 - x*x);
2436
2437 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(asin_op,locat,x.loc(),y.loc());
2438 #if defined(ADOLC_TRACK_ACTIVITY)
2439 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) { // y will have same activity as x and can be considered as second input here
2440 #endif
2441 put_op(asin_op);
2442 ADOLC_PUT_LOCINT(x.loc()); // = arg1
2443 ADOLC_PUT_LOCINT(y.loc()); // = arg2
2444 ADOLC_PUT_LOCINT(locat); // = res
2445
2446 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2447 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2448 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2449 #if defined(ADOLC_TRACK_ACTIVITY)
2450 } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2451 if (coval == 0.0) {
2452 put_op(assign_d_zero);
2453 ADOLC_PUT_LOCINT(locat);
2454 } else if (coval == 1.0) {
2455 put_op(assign_d_one);
2456 ADOLC_PUT_LOCINT(locat);
2457 } else {
2458 put_op(assign_d);
2459 ADOLC_PUT_LOCINT(locat);
2460 ADOLC_PUT_VAL(coval);
2461 }
2462
2463 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2464 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2465 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2466 }
2467 #endif
2468 }
2469
2470 ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2471 #if defined(ADOLC_TRACK_ACTIVITY)
2472 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2473 #endif
2474 ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2475 return locat;
2476 }
2477
2478 /*--------------------------------------------------------------------------*/
2479 /* Acos value -- really a quadrature */
acos(const badouble & x)2480 adub acos ( const badouble& x ) {
2481 ADOLC_OPENMP_THREAD_NUMBER;
2482 ADOLC_OPENMP_GET_THREAD_NUMBER;
2483 locint locat = next_loc();
2484 double coval = ADOLC_MATH_NSP::acos(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2485
2486 adouble y = -1.0 / sqrt(1.0 - x*x);
2487
2488 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(acos_op,locat,x.loc(),y.loc());
2489 #if defined(ADOLC_TRACK_ACTIVITY)
2490 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) { // y will have same activity as x and can be considered as second input here
2491 #endif
2492 put_op(acos_op);
2493 ADOLC_PUT_LOCINT(x.loc()); // = arg1
2494 ADOLC_PUT_LOCINT(y.loc()); // = arg2
2495 ADOLC_PUT_LOCINT(locat); // = res
2496
2497 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2498 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2499 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2500 #if defined(ADOLC_TRACK_ACTIVITY)
2501 } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2502 if (coval == 0.0) {
2503 put_op(assign_d_zero);
2504 ADOLC_PUT_LOCINT(locat);
2505 } else if (coval == 1.0) {
2506 put_op(assign_d_one);
2507 ADOLC_PUT_LOCINT(locat);
2508 } else {
2509 put_op(assign_d);
2510 ADOLC_PUT_LOCINT(locat);
2511 ADOLC_PUT_VAL(coval);
2512 }
2513
2514 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2515 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2516 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2517 }
2518 #endif
2519 }
2520
2521 ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2522 #if defined(ADOLC_TRACK_ACTIVITY)
2523 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2524 #endif
2525 ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2526 return locat;
2527 }
2528
2529 /*--------------------------------------------------------------------------*/
2530 /* Atan value -- really a quadrature */
atan(const badouble & x)2531 adub atan ( const badouble& x ) {
2532 ADOLC_OPENMP_THREAD_NUMBER;
2533 ADOLC_OPENMP_GET_THREAD_NUMBER;
2534 locint locat = next_loc();
2535 double coval = ADOLC_MATH_NSP::atan(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2536
2537 adouble y = 1.0 / (1.0 + x*x);
2538
2539 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(atan_op,locat,x.loc(),y.loc());
2540 #if defined(ADOLC_TRACK_ACTIVITY)
2541 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) { // y will have same activity as x and can be considered as second input here
2542 #endif
2543 put_op(atan_op);
2544 ADOLC_PUT_LOCINT(x.loc()); // = arg1
2545 ADOLC_PUT_LOCINT(y.loc()); // = arg2
2546 ADOLC_PUT_LOCINT(locat); // = res
2547
2548 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2549 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2550 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2551 #if defined(ADOLC_TRACK_ACTIVITY)
2552 } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2553 if (coval == 0.0) {
2554 put_op(assign_d_zero);
2555 ADOLC_PUT_LOCINT(locat);
2556 } else if (coval == 1.0) {
2557 put_op(assign_d_one);
2558 ADOLC_PUT_LOCINT(locat);
2559 } else {
2560 put_op(assign_d);
2561 ADOLC_PUT_LOCINT(locat);
2562 ADOLC_PUT_VAL(coval);
2563 }
2564
2565 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2566 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2567 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2568 }
2569 #endif
2570 }
2571
2572 ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2573 #if defined(ADOLC_TRACK_ACTIVITY)
2574 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2575 #endif
2576 ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2577 return locat;
2578 }
2579
2580 /*--------------------------------------------------------------------------*/
atan2(const badouble & y,const badouble & x)2581 adouble atan2( const badouble& y, const badouble& x) {
2582 adouble a1, a2, ret, sy;
2583 const double pihalf = ADOLC_MATH_NSP::asin(1.0);
2584 /* y+0.0 is a hack since condassign is currently not defined for
2585 badoubles */
2586 condassign( sy, y, (adouble)1.0 , (adouble)-1.0 );
2587 condassign( a1, x, atan(y/x), atan(y/x)+sy*2*pihalf);
2588 condassign( a2, fabs(y), sy*pihalf-atan(x/y), (adouble) 0.0 );
2589 condassign( ret, fabs(x) - fabs(y), a1, a2 );
2590 return ret;
2591 }
2592
2593 /*--------------------------------------------------------------------------*/
2594 /* power value -- adouble ^ floating point */
pow(const badouble & x,double coval)2595 adub pow ( const badouble& x, double coval ) {
2596 ADOLC_OPENMP_THREAD_NUMBER;
2597 ADOLC_OPENMP_GET_THREAD_NUMBER;
2598 locint locat = next_loc();
2599 double coval2 = ADOLC_MATH_NSP::pow(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()],coval);
2600
2601 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(pow_op,locat,cocval,x.loc());
2602 #if defined(ADOLC_TRACK_ACTIVITY)
2603 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2604 #endif
2605 put_op(pow_op);
2606 ADOLC_PUT_LOCINT(x.loc()); // = arg
2607 ADOLC_PUT_LOCINT(locat); // = res
2608 ADOLC_PUT_VAL(coval); // = coval
2609
2610 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2611 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2612 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2613 #if defined(ADOLC_TRACK_ACTIVITY)
2614 } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2615 if (coval2 == 0.0) {
2616 put_op(assign_d_zero);
2617 ADOLC_PUT_LOCINT(locat);
2618 } else if (coval2 == 1.0) {
2619 put_op(assign_d_one);
2620 ADOLC_PUT_LOCINT(locat);
2621 } else {
2622 put_op(assign_d);
2623 ADOLC_PUT_LOCINT(locat);
2624 ADOLC_PUT_VAL(coval2);
2625 }
2626
2627 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2628 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2629 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2630 }
2631 #endif
2632 }
2633
2634 ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval2;
2635 #if defined(ADOLC_TRACK_ACTIVITY)
2636 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2637 #endif
2638 ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2639 return locat;
2640 }
2641
2642 /*--------------------------------------------------------------------------*/
2643 /* power value --- floating point ^ adouble */
pow(double coval,const badouble & y)2644 adouble pow ( double coval, const badouble& y ) {
2645 adouble ret;
2646
2647 if (coval <= 0) {
2648 fprintf(DIAG_OUT,"\nADOL-C message: exponent at zero/negative constant basis deactivated\n");
2649 }
2650
2651 condassign (ret, (adouble) coval, exp(y*ADOLC_MATH_NSP::log(coval)),
2652 (adouble) ADOLC_MATH_NSP::pow(coval,y.getValue()) );
2653
2654 return ret;
2655 }
2656
2657 /*--------------------------------------------------------------------------*/
2658 /* power value --- adouble ^ adouble */
pow(const badouble & x,const badouble & y)2659 adouble pow ( const badouble& x, const badouble& y) {
2660 adouble a1, a2, ret;
2661 double vx = x.getValue();
2662 double vy = y.getValue();
2663
2664 if (!(vx > 0)) {
2665 if (vx < 0 || vy >= 0)
2666 fprintf(DIAG_OUT,"\nADOL-C message: exponent of zero/negative basis deactivated\n");
2667 else
2668 fprintf(DIAG_OUT,"\nADOL-C message: negative exponent and zero basis deactivated\n");
2669 }
2670 condassign(a1, -y, (adouble) ADOLC_MATH_NSP::pow(vx,vy), pow(x,vy));
2671 condassign(a2, fabs(x), pow(x, vy), a1);
2672 condassign(ret, x, exp(y*log(x)),a2);
2673
2674 return ret;
2675 }
2676
2677 /*--------------------------------------------------------------------------*/
2678 /* log base 10 of an adouble */
log10(const badouble & x)2679 adub log10 ( const badouble& x ) {
2680 return log(x) / ADOLC_MATH_NSP::log(10.0);
2681 }
2682
2683 /*--------------------------------------------------------------------------*/
2684 /* Hyperbolic Sine of an adouble */
2685 /* 981119 olvo changed as J.M. Aparicio suggested */
sinh(const badouble & x)2686 adub sinh ( const badouble& x ) {
2687 if (x.getValue() < 0.0) {
2688 adouble temp = exp(x);
2689 return 0.5*(temp - 1.0/temp);
2690 } else {
2691 adouble temp = exp(-x);
2692 return 0.5*(1.0/temp - temp);
2693 }
2694 }
2695
2696 /*--------------------------------------------------------------------------*/
2697 /* Hyperbolic Cosine of an adouble */
2698 /* 981119 olvo changed as J.M. Aparicio suggested */
cosh(const badouble & x)2699 adub cosh ( const badouble& x ) {
2700 adouble temp = (x.getValue() < 0.0) ? exp(x) : exp(-x);
2701 return 0.5*(temp + 1.0/temp);
2702 }
2703
2704 /*--------------------------------------------------------------------------*/
2705 /*
2706 Hyperbolic Tangent of an adouble value.
2707 */
2708 /* 981119 olvo changed as J.M. Aparicio suggested */
tanh(const badouble & x)2709 adub tanh ( const badouble& x ) {
2710 if (x.getValue() < 0.0) {
2711 adouble temp = exp(2.0*x);
2712 return (temp - 1.0)/(temp + 1.0);
2713 } else {
2714 adouble temp = exp((-2.0)*x);
2715 return (1.0 - temp)/(temp + 1.0);
2716 }
2717 }
2718
2719 /*--------------------------------------------------------------------------*/
2720 /* Ceiling function (NOTE: This function is nondifferentiable) */
ceil(const badouble & x)2721 adub ceil ( const badouble& x ) {
2722 ADOLC_OPENMP_THREAD_NUMBER;
2723 ADOLC_OPENMP_GET_THREAD_NUMBER;
2724 locint locat=next_loc();
2725
2726 double coval = ADOLC_MATH_NSP::ceil(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2727
2728 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(ceil_op,locat,coval,x.loc());
2729 #if defined(ADOLC_TRACK_ACTIVITY)
2730 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2731 #endif
2732 put_op(ceil_op);
2733 ADOLC_PUT_LOCINT(x.loc()); // = arg
2734 ADOLC_PUT_LOCINT(locat); // = res
2735 ADOLC_PUT_VAL(coval); // = coval
2736
2737 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2738 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2739 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2740 #if defined(ADOLC_TRACK_ACTIVITY)
2741 } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2742 if (coval == 0.0) {
2743 put_op(assign_d_zero);
2744 ADOLC_PUT_LOCINT(locat);
2745 } else if (coval == 1.0) {
2746 put_op(assign_d_one);
2747 ADOLC_PUT_LOCINT(locat);
2748 } else {
2749 put_op(assign_d);
2750 ADOLC_PUT_LOCINT(locat);
2751 ADOLC_PUT_VAL(coval);
2752 }
2753
2754 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2755 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2756 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2757 }
2758 #endif
2759 }
2760
2761 ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2762 #if defined(ADOLC_TRACK_ACTIVITY)
2763 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2764 #endif
2765 return locat;
2766 }
2767
2768 /*--------------------------------------------------------------------------*/
2769 /* Floor function (NOTE: This function is nondifferentiable) */
floor(const badouble & x)2770 adub floor ( const badouble& x ) {
2771 ADOLC_OPENMP_THREAD_NUMBER;
2772 ADOLC_OPENMP_GET_THREAD_NUMBER;
2773 locint locat=next_loc();
2774
2775 double coval =
2776 ADOLC_MATH_NSP::floor(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2777
2778 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(floor_op,locat,coval,x.loc());
2779 #if defined(ADOLC_TRACK_ACTIVITY)
2780 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
2781 #endif
2782 put_op(floor_op);
2783 ADOLC_PUT_LOCINT(x.loc()); // = arg
2784 ADOLC_PUT_LOCINT(locat); // = res
2785 ADOLC_PUT_VAL(coval); // = coval
2786
2787 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2788 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2789 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2790 #if defined(ADOLC_TRACK_ACTIVITY)
2791 } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2792 if (coval == 0.0) {
2793 put_op(assign_d_zero);
2794 ADOLC_PUT_LOCINT(locat);
2795 } else if (coval == 1.0) {
2796 put_op(assign_d_one);
2797 ADOLC_PUT_LOCINT(locat);
2798 } else {
2799 put_op(assign_d);
2800 ADOLC_PUT_LOCINT(locat);
2801 ADOLC_PUT_VAL(coval);
2802 }
2803
2804 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2805 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2806 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2807 }
2808 #endif
2809 }
2810
2811 ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2812 #if defined(ADOLC_TRACK_ACTIVITY)
2813 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2814 #endif
2815 return locat;
2816 }
2817
2818 #ifdef ATRIG_ERF
2819 /* NOTE: enable if your compiler knows asinh, acosh, atanh, erf */
2820
2821 /*--------------------------------------------------------------------------*/
2822 /* Asinh value -- really a quadrature */
asinh(const badouble & x)2823 adub asinh ( const badouble& x ) {
2824 ADOLC_OPENMP_THREAD_NUMBER;
2825 ADOLC_OPENMP_GET_THREAD_NUMBER;
2826 locint locat = next_loc();
2827 double coval = ADOLC_MATH_NSP_ERF::asinh(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2828
2829 adouble y = 1.0 / sqrt(1.0 + x*x);
2830
2831 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(asinh_op,locat,x.loc(),y.loc());
2832 #if defined(ADOLC_TRACK_ACTIVITY)
2833 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) { // y will have same activity as x and can be considered as second input here
2834 #endif
2835 put_op(asinh_op);
2836 ADOLC_PUT_LOCINT(x.loc()); // = arg1
2837 ADOLC_PUT_LOCINT(y.loc()); // = arg2
2838 ADOLC_PUT_LOCINT(locat); // = res
2839
2840 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2841 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2842 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2843 #if defined(ADOLC_TRACK_ACTIVITY)
2844 } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2845 if (coval == 0.0) {
2846 put_op(assign_d_zero);
2847 ADOLC_PUT_LOCINT(locat);
2848 } else if (coval == 1.0) {
2849 put_op(assign_d_one);
2850 ADOLC_PUT_LOCINT(locat);
2851 } else {
2852 put_op(assign_d);
2853 ADOLC_PUT_LOCINT(locat);
2854 ADOLC_PUT_VAL(coval);
2855 }
2856
2857 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2858 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2859 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2860 }
2861 #endif
2862 }
2863
2864 ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2865 #if defined(ADOLC_TRACK_ACTIVITY)
2866 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2867 #endif
2868 ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2869 return locat;
2870 }
2871
2872 /*--------------------------------------------------------------------------*/
2873 /* Acosh value -- really a quadrature */
acosh(const badouble & x)2874 adub acosh ( const badouble& x ) {
2875 ADOLC_OPENMP_THREAD_NUMBER;
2876 ADOLC_OPENMP_GET_THREAD_NUMBER;
2877 locint locat = next_loc();
2878 double coval = ADOLC_MATH_NSP_ERF::acosh(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2879
2880 adouble y = 1.0 / sqrt(x*x-1.0);
2881
2882 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(acosh_op,locat,x.loc(),y.loc());
2883 #if defined(ADOLC_TRACK_ACTIVITY)
2884 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) { // y will have same activity as x and can be considered as second input here
2885 #endif
2886 put_op(acosh_op);
2887 ADOLC_PUT_LOCINT(x.loc()); // = arg1
2888 ADOLC_PUT_LOCINT(y.loc()); // = arg2
2889 ADOLC_PUT_LOCINT(locat); // = res
2890
2891 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2892 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2893 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2894 #if defined(ADOLC_TRACK_ACTIVITY)
2895 } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2896 if (coval == 0.0) {
2897 put_op(assign_d_zero);
2898 ADOLC_PUT_LOCINT(locat);
2899 } else if (coval == 1.0) {
2900 put_op(assign_d_one);
2901 ADOLC_PUT_LOCINT(locat);
2902 } else {
2903 put_op(assign_d);
2904 ADOLC_PUT_LOCINT(locat);
2905 ADOLC_PUT_VAL(coval);
2906 }
2907
2908 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2909 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2910 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2911 }
2912 #endif
2913 }
2914
2915 ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2916 #if defined(ADOLC_TRACK_ACTIVITY)
2917 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2918 #endif
2919 ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2920 return locat;
2921 }
2922
2923 /*--------------------------------------------------------------------------*/
2924 /* Atanh value -- really a quadrature */
atanh(const badouble & x)2925 adub atanh ( const badouble& x ) {
2926 ADOLC_OPENMP_THREAD_NUMBER;
2927 ADOLC_OPENMP_GET_THREAD_NUMBER;
2928 locint locat = next_loc();
2929 double coval = ADOLC_MATH_NSP_ERF::atanh(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2930
2931 adouble y = 1.0 / (1.0 - x*x);
2932
2933 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(atanh_op,locat,x.loc(),y.loc());
2934 #if defined(ADOLC_TRACK_ACTIVITY)
2935 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) { // y will have same activity as x and can be considered as second input here
2936 #endif
2937 put_op(atanh_op);
2938 ADOLC_PUT_LOCINT(x.loc()); // = arg1
2939 ADOLC_PUT_LOCINT(y.loc()); // = arg2
2940 ADOLC_PUT_LOCINT(locat); // = res
2941
2942 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2943 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2944 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2945 #if defined(ADOLC_TRACK_ACTIVITY)
2946 } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2947 if (coval == 0.0) {
2948 put_op(assign_d_zero);
2949 ADOLC_PUT_LOCINT(locat);
2950 } else if (coval == 1.0) {
2951 put_op(assign_d_one);
2952 ADOLC_PUT_LOCINT(locat);
2953 } else {
2954 put_op(assign_d);
2955 ADOLC_PUT_LOCINT(locat);
2956 ADOLC_PUT_VAL(coval);
2957 }
2958
2959 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2960 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2961 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2962 }
2963 #endif
2964 }
2965
2966 ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
2967 #if defined(ADOLC_TRACK_ACTIVITY)
2968 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
2969 #endif
2970 ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
2971 return locat;
2972 }
2973
2974 /*--------------------------------------------------------------------------*/
2975 /* The error function erf */
erf(const badouble & x)2976 adub erf( const badouble& x ) {
2977 ADOLC_OPENMP_THREAD_NUMBER;
2978 ADOLC_OPENMP_GET_THREAD_NUMBER;
2979 locint locat = next_loc();
2980 double coval = ADOLC_MATH_NSP_ERF::erf(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
2981
2982 adouble y = 2.0 /
2983 ADOLC_MATH_NSP_ERF::sqrt(ADOLC_MATH_NSP::acos(-1.0))*exp(-x*x);
2984
2985 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_quad(erf_op,locat,x.loc(),y.loc());
2986 #if defined(ADOLC_TRACK_ACTIVITY)
2987 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) { // y will have same activity as x and can be considered as second input here
2988 #endif
2989 put_op(erf_op);
2990 ADOLC_PUT_LOCINT(x.loc()); // = arg1
2991 ADOLC_PUT_LOCINT(y.loc()); // = arg2
2992 ADOLC_PUT_LOCINT(locat); // = res
2993
2994 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
2995 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
2996 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
2997 #if defined(ADOLC_TRACK_ACTIVITY)
2998 } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
2999 if (coval == 0.0) {
3000 put_op(assign_d_zero);
3001 ADOLC_PUT_LOCINT(locat);
3002 } else if (coval == 1.0) {
3003 put_op(assign_d_one);
3004 ADOLC_PUT_LOCINT(locat);
3005 } else {
3006 put_op(assign_d);
3007 ADOLC_PUT_LOCINT(locat);
3008 ADOLC_PUT_VAL(coval);
3009 }
3010
3011 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3012 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3013 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3014 }
3015 #endif
3016 }
3017
3018 ADOLC_GLOBAL_TAPE_VARS.store[locat] = coval;
3019 #if defined(ADOLC_TRACK_ACTIVITY)
3020 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
3021 #endif
3022 ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
3023 return locat;
3024 }
3025
3026 #endif
3027
3028 /*--------------------------------------------------------------------------*/
3029 /* Fabs Function (NOTE: This function is also nondifferentiable at x=0) */
fabs(const badouble & x)3030 adub fabs ( const badouble& x ) {
3031 ADOLC_OPENMP_THREAD_NUMBER;
3032 ADOLC_OPENMP_GET_THREAD_NUMBER;
3033 locint locat = next_loc();
3034
3035 double coval = 1.0;
3036 double temp = ADOLC_MATH_NSP::fabs(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]);
3037 if (temp != ADOLC_GLOBAL_TAPE_VARS.store[x.loc()])
3038 coval = 0.0;
3039
3040 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { /* write_args_d_a(abs_val,locat,coval,x.loc()); */
3041 #if defined(ADOLC_TRACK_ACTIVITY)
3042 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()]) {
3043 #endif
3044 put_op(abs_val);
3045 ADOLC_PUT_LOCINT(x.loc()); /* arg */
3046 ADOLC_PUT_LOCINT(locat); /* res */
3047 ADOLC_PUT_VAL(coval); /* coval */
3048
3049 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3050 if (ADOLC_CURRENT_TAPE_INFOS.stats[NO_MIN_MAX])
3051 ++ADOLC_CURRENT_TAPE_INFOS.numSwitches;
3052 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3053 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3054 #if defined(ADOLC_TRACK_ACTIVITY)
3055 } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
3056 if (temp == 0.0) {
3057 put_op(assign_d_zero);
3058 ADOLC_PUT_LOCINT(locat);
3059 } else if (temp == 1.0) {
3060 put_op(assign_d_one);
3061 ADOLC_PUT_LOCINT(locat);
3062 } else {
3063 put_op(assign_d);
3064 ADOLC_PUT_LOCINT(locat);
3065 ADOLC_PUT_VAL(temp);
3066 }
3067
3068 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3069 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3070 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3071 }
3072 #endif
3073 }
3074 ADOLC_GLOBAL_TAPE_VARS.store[locat] = temp;
3075 #if defined(ADOLC_TRACK_ACTIVITY)
3076 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()];
3077 #endif
3078 return locat;
3079 }
3080
3081 /*--------------------------------------------------------------------------*/
3082 /* max and min functions (changed : 11/15/95) */
fmin(const badouble & x,const badouble & y)3083 adub fmin ( const badouble& x, const badouble& y ) { /* olvo 980702 tested: return 0.5*fabs(x+y-fabs(x-y)); */
3084 ADOLC_OPENMP_THREAD_NUMBER;
3085 ADOLC_OPENMP_GET_THREAD_NUMBER;
3086 if (ADOLC_CURRENT_TAPE_INFOS.stats[NO_MIN_MAX])
3087 return ((x + y - fabs(x - y))/2.0);
3088
3089 #if defined(ADOLC_TRACK_ACTIVITY)
3090 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
3091 if ( ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()] && ! ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] ) {
3092 locint tmploc = x.loc();
3093 double temp = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3094 if (temp == 0.0) {
3095 put_op(assign_d_zero);
3096 ADOLC_PUT_LOCINT(tmploc);
3097 } else if (temp == 1.0) {
3098 put_op(assign_d_one);
3099 ADOLC_PUT_LOCINT(tmploc);
3100 } else {
3101 put_op(assign_d);
3102 ADOLC_PUT_LOCINT(tmploc);
3103 ADOLC_PUT_VAL(temp);
3104 }
3105
3106 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3107 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3108 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3109 }
3110 if ( ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] && ! ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()] ) {
3111 locint tmploc = y.loc();
3112 double temp = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3113 if (temp == 0.0) {
3114 put_op(assign_d_zero);
3115 ADOLC_PUT_LOCINT(tmploc);
3116 } else if (temp == 1.0) {
3117 put_op(assign_d_one);
3118 ADOLC_PUT_LOCINT(tmploc);
3119 } else {
3120 put_op(assign_d);
3121 ADOLC_PUT_LOCINT(tmploc);
3122 ADOLC_PUT_VAL(temp);
3123 }
3124
3125 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3126 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3127 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3128 }
3129 }
3130 #endif
3131
3132 locint locat = next_loc();
3133 double coval, temp;
3134
3135 if (ADOLC_GLOBAL_TAPE_VARS.store[y.loc()] < ADOLC_GLOBAL_TAPE_VARS.store[x.loc()]) {
3136 coval = 0.0;
3137 temp = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3138 } else {
3139 coval = 1.0;
3140 temp = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3141 }
3142
3143 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_min_op(x.loc(),y.loc(),locat,0.0);
3144 #if defined(ADOLC_TRACK_ACTIVITY)
3145 if ( ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] || ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()] ) {
3146 #endif
3147 put_op(min_op);
3148 ADOLC_PUT_LOCINT(x.loc()); // = arg1
3149 ADOLC_PUT_LOCINT(y.loc()); // = arg2
3150 ADOLC_PUT_LOCINT(locat); // = res
3151 ADOLC_PUT_VAL(coval); // = coval
3152
3153 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3154 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3155 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3156 #if defined(ADOLC_TRACK_ACTIVITY)
3157 } else if (ADOLC_GLOBAL_TAPE_VARS.actStore[locat]) {
3158 if (temp == 0.0) {
3159 put_op(assign_d_zero);
3160 ADOLC_PUT_LOCINT(locat);
3161 } else if (temp == 1.0) {
3162 put_op(assign_d_one);
3163 ADOLC_PUT_LOCINT(locat);
3164 } else {
3165 put_op(assign_d);
3166 ADOLC_PUT_LOCINT(locat);
3167 ADOLC_PUT_VAL(temp);
3168 }
3169
3170 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3171 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3172 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3173 }
3174 #endif
3175 }
3176
3177 ADOLC_GLOBAL_TAPE_VARS.store[locat]=temp;
3178 #if defined(ADOLC_TRACK_ACTIVITY)
3179 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = (ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] || ADOLC_GLOBAL_TAPE_VARS.actStore[y.loc()]);
3180 #endif
3181 return locat;
3182 }
3183
3184 /*--------------------------------------------------------------------------*/
3185 /*21.8.96*/
fmin(double d,const badouble & y)3186 adub fmin ( double d, const badouble& y ) {
3187 adouble x = d;
3188 return (fmin (x,y));
3189 }
3190
3191 /*--------------------------------------------------------------------------*/
fmin(const badouble & x,double d)3192 adub fmin ( const badouble& x, double d ) {
3193 adouble y = d;
3194 return (fmin (x,y));
3195 }
3196
3197 /*--------------------------------------------------------------------------*/
fmax(const badouble & x,const badouble & y)3198 adub fmax ( const badouble& x, const badouble& y ) {
3199 return (-fmin(-x,-y));
3200 }
3201
3202 /*--------------------------------------------------------------------------*/
3203 /*21.8.96*/
fmax(double d,const badouble & y)3204 adub fmax ( double d, const badouble& y ) {
3205 adouble x = d;
3206 return (-fmin(-x,-y));
3207 }
3208
3209 /*--------------------------------------------------------------------------*/
fmax(const badouble & x,double d)3210 adub fmax ( const badouble& x, double d ) {
3211 adouble y = d;
3212 return (-fmin(-x,-y));
3213 }
3214
3215 /*--------------------------------------------------------------------------*/
3216 /* Ldexp Function */
ldexp(const badouble & x,int exp)3217 adub ldexp ( const badouble& x, int exp ) {
3218 return x*ldexp(1.0,exp);
3219 }
3220 /*--------------------------------------------------------------------------*/
3221 /* frexp Function */
frexp(const badouble & x,int * n)3222 adub frexp ( const badouble& x, int* n) {
3223 double v = frexp(x.value(), n);
3224 adouble r = x - v;
3225 adouble z = r - double(*n);
3226 if (z == 0) {
3227 return (x - double(*n));
3228 } else {
3229 fprintf(stderr,"ADOL-C warning: std::frexp() returned inconsistent results\n");
3230 return (r - double(*n));
3231 }
3232 }
3233
3234 /*--------------------------------------------------------------------------*/
3235 /* Macro for user defined quadratures, example myquad is below.*/
3236 /* the forward sweep tests if the tape is executed exactly at */
3237 /* the same argument point otherwise it stops with a returnval */
3238 #define extend_quad(func,integrand)\
3239 adouble func ( const badouble& arg )\
3240 { adouble temp; \
3241 adouble val; \
3242 integrand; \
3243 ADOLC_OPENMP_THREAD_NUMBER; \
3244 ADOLC_OPENMP_GET_THREAD_NUMBER; \
3245 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) \
3246 { put_op(gen_quad); \
3247 ADOLC_PUT_LOCINT(arg.loc()); \
3248 ADOLC_PUT_LOCINT(val.loc()); \
3249 ADOLC_PUT_LOCINT(temp.loc()); \
3250 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape; \
3251 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors) \
3252 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[temp.loc()]); \
3253 } \
3254 ADOLC_GLOBAL_TAPE_VARS.store[temp.loc()]=func(ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()]); \
3255 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) \
3256 { ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()]); \
3257 ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[temp.loc()]); \
3258 } \
3259 return temp; }
3260
myquad(double & x)3261 double myquad(double& x) {
3262 double res;
3263 res = ADOLC_MATH_NSP::log(x);
3264 return res;
3265 }
3266
3267 /* This defines the natural logarithm as a quadrature */
3268
3269 extend_quad(myquad,val = 1/arg)
3270
3271
3272 /****************************************************************************/
3273 /* CONDITIONALS */
3274 /*--------------------------------------------------------------------------*/
3275 #if defined(ADOLC_ADVANCED_BRANCHING)
3276 adub operator != (const badouble& x, const badouble& y) {
3277 ADOLC_OPENMP_THREAD_NUMBER;
3278 ADOLC_OPENMP_GET_THREAD_NUMBER;
3279 double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3280 double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3281 double res = (double)(xval != yval);
3282 locint locat = next_loc();
3283 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
3284 put_op(neq_a_a);
3285 ADOLC_PUT_LOCINT(x.loc()); // arg
3286 ADOLC_PUT_LOCINT(y.loc()); // arg1
3287 ADOLC_PUT_VAL(res); // check for branch switch
3288 ADOLC_PUT_LOCINT(locat); // res
3289
3290 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3291 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3292 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3293 }
3294 ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
3295 return locat;
3296 }
3297 /*--------------------------------------------------------------------------*/
operator ==(const badouble & x,const badouble & y)3298 adub operator == (const badouble& x, const badouble& y) {
3299 ADOLC_OPENMP_THREAD_NUMBER;
3300 ADOLC_OPENMP_GET_THREAD_NUMBER;
3301 double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3302 double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3303 double res = (double)(xval == yval);
3304 locint locat = next_loc();
3305 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
3306 put_op(eq_a_a);
3307 ADOLC_PUT_LOCINT(x.loc()); // arg
3308 ADOLC_PUT_LOCINT(y.loc()); // arg1
3309 ADOLC_PUT_VAL(res); // check for branch switch
3310 ADOLC_PUT_LOCINT(locat); // res
3311
3312 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3313 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3314 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3315 }
3316 ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
3317 return locat;
3318 }
3319 /*--------------------------------------------------------------------------*/
operator <=(const badouble & x,const badouble & y)3320 adub operator <= (const badouble& x, const badouble& y) {
3321 ADOLC_OPENMP_THREAD_NUMBER;
3322 ADOLC_OPENMP_GET_THREAD_NUMBER;
3323 double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3324 double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3325 double res = (double)(xval <= yval);
3326 locint locat = next_loc();
3327 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
3328 put_op(le_a_a);
3329 ADOLC_PUT_LOCINT(x.loc()); // arg
3330 ADOLC_PUT_LOCINT(y.loc()); // arg1
3331 ADOLC_PUT_VAL(res); // check for branch switch
3332 ADOLC_PUT_LOCINT(locat); // res
3333
3334 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3335 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3336 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3337 }
3338 ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
3339 return locat;
3340 }
3341 /*--------------------------------------------------------------------------*/
operator >=(const badouble & x,const badouble & y)3342 adub operator >= (const badouble& x, const badouble& y) {
3343 ADOLC_OPENMP_THREAD_NUMBER;
3344 ADOLC_OPENMP_GET_THREAD_NUMBER;
3345 double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3346 double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3347 double res = (double)(xval >= yval);
3348 locint locat = next_loc();
3349 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
3350 put_op(ge_a_a);
3351 ADOLC_PUT_LOCINT(x.loc()); // arg
3352 ADOLC_PUT_LOCINT(y.loc()); // arg1
3353 ADOLC_PUT_VAL(res); // check for branch switch
3354 ADOLC_PUT_LOCINT(locat); // res
3355
3356 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3357 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3358 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3359 }
3360 ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
3361 return locat;
3362 }
3363 /*--------------------------------------------------------------------------*/
operator >(const badouble & x,const badouble & y)3364 adub operator > (const badouble& x, const badouble& y) {
3365 ADOLC_OPENMP_THREAD_NUMBER;
3366 ADOLC_OPENMP_GET_THREAD_NUMBER;
3367 double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3368 double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3369 double res = (double)(xval > yval);
3370 locint locat = next_loc();
3371 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
3372 put_op(gt_a_a);
3373 ADOLC_PUT_LOCINT(x.loc()); // arg
3374 ADOLC_PUT_LOCINT(y.loc()); // arg1
3375 ADOLC_PUT_VAL(res); // check for branch switch
3376 ADOLC_PUT_LOCINT(locat); // res
3377
3378 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3379 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3380 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3381 }
3382 ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
3383 return locat;
3384 }
3385 /*--------------------------------------------------------------------------*/
operator <(const badouble & x,const badouble & y)3386 adub operator < (const badouble& x, const badouble& y) {
3387 ADOLC_OPENMP_THREAD_NUMBER;
3388 ADOLC_OPENMP_GET_THREAD_NUMBER;
3389 double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
3390 double yval = ADOLC_GLOBAL_TAPE_VARS.store[y.loc()];
3391 double res = (double)(xval < yval);
3392 locint locat = next_loc();
3393 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
3394 put_op(lt_a_a);
3395 ADOLC_PUT_LOCINT(x.loc()); // arg
3396 ADOLC_PUT_LOCINT(y.loc()); // arg1
3397 ADOLC_PUT_VAL(res); // check for branch switch
3398 ADOLC_PUT_LOCINT(locat); // res
3399
3400 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3401 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3402 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
3403 }
3404 ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
3405 return locat;
3406 }
3407 #endif
3408 /*--------------------------------------------------------------------------*/
3409 /*--------------------------------------------------------------------------*/
condassign(adouble & res,const badouble & cond,const badouble & arg1,const badouble & arg2)3410 void condassign( adouble &res, const badouble &cond,
3411 const badouble &arg1, const badouble &arg2 ) {
3412 ADOLC_OPENMP_THREAD_NUMBER;
3413 ADOLC_OPENMP_GET_THREAD_NUMBER;
3414 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign(res.loc(),cond.loc(),arg1.loc(),
3415 // arg2.loc());
3416 #if defined(ADOLC_TRACK_ACTIVITY)
3417 if ( ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3418 if (! ADOLC_GLOBAL_TAPE_VARS.actStore[arg1.loc()] ) {
3419 locint tmploc = arg1.loc();
3420 double temp = ADOLC_GLOBAL_TAPE_VARS.store[arg1.loc()];
3421 if (temp == 0.0) {
3422 put_op(assign_d_zero);
3423 ADOLC_PUT_LOCINT(tmploc);
3424 } else if (temp == 1.0) {
3425 put_op(assign_d_one);
3426 ADOLC_PUT_LOCINT(tmploc);
3427 } else {
3428 put_op(assign_d);
3429 ADOLC_PUT_LOCINT(tmploc);
3430 ADOLC_PUT_VAL(temp);
3431 }
3432
3433 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3434 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3435 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3436 }
3437 if (! ADOLC_GLOBAL_TAPE_VARS.actStore[arg2.loc()] ) {
3438 locint tmploc = arg2.loc();
3439 double temp = ADOLC_GLOBAL_TAPE_VARS.store[arg2.loc()];
3440 if (temp == 0.0) {
3441 put_op(assign_d_zero);
3442 ADOLC_PUT_LOCINT(tmploc);
3443 } else if (temp == 1.0) {
3444 put_op(assign_d_one);
3445 ADOLC_PUT_LOCINT(tmploc);
3446 } else {
3447 put_op(assign_d);
3448 ADOLC_PUT_LOCINT(tmploc);
3449 ADOLC_PUT_VAL(temp);
3450 }
3451
3452 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3453 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3454 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3455 }
3456 #endif
3457 put_op(cond_assign);
3458 ADOLC_PUT_LOCINT(cond.loc()); // = arg
3459 ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()]);
3460 ADOLC_PUT_LOCINT(arg1.loc()); // = arg1
3461 ADOLC_PUT_LOCINT(arg2.loc()); // = arg2
3462 ADOLC_PUT_LOCINT(res.loc()); // = res
3463
3464 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3465 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3466 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3467 #if defined(ADOLC_TRACK_ACTIVITY)
3468 } else {
3469 locint x_loc;
3470 if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3471 x_loc = arg1.loc();
3472 else
3473 x_loc = arg2.loc();
3474
3475 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x_loc]) {
3476 put_op(assign_a);
3477 ADOLC_PUT_LOCINT(x_loc); // = arg
3478 ADOLC_PUT_LOCINT(res.loc()); // = res
3479
3480 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3481 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3482 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3483 } else {
3484 if (ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()]) {
3485 double coval = ADOLC_GLOBAL_TAPE_VARS.store[x_loc];
3486 if (coval == 0) {
3487 put_op(assign_d_zero);
3488 ADOLC_PUT_LOCINT(res.loc()); // = res
3489 } else if (coval == 1.0) {
3490 put_op(assign_d_one);
3491 ADOLC_PUT_LOCINT(res.loc()); // = res
3492 } else {
3493 put_op(assign_d);
3494 ADOLC_PUT_LOCINT(res.loc()); // = res
3495 ADOLC_PUT_VAL(coval); // = coval
3496 }
3497
3498 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3499 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3500 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3501 }
3502 }
3503 }
3504 #endif
3505 }
3506
3507 if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3508 ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg1.loc()];
3509 else
3510 ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg2.loc()];
3511 #if defined(ADOLC_TRACK_ACTIVITY)
3512 if ( ! ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3513 if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3514 ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[arg1.loc()];
3515 else
3516 ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[arg2.loc()];
3517 } else
3518 ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()];
3519 #endif
3520 }
3521
3522 /*--------------------------------------------------------------------------*/
condassign(adouble & res,const badouble & cond,const badouble & arg)3523 void condassign( adouble &res, const badouble &cond, const badouble &arg ) {
3524 ADOLC_OPENMP_THREAD_NUMBER;
3525 ADOLC_OPENMP_GET_THREAD_NUMBER;
3526 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign2(res.loc(),cond.loc(),arg.loc());
3527 #if defined(ADOLC_TRACK_ACTIVITY)
3528 if ( ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3529 if (! ADOLC_GLOBAL_TAPE_VARS.actStore[arg.loc()] ) {
3530 locint tmploc = arg.loc();
3531 double temp = ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()];
3532 if (temp == 0.0) {
3533 put_op(assign_d_zero);
3534 ADOLC_PUT_LOCINT(tmploc);
3535 } else if (temp == 1.0) {
3536 put_op(assign_d_one);
3537 ADOLC_PUT_LOCINT(tmploc);
3538 } else {
3539 put_op(assign_d);
3540 ADOLC_PUT_LOCINT(tmploc);
3541 ADOLC_PUT_VAL(temp);
3542 }
3543
3544 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3545 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3546 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3547 }
3548 #endif
3549 put_op(cond_assign_s);
3550 ADOLC_PUT_LOCINT(cond.loc()); // = arg
3551 ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()]);
3552 ADOLC_PUT_LOCINT(arg.loc()); // = arg1
3553 ADOLC_PUT_LOCINT(res.loc()); // = res
3554
3555 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3556 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3557 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3558 #if defined(ADOLC_TRACK_ACTIVITY)
3559 } else {
3560 locint x_loc;
3561 if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0) {
3562 x_loc = arg.loc();
3563 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x_loc]) {
3564 put_op(assign_a);
3565 ADOLC_PUT_LOCINT(x_loc); // = arg
3566 ADOLC_PUT_LOCINT(res.loc()); // = res
3567
3568 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3569 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3570 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3571 } else {
3572 if (ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()]) {
3573 double coval = ADOLC_GLOBAL_TAPE_VARS.store[x_loc];
3574 if (coval == 0) {
3575 put_op(assign_d_zero);
3576 ADOLC_PUT_LOCINT(res.loc()); // = res
3577 } else if (coval == 1.0) {
3578 put_op(assign_d_one);
3579 ADOLC_PUT_LOCINT(res.loc()); // = res
3580 } else {
3581 put_op(assign_d);
3582 ADOLC_PUT_LOCINT(res.loc()); // = res
3583 ADOLC_PUT_VAL(coval); // = coval
3584 }
3585
3586 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3587 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3588 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3589 }
3590 }
3591 }
3592 }
3593 #endif
3594 }
3595
3596 if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3597 ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()];
3598 #if defined(ADOLC_TRACK_ACTIVITY)
3599 if ( ! ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3600 if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3601 ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[arg.loc()];
3602 } else
3603 ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()];
3604 #endif
3605 }
3606 /*--------------------------------------------------------------------------*/
condeqassign(adouble & res,const badouble & cond,const badouble & arg1,const badouble & arg2)3607 void condeqassign( adouble &res, const badouble &cond,
3608 const badouble &arg1, const badouble &arg2 ) {
3609 ADOLC_OPENMP_THREAD_NUMBER;
3610 ADOLC_OPENMP_GET_THREAD_NUMBER;
3611 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign(res.loc(),cond.loc(),arg1.loc(),
3612 // arg2.loc());
3613 #if defined(ADOLC_TRACK_ACTIVITY)
3614 if ( ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3615 if (! ADOLC_GLOBAL_TAPE_VARS.actStore[arg1.loc()] ) {
3616 locint tmploc = arg1.loc();
3617 double temp = ADOLC_GLOBAL_TAPE_VARS.store[arg1.loc()];
3618 if (temp == 0.0) {
3619 put_op(assign_d_zero);
3620 ADOLC_PUT_LOCINT(tmploc);
3621 } else if (temp == 1.0) {
3622 put_op(assign_d_one);
3623 ADOLC_PUT_LOCINT(tmploc);
3624 } else {
3625 put_op(assign_d);
3626 ADOLC_PUT_LOCINT(tmploc);
3627 ADOLC_PUT_VAL(temp);
3628 }
3629
3630 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3631 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3632 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3633 }
3634 if (! ADOLC_GLOBAL_TAPE_VARS.actStore[arg2.loc()] ) {
3635 locint tmploc = arg2.loc();
3636 double temp = ADOLC_GLOBAL_TAPE_VARS.store[arg2.loc()];
3637 if (temp == 0.0) {
3638 put_op(assign_d_zero);
3639 ADOLC_PUT_LOCINT(tmploc);
3640 } else if (temp == 1.0) {
3641 put_op(assign_d_one);
3642 ADOLC_PUT_LOCINT(tmploc);
3643 } else {
3644 put_op(assign_d);
3645 ADOLC_PUT_LOCINT(tmploc);
3646 ADOLC_PUT_VAL(temp);
3647 }
3648
3649 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3650 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3651 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3652 }
3653 #endif
3654 put_op(cond_eq_assign);
3655 ADOLC_PUT_LOCINT(cond.loc()); // = arg
3656 ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()]);
3657 ADOLC_PUT_LOCINT(arg1.loc()); // = arg1
3658 ADOLC_PUT_LOCINT(arg2.loc()); // = arg2
3659 ADOLC_PUT_LOCINT(res.loc()); // = res
3660
3661 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3662 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3663 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3664 #if defined(ADOLC_TRACK_ACTIVITY)
3665 } else {
3666 locint x_loc;
3667 if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3668 x_loc = arg1.loc();
3669 else
3670 x_loc = arg2.loc();
3671
3672 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x_loc]) {
3673 put_op(assign_a);
3674 ADOLC_PUT_LOCINT(x_loc); // = arg
3675 ADOLC_PUT_LOCINT(res.loc()); // = res
3676
3677 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3678 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3679 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3680 } else {
3681 if (ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()]) {
3682 double coval = ADOLC_GLOBAL_TAPE_VARS.store[x_loc];
3683 if (coval == 0) {
3684 put_op(assign_d_zero);
3685 ADOLC_PUT_LOCINT(res.loc()); // = res
3686 } else if (coval == 1.0) {
3687 put_op(assign_d_one);
3688 ADOLC_PUT_LOCINT(res.loc()); // = res
3689 } else {
3690 put_op(assign_d);
3691 ADOLC_PUT_LOCINT(res.loc()); // = res
3692 ADOLC_PUT_VAL(coval); // = coval
3693 }
3694
3695 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3696 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3697 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3698 }
3699 }
3700 }
3701 #endif
3702 }
3703
3704 if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] >= 0)
3705 ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg1.loc()];
3706 else
3707 ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg2.loc()];
3708 #if defined(ADOLC_TRACK_ACTIVITY)
3709 if ( ! ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3710 if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3711 ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[arg1.loc()];
3712 else
3713 ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[arg2.loc()];
3714 } else
3715 ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()];
3716 #endif
3717 }
3718
3719 /*--------------------------------------------------------------------------*/
condeqassign(adouble & res,const badouble & cond,const badouble & arg)3720 void condeqassign( adouble &res, const badouble &cond, const badouble &arg ) {
3721 ADOLC_OPENMP_THREAD_NUMBER;
3722 ADOLC_OPENMP_GET_THREAD_NUMBER;
3723 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_condassign2(res.loc(),cond.loc(),arg.loc());
3724 #if defined(ADOLC_TRACK_ACTIVITY)
3725 if ( ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3726 if (! ADOLC_GLOBAL_TAPE_VARS.actStore[arg.loc()] ) {
3727 locint tmploc = arg.loc();
3728 double temp = ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()];
3729 if (temp == 0.0) {
3730 put_op(assign_d_zero);
3731 ADOLC_PUT_LOCINT(tmploc);
3732 } else if (temp == 1.0) {
3733 put_op(assign_d_one);
3734 ADOLC_PUT_LOCINT(tmploc);
3735 } else {
3736 put_op(assign_d);
3737 ADOLC_PUT_LOCINT(tmploc);
3738 ADOLC_PUT_VAL(temp);
3739 }
3740
3741 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3742 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3743 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
3744 }
3745 #endif
3746 put_op(cond_eq_assign_s);
3747 ADOLC_PUT_LOCINT(cond.loc()); // = arg
3748 ADOLC_PUT_VAL(ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()]);
3749 ADOLC_PUT_LOCINT(arg.loc()); // = arg1
3750 ADOLC_PUT_LOCINT(res.loc()); // = res
3751
3752 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3753 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3754 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3755 #if defined(ADOLC_TRACK_ACTIVITY)
3756 } else {
3757 locint x_loc;
3758 if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0) {
3759 x_loc = arg.loc();
3760 if (ADOLC_GLOBAL_TAPE_VARS.actStore[x_loc]) {
3761 put_op(assign_a);
3762 ADOLC_PUT_LOCINT(x_loc); // = arg
3763 ADOLC_PUT_LOCINT(res.loc()); // = res
3764
3765 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3766 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3767 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3768 } else {
3769 if (ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()]) {
3770 double coval = ADOLC_GLOBAL_TAPE_VARS.store[x_loc];
3771 if (coval == 0) {
3772 put_op(assign_d_zero);
3773 ADOLC_PUT_LOCINT(res.loc()); // = res
3774 } else if (coval == 1.0) {
3775 put_op(assign_d_one);
3776 ADOLC_PUT_LOCINT(res.loc()); // = res
3777 } else {
3778 put_op(assign_d);
3779 ADOLC_PUT_LOCINT(res.loc()); // = res
3780 ADOLC_PUT_VAL(coval); // = coval
3781 }
3782
3783 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
3784 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
3785 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[res.loc()]);
3786 }
3787 }
3788 }
3789 }
3790 #endif
3791 }
3792
3793 if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] >= 0)
3794 ADOLC_GLOBAL_TAPE_VARS.store[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.store[arg.loc()];
3795 #if defined(ADOLC_TRACK_ACTIVITY)
3796 if ( ! ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()] ) {
3797 if (ADOLC_GLOBAL_TAPE_VARS.store[cond.loc()] > 0)
3798 ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[arg.loc()];
3799 } else
3800 ADOLC_GLOBAL_TAPE_VARS.actStore[res.loc()] = ADOLC_GLOBAL_TAPE_VARS.actStore[cond.loc()];
3801 #endif
3802 }
3803
3804 /****************************************************************************/
3805 /* THAT'S ALL*/
3806