1 | $Id: fun_deprecated.omh 3607 2015-01-20 16:20:41Z bradbell $ |
---|
2 | /* -------------------------------------------------------------------------- |
---|
3 | CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell |
---|
4 | |
---|
5 | CppAD is distributed under multiple licenses. This distribution is under |
---|
6 | the terms of the |
---|
7 | Eclipse Public License Version 1.0. |
---|
8 | |
---|
9 | A copy of this license is included in the COPYING file of this distribution. |
---|
10 | Please visit http://www.coin-or.org/CppAD/ for information on other licenses. |
---|
11 | -------------------------------------------------------------------------- */ |
---|
12 | $begin FunDeprecated$$ |
---|
13 | $spell |
---|
14 | bool |
---|
15 | VecAD |
---|
16 | CppAD |
---|
17 | const |
---|
18 | Taylor |
---|
19 | sizeof |
---|
20 | var |
---|
21 | $$ |
---|
22 | |
---|
23 | $section ADFun Object Deprecated Member Functions$$ |
---|
24 | |
---|
25 | $head Syntax$$ |
---|
26 | $icode%f%.Dependent(%y%) |
---|
27 | %$$ |
---|
28 | $icode%o% = %f%.Order() |
---|
29 | %$$ |
---|
30 | $icode%m% = %f%.Memory() |
---|
31 | %$$ |
---|
32 | $icode%s% = %f%.Size() |
---|
33 | %$$ |
---|
34 | $icode%t% = %f%.taylor_size() |
---|
35 | %$$ |
---|
36 | $icode%u% = %f%.use_VecAD() |
---|
37 | %$$ |
---|
38 | $icode%v% = %f%.size_taylor() |
---|
39 | %$$ |
---|
40 | $icode%w% = %f%.capacity_taylor() |
---|
41 | %$$ |
---|
42 | |
---|
43 | |
---|
44 | $head Purpose$$ |
---|
45 | The $codei%ADFun<%Base%>%$$ functions documented here have been deprecated; |
---|
46 | i.e., they are no longer approved of and may be removed from some future |
---|
47 | version of CppAD. |
---|
48 | |
---|
49 | $head Dependent$$ |
---|
50 | $index ADFun, Dependent$$ |
---|
51 | $index Dependent, ADFun$$ |
---|
52 | A recording of and AD of $icode Base$$ |
---|
53 | $cref/operation sequence/glossary/Operation/Sequence/$$ |
---|
54 | is started by a call of the form |
---|
55 | $codei% |
---|
56 | Independent(%x%) |
---|
57 | %$$ |
---|
58 | If there is only one such recording at the current time, |
---|
59 | you can use $icode%f%.Dependent(%y%)%$$ in place of |
---|
60 | $codei% |
---|
61 | %f%.Dependent(%x%, %y%) |
---|
62 | %$$ |
---|
63 | See $cref Dependent$$ for a description of this operation. |
---|
64 | |
---|
65 | $subhead Deprecated 2007-08-07$$ |
---|
66 | This syntax was deprecated when CppAD was extended to allow |
---|
67 | for more than one $codei%AD<%Base%>%$$ recording to be |
---|
68 | active at one time. |
---|
69 | This was necessary to allow for multiple threading applications. |
---|
70 | |
---|
71 | $head Order$$ |
---|
72 | $index ADFun, Order$$ |
---|
73 | $index Order, ADFun$$ |
---|
74 | The result $icode o$$ has prototype |
---|
75 | $codei% |
---|
76 | size_t %o% |
---|
77 | %$$ |
---|
78 | and is the order of the previous forward operation |
---|
79 | using the function $icode f$$. |
---|
80 | This is the highest order of the |
---|
81 | $cref/Taylor coefficients/glossary/Taylor Coefficient/$$ |
---|
82 | that are currently stored in $icode f$$. |
---|
83 | |
---|
84 | $subhead Deprecated 2006-03-31$$ |
---|
85 | Zero order corresponds to function values being stored in $icode f$$. |
---|
86 | In the future, we would like to be able to erase the function |
---|
87 | values so that $icode f$$ uses less memory. |
---|
88 | In this case, the return value of $code Order$$ would not make sense. |
---|
89 | Use $cref size_order$$ to obtain |
---|
90 | the number of Taylor coefficients currently stored |
---|
91 | in the ADFun object $icode f$$ |
---|
92 | (which is equal to the order plus one). |
---|
93 | |
---|
94 | |
---|
95 | $head Memory$$ |
---|
96 | $index ADFun, Memory$$ |
---|
97 | $index Memory, ADFun$$ |
---|
98 | The result |
---|
99 | $codei% |
---|
100 | size_t %m% |
---|
101 | %$$ |
---|
102 | and is the number of memory units ($code sizeof$$) required for the |
---|
103 | information currently stored in $icode f$$. |
---|
104 | This memory is returned to the system when the destructor for |
---|
105 | $icode f$$ is called. |
---|
106 | |
---|
107 | $subhead Deprecated 2006-03-31$$ |
---|
108 | It used to be the case that an ADFun object just kept increasing its |
---|
109 | buffers to the maximum size necessary during its lifetime. |
---|
110 | It would then return the buffers to the system when its destructor |
---|
111 | was called. |
---|
112 | This is no longer the case, an ADFun object now returns memory |
---|
113 | when it no longer needs the values stored in that memory. |
---|
114 | Thus the $code Memory$$ function is no longer well defined. |
---|
115 | |
---|
116 | $head Size$$ |
---|
117 | $index ADFun, Size$$ |
---|
118 | $index Size, ADFun$$ |
---|
119 | The result $icode s$$ has prototype |
---|
120 | $codei% |
---|
121 | size_t %s% |
---|
122 | %$$ |
---|
123 | and is the number of variables in the operation sequence plus the following: |
---|
124 | one for a phantom variable with tape address zero, |
---|
125 | one for each component of the domain that is a parameter. |
---|
126 | The amount of work and memory necessary for computing function values |
---|
127 | and derivatives using $icode f$$ is roughly proportional to $icode s$$. |
---|
128 | |
---|
129 | $subhead Deprecated 2006-04-03$$ |
---|
130 | There are other sizes attached to an ADFun object, for example, |
---|
131 | the number of operations in the sequence. |
---|
132 | In order to avoid confusion with these other sizes, |
---|
133 | use $cref/size_var/seq_property/size_var/$$ to obtain |
---|
134 | the number of variables in the operation sequence. |
---|
135 | |
---|
136 | $head taylor_size$$ |
---|
137 | $index ADFun, taylor_size$$ |
---|
138 | $index taylor_size, ADFun$$ |
---|
139 | The result $icode t$$ has prototype |
---|
140 | $codei% |
---|
141 | size_t %t% |
---|
142 | %$$ |
---|
143 | and is the number of Taylor coefficient orders |
---|
144 | currently calculated and stored in the ADFun object $icode f$$. |
---|
145 | |
---|
146 | $subhead Deprecated 2006-06-17$$ |
---|
147 | This function has been replaced by $cref size_order$$. |
---|
148 | |
---|
149 | $head use_VecAD$$ |
---|
150 | $index ADFun, use_VecAD$$ |
---|
151 | $index use_VecAD, ADFun$$ |
---|
152 | The result $icode u$$ has prototype |
---|
153 | $codei% |
---|
154 | bool %u% |
---|
155 | %$$ |
---|
156 | If it is true, the |
---|
157 | AD of $icode Base$$ |
---|
158 | $cref/operation sequence/glossary/Operation/Sequence/$$ |
---|
159 | stored in $icode f$$ contains |
---|
160 | $cref/VecAD/VecAD/VecAD<Base>::reference/$$ operands. |
---|
161 | Otherwise $icode u$$ is false. |
---|
162 | |
---|
163 | $subhead Deprecated 2006-04-08$$ |
---|
164 | You can instead use |
---|
165 | $codei% |
---|
166 | %u% = %f%.size_VecAD() > 0 |
---|
167 | %$$ |
---|
168 | |
---|
169 | $head size_taylor$$ |
---|
170 | $index ADFun, size_taylor$$ |
---|
171 | $index size_taylor, ADFun$$ |
---|
172 | The result $icode v$$ has prototype |
---|
173 | $codei% |
---|
174 | size_t %v% |
---|
175 | %$$ |
---|
176 | and is the number of Taylor coefficient orders |
---|
177 | currently calculated and stored in the ADFun object $icode f$$. |
---|
178 | |
---|
179 | $subhead Deprecated 2014-03-18$$ |
---|
180 | This function has been replaced by $cref size_order$$. |
---|
181 | |
---|
182 | $head capacity_taylor$$ |
---|
183 | $index ADFun, capacity_taylor$$ |
---|
184 | $index capacity_taylor, ADFun$$ |
---|
185 | The result $icode w$$ has prototype |
---|
186 | $codei% |
---|
187 | size_t %w% |
---|
188 | %$$ |
---|
189 | and is the number of Taylor coefficient orders currently allocated |
---|
190 | in the ADFun object $icode f$$. |
---|
191 | |
---|
192 | $subhead Deprecated 2014-03-18$$ |
---|
193 | This function has been replaced by $cref capacity_order$$. |
---|
194 | |
---|
195 | |
---|
196 | $end |
---|