kangaroo  1.0
the cbls library
summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp
Go to the documentation of this file.
1 
12 #ifndef SummationValueScalarOrFactorVectorOptiSwapToValueFactorVectorHppIncluded
13 #define SummationValueScalarOrFactorVectorOptiSwapToValueFactorVectorHppIncluded
14 
15 
16 #include "cbls/functions/valueVectorFuncs/naryValueScalarOrFactorVectorToValueFactorVectorFuncs/naryValueScalarOrFactorVectorToValueFactorVectorFunc.hpp"
17 
18 
19 
20 openKangarooSpace
21 
22 
23 
40 template <Order MaxiOrMini, typename paramValue, typename value = paramValue, typename paramMetric = paramValue, typename metric = paramMetric>
41 class SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector : public NaryValueScalarOrFactorVectorToValueFactorVectorFunc<value,metric>
42 {
43  public:
44 
45  typedef paramValue ParamValueType;
46  typedef paramMetric ParamMetricType;
47  typedef value ValueType;
48  typedef metric MetricType;
49 
52 
54  static SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric> *
55  define(System * const pSystem, Dim const ParamCount, Expression * const * ParamExprs, ParamSpecType * const ParamSpecs=nullptr);
56 
58 
59  private:
60 
61  ~SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector();
62  SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector(System * const pSystem,
63  Dim const ParamCount, Expression * const * pParamExprs, ParamSpecType * const pParamSpecs);
64 
65  SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector(SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector
66  <MaxiOrMini,paramValue,value,paramMetric,metric> && that) noexcept = delete;
67  SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector(SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector
68  <MaxiOrMini,paramValue,value,paramMetric,metric> const & that) = delete;
69  SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector & operator =
70  (SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector
71  <MaxiOrMini,paramValue,value,paramMetric,metric> && that) noexcept = delete;
72  SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector & operator =
73  (SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector
74  <MaxiOrMini,paramValue,value,paramMetric,metric> const & that) = delete;
75 
76  virtual void computeFinal();
77  virtual void executeAnew();
78  virtual void simulateAnew();
79  virtual void executeIncr();
80  virtual void simulateIncr();
81 
82  #if ComputeLazy
83  virtual void executeBacklog();
84  virtual void emulateBacklog();
85  virtual void undoScalars(Serial const ParamSerial);
86  virtual void undoVectors(Serial const ParamSerial);
87  #endif // ComputeLazy
88 
89  typedef typename DataTempBuff<paramValue,value>::Type ValueBuffType;
90  typedef typename DataTempBuff<paramMetric,metric>::Type MetricBuffType;
91 
92  typedef union
93  {
94  ScalarRecord<paramMetric> const * mExprScalarRecord;
95  VectorRecord<paramMetric> const * mExprVectorRecord;
96  } VectorOrScalarRecord;
97 
98  kb<ValueRecord<paramValue> const * > mParamExprValueRecords;
99  kb<VectorOrScalarRecord > mParamExprMetricRecords;
100  kb< OptiSwap<paramMetric,MetricBuffType> > mParamOptiSwapOperators;
101 
102  #if SimulDownward
103  ValueBuffType cacheSimulValue;
104  #endif//SimulDownward
105 
106  ValueBuffType cacheExecValue;
107 
108  #if ComputeLazy
109  ValueBuffType cacheEmulValue;
110  #endif // ComputeLazy
111 
112  kb<MetricBuffType> * cacheExecVector;
113  kll<Serial> * tempChangedVector;
114 };
115 
116 
117 
121 template <Order MaxiOrMini, typename paramValue, typename value, typename paramMetric, typename metric>
122 inline SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric>::~SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector()
123 {
124  WatchError
125  if (cacheExecVector) delete cacheExecVector;
126  if (tempChangedVector) delete tempChangedVector;
127  CatchError
128 }
129 
130 
131 
135 template <Order MaxiOrMini, typename paramValue, typename value, typename paramMetric, typename metric>
136 inline SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric> *
137  SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric>::define(System * const pSystem, Dim const ParamCount,
138  Expression * const * pParamExprs, ParamSpecType * const pParamSpecs)
139 {
140  WatchError
141  Warn(ParamCount < 2 || ParamCount > MaxDim, kFuncNotRequiredParams);
142 
143  SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric> * tFunction =
144  new SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric>(pSystem, ParamCount, pParamExprs, pParamSpecs);
145 
146  Serial const tFuncSerial = Function::defineWithinSystem(tFunction);
147  if (tFuncSerial != InvalidSerial)
148  return scast<SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric> *>(pSystem->LocateFunc(tFuncSerial));
149 
150  tFunction->defineRootWithinSystem();
151  return tFunction;
152  CatchError
153 }
154 
155 
156 
160 template <Order MaxiOrMini, typename paramValue, typename value, typename paramMetric, typename metric>
161 inline SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric>::SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector
162  (System * const pSystem, Dim const ParamCount, Expression * const * pParamExprs, ParamSpecType * const pParamSpecs) :
163  NaryValueScalarOrFactorVectorToValueFactorVectorFunc<value,metric>(pSystem, MaxiOrMini, ParamCount),
164  mParamExprValueRecords(ParamCount), mParamExprMetricRecords(ParamCount), mParamOptiSwapOperators(ParamCount), cacheExecVector(nullptr),
165  tempChangedVector(nullptr)
166 {
167  WatchError
168  this->setExprFormat(identifier<SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric> >());
169  this->setParameters(UnorderedParams, ParamCount, pParamExprs, pParamSpecs);
170  this->setExprHash(this->calcExprHash());
171  this->defineExprValueRecord();
172  this->defineExprVectorRecord(this->FactorVars.ItemCount());
173 
174  for(Serial tParamSerial = 0; tParamSerial < ParamCount; ++tParamSerial)
175  {
176  this->mParamExprValueRecords[tParamSerial] = getExprValueRecord<paramValue>(this->ParamExprs[tParamSerial]);
177 
178  ParamSpecType tParamSpecType = this->ParamSpecs ? this->ParamSpecs->Item(tParamSerial) : DefaultParam;
179 
180  if (checkReifyScalarAsVectorMetric(tParamSpecType))
181  {
182  this->mParamExprMetricRecords[tParamSerial].mExprScalarRecord = getExprScalarRecord<paramMetric>(this->ParamExprs[tParamSerial], MaxiOrMini, tParamSpecType);
183 
184  this->mVectorNotScalars[tParamSerial] = false;
185  }
186  else
187  {
188  this->mParamExprMetricRecords[tParamSerial].mExprVectorRecord = getExprVectorRecord<paramMetric>(this->ParamExprs[tParamSerial], MaxiOrMini, tParamSpecType);
189 
190  this->mVectorNotScalars[tParamSerial] = true;
191  }
192  this->mParamOptiSwapOperators[tParamSerial] = OptiSwap<paramMetric,MetricBuffType>(tParamSpecType);
193  }
194 
195  this->cacheExecVector = new kb<MetricBuffType>(this->FactorVars.ItemCount());
196  this->tempChangedVector = new kll<Serial>(this->FactorVars.ItemCount());
197 
198  CatchError
199 }
200 
201 
202 
206 template <Order MaxiOrMini, typename paramValue, typename value, typename paramMetric, typename metric>
207 inline void SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric>::computeFinal()
208 {
209  WatchError
210  if (!this->Updatable())
211  {
212  cacheExecValue = 0;
213  for(Serial tFactorSerial = 0; tFactorSerial < this->FactorVars.ItemCount(); ++tFactorSerial)
214  cacheExecVector->Item(tFactorSerial) = 0;
215 
216  for(Serial tParamSerial = 0; tParamSerial < mParamExprValueRecords.ItemCount(); ++tParamSerial)
217  {
218  cacheExecValue += mParamExprValueRecords[tParamSerial]->ExecData();
219 
220  if (this->mVectorNotScalars[tParamSerial])
221  {
222  VectorRecord<paramMetric> const * tParamExprVectorRecord = mParamExprMetricRecords[tParamSerial].mExprVectorRecord;
223  for(Serial tParamFactorSerial = 0; tParamFactorSerial < this->ParamFactors[tParamSerial].ItemCount(); ++tParamFactorSerial)
224  {
225  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
226  cacheExecVector->Item(tFactorSerial) += mParamOptiSwapOperators[tParamSerial](
227  tParamExprVectorRecord->Field(tParamFactorSerial).ExecData());
228  }
229  }
230  else
231  {
232  ScalarRecord<paramMetric> const * tParamExprScalarRecord = mParamExprMetricRecords[tParamSerial].mExprScalarRecord;
233  for(Serial tParamFactorSerial = 0; tParamFactorSerial < this->ParamFactors[tParamSerial].ItemCount(); ++tParamFactorSerial)
234  {
235  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
236  cacheExecVector->Item(tFactorSerial) += mParamOptiSwapOperators[tParamSerial](
237  tParamExprScalarRecord->ExecData());
238  }
239  }
240  }
241  this->mExprValueRecord->finaliseRecord(tc<ValueBuffType,value>::iof(cacheExecValue));
242  for(Serial tFactorSerial = 0; tFactorSerial < this->FactorVars.ItemCount(); ++tFactorSerial)
243  this->mExprVectorRecord->finaliseField(tFactorSerial,tc<MetricBuffType,metric>::iof(cacheExecVector->Item(tFactorSerial)));
244  }
245  CatchError
246 }
247 
248 
249 
253 template <Order MaxiOrMini, typename paramValue, typename value, typename paramMetric, typename metric>
254 inline void SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric>::executeAnew()
255 {
256  WatchError
257  cacheExecValue = 0;
258  for(Serial tFactorSerial = 0; tFactorSerial < this->FactorVars.ItemCount(); ++tFactorSerial)
259  cacheExecVector->Item(tFactorSerial) = 0;
260 
261  for(Serial tParamSerial = 0; tParamSerial < mParamExprValueRecords.ItemCount(); ++tParamSerial)
262  {
263  #if ExecDownward
264  Expression::performExecAnew(this->ParamExprs[tParamSerial]);
265  #endif//ExecDownward
266 
267  cacheExecValue += mParamExprValueRecords[tParamSerial]->ExecData();
268 
269  if (this->mVectorNotScalars[tParamSerial])
270  {
271  VectorRecord<paramMetric> const * tParamExprVectorRecord = mParamExprMetricRecords[tParamSerial].mExprVectorRecord;
272  for(Serial tParamFactorSerial = 0; tParamFactorSerial < this->ParamFactors[tParamSerial].ItemCount(); ++tParamFactorSerial)
273  {
274  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
275  cacheExecVector->Item(tFactorSerial) += mParamOptiSwapOperators[tParamSerial](
276  tParamExprVectorRecord->Field(tParamFactorSerial).ExecData());
277  }
278  }
279  else
280  {
281  ScalarRecord<paramMetric> const * tParamExprScalarRecord = mParamExprMetricRecords[tParamSerial].mExprScalarRecord;
282 
283  for(Serial tParamFactorSerial = 0; tParamFactorSerial < this->ParamFactors[tParamSerial].ItemCount(); ++tParamFactorSerial)
284  {
285  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
286  cacheExecVector->Item(tFactorSerial) += mParamOptiSwapOperators[tParamSerial](
287  tParamExprScalarRecord->ExecData());
288  }
289  }
290  }
291 
292  this->mExprValueRecord->initialiseExecData(tc<ValueBuffType,value>::iof(cacheExecValue));
293  for(Serial tFactorSerial = 0; tFactorSerial < this->FactorVars.ItemCount(); ++tFactorSerial)
294  this->mExprVectorRecord->initialiseExecData(tFactorSerial,tc<MetricBuffType,metric>::iof(cacheExecVector->Item(tFactorSerial)));
295  #if ExecUpwardOrLazyDownward
296  this->runPostExecAnew();
297  #endif
298  CatchError
299 }
300 
301 
302 
306 template <Order MaxiOrMini, typename paramValue, typename value, typename paramMetric, typename metric>
307 inline void SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric>::simulateAnew()
308 {
309  WatchError
310  ValueBuffType tSimulValue = 0;
311  for(Serial tParamSerial = 0; tParamSerial < mParamExprValueRecords.ItemCount(); ++tParamSerial)
312  {
313  #if SimulDownward
314  Expression::performSimulAnew(this->ParamExprs[tParamSerial]);
315  #endif//SimulDownward
316 
317  tSimulValue += mParamExprValueRecords[tParamSerial]->SimulData(this->SysMaster->SimulClock());
318  }
319  this->mExprValueRecord->updateSimulData(this->SysMaster->SimulClock(), tc<ValueBuffType,value>::iof(tSimulValue));
320  #if SimulUpward
321  this->runPostSimulAnew();
322  #endif
323  CatchError
324 }
325 
326 
327 #if ComputeLazy
328 
331 template <Order MaxiOrMini, typename paramValue, typename value, typename paramMetric, typename metric>
332 inline void SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric>::undoScalars(Serial const ParamSerial)
333 {
334  WatchError
335  cacheExecValue -= mParamExprValueRecords[ParamSerial]->PrevData(this->SysMaster->ExecClock());
336  if (!this->mVectorNotScalars[ParamSerial])
337  {
338  ScalarRecord<paramMetric> const * tParamExprScalarRecord = mParamExprMetricRecords[ParamSerial].mExprScalarRecord;
339 
340  for(Serial tParamFactorSerial = 0; tParamFactorSerial < this->ParamFactors[ParamSerial].ItemCount(); ++tParamFactorSerial)
341  {
342  Serial const tFactorSerial = this->ParamFactors[ParamSerial][tParamFactorSerial];
343  cacheExecVector->Item(tFactorSerial) -= mParamOptiSwapOperators[ParamSerial](
344  tParamExprScalarRecord->PrevData(this->SysMaster->ExecClock()));
345  }
346  }
347  CatchError
348 }
349 #endif // ComputeLazy
350 
351 
352 
353 #if ComputeLazy
354 
357 template <Order MaxiOrMini, typename paramValue, typename value, typename paramMetric, typename metric>
358 inline void SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric>::undoVectors(Serial const ParamSerial)
359 {
360  WatchError
361  if (this->mVectorNotScalars[ParamSerial])
362  {
363  VectorRecord<paramMetric> const * tParamExprVectorRecord = mParamExprMetricRecords[ParamSerial].mExprVectorRecord;
364  for (Index tDiffIndex = 0; tDiffIndex < tParamExprVectorRecord->PrevSerialCount(); ++tDiffIndex)
365  {
366  Serial const tParamFactorSerial = tParamExprVectorRecord->PrevSerial(tDiffIndex);
367  Serial const tFactorSerial = this->ParamFactors[ParamSerial][tParamFactorSerial];
368  if (this->mVectorUndoneParams->List(ParamSerial).Tagged(tParamFactorSerial))
369  cacheExecVector->Item(tFactorSerial) -= mParamOptiSwapOperators[ParamSerial](
370  tParamExprVectorRecord->Field(tParamFactorSerial).PrevBuffer());
371  }
372  }
373  CatchError
374 }
375 #endif // ComputeLazy
376 
377 
381 template <Order MaxiOrMini, typename paramValue, typename value, typename paramMetric, typename metric>
382 inline void SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric>::executeIncr()
383 {
384  WatchError
385  #if ExecUpward
386  if (this->mExecChangedParams.TagCount())
387  {
388  tempChangedVector->sweep(this->SysMaster->ExecClock());
389  for(Index tIndex = 0; tIndex < this->mExecChangedParams.TagCount(); ++tIndex)
390  {
391  Serial const tParamSerial = this->mExecChangedParams.TaggedSerial(tIndex);
392 
393  ValueRecord<paramValue> const * tParamExprValueRecord = mParamExprValueRecords[tParamSerial];
394  if (tParamExprValueRecord->PrevDiff(this->SysMaster->ExecClock()))
395  cacheExecValue += tParamExprValueRecord->ExecBuffer() - tParamExprValueRecord->PrevBuffer();
396 
397  if (this->mVectorNotScalars[tParamSerial])
398  {
399  VectorRecord<paramMetric> const * tParamExprVectorRecord = mParamExprMetricRecords[tParamSerial].mExprVectorRecord;
400  for (Index tDiffIndex = 0; tDiffIndex < tParamExprVectorRecord->PrevSerialCount(); ++tDiffIndex)
401  {
402  Serial const tParamFactorSerial = tParamExprVectorRecord->PrevSerial(tDiffIndex);
403  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
404  cacheExecVector->Item(tFactorSerial) +=
405  mParamOptiSwapOperators[tParamSerial](tParamExprVectorRecord->Field(tParamFactorSerial).ExecBuffer()) -
406  mParamOptiSwapOperators[tParamSerial](tParamExprVectorRecord->Field(tParamFactorSerial).PrevBuffer());
407  tempChangedVector->tagBool(tFactorSerial);
408  }
409  }
410  else
411  {
412  ScalarRecord<paramMetric> const * tParamExprScalarRecord = mParamExprMetricRecords[tParamSerial].mExprScalarRecord;
413  if (tParamExprScalarRecord->PrevDiff(this->SysMaster->ExecClock()))
414  for(Serial tParamFactorSerial = 0; tParamFactorSerial < this->ParamFactors[tParamSerial].ItemCount(); ++tParamFactorSerial)
415  {
416  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
417  cacheExecVector->Item(tFactorSerial) +=
418  mParamOptiSwapOperators[tParamSerial](tParamExprScalarRecord->ExecBuffer()) -
419  mParamOptiSwapOperators[tParamSerial](tParamExprScalarRecord->PrevBuffer());
420  tempChangedVector->tagBool(tFactorSerial);
421  }
422  }
423  }
424  this->mExprValueRecord->updateExecData(this->SysMaster->ExecClock(), tc<ValueBuffType,value>::iof(cacheExecValue));
425 
426  this->mExprVectorRecord->resetPrevSerials(this->SysMaster->ExecClock());
427  for(Index tIndex = 0; tIndex < tempChangedVector->TagCount(); ++tIndex)
428  {
429  Serial const tFactorSerial = tempChangedVector->TaggedSerial(tIndex);
430  this->mExprVectorRecord->updateExecData(tFactorSerial,this->SysMaster->ExecClock(),
431  tc<MetricBuffType,metric>::iof(cacheExecVector->Item(tFactorSerial)));
432  }
433  this->runPostExecIncr();
434  }
435  #endif//ExecUpward
436  #if ExecDownward
437  #if ComputeLazy
438  if (!this->BacklogExists())
439  {
440  #endif // ComputeLazy
441  if (this->needExecParamComputation()) this->listExecParams();
442  if (this->mBlockExecParams->ItemCount())
443  {
444  tempChangedVector->sweep(this->SysMaster->ExecClock());
445  for(Index tIndex = 0; tIndex < this->mBlockExecParams->ItemCount(); ++tIndex)
446  {
447  Serial const tParamSerial = this->mBlockExecParams->Item(tIndex);
448  Expression::performExecIncr(this->ParamExprs[tParamSerial]);
449  ValueRecord<paramValue> const * tParamExprValueRecord = mParamExprValueRecords[tParamSerial];
450  if (tParamExprValueRecord->PrevDiff(this->SysMaster->ExecClock()))
451  cacheExecValue += tParamExprValueRecord->ExecBuffer() - tParamExprValueRecord->PrevBuffer();
452 
453  if (this->mVectorNotScalars[tParamSerial])
454  {
455  VectorRecord<paramMetric> const * tParamExprVectorRecord = mParamExprMetricRecords[tParamSerial].mExprVectorRecord;
456  for (Index tDiffIndex = 0; tDiffIndex < tParamExprVectorRecord->PrevSerialCount(); ++tDiffIndex)
457  {
458  Serial const tParamFactorSerial = tParamExprVectorRecord->PrevSerial(tDiffIndex);
459  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
460  cacheExecVector->Item(tFactorSerial) +=
461  mParamOptiSwapOperators[tParamSerial](tParamExprVectorRecord->Field(tParamFactorSerial).ExecBuffer()) -
462  mParamOptiSwapOperators[tParamSerial](tParamExprVectorRecord->Field(tParamFactorSerial).PrevBuffer());
463  tempChangedVector->tagBool(tFactorSerial);
464  }
465  }
466  else
467  {
468  ScalarRecord<paramMetric> const * tParamExprScalarRecord = mParamExprMetricRecords[tParamSerial].mExprScalarRecord;
469  if (tParamExprScalarRecord->PrevDiff(this->SysMaster->ExecClock()))
470  for(Serial tParamFactorSerial = 0; tParamFactorSerial < this->ParamFactors[tParamSerial].ItemCount(); ++tParamFactorSerial)
471  {
472  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
473  cacheExecVector->Item(tFactorSerial) +=
474  mParamOptiSwapOperators[tParamSerial](tParamExprScalarRecord->ExecBuffer()) -
475  mParamOptiSwapOperators[tParamSerial](tParamExprScalarRecord->PrevBuffer());
476  tempChangedVector->tagBool(tFactorSerial);
477  }
478  }
479  }
480  this->mExprValueRecord->updateExecData(this->SysMaster->ExecClock(), tc<ValueBuffType,value>::iof(cacheExecValue));
481 
482  this->mExprVectorRecord->resetPrevSerials(this->SysMaster->ExecClock());
483  for(Index tIndex = 0; tIndex < tempChangedVector->TagCount(); ++tIndex)
484  {
485  Serial const tFactorSerial = tempChangedVector->TaggedSerial(tIndex);
486  this->mExprVectorRecord->updateExecData(tFactorSerial, this->SysMaster->ExecClock(),
487  tc<MetricBuffType,metric>::iof(cacheExecVector->Item(tFactorSerial)));
488  }
489  }
490  #if ComputeLazy
491  }
492  else
493  {
494  if (this->needExecParamComputation()) this->markExecParams();
495  tempChangedVector->sweep(this->SysMaster->ExecClock());
496  for(Index tIndex = 0; tIndex < this->mBlockExecParams->ItemCount(); ++tIndex)
497  {
498  Serial const tParamSerial = this->mBlockExecParams->Item(tIndex);
499  Expression::performExecIncr(this->ParamExprs[tParamSerial]);
500  ValueRecord<paramValue> const * tParamExprValueRecord = mParamExprValueRecords[tParamSerial];
501 
502  if (this->mScalarUndoneParams->Tagged(tParamSerial))
503  {
504  cacheExecValue += tParamExprValueRecord->ExecData();
505  if (!this->mVectorNotScalars[tParamSerial])
506  {
507  ScalarRecord<paramMetric> const * tParamExprScalarRecord = mParamExprMetricRecords[tParamSerial].mExprScalarRecord;
508  for(Serial tParamFactorSerial = 0; tParamFactorSerial < this->ParamFactors[tParamSerial].ItemCount(); ++tParamFactorSerial)
509  {
510  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
511  cacheExecVector->Item(tFactorSerial) +=
512  mParamOptiSwapOperators[tParamSerial](tParamExprScalarRecord->ExecData());
513  tempChangedVector->tagBool(tFactorSerial);
514  }
515  }
516  }
517  else
518  {
519  if (tParamExprValueRecord->PrevDiff(this->SysMaster->ExecClock()))
520  cacheExecValue += tParamExprValueRecord->ExecBuffer() - tParamExprValueRecord->PrevBuffer();
521  if (!this->mVectorNotScalars[tParamSerial])
522  {
523  ScalarRecord<paramMetric> const * tParamExprScalarRecord = mParamExprMetricRecords[tParamSerial].mExprScalarRecord;
524 
525  if (tParamExprScalarRecord->PrevDiff(this->SysMaster->ExecClock()))
526  for(Serial tParamFactorSerial = 0; tParamFactorSerial < this->ParamFactors[tParamSerial].ItemCount(); ++tParamFactorSerial)
527  {
528  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
529  cacheExecVector->Item(tFactorSerial) +=
530  mParamOptiSwapOperators[tParamSerial](tParamExprScalarRecord->ExecBuffer()) -
531  mParamOptiSwapOperators[tParamSerial](tParamExprScalarRecord->PrevBuffer());
532  tempChangedVector->tagBool(tFactorSerial);
533  }
534  }
535  }
536  if (this->mVectorNotScalars[tParamSerial])
537  {
538  VectorRecord<paramMetric> const * tParamExprVectorRecord = mParamExprMetricRecords[tParamSerial].mExprVectorRecord;
539  if (tParamExprVectorRecord->PrevSerialCount())
540  for (Index tDiffIndex = 0; tDiffIndex < tParamExprVectorRecord->PrevSerialCount(); ++tDiffIndex)
541  {
542  Serial const tParamFactorSerial = tParamExprVectorRecord->PrevSerial(tDiffIndex);
543  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
544  if (!this->mVectorUndoneParams->List(tParamSerial).Tagged(tParamFactorSerial))
545  {
546  cacheExecVector->Item(tFactorSerial) +=
547  mParamOptiSwapOperators[tParamSerial](tParamExprVectorRecord->Field(tParamFactorSerial).ExecBuffer()) -
548  mParamOptiSwapOperators[tParamSerial](tParamExprVectorRecord->Field(tParamFactorSerial).PrevBuffer());
549  tempChangedVector->tagBool(tFactorSerial);
550  }
551  }
552  }
553  }
554 
555  for(Index tIndex = 0; tIndex < this->mBacklogParams.TagCount(); ++tIndex)
556  {
557  Serial const tParamSerial = this->mBacklogParams.TaggedSerial(tIndex);
558  if (this->mLabelExecParams.Tagged(tParamSerial)) continue;
559  Expression::performExecBacklog(this->ParamExprs[tParamSerial]);
560  ValueRecord<paramValue> const * tParamExprValueRecord = mParamExprValueRecords[tParamSerial];
561 
562  if (this->mScalarUndoneParams->Tagged(tParamSerial))
563  {
564  cacheExecValue += tParamExprValueRecord->ExecData();
565  if (!this->mVectorNotScalars[tParamSerial])
566  {
567  ScalarRecord<paramMetric> const * tParamExprScalarRecord = mParamExprMetricRecords[tParamSerial].mExprScalarRecord;
568 
569  for(Serial tParamFactorSerial = 0; tParamFactorSerial < this->ParamFactors[tParamSerial].ItemCount(); ++tParamFactorSerial)
570  {
571  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
572  cacheExecVector->Item(tFactorSerial) +=
573  mParamOptiSwapOperators[tParamSerial](tParamExprScalarRecord->ExecData());
574  tempChangedVector->tagBool(tFactorSerial);
575  }
576  }
577  }
578  else
579  {
580  if (tParamExprValueRecord->PrevDiff(this->SysMaster->ExecClock()))
581  cacheExecValue += tParamExprValueRecord->ExecBuffer() - tParamExprValueRecord->PrevBuffer();
582  if (!this->mVectorNotScalars[tParamSerial])
583  {
584  ScalarRecord<paramMetric> const * tParamExprScalarRecord = mParamExprMetricRecords[tParamSerial].mExprScalarRecord;
585  if (tParamExprScalarRecord->PrevDiff(this->SysMaster->ExecClock()))
586  for(Serial tParamFactorSerial = 0; tParamFactorSerial < this->ParamFactors[tParamSerial].ItemCount(); ++tParamFactorSerial)
587  {
588  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
589  cacheExecVector->Item(tFactorSerial) +=
590  mParamOptiSwapOperators[tParamSerial](tParamExprScalarRecord->ExecBuffer()) -
591  mParamOptiSwapOperators[tParamSerial](tParamExprScalarRecord->PrevBuffer());
592  tempChangedVector->tagBool(tFactorSerial);
593  }
594  }
595  }
596  if (this->mVectorNotScalars[tParamSerial])
597  {
598  VectorRecord<paramMetric> const * tParamExprVectorRecord = mParamExprMetricRecords[tParamSerial].mExprVectorRecord;
599  for (Index tDiffIndex = 0; tDiffIndex < tParamExprVectorRecord->PrevSerialCount(); ++tDiffIndex)
600  {
601  Serial const tParamFactorSerial = tParamExprVectorRecord->PrevSerial(tDiffIndex);
602  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
603  if (!this->mVectorUndoneParams->List(tParamSerial).Tagged(tParamFactorSerial))
604  {
605  cacheExecVector->Item(tFactorSerial) +=
606  mParamOptiSwapOperators[tParamSerial](tParamExprVectorRecord->Field(tParamFactorSerial).ExecBuffer()) -
607  mParamOptiSwapOperators[tParamSerial](tParamExprVectorRecord->Field(tParamFactorSerial).PrevBuffer());
608  tempChangedVector->tagBool(tFactorSerial);
609  }
610  }
611  for(Index tUndoIndex = 0; tUndoIndex < this->mVectorUndoneParams->List(tParamSerial).TagCount(); ++tUndoIndex)
612  {
613  Serial const tParamFactorSerial = this->mVectorUndoneParams->List(tParamSerial).TaggedSerial(tUndoIndex);
614  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
615  cacheExecVector->Item(tFactorSerial) +=
616  mParamOptiSwapOperators[tParamSerial](tParamExprVectorRecord->Field(tParamFactorSerial).ExecData());
617  tempChangedVector->tagBool(tFactorSerial);
618  }
619  }
620  }
621 
622  this->mExprValueRecord->updateExecData(this->SysMaster->ExecClock(), tc<ValueBuffType,value>::iof(cacheExecValue));
623  this->mExprVectorRecord->resetPrevSerials(this->SysMaster->ExecClock());
624  for(Index tIndex = 0; tIndex < tempChangedVector->TagCount(); ++tIndex)
625  {
626  Serial const tFactorSerial = tempChangedVector->TaggedSerial(tIndex);
627  this->mExprVectorRecord->updateExecData(tFactorSerial,this->SysMaster->ExecClock(),
628  tc<MetricBuffType,metric>::iof(cacheExecVector->Item(tFactorSerial)));
629  }
630  }
631  this->runPostExecIncr();
632  #endif // ComputeLazy
633  #endif//ExecDownward
634  CatchError
635 }
636 
637 
638 #if ComputeLazy
639 
642 template <Order MaxiOrMini, typename paramValue, typename value, typename paramMetric, typename metric>
643 inline void SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric>::executeBacklog()
644 {
645  WatchError
646  for(Index tIndex = 0; tIndex < this->mBacklogParams.TagCount(); ++tIndex)
647  {
648  Serial const tParamSerial = this->mBacklogParams.TaggedSerial(tIndex);
649  Expression::performExecBacklog(this->ParamExprs[tParamSerial]);
650 
651  ScalarRecord<paramMetric> const * tParamExprValueRecord = mParamExprValueRecords[tParamSerial];
652 
653  if (this->mScalarUndoneParams->Tagged(tParamSerial))
654  {
655  cacheExecValue += tParamExprValueRecord->ExecData();
656  if (!this->mVectorNotScalars[tParamSerial])
657  {
658  ScalarRecord<paramMetric> const * tParamExprScalarRecord = mParamExprMetricRecords[tParamSerial].mExprScalarRecord;
659 
660  for(Serial tParamFactorSerial = 0; tParamFactorSerial < this->ParamFactors[tParamSerial].ItemCount(); ++tParamFactorSerial)
661  {
662  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
663  cacheExecVector->Item(tFactorSerial) +=
664  mParamOptiSwapOperators[tParamSerial](tParamExprScalarRecord->ExecData());
665  tempChangedVector->tagBool(tFactorSerial);
666  }
667  }
668  }
669  else
670  {
671  if (tParamExprValueRecord->PrevDiff(this->SysMaster->ExecClock()))
672  cacheExecValue += tParamExprValueRecord->ExecBuffer() - tParamExprValueRecord->PrevBuffer();
673  if (!this->mVectorNotScalars[tParamSerial])
674  {
675  ScalarRecord<paramMetric> const * tParamExprScalarRecord = mParamExprMetricRecords[tParamSerial].mExprScalarRecord;
676 
677  if (tParamExprScalarRecord->PrevDiff(this->SysMaster->ExecClock()))
678  for(Serial tParamFactorSerial = 0; tParamFactorSerial < this->ParamFactors[tParamSerial].ItemCount(); ++tParamFactorSerial)
679  {
680  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
681  cacheExecVector->Item(tFactorSerial) +=
682  mParamOptiSwapOperators[tParamSerial](tParamExprScalarRecord->ExecBuffer()) -
683  mParamOptiSwapOperators[tParamSerial](tParamExprScalarRecord->PrevBuffer());
684  tempChangedVector->tagBool(tFactorSerial);
685  }
686  }
687  }
688  if (this->mVectorNotScalars[tParamSerial])
689  {
690  VectorRecord<paramMetric> const * tParamExprVectorRecord = mParamExprMetricRecords[tParamSerial].mExprVectorRecord;
691  for (Index tDiffIndex = 0; tDiffIndex < tParamExprVectorRecord->PrevSerialCount(); ++tDiffIndex)
692  {
693  Serial const tParamFactorSerial = tParamExprVectorRecord->PrevSerial(tDiffIndex);
694  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
695  if (!this->mVectorUndoneParams->List(tParamSerial).Tagged(tParamFactorSerial))
696  {
697  cacheExecVector->Item(tFactorSerial) +=
698  mParamOptiSwapOperators[tParamSerial](tParamExprVectorRecord->Field(tParamFactorSerial).ExecBuffer()) -
699  mParamOptiSwapOperators[tParamSerial](tParamExprVectorRecord->Field(tParamFactorSerial).PrevBuffer());
700  tempChangedVector->tagBool(tFactorSerial);
701  }
702  }
703  for(Index tUndoIndex = 0; tUndoIndex < this->mVectorUndoneParams->List(tParamSerial).TagCount(); ++tUndoIndex)
704  {
705  Serial const tParamFactorSerial = this->mVectorUndoneParams->List(tParamSerial).TaggedSerial(tUndoIndex);
706  Serial const tFactorSerial = this->ParamFactors[tParamSerial][tParamFactorSerial];
707  cacheExecVector->Item(tFactorSerial) +=
708  mParamOptiSwapOperators[tParamSerial](tParamExprVectorRecord->Field(tParamFactorSerial).ExecData());
709  tempChangedVector->tagBool(tFactorSerial);
710  }
711  }
712  }
713 
714  this->mExprValueRecord->updateExecData(this->SysMaster->ExecClock(), tc<ValueBuffType,value>::iof(cacheExecValue));
715  this->mExprVectorRecord->resetPrevSerials(this->SysMaster->ExecClock());
716  for(Index tIndex = 0; tIndex < tempChangedVector->TagCount(); ++tIndex)
717  {
718  Serial const tFactorSerial = tempChangedVector->TaggedSerial(tIndex);
719  this->mExprVectorRecord->updateExecData(tFactorSerial,this->SysMaster->ExecClock(),
720  tc<MetricBuffType,metric>::iof(cacheExecVector->Item(tFactorSerial)));
721  }
722  this->runPostExecBacklog();
723  CatchError
724 }
725 #endif // ComputeLazy
726 
727 
728 
732 template <Order MaxiOrMini, typename paramValue, typename value, typename paramMetric, typename metric>
733 inline void SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric>::simulateIncr()
734 {
735  WatchError
736  #if SimulUpward
737  if (this->mSimulChangedParams.TagCount())
738  {
739  ValueBuffType tSimulValue = cacheExecValue;
740  for(Index tIndex = 0; tIndex < this->mSimulChangedParams.TagCount(); ++tIndex)
741  {
742  Serial const tParamSerial = this->mSimulChangedParams.TaggedSerial(tIndex);
743  ValueRecord<paramValue> const * tParamExprValueRecord = mParamExprValueRecords[tParamSerial];
744  if (tParamExprValueRecord->SimulDiff(this->SysMaster->SimulClock()))
745  tSimulValue += tParamExprValueRecord->SimulBuffer() - tParamExprValueRecord->ExecBuffer();
746  }
747  this->mExprValueRecord->updateSimulData(this->SysMaster->SimulClock(), tc<ValueBuffType,value>::iof(tSimulValue));
748  this->runPostSimulIncr();
749  }
750  #endif //SimulUpward
751  #if SimulDownward
752  #if ComputeLazy
753  if (!this->BacklogExists())
754  {
755  #endif // ComputeLazy
756  #if SimulFlexi
757  if (this->needSimulFlexiParamComputation()) this->listSimulFlexiParams();
758  #endif
759  #if SimulFixedFlexi
760  if (this->needSimulFixedParamComputation())
761  this->enumSimulFixedParams(this->mBlockSimulFlexiParams->ItemCount());
762  #elif SimulFixedOnly
763  if (this->needSimulFixedParamComputation()) this->listSimulFixedParams();
764  #endif
765 
766  #if SimulFixed
767  if (this->needSimulCacheComputation())
768  {
769  cacheSimulValue = cacheExecValue;
770  for(Index tIndex = 0; tIndex < this->mBlockSimulFixedParams->ItemCount(); ++tIndex)
771  {
772  Serial const tParamSerial = this->mBlockSimulFixedParams->Item(tIndex);
773  cacheSimulValue -= mParamExprValueRecords[tParamSerial]->ExecData();
774  }
775  }
776  #endif
777 
778  #if SimulFixedFlexi
779  if (this->mBlockSimulFixedParams->ItemCount() || this->mBlockSimulFlexiParams->ItemCount())
780  #elif SimulFixedOnly
781  if (this->mBlockSimulFixedParams->ItemCount())
782  #elif SimulFlexiOnly
783  if (this->mBlockSimulFlexiParams->ItemCount())
784  #endif
785  {
786  #if SimulFixed
787  ValueBuffType tSimulValue = cacheSimulValue;
788  #else
789  ValueBuffType tSimulValue = cacheExecValue;
790  #endif//SimulFixed
791 
792  #if SimulFixed
793  for(Index tIndex = 0; tIndex < this->mBlockSimulFixedParams->ItemCount(); ++tIndex)
794  {
795  Serial const tParamSerial = this->mBlockSimulFixedParams->Item(tIndex);
796  Expression::performSimulIncr(this->ParamExprs[tParamSerial]);
797  tSimulValue += mParamExprValueRecords[tParamSerial]->SimulData(this->SysMaster->SimulClock()); //not SimulBuffer()!
798  }
799  #endif//SimulFixed
800 
801  #if SimulFlexi
802  for(Index tIndex = 0; tIndex < this->mBlockSimulFlexiParams->ItemCount(); ++tIndex)
803  {
804  Serial const tParamSerial = this->mBlockSimulFlexiParams->Item(tIndex);
805  #if SimulFixed
806  if (this->mLabelSimulFixedParams.Tagged(tParamSerial)) continue;
807  #endif
808  Expression::performSimulIncr(this->ParamExprs[tParamSerial]);
809 
810  ValueRecord<paramValue> const * tParamExprValueRecord = mParamExprValueRecords[tParamSerial];
811  if (tParamExprValueRecord->SimulDiff(this->SysMaster->SimulClock()))
812  tSimulValue += tParamExprValueRecord->SimulBuffer() - tParamExprValueRecord->ExecBuffer();
813  }
814  #endif//SimulFlexi
815 
816  this->mExprValueRecord->updateSimulData(this->SysMaster->SimulClock(), tc<ValueBuffType,value>::iof(tSimulValue));
817  }
818  #if ComputeLazy
819  }
820  else // defered
821  {
822  #if SimulFlexi
823  if (this->needSimulFlexiParamComputation()) this->listSimulFlexiParams();
824  #endif
825  #if SimulFixed
826  if (this->needSimulFixedParamComputation()) this->markSimulFixedParams();
827  #endif
828 
829  if (this->needSimulCacheComputation())
830  {
831  if (!this->ChangedSystemEmulClock())
832  {
833  cacheSimulValue = cacheEmulValue;
834  #if SimulFixed
835  for(Index tIndex = 0; tIndex < this->mBlockSimulFixedParams->ItemCount(); ++tIndex)
836  {
837  Serial const tParamSerial = this->mBlockSimulFixedParams->Item(tIndex);
838  cacheSimulValue -= mParamExprValueRecords[tParamSerial]->EmulData(this->SysMaster->EmulClock());
839  }
840  #endif //SimulFixed
841  }
842  else
843  {
844  cacheSimulValue = cacheExecValue;
845  #if SimulFixed
846  for(Index tIndex = 0; tIndex < this->mBlockSimulFixedParams->ItemCount(); ++tIndex)
847  {
848  Serial const tParamSerial = this->mBlockSimulFixedParams->Item(tIndex);
849  if (!this->mScalarUndoneParams->Tagged(tParamSerial))
850  cacheSimulValue -= mParamExprValueRecords[tParamSerial]->ExecData();
851  }
852  #endif //SimulFixed
853  for(Index tIndex = 0; tIndex < this->mBacklogParams.TagCount(); ++tIndex)
854  {
855  Serial const tParamSerial = this->mBacklogParams.TaggedSerial(tIndex);
856  #if SimulFixed
857  if (this->mLabelSimulFixedParams.Tagged(tParamSerial)) continue;
858  #endif //SimulFixed
859  Expression::performEmulBacklog(this->ParamExprs[tParamSerial]);
860  ValueRecord<paramValue> const * tParamExprValueRecord = mParamExprValueRecords[tParamSerial];
861 
862  if (this->mScalarUndoneParams->Tagged(tParamSerial))
863  cacheSimulValue += tParamExprValueRecord->EmulData(this->SysMaster->EmulClock()); // emulation data, not buff.
864  else if (tParamExprValueRecord->EmulDiff(this->SysMaster->EmulClock()))
865  cacheSimulValue += tParamExprValueRecord->EmulBuffer() - tParamExprValueRecord->ExecBuffer();
866  }
867  }
868  }
869 
870  ValueBuffType tSimulValue = cacheSimulValue;
871 
872  #if SimulFixed
873  for(Index tIndex = 0; tIndex < this->mBlockSimulFixedParams->ItemCount(); ++tIndex)
874  {
875  Serial const tParamSerial = this->mBlockSimulFixedParams->Item(tIndex);
876  Expression::performSimulIncr(this->ParamExprs[tParamSerial]);
877  tSimulValue += mParamExprValueRecords[tParamSerial]->SimulData(this->SysMaster->SimulClock()); //not SimulBuffer()!
878  }
879  #endif//SimulFixed
880 
881  #if SimulFlexi
882  for(Index tIndex = 0; tIndex < this->mBlockSimulFlexiParams->ItemCount(); ++tIndex)
883  {
884  Serial const tParamSerial = this->mBlockSimulFlexiParams->Item(tIndex);
885 
886  #if SimulFixed
887  if (this->mLabelSimulFixedParams.Tagged(tParamSerial)) continue;
888  #endif
889 
890  Expression::performEmulBacklog(this->ParamExprs[tParamSerial]);
891  Expression::performSimulIncr(this->ParamExprs[tParamSerial]);
892  ValueRecord<paramValue> const * tParamExprValueRecord = mParamExprValueRecords[tParamSerial];
893  if (tParamExprValueRecord->EmulSimulDiff(this->SysMaster->EmulClock(), this->SysMaster->SimulClock()))
894  tSimulValue += tParamExprValueRecord->SimulData(this->SysMaster->SimulClock()) -
895  tParamExprValueRecord->EmulData(this->SysMaster->EmulClock());
896  }
897  #endif
898 
899  this->mExprValueRecord->updateSimulData(this->SysMaster->SimulClock(), tc<ValueBuffType,value>::iof(tSimulValue));
900  }
901  #endif // ComputeLazy
902  #endif//SimulDownward
903  CatchError
904 }
905 
906 
907 
908 #if ComputeLazy
909 
912 template <Order MaxiOrMini, typename paramValue, typename value, typename paramMetric, typename metric>
913 inline void SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector<MaxiOrMini,paramValue,value,paramMetric,metric>::emulateBacklog()
914 {
915  WatchError
916  cacheEmulValue = cacheExecValue;
917  for(Index tIndex = 0; tIndex < this->mBacklogParams.TagCount(); ++tIndex)
918  {
919  Serial const tParamSerial = this->mBacklogParams.TaggedSerial(tIndex);
920  Expression::performEmulBacklog(this->ParamExprs[tParamSerial]);
921  ValueRecord<paramValue> const * tParamExprValueRecord = mParamExprValueRecords[tParamSerial];
922 
923  if (this->mScalarUndoneParams->Tagged(tParamSerial))
924  cacheEmulValue += tParamExprValueRecord->EmulData(this->SysMaster->EmulClock());
925  else if (tParamExprValueRecord->EmulDiff(this->SysMaster->EmulClock()))
926  cacheEmulValue += tParamExprValueRecord->EmulBuffer() - tParamExprValueRecord->ExecBuffer();
927  }
928  this->mExprValueRecord->updateEmulData(this->SysMaster->EmulClock(), tc<ValueBuffType,value>::iof(cacheEmulValue));
929  CatchError
930 }
931 #endif // ComputeLazy
932 
933 closeKangarooSpace
934 
935 
936 #endif//SummationValueScalarOrFactorVectorOptiSwapToValueFactorVectorHppIncluded
ScalarRecord::updateExecData
void updateExecData(Clock const ExecClock, data const &Data)
Update the execution data.
Definition: scalarrecord.hpp:228
Expression::performExecIncr
static void performExecIncr(Expression *const pExpression)
Execute in incremental mode.
Definition: expression1.hpp:287
Expression::setExprHash
void setExprHash(Hash const pHash)
Set expression hash value.
Definition: expression1.hpp:607
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::ValueType
value ValueType
Value type.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:47
Expression::Updatable
Bool Updatable() const
Whether the expression updatable—variables are updatable, functions may be updatable.
Definition: expression1.hpp:44
System::SimulClock
Clock SimulClock() const
Get the simulation clock.
Definition: system1.hpp:249
SimulFlexiOnly
#define SimulFlexiOnly
Use flexi simulation only, not fixed one.
Definition: options.hpp:166
Function::ParamSpecs
kb< ParamSpecType > const *const ParamSpecs
Parameter specifications i.e. how to use values and metrics.
Definition: function0.hpp:172
VectorRecord::finaliseField
void finaliseField(Serial const FieldSerial, data const &Data)
Finalise the field particularly for unupdatable expressions.
Definition: vectorrecord.hpp:324
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::cacheExecValue
ValueBuffType cacheExecValue
Execution cache value.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:106
ValueVectorFunction< value, metric, FactorVector >::mExprValueRecord
ValueRecord< value > * mExprValueRecord
Point to the value record.
Definition: valueVectorFunction.hpp:81
openKangarooSpace
#define openKangarooSpace
Open the project namespace.
Definition: project.hpp:74
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::mParamExprMetricRecords
kb< VectorOrScalarRecord > mParamExprMetricRecords
Parameter expression metric records.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:99
Function::FactorVars
xb< Variable * > const FactorVars
Factor variables that this function transitively depends on.
Definition: function0.hpp:177
ValueRecord::updateSimulData
void updateSimulData(Clock const SimulClock, data const &Data)
Update the simulation data.
Definition: valuerecord.hpp:299
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::ValueBuffType
DataTempBuff< paramValue, value >::Type ValueBuffType
Value buffer type.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:89
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector(System *const pSystem, Dim const ParamCount, Expression *const *pParamExprs, ParamSpecType *const pParamSpecs)
Param constructor.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:162
kFuncNotRequiredParams
constexpr char const * kFuncNotRequiredParams
Function does not have required parameters.
Definition: messages.hpp:247
ScalarRecord::initialiseExecData
void initialiseExecData(data const &Data)
Initialise the execution data.
Definition: scalarrecord.hpp:214
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector
Summation value scalar or factor vector optimisation swap to value factor vector function.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:41
ScalarRecord::PrevData
data const & PrevData(Clock const ExecClock) const
PrevData = PrevDiff ? PrevBuffer : ExecBuffer().
Definition: scalarrecord.hpp:300
ValueRecord::SimulDiff
Bool SimulDiff(Clock const SimulClock) const
SimulDiff = (SimulClock == SimulClock).
Definition: valuerecord.hpp:420
ScalarRecord::PrevDiff
Bool PrevDiff(Clock const ExecClock) const
PrevDiff = (PrevClock == ExecClock).
Definition: scalarrecord.hpp:313
Function::ParamExprs
kb< Expression * > const ParamExprs
Parameter expressions that this function immediately depends on.
Definition: function0.hpp:171
Function::defineWithinSystem
static Serial defineWithinSystem(Function *const pFunction)
Define the function in the system.
Definition: function1.hpp:1619
Function::calcExprHash
Hash calcExprHash() const
Calculate expression hash value.
Definition: function1.hpp:855
DataTempBuff
Compatible temporary buffer type for two given data types.
Definition: datatypes.hpp:294
DefaultParam
Use default parameter option which is just null.
Definition: parameter.hpp:32
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::~SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector
~SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector()
Destructor.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:122
ValueRecord::SimulBuffer
data const & SimulBuffer() const
Return simulation buffer; validity depends on SimulDiff.
Definition: valuerecord.hpp:365
VectorRecord::Field
VectorField< data > const & Field(Serial const FieldSerial) const
Get the field data for a given field.
Definition: vectorrecord.hpp:258
Function::setParameters
void setParameters(ParamOrder const pParamOrder, Dim const ParamCount, Expression *const *const pParamExprs, ParamSpecType const *const pParamSpecs=nullptr, Index *const pParamIndexes=nullptr)
Set the parameters, if unordered then expression pointers along with indexes (if given) are sorted...
Definition: function1.hpp:927
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::computeFinal
virtual void computeFinal()
Compute the expression.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:207
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::simulateIncr
virtual void simulateIncr()
Simulate the expression.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:733
ScalarRecord::ExecData
data const & ExecData() const
Return execution data in execution buffer.
Definition: scalarrecord.hpp:287
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::ParamValueType
paramValue ParamValueType
Parameter value type.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:45
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::ParamMetricType
paramMetric ParamMetricType
Parameter metric type.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:46
checkReifyScalarAsVectorMetric
Bool checkReifyScalarAsVectorMetric(ParamSpecType const ParamSpec)
Definition: parameter.hpp:109
VectorRecord::initialiseExecData
void initialiseExecData(Serial const FieldSerial, data const &Data)
Initialise the execution buffer, particularly for anew execution.
Definition: vectorrecord.hpp:336
Expression::setExprFormat
void setExprFormat(Identifier const pFormat)
Set expression format.
Definition: expression1.hpp:577
ValueRecord::finaliseRecord
void finaliseRecord(data const &Data)
Finalise the record.
Definition: valuerecord.hpp:262
Expression::performExecAnew
static void performExecAnew(Expression *const pExpression)
Execute in anew mode.
Definition: expression1.hpp:271
VectorRecord::PrevSerialCount
Dim PrevSerialCount() const
Get the number of fields with previous data; valid when PrevDiffSerials.
Definition: vectorrecord.hpp:270
ScalarRecord::PrevBuffer
data const & PrevBuffer() const
Return previous data in previous buffer: validity depends on PrevDiff.
Definition: scalarrecord.hpp:339
NaryValueScalarOrFactorVectorToValueFactorVectorFunc::mVectorNotScalars
kb< Bool > mVectorNotScalars
Whether optimisation segment is a vector or a scalar.
Definition: naryValueScalarOrFactorVectorToValueFactorVectorFunc.hpp:63
ValueVectorFunction< value, metric, FactorVector >::defineExprValueRecord
void defineExprValueRecord()
Define expression value.
identifier
Unique identifier of a class.
Function::defineRootWithinSystem
void defineRootWithinSystem()
Define as a root within the system.
Definition: function1.hpp:1605
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::executeAnew
virtual void executeAnew()
Execute the expression.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:254
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::define
static SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector< MaxiOrMini, paramValue, value, paramMetric, metric > * define(System *const pSystem, Dim const ParamCount, Expression *const *ParamExprs, ParamSpecType *const ParamSpecs=nullptr)
Define a summation value scalar or factor vector optimisation swap to value factor vector...
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:137
System::ExecClock
Clock ExecClock() const
Get the execution clock.
Definition: system1.hpp:237
VectorRecord::updateExecData
Bool updateExecData(Serial const FieldSerial, Clock const ExecClock, data const &Data)
Update the execution buffer and insert into previous fields if needed.
Definition: vectorrecord.hpp:348
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::tempChangedVector
kll< Serial > * tempChangedVector
Vector that undergone changes.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:113
ValueVectorFunction< value, metric, FactorVector >::defineExprVectorRecord
void defineExprVectorRecord(Dim const FieldCount)
Define vector record.
VectorRecord::resetPrevSerials
void resetPrevSerials(Clock const ExecClock)
Reset the list of fields having previous data.
Definition: vectorrecord.hpp:309
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::mParamOptiSwapOperators
kb< OptiSwap< paramMetric, MetricBuffType > > mParamOptiSwapOperators
Parameter optimisation swap operators.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:100
UnorderedParams
Unordered parameters.
Definition: parameter.hpp:66
Expression::performSimulIncr
static void performSimulIncr(Expression *const pExpression)
Simulate in incremental mode.
Definition: expression1.hpp:326
ScalarRecord::ExecBuffer
data const & ExecBuffer() const
Return execution data in execution buffer.
Definition: scalarrecord.hpp:326
System
Constraint-based local search systems.
Definition: system0.hpp:45
ParamSpecType
BitStr ParamSpecType
Parameter specification type.
Definition: parameter.hpp:76
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::mParamExprValueRecords
kb< ValueRecord< paramValue > const * > mParamExprValueRecords
Parameter expression value records.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:98
Expression::SysMaster
System *const SysMaster
The system that contains this expression.
Definition: expression0.hpp:281
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::simulateAnew
virtual void simulateAnew()
Simulate the expression.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:307
NaryValueScalarOrFactorVectorToValueFactorVectorFunc
Flexible arity value scalar or vector to value vector functions.
Definition: naryValueScalarOrFactorVectorToValueFactorVectorFunc.hpp:31
DataTempBuff::Type
void Type
Temporary buffer type.
Definition: datatypes.hpp:297
SimulFixedOnly
#define SimulFixedOnly
Use fixed simulation only, not flexi one.
Definition: options.hpp:165
closeKangarooSpace
#define closeKangarooSpace
Close the project namespace.
Definition: project.hpp:75
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::cacheExecVector
kb< MetricBuffType > * cacheExecVector
Execution cache Vector.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:112
ValueVectorFunction< value, metric, FactorVector >::mExprVectorRecord
VectorRecord< metric > * mExprVectorRecord
Point to the vector record.
Definition: valueVectorFunction.hpp:82
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::MetricBuffType
DataTempBuff< paramMetric, metric >::Type MetricBuffType
Metric buffer type.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:90
ValueRecord::SimulData
data const & SimulData(Clock const SimulClock) const
SimulDiff ? SimulBuffer : ExecBuffer().
Definition: valuerecord.hpp:408
VectorRecord::PrevSerial
Serial PrevSerial(Index const PrevIndex) const
Get the serial of a field having previous data; valid when PrevDiffSerials.
Definition: vectorrecord.hpp:283
OptiSwap
Optimisation swap operator that is used if maxi and mini are swapped or vice versa.
Definition: optiswap.hpp:33
Expression
Abstract expressions.
Definition: expression0.hpp:41
ValueRecord
Value records store expression values.
Definition: valuerecord.hpp:32
Expression::performSimulAnew
static void performSimulAnew(Expression *const pExpression)
Simulate in anew mode.
Definition: expression1.hpp:310
Function::ParamFactors
nrl< xb< Serial > > const ParamFactors
Variables that parameters depend on. Factor serial of the function are use to represent parameter var...
Definition: function0.hpp:178
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::MetricType
metric MetricType
Metric type.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:48
SummationValueScalarOrFactorVectorOptiSwapToValueFactorVector::executeIncr
virtual void executeIncr()
Execute the expression.
Definition: summationValueScalarOrFactorVectorOptiSwapToValueFactorVector.hpp:382
naryValueScalarOrFactorVectorToValueFactorVectorFunc.hpp
Flexible arity value scalar or vector to value vector function.
Generated on Tue Sep 12 2017 17:22:08 for kangaroo by   doxygen 1.8.11