cisst-saw
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
vctDynamicMatrixLoopEngines.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): Ofri Sadowsky, Anton Deguet
7  Created on: 2003-12-16
8 
9  (C) Copyright 2003-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 _vctDynamicMatrixLoopEngines_h
23 #define _vctDynamicMatrixLoopEngines_h
24 
30 #include <cisstCommon/cmnPortability.h>
31 #include <cisstCommon/cmnThrow.h>
32 #include <cisstVector/vctDynamicCompactLoopEngines.h>
33 
39 class vctDynamicMatrixLoopEngines {
40 
41 public:
42 
45  inline static void ThrowSizeMismatchException(void) throw(std::runtime_error) {
46  cmnThrow(std::runtime_error("vctDynamicMatrixLoopEngines: Sizes of matrices don't match"));
47  }
48 
52  inline static void ThrowSharedPointersException(void) throw(std::runtime_error) {
53  cmnThrow(std::runtime_error("vctDynamicMatrixLoopEngines: Output base pointer is same as one of input base pointers."));
54  }
55 
56 
88  template<class _elementOperationType>
89  class MoMiMi {
90  public:
91  template<class _outputMatrixType, class _input1MatrixType, class _input2MatrixType>
92  static void Run(_outputMatrixType & outputMatrix,
93  const _input1MatrixType & input1Matrix,
94  const _input2MatrixType & input2Matrix)
95  {
96  typedef _outputMatrixType OutputMatrixType;
97  typedef typename OutputMatrixType::OwnerType OutputOwnerType;
98  typedef typename OutputOwnerType::size_type size_type;
99  typedef typename OutputOwnerType::stride_type stride_type;
100  typedef typename OutputOwnerType::pointer OutputPointerType;
101 
102  typedef _input1MatrixType Input1MatrixType;
103  typedef typename Input1MatrixType::OwnerType Input1OwnerType;
104  typedef typename Input1OwnerType::const_pointer Input1PointerType;
105 
106  typedef _input2MatrixType Input2MatrixType;
107  typedef typename Input2MatrixType::OwnerType Input2OwnerType;
108  typedef typename Input2OwnerType::const_pointer Input2PointerType;
109 
110  // retrieve owners
111  OutputOwnerType & outputOwner = outputMatrix.Owner();
112  const Input1OwnerType & input1Owner = input1Matrix.Owner();
113  const Input2OwnerType & input2Owner = input2Matrix.Owner();
114 
115  const size_type rows = outputOwner.rows();
116  const size_type cols = outputOwner.cols();
117 
118  // check sizes
119  if ((rows != input1Owner.rows())
120  || (cols != input1Owner.cols())
121  || (rows != input2Owner.rows())
122  || (cols != input2Owner.cols()))
123  {
124  ThrowSizeMismatchException();
125  }
126 
127  // if compact and same strides
128  if (outputOwner.IsCompact() && input1Owner.IsCompact() && input2Owner.IsCompact()
129  && (outputOwner.strides() == input1Owner.strides())
130  && (outputOwner.strides() == input2Owner.strides())) {
131  vctDynamicCompactLoopEngines::CoCiCi<_elementOperationType>::Run(outputOwner, input1Owner, input2Owner);
132  } else {
133  const stride_type outputColStride = outputOwner.col_stride();
134  const stride_type outputRowStride = outputOwner.row_stride();
135  const stride_type outputStrideToNextRow = outputRowStride - cols * outputColStride;
136 
137  const stride_type input1ColStride = input1Owner.col_stride();
138  const stride_type input1RowStride = input1Owner.row_stride();
139  const stride_type input1StrideToNextRow = input1RowStride - cols * input1ColStride;
140 
141  const stride_type input2ColStride = input2Owner.col_stride();
142  const stride_type input2RowStride = input2Owner.row_stride();
143  const stride_type input2StrideToNextRow = input2RowStride - cols * input2ColStride;
144 
145  OutputPointerType outputPointer = outputOwner.Pointer();
146  const OutputPointerType outputRowEnd = outputPointer + rows * outputRowStride;
147  OutputPointerType outputColEnd = outputPointer + cols * outputColStride;
148 
149  Input1PointerType input1Pointer = input1Owner.Pointer();
150  Input2PointerType input2Pointer = input2Owner.Pointer();
151 
152  for (;
153  outputPointer != outputRowEnd;
154  outputPointer += outputStrideToNextRow, input1Pointer += input1StrideToNextRow, input2Pointer += input2StrideToNextRow,
155  outputColEnd += outputRowStride) {
156  for (;
157  outputPointer != outputColEnd;
158  outputPointer += outputColStride, input1Pointer += input1ColStride, input2Pointer += input2ColStride) {
159  *outputPointer = _elementOperationType::Operate(*input1Pointer, *input2Pointer);
160  }
161  }
162  }
163  } // Run method
164  }; // MoMiMi class
165 
166 
167  template<class _elementOperationType>
168  class MoMi {
169  public:
170  template<class _outputMatrixType, class _inputMatrixType>
171  static inline void Run(_outputMatrixType & outputMatrix,
172  const _inputMatrixType & inputMatrix)
173  {
174  typedef _outputMatrixType OutputMatrixType;
175  typedef typename OutputMatrixType::OwnerType OutputOwnerType;
176  typedef typename OutputOwnerType::size_type size_type;
177  typedef typename OutputOwnerType::stride_type stride_type;
178  typedef typename OutputOwnerType::pointer OutputPointerType;
179 
180  typedef _inputMatrixType InputMatrixType;
181  typedef typename InputMatrixType::OwnerType InputOwnerType;
182  typedef typename InputOwnerType::const_pointer InputPointerType;
183 
184  // retrieve owners
185  const InputOwnerType & inputOwner = inputMatrix.Owner();
186  OutputOwnerType & outputOwner = outputMatrix.Owner();
187 
188  const size_type rows = outputMatrix.rows();
189  const size_type cols = outputMatrix.cols();
190 
191  // check sizes
192  if ((rows != inputOwner.rows()) || (cols != inputOwner.cols())) {
193  ThrowSizeMismatchException();
194  }
195 
196  // if compact and same strides
197  if (outputOwner.IsCompact() && inputOwner.IsCompact()
198  && (outputOwner.strides() == inputOwner.strides())) {
199  vctDynamicCompactLoopEngines::CoCi<_elementOperationType>::Run(outputOwner, inputOwner);
200  } else {
201  // otherwise
202  const stride_type outputColStride = outputOwner.col_stride();
203  const stride_type outputRowStride = outputOwner.row_stride();
204  const stride_type outputStrideToNextRow = outputRowStride - cols * outputColStride;
205 
206  const stride_type inputColStride = inputOwner.col_stride();
207  const stride_type inputRowStride = inputOwner.row_stride();
208  const stride_type inputStrideToNextRow = inputRowStride - cols * inputColStride;
209 
210  OutputPointerType outputPointer = outputOwner.Pointer();
211  const OutputPointerType outputRowEnd = outputPointer + rows * outputRowStride;
212  OutputPointerType outputColEnd = outputPointer + cols * outputColStride;
213 
214  InputPointerType inputPointer = inputOwner.Pointer();
215 
216  for (;
217  outputPointer != outputRowEnd;
218  outputPointer += outputStrideToNextRow, inputPointer += inputStrideToNextRow,
219  outputColEnd += outputRowStride) {
220  for (;
221  outputPointer != outputColEnd;
222  outputPointer += outputColStride, inputPointer += inputColStride) {
223  *outputPointer = _elementOperationType::Operate(*inputPointer);
224  }
225  }
226  } // Compact engine if
227  } // Run method
228  }; // MoMi class
229 
230 
231  template<class _elementOperationType>
232  class Mio {
233  public:
234  template<class _inputOutputMatrixType>
235  static inline void Run(_inputOutputMatrixType & inputOutputMatrix)
236  {
237  typedef _inputOutputMatrixType InputOutputMatrixType;
238  typedef typename InputOutputMatrixType::OwnerType InputOutputOwnerType;
239  typedef typename InputOutputOwnerType::size_type size_type;
240  typedef typename InputOutputOwnerType::stride_type stride_type;
241  typedef typename InputOutputOwnerType::pointer PointerType;
242 
243  // retrieve owner
244  InputOutputOwnerType & inputOutputOwner = inputOutputMatrix.Owner();
245 
246  // if compact
247  if (inputOutputOwner.IsCompact()) {
248  vctDynamicCompactLoopEngines::Cio<_elementOperationType>::Run(inputOutputOwner);
249  } else {
250  const size_type rows = inputOutputOwner.rows();
251  const size_type cols = inputOutputOwner.cols();
252 
253  const stride_type colStride = inputOutputOwner.col_stride();
254  const stride_type rowStride = inputOutputOwner.row_stride();
255  const stride_type strideToNextRow = rowStride - cols * colStride;
256 
257  PointerType inputOutputPointer = inputOutputOwner.Pointer();
258  const PointerType rowEnd = inputOutputPointer + rows * rowStride;
259  PointerType colEnd = inputOutputPointer + cols * colStride;
260 
261  for (;
262  inputOutputPointer != rowEnd;
263  inputOutputPointer += strideToNextRow, colEnd += rowStride) {
264  for (;
265  inputOutputPointer != colEnd;
266  inputOutputPointer += colStride) {
267  _elementOperationType::Operate(*inputOutputPointer);
268  }
269  }
270  }
271  } // Run method
272  }; // Mio class
273 
274 
275  template<class _elementOperationType>
276  class MioMi {
277  public:
278  template<class _inputOutputMatrixType, class _inputMatrixType>
279  static inline void Run(_inputOutputMatrixType & inputOutputMatrix,
280  const _inputMatrixType & inputMatrix)
281  {
282  typedef _inputOutputMatrixType InputOutputMatrixType;
283  typedef typename InputOutputMatrixType::OwnerType InputOutputOwnerType;
284  typedef typename InputOutputOwnerType::size_type size_type;
285  typedef typename InputOutputOwnerType::stride_type stride_type;
286  typedef typename InputOutputOwnerType::pointer InputOutputPointerType;
287 
288  typedef _inputMatrixType InputMatrixType;
289  typedef typename InputMatrixType::OwnerType InputOwnerType;
290  typedef typename InputOwnerType::const_pointer InputPointerType;
291 
292  // retrieve owners
293  InputOutputOwnerType & inputOutputOwner = inputOutputMatrix.Owner();
294  const InputOwnerType & inputOwner = inputMatrix.Owner();
295 
296  const size_type rows = inputOutputOwner.rows();
297  const size_type cols = inputOutputOwner.cols();
298 
299  // check sizes
300  if ((rows != inputOwner.rows()) || (cols != inputOwner.cols()))
301  {
302  ThrowSizeMismatchException();
303  }
304 
305  // if compact and same strides
306  if (inputOutputOwner.IsCompact() && inputOwner.IsCompact()
307  && (inputOutputOwner.strides() == inputOwner.strides())) {
308  vctDynamicCompactLoopEngines::CioCi<_elementOperationType>::Run(inputOutputOwner, inputOwner);
309  } else {
310  const stride_type inputOutputColStride = inputOutputOwner.col_stride();
311  const stride_type inputOutputRowStride = inputOutputOwner.row_stride();
312  const stride_type inputOutputStrideToNextRow = inputOutputRowStride - cols * inputOutputColStride;
313 
314  const stride_type inputColStride = inputOwner.col_stride();
315  const stride_type inputRowStride = inputOwner.row_stride();
316  const stride_type inputStrideToNextRow = inputRowStride - cols * inputColStride;
317 
318  InputOutputPointerType inputOutputPointer = inputOutputOwner.Pointer();
319  const InputOutputPointerType inputOutputRowEnd = inputOutputPointer + rows * inputOutputRowStride;
320  InputOutputPointerType inputOutputColEnd = inputOutputPointer + cols * inputOutputColStride;
321 
322  InputPointerType inputPointer = inputOwner.Pointer();
323 
324  for (;
325  inputOutputPointer != inputOutputRowEnd;
326  inputOutputPointer += inputOutputStrideToNextRow, inputPointer += inputStrideToNextRow,
327  inputOutputColEnd += inputOutputRowStride) {
328  for (;
329  inputOutputPointer != inputOutputColEnd;
330  inputOutputPointer += inputOutputColStride, inputPointer += inputColStride) {
331  _elementOperationType::Operate(*inputOutputPointer, *inputPointer);
332  }
333  }
334  }
335  } // Run method
336  }; // MioMi class
337 
338 
339  template<class _elementOperationType>
340  class MoMiSi {
341  public:
342  template<class _outputMatrixType, class _inputMatrixType, class _inputScalarType>
343  static void Run(_outputMatrixType & outputMatrix,
344  const _inputMatrixType & inputMatrix,
345  const _inputScalarType inputScalar)
346  {
347  typedef _outputMatrixType OutputMatrixType;
348  typedef typename OutputMatrixType::OwnerType OutputOwnerType;
349  typedef typename OutputOwnerType::size_type size_type;
350  typedef typename OutputOwnerType::stride_type stride_type;
351  typedef typename OutputOwnerType::pointer OutputPointerType;
352 
353  typedef _inputMatrixType InputMatrixType;
354  typedef typename InputMatrixType::OwnerType InputOwnerType;
355  typedef typename InputOwnerType::const_pointer InputPointerType;
356 
357  // retrieve owners
358  OutputOwnerType & outputOwner = outputMatrix.Owner();
359  const InputOwnerType & inputOwner = inputMatrix.Owner();
360 
361  const size_type rows = outputOwner.rows();
362  const size_type cols = outputOwner.cols();
363 
364  // check sizes
365  if ((rows != inputOwner.rows()) || (cols != inputOwner.cols()))
366  {
367  ThrowSizeMismatchException();
368  }
369 
370  // if compact and same strides
371  if (outputOwner.IsCompact() && inputOwner.IsCompact()
372  && (outputOwner.strides() == inputOwner.strides())) {
373  vctDynamicCompactLoopEngines::CoCiSi<_elementOperationType>::Run(outputOwner, inputOwner, inputScalar);
374  } else {
375  // otherwise
376  const stride_type outputColStride = outputOwner.col_stride();
377  const stride_type outputRowStride = outputOwner.row_stride();
378  const stride_type outputStrideToNextRow = outputRowStride - cols * outputColStride;
379 
380  const stride_type inputColStride = inputOwner.col_stride();
381  const stride_type inputRowStride = inputOwner.row_stride();
382  const stride_type inputStrideToNextRow = inputRowStride - cols * inputColStride;
383 
384  OutputPointerType outputPointer = outputOwner.Pointer();
385  const OutputPointerType outputRowEnd = outputPointer + rows * outputRowStride;
386  OutputPointerType outputColEnd = outputPointer + cols * outputColStride;
387 
388  InputPointerType inputPointer = inputOwner.Pointer();
389 
390  for (;
391  outputPointer != outputRowEnd;
392  outputPointer += outputStrideToNextRow, inputPointer += inputStrideToNextRow,
393  outputColEnd += outputRowStride) {
394  for (;
395  outputPointer != outputColEnd;
396  outputPointer += outputColStride, inputPointer += inputColStride) {
397  *outputPointer = _elementOperationType::Operate(*inputPointer, inputScalar);
398  }
399  }
400  }
401  } // Run method
402  }; // MoMiSi
403 
404 
405  template<class _elementOperationType>
406  class MoSiMi {
407  public:
408  template<class _outputMatrixType, class _inputScalarType, class _inputMatrixType>
409  static void Run(_outputMatrixType & outputMatrix,
410  const _inputScalarType inputScalar,
411  const _inputMatrixType & inputMatrix)
412  {
413  typedef _outputMatrixType OutputMatrixType;
414  typedef typename OutputMatrixType::OwnerType OutputOwnerType;
415  typedef typename OutputOwnerType::size_type size_type;
416  typedef typename OutputOwnerType::stride_type stride_type;
417  typedef typename OutputOwnerType::pointer OutputPointerType;
418 
419  typedef _inputMatrixType InputMatrixType;
420  typedef typename InputMatrixType::OwnerType InputOwnerType;
421  typedef typename InputOwnerType::const_pointer InputPointerType;
422 
423  // retrieve owners
424  OutputOwnerType & outputOwner = outputMatrix.Owner();
425  const InputOwnerType & inputOwner = inputMatrix.Owner();
426 
427  const size_type rows = outputOwner.rows();
428  const size_type cols = outputOwner.cols();
429 
430  // check sizes
431  if ((rows != inputOwner.rows()) || (cols != inputOwner.cols()))
432  {
433  ThrowSizeMismatchException();
434  }
435 
436  // if compact and same strides
437  if (outputOwner.IsCompact() && inputOwner.IsCompact()
438  && (outputOwner.strides() == inputOwner.strides())) {
439  vctDynamicCompactLoopEngines::CoSiCi<_elementOperationType>::Run(outputOwner, inputScalar, inputOwner);
440  } else {
441  // otherwise
442  const stride_type outputColStride = outputOwner.col_stride();
443  const stride_type outputRowStride = outputOwner.row_stride();
444  const stride_type outputStrideToNextRow = outputRowStride - cols * outputColStride;
445 
446  const stride_type inputColStride = inputOwner.col_stride();
447  const stride_type inputRowStride = inputOwner.row_stride();
448  const stride_type inputStrideToNextRow = inputRowStride - cols * inputColStride;
449 
450  OutputPointerType outputPointer = outputOwner.Pointer();
451  const OutputPointerType outputRowEnd = outputPointer + rows * outputRowStride;
452  OutputPointerType outputColEnd = outputPointer + cols * outputColStride;
453 
454  InputPointerType inputPointer = inputOwner.Pointer();
455 
456  for (;
457  outputPointer != outputRowEnd;
458  outputPointer += outputStrideToNextRow, inputPointer += inputStrideToNextRow,
459  outputColEnd += outputRowStride) {
460  for (;
461  outputPointer != outputColEnd;
462  outputPointer += outputColStride, inputPointer += inputColStride) {
463  *outputPointer = _elementOperationType::Operate(inputScalar, *inputPointer);
464  }
465  }
466  }
467  } // Run method
468  }; // MoSiMi class
469 
470 
471  template<class _elementOperationType>
472  class MioSi {
473  public:
474  template<class _inputOutputMatrixType, class _inputScalarType>
475  static void Run(_inputOutputMatrixType & inputOutputMatrix,
476  const _inputScalarType inputScalar)
477  {
478  typedef _inputOutputMatrixType InputOutputMatrixType;
479  typedef typename InputOutputMatrixType::OwnerType InputOutputOwnerType;
480  typedef typename InputOutputOwnerType::size_type size_type;
481  typedef typename InputOutputOwnerType::stride_type stride_type;
482  typedef typename InputOutputOwnerType::pointer InputOutputPointerType;
483 
484  // retrieve owner
485  InputOutputOwnerType & inputOutputOwner = inputOutputMatrix.Owner();
486 
487  if (inputOutputOwner.IsCompact()) {
488  vctDynamicCompactLoopEngines::CioSi<_elementOperationType>::Run(inputOutputOwner, inputScalar);
489  } else {
490  const size_type rows = inputOutputOwner.rows();
491  const size_type cols = inputOutputOwner.cols();
492 
493  const stride_type colStride = inputOutputOwner.col_stride();
494  const stride_type rowStride = inputOutputOwner.row_stride();
495  const stride_type strideToNextRow = rowStride - cols * colStride;
496 
497  InputOutputPointerType inputOutputPointer = inputOutputOwner.Pointer();
498  const InputOutputPointerType rowEnd = inputOutputPointer + rows * rowStride;
499  InputOutputPointerType colEnd = inputOutputPointer + cols * colStride;
500 
501  for (;
502  inputOutputPointer != rowEnd;
503  inputOutputPointer += strideToNextRow, colEnd += rowStride) {
504  for (;
505  inputOutputPointer != colEnd;
506  inputOutputPointer += colStride) {
507  _elementOperationType::Operate(*inputOutputPointer, inputScalar);
508  }
509  }
510  }
511  } // Run method
512  }; // MioSi class
513 
514 
515  template<class _incrementalOperationType, class _elementOperationType>
516  class SoMi {
517  public:
518  typedef typename _incrementalOperationType::OutputType OutputType;
519 
520  template<class _inputMatrixType>
521  static OutputType Run(const _inputMatrixType & inputMatrix)
522  {
523  typedef _inputMatrixType InputMatrixType;
524  typedef typename InputMatrixType::OwnerType InputOwnerType;
525  typedef typename InputOwnerType::size_type size_type;
526  typedef typename InputOwnerType::stride_type stride_type;
527  typedef typename InputOwnerType::const_pointer InputPointerType;
528 
529  // retrieve owner
530  const InputOwnerType & inputOwner = inputMatrix.Owner();
531 
532  if (inputOwner.IsCompact()) {
533  return vctDynamicCompactLoopEngines::SoCi<_incrementalOperationType, _elementOperationType>
534  ::Run(inputOwner);
535  } else {
536  const size_type rows = inputOwner.rows();
537  const size_type cols = inputOwner.cols();
538 
539  OutputType incrementalResult = _incrementalOperationType::NeutralElement();
540 
541  const stride_type inputColStride = inputOwner.col_stride();
542  const stride_type inputRowStride = inputOwner.row_stride();
543  const stride_type inputStrideToNextRow = inputRowStride - cols * inputColStride;
544  InputPointerType inputPointer = inputOwner.Pointer();
545  const InputPointerType inputRowEnd = inputPointer + rows * inputRowStride;
546  InputPointerType inputColEnd = inputPointer + cols * inputColStride;
547 
548  for (;
549  inputPointer != inputRowEnd;
550  inputPointer += inputStrideToNextRow, inputColEnd += inputRowStride) {
551  for (;
552  inputPointer != inputColEnd;
553  inputPointer += inputColStride) {
554  incrementalResult = _incrementalOperationType::Operate(
555  incrementalResult, _elementOperationType::Operate(*inputPointer) );
556  }
557  }
558  return incrementalResult;
559  }
560  } // Run method
561  }; // SoMi class
562 
563 
564  template<class _incrementalOperationType, class _elementOperationType>
565  class SoMiMi {
566  public:
567  typedef typename _incrementalOperationType::OutputType OutputType;
568 
569  template<class _input1MatrixType, class _input2MatrixType>
570  static OutputType Run(const _input1MatrixType & input1Matrix,
571  const _input2MatrixType & input2Matrix) {
572  typedef _input1MatrixType Input1MatrixType;
573  typedef typename Input1MatrixType::OwnerType Input1OwnerType;
574  typedef typename Input1OwnerType::size_type size_type;
575  typedef typename Input1OwnerType::stride_type stride_type;
576  typedef typename Input1OwnerType::const_pointer Input1PointerType;
577 
578  typedef _input2MatrixType Input2MatrixType;
579  typedef typename Input2MatrixType::OwnerType Input2OwnerType;
580  typedef typename Input2OwnerType::const_pointer Input2PointerType;
581 
582  // retrieve owners
583  const Input1OwnerType & input1Owner = input1Matrix.Owner();
584  const Input2OwnerType & input2Owner = input2Matrix.Owner();
585 
586  const size_type rows = input1Owner.rows();
587  const size_type cols = input1Owner.cols();
588 
589  // check sizes
590  if ((rows != input2Owner.rows()) || (cols != input2Owner.cols())) {
591  ThrowSizeMismatchException();
592  }
593 
594  // if compact and same strides
595  if (input1Owner.IsCompact() && input2Owner.IsCompact()
596  && (input1Owner.strides() == input2Owner.strides())) {
597  return vctDynamicCompactLoopEngines::SoCiCi<_incrementalOperationType, _elementOperationType>::Run(input1Owner, input2Owner);
598  } else {
599  // otherwise
600  OutputType incrementalResult = _incrementalOperationType::NeutralElement();
601  const stride_type input1ColStride = input1Owner.col_stride();
602  const stride_type input1RowStride = input1Owner.row_stride();
603  const stride_type input1StrideToNextRow = input1RowStride - cols * input1ColStride;
604 
605  const stride_type input2ColStride = input2Owner.col_stride();
606  const stride_type input2RowStride = input2Owner.row_stride();
607  const stride_type input2StrideToNextRow = input2RowStride - cols * input2ColStride;
608 
609  Input1PointerType input1Pointer = input1Owner.Pointer();
610  const Input1PointerType input1RowEnd = input1Pointer + rows * input1RowStride;
611  Input1PointerType input1ColEnd = input1Pointer + cols * input1ColStride;
612 
613  Input2PointerType input2Pointer = input2Owner.Pointer();
614 
615  for (;
616  input1Pointer != input1RowEnd;
617  input1Pointer += input1StrideToNextRow, input2Pointer += input2StrideToNextRow,
618  input1ColEnd += input1RowStride) {
619  for (;
620  input1Pointer != input1ColEnd;
621  input1Pointer += input1ColStride, input2Pointer += input2ColStride) {
622  incrementalResult = _incrementalOperationType::Operate(incrementalResult,
623  _elementOperationType::Operate(*input1Pointer, *input2Pointer) );
624  }
625  }
626  return incrementalResult;
627  }
628  }
629  };
630 
631 
657  template<class _ioElementOperationType, class _scalarMatrixElementOperationType>
658  class MioSiMi
659  {
660  public:
661 
662  template<class _ioMatrixType, class _inputScalarType, class _inputMatrixType>
663  static inline void Run(_ioMatrixType & ioMatrix,
664  const _inputScalarType & inputScalar,
665  const _inputMatrixType & inputMatrix)
666  {
667  typedef _ioMatrixType IoMatrixType;
668  typedef typename IoMatrixType::OwnerType IoOwnerType;
669  typedef typename IoOwnerType::size_type size_type;
670  typedef typename IoOwnerType::stride_type stride_type;
671  typedef typename IoOwnerType::pointer IoPointerType;
672 
673  typedef _inputMatrixType InputMatrixType;
674  typedef typename InputMatrixType::OwnerType InputOwnerType;
675  typedef typename InputOwnerType::const_pointer InputPointerType;
676 
677  // retrieve owners
678  IoOwnerType & ioOwner = ioMatrix.Owner();
679  const InputOwnerType & inputOwner = inputMatrix.Owner();
680 
681  const size_type rows = ioOwner.rows();
682  const size_type cols = ioOwner.cols();
683 
684  // check sizes
685  if ((rows != inputOwner.rows()) || (cols != inputOwner.cols())) {
686  ThrowSizeMismatchException();
687  }
688 
689  // if compact and same strides
690  if (ioOwner.IsCompact() && inputOwner.IsCompact()
691  && (ioOwner.strides() == inputOwner.strides())) {
692  vctDynamicCompactLoopEngines::CioSiCi<_ioElementOperationType, _scalarMatrixElementOperationType>::Run(ioOwner, inputScalar, inputOwner);
693  } else {
694  // otherwise
695  const stride_type ioColStride = ioOwner.col_stride();
696  const stride_type ioRowStride = ioOwner.row_stride();
697  const stride_type ioStrideToNextRow = ioRowStride - cols * ioColStride;
698 
699  const stride_type inputColStride = inputOwner.col_stride();
700  const stride_type inputRowStride = inputOwner.row_stride();
701  const stride_type inputStrideToNextRow = inputRowStride - cols * inputColStride;
702 
703  IoPointerType ioPointer = ioOwner.Pointer();
704  InputPointerType inputPointer = inputOwner.Pointer();
705 
706  size_type rowIndex, colIndex;
707  for (rowIndex = 0;
708  rowIndex < rows;
709  ++rowIndex, ioPointer += ioStrideToNextRow, inputPointer += inputStrideToNextRow) {
710  for (colIndex = 0;
711  colIndex < cols;
712  ++colIndex, ioPointer += ioColStride, inputPointer += inputColStride) {
713  _ioElementOperationType::Operate(*ioPointer,
714  _scalarMatrixElementOperationType::Operate(inputScalar, *inputPointer));
715  }
716  }
717  }
718  }
719  };
720 
721 
748  template<class _ioElementOperationType, class _matrixElementOperationType>
749  class MioMiMi
750  {
751  public:
752 
753  template<class _ioMatrixType, class _input1MatrixType, class _input2MatrixType>
754  static inline void Run(_ioMatrixType & ioMatrix,
755  const _input1MatrixType & input1Matrix,
756  const _input2MatrixType & input2Matrix)
757  {
758  typedef _ioMatrixType IoMatrixType;
759  typedef typename IoMatrixType::OwnerType IoOwnerType;
760  typedef typename IoOwnerType::size_type size_type;
761  typedef typename IoOwnerType::stride_type stride_type;
762  typedef typename IoOwnerType::pointer IoPointerType;
763 
764  typedef _input1MatrixType Input1MatrixType;
765  typedef typename Input1MatrixType::OwnerType Input1OwnerType;
766  typedef typename Input1OwnerType::const_pointer Input1PointerType;
767 
768  typedef _input2MatrixType Input2MatrixType;
769  typedef typename Input2MatrixType::OwnerType Input2OwnerType;
770  typedef typename Input2OwnerType::const_pointer Input2PointerType;
771 
772  // retrieve owners
773  IoOwnerType & ioOwner = ioMatrix.Owner();
774  const Input1OwnerType & input1Owner = input1Matrix.Owner();
775  const Input2OwnerType & input2Owner = input2Matrix.Owner();
776 
777  const size_type rows = ioOwner.rows();
778  const size_type cols = ioOwner.cols();
779 
780  // check sizes
781  if ((rows != input1Owner.rows()) || (cols != input1Owner.cols())
782  || (rows != input2Owner.rows()) || (cols != input2Owner.cols())
783  ) {
784  ThrowSizeMismatchException();
785  }
786 
787  // if compact and same strides
788  if (ioOwner.IsCompact() && input1Owner.IsCompact() && input2Owner.IsCompact()
789  && (ioOwner.strides() == input1Owner.strides())
790  && (ioOwner.strides() == input2Owner.strides())) {
791  vctDynamicCompactLoopEngines::CioCiCi<_ioElementOperationType, _matrixElementOperationType>::Run(ioOwner, input1Owner, input2Owner);
792  } else {
793  // otherwise
794  const stride_type ioColStride = ioOwner.col_stride();
795  const stride_type ioRowStride = ioOwner.row_stride();
796  const stride_type ioStrideToNextRow = ioRowStride - cols * ioColStride;
797 
798  const stride_type input1ColStride = input1Owner.col_stride();
799  const stride_type input1RowStride = input1Owner.row_stride();
800  const stride_type input1StrideToNextRow = input1RowStride - cols * input1ColStride;
801 
802  const stride_type input2ColStride = input2Owner.col_stride();
803  const stride_type input2RowStride = input2Owner.row_stride();
804  const stride_type input2StrideToNextRow = input2RowStride - cols * input2ColStride;
805 
806  IoPointerType ioPointer = ioOwner.Pointer();
807  Input1PointerType input1Pointer = input1Owner.Pointer();
808  Input2PointerType input2Pointer = input2Owner.Pointer();
809 
810  size_type rowIndex, colIndex;
811  for (rowIndex = 0;
812  rowIndex < rows;
813  ++rowIndex, ioPointer += ioStrideToNextRow,
814  input1Pointer += input1StrideToNextRow,
815  input2Pointer += input2StrideToNextRow) {
816  for (colIndex = 0;
817  colIndex < cols;
818  ++colIndex, ioPointer += ioColStride,
819  input1Pointer += input1ColStride,
820  input2Pointer += input2ColStride) {
821  _ioElementOperationType::Operate(*ioPointer,
822  _matrixElementOperationType::Operate(*input1Pointer, *input2Pointer));
823  }
824  }
825  }
826  }
827  };
828 
829 
830  template<class _incrementalOperationType, class _elementOperationType>
831  class SoMiSi {
832  public:
833  typedef typename _incrementalOperationType::OutputType OutputType;
834 
835  template<class _inputMatrixType, class _inputScalarType>
836  static OutputType Run(const _inputMatrixType & inputMatrix,
837  const _inputScalarType & inputScalar)
838  {
839  typedef _inputMatrixType InputMatrixType;
840  typedef typename InputMatrixType::OwnerType InputOwnerType;
841  typedef typename InputOwnerType::size_type size_type;
842  typedef typename InputOwnerType::stride_type stride_type;
843  typedef typename InputOwnerType::const_pointer InputPointerType;
844 
845  // retrieve owners
846  const InputOwnerType & inputOwner = inputMatrix.Owner();
847 
848  const size_type rows = inputOwner.rows();
849  const size_type cols = inputOwner.cols();
850 
851  // if compact and same strides
852  if (inputOwner.IsCompact()) {
853  return vctDynamicCompactLoopEngines::SoCiSi<_incrementalOperationType, _elementOperationType>::Run(inputOwner, inputScalar);
854  } else {
855  // otherwise
856  OutputType incrementalResult = _incrementalOperationType::NeutralElement();
857 
858  const stride_type inputColStride = inputOwner.col_stride();
859  const stride_type inputRowStride = inputOwner.row_stride();
860  const stride_type inputStrideToNextRow = inputRowStride - cols * inputColStride;
861  InputPointerType inputPointer = inputOwner.Pointer();
862  const InputPointerType inputRowEnd = inputPointer + rows * inputRowStride;
863  InputPointerType inputColEnd = inputPointer + cols * inputColStride;
864 
865  for (;
866  inputPointer != inputRowEnd;
867  inputPointer += inputStrideToNextRow, inputColEnd += inputRowStride) {
868  for (;
869  inputPointer != inputColEnd;
870  inputPointer += inputColStride) {
871  incrementalResult =
872  _incrementalOperationType::Operate(incrementalResult,
873  _elementOperationType::Operate(*inputPointer, inputScalar));
874  }
875  }
876  return incrementalResult;
877  }
878  }
879  };
880 
881 
882 
883  template<class _operationType>
884  class Product {
885  public:
886  template<class _outputMatrixType, class _input1MatrixType, class _input2MatrixType>
887  static void Run(_outputMatrixType & outputMatrix,
888  const _input1MatrixType & input1Matrix,
889  const _input2MatrixType & input2Matrix)
890  {
891  typedef _outputMatrixType OutputMatrixType;
892  typedef typename OutputMatrixType::size_type size_type;
893  typedef typename OutputMatrixType::stride_type stride_type;
894  typedef typename OutputMatrixType::pointer OutputPointerType;
895 
896  typedef _input1MatrixType Input1MatrixType;
897  typedef typename Input1MatrixType::const_pointer Input1PointerType;
898 
899  typedef _input2MatrixType Input2MatrixType;
900  typedef typename Input2MatrixType::const_pointer Input2PointerType;
901 
902  const size_type rows = outputMatrix.rows();
903  const size_type cols = outputMatrix.cols();
904  const size_type input1Cols = input1Matrix.cols();
905  // check sizes
906  if ((rows != input1Matrix.rows())
907  || (cols != input2Matrix.cols())
908  || (input1Cols != input2Matrix.rows()))
909  {
910  ThrowSizeMismatchException();
911  }
912 
913  // Otherwise
914  const stride_type outputColStride = outputMatrix.col_stride();
915  const stride_type outputRowStride = outputMatrix.row_stride();
916  const stride_type outputStrideToNextRow = outputRowStride - cols * outputColStride;
917 
918  const stride_type input1ColStride = input1Matrix.col_stride();
919  const stride_type input1RowStride = input1Matrix.row_stride();
920 
921  const stride_type input2ColStride = input2Matrix.col_stride();
922  const stride_type input2RowStride = input2Matrix.row_stride();
923 
924  OutputPointerType outputPointer = outputMatrix.Pointer();
925  const OutputPointerType outputRowEnd = outputPointer + rows * outputRowStride;
926  OutputPointerType outputColEnd = outputPointer + cols * outputColStride;
927 
928  Input1PointerType input1Pointer = input1Matrix.Pointer();
929  Input2PointerType input2Pointer = input2Matrix.Pointer();
930 
931  typename Input1MatrixType::ConstRowRefType input1Row;
932  typename Input2MatrixType::ConstColumnRefType input2Col;
933 
934  if ((outputPointer == input1Pointer) ||
935  (outputPointer == input2Pointer)) {
936  ThrowSharedPointersException();
937  }
938 
939  for (; outputPointer != outputRowEnd;
940  outputPointer += outputStrideToNextRow,
941  input1Pointer += input1RowStride,
942  input2Pointer = input2Matrix.Pointer(),
943  outputColEnd += outputRowStride)
944  {
945  input1Row.SetRef(input1Cols, input1Pointer, input1ColStride);
946  for (; outputPointer != outputColEnd;
947  outputPointer += outputColStride,
948  input2Pointer += input2ColStride)
949  {
950  input2Col.SetRef(input1Cols, input2Pointer, input2RowStride);
951  *outputPointer = _operationType::Operate(input1Row, input2Col);
952  }
953  }
954  } // Run method
955  }; // Product class
956 
957 
962  class MinAndMax
963  {
964  public:
965  template<class _inputMatrixType>
966  static void Run(const _inputMatrixType & inputMatrix,
967  typename _inputMatrixType::value_type & minValue, typename _inputMatrixType::value_type & maxValue)
968  {
969  typedef _inputMatrixType InputMatrixType;
970  typedef typename InputMatrixType::OwnerType InputOwnerType;
971  typedef typename InputOwnerType::size_type size_type;
972  typedef typename InputOwnerType::stride_type stride_type;
973  typedef typename InputOwnerType::const_pointer InputPointerType;
974  typedef typename InputOwnerType::value_type value_type;
975 
976  // retrieve owner
977  const InputOwnerType & inputOwner = inputMatrix.Owner();
978  InputPointerType inputPointer = inputOwner.Pointer();
979 
980  if (inputPointer == 0)
981  return;
982 
983  if (inputOwner.IsCompact()) {
984  vctDynamicCompactLoopEngines::MinAndMax::Run(inputOwner, minValue, maxValue);
985  } else {
986  // otherwise
987  const size_type rows = inputOwner.rows();
988  const size_type cols = inputOwner.cols();
989 
990  const stride_type inputColStride = inputOwner.col_stride();
991  const stride_type inputRowStride = inputOwner.row_stride();
992  const stride_type inputStrideToNextRow = inputRowStride - cols * inputColStride;
993  const InputPointerType inputRowEnd = inputPointer + rows * inputRowStride;
994  InputPointerType inputColEnd = inputPointer + cols * inputColStride;
995 
996  value_type minElement, maxElement;
997  maxElement = minElement = *inputPointer;
998 
999  for (;
1000  inputPointer != inputRowEnd;
1001  inputPointer += inputStrideToNextRow, inputColEnd += inputRowStride) {
1002  for (;
1003  inputPointer != inputColEnd;
1004  inputPointer += inputColStride) {
1005  const value_type element = *inputPointer;
1006  if (element < minElement) {
1007  minElement = element;
1008  } else if (maxElement < element) {
1009  maxElement = element;
1010  }
1011  }
1012  }
1013  minValue = minElement;
1014  maxValue = maxElement;
1015  }
1016  } // Run method
1017  }; // MinAndMax class
1018 
1019 
1020  class SelectRowsByIndex
1021  {
1022  public:
1023  template<class _outputMatrixType, class _inputMatrixType, class _indexVectorType>
1024  static void Run(_outputMatrixType & outputMatrix, const _inputMatrixType & inputMatrix,
1025  const _indexVectorType & indexVector)
1026  {
1027  typedef _outputMatrixType OutputMatrixType;
1028  // check sizes
1029  typedef _outputMatrixType OutputMatrixType;
1030  typedef typename OutputMatrixType::size_type size_type;
1031  typedef typename OutputMatrixType::stride_type stride_type;
1032  typedef typename OutputMatrixType::pointer OutputPointerType;
1033 
1034  typedef _inputMatrixType InputMatrixType;
1035  typedef typename InputMatrixType::const_pointer InputPointerType;
1036  typedef _indexVectorType IndexVectorType;
1037  typedef typename IndexVectorType::const_pointer IndexPointerType;
1038 
1039  const size_type rows = outputMatrix.rows();
1040  const size_type cols = outputMatrix.cols();
1041  if ((cols != inputMatrix.cols())
1042  || (rows != indexVector.size()))
1043  {
1044  ThrowSizeMismatchException();
1045  }
1046 
1047  // otherwise
1048  const stride_type outputColStride = outputMatrix.col_stride();
1049  const stride_type outputRowStride = outputMatrix.row_stride();
1050  const stride_type outputStrideToNextRow = outputRowStride - cols * outputColStride;
1051 
1052  const stride_type inputColStride = inputMatrix.col_stride();
1053  const stride_type indexStride = indexVector.stride();
1054 
1055  OutputPointerType outputPointer = outputMatrix.Pointer();
1056  const OutputPointerType outputRowEnd = outputPointer + rows * outputRowStride;
1057  OutputPointerType outputColEnd = outputPointer + cols * outputColStride;
1058 
1059  InputPointerType inputPointer;
1060  IndexPointerType indexPointer = indexVector.Pointer();
1061 
1062  for (; outputPointer != outputRowEnd;
1063  outputPointer += outputStrideToNextRow,
1064  indexPointer += indexStride,
1065  outputColEnd += outputRowStride)
1066  {
1067  inputPointer = inputMatrix.Pointer(*indexPointer, 0);
1068  for (; outputPointer != outputColEnd;
1069  outputPointer += outputColStride,
1070  inputPointer += inputColStride)
1071  {
1072  *outputPointer = *inputPointer;
1073  }
1074  }
1075 
1076  }
1077  };
1078 
1079 
1080 };
1081 
1082 
1083 #endif // _vctDynamicMatrixLoopEngines_h
1084 
vctDynamicMatrixLoopEngines::SoMi::Run
static OutputType Run(const _inputMatrixType &inputMatrix)
Definition: vctDynamicMatrixLoopEngines.h:521
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
vctDynamicMatrixLoopEngines::MoMi::Run
static void Run(_outputMatrixType &outputMatrix, const _inputMatrixType &inputMatrix)
Definition: vctDynamicMatrixLoopEngines.h:171
vctDynamicMatrixLoopEngines::SoMiMi::Run
static OutputType Run(const _input1MatrixType &input1Matrix, const _input2MatrixType &input2Matrix)
Definition: vctDynamicMatrixLoopEngines.h:570
vctDynamicMatrixLoopEngines::Mio::Run
static void Run(_inputOutputMatrixType &inputOutputMatrix)
Definition: vctDynamicMatrixLoopEngines.h:235
vctDynamicMatrixLoopEngines::SoMiSi::OutputType
_incrementalOperationType::OutputType OutputType
Definition: vctDynamicMatrixLoopEngines.h:833
vctDynamicMatrixLoopEngines::MioMi
Definition: vctDynamicMatrixLoopEngines.h:276
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
vctDynamicMatrixLoopEngines::MioSi::Run
static void Run(_inputOutputMatrixType &inputOutputMatrix, const _inputScalarType inputScalar)
Definition: vctDynamicMatrixLoopEngines.h:475
vctDynamicMatrixLoopEngines::MoMi
Definition: vctDynamicMatrixLoopEngines.h:168
vctDynamicMatrixLoopEngines::SoMi::OutputType
_incrementalOperationType::OutputType OutputType
Definition: vctDynamicMatrixLoopEngines.h:518
vctDynamicMatrixLoopEngines::ThrowSizeMismatchException
static void ThrowSizeMismatchException(void)
Definition: vctDynamicMatrixLoopEngines.h:45
vctDynamicMatrixLoopEngines::MoMiSi::Run
static void Run(_outputMatrixType &outputMatrix, const _inputMatrixType &inputMatrix, const _inputScalarType inputScalar)
Definition: vctDynamicMatrixLoopEngines.h:343
vctDynamicCompactLoopEngines::SoCiCi::Run
static OutputType Run(const _input1OwnerType &input1Owner, const _input2OwnerType &input2Owner)
Definition: vctDynamicCompactLoopEngines.h:450
vctDynamicCompactLoopEngines::CioCi::Run
static void Run(_inputOutputOwnerType &inputOutputOwner, const _inputOwnerType &inputOwner)
Definition: vctDynamicCompactLoopEngines.h:121
vct::size_type
size_t size_type
Definition: vctContainerTraits.h:35
vctDynamicMatrixLoopEngines::MioMi::Run
static void Run(_inputOutputMatrixType &inputOutputMatrix, const _inputMatrixType &inputMatrix)
Definition: vctDynamicMatrixLoopEngines.h:279
vctDynamicCompactLoopEngines.h
Declaration of vctDynamicCompactLoopEngines.
vctDynamicMatrixLoopEngines::Product::Run
static void Run(_outputMatrixType &outputMatrix, const _input1MatrixType &input1Matrix, const _input2MatrixType &input2Matrix)
Definition: vctDynamicMatrixLoopEngines.h:887
vctDynamicMatrixLoopEngines::MoSiMi
Definition: vctDynamicMatrixLoopEngines.h:406
vctDynamicMatrixLoopEngines
Container class for the dynamic matrix engines.
Definition: vctDynamicMatrixLoopEngines.h:39
vctDynamicMatrixLoopEngines::MoMiMi
Definition: vctDynamicMatrixLoopEngines.h:89
vctDynamicMatrixLoopEngines::MinAndMax::Run
static void Run(const _inputMatrixType &inputMatrix, typename _inputMatrixType::value_type &minValue, typename _inputMatrixType::value_type &maxValue)
Definition: vctDynamicMatrixLoopEngines.h:966
vctDynamicMatrixLoopEngines::SoMiMi::OutputType
_incrementalOperationType::OutputType OutputType
Definition: vctDynamicMatrixLoopEngines.h:567
vctDynamicMatrixLoopEngines::SoMiMi
Definition: vctDynamicMatrixLoopEngines.h:565
vctDynamicCompactLoopEngines::CioCiCi::Run
static void Run(_ioOwnerType &ioOwner, const _input1OwnerType &input1Owner, const _input2OwnerType &input2Owner)
Definition: vctDynamicCompactLoopEngines.h:549
vctDynamicMatrixLoopEngines::MioSiMi::Run
static void Run(_ioMatrixType &ioMatrix, const _inputScalarType &inputScalar, const _inputMatrixType &inputMatrix)
Definition: vctDynamicMatrixLoopEngines.h:663
vctDynamicMatrixLoopEngines::MoMiMi::Run
static void Run(_outputMatrixType &outputMatrix, const _input1MatrixType &input1Matrix, const _input2MatrixType &input2Matrix)
Definition: vctDynamicMatrixLoopEngines.h:92
vctDynamicMatrixLoopEngines::SoMi
Definition: vctDynamicMatrixLoopEngines.h:516
vctDynamicMatrixLoopEngines::SelectRowsByIndex
Definition: vctDynamicMatrixLoopEngines.h:1020
vctDynamicMatrixLoopEngines::MioSi
Definition: vctDynamicMatrixLoopEngines.h:472
vctDynamicMatrixLoopEngines::ThrowSharedPointersException
static void ThrowSharedPointersException(void)
Definition: vctDynamicMatrixLoopEngines.h:52
cmnThrow
#define cmnThrow(a)
Definition: MinimalCmn.h:4
vctDynamicCompactLoopEngines::CoCiCi::Run
static void Run(_outputOwnerType &outputOwner, const _input1OwnerType &input1Owner, const _input2OwnerType &input2Owner)
Definition: vctDynamicCompactLoopEngines.h:75
vctDynamicMatrixLoopEngines::Product
Definition: vctDynamicMatrixLoopEngines.h:884
vctDynamicMatrixLoopEngines::MioSiMi
Implement operation of the form for fixed size matrices.
Definition: vctDynamicMatrixLoopEngines.h:658
vctDynamicMatrixLoopEngines::MoMiSi
Definition: vctDynamicMatrixLoopEngines.h:340
vct::stride_type
ptrdiff_t stride_type
Definition: vctContainerTraits.h:37
vctDynamicMatrixLoopEngines::MioMiMi::Run
static void Run(_ioMatrixType &ioMatrix, const _input1MatrixType &input1Matrix, const _input2MatrixType &input2Matrix)
Definition: vctDynamicMatrixLoopEngines.h:754
vctDynamicMatrixLoopEngines::MioMiMi
Implement operation of the form for fixed size matrices.
Definition: vctDynamicMatrixLoopEngines.h:749
vctDynamicCompactLoopEngines::CoCiSi::Run
static void Run(_outputOwnerType &outputOwner, const _inputOwnerType &inputOwner, const _inputScalarType inputScalar)
Definition: vctDynamicCompactLoopEngines.h:204
vctDynamicMatrixLoopEngines::SoMiSi::Run
static OutputType Run(const _inputMatrixType &inputMatrix, const _inputScalarType &inputScalar)
Definition: vctDynamicMatrixLoopEngines.h:836
vctDynamicMatrixLoopEngines::Mio
Definition: vctDynamicMatrixLoopEngines.h:232
cmnThrow.h
Declaration of the template function cmnThrow.
vctDynamicCompactLoopEngines::SoCiSi::Run
static OutputType Run(const _inputOwnerType &inputOwner, const _inputScalarType &inputScalar)
Definition: vctDynamicCompactLoopEngines.h:603
vctDynamicMatrixLoopEngines::MoSiMi::Run
static void Run(_outputMatrixType &outputMatrix, const _inputScalarType inputScalar, const _inputMatrixType &inputMatrix)
Definition: vctDynamicMatrixLoopEngines.h:409
vctDynamicCompactLoopEngines::MinAndMax::Run
static void Run(const _inputOwnerType &inputOwner, typename _inputOwnerType::value_type &minValue, typename _inputOwnerType::value_type &maxValue)
Definition: vctDynamicCompactLoopEngines.h:630
vctDynamicMatrixLoopEngines::MinAndMax
Definition: vctDynamicMatrixLoopEngines.h:962
vctDynamicMatrixLoopEngines::SelectRowsByIndex::Run
static void Run(_outputMatrixType &outputMatrix, const _inputMatrixType &inputMatrix, const _indexVectorType &indexVector)
Definition: vctDynamicMatrixLoopEngines.h:1024
vctDynamicCompactLoopEngines::CioSiCi::Run
static void Run(_ioOwnerType &ioOwner, const _inputScalarType inputScalar, const _inputOwnerType &inputOwner)
Definition: vctDynamicCompactLoopEngines.h:500
vctDynamicMatrixLoopEngines::SoMiSi
Definition: vctDynamicMatrixLoopEngines.h:831
Generated by   doxygen 1.8.6