cisst-saw
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
vctDynamicNArrayLoopEngines.h
Go to the documentation of this file.
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */
3 
4 /*
5 
6  Author(s): Daniel Li, Ofri Sadowsky, Anton Deguet
7  Created on: 2006-07-05
8 
9  (C) Copyright 2006-2013 Johns Hopkins University (JHU), All Rights
10  Reserved.
11 
12 --- begin cisst license - do not edit ---
13 
14 This software is provided "as is" under an open source license, with
15 no warranty. The complete license can be found in license.txt and
16 http://www.cisst.org/cisst/license.txt.
17 
18 --- end cisst license ---
19 */
20 
21 #pragma once
22 #ifndef _vctDynamicNArrayLoopEngines_h
23 #define _vctDynamicNArrayLoopEngines_h
24 
30 #include <cisstCommon/cmnPortability.h>
31 #include <cisstCommon/cmnThrow.h>
32 
33 #include <cisstVector/vctFixedSizeVector.h>
34 #include <cisstVector/vctContainerTraits.h>
35 #include <cisstVector/vctDynamicCompactLoopEngines.h>
36 
42 template <vct::size_type _dimension>
43 class vctDynamicNArrayLoopEngines
44 {
45 public:
46  /* define types */
47  typedef vct::size_type size_type;
48  typedef vct::stride_type stride_type;
49  typedef vct::difference_type difference_type;
50  typedef vct::index_type index_type;
51 
52  VCT_NARRAY_TRAITS_TYPEDEFS(_dimension);
53 
56  inline static void ThrowSizeMismatchException(void) throw(std::runtime_error)
57  {
58  cmnThrow(std::runtime_error("vctDynamicNArrayLoopEngines: Sizes of nArrays don't match"));
59  }
60 
61 
63  inline static void CalculateSTND(nstride_type & stnd,
64  const nsize_type & sizes,
65  const nstride_type & strides)
66  {
67  // set up iterators
68  typename nsize_type::const_iterator sizesIter = sizes.begin();
69  typename nstride_type::const_iterator stridesIter = strides.begin();
70  typename nstride_type::iterator stndIter = stnd.begin();
71  const typename nstride_type::const_iterator stndIterEnd = stnd.end();
72 
73  *stndIter = 0;
74  ++sizesIter;
75  ++stridesIter;
76  ++stndIter;
77 
78  stride_type skippedStrides;
79  for (;
80  stndIter != stndIterEnd;
81  ++sizesIter, ++stridesIter, ++stndIter)
82  {
83  skippedStrides = static_cast<stride_type>(*sizesIter) * (*stridesIter);
84  *stndIter = *(stridesIter-1) - skippedStrides;
85  }
86  }
87 
88 
90  inline static void CalculateOTND(nstride_type & otnd,
91  const nstride_type & strides,
92  const nstride_type & stnd)
93  {
94  // set up iterators
95  stride_type previousOTND = *(strides.rbegin());
96  typename nstride_type::const_reverse_iterator stndIter = stnd.rbegin();
97  typename nstride_type::reverse_iterator otndIter = otnd.rbegin();
98  const typename nstride_type::const_reverse_iterator otnd_rend = otnd.rend();
99 
100  *otndIter = previousOTND;
101  ++otndIter;
102 
103  for (;
104  otndIter != otnd_rend;
105  ++otndIter, ++stndIter)
106  {
107  *otndIter = *stndIter + previousOTND;
108  previousOTND = *otndIter;
109  }
110  }
111 
112 
114  template <class _elementType>
115  inline static void InitializeTargets(vctFixedSizeVector<const _elementType *, _dimension> & targets,
116  const nsize_type & sizes,
117  const nstride_type & strides,
118  const _elementType * basePtr)
119  {
120  typedef _elementType value_type;
121 
122  // set up iterators
123  typename nsize_type::const_iterator sizesIter = sizes.begin();
124  typename nstride_type::const_iterator stridesIter = strides.begin();
125  typename vctFixedSizeVector<const value_type *, _dimension>::iterator targetsIter = targets.begin();
126  const typename vctFixedSizeVector<const value_type *, _dimension>::const_iterator targetsIterEnd = targets.end();
127 
128  stride_type offset;
129  for (;
130  targetsIter != targetsIterEnd;
131  ++targetsIter, ++sizesIter, ++stridesIter)
132  {
133  offset = static_cast<stride_type>(*sizesIter) * (*stridesIter);
134  *targetsIter = basePtr + offset;
135  }
136  }
137 
138 
141  template <class _elementType>
142  inline static void SyncCurrentPointer(const _elementType * & currentPointer,
143  const nstride_type & otnd,
144  difference_type numberOfWrappedDimensions)
145  {
146  const typename nstride_type::const_reverse_iterator otndBegin = otnd.rbegin();
147  currentPointer += otndBegin[numberOfWrappedDimensions];
148  }
149 
150 
153  template <class _elementType, class _pointerType>
154  inline static dimension_type IncrementPointers(vctFixedSizeVector<const _elementType *, _dimension> & targets,
155  _pointerType & currentPointer,
156  const nstride_type & strides,
157  const nstride_type & stnd)
158  {
159  typedef _elementType value_type;
160 
161  // set up iterators
162  typename vctFixedSizeVector<const value_type *, _dimension>::reverse_iterator targetsIter = targets.rbegin();
163  const typename vctFixedSizeVector<const value_type *, _dimension>::const_reverse_iterator targets_rbeg = targets.rbegin();
164  // typename vctFixedSizeVector<const value_type *, _dimension>::reverse_iterator targets_innerIter;
165  typename nstride_type::const_reverse_iterator stridesIter = strides.rbegin();
166  // const typename nstride_type::const_reverse_iterator strides_rend = strides.rend();
167  typename nstride_type::const_reverse_iterator stndIter = stnd.rbegin();
168  // typename nstride_type::const_reverse_iterator stnd_innerIter;
169  dimension_type numberOfWrappedDimensions = 0;
170 
171  //* Below is Ofri's code
172  // Consider the following structure.
173  //
174  // initial target setup : // performed before engine loop is begun, outside of this function
175  // currPtr = base;
176  // for each k
177  // target[k] = currPtr + size[k] * stride[k]; // This should be invariant after every dimension wrap
178  // stnd[k] = stride[k-1] - size[k] * stride[k]; // This is constant through the run
179  //
180  // wrap(nw) : // nw is the number of dimensions wrapped
181  // currPtr += sum_{i =(d-nw)}^{d-1}( stnd[i] ); // obsolete if currPtr already determined; see below
182  // for k = (d-nw) to (d-1)
183  // target[k] = currPtr + size[k] * stride[k];
184  //
185  // check_wrap : // this updates currentPtr (see above) and finds out nw (number of wrapped dimensions)
186  // k = d-1;
187  // nw = 0;
188  // currPtr += stride[k];
189  // while (currPtr == target[k]) {
190  // currPtr += stnd[k];
191  // --k;
192  // ++nw;
193  // }
194  // return nw;
195  //
196  // NOTE: The invariant condition above and the initialization of stnd leads to
197  // size[k] * stride[k] = stride[k-1] - stnd[k];
198 
199  currentPointer += *stridesIter;
200  while (currentPointer == *targetsIter) {
201  currentPointer += *stndIter;
202  ++targetsIter;
203  ++stndIter;
204  ++numberOfWrappedDimensions;
205  if (numberOfWrappedDimensions == _dimension)
206  return numberOfWrappedDimensions;
207  }
208 
209  if (numberOfWrappedDimensions == 0)
210  return numberOfWrappedDimensions;
211 
212  stridesIter += numberOfWrappedDimensions;
213  difference_type targetOffset;
214  do {
215  --targetsIter;
216  --stndIter;
217  targetOffset = *stridesIter - *stndIter;
218  *targetsIter = currentPointer + targetOffset;
219  --stridesIter;
220  } while (targetsIter != targets_rbeg);
221  return numberOfWrappedDimensions;
222  }
223 
224 
225  template <class _incrementalOperationType, class _elementOperationType>
226  class SoNi
227  {
228  public:
229  typedef typename _incrementalOperationType::OutputType OutputType;
230 
231  template <class _inputNArrayType>
232  static OutputType Run(const _inputNArrayType & inputNArray)
233  {
234  typedef _inputNArrayType InputNArrayType;
235  typedef typename InputNArrayType::OwnerType InputOwnerType;
236  typedef typename InputOwnerType::const_pointer InputPointerType;
237 
238  // retrieve owners
239  const InputOwnerType & inputOwner = inputNArray.Owner();
240 
241  // if compact
242  if (inputOwner.IsCompact()) {
243  return vctDynamicCompactLoopEngines::SoCi<_incrementalOperationType, _elementOperationType>::Run(inputOwner);
244  } else {
245  // declare all variables used for inputOwner
246  const nsize_type & inputSizes = inputOwner.sizes();
247  const nstride_type & inputStrides = inputOwner.strides();
248  nstride_type inputSTND;
249  vctFixedSizeVector<InputPointerType, _dimension> inputTargets;
250  InputPointerType inputPointer = inputOwner.Pointer();
251 
252  dimension_type numberOfWrappedDimensions = 0;
253  const dimension_type maxWrappedDimensions = inputOwner.dimension();
254 
255  CalculateSTND(inputSTND, inputSizes, inputStrides);
256  InitializeTargets(inputTargets, inputSizes, inputStrides, inputPointer);
257 
258  OutputType incrementalResult = _incrementalOperationType::NeutralElement();
259 
260  while (numberOfWrappedDimensions != maxWrappedDimensions) {
261  incrementalResult =
262  _incrementalOperationType::Operate(incrementalResult,
263  _elementOperationType::Operate(*inputPointer) );
264 
265  numberOfWrappedDimensions =
266  IncrementPointers(inputTargets, inputPointer, inputStrides, inputSTND);
267  }
268  return incrementalResult;
269  }
270  } // Run method
271  }; // SoNi class
272 
273 
274  template <class _incrementalOperationType, class _elementOperationType>
275  class SoNiNi
276  {
277  public:
278  typedef typename _incrementalOperationType::OutputType OutputType;
279 
280  template <class _input1NArrayType, class _input2NArrayType>
281  static OutputType Run(const _input1NArrayType & input1NArray,
282  const _input2NArrayType & input2NArray)
283  {
284  typedef _input1NArrayType Input1NArrayType;
285  typedef typename Input1NArrayType::OwnerType Input1OwnerType;
286  typedef typename Input1OwnerType::const_pointer Input1PointerType;
287 
288  typedef _input2NArrayType Input2NArrayType;
289  typedef typename Input2NArrayType::OwnerType Input2OwnerType;
290  typedef typename Input2OwnerType::const_pointer Input2PointerType;
291 
292  // retrieve owners
293  const Input1OwnerType & input1Owner = input1NArray.Owner();
294  const Input2OwnerType & input2Owner = input2NArray.Owner();
295 
296  // check sizes
297  const nsize_type & input1Sizes = input1Owner.sizes();
298  const nsize_type & input2Sizes = input2Owner.sizes();
299  if (input1Sizes.NotEqual(input2Sizes)) {
300  ThrowSizeMismatchException();
301  }
302 
303  // if compact and same strides
304  const nstride_type & input1Strides = input1Owner.strides();
305  const nstride_type & input2Strides = input2Owner.strides();
306 
307  if (input1Owner.IsCompact() && input2Owner.IsCompact()
308  && (input1Owner.strides() == input2Owner.strides())) {
309  return vctDynamicCompactLoopEngines::SoCiCi<_incrementalOperationType, _elementOperationType>::Run(input1Owner, input2Owner);
310  } else {
311  // otherwise
312  // declare all variables used for input1Owner
313  nstride_type input1STND;
314  vctFixedSizeVector<Input1PointerType, _dimension> input1Targets;
315  Input1PointerType input1Pointer = input1Owner.Pointer();
316 
317  // declare all variables used for input2Owner
318  nstride_type input2STND;
319  nstride_type input2OTND;
320  Input2PointerType input2Pointer = input2Owner.Pointer();
321 
322  dimension_type numberOfWrappedDimensions = 0;
323  const dimension_type maxWrappedDimensions = input1Owner.dimension();
324 
325  CalculateSTND(input1STND, input1Sizes, input1Strides);
326  CalculateSTND(input2STND, input2Sizes, input2Strides);
327  CalculateOTND(input2OTND, input2Strides, input2STND);
328  InitializeTargets(input1Targets, input1Sizes, input1Strides, input1Pointer);
329 
330  OutputType incrementalResult = _incrementalOperationType::NeutralElement();
331 
332  while (numberOfWrappedDimensions != maxWrappedDimensions) {
333  incrementalResult =
334  _incrementalOperationType::Operate(incrementalResult,
335  _elementOperationType::Operate(*input1Pointer, *input2Pointer) );
336 
337  numberOfWrappedDimensions =
338  IncrementPointers(input1Targets, input1Pointer, input1Strides, input1STND);
339 
340  SyncCurrentPointer(input2Pointer, input2OTND, numberOfWrappedDimensions);
341  }
342  return incrementalResult;
343  }
344  } // Run method
345  }; // SoNiNi class
346 
347 
348  template <class _incrementalOperationType, class _elementOperationType>
349  class SoNiSi
350  {
351  public:
352  typedef typename _incrementalOperationType::OutputType OutputType;
353 
354  template <class _inputNArrayType, class _inputScalarType>
355  static OutputType Run(const _inputNArrayType & inputNArray,
356  const _inputScalarType inputScalar)
357  {
358  typedef _inputNArrayType InputNArrayType;
359  typedef typename InputNArrayType::OwnerType InputOwnerType;
360  typedef typename InputOwnerType::const_pointer InputPointerType;
361 
362  // retrieve owners
363  const InputOwnerType & inputOwner = inputNArray.Owner();
364 
365  // if compact
366  if (inputOwner.IsCompact()) {
367  return vctDynamicCompactLoopEngines::SoCiSi<_incrementalOperationType, _elementOperationType>::Run(inputOwner, inputScalar);
368  } else {
369  // declare all variables used for inputOwner
370  const nsize_type & inputSizes = inputOwner.sizes();
371  const nstride_type & inputStrides = inputOwner.strides();
372  nstride_type inputSTND;
373  vctFixedSizeVector<InputPointerType, _dimension> inputTargets;
374  InputPointerType inputPointer = inputOwner.Pointer();
375 
376  dimension_type numberOfWrappedDimensions = 0;
377  const dimension_type maxWrappedDimensions = inputOwner.dimension();
378 
379  CalculateSTND(inputSTND, inputSizes, inputStrides);
380  InitializeTargets(inputTargets, inputSizes, inputStrides, inputPointer);
381 
382  OutputType incrementalResult = _incrementalOperationType::NeutralElement();
383 
384  while (numberOfWrappedDimensions != maxWrappedDimensions) {
385  incrementalResult =
386  _incrementalOperationType::Operate(incrementalResult,
387  _elementOperationType::Operate(*inputPointer, inputScalar) );
388 
389  numberOfWrappedDimensions =
390  IncrementPointers(inputTargets, inputPointer, inputStrides, inputSTND);
391  }
392  return incrementalResult;
393  }
394  } // Run method
395  }; // SoNiSi class
396 
397 
398  template <class _elementOperationType>
399  class NoNiNi
400  {
401  public:
402  template <class _outputNArrayType, class _input1NArrayType, class _input2NArrayType>
403  static void Run(_outputNArrayType & outputNArray,
404  const _input1NArrayType & input1NArray,
405  const _input2NArrayType & input2NArray)
406  {
407  typedef _outputNArrayType OutputNArrayType;
408  typedef typename OutputNArrayType::OwnerType OutputOwnerType;
409  typedef typename OutputOwnerType::pointer OutputPointerType;
410  typedef typename OutputOwnerType::const_pointer OutputConstPointerType;
411 
412  typedef _input1NArrayType Input1NArrayType;
413  typedef typename Input1NArrayType::OwnerType Input1OwnerType;
414  typedef typename Input1OwnerType::const_pointer Input1PointerType;
415 
416  typedef _input2NArrayType Input2NArrayType;
417  typedef typename Input2NArrayType::OwnerType Input2OwnerType;
418  typedef typename Input2OwnerType::const_pointer Input2PointerType;
419 
420  // retrieve owners
421  OutputOwnerType & outputOwner = outputNArray.Owner();
422  const Input1OwnerType & input1Owner = input1NArray.Owner();
423  const Input2OwnerType & input2Owner = input2NArray.Owner();
424 
425  // check sizes
426  const nsize_type & outputSizes = outputOwner.sizes();
427  const nsize_type & input1Sizes = input1Owner.sizes();
428  const nsize_type & input2Sizes = input2Owner.sizes();
429  if (outputSizes.NotEqual(input1Sizes) || outputSizes.NotEqual(input2Sizes)) {
430  ThrowSizeMismatchException();
431  }
432 
433  // if compact and same strides
434  const nstride_type & outputStrides = outputOwner.strides();
435  const nstride_type & input1Strides = input1Owner.strides();
436  const nstride_type & input2Strides = input2Owner.strides();
437 
438  if (outputOwner.IsCompact() && input1Owner.IsCompact() && input2Owner.IsCompact()
439  && (outputOwner.strides() == input1Owner.strides())
440  && (outputOwner.strides() == input2Owner.strides())) {
441  vctDynamicCompactLoopEngines::CoCiCi<_elementOperationType>::Run(outputOwner, input1Owner, input2Owner);
442  } else {
443  // otherwise
444  // declare all variables used for outputOwner
445  nstride_type outputSTND;
446  vctFixedSizeVector<OutputConstPointerType, _dimension> outputTargets;
447  OutputPointerType outputPointer = outputOwner.Pointer();
448 
449  // declare all variables used for input1Owner
450  nstride_type input1STND;
451  nstride_type input1OTND;
452  Input1PointerType input1Pointer = input1Owner.Pointer();
453 
454  // declare all variables used for input2Owner
455  const nsize_type & input2Sizes = input2Owner.sizes();
456  nstride_type input2STND;
457  nstride_type input2OTND;
458  Input2PointerType input2Pointer = input2Owner.Pointer();
459 
460  dimension_type numberOfWrappedDimensions = 0;
461  const dimension_type maxWrappedDimensions = outputOwner.dimension();
462 
463  CalculateSTND(outputSTND, outputSizes, outputStrides);
464  CalculateSTND(input1STND, input1Sizes, input1Strides);
465  CalculateSTND(input2STND, input2Sizes, input2Strides);
466  CalculateOTND(input1OTND, input1Strides, input1STND);
467  CalculateOTND(input2OTND, input2Strides, input2STND);
468  InitializeTargets(outputTargets, outputSizes, outputStrides, outputPointer);
469 
470  while (numberOfWrappedDimensions != maxWrappedDimensions) {
471  *outputPointer = _elementOperationType::Operate(*input1Pointer, *input2Pointer);
472 
473  numberOfWrappedDimensions =
474  IncrementPointers(outputTargets, outputPointer, outputStrides, outputSTND);
475 
476  SyncCurrentPointer(input1Pointer, input1OTND, numberOfWrappedDimensions);
477  SyncCurrentPointer(input2Pointer, input2OTND, numberOfWrappedDimensions);
478  }
479  }
480  } // Run method
481  }; // NoNiNi class
482 
483 
484  template <class _elementOperationType>
485  class NoNiSi
486  {
487  public:
488  template <class _outputNArrayType, class _inputNArrayType, class _inputScalarType>
489  static void Run(_outputNArrayType & outputNArray,
490  const _inputNArrayType & inputNArray,
491  const _inputScalarType inputScalar)
492  {
493  typedef _outputNArrayType OutputNArrayType;
494  typedef typename OutputNArrayType::OwnerType OutputOwnerType;
495  typedef typename OutputOwnerType::pointer OutputPointerType;
496  typedef typename OutputOwnerType::const_pointer OutputConstPointerType;
497 
498  typedef _inputNArrayType InputNArrayType;
499  typedef typename InputNArrayType::OwnerType InputOwnerType;
500  typedef typename InputOwnerType::const_pointer InputPointerType;
501 
502  // retrieve owners
503  OutputOwnerType & outputOwner = outputNArray.Owner();
504  const InputOwnerType & inputOwner = inputNArray.Owner();
505 
506  // check sizes
507  const nsize_type & outputSizes = outputOwner.sizes();
508  const nsize_type & inputSizes = inputOwner.sizes();
509  if (outputSizes.NotEqual(inputSizes)) {
510  ThrowSizeMismatchException();
511  }
512 
513  // if compact and same strides
514  const nstride_type & outputStrides = outputOwner.strides();
515  const nstride_type & inputStrides = inputOwner.strides();
516 
517  if (outputOwner.IsCompact() && inputOwner.IsCompact()
518  && (outputOwner.strides() == inputOwner.strides())) {
519  vctDynamicCompactLoopEngines::CoCiSi<_elementOperationType>::Run(outputOwner, inputOwner, inputScalar);
520  } else {
521  // otherwise
522  // declare all variables used for outputOwner
523  nstride_type outputSTND;
524  vctFixedSizeVector<OutputConstPointerType, _dimension> outputTargets;
525  OutputPointerType outputPointer = outputOwner.Pointer();
526 
527  // declare all variables used for inputOwner
528  nstride_type inputSTND;
529  nstride_type inputOTND;
530  InputPointerType inputPointer = inputOwner.Pointer();
531 
532  dimension_type numberOfWrappedDimensions = 0;
533  const dimension_type maxWrappedDimensions = outputOwner.dimension();
534 
535  CalculateSTND(outputSTND, outputSizes, outputStrides);
536  CalculateSTND(inputSTND, inputSizes, inputStrides);
537  CalculateOTND(inputOTND, inputStrides, inputSTND);
538  InitializeTargets(outputTargets, outputSizes, outputStrides, outputPointer);
539 
540  while (numberOfWrappedDimensions != maxWrappedDimensions) {
541  *outputPointer = _elementOperationType::Operate(*inputPointer, inputScalar);
542 
543  numberOfWrappedDimensions =
544  IncrementPointers(outputTargets, outputPointer, outputStrides, outputSTND);
545 
546  SyncCurrentPointer(inputPointer, inputOTND, numberOfWrappedDimensions);
547  }
548  }
549  } // Run method
550  }; // NoNiSi class
551 
552 
553  template <class _elementOperationType>
554  class NoSiNi
555  {
556  public:
557  template <class _outputNArrayType, class _inputScalarType, class _inputNArrayType>
558  static void Run(_outputNArrayType & outputNArray,
559  const _inputScalarType inputScalar,
560  const _inputNArrayType & inputNArray)
561  {
562  typedef _outputNArrayType OutputNArrayType;
563  typedef typename OutputNArrayType::OwnerType OutputOwnerType;
564  typedef typename OutputOwnerType::pointer OutputPointerType;
565  typedef typename OutputOwnerType::const_pointer OutputConstPointerType;
566 
567  typedef _inputNArrayType InputNArrayType;
568  typedef typename InputNArrayType::OwnerType InputOwnerType;
569  typedef typename InputOwnerType::const_pointer InputPointerType;
570 
571  // retrieve owners
572  OutputOwnerType & outputOwner = outputNArray.Owner();
573  const InputOwnerType & inputOwner = inputNArray.Owner();
574 
575  // check sizes
576  const nsize_type & outputSizes = outputOwner.sizes();
577  const nsize_type & inputSizes = inputOwner.sizes();
578  if (outputSizes.NotEqual(inputSizes)) {
579  ThrowSizeMismatchException();
580  }
581 
582  // if compact and same strides
583  const nstride_type & outputStrides = outputOwner.strides();
584  const nstride_type & inputStrides = inputOwner.strides();
585 
586  if (outputOwner.IsCompact() && inputOwner.IsCompact()
587  && (outputOwner.strides() == inputOwner.strides())) {
588  vctDynamicCompactLoopEngines::CoSiCi<_elementOperationType>::Run(outputOwner, inputScalar, inputOwner);
589  } else {
590  // otherwise
591  // declare all variables used for outputNArray
592  nstride_type outputSTND;
593  vctFixedSizeVector<OutputConstPointerType, _dimension> outputTargets;
594  OutputPointerType outputPointer = outputNArray.Pointer();
595 
596  // declare all variables used for inputNArray
597  nstride_type inputSTND;
598  nstride_type inputOTND;
599  InputPointerType inputPointer = inputNArray.Pointer();
600 
601  dimension_type numberOfWrappedDimensions = 0;
602  const dimension_type maxWrappedDimensions = outputNArray.dimension();
603 
604  CalculateSTND(outputSTND, outputSizes, outputStrides);
605  CalculateSTND(inputSTND, inputSizes, inputStrides);
606  CalculateOTND(inputOTND, inputStrides, inputSTND);
607  InitializeTargets(outputTargets, outputSizes, outputStrides, outputPointer);
608 
609  while (numberOfWrappedDimensions != maxWrappedDimensions) {
610  *outputPointer = _elementOperationType::Operate(inputScalar, *inputPointer);
611 
612  numberOfWrappedDimensions =
613  IncrementPointers(outputTargets, outputPointer, outputStrides, outputSTND);
614 
615  SyncCurrentPointer(inputPointer, inputOTND, numberOfWrappedDimensions);
616  }
617  }
618  } // Run method
619  }; // NoSiNi class
620 
621 
622  template <class _elementOperationType>
623  class NioSi
624  {
625  public:
626  template <class _inputOutputNArrayType, class _inputScalarType>
627  static void Run(_inputOutputNArrayType & inputOutputNArray,
628  const _inputScalarType inputScalar)
629  {
630  typedef _inputOutputNArrayType InputOutputNArrayType;
631  typedef typename InputOutputNArrayType::OwnerType InputOutputOwnerType;
632  typedef typename InputOutputOwnerType::const_pointer InputOutputConstPointerType;
633  typedef typename InputOutputOwnerType::pointer InputOutputPointerType;
634 
635  // retrieve owners
636  InputOutputOwnerType & inputOutputOwner = inputOutputNArray.Owner();
637 
638  // if compact
639  if (inputOutputOwner.IsCompact()) {
640  vctDynamicCompactLoopEngines::CioSi<_elementOperationType>::Run(inputOutputOwner, inputScalar);
641  } else {
642  // declare all variables used for inputOwner
643  const nsize_type & inputOutputSizes = inputOutputOwner.sizes();
644  const nstride_type & inputOutputStrides = inputOutputOwner.strides();
645  nstride_type inputOutputSTND;
646  vctFixedSizeVector<InputOutputConstPointerType, _dimension> inputOutputTargets;
647  InputOutputPointerType inputOutputPointer = inputOutputOwner.Pointer();
648 
649  dimension_type numberOfWrappedDimensions = 0;
650  const dimension_type maxWrappedDimensions = inputOutputOwner.dimension();
651 
652  CalculateSTND(inputOutputSTND, inputOutputSizes, inputOutputStrides);
653  InitializeTargets(inputOutputTargets, inputOutputSizes, inputOutputStrides, inputOutputPointer);
654 
655  while (numberOfWrappedDimensions != maxWrappedDimensions) {
656  _elementOperationType::Operate(*inputOutputPointer, inputScalar);
657 
658  numberOfWrappedDimensions =
659  IncrementPointers(inputOutputTargets, inputOutputPointer, inputOutputStrides, inputOutputSTND);
660  }
661  }
662  } // Run method
663  }; // NioSi class
664 
665 
666  template <class _elementOperationType>
667  class NioNi
668  {
669  public:
670  template <class _inputOutputNArrayType, class _inputNArrayType>
671  static void Run(_inputOutputNArrayType & inputOutputNArray,
672  const _inputNArrayType & inputNArray)
673  {
674  typedef _inputOutputNArrayType InputOutputNArrayType;
675  typedef typename InputOutputNArrayType::OwnerType InputOutputOwnerType;
676  typedef typename InputOutputOwnerType::const_pointer InputOutputConstPointerType;
677  typedef typename InputOutputOwnerType::pointer InputOutputPointerType;
678 
679  typedef _inputNArrayType InputNArrayType;
680  typedef typename InputNArrayType::OwnerType InputOwnerType;
681  typedef typename InputOwnerType::const_pointer InputPointerType;
682 
683  // retrieve owners
684  InputOutputOwnerType & inputOutputOwner = inputOutputNArray.Owner();
685  const InputOwnerType & inputOwner = inputNArray.Owner();
686 
687  // check sizes
688  const nsize_type & inputOutputSizes = inputOutputOwner.sizes();
689  const nsize_type & inputSizes = inputOwner.sizes();
690  if (inputOutputSizes.NotEqual(inputSizes)) {
691  ThrowSizeMismatchException();
692  }
693 
694  // if compact and same strides
695  const nstride_type & inputOutputStrides = inputOutputOwner.strides();
696  const nstride_type & inputStrides = inputOwner.strides();
697 
698  if (inputOutputOwner.IsCompact() && inputOwner.IsCompact()
699  && (inputOutputOwner.strides() == inputOwner.strides())) {
700  vctDynamicCompactLoopEngines::CioCi<_elementOperationType>::Run(inputOutputOwner, inputOwner);
701  } else {
702  // otherwise
703  // declare all variables used for inputOutputOwner
704  nstride_type inputOutputSTND;
705  vctFixedSizeVector<InputOutputConstPointerType, _dimension> inputOutputTargets;
706  InputOutputPointerType inputOutputPointer = inputOutputOwner.Pointer();
707 
708  // declare all variables used for inputOwner
709  nstride_type inputSTND;
710  nstride_type inputOTND;
711  InputPointerType inputPointer = inputOwner.Pointer();
712 
713  dimension_type numberOfWrappedDimensions = 0;
714  const dimension_type maxWrappedDimensions = inputOutputOwner.dimension();
715 
716  CalculateSTND(inputOutputSTND, inputOutputSizes, inputOutputStrides);
717  CalculateSTND(inputSTND, inputSizes, inputStrides);
718  CalculateOTND(inputOTND, inputStrides, inputSTND);
719  InitializeTargets(inputOutputTargets, inputOutputSizes, inputOutputStrides, inputOutputPointer);
720 
721  while (numberOfWrappedDimensions != maxWrappedDimensions) {
722  _elementOperationType::Operate(*inputOutputPointer, *inputPointer);
723 
724  numberOfWrappedDimensions =
725  IncrementPointers(inputOutputTargets, inputOutputPointer, inputOutputStrides, inputOutputSTND);
726 
727  SyncCurrentPointer(inputPointer, inputOTND, numberOfWrappedDimensions);
728  }
729  }
730  } // Run method
731  }; // NioNi class
732 
733 
734  template <class _elementOperationType>
735  class NoNi
736  {
737  public:
738  template <class _outputNArrayType, class _inputNArrayType>
739  static inline void Run(_outputNArrayType & outputNArray,
740  const _inputNArrayType & inputNArray)
741  {
742  typedef _outputNArrayType OutputNArrayType;
743  typedef typename OutputNArrayType::OwnerType OutputOwnerType;
744  typedef typename OutputOwnerType::const_pointer OutputConstPointerType;
745  typedef typename OutputOwnerType::pointer OutputPointerType;
746 
747  typedef _inputNArrayType InputNArrayType;
748  typedef typename InputNArrayType::OwnerType InputOwnerType;
749  typedef typename InputOwnerType::const_pointer InputPointerType;
750 
751  // retrieve owners
752  OutputOwnerType & outputOwner = outputNArray.Owner();
753  const InputOwnerType & inputOwner = inputNArray.Owner();
754 
755  // check sizes
756  const nsize_type & outputSizes = outputOwner.sizes();
757  const nsize_type & inputSizes = inputOwner.sizes();
758  if (inputSizes.NotEqual(outputSizes)) {
759  ThrowSizeMismatchException();
760  }
761 
762  // if compact and same strides
763  const nstride_type & outputStrides = outputOwner.strides();
764  const nstride_type & inputStrides = inputOwner.strides();
765 
766  if (outputOwner.IsCompact() && inputOwner.IsCompact()
767  && (outputOwner.strides() == inputOwner.strides())) {
768  vctDynamicCompactLoopEngines::CoCi<_elementOperationType>::Run(outputOwner, inputOwner);
769  } else {
770  // otherwise
771  // declare all variables used for outputNArray
772  nstride_type outputSTND;
773  vctFixedSizeVector<OutputConstPointerType, _dimension> outputTargets;
774  OutputPointerType outputPointer = outputOwner.Pointer();
775 
776  // declare all variables used for inputNArray
777  nstride_type inputSTND;
778  nstride_type inputOTND;
779  InputPointerType inputPointer = inputOwner.Pointer();
780 
781  dimension_type numberOfWrappedDimensions = 0;
782  const dimension_type maxWrappedDimensions = outputOwner.dimension();
783 
784  CalculateSTND(outputSTND, outputSizes, outputStrides);
785  CalculateSTND(inputSTND, inputSizes, inputStrides);
786  CalculateOTND(inputOTND, inputStrides, inputSTND);
787  InitializeTargets(outputTargets, outputSizes, outputStrides, outputPointer);
788 
789  while (numberOfWrappedDimensions != maxWrappedDimensions) {
790  *outputPointer = _elementOperationType::Operate(*inputPointer);
791 
792  numberOfWrappedDimensions =
793  IncrementPointers(outputTargets, outputPointer, outputStrides, outputSTND);
794 
795  SyncCurrentPointer(inputPointer, inputOTND, numberOfWrappedDimensions);
796  }
797  }
798  } // Run method
799  }; // NoNi class
800 
801 
802  template <class _elementOperationType>
803  class Nio
804  {
805  public:
806  template <class _inputOutputNArrayType>
807  static void Run(_inputOutputNArrayType & inputOutputNArray)
808  {
809  typedef _inputOutputNArrayType InputOutputNArrayType;
810  typedef typename InputOutputNArrayType::OwnerType InputOutputOwnerType;
811  typedef typename InputOutputOwnerType::const_pointer InputOutputConstPointerType;
812  typedef typename InputOutputOwnerType::pointer InputOutputPointerType;
813 
814  // retrieve owners
815  InputOutputOwnerType & inputOutputOwner = inputOutputNArray.Owner();
816 
817  // if compact and same strides
818  const nstride_type & inputOutputStrides = inputOutputOwner.strides();
819 
820  if (inputOutputOwner.IsCompact()) {
821  vctDynamicCompactLoopEngines::Cio<_elementOperationType>::Run(inputOutputOwner);
822  } else {
823  // otherwise
824  const nsize_type & inputOutputSizes = inputOutputOwner.sizes();
825  nstride_type inputOutputSTND;
826  vctFixedSizeVector<InputOutputConstPointerType, _dimension> inputOutputTargets;
827  InputOutputPointerType inputOutputPointer = inputOutputOwner.Pointer();
828 
829  dimension_type numberOfWrappedDimensions = 0;
830  const dimension_type maxWrappedDimensions = inputOutputOwner.dimension();
831 
832  CalculateSTND(inputOutputSTND, inputOutputSizes, inputOutputStrides);
833  InitializeTargets(inputOutputTargets, inputOutputSizes, inputOutputStrides, inputOutputPointer);
834 
835  while (numberOfWrappedDimensions != maxWrappedDimensions) {
836  _elementOperationType::Operate(*inputOutputPointer);
837 
838  numberOfWrappedDimensions =
839  IncrementPointers(inputOutputTargets, inputOutputPointer, inputOutputStrides, inputOutputSTND);
840  }
841  }
842  } // Run method
843  }; // Nio class
844 
845 
846  template <class _inputOutputElementOperationType, class _scalarNArrayElementOperationType>
847  class NioSiNi
848  {
849  public:
850  template <class _inputOutputNArrayType, class _inputScalarType, class _inputNArrayType>
851  static void Run(_inputOutputNArrayType & inputOutputNArray,
852  const _inputScalarType inputScalar,
853  const _inputNArrayType & inputNArray)
854  {
855  typedef _inputOutputNArrayType InputOutputNArrayType;
856  typedef typename InputOutputNArrayType::OwnerType InputOutputOwnerType;
857  typedef typename InputOutputOwnerType::const_pointer InputOutputConstPointerType;
858  typedef typename InputOutputOwnerType::pointer InputOutputPointerType;
859 
860  typedef _inputNArrayType InputNArrayType;
861  typedef typename InputNArrayType::OwnerType InputOwnerType;
862  typedef typename InputOwnerType::const_pointer InputPointerType;
863 
864  // retrieve owners
865  InputOutputOwnerType & inputOutputOwner = inputOutputNArray.Owner();
866  const InputOwnerType & inputOwner = inputNArray.Owner();
867 
868  // check sizes
869  const nsize_type & inputOutputSizes = inputOutputOwner.sizes();
870  const nsize_type & inputSizes = inputOwner.sizes();
871  if (inputOutputSizes.NotEqual(inputSizes)) {
872  ThrowSizeMismatchException();
873  }
874 
875  // if compact and same strides
876  const nstride_type & inputOutputStrides = inputOutputOwner.strides();
877  const nstride_type & inputStrides = inputOwner.strides();
878 
879  if (inputOutputOwner.IsCompact() && inputOwner.IsCompact()
880  && (inputOutputOwner.strides() == inputOwner.strides())) {
881  vctDynamicCompactLoopEngines::CioSiCi<_inputOutputElementOperationType, _scalarNArrayElementOperationType>::Run(inputOutputOwner, inputScalar, inputOwner);
882  } else {
883  // otherwise
884  // declare all variables used for inputOutputNArray
885  nstride_type inputOutputSTND;
886  vctFixedSizeVector<InputOutputConstPointerType, _dimension> inputOutputTargets;
887  InputOutputPointerType inputOutputPointer = inputOutputNArray.Pointer();
888 
889  // declare all variables used for inputNArray
890  nstride_type inputSTND;
891  nstride_type inputOTND;
892  InputPointerType inputPointer = inputNArray.Pointer();
893 
894  dimension_type numberOfWrappedDimensions = 0;
895  const dimension_type maxWrappedDimensions = inputOutputNArray.dimension();
896 
897  CalculateSTND(inputOutputSTND, inputOutputSizes, inputOutputStrides);
898  CalculateSTND(inputSTND, inputSizes, inputStrides);
899  CalculateOTND(inputOTND, inputStrides, inputSTND);
900  InitializeTargets(inputOutputTargets, inputOutputSizes, inputOutputStrides, inputOutputPointer);
901 
902  while (numberOfWrappedDimensions != maxWrappedDimensions) {
903  _inputOutputElementOperationType::Operate(*inputOutputPointer,
904  _scalarNArrayElementOperationType::Operate(inputScalar, *inputPointer) );
905 
906  numberOfWrappedDimensions =
907  IncrementPointers(inputOutputTargets, inputOutputPointer, inputOutputStrides, inputOutputSTND);
908 
909  SyncCurrentPointer(inputPointer, inputOTND, numberOfWrappedDimensions);
910  }
911  }
912  } // Run method
913  }; // NioSiNi class
914 
915 
916 
917  template <class _inputOutputElementOperationType, class _nArrayElementOperationType>
918  class NioNiNi
919  {
920  public:
921  template <class _inputOutputNArrayType, class _input1NArrayType, class _input2NArrayType>
922  static void Run(_inputOutputNArrayType & inputOutputNArray,
923  const _input1NArrayType & input1NArray,
924  const _input2NArrayType & input2NArray)
925  {
926  typedef _inputOutputNArrayType InputOutputNArrayType;
927  typedef typename InputOutputNArrayType::OwnerType InputOutputOwnerType;
928  typedef typename InputOutputOwnerType::const_pointer InputOutputConstPointerType;
929  typedef typename InputOutputOwnerType::pointer InputOutputPointerType;
930 
931  typedef _input1NArrayType Input1NArrayType;
932  typedef typename Input1NArrayType::OwnerType Input1OwnerType;
933  typedef typename Input1OwnerType::const_pointer Input1PointerType;
934 
935  typedef _input2NArrayType Input2NArrayType;
936  typedef typename Input2NArrayType::OwnerType Input2OwnerType;
937  typedef typename Input2OwnerType::const_pointer Input2PointerType;
938 
939  // retrieve owners
940  InputOutputOwnerType & inputOutputOwner = inputOutputNArray.Owner();
941  const Input1OwnerType & input1Owner = input1NArray.Owner();
942  const Input2OwnerType & input2Owner = input2NArray.Owner();
943 
944  // check sizes
945  const nsize_type & inputOutputSizes = inputOutputOwner.sizes();
946  const nsize_type & input1Sizes = input1Owner.sizes();
947  const nsize_type & input2Sizes = input2Owner.sizes();
948  if (inputOutputSizes.NotEqual(input1Sizes) || inputOutputSizes.NotEqual(input2Sizes)) {
949  ThrowSizeMismatchException();
950  }
951 
952  // if compact and same strides
953  const nstride_type & inputOutputStrides = inputOutputOwner.strides();
954  const nstride_type & input1Strides = input1Owner.strides();
955  const nstride_type & input2Strides = input2Owner.strides();
956 
957  if (inputOutputOwner.IsCompact() && input1Owner.IsCompact() && input2Owner.IsCompact()
958  && (inputOutputOwner.strides() == input1Owner.strides())
959  && (inputOutputOwner.strides() == input2Owner.strides())) {
960  vctDynamicCompactLoopEngines::CioCiCi<_inputOutputElementOperationType, _nArrayElementOperationType>::Run(inputOutputOwner, input1Owner, input2Owner);
961  } else {
962  // otherwise
963  // declare all variables used for inputOutputNArray
964  nstride_type inputOutputSTND;
965  vctFixedSizeVector<InputOutputConstPointerType, _dimension> inputOutputTargets;
966  InputOutputPointerType inputOutputPointer = inputOutputNArray.Pointer();
967 
968  // declare all variables used for input1NArray
969  nstride_type input1STND;
970  nstride_type input1OTND;
971  Input1PointerType input1Pointer = input1NArray.Pointer();
972 
973  // declare all variables used for input2NArray
974  nstride_type input2STND;
975  nstride_type input2OTND;
976  Input2PointerType input2Pointer = input2NArray.Pointer();
977 
978  dimension_type numberOfWrappedDimensions = 0;
979  const dimension_type maxWrappedDimensions = inputOutputNArray.dimension();
980 
981  CalculateSTND(inputOutputSTND, inputOutputSizes, inputOutputStrides);
982  CalculateSTND(input1STND, input1Sizes, input1Strides);
983  CalculateOTND(input1OTND, input1Strides, input1STND);
984  CalculateSTND(input2STND, input2Sizes, input2Strides);
985  CalculateOTND(input2OTND, input2Strides, input2STND);
986  InitializeTargets(inputOutputTargets, inputOutputSizes, inputOutputStrides, inputOutputPointer);
987 
988  while (numberOfWrappedDimensions != maxWrappedDimensions) {
989  _inputOutputElementOperationType::Operate(*inputOutputPointer,
990  _nArrayElementOperationType::Operate(*input1Pointer, *input2Pointer) );
991 
992  numberOfWrappedDimensions =
993  IncrementPointers(inputOutputTargets, inputOutputPointer, inputOutputStrides, inputOutputSTND);
994 
995  SyncCurrentPointer(input1Pointer, input1OTND, numberOfWrappedDimensions);
996  SyncCurrentPointer(input2Pointer, input2OTND, numberOfWrappedDimensions);
997  }
998  }
999  } // Run method
1000  }; // NioNiNi class
1001 
1002 
1003  class MinAndMax
1004  {
1005  public:
1006  template <class _inputNArrayType>
1007  static void Run(const _inputNArrayType & inputNArray,
1008  typename _inputNArrayType::value_type & minValue,
1009  typename _inputNArrayType::value_type & maxValue)
1010  {
1011  typedef _inputNArrayType InputNArrayType;
1012  typedef typename InputNArrayType::OwnerType InputOwnerType;
1013  typedef typename InputOwnerType::value_type value_type;
1014  typedef typename InputOwnerType::const_pointer InputPointerType;
1015 
1016  // retrieve owner
1017  const InputOwnerType & inputOwner = inputNArray.Owner();
1018  InputPointerType inputPointer = inputOwner.Pointer();
1019 
1020  if (inputPointer == 0)
1021  return;
1022 
1023  // if compact
1024  if (inputOwner.IsCompact()) {
1025  vctDynamicCompactLoopEngines::MinAndMax::Run(inputOwner, minValue, maxValue);
1026  } else {
1027  // otherwise
1028  const nsize_type & inputSizes = inputOwner.sizes();
1029  const nstride_type & inputStrides = inputOwner.strides();
1030  nstride_type inputSTND;
1031  vctFixedSizeVector<InputPointerType, _dimension> inputTargets;
1032 
1033  dimension_type numberOfWrappedDimensions = 0;
1034  const dimension_type maxWrappedDimensions = inputOwner.dimension();
1035 
1036  CalculateSTND(inputSTND, inputSizes, inputStrides);
1037  InitializeTargets(inputTargets, inputSizes, inputStrides, inputPointer);
1038 
1039  value_type minElement, maxElement, inputElement;
1040  minElement = maxElement = *inputPointer;
1041 
1042  while (numberOfWrappedDimensions != maxWrappedDimensions) {
1043  inputElement = *inputPointer;
1044 
1045  if (inputElement < minElement) {
1046  minElement = inputElement;
1047  } else if (inputElement > maxElement) {
1048  maxElement = inputElement;
1049  }
1050 
1051  numberOfWrappedDimensions =
1052  IncrementPointers(inputTargets, inputPointer, inputStrides, inputSTND);
1053  }
1054  minValue = minElement;
1055  maxValue = maxElement;
1056  }
1057  } // Run method
1058  }; // MinAndMax class
1059 
1060 
1061 }; // vctDynamicNArrayLoopEngines
1062 
1063 
1064 #endif // _vctDynamicNArrayLoopEngines_h
1065 
vctDynamicNArrayLoopEngines::SoNiNi::OutputType
_incrementalOperationType::OutputType OutputType
Definition: vctDynamicNArrayLoopEngines.h:278
vct::index_type
size_t index_type
Definition: vctContainerTraits.h:36
vctFixedStrideVectorIterator
Definition: vctFixedStrideVectorIterator.h:224
vctDynamicCompactLoopEngines::SoCi::Run
static OutputType Run(const _inputOwnerType &inputOwner)
Definition: vctDynamicCompactLoopEngines.h:406
vctDynamicCompactLoopEngines::Cio::Run
static void Run(_inputOutputOwnerType &inputOutputOwner)
Definition: vctDynamicCompactLoopEngines.h:367
vctDynamicCompactLoopEngines::CoCi::Run
static void Run(_outputOwnerType &outputOwner, const _inputOwnerType &inputOwner)
Definition: vctDynamicCompactLoopEngines.h:325
vctDynamicNArrayLoopEngines::SoNiSi::OutputType
_incrementalOperationType::OutputType OutputType
Definition: vctDynamicNArrayLoopEngines.h:352
vctDynamicNArrayLoopEngines::MinAndMax
Definition: vctDynamicNArrayLoopEngines.h:1003
vctDynamicNArrayLoopEngines::SyncCurrentPointer
static void SyncCurrentPointer(const _elementType *&currentPointer, const nstride_type &otnd, difference_type numberOfWrappedDimensions)
Definition: vctDynamicNArrayLoopEngines.h:142
vctDynamicNArrayLoopEngines::NioNiNi::Run
static void Run(_inputOutputNArrayType &inputOutputNArray, const _input1NArrayType &input1NArray, const _input2NArrayType &input2NArray)
Definition: vctDynamicNArrayLoopEngines.h:922
vctDynamicNArrayLoopEngines::stride_type
vct::stride_type stride_type
Definition: vctDynamicNArrayLoopEngines.h:48
vctDynamicNArrayLoopEngines::VCT_NARRAY_TRAITS_TYPEDEFS
VCT_NARRAY_TRAITS_TYPEDEFS(_dimension)
cmnPortability.h
Portability across compilers and operating systems tools.
vctDynamicCompactLoopEngines::CoSiCi::Run
static void Run(_outputOwnerType &outputOwner, const _inputScalarType inputScalar, const _inputOwnerType &inputOwner)
Definition: vctDynamicCompactLoopEngines.h:246
vctDynamicCompactLoopEngines::CioSi::Run
static void Run(_inputOutputOwnerType &inputOutputOwner, const _inputScalarType inputScalar)
Definition: vctDynamicCompactLoopEngines.h:289
vctDynamicNArrayLoopEngines::index_type
vct::index_type index_type
Definition: vctDynamicNArrayLoopEngines.h:50
vctDynamicNArrayLoopEngines
Container class for the dynamic nArray engines.
Definition: vctDynamicNArrayLoopEngines.h:43
vctDynamicNArrayLoopEngines::SoNiNi::Run
static OutputType Run(const _input1NArrayType &input1NArray, const _input2NArrayType &input2NArray)
Definition: vctDynamicNArrayLoopEngines.h:281
vctDynamicCompactLoopEngines::CioCi::Run
static void Run(_inputOutputOwnerType &inputOutputOwner, const _inputOwnerType &inputOwner)
Definition: vctDynamicCompactLoopEngines.h:121
vctDynamicCompactLoopEngines::SoCiCi::Run
static OutputType Run(const _input1OwnerType &input1Owner, const _input2OwnerType &input2Owner)
Definition: vctDynamicCompactLoopEngines.h:450
vctDynamicNArrayLoopEngines::NoSiNi
Definition: vctDynamicNArrayLoopEngines.h:554
vctDynamicNArrayLoopEngines::Nio
Definition: vctDynamicNArrayLoopEngines.h:803
vctDynamicNArrayLoopEngines::NoNiNi::Run
static void Run(_outputNArrayType &outputNArray, const _input1NArrayType &input1NArray, const _input2NArrayType &input2NArray)
Definition: vctDynamicNArrayLoopEngines.h:403
vct::size_type
size_t size_type
Definition: vctContainerTraits.h:35
vctDynamicCompactLoopEngines.h
Declaration of vctDynamicCompactLoopEngines.
vctDynamicNArrayLoopEngines::NioSi::Run
static void Run(_inputOutputNArrayType &inputOutputNArray, const _inputScalarType inputScalar)
Definition: vctDynamicNArrayLoopEngines.h:627
vctDynamicNArrayLoopEngines::CalculateSTND
static void CalculateSTND(nstride_type &stnd, const nsize_type &sizes, const nstride_type &strides)
Definition: vctDynamicNArrayLoopEngines.h:63
vctDynamicNArrayLoopEngines::NioNi::Run
static void Run(_inputOutputNArrayType &inputOutputNArray, const _inputNArrayType &inputNArray)
Definition: vctDynamicNArrayLoopEngines.h:671
vctDynamicNArrayLoopEngines::Nio::Run
static void Run(_inputOutputNArrayType &inputOutputNArray)
Definition: vctDynamicNArrayLoopEngines.h:807
vctDynamicNArrayLoopEngines::NoSiNi::Run
static void Run(_outputNArrayType &outputNArray, const _inputScalarType inputScalar, const _inputNArrayType &inputNArray)
Definition: vctDynamicNArrayLoopEngines.h:558
vctFixedSizeVector
Implementation of a fixed-size vector using template metaprogramming.
Definition: vctFixedSizeVector.h:52
vctDynamicNArrayLoopEngines::NoNi::Run
static void Run(_outputNArrayType &outputNArray, const _inputNArrayType &inputNArray)
Definition: vctDynamicNArrayLoopEngines.h:739
vctDynamicNArrayLoopEngines::ThrowSizeMismatchException
static void ThrowSizeMismatchException(void)
Definition: vctDynamicNArrayLoopEngines.h:56
vctFixedStrideVectorConstIterator
Definition: vctFixedStrideVectorIterator.h:62
vctDynamicNArrayLoopEngines::SoNi::OutputType
_incrementalOperationType::OutputType OutputType
Definition: vctDynamicNArrayLoopEngines.h:229
vct::difference_type
ptrdiff_t difference_type
Definition: vctContainerTraits.h:38
vctDynamicNArrayLoopEngines::NioNiNi
Definition: vctDynamicNArrayLoopEngines.h:918
vctDynamicCompactLoopEngines::CioCiCi::Run
static void Run(_ioOwnerType &ioOwner, const _input1OwnerType &input1Owner, const _input2OwnerType &input2Owner)
Definition: vctDynamicCompactLoopEngines.h:549
vctDynamicNArrayLoopEngines::CalculateOTND
static void CalculateOTND(nstride_type &otnd, const nstride_type &strides, const nstride_type &stnd)
Definition: vctDynamicNArrayLoopEngines.h:90
vctFixedSizeVector.h
Declaration of vctFixedSizeVector.
vctContainerTraits.h
Basic traits for the cisstVector containers.
vctDynamicNArrayLoopEngines::difference_type
vct::difference_type difference_type
Definition: vctDynamicNArrayLoopEngines.h:49
vctDynamicNArrayLoopEngines::IncrementPointers
static dimension_type IncrementPointers(vctFixedSizeVector< const _elementType *, _dimension > &targets, _pointerType &currentPointer, const nstride_type &strides, const nstride_type &stnd)
Definition: vctDynamicNArrayLoopEngines.h:154
cmnThrow
#define cmnThrow(a)
Definition: MinimalCmn.h:4
vctDynamicNArrayLoopEngines::NoNi
Definition: vctDynamicNArrayLoopEngines.h:735
vctDynamicNArrayLoopEngines::SoNi::Run
static OutputType Run(const _inputNArrayType &inputNArray)
Definition: vctDynamicNArrayLoopEngines.h:232
vctDynamicCompactLoopEngines::CoCiCi::Run
static void Run(_outputOwnerType &outputOwner, const _input1OwnerType &input1Owner, const _input2OwnerType &input2Owner)
Definition: vctDynamicCompactLoopEngines.h:75
vctDynamicNArrayLoopEngines::MinAndMax::Run
static void Run(const _inputNArrayType &inputNArray, typename _inputNArrayType::value_type &minValue, typename _inputNArrayType::value_type &maxValue)
Definition: vctDynamicNArrayLoopEngines.h:1007
vctDynamicNArrayLoopEngines::size_type
vct::size_type size_type
Definition: vctDynamicNArrayLoopEngines.h:47
vct::stride_type
ptrdiff_t stride_type
Definition: vctContainerTraits.h:37
vctDynamicNArrayLoopEngines::NoNiSi
Definition: vctDynamicNArrayLoopEngines.h:485
vctDynamicNArrayLoopEngines::NioSi
Definition: vctDynamicNArrayLoopEngines.h:623
vctDynamicNArrayLoopEngines::SoNiSi::Run
static OutputType Run(const _inputNArrayType &inputNArray, const _inputScalarType inputScalar)
Definition: vctDynamicNArrayLoopEngines.h:355
vctDynamicCompactLoopEngines::CoCiSi::Run
static void Run(_outputOwnerType &outputOwner, const _inputOwnerType &inputOwner, const _inputScalarType inputScalar)
Definition: vctDynamicCompactLoopEngines.h:204
vctDynamicNArrayLoopEngines::NioSiNi::Run
static void Run(_inputOutputNArrayType &inputOutputNArray, const _inputScalarType inputScalar, const _inputNArrayType &inputNArray)
Definition: vctDynamicNArrayLoopEngines.h:851
vctFixedSizeVectorBase::Pointer
pointer Pointer(size_type index=0)
Definition: vctFixedSizeVectorBase.h:226
vctDynamicNArrayLoopEngines::InitializeTargets
static void InitializeTargets(vctFixedSizeVector< const _elementType *, _dimension > &targets, const nsize_type &sizes, const nstride_type &strides, const _elementType *basePtr)
Definition: vctDynamicNArrayLoopEngines.h:115
vctDynamicNArrayLoopEngines::NoNiSi::Run
static void Run(_outputNArrayType &outputNArray, const _inputNArrayType &inputNArray, const _inputScalarType inputScalar)
Definition: vctDynamicNArrayLoopEngines.h:489
cmnThrow.h
Declaration of the template function cmnThrow.
vctDynamicNArrayLoopEngines::SoNiNi
Definition: vctDynamicNArrayLoopEngines.h:275
vctDynamicCompactLoopEngines::SoCiSi::Run
static OutputType Run(const _inputOwnerType &inputOwner, const _inputScalarType &inputScalar)
Definition: vctDynamicCompactLoopEngines.h:603
vctDynamicNArrayLoopEngines::NoNiNi
Definition: vctDynamicNArrayLoopEngines.h:399
vctDynamicNArrayLoopEngines::SoNi
Definition: vctDynamicNArrayLoopEngines.h:226
vctDynamicNArrayLoopEngines::NioNi
Definition: vctDynamicNArrayLoopEngines.h:667
vctDynamicCompactLoopEngines::MinAndMax::Run
static void Run(const _inputOwnerType &inputOwner, typename _inputOwnerType::value_type &minValue, typename _inputOwnerType::value_type &maxValue)
Definition: vctDynamicCompactLoopEngines.h:630
vctDynamicCompactLoopEngines::CioSiCi::Run
static void Run(_ioOwnerType &ioOwner, const _inputScalarType inputScalar, const _inputOwnerType &inputOwner)
Definition: vctDynamicCompactLoopEngines.h:500
vctDynamicNArrayLoopEngines::SoNiSi
Definition: vctDynamicNArrayLoopEngines.h:349
vctDynamicNArrayLoopEngines::NioSiNi
Definition: vctDynamicNArrayLoopEngines.h:847
Generated by   doxygen 1.8.6