1 #ifndef CPPAD_CG_LANG_C_DEFAULT_VAR_NAME_GEN_INCLUDED
2 #define CPPAD_CG_LANG_C_DEFAULT_VAR_NAME_GEN_INCLUDED
28 class LangCDefaultVariableNameGenerator :
public VariableNameGenerator<Base> {
31 std::stringstream _ss;
35 std::string _indepName;
39 std::string _tmpArrayName;
41 std::string _tmpSparseArrayName;
43 size_t _minTemporaryID;
45 size_t _maxTemporaryID;
47 size_t _maxTemporaryArrayID;
49 size_t _maxTemporarySparseArrayID;
52 inline explicit LangCDefaultVariableNameGenerator(std::string depName =
"y",
53 std::string indepName =
"x",
54 std::string tmpName =
"v",
55 std::string tmpArrayName =
"array",
56 std::string tmpSparseArrayName =
"sarray") :
57 _depName(std::move(depName)),
58 _indepName(std::move(indepName)),
59 _tmpName(std::move(tmpName)),
60 _tmpArrayName(std::move(tmpArrayName)),
61 _tmpSparseArrayName(std::move(tmpSparseArrayName)),
64 _maxTemporaryArrayID(0),
65 _maxTemporarySparseArrayID(0) {
67 this->_independent.push_back(FuncArgument(_indepName));
68 this->_dependent.push_back(FuncArgument(_depName));
69 this->_temporary.push_back(FuncArgument(_tmpName));
70 this->_temporary.push_back(FuncArgument(_tmpArrayName));
71 this->_temporary.push_back(FuncArgument(_tmpSparseArrayName));
74 inline virtual ~LangCDefaultVariableNameGenerator() =
default;
76 inline size_t getMinTemporaryVariableID()
const override {
77 return _minTemporaryID;
80 inline size_t getMaxTemporaryVariableID()
const override {
81 return _maxTemporaryID;
84 inline size_t getMaxTemporaryArrayVariableID()
const override {
85 return _maxTemporaryArrayID;
88 size_t getMaxTemporarySparseArrayVariableID()
const override {
89 return _maxTemporarySparseArrayID;
92 inline std::string generateDependent(
size_t index)
override {
96 _ss << _depName <<
"[" << index <<
"]";
101 inline std::string generateIndependent(
const OperationNode<Base>& independent,
102 size_t id)
override {
106 _ss << _indepName <<
"[" << (
id - 1) <<
"]";
111 inline std::string generateTemporary(
const OperationNode<Base>& variable,
112 size_t id)
override {
116 if (this->_temporary[0].array) {
117 _ss << _tmpName <<
"[" << (
id - this->_minTemporaryID) <<
"]";
119 _ss << _tmpName << id;
125 std::string generateTemporaryArray(
const OperationNode<Base>& variable,
126 size_t id)
override {
130 CPPADCG_ASSERT_UNKNOWN(variable.getOperationType() == CGOpCode::ArrayCreation)
132 _ss <<
"&" << _tmpArrayName <<
"[" << (
id - 1) <<
"]";
137 std::string generateTemporarySparseArray(
const OperationNode<Base>& variable,
138 size_t id)
override {
142 CPPADCG_ASSERT_UNKNOWN(variable.getOperationType() == CGOpCode::SparseArrayCreation)
144 _ss <<
"&" << _tmpSparseArrayName <<
"[" << (
id - 1) <<
"]";
149 std::string generateIndexedDependent(
const OperationNode<Base>& var,
151 const IndexPattern& ip)
override {
152 CPPADCG_ASSERT_KNOWN(var.getOperationType() == CGOpCode::LoopIndexedDep,
"Invalid node type")
153 CPPADCG_ASSERT_KNOWN(!var.getArguments().empty(), "Invalid number of arguments")
158 _ss << _depName << "[" << LanguageC<Base>::indexPattern2String(ip, getIndexes(var, 1)) << "]";
163 std::
string generateIndexedIndependent(const OperationNode<Base>& independent,
165 const IndexPattern& ip)
override {
166 CPPADCG_ASSERT_KNOWN(independent.getOperationType() == CGOpCode::LoopIndexedIndep,
"Invalid node type")
167 CPPADCG_ASSERT_KNOWN(independent.getArguments().size() > 0, "Invalid number of arguments")
172 _ss << _indepName << "[" << LanguageC<Base>::indexPattern2String(ip, getIndexes(independent, 0)) << "]";
177 inline
void setTemporaryVariableID(
size_t minTempID,
179 size_t maxTempArrayID,
180 size_t maxTempSparseArrayID)
override {
181 _minTemporaryID = minTempID;
182 _maxTemporaryID = maxTempID;
183 _maxTemporaryArrayID = maxTempArrayID;
184 _maxTemporarySparseArrayID = maxTempSparseArrayID;
189 CPPADCG_ASSERT_UNKNOWN(_minTemporaryID <= _maxTemporaryID + 1)
192 const std::string& getIndependentArrayName(
const OperationNode<Base>& indep,
193 size_t id)
override {
197 size_t getIndependentArrayIndex(
const OperationNode<Base>& indep,
198 size_t id)
override {
202 bool isConsecutiveInIndepArray(
const OperationNode<Base>& indepFirst,
204 const OperationNode<Base>& indepSecond,
205 size_t idSecond)
override {
206 return idFirst + 1 == idSecond;
209 bool isInSameIndependentArray(
const OperationNode<Base>& indep1,
211 const OperationNode<Base>& indep2,
212 size_t id2)
override {
216 const std::string& getTemporaryVarArrayName(
const OperationNode<Base>& var,
217 size_t id)
override {
221 size_t getTemporaryVarArrayIndex(
const OperationNode<Base>& var,
222 size_t id)
override {
223 return id - this->_minTemporaryID;
226 bool isConsecutiveInTemporaryVarArray(
const OperationNode<Base>& varFirst,
228 const OperationNode<Base>& varSecond,
229 size_t idSecond)
override {
230 return idFirst + 1 == idSecond;
233 bool isInSameTemporaryVarArray(
const OperationNode<Base>& var1,
235 const OperationNode<Base>& var2,
236 size_t id2)
override {
242 static inline std::vector<const OperationNode<Base>*> getIndexes(
const OperationNode<Base>& var,
244 const std::vector<Argument<Base> >& args = var.getArguments();
245 std::vector<const OperationNode<Base>*> indexes(args.size() - offset);
247 for (
size_t a = offset; a < args.size(); a++) {
248 CPPADCG_ASSERT_KNOWN(args[a].getOperation() !=
nullptr,
"Invalid argument")
249 CPPADCG_ASSERT_KNOWN(args[a].getOperation()->getOperationType() == CGOpCode::Index, "Invalid argument")
251 indexes[a - offset] = &static_cast<const IndexOperationNode<Base>*> (args[a].getOperation())->getIndex();