Utility.h

Go to the documentation of this file.

/*
 * Expression Template Matrix Library
 *
 * Copyright (C) 2004 - 2006 Ricky Lung <mtlung@users.sourceforge.net>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */


#ifndef EXMAT_MATH_UTILITY_H
#define EXMAT_MATH_UTILITY_H

#ifdef _MSC_VER
#   pragma warning( push )
#   pragma warning( disable : 4786 )
#endif  // _MSC_VER

#include "../Mat.h"
#include "FunctionTable.h"
#include <cmath>

#if (EXMAT_VC6 && EXMAT_VC6_DEFAULT_STL || EXMAT_ICL)
#   define VC6_STD_MATH_WKAR
#else
#   define VC6_STD_MATH_WKAR std
#endif

namespace exmat {

namespace Math {


EXMAT_INLINE2 static double CPi() {
    return static_cast<double>(3.1415926535897932384626433832795);
}
EXMAT_INLINE2 static double C2Pi() {
    return static_cast<double>(3.1415926535897932384626433832795*2);
}
EXMAT_INLINE2 static double CPi_2() {
    return static_cast<double>(1.5707963267948966192313216916395);
}
EXMAT_INLINE2 static double CPi_4() {
    return static_cast<double>(0.785398163397448309616);
}
EXMAT_INLINE2 static double C1_Pi() {
    return static_cast<double>(0.318309886183790671538);
}
EXMAT_INLINE2 static double C2_Pi() {
    return static_cast<double>(0.636619772367581343076);
}
EXMAT_INLINE2 static double CE() {
    return static_cast<double>(2.7182818284590452353602874713527);
}
EXMAT_INLINE2 static double CSqrt2() {
    return static_cast<double>(1.41421356237309504880);
}
EXMAT_INLINE2 static double C1_Sqrt2() {
    return static_cast<double>(0.707106781186547524401);
}



EXMAT_INLINE2 static int abs(int x) {
    return int(VC6_STD_MATH_WKAR::abs(x));
}
EXMAT_INLINE2 static float abs(float x) {
    return float(VC6_STD_MATH_WKAR::fabs(x));
}
EXMAT_INLINE2 static double abs(double x) {
    return double(VC6_STD_MATH_WKAR::fabs(x));
}

EXMAT_INLINE2 static bool isEqual(double s1, double s2, double eps=1e-6) {
    return (Math::abs(s1 - s2) <= eps);
}

template<typename T> EXMAT_INLINE2 static
T min(const T& x1, const T& x2) {
    return x1 < x2 ? x1 : x2;
}
template<typename T> EXMAT_INLINE2 static
T min(const T& x1, const T& x2, const T& x3) {
    T tmp = min(x2, x3);
    return x1 < tmp ? x1 : tmp;
}
template<typename T> EXMAT_INLINE2 static
T min(const T& x1, const T& x2, const T& x3, const T& x4) {
    T tmp = min(x2, x3, x4);
    return x1 < tmp ? x1 : tmp;
}
template<typename T> EXMAT_INLINE2 static
T min(const T& x1, const T& x2, const T& x3, const T& x4, const T& x5) {
    T tmp = min(x2, x3, x4, x5);
    return x1 < tmp ? x1 : tmp;
}
EXMAT_INLINE2 static float min(const float* in, size_t N) {
    return PNS::FUNffpiTable[PNS::FUNffpi_ID::min](in, N);
}

template<typename T> EXMAT_INLINE2 static
T max(const T& x1, const T& x2) {
    return x1 > x2 ? x1 : x2;
}
template<typename T> EXMAT_INLINE2 static
T max(const T& x1, const T& x2, const T& x3) {
    T tmp = max(x2, x3);
    return x1 > tmp ? x1 : tmp;
}
template<typename T> EXMAT_INLINE2 static
T max(const T& x1, const T& x2, const T& x3, const T& x4) {
    T tmp = max(x2, x3, x4);
    return x1 > tmp ? x1 : tmp;
}
template<typename T> EXMAT_INLINE2 static
T max(const T& x1, const T& x2, const T& x3, const T& x4, const T& x5) {
    T tmp = max(x2, x3, x4, x5);
    return x1 > tmp ? x1 : tmp;
}
EXMAT_INLINE2 static float max(const float* in, size_t N) {
    return PNS::FUNffpiTable[PNS::FUNffpi_ID::max](in, N);
}

EXMAT_INLINE2 static float sum(const float* in, size_t N) {
    return PNS::FUNffpiTable[PNS::FUNffpi_ID::sum](in, N);
}

EXMAT_INLINE2 static float rcp(float x) {
    return PNS::FUNffTable[PNS::FUNff_ID::rcp](x);
}
EXMAT_INLINE2 static void rcp(const float* in, float* out, size_t N) {
    PNS::FUNvfpfpiTable[PNS::FUNff_ID::rcp](in, out, N);
}


EXMAT_INLINE2 static float sqrt(float x) {
    return PNS::FUNffTable[PNS::FUNff_ID::sqrt](x);
}
EXMAT_INLINE2 static double sqrt(double x) {
    using namespace std;
    return double(VC6_STD_MATH_WKAR::sqrt(x));
}
EXMAT_INLINE2 static void sqrt(const float* in, float* out, size_t N) {
    PNS::FUNvfpfpiTable[PNS::FUNff_ID::sqrt](in, out, N);
}


EXMAT_INLINE2 static float rsqrt(float x) {
    return PNS::FUNffTable[PNS::FUNff_ID::rsqrt](x);
}
EXMAT_INLINE2 static double rsqrt(double x) {
    using namespace std;
    return 1.0 / double(VC6_STD_MATH_WKAR::sqrt(x));
}
EXMAT_INLINE2 static void rsqrt(const float* in, float* out, size_t N) {
    PNS::FUNvfpfpiTable[PNS::FUNff_ID::rsqrt](in, out, N);
}


EXMAT_INLINE2 static float exp(float x) {
    return PNS::FUNffTable[PNS::FUNff_ID::exp](x);
}
EXMAT_INLINE2 static double exp(double x) {
    return double(VC6_STD_MATH_WKAR::exp(x));
}
EXMAT_INLINE2 static void exp(const float* in, float* out, size_t N) {
    PNS::FUNvfpfpiTable[PNS::FUNff_ID::exp](in, out, N);
}


EXMAT_INLINE2 static float log(float x) {
    return PNS::FUNffTable[PNS::FUNff_ID::log](x);
}
EXMAT_INLINE2 static double log(double x) {
    return double(VC6_STD_MATH_WKAR::log(x));
}
EXMAT_INLINE2 static void log(const float* in, float* out, size_t N) {
    PNS::FUNvfpfpiTable[PNS::FUNff_ID::log](in, out, N);
}


EXMAT_INLINE2 static float pow(float x, float y) {
    return PNS::FUNfffTable[PNS::FUNfff_ID::pow](x, y);
}
EXMAT_INLINE2 static double pow(double x, double y) {
    return double(VC6_STD_MATH_WKAR::pow(x, y));
}



EXMAT_INLINE2 static float sin(float x) {
    return PNS::FUNffTable[PNS::FUNff_ID::sin](x);
}
EXMAT_INLINE2 static double sin(double x) {
    return double(VC6_STD_MATH_WKAR::sin(x));
}
EXMAT_INLINE2 static void sin(const float* in, float* out, size_t N) {
    PNS::FUNvfpfpiTable[PNS::FUNff_ID::sin](in, out, N);
}

EXMAT_INLINE2 static float cos(float x) {
    return PNS::FUNffTable[PNS::FUNff_ID::cos](x);
}
EXMAT_INLINE2 static double cos(double x) {
    return double(VC6_STD_MATH_WKAR::cos(x));
}
EXMAT_INLINE2 static void cos(const float* in, float* out, size_t N) {
    PNS::FUNvfpfpiTable[PNS::FUNff_ID::cos](in, out, N);
}

EXMAT_INLINE2 static void sincos(float x, float& s, float& c) {
    PNS::FUNvffafaTable[PNS::FUNvffafa_ID::sincos](x, s, c);
}
EXMAT_INLINE2 static void sincos(double x, double& s, double& c) {
    s = VC6_STD_MATH_WKAR::sin(x);
    c = VC6_STD_MATH_WKAR::sin(c);
}

EXMAT_INLINE2 static float tan(float x) {
    return PNS::FUNffTable[PNS::FUNff_ID::tan](x);
}
EXMAT_INLINE2 static double tan(double x) {
    return double(VC6_STD_MATH_WKAR::tan(x));
}
EXMAT_INLINE2 static void tan(const float* in, float* out, size_t N) {
    PNS::FUNvfpfpiTable[PNS::FUNff_ID::tan](in, out, N);
}

EXMAT_INLINE2 static float asin(float x) {
    return PNS::FUNffTable[PNS::FUNff_ID::asin](x);
}
EXMAT_INLINE2 static double asin(double x) {
    return double(VC6_STD_MATH_WKAR::asin(x));
}
EXMAT_INLINE2 static void asin(const float* in, float* out, size_t N) {
    PNS::FUNvfpfpiTable[PNS::FUNff_ID::asin](in, out, N);
}

EXMAT_INLINE2 static float acos(float x) {
    return PNS::FUNffTable[PNS::FUNff_ID::acos](x);
}
EXMAT_INLINE2 static double acos(double x) {
    return double(VC6_STD_MATH_WKAR::acos(x));
}
EXMAT_INLINE2 static void acos(const float* in, float* out, size_t N) {
    PNS::FUNvfpfpiTable[PNS::FUNff_ID::acos](in, out, N);
}

EXMAT_INLINE2 static float atan(float x) {
    return PNS::FUNffTable[PNS::FUNff_ID::atan](x);
}
EXMAT_INLINE2 static double atan(double x) {
    return double(VC6_STD_MATH_WKAR::atan(x));
}
EXMAT_INLINE2 static void atan(const float* in, float* out, size_t N) {
    PNS::FUNvfpfpiTable[PNS::FUNff_ID::atan](in, out, N);
}


};  // namespace Math


template<class Rep1, class Rep2, class ErrChk1, class ErrChk2> EXMAT_INLINE0 bool
isEqual(const Mat<Rep1,ErrChk1>& mat1, const Mat<Rep2,ErrChk2>& mat2, double eps=1e-6) {
    typedef typename TypeTraits<TTYPENAME Rep1::value_type, TTYPENAME Rep2::value_type>::HigherValue value_type;
    typedef typename Rep1::index_type index_type;
    // Check for same dimension
    if(mat1.rows() != mat2.rows() || mat1.cols() != mat2.cols())
        return false;
    for(index_type i=0; i<mat1.rows(); ++i) for(index_type j=0; j<mat1.cols(); ++j) {
        if(Math::abs(mat1.getAt(i,j) - mat2.getAt(i,j)) > eps)
            return false;
    }
    return true;
}


}   // namespace exmat

#ifdef _MSC_VER
#   pragma warning( pop )
#endif  // _MSC_VER

#ifdef VC6_STD_MATH_WKAR
#   undef VC6_STD_MATH_WKAR
#endif

#endif  // EXMAT_MATH_UTILITY_H

---