vctBinaryOperations.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):  Ofri Sadowsky, Anton Deguet
  Created on: 2003-08-18

  (C) Copyright 2003-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 _vctBinaryOperations_h
#define _vctBinaryOperations_h

#include <cisstCommon/cmnTypeTraits.h>

template<class _outputType, class _input1Type = _outputType, class _input2Type = _outputType>
class vctBinaryOperations {
    public:
    typedef _outputType OutputType;
    typedef _input1Type Input1Type;
    typedef _input2Type Input2Type;

    class Addition {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const Input1Type & input1, const Input2Type & input2) {
            return OutputType(input1+input2);
        }

        static inline OutputType NeutralElement()
        {
            return OutputType(0);
        }
    };

    class Subtraction {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const Input1Type & input1, const Input2Type & input2) {
            return OutputType(input1-input2);
        }

        static inline OutputType NeutralElement()
        {
            return OutputType(0);
        }
    };

    class Multiplication {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const Input1Type & input1, const Input2Type & input2) {
            return OutputType(input1*input2);
        }

        static inline OutputType NeutralElement()
        {
            return OutputType(1);
        }
    };

    class Division {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const Input1Type & input1, const Input2Type & input2) {
            return OutputType(input1 / input2);
        }

        static inline OutputType NeutralElement()
        {
            return OutputType(1);
        }
    };


    class FirstOperand {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const Input1Type & input1, const Input2Type & CMN_UNUSED(input2)) {
            return OutputType(input1);
        }
    };

    class SecondOperand {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const Input1Type & CMN_UNUSED(input1), const Input2Type & input2) {
            return OutputType(input2);
        }
    };

    class Maximum {
    public:
        typedef _outputType OutputType;
        static inline const OutputType & Operate(const OutputType & input1, const OutputType & input2) {
            return (input1 > input2) ? input1 : input2;
        }

        static inline OutputType NeutralElement()
        {
            return cmnTypeTraits<OutputType>::MinNegativeValue();
        }
    };

    class Minimum {
    public:
        typedef _outputType OutputType;
        static inline const OutputType & Operate(const OutputType & input1, const OutputType & input2) {
            return (input1 < input2) ? input1 : input2;
        }

        static inline OutputType NeutralElement()
        {
            return cmnTypeTraits<OutputType>::MaxPositiveValue();
        }
    };

    class ClipIn {
    public:
        typedef _outputType OutputType;
        static inline const OutputType Operate(const OutputType & bound, const OutputType & input) {
            if (input > bound) {
                return bound;
            } else if (input < -bound) {
                return -bound;
            }
            return input;
        }

        static inline OutputType NeutralElement(void) {
            return cmnTypeTraits<OutputType>::MaxPositiveValue();
        }
    };


    class Equal {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const Input1Type & input1, const Input2Type & input2) {
            return OutputType(input1 == input2);
        }
    };

    class NotEqual {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const Input1Type & input1, const Input2Type & input2) {
            return OutputType(input1 != input2);
        }
    };

    class Lesser {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const Input1Type & input1, const Input2Type & input2) {
            return OutputType(input1 < input2);
        }
    };

    class LesserOrEqual {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const Input1Type & input1, const Input2Type & input2) {
            return OutputType(input1 <= input2);
        }
    };

    class Greater {
    public:
        typedef bool OutputType;
        static inline OutputType Operate(const Input1Type & input1, const Input2Type & input2) {
            return OutputType(input1 > input2);
        }
    };

    class GreaterOrEqual {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const Input1Type & input1, const Input2Type & input2) {
            return OutputType(input1 >= input2);
        }
    };

    class And {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const Input1Type & input1, const Input2Type & input2) {
            return OutputType(input1 && input2);
        }

        static inline OutputType NeutralElement()
        {
            return OutputType(true);
        }
    };

    class Or {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const OutputType & input1, const OutputType & input2) {
            return OutputType(input1 || input2);
        }

        static inline OutputType NeutralElement()
        {
            return OutputType(false);
        }
    };

    class Bound {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const Input1Type & input1, const Input2Type & input2) {
            return OutputType( (-input2 <= input1) && (input1 <= input2) );
        }
    };


    class DotProduct {
    public:
        typedef _outputType OutputType;
        static inline OutputType Operate(const Input1Type & input1, const Input2Type & input2) {
            return input1.DotProduct(input2);
        }
    };


};

// Specialize Addition for bool to avoid compiler warnings. Other binary operations
// can be specialized if needed.
template<>
class vctBinaryOperations<bool, bool, bool>::Addition {
    public:
        static inline bool Operate(const bool & input1, const bool & input2) {
            return (input1|input2);
        }

        static inline bool NeutralElement()
        {
            return false;
        }
};


#endif  // _vctBinaryOperations_h