CppADCodeGen 2.4.3
A C++ Algorithmic Differentiation Package with Source Code Generation
Loading...
Searching...
No Matches
model_c_source_gen.hpp
1#ifndef CPPAD_CG_MODEL_C_SOURCE_GEN_INCLUDED
2#define CPPAD_CG_MODEL_C_SOURCE_GEN_INCLUDED
3/* --------------------------------------------------------------------------
4 * CppADCodeGen: C++ Algorithmic Differentiation with Source Code Generation:
5 * Copyright (C) 2012 Ciengis
6 * Copyright (C) 2019 Joao Leal
7 *
8 * CppADCodeGen is distributed under multiple licenses:
9 *
10 * - Eclipse Public License Version 1.0 (EPL1), and
11 * - GNU General Public License Version 3 (GPL3).
12 *
13 * EPL1 terms and conditions can be found in the file "epl-v10.txt", while
14 * terms and conditions for the GPL3 can be found in the file "gpl3.txt".
15 * ----------------------------------------------------------------------------
16 * Author: Joao Leal
17 */
18
19namespace CppAD {
20namespace cg {
21
26public:
27 std::vector<std::set<size_t> > locations; // location of each index in the compressed array
28 std::vector<size_t> indexes; // row or column index
29 bool ordered;
30};
31
37template<class Base>
40 using ADCG = CppAD::AD<CGBase>;
41 using SparsitySetType = std::vector<std::set<size_t> >;
42 using TapeVarType = std::pair<size_t, size_t>; // tape independent -> reference orig independent (temporaries only)
43public:
44 static const std::string FUNCTION_FORWAD_ZERO;
45 static const std::string FUNCTION_JACOBIAN;
46 static const std::string FUNCTION_HESSIAN;
47 static const std::string FUNCTION_FORWARD_ONE;
48 static const std::string FUNCTION_REVERSE_ONE;
49 static const std::string FUNCTION_REVERSE_TWO;
50 static const std::string FUNCTION_SPARSE_JACOBIAN;
51 static const std::string FUNCTION_SPARSE_HESSIAN;
52 static const std::string FUNCTION_JACOBIAN_SPARSITY;
53 static const std::string FUNCTION_HESSIAN_SPARSITY;
54 static const std::string FUNCTION_HESSIAN_SPARSITY2;
55 static const std::string FUNCTION_SPARSE_FORWARD_ONE;
56 static const std::string FUNCTION_SPARSE_REVERSE_ONE;
57 static const std::string FUNCTION_SPARSE_REVERSE_TWO;
58 static const std::string FUNCTION_FORWARD_ONE_SPARSITY;
59 static const std::string FUNCTION_REVERSE_ONE_SPARSITY;
60 static const std::string FUNCTION_REVERSE_TWO_SPARSITY;
61 static const std::string FUNCTION_INFO;
62 static const std::string FUNCTION_ATOMIC_FUNC_NAMES;
63protected:
64 static const std::string CONST;
65
69 class Position {
70 public:
71 bool defined;
72 std::vector<size_t> row;
73 std::vector<size_t> col;
74
75 inline Position() :
76 defined(false) {
77 }
78
79 inline Position(const std::vector<size_t>& r, const std::vector<size_t>& c) :
80 defined(true),
81 row(r),
82 col(c) {
83 CPPADCG_ASSERT_KNOWN(r.size() == c.size(), "The number of row indexes must be the same as the number of column indexes.")
84 }
85
86 template<class VectorSet>
87 inline Position(const VectorSet& elements) :
88 defined(true) {
89 size_t nnz = 0;
90 for (size_t i = 0; i < elements.size(); i++) {
91 nnz += elements[i].size();
92 }
93 row.resize(nnz);
94 col.resize(nnz);
95
96 nnz = 0;
97 for (size_t i = 0; i < elements.size(); i++) {
98 for (size_t it : elements[i]) {
99 row[nnz] = i;
100 col[nnz] = it;
101 nnz++;
102 }
103 }
104 }
105 };
106
111 public:
116 SparsitySetType sparsity;
117 // rows (in a custom order)
118 std::vector<size_t> rows;
119 // columns (in a custom order)
120 std::vector<size_t> cols;
121 };
122
126 class Color {
127 public:
129 std::set<size_t> rows;
131 std::map<size_t, size_t> column2Row;
133 std::map<size_t, std::set<size_t> > row2Columns;
135 std::set<size_t> forbiddenRows;
136 };
137
138protected:
151 std::set<LoopModel<Base>*> _loopTapes;
155 std::string _name;
159 const std::string _baseTypeName;
167 std::vector<Base> _x;
175 bool _zero;
176 bool _zeroEvaluated;
206 JacobianADMode _jacMode;
211 LocalSparsityInfo _jacSparsity;
216 LocalSparsityInfo _hessSparsity;
220 std::vector<LocalSparsityInfo> _hessSparsities;
224 std::vector<std::string> _atomicFunctions;
228 std::map<size_t, AtomicUseInfo<Base> >* _atomicsInfo;
232 std::ostringstream _cache;
244 std::vector<std::set<size_t> > _relatedDepCandidates;
249 std::map<LoopModel<Base>*, std::map<size_t, std::map<size_t, std::set<size_t> > > > _loopFor1Groups;
254 std::map<size_t, std::set<size_t> > _nonLoopFor1Elements;
259 std::map<LoopModel<Base>*, std::map<size_t, std::map<size_t, std::set<size_t> > > > _loopRev1Groups;
264 std::map<size_t, std::set<size_t> > _nonLoopRev1Elements;
269 std::map<LoopModel<Base>*, std::map<size_t, std::map<size_t, std::set<size_t> > > > _loopRev2Groups;
274 std::map<size_t, std::set<size_t> > _nonLoopRev2Elements;
278 JobTimer* _jobTimer;
282 std::map<std::string, std::string> _sources;
283public:
284
293 std::string model) :
294 _fun(fun),
295 _funNoLoops(nullptr),
296 _name(std::move(model)),
297 _baseTypeName(ModelCSourceGen<Base>::baseTypeName()),
298 _parameterPrecision(std::numeric_limits<Base>::digits10),
299 _multiThreading(true),
300 _zero(true),
301 _zeroEvaluated(false),
302 _jacobian(false),
303 _hessian(false),
304 _sparseJacobian(false),
305 _sparseHessian(false),
306 _hessianByEquation(false),
307 _forwardOne(false),
308 _reverseOne(false),
309 _reverseTwo(false),
312 _jacMode(JacobianADMode::Automatic),
313 _atomicsInfo(nullptr),
314 _maxAssignPerFunc(20000),
316 _jobTimer(nullptr) {
317
318 CPPADCG_ASSERT_KNOWN(!_name.empty(), "Model name cannot be empty");
319 CPPADCG_ASSERT_KNOWN((_name[0] >= 'a' && _name[0] <= 'z') ||
320 (_name[0] >= 'A' && _name[0] <= 'Z'),
321 "Invalid model name character");
322 for (size_t i = 1; i < _name.size(); i++) {
323 char c = _name[i];
324 CPPADCG_ASSERT_KNOWN((c >= 'a' && c <= 'z') ||
325 (c >= 'A' && c <= 'Z') ||
326 (c >= '0' && c <= '9') ||
327 c == '_'
328 , "Invalid model name character");
329 }
330 }
331
332 ModelCSourceGen(const ModelCSourceGen&) = delete;
333 ModelCSourceGen& operator=(const ModelCSourceGen&) = delete;
334
340 inline const std::string& getName() const {
341 return _name;
342 }
343
352 template<class VectorBase>
353 inline void setTypicalIndependentValues(const VectorBase& x) {
354 CPPAD_ASSERT_KNOWN(x.size() == 0 || x.size() == _fun.Domain(),
355 "Invalid independent variable vector size")
356 _x.resize(x.size());
357 for (size_t i = 0; i < x.size(); i++) {
358 _x[i] = x[i];
359 }
360 }
361
362 inline void setRelatedDependents(const std::vector<std::set<size_t> >& relatedDepCandidates) {
363 _relatedDepCandidates = relatedDepCandidates;
364 }
365
366 inline const std::vector<std::set<size_t> >& getRelatedDependents() const {
367 return _relatedDepCandidates;
368 }
369
376 virtual size_t getParameterPrecision() const {
377 return _parameterPrecision;
378 }
379
386 virtual void setParameterPrecision(size_t p) {
388 }
389
402 inline bool isMultiThreading() const {
403 return _multiThreading;
404 }
405
419 inline void setMultiThreading(bool multiThreading) {
420 _multiThreading = multiThreading;
421 }
422
423 inline bool isJacobianMultiThreadingEnabled() const {
425 }
426
427 inline bool isHessianMultiThreadingEnabled() const {
429 }
430
438 inline bool isCreateHessian() const {
439 return _hessian;
440 }
441
449 inline void setCreateHessian(bool create) {
450 _hessian = create;
451 }
452
459 inline JacobianADMode getJacobianADMode() const {
460 return _jacMode;
461 }
462
469 inline void setJacobianADMode(JacobianADMode mode) {
470 _jacMode = mode;
471 }
472
480 inline bool isCreateJacobian() const {
481 return _jacobian;
482 }
483
491 inline void setCreateJacobian(bool create) {
492 _jacobian = create;
493 }
494
513 inline bool isCreateSparseHessian() const {
514 return _sparseHessian;
515 }
516
535 inline void setCreateSparseHessian(bool create) {
536 _sparseHessian = create;
537 }
538
548 inline bool isSparseHessianReusesRev2() const {
550 }
551
561 inline void setSparseHessianReusesRev2(bool reuse) {
563 }
564
576 return _hessianByEquation;
577 }
578
589 inline void setCreateHessianSparsityByEquation(bool create) {
590 _hessianByEquation = create;
591 }
592
607 inline bool isCreateSparseJacobian() const {
608 return _sparseJacobian;
609 }
610
625 inline void setCreateSparseJacobian(bool create) {
626 _sparseJacobian = create;
627 }
628
641 }
642
654 inline void setSparseJacobianReuse1stOrderPasses(bool reuse) {
656 }
657
665 inline bool isCreateForwardZero() const {
666 return _zero;
667 }
668
676 inline void setCreateForwardZero(bool create) {
677 _zero = create;
678 }
679
694 inline bool isCreateSparseForwardOne() const {
695 return _forwardOne;
696 }
697
712 inline void setCreateForwardOne(bool create) {
713 _forwardOne = create;
714 }
715
730 inline bool isCreateReverseOne() const {
731 return _reverseOne;
732 }
733
748 inline void setCreateReverseOne(bool create) {
749 _reverseOne = create;
750 }
751
767 inline bool isCreateReverseTwo() const {
768 return _reverseOne;
769 }
770
788 inline void setCreateReverseTwo(bool create) {
789 _reverseTwo = create;
790 }
791
802 inline void setCustomSparseJacobianElements(const std::vector<size_t>& row,
803 const std::vector<size_t>& col) {
804 _custom_jac = Position(row, col);
805 }
806
816 template<class VectorSet>
817 inline void setCustomSparseJacobianElements(const VectorSet& elements) {
818 _custom_jac = Position(elements);
819 }
820
833 inline void setCustomSparseHessianElements(const std::vector<size_t>& row,
834 const std::vector<size_t>& col) {
835 _custom_hess = Position(row, col);
836 }
837
849 template<class VectorSet>
850 inline void setCustomSparseHessianElements(const VectorSet& elements) {
851 _custom_hess = Position(elements);
852 }
853
862 inline size_t getMaxAssignmentsPerFunc() const {
863 return _maxAssignPerFunc;
864 }
865
876 inline void setMaxAssignmentsPerFunc(size_t maxAssignPerFunc) {
877 _maxAssignPerFunc = maxAssignPerFunc;
878 }
879
885 inline size_t getMaxOperationsPerAssignment() const {
887 }
888
895 inline void setMaxOperationsPerAssignment(size_t maxOperationsPerAssignment) {
896 _maxOperationsPerAssignment = maxOperationsPerAssignment;
897 }
898
899 inline virtual ~ModelCSourceGen() {
900 delete _funNoLoops;
901 delete _atomicsInfo;
902
903 for (LoopModel<Base>* it : _loopTapes) {
904 delete it;
905 }
906 }
907
908public:
909 static inline std::string baseTypeName();
910
911 template<class T>
912 static void generateFunctionDeclarationSource(std::ostringstream& cache,
913 const std::string& model_function,
914 const std::string& suffix,
915 const std::map<size_t, T>& elements,
916 const std::string& argsDcl);
917
918protected:
919
920 virtual VariableNameGenerator<Base>* createVariableNameGenerator(const std::string& depName = "y",
921 const std::string& indepName = "x",
922 const std::string& tmpName = "v",
923 const std::string& tmpArrayName = "array");
924
925 const std::map<std::string, std::string>& getSources(MultiThreadingType multiThreadingType,
926 JobTimer* timer);
927
928 virtual void generateSources(MultiThreadingType multiThreadingType,
929 JobTimer* timer = nullptr);
930
931 virtual void generateLoops();
932
933 virtual void generateInfoSource();
934
935 virtual void generateAtomicFuncNames();
936
937 virtual bool isAtomicsUsed();
938
939 virtual const std::map<size_t, AtomicUseInfo<Base> >& getAtomicsInfo();
940
941 /***********************************************************************
942 * zero order (the original model)
943 **********************************************************************/
944
945 virtual void generateZeroSource();
946
950 virtual std::vector<CGBase> prepareForward0WithLoops(CodeHandler<Base>& handler,
951 const std::vector<CGBase>& x);
952
953 /***********************************************************************
954 * Jacobian
955 **********************************************************************/
956
957 virtual void generateJacobianSource();
958
959 virtual void generateSparseJacobianSource(MultiThreadingType multiThreadingType);
960
961 virtual void generateSparseJacobianSource(bool forward);
962
963 virtual void generateSparseJacobianForRevSource(bool forward,
964 MultiThreadingType multiThreadingType);
965
966 virtual std::string generateSparseJacobianForRevSingleThreadSource(const std::string& functionName,
967 std::map<size_t, CompressedVectorInfo> jacInfo,
968 size_t maxCompressedSize,
969 const std::string& functionRevFor,
970 const std::string& revForSuffix,
971 bool forward);
972
973 virtual std::string generateSparseJacobianForRevMultiThreadSource(const std::string& functionName,
974 std::map<size_t, CompressedVectorInfo> jacInfo,
975 size_t maxCompressedSize,
976 const std::string& functionRevFor,
977 const std::string& revForSuffix,
978 bool forward,
979 MultiThreadingType multiThreadingType);
1001 virtual std::vector<CGBase> prepareSparseJacobianWithLoops(CodeHandler<Base>& handler,
1002 const std::vector<CGBase>& x,
1003 bool forward);
1004
1005 inline void prepareSparseJacobianRowWithLoops(CodeHandler<Base>& handler,
1006 LoopModel<Base>& lModel,
1007 size_t tapeI,
1008 const loops::JacobianWithLoopsRowInfo& rowInfo,
1009 const std::vector<std::map<size_t, CGBase> >& dyiDxtape,
1010 const std::vector<std::map<size_t, CGBase> >& dzDx,
1011 const CGBase& py,
1012 IndexOperationNode<Base>& iterationIndexOp,
1013 std::vector<loops::IfElseInfo<Base> >& ifElses,
1014 size_t& jacLE,
1015 std::vector<std::pair<CG<Base>, IndexPattern*> >& indexedLoopResults,
1016 std::set<size_t>& allLocations);
1017
1018 inline void analyseSparseJacobianWithLoops(const std::vector<size_t>& rows,
1019 const std::vector<size_t>& cols,
1020 const std::vector<size_t>& location,
1021 SparsitySetType& noLoopEvalSparsity,
1022 std::vector<std::map<size_t, std::set<size_t> > >& noLoopEvalLocations,
1023 std::map<LoopModel<Base>*, SparsitySetType>& loopsEvalSparsities,
1024 std::map<LoopModel<Base>*, std::vector<loops::JacobianWithLoopsRowInfo> >& loopEqInfo);
1025
1026
1027 virtual void generateSparseJacobianWithLoopsSourceFromForRev(const std::map<size_t, CompressedVectorInfo>& jacInfo,
1028 size_t maxCompressedSize,
1029 const std::string& localFunctionTypeName,
1030 const std::string& suffix,
1031 const std::string& keyName,
1032 const std::map<size_t, std::set<size_t> >& nonLoopElements,
1033 const std::map<LoopModel<Base>*, std::map<size_t, std::map<size_t, std::set<size_t> > > >& loopGroups,
1034 void (*generateLocalFunctionName)(std::ostringstream& cache, const std::string& modelName, const LoopModel<Base>& loop, size_t g));
1035
1036 inline virtual void generateFunctionNameLoopFor1(std::ostringstream& cache,
1037 const LoopModel<Base>& loop,
1038 size_t g);
1039
1040 inline static void generateFunctionNameLoopFor1(std::ostringstream& cache,
1041 const std::string& modelName,
1042 const LoopModel<Base>& loop,
1043 size_t g);
1044
1045 inline virtual void generateFunctionNameLoopRev1(std::ostringstream& cache,
1046 const LoopModel<Base>& loop,
1047 size_t i);
1048
1049 inline static void generateFunctionNameLoopRev1(std::ostringstream& cache,
1050 const std::string& modelName,
1051 const LoopModel<Base>& loop,
1052 size_t i);
1053
1054 /***********************************************************************
1055 * Hessian
1056 **********************************************************************/
1057
1058 virtual void generateHessianSource();
1059
1060 virtual void generateSparseHessianSource(MultiThreadingType multiThreadingType);
1061
1063
1064 virtual void generateSparseHessianSourceFromRev2(MultiThreadingType multiThreadingType);
1065
1066 virtual std::string generateSparseHessianRev2SingleThreadSource(const std::string& functionName,
1067 std::map<size_t, CompressedVectorInfo> hessInfo,
1068 size_t maxCompressedSize,
1069 const std::string& functionRev2,
1070 const std::string& rev2Suffix);
1071
1072 virtual std::string generateSparseHessianRev2MultiThreadSource(const std::string& functionName,
1073 std::map<size_t, CompressedVectorInfo> hessInfo,
1074 size_t maxCompressedSize,
1075 const std::string& functionRev2,
1076 const std::string& rev2Suffix,
1077 MultiThreadingType multiThreadingType);
1078
1079 virtual void determineSecondOrderElements4Eval(std::vector<size_t>& userRows,
1080 std::vector<size_t>& userCols);
1081
1108 virtual std::vector<CGBase> prepareSparseHessianWithLoops(CodeHandler<Base>& handler,
1109 std::vector<CGBase>& indVars,
1110 std::vector<CGBase>& w,
1111 const std::vector<size_t>& lowerHessRows,
1112 const std::vector<size_t>& lowerHessCols,
1113 const std::vector<size_t>& lowerHessOrder,
1114 const std::map<size_t, size_t>& duplicates);
1115
1116 inline void analyseSparseHessianWithLoops(const std::vector<size_t>& lowerHessRows,
1117 const std::vector<size_t>& lowerHessCols,
1118 const std::vector<size_t>& lowerHessOrder,
1119 SparsitySetType& noLoopEvalJacSparsity,
1120 SparsitySetType& noLoopEvalHessSparsity,
1121 std::vector<std::map<size_t, std::set<size_t> > >& noLoopEvalHessLocations,
1122 std::map<LoopModel<Base>*, loops::HessianWithLoopsInfo<Base> >& loopHessInfo,
1123 bool useSymmetry);
1124
1125 inline virtual void generateSparseHessianWithLoopsSourceFromRev2(const std::map<size_t, CompressedVectorInfo>& hessInfo,
1126 size_t maxCompressedSize);
1127
1128 inline virtual void generateFunctionNameLoopRev2(std::ostringstream& cache,
1129 const LoopModel<Base>& loop,
1130 size_t g);
1131
1132 static inline void generateFunctionNameLoopRev2(std::ostringstream& cache,
1133 const std::string& modelName,
1134 const LoopModel<Base>& loop,
1135 size_t g);
1136
1137 /***********************************************************************
1138 * Sparsities for forward/reverse
1139 **********************************************************************/
1140
1141 virtual void generateSparsity1DSource(const std::string& function,
1142 const std::vector<size_t>& sparsity);
1143
1144 virtual void generateSparsity2DSource(const std::string& function,
1145 const LocalSparsityInfo& sparsity);
1146
1147 virtual void generateSparsity2DSource2(const std::string& function,
1148 const std::vector<LocalSparsityInfo>& sparsities);
1149
1150 virtual void generateSparsity1DSource2(const std::string& function,
1151 const std::map<size_t, std::vector<size_t> >& rows);
1152
1153 /***********************************************************************
1154 * Forward 1 mode
1155 **********************************************************************/
1156
1157 virtual void generateSparseForwardOneSources();
1158
1159 virtual void generateSparseForwardOneSourcesWithAtomics(const std::map<size_t, std::vector<size_t> >& elements);
1160
1161 virtual void generateSparseForwardOneSourcesNoAtomics(const std::map<size_t, std::vector<size_t> >& elements);
1162
1163 virtual void generateForwardOneSources();
1164
1165 virtual void prepareSparseForwardOneWithLoops(const std::map<size_t, std::vector<size_t> >& elements);
1166
1167 virtual void createForwardOneWithLoopsNL(CodeHandler<Base>& handler,
1168 size_t j,
1169 std::vector<CG<Base> >& jacCol);
1170
1171
1172 inline static std::map<size_t, std::map<size_t, CG<Base> > > generateLoopFor1Jac(ADFun<CGBase>& fun,
1173 const SparsitySetType& sparsity,
1174 const SparsitySetType& evalSparsity,
1175 const std::vector<CGBase>& xl,
1176 bool constainsAtomics);
1177
1178 /***********************************************************************
1179 * Reverse 1 mode
1180 **********************************************************************/
1181
1182 virtual void generateSparseReverseOneSources();
1183
1184 virtual void generateSparseReverseOneSourcesWithAtomics(const std::map<size_t, std::vector<size_t> >& elements);
1185
1186 virtual void generateSparseReverseOneSourcesNoAtomics(const std::map<size_t, std::vector<size_t> >& elements);
1187
1188 virtual void generateReverseOneSources();
1189
1190 virtual void prepareSparseReverseOneWithLoops(const std::map<size_t, std::vector<size_t> >& elements);
1191
1192 virtual void createReverseOneWithLoopsNL(CodeHandler<Base>& handler,
1193 size_t i,
1194 std::vector<CG<Base> >& jacRow);
1195
1196 inline static std::vector<std::map<size_t, CGBase> > generateLoopRev1Jac(ADFun<CGBase>& fun,
1197 const SparsitySetType& sparsity,
1198 const SparsitySetType& evalSparsity,
1199 const std::vector<CGBase>& xl,
1200 bool constainsAtomics);
1201
1202 /***********************************************************************
1203 * Reverse 2 mode
1204 **********************************************************************/
1205
1206 virtual void generateSparseReverseTwoSources();
1207
1208 virtual void generateSparseReverseTwoSourcesWithAtomics(const std::map<size_t, std::vector<size_t> >& elements);
1209
1210 virtual void generateSparseReverseTwoSourcesNoAtomics(const std::map<size_t, std::vector<size_t> >& elements,
1211 const std::vector<size_t>& evalRows,
1212 const std::vector<size_t>& evalCols);
1213
1214 virtual void generateReverseTwoSources();
1215
1216 virtual void generateGlobalDirectionalFunctionSource(const std::string& function,
1217 const std::string& function2_suffix,
1218 const std::string& function_sparsity,
1219 const std::map<size_t, std::vector<size_t> >& elements);
1220
1224 virtual void prepareSparseReverseTwoWithLoops(const std::map<size_t, std::vector<size_t> >& elements);
1225
1226 /***********************************************************************
1227 * Sparsities
1228 **********************************************************************/
1229
1230 virtual void determineJacobianSparsity();
1231
1232 virtual void generateJacobianSparsitySource();
1233
1234 virtual void determineHessianSparsity();
1235
1245 inline std::vector<ModelCSourceGen<Base>::Color> colorByRow(const std::set<size_t>& columns,
1246 const SparsitySetType& sparsity);
1247
1248 virtual void generateHessianSparsitySource();
1249
1250
1251 static inline std::map<size_t, std::vector<std::set<size_t> > > determineOrderByCol(const std::map<size_t, std::vector<size_t> >& elements,
1252 const LocalSparsityInfo& sparsity);
1253
1254 static inline std::map<size_t, std::vector<std::set<size_t> > > determineOrderByCol(const std::map<size_t, std::vector<size_t> >& elements,
1255 const std::vector<size_t>& userRows,
1256 const std::vector<size_t>& userCols);
1257
1258 static inline std::vector<std::set<size_t> > determineOrderByCol(size_t col,
1259 const std::vector<size_t>& colElements,
1260 const std::vector<size_t>& userRows,
1261 const std::vector<size_t>& userCols);
1262
1263 static inline std::map<size_t, std::vector<std::set<size_t> > > determineOrderByRow(const std::map<size_t, std::vector<size_t> >& elements,
1264 const LocalSparsityInfo& sparsity);
1265
1266 static inline std::map<size_t, std::vector<std::set<size_t> > > determineOrderByRow(const std::map<size_t, std::vector<size_t> >& elements,
1267 const std::vector<size_t>& userRows,
1268 const std::vector<size_t>& userCols);
1269
1270 static inline std::vector<std::set<size_t> > determineOrderByRow(size_t row,
1271 const std::vector<size_t>& rowsElements,
1272 const std::vector<size_t>& userRows,
1273 const std::vector<size_t>& userCols);
1274
1275 /***********************************************************************
1276 * Multi-threading
1277 **********************************************************************/
1278
1282 static void printFileStartPThreads(std::ostringstream& cache,
1283 const std::string& baseTypeName);
1284
1285 static void printFunctionStartPThreads(std::ostringstream& cache,
1286 size_t size);
1287
1288 static void printFunctionEndPThreads(std::ostringstream& cache,
1289 size_t size);
1290
1291 static void printFileStartOpenMP(std::ostringstream& cache);
1292
1293 static void printFunctionStartOpenMP(std::ostringstream& cache,
1294 size_t size);
1295
1296 static void printLoopStartOpenMP(std::ostringstream& cache,
1297 size_t size);
1298
1299 static void printLoopEndOpenMP(std::ostringstream& cache,
1300 size_t size);
1301
1305 inline void startingJob(const std::string& jobName,
1306 const JobType& type = JobTypeHolder<>::DEFAULT);
1307
1308 inline void finishedJob();
1309
1310 friend class
1311 ModelLibraryCSourceGen<Base>;
1312
1313 friend class
1314 ModelLibraryProcessor<Base>;
1315};
1316
1317} // END cg namespace
1318} // END CppAD namespace
1319
1320#endif
std::map< size_t, std::set< size_t > > row2Columns
maps row indexes to the corresponding columns
std::set< size_t > rows
all row with this color
std::set< size_t > forbiddenRows
used columns
std::map< size_t, size_t > column2Row
maps column indexes to the corresponding row
virtual void prepareSparseReverseOneWithLoops(const std::map< size_t, std::vector< size_t > > &elements)
void setCustomSparseJacobianElements(const VectorSet &elements)
virtual void generateGlobalDirectionalFunctionSource(const std::string &function, const std::string &function2_suffix, const std::string &function_sparsity, const std::map< size_t, std::vector< size_t > > &elements)
virtual std::vector< CGBase > prepareSparseJacobianWithLoops(CodeHandler< Base > &handler, const std::vector< CGBase > &x, bool forward)
virtual std::string generateSparseJacobianForRevMultiThreadSource(const std::string &functionName, std::map< size_t, CompressedVectorInfo > jacInfo, size_t maxCompressedSize, const std::string &functionRevFor, const std::string &revForSuffix, bool forward, MultiThreadingType multiThreadingType)
virtual std::vector< CGBase > prepareForward0WithLoops(CodeHandler< Base > &handler, const std::vector< CGBase > &x)
void analyseSparseHessianWithLoops(const std::vector< size_t > &lowerHessRows, const std::vector< size_t > &lowerHessCols, const std::vector< size_t > &lowerHessOrder, SparsitySetType &noLoopEvalJacSparsity, SparsitySetType &noLoopEvalHessSparsity, std::vector< std::map< size_t, std::set< size_t > > > &noLoopEvalHessLocations, std::map< LoopModel< Base > *, loops::HessianWithLoopsInfo< Base > > &loopHessInfo, bool useSymmetry)
virtual std::string generateSparseHessianRev2MultiThreadSource(const std::string &functionName, std::map< size_t, CompressedVectorInfo > hessInfo, size_t maxCompressedSize, const std::string &functionRev2, const std::string &rev2Suffix, MultiThreadingType multiThreadingType)
virtual void determineSecondOrderElements4Eval(std::vector< size_t > &userRows, std::vector< size_t > &userCols)
void prepareSparseJacobianRowWithLoops(CodeHandler< Base > &handler, LoopModel< Base > &lModel, size_t tapeI, const loops::JacobianWithLoopsRowInfo &rowInfo, const std::vector< std::map< size_t, CGBase > > &dyiDxtape, const std::vector< std::map< size_t, CGBase > > &dzDx, const CGBase &py, IndexOperationNode< Base > &iterationIndexOp, std::vector< loops::IfElseInfo< Base > > &ifElses, size_t &jacLE, std::vector< std::pair< CG< Base >, IndexPattern * > > &indexedLoopResults, std::set< size_t > &allLocations)
ModelCSourceGen(ADFun< CppAD::cg::CG< Base > > &fun, std::string model)
virtual void generateSparseForwardOneSourcesWithAtomics(const std::map< size_t, std::vector< size_t > > &elements)
std::vector< std::string > _atomicFunctions
bool _forwardOne
generate source code for forward first order mode
void setMaxAssignmentsPerFunc(size_t maxAssignPerFunc)
virtual void generateSparseHessianWithLoopsSourceFromRev2(const std::map< size_t, CompressedVectorInfo > &hessInfo, size_t maxCompressedSize)
void setCreateSparseHessian(bool create)
virtual void prepareSparseForwardOneWithLoops(const std::map< size_t, std::vector< size_t > > &elements)
LoopFreeModel< Base > * _funNoLoops
virtual void generateSparseReverseTwoSourcesNoAtomics(const std::map< size_t, std::vector< size_t > > &elements, const std::vector< size_t > &evalRows, const std::vector< size_t > &evalCols)
void setCustomSparseHessianElements(const VectorSet &elements)
void setCustomSparseHessianElements(const std::vector< size_t > &row, const std::vector< size_t > &col)
void setSparseJacobianReuse1stOrderPasses(bool reuse)
std::map< LoopModel< Base > *, std::map< size_t, std::map< size_t, std::set< size_t > > > > _loopFor1Groups
void setJacobianADMode(JacobianADMode mode)
void setTypicalIndependentValues(const VectorBase &x)
void setCreateSparseJacobian(bool create)
virtual std::vector< CGBase > prepareSparseHessianWithLoops(CodeHandler< Base > &handler, std::vector< CGBase > &indVars, std::vector< CGBase > &w, const std::vector< size_t > &lowerHessRows, const std::vector< size_t > &lowerHessCols, const std::vector< size_t > &lowerHessOrder, const std::map< size_t, size_t > &duplicates)
std::map< size_t, AtomicUseInfo< Base > > * _atomicsInfo
std::map< size_t, std::set< size_t > > _nonLoopRev1Elements
void setMaxOperationsPerAssignment(size_t maxOperationsPerAssignment)
virtual void generateSparseJacobianWithLoopsSourceFromForRev(const std::map< size_t, CompressedVectorInfo > &jacInfo, size_t maxCompressedSize, const std::string &localFunctionTypeName, const std::string &suffix, const std::string &keyName, const std::map< size_t, std::set< size_t > > &nonLoopElements, const std::map< LoopModel< Base > *, std::map< size_t, std::map< size_t, std::set< size_t > > > > &loopGroups, void(*generateLocalFunctionName)(std::ostringstream &cache, const std::string &modelName, const LoopModel< Base > &loop, size_t g))
virtual void setParameterPrecision(size_t p)
virtual void generateSparseHessianSourceFromRev2(MultiThreadingType multiThreadingType)
virtual void generateSparseForwardOneSourcesNoAtomics(const std::map< size_t, std::vector< size_t > > &elements)
bool _zero
generate source code for the zero order model evaluation
std::map< size_t, std::set< size_t > > _nonLoopRev2Elements
bool _sparseHessian
generate source code for a sparse Hessian
std::map< size_t, std::set< size_t > > _nonLoopFor1Elements
virtual void generateSparseJacobianSource(MultiThreadingType multiThreadingType)
JacobianADMode getJacobianADMode() const
void setCustomSparseJacobianElements(const std::vector< size_t > &row, const std::vector< size_t > &col)
std::map< LoopModel< Base > *, std::map< size_t, std::map< size_t, std::set< size_t > > > > _loopRev1Groups
virtual void generateSparseReverseOneSourcesWithAtomics(const std::map< size_t, std::vector< size_t > > &elements)
void analyseSparseJacobianWithLoops(const std::vector< size_t > &rows, const std::vector< size_t > &cols, const std::vector< size_t > &location, SparsitySetType &noLoopEvalSparsity, std::vector< std::map< size_t, std::set< size_t > > > &noLoopEvalLocations, std::map< LoopModel< Base > *, SparsitySetType > &loopsEvalSparsities, std::map< LoopModel< Base > *, std::vector< loops::JacobianWithLoopsRowInfo > > &loopEqInfo)
bool _sparseJacobian
generate source code for a sparse Jacobian
void setSparseHessianReusesRev2(bool reuse)
bool _reverseTwo
generate source code for reverse second order mode
const std::string & getName() const
virtual void generateSparseReverseOneSourcesNoAtomics(const std::map< size_t, std::vector< size_t > > &elements)
std::set< LoopModel< Base > * > _loopTapes
bool _jacobian
generate source code for a dense Jacobian
virtual void prepareSparseReverseTwoWithLoops(const std::map< size_t, std::vector< size_t > > &elements)
virtual void generateSparseJacobianForRevSource(bool forward, MultiThreadingType multiThreadingType)
std::map< LoopModel< Base > *, std::map< size_t, std::map< size_t, std::set< size_t > > > > _loopRev2Groups
virtual size_t getParameterPrecision() const
bool _reverseOne
generate source code for reverse first order mode
std::vector< LocalSparsityInfo > _hessSparsities
void setCreateHessianSparsityByEquation(bool create)
void setMultiThreading(bool multiThreading)
std::map< std::string, std::string > _sources
bool _hessian
generate source code for a dense Hessian
virtual void generateSparseHessianSource(MultiThreadingType multiThreadingType)
std::vector< ModelCSourceGen< Base >::Color > colorByRow(const std::set< size_t > &columns, const SparsitySetType &sparsity)