CppADCodeGen  2.3.0
A C++ Algorithmic Differentiation Package with Source Code Generation
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  *
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 
18 namespace CppAD {
19 namespace cg {
20 
25 public:
26  std::vector<std::set<size_t> > locations; // location of each index in the compressed array
27  std::vector<size_t> indexes; // row or column index
28  bool ordered;
29 };
30 
36 template<class Base>
37 class ModelCSourceGen {
38  using CGBase = CppAD::cg::CG<Base>;
39  using ADCG = CppAD::AD<CGBase>;
40  using SparsitySetType = std::vector<std::set<size_t> >;
41  using TapeVarType = std::pair<size_t, size_t>; // tape independent -> reference orig independent (temporaries only)
42 public:
43  static const std::string FUNCTION_FORWAD_ZERO;
44  static const std::string FUNCTION_JACOBIAN;
45  static const std::string FUNCTION_HESSIAN;
46  static const std::string FUNCTION_FORWARD_ONE;
47  static const std::string FUNCTION_REVERSE_ONE;
48  static const std::string FUNCTION_REVERSE_TWO;
49  static const std::string FUNCTION_SPARSE_JACOBIAN;
50  static const std::string FUNCTION_SPARSE_HESSIAN;
51  static const std::string FUNCTION_JACOBIAN_SPARSITY;
52  static const std::string FUNCTION_HESSIAN_SPARSITY;
53  static const std::string FUNCTION_HESSIAN_SPARSITY2;
54  static const std::string FUNCTION_SPARSE_FORWARD_ONE;
55  static const std::string FUNCTION_SPARSE_REVERSE_ONE;
56  static const std::string FUNCTION_SPARSE_REVERSE_TWO;
57  static const std::string FUNCTION_FORWARD_ONE_SPARSITY;
58  static const std::string FUNCTION_REVERSE_ONE_SPARSITY;
59  static const std::string FUNCTION_REVERSE_TWO_SPARSITY;
60  static const std::string FUNCTION_INFO;
61  static const std::string FUNCTION_ATOMIC_FUNC_NAMES;
62 protected:
63  static const std::string CONST;
64 
68  class Position {
69  public:
70  bool defined;
71  std::vector<size_t> row;
72  std::vector<size_t> col;
73 
74  inline Position() :
75  defined(false) {
76  }
77 
78  inline Position(const std::vector<size_t>& r, const std::vector<size_t>& c) :
79  defined(true),
80  row(r),
81  col(c) {
82  CPPADCG_ASSERT_KNOWN(r.size() == c.size(), "The number of row indexes must be the same as the number of column indexes.");
83  }
84 
85  template<class VectorSet>
86  inline Position(const VectorSet& elements) :
87  defined(true) {
88  size_t nnz = 0;
89  for (size_t i = 0; i < elements.size(); i++) {
90  nnz += elements[i].size();
91  }
92  row.resize(nnz);
93  col.resize(nnz);
94 
95  nnz = 0;
96  for (size_t i = 0; i < elements.size(); i++) {
97  for (size_t it : elements[i]) {
98  row[nnz] = i;
99  col[nnz] = it;
100  nnz++;
101  }
102  }
103  }
104  };
105 
110  public:
115  SparsitySetType sparsity;
116  // rows (in a custom order)
117  std::vector<size_t> rows;
118  // columns (in a custom order)
119  std::vector<size_t> cols;
120  };
121 
125  class Color {
126  public:
128  std::set<size_t> rows;
130  std::map<size_t, size_t> column2Row;
132  std::map<size_t, std::set<size_t> > row2Columns;
134  std::set<size_t> forbiddenRows;
135  };
136 
137 protected:
150  std::set<LoopModel<Base>*> _loopTapes;
154  std::string _name;
158  const std::string _baseTypeName;
166  std::vector<Base> _x;
174  bool _zero;
175  bool _zeroEvaluated;
177  bool _jacobian;
179  bool _hessian;
205  JacobianADMode _jacMode;
210  LocalSparsityInfo _jacSparsity;
215  LocalSparsityInfo _hessSparsity;
219  std::vector<LocalSparsityInfo> _hessSparsities;
223  std::vector<std::string> _atomicFunctions;
227  std::map<size_t, AtomicUseInfo<Base> >* _atomicsInfo;
231  std::ostringstream _cache;
239  std::vector<std::set<size_t> > _relatedDepCandidates;
244  std::map<LoopModel<Base>*, std::map<size_t, std::map<size_t, std::set<size_t> > > > _loopFor1Groups;
249  std::map<size_t, std::set<size_t> > _nonLoopFor1Elements;
254  std::map<LoopModel<Base>*, std::map<size_t, std::map<size_t, std::set<size_t> > > > _loopRev1Groups;
259  std::map<size_t, std::set<size_t> > _nonLoopRev1Elements;
264  std::map<LoopModel<Base>*, std::map<size_t, std::map<size_t, std::set<size_t> > > > _loopRev2Groups;
269  std::map<size_t, std::set<size_t> > _nonLoopRev2Elements;
273  JobTimer* _jobTimer;
277  std::map<std::string, std::string> _sources;
278 public:
279 
288  const std::string& model) :
289  _fun(fun),
290  _funNoLoops(nullptr),
291  _name(model),
292  _baseTypeName(ModelCSourceGen<Base>::baseTypeName()),
293  _parameterPrecision(std::numeric_limits<Base>::digits10),
294  _multiThreading(true),
295  _zero(true),
296  _zeroEvaluated(false),
297  _jacobian(false),
298  _hessian(false),
299  _sparseJacobian(false),
300  _sparseHessian(false),
301  _hessianByEquation(false),
302  _forwardOne(false),
303  _reverseOne(false),
304  _reverseTwo(false),
305  _sparseJacobianReusesOne(true),
306  _sparseHessianReusesRev2(true),
307  _jacMode(JacobianADMode::Automatic),
308  _atomicsInfo(nullptr),
309  _maxAssignPerFunc(20000),
310  _jobTimer(nullptr) {
311 
312  CPPADCG_ASSERT_KNOWN(!_name.empty(), "Model name cannot be empty");
313  CPPADCG_ASSERT_KNOWN((_name[0] >= 'a' && _name[0] <= 'z') ||
314  (_name[0] >= 'A' && _name[0] <= 'Z'),
315  "Invalid model name character");
316  for (size_t i = 1; i < _name.size(); i++) {
317  char c = _name[i];
318  CPPADCG_ASSERT_KNOWN((c >= 'a' && c <= 'z') ||
319  (c >= 'A' && c <= 'Z') ||
320  (c >= '0' && c <= '9') ||
321  c == '_'
322  , "Invalid model name character");
323  }
324  }
325 
326  ModelCSourceGen(const ModelCSourceGen&) = delete;
327  ModelCSourceGen& operator=(const ModelCSourceGen&) = delete;
328 
334  inline const std::string& getName() const {
335  return _name;
336  }
337 
346  template<class VectorBase>
347  inline void setTypicalIndependentValues(const VectorBase& x) {
348  CPPAD_ASSERT_KNOWN(x.size() == 0 || x.size() == _fun.Domain(),
349  "Invalid independent variable vector size");
350  _x.resize(x.size());
351  for (size_t i = 0; i < x.size(); i++) {
352  _x[i] = x[i];
353  }
354  }
355 
356  inline void setRelatedDependents(const std::vector<std::set<size_t> >& relatedDepCandidates) {
357  _relatedDepCandidates = relatedDepCandidates;
358  }
359 
360  inline const std::vector<std::set<size_t> >& getRelatedDependents() const {
361  return _relatedDepCandidates;
362  }
363 
370  virtual size_t getParameterPrecision() const {
371  return _parameterPrecision;
372  }
373 
380  virtual void setParameterPrecision(size_t p) {
381  _parameterPrecision = p;
382  }
383 
396  inline bool isMultiThreading() const {
397  return _multiThreading;
398  }
399 
413  inline void setMultiThreading(bool multiThreading) {
414  _multiThreading = multiThreading;
415  }
416 
417  inline bool isJacobianMultiThreadingEnabled() const {
418  return _multiThreading && _loopTapes.empty() && _sparseJacobian && _sparseJacobianReusesOne && (_forwardOne || _reverseOne);
419  }
420 
421  inline bool isHessianMultiThreadingEnabled() const {
422  return _multiThreading && _loopTapes.empty() && _sparseHessian && _sparseHessianReusesRev2 && _reverseTwo;
423  }
424 
432  inline bool isCreateHessian() const {
433  return _hessian;
434  }
435 
443  inline void setCreateHessian(bool create) {
444  _hessian = create;
445  }
446 
453  inline JacobianADMode getJacobianADMode() const {
454  return _jacMode;
455  }
456 
463  inline void setJacobianADMode(JacobianADMode mode) {
464  _jacMode = mode;
465  }
466 
474  inline bool isCreateJacobian() const {
475  return _jacobian;
476  }
477 
485  inline void setCreateJacobian(bool create) {
486  _jacobian = create;
487  }
488 
507  inline bool isCreateSparseHessian() const {
508  return _sparseHessian;
509  }
510 
529  inline void setCreateSparseHessian(bool create) {
530  _sparseHessian = create;
531  }
532 
542  inline bool isSparseHessianReusesRev2() const {
543  return _sparseHessianReusesRev2;
544  }
545 
555  inline void setSparseHessianReusesRev2(bool reuse) {
556  _sparseHessianReusesRev2 = reuse;
557  }
558 
569  inline bool isCreateHessianSparsityByEquation() const {
570  return _hessianByEquation;
571  }
572 
583  inline void setCreateHessianSparsityByEquation(bool create) {
584  _hessianByEquation = create;
585  }
586 
601  inline bool isCreateSparseJacobian() const {
602  return _sparseJacobian;
603  }
604 
619  inline void setCreateSparseJacobian(bool create) {
620  _sparseJacobian = create;
621  }
622 
634  return _sparseJacobianReusesOne;
635  }
636 
648  inline void setSparseJacobianReuse1stOrderPasses(bool reuse) {
649  _sparseJacobianReusesOne = reuse;
650  }
651 
659  inline bool isCreateForwardZero() const {
660  return _zero;
661  }
662 
670  inline void setCreateForwardZero(bool create) {
671  _zero = create;
672  }
673 
688  inline bool isCreateSparseForwardOne() const {
689  return _forwardOne;
690  }
691 
706  inline void setCreateForwardOne(bool create) {
707  _forwardOne = create;
708  }
709 
724  inline bool isCreateReverseOne() const {
725  return _reverseOne;
726  }
727 
742  inline void setCreateReverseOne(bool create) {
743  _reverseOne = create;
744  }
745 
761  inline bool isCreateReverseTwo() const {
762  return _reverseOne;
763  }
764 
782  inline void setCreateReverseTwo(bool create) {
783  _reverseTwo = create;
784  }
785 
786  inline void setCustomSparseJacobianElements(const std::vector<size_t>& row,
787  const std::vector<size_t>& col) {
788  _custom_jac = Position(row, col);
789  }
790 
791  template<class VectorSet>
792  inline void setCustomSparseJacobianElements(const VectorSet& elements) {
793  _custom_jac = Position(elements);
794  }
795 
796  inline void setCustomSparseHessianElements(const std::vector<size_t>& row,
797  const std::vector<size_t>& col) {
798  _custom_hess = Position(row, col);
799  }
800 
801  template<class VectorSet>
802  inline void setCustomSparseHessianElements(const VectorSet& elements) {
803  _custom_hess = Position(elements);
804  }
805 
806  inline size_t getMaxAssignmentsPerFunc() const {
807  return _maxAssignPerFunc;
808  }
809 
810  inline void setMaxAssignmentsPerFunc(size_t maxAssignPerFunc) {
811  _maxAssignPerFunc = maxAssignPerFunc;
812  }
813 
814  inline virtual ~ModelCSourceGen() {
815  delete _funNoLoops;
816  delete _atomicsInfo;
817 
818  for (LoopModel<Base>* it : _loopTapes) {
819  delete it;
820  }
821  }
822 
823 public:
824  static inline std::string baseTypeName();
825 
826  template<class T>
827  static void generateFunctionDeclarationSource(std::ostringstream& cache,
828  const std::string& model_function,
829  const std::string& suffix,
830  const std::map<size_t, T>& elements,
831  const std::string& argsDcl);
832 
833 protected:
834 
835  virtual VariableNameGenerator<Base>* createVariableNameGenerator(const std::string& depName = "y",
836  const std::string& indepName = "x",
837  const std::string& tmpName = "v",
838  const std::string& tmpArrayName = "array");
839 
840  const std::map<std::string, std::string>& getSources(MultiThreadingType multiThreadingType,
841  JobTimer* timer);
842 
843  virtual void generateSources(MultiThreadingType multiThreadingType,
844  JobTimer* timer = nullptr);
845 
846  virtual void generateLoops();
847 
848  virtual void generateInfoSource();
849 
850  virtual void generateAtomicFuncNames();
851 
852  virtual bool isAtomicsUsed();
853 
854  virtual const std::map<size_t, AtomicUseInfo<Base> >& getAtomicsInfo();
855 
856  /***********************************************************************
857  * zero order (the original model)
858  **********************************************************************/
859 
860  virtual void generateZeroSource();
861 
865  virtual std::vector<CGBase> prepareForward0WithLoops(CodeHandler<Base>& handler,
866  const std::vector<CGBase>& x);
867 
868  /***********************************************************************
869  * Jacobian
870  **********************************************************************/
871 
872  virtual void generateJacobianSource();
873 
874  virtual void generateSparseJacobianSource(MultiThreadingType multiThreadingType);
875 
876  virtual void generateSparseJacobianSource(bool forward);
877 
878  virtual void generateSparseJacobianForRevSource(bool forward,
879  MultiThreadingType multiThreadingType);
880 
881  virtual std::string generateSparseJacobianForRevSingleThreadSource(const std::string& functionName,
882  std::map<size_t, CompressedVectorInfo> jacInfo,
883  size_t maxCompressedSize,
884  const std::string& functionRevFor,
885  const std::string& revForSuffix,
886  bool forward);
887 
888  virtual std::string generateSparseJacobianForRevMultiThreadSource(const std::string& functionName,
889  std::map<size_t, CompressedVectorInfo> jacInfo,
890  size_t maxCompressedSize,
891  const std::string& functionRevFor,
892  const std::string& revForSuffix,
893  bool forward,
894  MultiThreadingType multiThreadingType);
916  virtual std::vector<CGBase> prepareSparseJacobianWithLoops(CodeHandler<Base>& handler,
917  const std::vector<CGBase>& x,
918  bool forward);
919 
920  inline void prepareSparseJacobianRowWithLoops(CodeHandler<Base>& handler,
921  LoopModel<Base>& lModel,
922  size_t tapeI,
923  const loops::JacobianWithLoopsRowInfo& rowInfo,
924  const std::vector<std::map<size_t, CGBase> >& dyiDxtape,
925  const std::vector<std::map<size_t, CGBase> >& dzDx,
926  const CGBase& py,
927  IndexOperationNode<Base>& iterationIndexOp,
928  std::vector<loops::IfElseInfo<Base> >& ifElses,
929  size_t& jacLE,
930  std::vector<std::pair<CG<Base>, IndexPattern*> >& indexedLoopResults,
931  std::set<size_t>& allLocations);
932 
933  inline void analyseSparseJacobianWithLoops(const std::vector<size_t>& rows,
934  const std::vector<size_t>& cols,
935  const std::vector<size_t>& location,
936  SparsitySetType& noLoopEvalSparsity,
937  std::vector<std::map<size_t, std::set<size_t> > >& noLoopEvalLocations,
938  std::map<LoopModel<Base>*, SparsitySetType>& loopsEvalSparsities,
939  std::map<LoopModel<Base>*, std::vector<loops::JacobianWithLoopsRowInfo> >& loopEqInfo);
940 
941 
942  virtual void generateSparseJacobianWithLoopsSourceFromForRev(const std::map<size_t, CompressedVectorInfo>& jacInfo,
943  size_t maxCompressedSize,
944  const std::string& localFunctionTypeName,
945  const std::string& suffix,
946  const std::string& keyName,
947  const std::map<size_t, std::set<size_t> >& nonLoopElements,
948  const std::map<LoopModel<Base>*, std::map<size_t, std::map<size_t, std::set<size_t> > > >& loopGroups,
949  void (*generateLocalFunctionName)(std::ostringstream& cache, const std::string& modelName, const LoopModel<Base>& loop, size_t g));
950 
951  inline virtual void generateFunctionNameLoopFor1(std::ostringstream& cache,
952  const LoopModel<Base>& loop,
953  size_t g);
954 
955  inline static void generateFunctionNameLoopFor1(std::ostringstream& cache,
956  const std::string& modelName,
957  const LoopModel<Base>& loop,
958  size_t g);
959 
960  inline virtual void generateFunctionNameLoopRev1(std::ostringstream& cache,
961  const LoopModel<Base>& loop,
962  size_t i);
963 
964  inline static void generateFunctionNameLoopRev1(std::ostringstream& cache,
965  const std::string& modelName,
966  const LoopModel<Base>& loop,
967  size_t i);
968 
969  /***********************************************************************
970  * Hessian
971  **********************************************************************/
972 
973  virtual void generateHessianSource();
974 
975  virtual void generateSparseHessianSource(MultiThreadingType multiThreadingType);
976 
977  virtual void generateSparseHessianSourceDirectly();
978 
979  virtual void generateSparseHessianSourceFromRev2(MultiThreadingType multiThreadingType);
980 
981  virtual std::string generateSparseHessianRev2SingleThreadSource(const std::string& functionName,
982  std::map<size_t, CompressedVectorInfo> hessInfo,
983  size_t maxCompressedSize,
984  const std::string& functionRev2,
985  const std::string& rev2Suffix);
986 
987  virtual std::string generateSparseHessianRev2MultiThreadSource(const std::string& functionName,
988  std::map<size_t, CompressedVectorInfo> hessInfo,
989  size_t maxCompressedSize,
990  const std::string& functionRev2,
991  const std::string& rev2Suffix,
992  MultiThreadingType multiThreadingType);
993 
994  virtual void determineSecondOrderElements4Eval(std::vector<size_t>& userRows,
995  std::vector<size_t>& userCols);
996 
1023  virtual std::vector<CGBase> prepareSparseHessianWithLoops(CodeHandler<Base>& handler,
1024  std::vector<CGBase>& indVars,
1025  std::vector<CGBase>& w,
1026  const std::vector<size_t>& lowerHessRows,
1027  const std::vector<size_t>& lowerHessCols,
1028  const std::vector<size_t>& lowerHessOrder,
1029  const std::map<size_t, size_t>& duplicates);
1030 
1031  inline void analyseSparseHessianWithLoops(const std::vector<size_t>& lowerHessRows,
1032  const std::vector<size_t>& lowerHessCols,
1033  const std::vector<size_t>& lowerHessOrder,
1034  SparsitySetType& noLoopEvalJacSparsity,
1035  SparsitySetType& noLoopEvalHessSparsity,
1036  std::vector<std::map<size_t, std::set<size_t> > >& noLoopEvalHessLocations,
1037  std::map<LoopModel<Base>*, loops::HessianWithLoopsInfo<Base> >& loopHessInfo,
1038  bool useSymmetry);
1039 
1040  inline virtual void generateSparseHessianWithLoopsSourceFromRev2(const std::map<size_t, CompressedVectorInfo>& hessInfo,
1041  size_t maxCompressedSize);
1042 
1043  inline virtual void generateFunctionNameLoopRev2(std::ostringstream& cache,
1044  const LoopModel<Base>& loop,
1045  size_t g);
1046 
1047  static inline void generateFunctionNameLoopRev2(std::ostringstream& cache,
1048  const std::string& modelName,
1049  const LoopModel<Base>& loop,
1050  size_t g);
1051 
1052  /***********************************************************************
1053  * Sparsities for forward/reverse
1054  **********************************************************************/
1055 
1056  virtual void generateSparsity1DSource(const std::string& function,
1057  const std::vector<size_t>& sparsity);
1058 
1059  virtual void generateSparsity2DSource(const std::string& function,
1060  const LocalSparsityInfo& sparsity);
1061 
1062  virtual void generateSparsity2DSource2(const std::string& function,
1063  const std::vector<LocalSparsityInfo>& sparsities);
1064 
1065  virtual void generateSparsity1DSource2(const std::string& function,
1066  const std::map<size_t, std::vector<size_t> >& rows);
1067 
1068  /***********************************************************************
1069  * Forward 1 mode
1070  **********************************************************************/
1071 
1072  virtual void generateSparseForwardOneSources();
1073 
1074  virtual void generateSparseForwardOneSourcesWithAtomics(const std::map<size_t, std::vector<size_t> >& elements);
1075 
1076  virtual void generateSparseForwardOneSourcesNoAtomics(const std::map<size_t, std::vector<size_t> >& elements);
1077 
1078  virtual void generateForwardOneSources();
1079 
1080  virtual void prepareSparseForwardOneWithLoops(const std::map<size_t, std::vector<size_t> >& elements);
1081 
1082  virtual void createForwardOneWithLoopsNL(CodeHandler<Base>& handler,
1083  size_t j,
1084  std::vector<CG<Base> >& jacCol);
1085 
1086 
1087  inline static std::map<size_t, std::map<size_t, CG<Base> > > generateLoopFor1Jac(ADFun<CGBase>& fun,
1088  const SparsitySetType& sparsity,
1089  const SparsitySetType& evalSparsity,
1090  const std::vector<CGBase>& xl,
1091  bool constainsAtomics);
1092 
1093  /***********************************************************************
1094  * Reverse 1 mode
1095  **********************************************************************/
1096 
1097  virtual void generateSparseReverseOneSources();
1098 
1099  virtual void generateSparseReverseOneSourcesWithAtomics(const std::map<size_t, std::vector<size_t> >& elements);
1100 
1101  virtual void generateSparseReverseOneSourcesNoAtomics(const std::map<size_t, std::vector<size_t> >& elements);
1102 
1103  virtual void generateReverseOneSources();
1104 
1105  virtual void prepareSparseReverseOneWithLoops(const std::map<size_t, std::vector<size_t> >& elements);
1106 
1107  virtual void createReverseOneWithLoopsNL(CodeHandler<Base>& handler,
1108  size_t i,
1109  std::vector<CG<Base> >& jacRow);
1110 
1111  inline static std::vector<std::map<size_t, CGBase> > generateLoopRev1Jac(ADFun<CGBase>& fun,
1112  const SparsitySetType& sparsity,
1113  const SparsitySetType& evalSparsity,
1114  const std::vector<CGBase>& xl,
1115  bool constainsAtomics);
1116 
1117  /***********************************************************************
1118  * Reverse 2 mode
1119  **********************************************************************/
1120 
1121  virtual void generateSparseReverseTwoSources();
1122 
1123  virtual void generateSparseReverseTwoSourcesWithAtomics(const std::map<size_t, std::vector<size_t> >& elements);
1124 
1125  virtual void generateSparseReverseTwoSourcesNoAtomics(const std::map<size_t, std::vector<size_t> >& elements,
1126  const std::vector<size_t>& evalRows,
1127  const std::vector<size_t>& evalCols);
1128 
1129  virtual void generateReverseTwoSources();
1130 
1131  virtual void generateGlobalDirectionalFunctionSource(const std::string& function,
1132  const std::string& function2_suffix,
1133  const std::string& function_sparsity,
1134  const std::map<size_t, std::vector<size_t> >& elements);
1135 
1139  virtual void prepareSparseReverseTwoWithLoops(const std::map<size_t, std::vector<size_t> >& elements);
1140 
1141  /***********************************************************************
1142  * Sparsities
1143  **********************************************************************/
1144 
1145  virtual void determineJacobianSparsity();
1146 
1147  virtual void generateJacobianSparsitySource();
1148 
1149  virtual void determineHessianSparsity();
1150 
1160  inline std::vector<ModelCSourceGen<Base>::Color> colorByRow(const std::set<size_t>& columns,
1161  const SparsitySetType& sparsity);
1162 
1163  virtual void generateHessianSparsitySource();
1164 
1165 
1166  static inline std::map<size_t, std::vector<std::set<size_t> > > determineOrderByCol(const std::map<size_t, std::vector<size_t> >& elements,
1167  const LocalSparsityInfo& sparsity);
1168 
1169  static inline std::map<size_t, std::vector<std::set<size_t> > > determineOrderByCol(const std::map<size_t, std::vector<size_t> >& elements,
1170  const std::vector<size_t>& userRows,
1171  const std::vector<size_t>& userCols);
1172 
1173  static inline std::vector<std::set<size_t> > determineOrderByCol(size_t col,
1174  const std::vector<size_t>& colElements,
1175  const std::vector<size_t>& userRows,
1176  const std::vector<size_t>& userCols);
1177 
1178  static inline std::map<size_t, std::vector<std::set<size_t> > > determineOrderByRow(const std::map<size_t, std::vector<size_t> >& elements,
1179  const LocalSparsityInfo& sparsity);
1180 
1181  static inline std::map<size_t, std::vector<std::set<size_t> > > determineOrderByRow(const std::map<size_t, std::vector<size_t> >& elements,
1182  const std::vector<size_t>& userRows,
1183  const std::vector<size_t>& userCols);
1184 
1185  static inline std::vector<std::set<size_t> > determineOrderByRow(size_t row,
1186  const std::vector<size_t>& rowsElements,
1187  const std::vector<size_t>& userRows,
1188  const std::vector<size_t>& userCols);
1189 
1190  /***********************************************************************
1191  * Multi-threading
1192  **********************************************************************/
1193 
1197  static void printFileStartPThreads(std::ostringstream& cache,
1198  const std::string& baseTypeName);
1199 
1200  static void printFunctionStartPThreads(std::ostringstream& cache,
1201  size_t size);
1202 
1203  static void printFunctionEndPThreads(std::ostringstream& cache,
1204  size_t size);
1205 
1206  static void printFileStartOpenMP(std::ostringstream& cache);
1207 
1208  static void printFunctionStartOpenMP(std::ostringstream& cache,
1209  size_t size);
1210 
1211  static void printLoopStartOpenMP(std::ostringstream& cache,
1212  size_t size);
1213 
1214  static void printLoopEndOpenMP(std::ostringstream& cache,
1215  size_t size);
1216 
1220  inline void startingJob(const std::string& jobName,
1221  const JobType& type = JobTypeHolder<>::DEFAULT);
1222 
1223  inline void finishedJob();
1224 
1225  friend class
1227 
1228  friend class
1230 };
1231 
1232 } // END cg namespace
1233 } // END CppAD namespace
1234 
1235 #endif
bool _reverseTwo
generate source code for reverse second order mode
bool _sparseJacobian
generate source code for a sparse Jacobian
std::set< size_t > rows
all row with this color
virtual size_t getParameterPrecision() const
bool isSparseJacobianReuse1stOrderPasses() const
std::vector< std::string > _atomicFunctions
std::map< size_t, std::set< size_t > > row2Columns
maps row indexes to the corresponding columns
ModelCSourceGen(ADFun< CppAD::cg::CG< Base > > &fun, const std::string &model)
bool _sparseHessian
generate source code for a sparse Hessian
const std::string & getName() const
STL namespace.
void setCreateForwardZero(bool create)
std::set< LoopModel< Base > * > _loopTapes
void setCreateReverseOne(bool create)
bool _reverseOne
generate source code for reverse first order mode
LoopFreeModel< Base > * _funNoLoops
std::map< size_t, size_t > column2Row
maps column indexes to the corresponding row
JacobianADMode getJacobianADMode() const
std::map< size_t, std::set< size_t > > _nonLoopRev1Elements
std::map< size_t, std::set< size_t > > _nonLoopRev2Elements
std::map< size_t, AtomicUseInfo< Base > > * _atomicsInfo
void setCreateSparseHessian(bool create)
std::map< LoopModel< Base > *, std::map< size_t, std::map< size_t, std::set< size_t > > > > _loopFor1Groups
std::vector< LocalSparsityInfo > _hessSparsities
void setMultiThreading(bool multiThreading)
std::map< LoopModel< Base > *, std::map< size_t, std::map< size_t, std::set< size_t > > > > _loopRev1Groups
void setTypicalIndependentValues(const VectorBase &x)
std::map< size_t, std::set< size_t > > _nonLoopFor1Elements
void setCreateReverseTwo(bool create)
bool _zero
generate source code for the zero order model evaluation
bool _hessian
generate source code for a dense Hessian
bool _forwardOne
generate source code for forward first order mode
void setCreateSparseJacobian(bool create)
void setSparseHessianReusesRev2(bool reuse)
void setSparseJacobianReuse1stOrderPasses(bool reuse)
std::map< std::string, std::string > _sources
virtual void setParameterPrecision(size_t p)
std::map< LoopModel< Base > *, std::map< size_t, std::map< size_t, std::set< size_t > > > > _loopRev2Groups
bool isCreateHessianSparsityByEquation() const
void setCreateHessianSparsityByEquation(bool create)
void setJacobianADMode(JacobianADMode mode)
void setCreateForwardOne(bool create)
std::set< size_t > forbiddenRows
used columns
bool _jacobian
generate source code for a dense Jacobian