ADMB Documentation  -a65f1c97
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
fvar_m27.cpp
Go to the documentation of this file.
1 /*
2  * $Id$
3  *
4  * Author: David Fournier
5  * Copyright (c) 2008-2012 Regents of the University of California
6  */
11 // file fvar.cpp
12 // constructors, destructors and misc functions involving class prevariable
13 
14 #include "fvar.hpp"
15 
16 #ifdef __TURBOC__
17  #pragma hdrstop
18  #include <iostream.h>
19 #endif
20 
21 #ifdef __ZTC__
22  #include <iostream.hpp>
23 #endif
24 
25 
26 #include <stdio.h>
27 #ifndef __SUN__
28 #endif
29 #include <math.h>
30 
31 // dvar_matrix mathematical functions
32 dvar_matrix exp(const dvar_matrix& m);
33 dvar_matrix log(const dvar_matrix& m);
34 dvar_matrix sin(const dvar_matrix& m);
35 dvar_matrix cos(const dvar_matrix& m);
36 dvar_matrix tan(const dvar_matrix& m);
37 dvar_matrix pow(const dvar_matrix& m, const double e);
38 dvar_matrix pow(const dvar_matrix& m, const prevariable& e);
39 dvar_matrix pow(const dmatrix& m, const prevariable& e);
40 dvar_matrix pow(const dvar_matrix& m, int e);
41 dvar_matrix elem_prod(const dvar_matrix& m, const dvar_matrix& m2);
42 dvar_matrix elem_prod(const dvar_matrix& m, const dmatrix& m2);
43 dvar_matrix elem_prod(const dmatrix& m, const dvar_matrix& m2);
44 dvar_matrix elem_div(const dvar_matrix& m, const dvar_matrix& m2);
45 dvar_matrix elem_div(const dvar_matrix& m, const dmatrix& m2);
46 dvar_matrix elem_div(const dmatrix& m, const dvar_matrix& m2);
47 // end of dvar_vector mathematical functions
48 
49 /* "template form for editor
50 dvar_matrix XXX(const dvar_matrix& m)
51 {
52  ivector cmin(m.rowmin(),m.rowmax());
53  ivector cmax(m.rowmin(),m.rowmax());
54  for (int i=m.rowmin();i<=m.rowmax();i++)
55  {
56  cmin(i)=m(i).indexmin();
57  cmax(i)=m(i).indexmax();
58  }
59  dvar_matrix tmp(m.rowmin(),m.rowmax(),cmin,cmax);
60  for (i=m.rowmin();i<=m.rowmax();i++)
61  {
62  tmp(i)=XXX(m(i));
63  }
64  return tmp;
65 }
66 
67 */
68 
73 dvar_matrix use_shape(const dvar_matrix& m)
74 {
75  int min = m.rowmin();
76  int max = m.rowmax();
77  ivector cmin(min, max);
78  ivector cmax(min, max);
79  int* pcmini = cmin.get_v() + min;
80  int* pcmaxi = cmax.get_v() + min;
81  const dvar_vector* pmi = &m(min);
82  for (int i = min; i <= max; ++i)
83  {
84  *pcmini = pmi->indexmin();
85  *pcmaxi = pmi->indexmax();
86 
87  ++pmi;
88  ++pcmini;
89  ++pcmaxi;
90  }
91  dvar_matrix tmp(min, max, cmin, cmax);
92  return tmp;
93 }
94 
99 dmatrix use_shape(const dmatrix& m)
100 {
101  int min = m.rowmin();
102  int max = m.rowmax();
103  ivector cmin(min, max);
104  ivector cmax(min, max);
105 
106  int* pcmini = cmin.get_v() + min;
107  int* pcmaxi = cmax.get_v() + min;
108  const dvector* pmi = &m(min);
109  for (int i = min; i <= max; ++i)
110  {
111  *pcmini = pmi->indexmin();
112  *pcmaxi = pmi->indexmax();
113 
114  ++pmi;
115  ++pcmini;
116  ++pcmaxi;
117  }
118  dmatrix tmp(min, max, cmin, cmax);
119  return tmp;
120 }
121 
126 dvar_matrix pow(const dvar_matrix& m, int e)
127 {
128  dvar_matrix tmp = use_shape(m);
129 
130  int min = m.rowmin();
131  int max = m.rowmax();
132  dvar_vector* ptmpi = &tmp(min);
133  const dvar_vector* pmi = &m(min);
134  for (int i = min; i <= max; ++i)
135  {
136  *ptmpi = pow(*pmi, e);
137 
138  ++ptmpi;
139  ++pmi;
140  }
141  return tmp;
142 }
143 
148 dvar_matrix pow(const dmatrix& m, const prevariable& e)
149 {
150  dvar_matrix tmp = use_shape(m);
151 
152  int min = m.rowmin();
153  int max = m.rowmax();
154  dvar_vector* ptmpi = &tmp(min);
155  const dvector* pmi = &m(min);
156  for (int i = min; i <= max; ++i)
157  {
158  *ptmpi = pow(*pmi, e);
159 
160  ++ptmpi;
161  ++pmi;
162  }
163  return tmp;
164 }
165 
170 dvar_matrix pow(const dvar_matrix& m, const prevariable& e)
171 {
172  dvar_matrix tmp = use_shape(m);
173 
174  int min = m.rowmin();
175  int max = m.rowmax();
176  dvar_vector* ptmpi = &tmp(min);
177  const dvar_vector* pmi = &m(min);
178  for (int i = min; i <= max; ++i)
179  {
180  *ptmpi = pow(*pmi, e);
181 
182  ++ptmpi;
183  ++pmi;
184  }
185  return tmp;
186 }
187 
192 dvar_matrix pow(const dvar_matrix& m, const double e)
193 {
194  dvar_matrix tmp = use_shape(m);
195 
196  int min = m.rowmin();
197  int max = m.rowmax();
198  dvar_vector* ptmpi = &tmp(min);
199  const dvar_vector* pmi = &m(min);
200  for (int i = min; i <= max; ++i)
201  {
202  *ptmpi = pow(*pmi, e);
203 
204  ++ptmpi;
205  ++pmi;
206  }
207  return tmp;
208 }
209 
214 dvar_matrix tan(const dvar_matrix& m)
215 {
216  dvar_matrix tmp = use_shape(m);
217 
218  int min = m.rowmin();
219  int max = m.rowmax();
220  dvar_vector* ptmpi = &tmp(min);
221  const dvar_vector* pmi = &m(min);
222  for (int i = min; i <= max; ++i)
223  {
224  *ptmpi = tan(*pmi);
225 
226  ++ptmpi;
227  ++pmi;
228  }
229  return tmp;
230 }
231 
236 dvar_matrix cos(const dvar_matrix& m)
237 {
238  dvar_matrix tmp = use_shape(m);
239 
240  int min = m.rowmin();
241  int max = m.rowmax();
242  dvar_vector* ptmpi = &tmp(min);
243  const dvar_vector* pmi = &m(min);
244  for (int i = min; i <= max; ++i)
245  {
246  *ptmpi = cos(*pmi);
247 
248  ++ptmpi;
249  ++pmi;
250  }
251  return tmp;
252 }
253 
258 dvar_matrix sin(const dvar_matrix& m)
259 {
260  dvar_matrix tmp = use_shape(m);
261 
262  int min = m.rowmin();
263  int max = m.rowmax();
264  dvar_vector* ptmpi = &tmp(min);
265  const dvar_vector* pmi = &m(min);
266  for (int i = min; i <= max; ++i)
267  {
268  *ptmpi = sin(*pmi);
269 
270  ++ptmpi;
271  ++pmi;
272  }
273  return tmp;
274 }
275 
280 dvar_matrix log(const dvar_matrix& m)
281 {
282  dvar_matrix tmp = use_shape(m);
283 
284  int min = m.rowmin();
285  int max = m.rowmax();
286  dvar_vector* ptmpi = &tmp(min);
287  const dvar_vector* pmi = &m(min);
288  for (int i = min; i <= max; ++i)
289  {
290  *ptmpi = log(*pmi);
291 
292  ++ptmpi;
293  ++pmi;
294  }
295  return tmp;
296 }
297 
302 dvar_matrix sqrt(const dvar_matrix& m)
303 {
304  dvar_matrix tmp = use_shape(m);
305 
306  int min = m.rowmin();
307  int max = m.rowmax();
308  dvar_vector* ptmpi = &tmp(min);
309  const dvar_vector* pmi = &m(min);
310  for (int i = min; i <= max; ++i)
311  {
312  *ptmpi = sqrt(*pmi);
313 
314  ++ptmpi;
315  ++pmi;
316  }
317  return tmp;
318 }
319 
324 dvar_matrix sqr(const dvar_matrix& m)
325 {
326  dvar_matrix tmp = use_shape(m);
327 
328  int min = m.rowmin();
329  int max = m.rowmax();
330  dvar_vector* ptmpi = &tmp(min);
331  const dvar_vector* pmi = &m(min);
332  for (int i = min; i <= max; ++i)
333  {
334  *ptmpi = sqr(*pmi);
335 
336  ++ptmpi;
337  ++pmi;
338  }
339  return tmp;
340 }
341 
346 dvar_matrix exp(const dvar_matrix& m)
347 {
348  dvar_matrix tmp = use_shape(m);
349 
350  int min = m.rowmin();
351  int max = m.rowmax();
352  dvar_vector* ptmpi = &tmp(min);
353  const dvar_vector* pmi = &m(min);
354  for (int i = min; i <= max; ++i)
355  {
356  *ptmpi = exp(*pmi);
357 
358  ++ptmpi;
359  ++pmi;
360  }
361  return tmp;
362 }
363 
368 dvar_matrix elem_div(const dvar_matrix& m, const dvar_matrix& m2)
369 {
370  dvar_matrix tmp = use_shape(m);
371 
372  int min = m.rowmin();
373  int max = m.rowmax();
374  dvar_vector* ptmpi = &tmp(min);
375  const dvar_vector* pmi = &m(min);
376  const dvar_vector* pm2i = &m2(min);
377  for (int i = min; i <= max; ++i)
378  {
379  *ptmpi = elem_div(*pmi, *pm2i);
380 
381  ++ptmpi;
382  ++pmi;
383  ++pm2i;
384  }
385  return tmp;
386 }
387 
392 dvar_matrix elem_div(const dmatrix& m,const dvar_matrix& m2)
393 {
394  dvar_matrix tmp = use_shape(m);
395 
396  int min = m.rowmin();
397  int max = m.rowmax();
398  dvar_vector* ptmpi = &tmp(min);
399  const dvector* pmi = &m(min);
400  const dvar_vector* pm2i = &m2(min);
401  for (int i = min; i <= max; ++i)
402  {
403  *ptmpi = elem_div(*pmi, *pm2i);
404 
405  ++ptmpi;
406  ++pmi;
407  ++pm2i;
408  }
409  return tmp;
410 }
411 
416 dvar_matrix elem_div(const dvar_matrix& m, const dmatrix& m2)
417 {
418  dvar_matrix tmp = use_shape(m);
419 
420  int min = m.rowmin();
421  int max = m.rowmax();
422  dvar_vector* ptmpi = &tmp(min);
423  const dvar_vector* pmi = &m(min);
424  const dvector* pm2i = &m2(min);
425  for (int i = min; i <= max; ++i)
426  {
427  *ptmpi = elem_div(*pmi, *pm2i);
428 
429  ++ptmpi;
430  ++pmi;
431  ++pm2i;
432  }
433  return tmp;
434 }
435 
440 dvar_matrix elem_prod(const dvar_matrix& m, const dvar_matrix& m2)
441 {
442  //dvar_matrix tmp=use_shape(m);
443  int min = m.rowmin();
444  int max = m.rowmax();
445  dvar_matrix tmp(min, max);
446 
447  dvar_vector* ptmpi = &tmp(min);
448  const dvar_vector* pmi = &m(min);
449  const dvar_vector* pm2i = &m2(min);
450  for (int i = min; i <= max; ++i)
451  {
452  *ptmpi = elem_prod(*pmi, *pm2i);
453 
454  ++ptmpi;
455  ++pmi;
456  ++pm2i;
457  }
458  return tmp;
459 }
460 
465 dvar_matrix elem_prod(const dmatrix& m, const dvar_matrix& m2)
466 {
467  dvar_matrix tmp = use_shape(m);
468 
469  int min = m.rowmin();
470  int max = m.rowmax();
471  dvar_vector* ptmpi = &tmp(min);
472  const dvector* pmi = &m(min);
473  const dvar_vector* pm2i = &m2(min);
474  for (int i = min; i <= max; ++i)
475  {
476  *ptmpi = elem_prod(*pmi, *pm2i);
477 
478  ++ptmpi;
479  ++pmi;
480  ++pm2i;
481  }
482  return tmp;
483 }
484 
489 dvar_matrix elem_prod(const dvar_matrix& m, const dmatrix& m2)
490 {
491  dvar_matrix tmp = use_shape(m);
492 
493  int min = m.rowmin();
494  int max = m.rowmax();
495  dvar_vector* ptmpi = &tmp(min);
496  const dvar_vector* pmi = &m(min);
497  const dvector* pm2i = &m2(min);
498  for (int i = min; i <= max; ++i)
499  {
500  *ptmpi = elem_prod(*pmi, *pm2i);
501 
502  ++ptmpi;
503  ++pmi;
504  ++pm2i;
505  }
506  return tmp;
507 }
508 
513 dvar_matrix operator+(const double x, const dvar_matrix& m)
514 {
515  dvar_matrix tmp = use_shape(m);
516 
517  int min = m.rowmin();
518  int max = m.rowmax();
519  dvar_vector* ptmpi = &tmp(min);
520  const dvar_vector* pmi = &m(min);
521  for (int i = min; i <= max; ++i)
522  {
523  *ptmpi = x + *pmi;
524 
525  ++ptmpi;
526  ++pmi;
527  }
528  return tmp;
529 }
530 
535 dvar_matrix operator*(const prevariable& x, const dvar_matrix& m)
536 {
537  dvar_matrix tmp = use_shape(m);
538 
539  int min = m.rowmin();
540  int max = m.rowmax();
541  dvar_vector* ptmpi = &tmp(min);
542  const dvar_vector* pmi = &m(min);
543  for (int i = min; i <= max; ++i)
544  {
545  *ptmpi = x * *pmi;
546 
547  ++ptmpi;
548  ++pmi;
549  }
550  return tmp;
551 }
552 
557 dvar_matrix operator+(const dvar_matrix& m, const double x)
558 {
559  dvar_matrix tmp = use_shape(m);
560 
561  int min = m.rowmin();
562  int max = m.rowmax();
563  dvar_vector* ptmpi = &tmp(min);
564  const dvar_vector* pmi = &m(min);
565  for (int i = min; i <= max; ++i)
566  {
567  *ptmpi = *pmi + x;
568 
569  ++ptmpi;
570  ++pmi;
571  }
572  return tmp;
573 }
574 
579 dvar_matrix operator+(const dvariable& x, const dvar_matrix& m)
580 {
581  dvar_matrix tmp = use_shape(m);
582 
583  int min = m.rowmin();
584  int max = m.rowmax();
585  dvar_vector* ptmpi = &tmp(min);
586  const dvar_vector* pmi = &m(min);
587  for (int i = min; i <= max; ++i)
588  {
589  *ptmpi = x + *pmi;
590 
591  ++ptmpi;
592  ++pmi;
593  }
594  return tmp;
595 }
596 
601 dvar_matrix operator+(const dvar_matrix& m, const dvariable& x)
602 {
603  dvar_matrix tmp = use_shape(m);
604 
605  int min = m.rowmin();
606  int max = m.rowmax();
607  dvar_vector* ptmpi = &tmp(min);
608  const dvar_vector* pmi = &m(min);
609  for (int i = min; i <= max; ++i)
610  {
611  *ptmpi = *pmi + x;
612 
613  ++ptmpi;
614  ++pmi;
615  }
616  return tmp;
617 }
618 
623 dvar_matrix operator*(const dvar_matrix& m, const prevariable& x)
624 {
625  dvar_matrix tmp = use_shape(m);
626 
627  int min = m.rowmin();
628  int max = m.rowmax();
629  dvar_vector* ptmpi = &tmp(min);
630  const dvar_vector* pmi = &m(min);
631  for (int i = min; i <= max; ++i)
632  {
633  *ptmpi = *pmi * x;
634 
635  ++ptmpi;
636  ++pmi;
637  }
638  return tmp;
639 }
640 
645 dvar_matrix operator-(const dvar_matrix& m, const double x)
646 {
647  dvar_matrix tmp=use_shape(m);
648 
649  int min = m.rowmin();
650  int max = m.rowmax();
651  dvar_vector* ptmpi = &tmp(min);
652  const dvar_vector* pmi = &m(min);
653  for (int i = min; i <= max; ++i)
654  {
655  *ptmpi = *pmi - x;
656 
657  ++ptmpi;
658  ++pmi;
659  }
660  return tmp;
661 }
662 
667 dvar_matrix operator-(const double x, const dvar_matrix& m)
668 {
669  dvar_matrix tmp = use_shape(m);
670 
671  int min = m.rowmin();
672  int max = m.rowmax();
673  dvar_vector* ptmpi = &tmp(min);
674  const dvar_vector* pmi = &m(min);
675  for (int i = min; i <= max; ++i)
676  {
677  *ptmpi = x - *pmi;
678 
679  ++ptmpi;
680  ++pmi;
681  }
682  return tmp;
683 }
684 
689 dvar_matrix operator-(const dvar_matrix& m, const dvariable& x)
690 {
691  dvar_matrix tmp = use_shape(m);
692 
693  int min = m.rowmin();
694  int max = m.rowmax();
695  dvar_vector* ptmpi = &tmp(min);
696  const dvar_vector* pmi = &m(min);
697  for (int i = min; i <= max; ++i)
698  {
699  *ptmpi = *pmi - x;
700 
701  ++ptmpi;
702  ++pmi;
703  }
704  return tmp;
705 }
706 
711 dvar_matrix operator-(const dvariable& x, const dvar_matrix& m)
712 {
713  dvar_matrix tmp = use_shape(m);
714 
715  int min = m.rowmin();
716  int max = m.rowmax();
717  dvar_vector* ptmpi = &tmp(min);
718  const dvar_vector* pmi = &m(min);
719  for (int i = min; i <= max; ++i)
720  {
721  *ptmpi = x - *pmi;
722 
723  ++ptmpi;
724  ++pmi;
725  }
726  return tmp;
727 }
prevariable
Base class for dvariable.
Definition: fvar.hpp:1315
tan
d3_array tan(const d3_array &arr3)
Returns d3_array results with computed tan from elements in arr3.
Definition: d3arr2a.cpp:73
sqr
d3_array sqr(const d3_array &arr3)
Returns d3_array with square values from arr3.
Definition: d3arr2c.cpp:25
elem_prod
d3_array elem_prod(const d3_array &a, const d3_array &b)
Returns d3_array results with computed elements product of a(i, j, k) * b(i, j, k).
Definition: d3arr2a.cpp:92
dvar_matrix::rowmax
int rowmax(void) const
Definition: fvar.hpp:2564
operator-
d3_array operator-(const d3_array &a, const d3_array &b)
Returns d3_array results with computed elements addition of a(i, j, k) + b(i, j, k).
Definition: d3arr2a.cpp:152
x
#define x
dvector
Vector of double precision numbers.
Definition: dvector.h:50
dvector::indexmin
int indexmin() const
Get minimum valid index.
Definition: dvector.h:199
operator+
d3_array operator+(const d3_array &a, const d3_array &b)
Returns d3_array results with computed elements addition of a(i, j, k) + b(i, j, k).
Definition: d3arr2a.cpp:132
elem_div
d3_array elem_div(const d3_array &a, const d3_array &b)
Returns d3_array results with computed elements division of a(i, j, k) / b(i, j, k).
Definition: d3arr2a.cpp:112
sin
d3_array sin(const d3_array &arr3)
Returns d3_array results with computed sin from elements in arr3.
Definition: d3arr2a.cpp:43
dvar_vector
ADMB variable vector.
Definition: fvar.hpp:2172
operator*
dmatrix operator*(const d3_array &t, const dvector &v)
Description not yet available.
Definition: d3arr12.cpp:17
ivector::get_v
int * get_v() const
Definition: ivector.h:114
ivector
Array of integers(int) with indexes from index_min to indexmax.
Definition: ivector.h:50
dmatrix::rowmax
int rowmax() const
Definition: fvar.hpp:2929
sqrt
d3_array sqrt(const d3_array &arr3)
Author: David Fournier Copyright (c) 2008-2012 Regents of the University of California.
Definition: d3arr2c.cpp:11
min
#define min(a, b)
Definition: cbivnorm.cpp:188
dvector::indexmax
int indexmax() const
Get maximum valid index.
Definition: dvector.h:204
fvar.hpp
Author: David Fournier Copyright (c) 2008-2012 Regents of the University of California.
exp
d3_array exp(const d3_array &arr3)
Returns d3_array results with computed exp from elements in arr3.
Definition: d3arr2a.cpp:28
dvar_matrix::rowmin
int rowmin(void) const
Definition: fvar.hpp:2560
dmatrix
Description not yet available.
Definition: fvar.hpp:2819
dvar_vector::indexmin
int indexmin() const
Definition: fvar.hpp:2287
cos
d3_array cos(const d3_array &arr3)
Returns d3_array results with computed cos from elements in arr3.
Definition: d3arr2a.cpp:58
dvar_matrix
Class definition of matrix with derivitive information .
Definition: fvar.hpp:2480
max
#define max(a, b)
Definition: cbivnorm.cpp:189
dvar_vector::indexmax
int indexmax() const
Definition: fvar.hpp:2292
dmatrix::rowmin
int rowmin() const
Definition: fvar.hpp:2925
dvariable
Fundamental data type for reverse mode automatic differentiation.
Definition: fvar.hpp:1518
log
d3_array log(const d3_array &arr3)
Author: David Fournier Copyright (c) 2008-2012 Regents of the University of California.
Definition: d3arr2a.cpp:13
pow
d3_array pow(const d3_array &m, int e)
Description not yet available.
Definition: d3arr6.cpp:17
use_shape
dvar_matrix use_shape(const dvar_matrix &m)
Description not yet available.
Definition: fvar_m27.cpp:73
ADMB Generated on Wed Sep 7 2022 00:01:28 for ADMB Documentation by doxygen 1.8.5