1 /*----------------------------------------------------------------------------
2 ADOL-C -- Automatic Differentiation by Overloading in C++
3 File: param.cpp
4 Revision: $Id$
5 Contents: class for parameter dependent functions
6
7 Copyright (c) Kshitij Kulshreshtha
8
9 This file is part of ADOL-C. This software is provided as open source.
10 Any use, reproduction, or distribution of the software constitutes
11 recipient's acceptance of the terms of the accompanying license file.
12
13 ----------------------------------------------------------------------------*/
14
15
16 #include "oplate.h"
17 #include "taping_p.h"
18 #include "dvlparms.h"
19 #include <adolc/adouble.h>
20
21 #include <limits>
22
pdouble(double pval)23 pdouble::pdouble(double pval) {
24 ADOLC_OPENMP_THREAD_NUMBER;
25 ADOLC_OPENMP_GET_THREAD_NUMBER;
26
27 _val = pval;
28 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
29 _idx = ADOLC_GLOBAL_TAPE_VARS.paramStoreMgrPtr->next_loc();
30 ADOLC_GLOBAL_TAPE_VARS.pStore[_idx] = _val;
31 } else {
32 _idx = std::numeric_limits<locint>::max();
33 }
34 }
35
pdouble(locint idx)36 pdouble::pdouble(locint idx) {
37 ADOLC_OPENMP_THREAD_NUMBER;
38 ADOLC_OPENMP_GET_THREAD_NUMBER;
39
40 if (idx < ADOLC_GLOBAL_TAPE_VARS.numparam) {
41 _val = ADOLC_GLOBAL_TAPE_VARS.pStore[idx];
42 _idx = idx;
43 } else {
44 fprintf(DIAG_OUT, "ADOL-C error: Parameter index %d out of bounds, "
45 "# existing parameters = %zu\n", idx,
46 ADOLC_GLOBAL_TAPE_VARS.numparam);
47 adolc_exit(-1,"",__func__,__FILE__,__LINE__);
48 }
49 }
50
operator pdouble*() const51 pdouble::operator pdouble*() const {
52 pdouble* ret = new pdouble(_idx);
53 return ret;
54 }
55
mkparam(double pval)56 pdouble mkparam(double pval) {
57 locint _idx;
58 ADOLC_OPENMP_THREAD_NUMBER;
59 ADOLC_OPENMP_GET_THREAD_NUMBER;
60
61 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
62 _idx = ADOLC_GLOBAL_TAPE_VARS.paramStoreMgrPtr->next_loc();
63 ADOLC_GLOBAL_TAPE_VARS.pStore[_idx] = pval;
64 } else {
65 return pval;
66 }
67 return _idx;
68 }
69
getparam(locint index)70 pdouble getparam(locint index) {
71 return index;
72 }
73
mkparam_idx(double pval)74 locint mkparam_idx(double pval) {
75 locint _idx;
76 ADOLC_OPENMP_THREAD_NUMBER;
77 ADOLC_OPENMP_GET_THREAD_NUMBER;
78 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
79 _idx = ADOLC_GLOBAL_TAPE_VARS.paramStoreMgrPtr->next_loc();
80 ADOLC_GLOBAL_TAPE_VARS.pStore[_idx] = pval;
81 } else {
82 fprintf(DIAG_OUT, "ADOL-C error: cannot define indexed parameter "
83 "while tracing is turned off!\n");
84 adolc_exit(-1,"",__func__,__FILE__,__LINE__);
85 }
86 return _idx;
87 }
88
operator adub() const89 pdouble::operator adub() const {
90 locint location;
91 ADOLC_OPENMP_THREAD_NUMBER;
92 ADOLC_OPENMP_GET_THREAD_NUMBER;
93
94 location = next_loc();
95 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
96 put_op(assign_p);
97 ADOLC_PUT_LOCINT(_idx);
98 ADOLC_PUT_LOCINT(location);
99
100 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
101 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
102 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
103 }
104 ADOLC_GLOBAL_TAPE_VARS.store[location] = _val;
105 #if defined(ADOLC_TRACK_ACTIVITY)
106 ADOLC_GLOBAL_TAPE_VARS.actStore[location] = true;
107 #endif
108 return location;
109 }
110
operator =(const pdouble & p)111 badouble& badouble::operator = (const pdouble& p) {
112 locint loc;
113 ADOLC_OPENMP_THREAD_NUMBER;
114 ADOLC_OPENMP_GET_THREAD_NUMBER;
115
116 loc = this->loc();
117 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
118 put_op(assign_p);
119 ADOLC_PUT_LOCINT(p._idx);
120 ADOLC_PUT_LOCINT(loc);
121
122 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
123 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
124 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc]);
125 }
126 ADOLC_GLOBAL_TAPE_VARS.store[loc] = p._val;
127 #if defined(ADOLC_TRACK_ACTIVITY)
128 ADOLC_GLOBAL_TAPE_VARS.actStore[loc] = true;
129 #endif
130 return *this;
131 }
132
operator =(const pdouble & p)133 adouble& adouble::operator = (const pdouble& p) {
134 this->loc();
135 (*this).badouble::operator=(p);
136 return (*this);
137 }
138
operator =(const pdouble & p)139 adubref& adubref::operator = (const pdouble& p) {
140 ADOLC_OPENMP_THREAD_NUMBER;
141 ADOLC_OPENMP_GET_THREAD_NUMBER;
142 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
143 put_op(ref_assign_p);
144 ADOLC_PUT_LOCINT(p._idx);
145 ADOLC_PUT_LOCINT(location);
146
147 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
148 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
149 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[refloc]);
150 }
151 ADOLC_GLOBAL_TAPE_VARS.store[refloc] = p._val;
152 #if defined(ADOLC_TRACK_ACTIVITY)
153 ADOLC_GLOBAL_TAPE_VARS.actStore[refloc] = true;
154 #endif
155 return *this;
156 }
157
operator +=(const pdouble & p)158 badouble& badouble::operator += (const pdouble& p) {
159 locint loc;
160 ADOLC_OPENMP_THREAD_NUMBER;
161 ADOLC_OPENMP_GET_THREAD_NUMBER;
162
163 loc = this->loc();
164 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
165 put_op(eq_plus_p);
166 ADOLC_PUT_LOCINT(p._idx);
167 ADOLC_PUT_LOCINT(loc);
168
169 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
170 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
171 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc]);
172 }
173
174 ADOLC_GLOBAL_TAPE_VARS.store[loc] += p._val;
175 #if defined(ADOLC_TRACK_ACTIVITY)
176 ADOLC_GLOBAL_TAPE_VARS.actStore[loc] = true;
177 #endif
178 return *this;
179 }
180
operator +=(const pdouble & p)181 adubref& adubref::operator += (const pdouble& p) {
182 ADOLC_OPENMP_THREAD_NUMBER;
183 ADOLC_OPENMP_GET_THREAD_NUMBER;
184
185 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
186 put_op(ref_eq_plus_p);
187 ADOLC_PUT_LOCINT(p._idx);
188 ADOLC_PUT_LOCINT(location);
189
190 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
191 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
192 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[refloc]);
193 }
194
195 ADOLC_GLOBAL_TAPE_VARS.store[refloc] += p._val;
196 #if defined(ADOLC_TRACK_ACTIVITY)
197 ADOLC_GLOBAL_TAPE_VARS.actStore[refloc] = true;
198 #endif
199 return *this;
200 }
201
operator -=(const pdouble & p)202 badouble& badouble::operator -= (const pdouble& p) {
203 ADOLC_OPENMP_THREAD_NUMBER;
204 ADOLC_OPENMP_GET_THREAD_NUMBER;
205 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_min_d,loc(),coval);
206 put_op(eq_min_p);
207 ADOLC_PUT_LOCINT(p._idx);
208 ADOLC_PUT_LOCINT(loc());
209
210 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
211 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
212 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
213 }
214
215 ADOLC_GLOBAL_TAPE_VARS.store[loc()] -= p._val;
216 #if defined(ADOLC_TRACK_ACTIVITY)
217 ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] = true;
218 #endif
219 return *this;
220 }
221
operator -=(const pdouble & p)222 adubref& adubref::operator -= (const pdouble& p) {
223 ADOLC_OPENMP_THREAD_NUMBER;
224 ADOLC_OPENMP_GET_THREAD_NUMBER;
225 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_min_d,location,coval);
226 put_op(ref_eq_min_p);
227 ADOLC_PUT_LOCINT(p._idx);
228 ADOLC_PUT_LOCINT(location);
229
230 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
231 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
232 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[refloc]);
233 }
234
235 ADOLC_GLOBAL_TAPE_VARS.store[refloc] -= p._val;
236 #if defined(ADOLC_TRACK_ACTIVITY)
237 ADOLC_GLOBAL_TAPE_VARS.actStore[refloc] = true;
238 #endif
239 return *this;
240 }
241
operator *=(const pdouble & p)242 badouble& badouble::operator *= (const pdouble& p) {
243 ADOLC_OPENMP_THREAD_NUMBER;
244 ADOLC_OPENMP_GET_THREAD_NUMBER;
245 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_mult_d,loc(),coval);
246 put_op(eq_mult_p);
247 ADOLC_PUT_LOCINT(p._idx); // = coval
248 ADOLC_PUT_LOCINT(loc()); // = res
249
250 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
251 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
252 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[loc()]);
253 }
254
255 ADOLC_GLOBAL_TAPE_VARS.store[loc()] *= p._val;
256 #if defined(ADOLC_TRACK_ACTIVITY)
257 ADOLC_GLOBAL_TAPE_VARS.actStore[loc()] = true;
258 #endif
259 return *this;
260 }
261
operator *=(const pdouble & p)262 adubref& adubref::operator *= (const pdouble& p) {
263 ADOLC_OPENMP_THREAD_NUMBER;
264 ADOLC_OPENMP_GET_THREAD_NUMBER;
265 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_d_same_arg(eq_mult_d,location,coval);
266 put_op(ref_eq_mult_p);
267 ADOLC_PUT_LOCINT(p._idx);
268 ADOLC_PUT_LOCINT(location);
269
270 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
271 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
272 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[refloc]);
273 }
274
275 ADOLC_GLOBAL_TAPE_VARS.store[refloc] *= p._val;
276 #if defined(ADOLC_TRACK_ACTIVITY)
277 ADOLC_GLOBAL_TAPE_VARS.actStore[refloc] = true;
278 #endif
279 return *this;
280 }
281
operator +(const badouble & a,const pdouble & p)282 adub operator + (const badouble& a, const pdouble& p) {
283 ADOLC_OPENMP_THREAD_NUMBER;
284 ADOLC_OPENMP_GET_THREAD_NUMBER;
285 locint locat = next_loc();
286
287 /* olvo 980708 test coval to be zero */
288 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(plus_d_a,locat,coval,y.loc());
289 #if defined(ADOLC_TRACK_ACTIVITY)
290 if (! ADOLC_GLOBAL_TAPE_VARS.actStore[a.loc()] ) {
291 locint tmploc = a.loc();
292 double temp = ADOLC_GLOBAL_TAPE_VARS.store[a.loc()];
293 if (temp == 0.0) {
294 put_op(assign_d_zero);
295 ADOLC_PUT_LOCINT(tmploc);
296 } else if (temp == 1.0) {
297 put_op(assign_d_one);
298 ADOLC_PUT_LOCINT(tmploc);
299 } else {
300 put_op(assign_d);
301 ADOLC_PUT_LOCINT(tmploc);
302 ADOLC_PUT_VAL(temp);
303 }
304
305 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
306 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
307 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
308 }
309 #endif
310 put_op(plus_a_p);
311 ADOLC_PUT_LOCINT(a.loc());
312 ADOLC_PUT_LOCINT(p._idx);
313 ADOLC_PUT_LOCINT(locat);
314
315 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
316 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
317 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
318 }
319
320 ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[a.loc()] + p._val;
321 #if defined(ADOLC_TRACK_ACTIVITY)
322 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = true;
323 #endif
324 return locat;
325 }
326
operator -(const badouble & a,const pdouble & p)327 adub operator - (const badouble& a, const pdouble& p) {
328 ADOLC_OPENMP_THREAD_NUMBER;
329 ADOLC_OPENMP_GET_THREAD_NUMBER;
330 locint locat = next_loc();
331
332 /* olvo 980708 test coval to be zero */
333 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(plus_d_a,locat,coval,y.loc());
334 #if defined(ADOLC_TRACK_ACTIVITY)
335 if (! ADOLC_GLOBAL_TAPE_VARS.actStore[a.loc()] ) {
336 locint tmploc = a.loc();
337 double temp = ADOLC_GLOBAL_TAPE_VARS.store[a.loc()];
338 if (temp == 0.0) {
339 put_op(assign_d_zero);
340 ADOLC_PUT_LOCINT(tmploc);
341 } else if (temp == 1.0) {
342 put_op(assign_d_one);
343 ADOLC_PUT_LOCINT(tmploc);
344 } else {
345 put_op(assign_d);
346 ADOLC_PUT_LOCINT(tmploc);
347 ADOLC_PUT_VAL(temp);
348 }
349
350 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
351 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
352 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
353 }
354 #endif
355 put_op(min_a_p);
356 ADOLC_PUT_LOCINT(a.loc());
357 ADOLC_PUT_LOCINT(p._idx);
358 ADOLC_PUT_LOCINT(locat);
359
360 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
361 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
362 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
363 }
364
365 ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[a.loc()] - p._val;
366 #if defined(ADOLC_TRACK_ACTIVITY)
367 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = true;
368 #endif
369 return locat;
370 }
371
operator *(const badouble & a,const pdouble & p)372 adub operator * (const badouble& a, const pdouble& p) {
373 ADOLC_OPENMP_THREAD_NUMBER;
374 ADOLC_OPENMP_GET_THREAD_NUMBER;
375 locint locat = next_loc();
376
377 /* olvo 980708 test coval to be zero */
378 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(plus_d_a,locat,coval,y.loc());
379 #if defined(ADOLC_TRACK_ACTIVITY)
380 if (! ADOLC_GLOBAL_TAPE_VARS.actStore[a.loc()] ) {
381 locint tmploc = a.loc();
382 double temp = ADOLC_GLOBAL_TAPE_VARS.store[a.loc()];
383 if (temp == 0.0) {
384 put_op(assign_d_zero);
385 ADOLC_PUT_LOCINT(tmploc);
386 } else if (temp == 1.0) {
387 put_op(assign_d_one);
388 ADOLC_PUT_LOCINT(tmploc);
389 } else {
390 put_op(assign_d);
391 ADOLC_PUT_LOCINT(tmploc);
392 ADOLC_PUT_VAL(temp);
393 }
394
395 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
396 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
397 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
398 }
399 #endif
400 put_op(mult_a_p);
401 ADOLC_PUT_LOCINT(a.loc());
402 ADOLC_PUT_LOCINT(p._idx);
403 ADOLC_PUT_LOCINT(locat);
404
405 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
406 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
407 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
408 }
409
410 ADOLC_GLOBAL_TAPE_VARS.store[locat] = ADOLC_GLOBAL_TAPE_VARS.store[a.loc()] * p._val;
411 #if defined(ADOLC_TRACK_ACTIVITY)
412 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = true;
413 #endif
414 return locat;
415 }
416
operator /(const pdouble & p,const badouble & a)417 adub operator / (const pdouble& p, const badouble& a) {
418 ADOLC_OPENMP_THREAD_NUMBER;
419 ADOLC_OPENMP_GET_THREAD_NUMBER;
420 locint locat = next_loc();
421
422 /* olvo 980708 test coval to be zero */
423 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(plus_d_a,locat,coval,y.loc());
424 #if defined(ADOLC_TRACK_ACTIVITY)
425 if (! ADOLC_GLOBAL_TAPE_VARS.actStore[a.loc()] ) {
426 locint tmploc = a.loc();
427 double temp = ADOLC_GLOBAL_TAPE_VARS.store[a.loc()];
428 if (temp == 0.0) {
429 put_op(assign_d_zero);
430 ADOLC_PUT_LOCINT(tmploc);
431 } else if (temp == 1.0) {
432 put_op(assign_d_one);
433 ADOLC_PUT_LOCINT(tmploc);
434 } else {
435 put_op(assign_d);
436 ADOLC_PUT_LOCINT(tmploc);
437 ADOLC_PUT_VAL(temp);
438 }
439
440 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
441 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
442 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
443 }
444 #endif
445 put_op(div_p_a);
446 ADOLC_PUT_LOCINT(a.loc());
447 ADOLC_PUT_LOCINT(p._idx);
448 ADOLC_PUT_LOCINT(locat);
449
450 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
451 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
452 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
453 }
454
455 ADOLC_GLOBAL_TAPE_VARS.store[locat] = p._val/ADOLC_GLOBAL_TAPE_VARS.store[a.loc()];
456 #if defined(ADOLC_TRACK_ACTIVITY)
457 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = true;
458 #endif
459 return locat;
460 }
461
pow(const badouble & x,const pdouble & p)462 adub pow( const badouble& x, const pdouble& p) {
463 ADOLC_OPENMP_THREAD_NUMBER;
464 ADOLC_OPENMP_GET_THREAD_NUMBER;
465 locint locat = next_loc();
466
467 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) { // old: write_args_d_a(pow_op,locat,cocval,x.loc());
468 #if defined(ADOLC_TRACK_ACTIVITY)
469 if (! ADOLC_GLOBAL_TAPE_VARS.actStore[x.loc()] ) {
470 locint tmploc = x.loc();
471 double temp = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
472 if (temp == 0.0) {
473 put_op(assign_d_zero);
474 ADOLC_PUT_LOCINT(tmploc);
475 } else if (temp == 1.0) {
476 put_op(assign_d_one);
477 ADOLC_PUT_LOCINT(tmploc);
478 } else {
479 put_op(assign_d);
480 ADOLC_PUT_LOCINT(tmploc);
481 ADOLC_PUT_VAL(temp);
482 }
483
484 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
485 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
486 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[tmploc]);
487 }
488 #endif
489 put_op(pow_op_p);
490 ADOLC_PUT_LOCINT(x.loc()); // = arg
491 ADOLC_PUT_LOCINT(p._idx); // = coval
492 ADOLC_PUT_LOCINT(locat); // = res
493
494 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
495 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
496 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
497 }
498
499 ADOLC_GLOBAL_TAPE_VARS.store[locat] =
500 ADOLC_MATH_NSP::pow(ADOLC_GLOBAL_TAPE_VARS.store[x.loc()],p._val);
501 #if defined(ADOLC_TRACK_ACTIVITY)
502 ADOLC_GLOBAL_TAPE_VARS.actStore[locat] = true;
503 #endif
504 ADOLC_OPENMP_RESTORE_THREAD_NUMBER;
505 return locat;
506 }
recipr(const pdouble & p)507 adub recipr( const pdouble& p) {
508 locint location;
509 ADOLC_OPENMP_THREAD_NUMBER;
510 ADOLC_OPENMP_GET_THREAD_NUMBER;
511
512 location = next_loc();
513 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
514 put_op(recipr_p);
515 ADOLC_PUT_LOCINT(p._idx);
516 ADOLC_PUT_LOCINT(location);
517
518 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
519 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
520 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
521 }
522 ADOLC_GLOBAL_TAPE_VARS.store[location] = 1.0/p._val;
523 #if defined(ADOLC_TRACK_ACTIVITY)
524 ADOLC_GLOBAL_TAPE_VARS.actStore[location] = true;
525 #endif
526 return location;
527 }
528
operator -(const pdouble & p)529 adub operator - (const pdouble& p) {
530 locint location;
531 ADOLC_OPENMP_THREAD_NUMBER;
532 ADOLC_OPENMP_GET_THREAD_NUMBER;
533
534 location = next_loc();
535 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
536 put_op(neg_sign_p);
537 ADOLC_PUT_LOCINT(p._idx);
538 ADOLC_PUT_LOCINT(location);
539
540 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
541 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
542 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[location]);
543 }
544 ADOLC_GLOBAL_TAPE_VARS.store[location] = -p._val;
545 #if defined(ADOLC_TRACK_ACTIVITY)
546 ADOLC_GLOBAL_TAPE_VARS.actStore[location] = true;
547 #endif
548 return location;
549 }
550
pow(const pdouble & p,const badouble & y)551 adouble pow( const pdouble& p, const badouble& y) {
552 adouble a1, a2, ret;
553 double vx = p._val;
554 double vy = y.getValue();
555 if (!(vx > 0)) {
556 if (vx < 0 || vy >= 0)
557 fprintf(DIAG_OUT,"\nADOL-C message: exponent of zero/negative basis deactivated\n");
558 else
559 fprintf(DIAG_OUT,"\nADOL-C message: negative exponent and zero basis deactivated\n");
560 }
561 condassign(a1, -y, (adouble) ADOLC_MATH_NSP::pow(vx,vy), pow(p,vy));
562 condassign(a2, fabs(adub(p)), pow(p, vy), a1);
563 condassign(ret, p, exp(y*log(adub(p))),a2);
564
565 return ret;
566 }
567
568 #if defined(ADOLC_ADVANCED_BRANCHING)
operator !=(const badouble & x,const pdouble & y)569 adub operator != (const badouble& x, const pdouble& y) {
570 ADOLC_OPENMP_THREAD_NUMBER;
571 ADOLC_OPENMP_GET_THREAD_NUMBER;
572 double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
573 double yval = y._val;
574 double res = (double)(xval != yval);
575 locint locat = next_loc();
576 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
577 put_op(neq_a_p);
578 ADOLC_PUT_LOCINT(x.loc()); // arg
579 ADOLC_PUT_LOCINT(y._idx); // arg1
580 ADOLC_PUT_VAL(res); // check for branch switch
581 ADOLC_PUT_LOCINT(locat); // res
582
583 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
584 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
585 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
586 }
587 ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
588 return locat;
589 }
590 /*--------------------------------------------------------------------------*/
operator ==(const badouble & x,const pdouble & y)591 adub operator == (const badouble& x, const pdouble& y) {
592 ADOLC_OPENMP_THREAD_NUMBER;
593 ADOLC_OPENMP_GET_THREAD_NUMBER;
594 double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
595 double yval = y._val;
596 double res = (double)(xval == yval);
597 locint locat = next_loc();
598 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
599 put_op(eq_a_p);
600 ADOLC_PUT_LOCINT(x.loc()); // arg
601 ADOLC_PUT_LOCINT(y._idx); // arg1
602 ADOLC_PUT_VAL(res); // check for branch switch
603 ADOLC_PUT_LOCINT(locat); // res
604
605 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
606 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
607 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
608 }
609 ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
610 return locat;
611 }
612 /*--------------------------------------------------------------------------*/
operator <=(const badouble & x,const pdouble & y)613 adub operator <= (const badouble& x, const pdouble& y) {
614 ADOLC_OPENMP_THREAD_NUMBER;
615 ADOLC_OPENMP_GET_THREAD_NUMBER;
616 double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
617 double yval = y._val;
618 double res = (double)(xval <= yval);
619 locint locat = next_loc();
620 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
621 put_op(le_a_p);
622 ADOLC_PUT_LOCINT(x.loc()); // arg
623 ADOLC_PUT_LOCINT(y._idx); // arg1
624 ADOLC_PUT_VAL(res); // check for branch switch
625 ADOLC_PUT_LOCINT(locat); // res
626
627 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
628 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
629 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
630 }
631 ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
632 return locat;
633 }
634 /*--------------------------------------------------------------------------*/
operator >=(const badouble & x,const pdouble & y)635 adub operator >= (const badouble& x, const pdouble& y) {
636 ADOLC_OPENMP_THREAD_NUMBER;
637 ADOLC_OPENMP_GET_THREAD_NUMBER;
638 double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
639 double yval = y._val;
640 double res = (double)(xval >= yval);
641 locint locat = next_loc();
642 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
643 put_op(ge_a_p);
644 ADOLC_PUT_LOCINT(x.loc()); // arg
645 ADOLC_PUT_LOCINT(y._idx); // arg1
646 ADOLC_PUT_VAL(res); // check for branch switch
647 ADOLC_PUT_LOCINT(locat); // res
648
649 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
650 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
651 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
652 }
653 ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
654 return locat;
655 }
656 /*--------------------------------------------------------------------------*/
operator >(const badouble & x,const pdouble & y)657 adub operator > (const badouble& x, const pdouble& y) {
658 ADOLC_OPENMP_THREAD_NUMBER;
659 ADOLC_OPENMP_GET_THREAD_NUMBER;
660 double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
661 double yval = y._val;
662 double res = (double)(xval > yval);
663 locint locat = next_loc();
664 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
665 put_op(gt_a_p);
666 ADOLC_PUT_LOCINT(x.loc()); // arg
667 ADOLC_PUT_LOCINT(y._idx); // arg1
668 ADOLC_PUT_VAL(res); // check for branch switch
669 ADOLC_PUT_LOCINT(locat); // res
670
671 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
672 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
673 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
674 }
675 ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
676 return locat;
677 }
678 /*--------------------------------------------------------------------------*/
operator <(const badouble & x,const pdouble & y)679 adub operator < (const badouble& x, const pdouble& y) {
680 ADOLC_OPENMP_THREAD_NUMBER;
681 ADOLC_OPENMP_GET_THREAD_NUMBER;
682 double xval = ADOLC_GLOBAL_TAPE_VARS.store[x.loc()];
683 double yval = y._val;
684 double res = (double)(xval < yval);
685 locint locat = next_loc();
686 if (ADOLC_CURRENT_TAPE_INFOS.traceFlag) {
687 put_op(lt_a_p);
688 ADOLC_PUT_LOCINT(x.loc()); // arg
689 ADOLC_PUT_LOCINT(y._idx); // arg1
690 ADOLC_PUT_VAL(res); // check for branch switch
691 ADOLC_PUT_LOCINT(locat); // res
692
693 ++ADOLC_CURRENT_TAPE_INFOS.numTays_Tape;
694 if (ADOLC_CURRENT_TAPE_INFOS.keepTaylors)
695 ADOLC_WRITE_SCAYLOR(ADOLC_GLOBAL_TAPE_VARS.store[locat]);
696 }
697 ADOLC_GLOBAL_TAPE_VARS.store[locat] = res;
698 return locat;
699 }
700 #endif
701