vctDynamicCompactLoopEngines.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */
 
/*
 
  Author(s):    Anton Deguet
  Created on:   2007-07-07
 
  (C) Copyright 2007-2013 Johns Hopkins University (JHU), All Rights
  Reserved.
 
--- begin cisst license - do not edit ---
 
This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.
 
--- end cisst license ---
*/
 
#pragma once
#ifndef _vctDynamicCompactLoopEngines_h
#define _vctDynamicCompactLoopEngines_h

 
#include <cisstCommon/cmnPortability.h>
#include <cisstCommon/cmnThrow.h>

class vctDynamicCompactLoopEngines {
 
 public:

    template<class _elementOperationType>
    class CoCiCi {
    public:
        template<class _outputOwnerType, class _input1OwnerType, class _input2OwnerType>
        static inline void Run(_outputOwnerType & outputOwner,
                               const _input1OwnerType & input1Owner,
                               const _input2OwnerType & input2Owner) {
 
            typedef _outputOwnerType OutputOwnerType;
            typedef typename OutputOwnerType::pointer OutputPointerType;
            typedef typename OutputOwnerType::size_type size_type;
 
            typedef _input1OwnerType Input1OwnerType;
            typedef typename Input1OwnerType::const_pointer Input1PointerType;
 
            typedef _input2OwnerType Input2OwnerType;
            typedef typename Input2OwnerType::const_pointer Input2PointerType;
 
            const size_type size = outputOwner.size();
 
            OutputPointerType outputPointer = outputOwner.Pointer();
            const OutputPointerType outputEnd = outputPointer + size;
 
            Input1PointerType input1Pointer = input1Owner.Pointer();
            Input2PointerType input2Pointer = input2Owner.Pointer();
 
            for (;
                 outputPointer != outputEnd;
                 outputPointer++, input1Pointer++, input2Pointer++) {
                *outputPointer = _elementOperationType::Operate(*input1Pointer, *input2Pointer);
            }
        }
    };
 

    template<class _elementOperationType>
    class CioCi {
    public:
        template<class _inputOutputOwnerType, class _inputOwnerType>
        static void Run(_inputOutputOwnerType & inputOutputOwner,
                        const _inputOwnerType & inputOwner) {
 
            typedef _inputOutputOwnerType InputOutputOwnerType;
            typedef typename InputOutputOwnerType::pointer InputOutputPointerType;
            typedef typename InputOutputOwnerType::size_type size_type;
 
            typedef _inputOwnerType InputOwnerType;
            typedef typename InputOwnerType::const_pointer InputPointerType;
 
            const size_type size = inputOutputOwner.size();
 
            InputOutputPointerType inputOutputPointer = inputOutputOwner.Pointer();
            const InputOutputPointerType inputOutputEnd = inputOutputPointer + size;
 
            InputPointerType inputPointer = inputOwner.Pointer();
 
            for (;
                 inputOutputPointer != inputOutputEnd;
                 inputOutputPointer++, inputPointer++) {
                *inputOutputPointer = _elementOperationType::Operate(*inputOutputPointer, *inputPointer);
            }
        }
    };
 

    template<class _elementOperationType>
    class CioCio {
    public:
        template<class _inputOutput1OwnerType, class _inputOutput2OwnerType>
        static void Run(_inputOutput1OwnerType & inputOutput1Owner,
                        _inputOutput2OwnerType & inputOutput2Owner) {
 
            typedef _inputOutput1OwnerType InputOutput1OwnerType;
            typedef typename InputOutput1OwnerType::pointer InputOutput1PointerType;
            typedef typename InputOutput1OwnerType::size_type size_type;
 
            typedef _inputOutput2OwnerType InputOutput2OwnerType;
            typedef typename InputOutput2OwnerType::pointer InputOutput2PointerType;
 
            const size_type size = inputOutput1Owner.size();
 
            InputOutput1PointerType inputOutput1Pointer = inputOutput1Owner.Pointer();
            const InputOutput1PointerType inputOutput1End = inputOutput1Pointer + size;
 
            InputOutput2PointerType inputOutput2Pointer = inputOutput2Owner.Pointer();
 
            for (;
                 inputOutput1Pointer != inputOutput1End;
                 inputOutput1Pointer++, inputOutput2Pointer++) {
                _elementOperationType::Operate(*inputOutput1Pointer, *inputOutput2Pointer);
            }
        }
    };
 

    template<class _elementOperationType>
    class CoCiSi {
    public:
        template<class _outputOwnerType, class _inputOwnerType, class _inputScalarType>
        static inline void Run(_outputOwnerType & outputOwner,
                               const _inputOwnerType & inputOwner,
                               const _inputScalarType inputScalar) {
 
            typedef _outputOwnerType OutputOwnerType;
            typedef typename OutputOwnerType::pointer OutputPointerType;
            typedef typename OutputOwnerType::size_type size_type;
 
            typedef _inputOwnerType InputOwnerType;
            typedef typename InputOwnerType::const_pointer InputPointerType;
 
            const size_type size = outputOwner.size();
 
            OutputPointerType outputPointer = outputOwner.Pointer();
            const OutputPointerType outputEnd = outputPointer + size;
 
            InputPointerType inputPointer = inputOwner.Pointer();
 
            for (;
                 outputPointer != outputEnd;
                 outputPointer++, inputPointer++) {
                *outputPointer = _elementOperationType::Operate(*inputPointer, inputScalar);
            }
        }
    };
 

    template<class _elementOperationType>
    class CoSiCi {
    public:
        template<class _outputOwnerType, class _inputScalarType, class _inputOwnerType>
        static inline void Run(_outputOwnerType & outputOwner,
                               const _inputScalarType inputScalar,
                               const _inputOwnerType & inputOwner) {
 
            typedef _outputOwnerType OutputOwnerType;
            typedef typename OutputOwnerType::pointer OutputPointerType;
            typedef typename OutputOwnerType::size_type size_type;
 
            typedef _inputOwnerType InputOwnerType;
            typedef typename InputOwnerType::const_pointer InputPointerType;
 
            const size_type size = outputOwner.size();
 
            OutputPointerType outputPointer = outputOwner.Pointer();
            const OutputPointerType outputEnd = outputPointer + size;
 
            InputPointerType inputPointer = inputOwner.Pointer();
 
            for (;
                 outputPointer != outputEnd;
                 outputPointer++, inputPointer++) {
                *outputPointer = _elementOperationType::Operate(inputScalar, *inputPointer);
            }
        }
    };
 

    template<class _elementOperationType>
    class CioSi {
    public:
        template<class _inputOutputOwnerType, class _inputScalarType>
        static void Run(_inputOutputOwnerType & inputOutputOwner,
                        const _inputScalarType inputScalar) {
 
            typedef _inputOutputOwnerType InputOutputOwnerType;
            typedef typename InputOutputOwnerType::pointer InputOutputPointerType;
            typedef typename InputOutputOwnerType::size_type size_type;
 
            const size_type size = inputOutputOwner.size();
 
            InputOutputPointerType inputOutputPointer = inputOutputOwner.Pointer();
            const InputOutputPointerType inputOutputEnd = inputOutputPointer + size;;
 
            for (;
                 inputOutputPointer != inputOutputEnd;
                 inputOutputPointer++) {
                _elementOperationType::Operate(*inputOutputPointer, inputScalar);
            }
        }
    };
 

    template<class _elementOperationType>
    class CoCi {
    public:
        template<class _outputOwnerType, class _inputOwnerType>
        static inline void Run(_outputOwnerType & outputOwner,
                               const _inputOwnerType & inputOwner) {
 
            typedef _outputOwnerType OutputOwnerType;
            typedef typename OutputOwnerType::pointer OutputPointerType;
            typedef typename OutputOwnerType::size_type size_type;
 
            typedef _inputOwnerType InputOwnerType;
            typedef typename InputOwnerType::const_pointer InputPointerType;
 
            OutputPointerType outputPointer = outputOwner.Pointer();
            const size_type size = outputOwner.size();
            const OutputPointerType outputEnd = outputPointer + size;
 
            InputPointerType inputPointer = inputOwner.Pointer();
 
            for (;
                 outputPointer != outputEnd;
                 outputPointer++, inputPointer++) {
                *outputPointer = _elementOperationType::Operate(*inputPointer);
            }
        }
    };
 
 

    template<class _elementOperationType>
    class Cio {
    public:
        template<class _inputOutputOwnerType>
        static inline void Run(_inputOutputOwnerType & inputOutputOwner) {
 
            typedef _inputOutputOwnerType InputOutputOwnerType;
            typedef typename InputOutputOwnerType::pointer InputOutputPointerType;
            typedef typename InputOutputOwnerType::size_type size_type;
 
            const size_type size = inputOutputOwner.size();
 
            InputOutputPointerType inputOutputPointer = inputOutputOwner.Pointer();
            const InputOutputPointerType inputOutputEnd = inputOutputPointer + size;
 
            for (;
                 inputOutputPointer != inputOutputEnd;
                 inputOutputPointer++) {
                _elementOperationType::Operate(*inputOutputPointer);
            }
        }
    };
 
 

    template<class _incrementalOperationType, class _elementOperationType>
    class SoCi {
    public:
        typedef typename _incrementalOperationType::OutputType OutputType;
 
        template<class _inputOwnerType>
        static OutputType Run(const _inputOwnerType & inputOwner) {
 
            typedef _inputOwnerType InputOwnerType;
            typedef typename InputOwnerType::const_pointer InputPointerType;
            typedef typename InputOwnerType::size_type size_type;
 
            const size_type size = inputOwner.size();
            OutputType incrementalResult = _incrementalOperationType::NeutralElement();
 
            InputPointerType inputPointer = inputOwner.Pointer();
            const InputPointerType inputEnd = inputPointer + size;
 
            for (;
                 inputPointer != inputEnd;
                 inputPointer++) {
                incrementalResult = _incrementalOperationType::Operate(incrementalResult,
                                                                       _elementOperationType::Operate(*inputPointer));
            }
            return incrementalResult;
        }
    };
 

    template<class _incrementalOperationType, class _elementOperationType>
    class SoCiCi {
    public:
        typedef typename _incrementalOperationType::OutputType OutputType;
 
        template<class _input1OwnerType, class _input2OwnerType>
        static inline OutputType Run(const _input1OwnerType & input1Owner,
                                     const _input2OwnerType & input2Owner) {
 
            typedef _input1OwnerType Input1OwnerType;
            typedef typename Input1OwnerType::const_pointer Input1PointerType;
            typedef typename Input1OwnerType::size_type size_type;
 
            typedef _input2OwnerType Input2OwnerType;
            typedef typename Input2OwnerType::const_pointer Input2PointerType;
 
            const size_type size = input1Owner.size();
 
            OutputType incrementalResult = _incrementalOperationType::NeutralElement();
 
            Input1PointerType input1Pointer = input1Owner.Pointer();
            const Input1PointerType input1End = input1Pointer + size;
 
            Input2PointerType input2Pointer = input2Owner.Pointer();
 
            for (;
                 input1Pointer != input1End;
                 input1Pointer++, input2Pointer++) {
                incrementalResult = _incrementalOperationType::Operate(incrementalResult,
                                                                       _elementOperationType::Operate(*input1Pointer,
                                                                                                      *input2Pointer));
            }
            return incrementalResult;
        }
    };
 

    template<class _ioElementOperationType, class _scalarElementOperationType>
    class CioSiCi {
    public:
        template<class _ioOwnerType, class _inputScalarType, class _inputOwnerType>
        static inline void Run(_ioOwnerType & ioOwner,
                               const _inputScalarType inputScalar, const _inputOwnerType & inputOwner)
        {
            typedef _ioOwnerType IoOwnerType;
            typedef typename IoOwnerType::pointer IoPointerType;
            typedef typename IoOwnerType::size_type size_type;
 
            typedef _inputOwnerType InputOwnerType;
            typedef typename InputOwnerType::const_pointer InputPointerType;
 
            const size_type size = ioOwner.size();
 
            IoPointerType ioPointer = ioOwner.Pointer();
            const IoPointerType ioEnd = ioPointer + size;
 
            InputPointerType inputPointer = inputOwner.Pointer();
 
            for (;
                 ioPointer != ioEnd;
                 ioPointer++, inputPointer++)
            {
                _ioElementOperationType::Operate(*ioPointer,
                                                 _scalarElementOperationType::Operate(inputScalar, *inputPointer));
            }
        }
 
    };
 
 

    template<class _ioElementOperationType, class _ownerElementOperationType>
    class CioCiCi {
    public:
        template<class _ioOwnerType, class _input1OwnerType, class _input2OwnerType>
        static inline void Run(_ioOwnerType & ioOwner,
                               const _input1OwnerType & input1Owner, const _input2OwnerType & input2Owner)
        {
            typedef _ioOwnerType IoOwnerType;
            typedef typename IoOwnerType::pointer IoPointerType;
            typedef typename IoOwnerType::size_type size_type;
 
            typedef _input1OwnerType Input1OwnerType;
            typedef typename Input1OwnerType::const_pointer Input1PointerType;
 
            typedef _input2OwnerType Input2OwnerType;
            typedef typename Input2OwnerType::const_pointer Input2PointerType;
 
            const size_type size = ioOwner.size();
 
            IoPointerType ioPointer = ioOwner.Pointer();
            const IoPointerType ioEnd = ioPointer + size;
 
            Input1PointerType input1Pointer = input1Owner.Pointer();
            Input2PointerType input2Pointer = input2Owner.Pointer();
 
            for (;
                 ioPointer != ioEnd;
                 ioPointer++, input1Pointer++, input2Pointer++)
            {
                _ioElementOperationType::Operate(*ioPointer,
                                                 _ownerElementOperationType::Operate(*input1Pointer, *input2Pointer));
            }
        }
 
    };
 

    template<class _incrementalOperationType, class _elementOperationType>
    class SoCiSi {
    public:
        typedef typename _incrementalOperationType::OutputType OutputType;
 
        template<class _inputOwnerType, class _inputScalarType>
        static inline OutputType Run(const _inputOwnerType & inputOwner,
                                     const _inputScalarType & inputScalar) {
 
            typedef _inputOwnerType InputOwnerType;
            typedef typename InputOwnerType::const_pointer InputPointerType;
            typedef typename InputOwnerType::size_type size_type;
 
            const size_type size = inputOwner.size();
            OutputType incrementalResult = _incrementalOperationType::NeutralElement();
 
            InputPointerType inputPointer = inputOwner.Pointer();
            const InputPointerType inputEnd = inputPointer + size;
 
            for (;
                 inputPointer != inputEnd;
                 inputPointer++) {
                incrementalResult = _incrementalOperationType::Operate(incrementalResult,
                                                                       _elementOperationType::Operate(*inputPointer, inputScalar));
            }
            return incrementalResult;
        }
    };
 
 
    class MinAndMax {
    public:
        template<class _inputOwnerType>
        static void Run(const _inputOwnerType & inputOwner, typename _inputOwnerType::value_type & minValue,
                        typename _inputOwnerType::value_type & maxValue)
        {
            typedef _inputOwnerType InputOwnerType;
            typedef typename InputOwnerType::const_pointer InputPointerType;
            typedef typename InputOwnerType::size_type size_type;
            typedef typename InputOwnerType::value_type value_type;
 
            InputPointerType inputPointer = inputOwner.Pointer();
 
            const size_type size = inputOwner.size();
            const InputPointerType inputEnd = inputPointer + size;
 
            value_type minElement, maxElement;
            maxElement = minElement = *inputPointer;
 
            for (;
                 inputPointer != inputEnd;
                 inputPointer++) {
                const value_type element = *inputPointer;
                if (element < minElement) {
                    minElement = element;
                } else if (maxElement < element) {
                    maxElement = element;
                }
            }
            minValue = minElement;
            maxValue = maxElement;
        }
    };
 
};
 
 
#endif  // _vctDynamicCompactLoopEngines_h