LinearAlgebraUtils.h

Go to the documentation of this file.

// LinearAlgebraUtils.h:
// ---------------------
//

#ifndef __IPSDKMATH_LINEARALGEBRAUTILS_H__
#define __IPSDKMATH_LINEARALGEBRAUTILS_H__

#include <IPSDKMath/IPSDKMathExports.h>
#include <IPSDKMath/LinearAlgebra/LinearAlgebraTypes.h>
#include <IPSDKMath/Constants.h>
#include <IPSDKUtil/Tools/ForceInline.h>
#include <vector>

namespace ipsdk {
namespace math {


IPSDK_FORCEINLINE ipReal64
comparable_distance(const ipsdk::math::Vector& v0,
                    const ipsdk::math::Vector& v1)
{
    // parse all elements
    ipReal64 dist = 0;
    Vector::const_iterator iter0 = v0.begin();
    Vector::const_iterator iter1 = v1.begin();
    while (iter0 != v0.end()) {
    
        // retrieve current elements
        const ipReal64 curValue0 = *iter0;
        const ipReal64 curValue1 = *iter1;

        // compute contribution to comparable distance
        const ipReal64 delta = curValue0 - curValue1;
        dist += delta*delta;

        ++iter0;
        ++iter1;
    }

    return dist;
}

IPSDK_FORCEINLINE ipReal64
euclidian_distance(const ipsdk::math::Vector& v0,
                   const ipsdk::math::Vector& v1)
{
    return std::sqrt(comparable_distance(v0, v1));
}

template <typename ArrayType>
std::vector<ipReal64>
fromUBlas(const boost::numeric::ublas::vector<ipReal64, ArrayType>& inputVector)
{
    std::vector<ipReal64> outputVector;
    fromUBlas(inputVector, outputVector);

    return outputVector;
}
template <typename ArrayType>
void
fromUBlas(const boost::numeric::ublas::vector<ipReal64, ArrayType>& inputVector,
          std::vector<ipReal64>& outputVector)
{
    outputVector.clear();
    outputVector.reserve(inputVector.size());
    boost::numeric::ublas::vector<ipReal64>::const_iterator iter = inputVector.begin();
    while (iter != inputVector.end()) {
    
        outputVector.push_back(*iter);

        ++iter;
    }
}
IPSDKMATH_API ipsdk::math::Vector
toUBlas(const std::vector<ipReal64>& inputVector);
IPSDKMATH_API void
toUBlas(const std::vector<ipReal64>& inputVector,
        ipsdk::math::Vector& outputVector);

template <typename ArrayType>
std::vector<ipReal64>
fromUBlas(const boost::numeric::ublas::matrix<ipReal64, boost::numeric::ublas::row_major, ArrayType>& inputMatrix)
{
    std::vector<ipReal64> outputVector;
    fromUBlas(inputMatrix, outputVector);

    return outputVector;
}
template <typename ArrayType>
void
fromUBlas(const boost::numeric::ublas::matrix<ipReal64, boost::numeric::ublas::row_major, ArrayType>& inputMatrix,
          std::vector<ipReal64>& outputVector)
{
    outputVector.clear();
    outputVector.reserve(inputMatrix.data().size());
    boost::numeric::ublas::vector<ipReal64>::const_iterator iter = inputMatrix.data().begin();
    while (iter != inputMatrix.data().end()) {
    
        outputVector.push_back(*iter);

        ++iter;
    }
}
IPSDKMATH_API ipsdk::math::Matrix
toUBlas(const std::vector<ipReal64>& inputVector,
        const ipUInt32 sizeX,
        const ipUInt32 sizeY);
IPSDKMATH_API void
toUBlas(const std::vector<ipReal64>& inputVector,
        ipsdk::math::Matrix& outputMatrix);

template <typename ArrayType1, typename ArrayType2>
bool
equal(const boost::numeric::ublas::matrix<ipReal64, boost::numeric::ublas::row_major, ArrayType1>& mat1,
      const boost::numeric::ublas::matrix<ipReal64, boost::numeric::ublas::row_major, ArrayType2>& mat2)
{
    const ipReal64 normDiff = boost::numeric::ublas::norm_frobenius(mat1 - mat2);

    return normDiff == 0;
}

template <typename ArrayType1, typename ArrayType2>
bool
compare(const boost::numeric::ublas::matrix<ipReal64, boost::numeric::ublas::row_major, ArrayType1>& mat1,
        const boost::numeric::ublas::matrix<ipReal64, boost::numeric::ublas::row_major, ArrayType2>& mat2,
        const ipReal64 epsilonValue = NumericLimits<ipReal64>::sqrt_epsilon())
{
    const ipReal64 normDiff = boost::numeric::ublas::norm_frobenius(mat1 - mat2);

    return normDiff < epsilonValue;
}

template <typename ArrayType1, typename ArrayType2>
bool
compareRelative(const boost::numeric::ublas::matrix<ipReal64, boost::numeric::ublas::row_major, ArrayType1>& mat1,
                const boost::numeric::ublas::matrix<ipReal64, boost::numeric::ublas::row_major, ArrayType2>& mat2,
                const ipReal64 epsilonValue = NumericLimits<ipReal64>::sqrt_epsilon())
{
    const ipReal64 norm1 = boost::numeric::ublas::norm_frobenius(mat1);
    const ipReal64 norm2 = boost::numeric::ublas::norm_frobenius(mat2);
    const ipReal64 normDiff = boost::numeric::ublas::norm_frobenius(mat1 - mat2);

    return normDiff < epsilonValue * std::max(norm1, norm2);
}

template <typename ArrayType1, typename ArrayType2>
bool
equal(const boost::numeric::ublas::vector<ipReal64, ArrayType1>& vec1,
      const boost::numeric::ublas::vector<ipReal64, ArrayType2>& vec2)
{
    const ipReal64 normDiff = boost::numeric::ublas::norm_2(vec1 - vec2);

    return normDiff == 0;
}

template <typename ArrayType1, typename ArrayType2>
bool
compare(const boost::numeric::ublas::vector<ipReal64, ArrayType1>& vec1,
        const boost::numeric::ublas::vector<ipReal64, ArrayType2>& vec2,
        const ipReal64 epsilonValue = NumericLimits<ipReal64>::sqrt_epsilon())
{
    const ipReal64 normDiff = boost::numeric::ublas::norm_2(vec1 - vec2);

    return normDiff < epsilonValue;
}

template <typename ArrayType1, typename ArrayType2>
bool
compareRelative(const boost::numeric::ublas::vector<ipReal64, ArrayType1>& vec1,
                const boost::numeric::ublas::vector<ipReal64, ArrayType2>& vec2,
                const ipReal64 epsilonValue = NumericLimits<ipReal64>::sqrt_epsilon())
{
    const ipReal64 norm1 = boost::numeric::ublas::norm_2(vec1);
    const ipReal64 norm2 = boost::numeric::ublas::norm_2(vec2);
    const ipReal64 normDiff = boost::numeric::ublas::norm_2(vec1 - vec2);

    return normDiff < epsilonValue * std::max(norm1, norm2);
}


} // end of namespace math
} // end of namespace ipsdk

#endif // __IPSDKMATH_LINEARALGEBRAUTILS_H__