CppADCodeGen 2.4.3
A C++ Algorithmic Differentiation Package with Source Code Generation
Loading...
Searching...
No Matches
iter_equation_group.hpp
1#ifndef CPPAD_CG_ITER_EQUATION_GROUP_INCLUDED
2#define CPPAD_CG_ITER_EQUATION_GROUP_INCLUDED
3/* --------------------------------------------------------------------------
4 * CppADCodeGen: C++ Algorithmic Differentiation with Source Code Generation:
5 * Copyright (C) 2013 Ciengis
6 *
7 * CppADCodeGen is distributed under multiple licenses:
8 *
9 * - Eclipse Public License Version 1.0 (EPL1), and
10 * - GNU General Public License Version 3 (GPL3).
11 *
12 * EPL1 terms and conditions can be found in the file "epl-v10.txt", while
13 * terms and conditions for the GPL3 can be found in the file "gpl3.txt".
14 * ----------------------------------------------------------------------------
15 * Author: Joao Leal
16 */
17
18namespace CppAD {
19namespace cg {
20
24template <class Base>
26public:
28 using Arg = Argument<Base>;
29 using pairss = std::pair<size_t, size_t>;
30private:
31 static const std::vector<std::set<pairss> > EMPTYVECTORSETSS;
32 static const std::vector<std::set<size_t> > EMPTYVECTORSETS;
33 static const std::map<size_t, std::set<size_t> > EMPTYMAPSETS;
34public:
36 size_t index;
38 std::set<size_t> tapeI;
40 std::set<size_t> iterations;
42 LoopModel<Base>* model;
43private:
47 std::vector<std::set<size_t> > hessTapeSparsity_;
48 bool hessSparsity_;
53 std::map<pairss, std::vector<std::set<pairss> > > hessOrig2Iter2TapeJ1TapeJ2_;
58 std::map<pairss, std::vector<std::set<size_t> > > hessOrig2Iter2TapeJ1OrigJ2_;
63 std::map<pairss, std::vector<std::set<size_t> > > hessOrig2Iter2OrigJ1TapeJ2_;
68 std::set<pairss> hessOrigJ1OrigJ2_;
73 std::map<pairss, std::map<size_t, std::set<size_t> > > hessOrig2TempTapeJ22Iter_;
74public:
75
76 inline IterEquationGroup() :
77 index((std::numeric_limits<size_t>::max)()), // not really required
78 model(nullptr),
79 hessSparsity_(false) {
80 }
81
82 inline void evalHessianSparsity() {
83 if (hessSparsity_) {
84 return; // already evaluated
85 }
86
87 CPPADCG_ASSERT_UNKNOWN(model != nullptr);
88 size_t iterationCount = model->getIterationCount();
89
90 const std::vector<std::vector<LoopPosition> >& indexedIndepIndexes = model->getIndexedIndepIndexes();
91 const std::vector<LoopPosition>& nonIndexedIndepIndexes = model->getNonIndexedIndepIndexes();
92 const std::vector<LoopPosition>& temporaryIndependents = model->getTemporaryIndependents();
93
94 ADFun<CGB>& fun = model->getTape();
95
96 hessTapeSparsity_ = hessianSparsitySet<std::vector<std::set<size_t> >, CGB>(fun, tapeI);
97
101 size_t nIndexed = indexedIndepIndexes.size();
102 size_t nNonIndexed = nonIndexedIndepIndexes.size();
103 size_t nTemp = temporaryIndependents.size();
104
105 for (size_t iter : iterations) {
109 for (size_t tapeJ1 = 0; tapeJ1 < nIndexed; tapeJ1++) {
110 const std::set<size_t>& hessRow = hessTapeSparsity_[tapeJ1];
111 size_t j1 = indexedIndepIndexes[tapeJ1][iter].original;
112
113 std::set<size_t> ::const_iterator itTape2;
114 for (itTape2 = hessRow.begin(); itTape2 != hessRow.end() && *itTape2 < nIndexed; ++itTape2) {
115 size_t j2 = indexedIndepIndexes[*itTape2][iter].original;
116 pairss orig(j1, j2);
117 pairss tapeTape(tapeJ1, *itTape2);
118 std::vector<std::set<pairss> >& iterations = hessOrig2Iter2TapeJ1TapeJ2_[orig];
119 iterations.resize(iterationCount);
120 iterations[iter].insert(tapeTape);
121 }
122
123 for (; itTape2 != hessRow.end() && *itTape2 < nIndexed + nNonIndexed; ++itTape2) {
124 size_t j2 = nonIndexedIndepIndexes[*itTape2 - nIndexed].original;
125 pairss orig(j1, j2);
126 std::vector<std::set<size_t> >& iterations = hessOrig2Iter2TapeJ1OrigJ2_[orig];
127 iterations.resize(iterationCount);
128 iterations[iter].insert(tapeJ1);
129 }
130 }
131
135 for (size_t tapeJ1 = nIndexed; tapeJ1 < nIndexed + nNonIndexed; tapeJ1++) {
136 const std::set<size_t>& hessRow = hessTapeSparsity_[tapeJ1];
137 size_t j1 = nonIndexedIndepIndexes[tapeJ1 - nIndexed].original;
138
139 std::set<size_t> ::const_iterator itTape2;
140 for (itTape2 = hessRow.begin(); itTape2 != hessRow.end() && *itTape2 < nIndexed; ++itTape2) {
141 size_t j2 = indexedIndepIndexes[*itTape2][iter].original;
142 pairss orig(j1, j2);
143 std::vector<std::set<size_t> >& iterations = hessOrig2Iter2OrigJ1TapeJ2_[orig];
144 iterations.resize(iterationCount);
145 iterations[iter].insert(*itTape2);
146 }
147
148 for (; itTape2 != hessRow.end() && *itTape2 < nIndexed + nNonIndexed; ++itTape2) {
149 size_t j2 = nonIndexedIndepIndexes[*itTape2 - nIndexed].original;
150 pairss orig(j1, j2);
151 hessOrigJ1OrigJ2_.insert(orig);
152 }
153 }
154
158 for (size_t tapeJ1 = nIndexed + nNonIndexed; tapeJ1 < nIndexed + nNonIndexed + nTemp; tapeJ1++) {
159 const std::set<size_t>& hessRow = hessTapeSparsity_[tapeJ1];
160 size_t k1 = temporaryIndependents[tapeJ1 - nIndexed - nNonIndexed].original;
161
162 std::set<size_t> ::const_iterator itTape2;
163 for (itTape2 = hessRow.begin(); itTape2 != hessRow.end() && *itTape2 < nIndexed; ++itTape2) {
164 size_t j2 = indexedIndepIndexes[*itTape2][iter].original;
165 pairss pos(k1, j2);
166 std::map<size_t, std::set<size_t> >& var2iters = hessOrig2TempTapeJ22Iter_[pos];
167 var2iters[*itTape2].insert(iter);
168 }
169
170 }
171 }
172
173 hessSparsity_ = true;
174
175 }
176
177 inline const std::vector<std::set<size_t> >& getHessianSparsity() const {
178 return hessTapeSparsity_;
179 }
180
188 inline const std::vector<std::set<pairss> >& getHessianIndexedIndexedTapeIndexes(size_t origJ1,
189 size_t origJ2) const {
190 pairss orig(origJ1, origJ2);
191
192 std::map<pairss, std::vector<std::set<pairss> > >::const_iterator it;
193 it = hessOrig2Iter2TapeJ1TapeJ2_.find(orig);
194 if (it != hessOrig2Iter2TapeJ1TapeJ2_.end()) {
195 return it->second;
196 } else {
197 return EMPTYVECTORSETSS;
198 }
199 }
200
201 inline const std::vector<std::set<size_t> >& getHessianIndexedNonIndexedTapeIndexes(size_t origJ1,
202 size_t origJ2) const {
203 pairss orig(origJ1, origJ2);
204
205 std::map<pairss, std::vector<std::set<size_t> > > ::const_iterator it;
206 it = hessOrig2Iter2TapeJ1OrigJ2_.find(orig);
207 if (it != hessOrig2Iter2TapeJ1OrigJ2_.end()) {
208 return it->second;
209 } else {
210 return EMPTYVECTORSETS;
211 }
212 }
213
214 inline const std::vector<std::set<size_t> >& getHessianNonIndexedIndexedTapeIndexes(size_t origJ1,
215 size_t origJ2) const {
216 pairss orig(origJ1, origJ2);
217
218 std::map<pairss, std::vector<std::set<size_t> > >::const_iterator it;
219 it = hessOrig2Iter2OrigJ1TapeJ2_.find(orig);
220 if (it != hessOrig2Iter2OrigJ1TapeJ2_.end()) {
221 return it->second;
222 } else {
223 return EMPTYVECTORSETS;
224 }
225 }
226
227 inline const std::set<std::pair<size_t, size_t> >& getHessianNonIndexedNonIndexedIndexes() const {
228 return hessOrigJ1OrigJ2_;
229 }
230
231 inline const std::map<size_t, std::set<size_t> >& getHessianTempIndexedTapeIndexes(size_t k1,
232 size_t origJ2) const {
233 pairss pos(k1, origJ2);
234
235 std::map<pairss, std::map<size_t, std::set<size_t> > >::const_iterator it;
236 it = hessOrig2TempTapeJ22Iter_.find(pos);
237 if (it != hessOrig2TempTapeJ22Iter_.end()) {
238 return it->second;
239 } else {
240 return EMPTYMAPSETS;
241 }
242 }
243
244};
245
246template<class Base>
247const std::vector<std::set<std::pair<size_t, size_t> > > IterEquationGroup<Base>::EMPTYVECTORSETSS;
248
249template<class Base>
250const std::vector<std::set<size_t> > IterEquationGroup<Base>::EMPTYVECTORSETS;
251
252template<class Base>
253const std::map<size_t, std::set<size_t> > IterEquationGroup<Base>::EMPTYMAPSETS;
254
255} // END cg namespace
256} // END CppAD namespace
257
258#endif
const std::vector< std::set< pairss > > & getHessianIndexedIndexedTapeIndexes(size_t origJ1, size_t origJ2) const
std::set< size_t > tapeI
equations indexes in tape of the loop model
std::set< size_t > iterations
iterations which only have these equations defined
size_t index
iteration group index/ID
const std::vector< LoopPosition > & getTemporaryIndependents() const
const std::vector< std::vector< LoopPosition > > & getIndexedIndepIndexes() const
const size_t getIterationCount() const
const std::vector< LoopPosition > & getNonIndexedIndepIndexes() const
ADFun< CGB > & getTape() const