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