mm.h

Go to the documentation of this file.

/*
 * $Id: mm.h,v 1.5 2003/09/05 04:20:11 jmk Exp $
 */
///////////////////////////////////////////////////////////////////////////
//              _____________  ______________________    __   __  _____
//             /  ________  |  |   ___   ________   /   |  \ /  \   |
//            |  |       |  |_ |  |_ |  |       /  /    \__  |      |
//            |  |  ___  |  || |  || |  |      /  /        | |      |
//            |  | |   \ |  || |  || |  |     /  /      \__/ \__/ __|__
//            |  | |_@  ||  || |  || |  |    /  /          Institute
//            |  |___/  ||  ||_|  || |  |   /  /_____________________
//             \_______/  \______/ | |__|  /___________________________
//                        |  |__|  |
//                         \______/
//                    University of Utah       
//                           2002
///////////////////////////////////////////////////////////////////////////

#ifndef mm_h
#define mm_h

#define __win32 WIN32

#if __sgi
#include <math.h>
#include <float.h>
#include <assert.h>
#else
#include <cassert>
#include <cmath>
#include <cfloat>
#endif
#include <string>
//#if __win32
//#include <windows.h>
//#endif

#include <sstream>
// type shorthand
typedef unsigned char   uchar;
typedef unsigned char   ubyte;
typedef unsigned short  ushort;
typedef unsigned int    uint;
typedef unsigned long   ulong;
#if __win32
typedef __int64 llong;
typedef unsigned __int64 ullong;
#else // __real_os
typedef long long llong;
typedef unsigned long long ullong;
#endif // __win32

namespace gutz{ 

#if __win32
#if VC6 
// these are missing from math.h
#define M_E        2.71828182845904523536 
#define M_LOG2E    1.44269504088896340736 
#define M_LOG10E   0.434294481903251827651 
#define M_LN2      0.693147180559945309417 
#define M_LN10     2.30258509299404568402 
#define M_PI       3.14159265358979323846 
#define M_PI_2     1.57079632679489661923 
#define M_PI_4     0.785398163397448309616 
#define M_1_PI     0.318309886183790671538 
#define M_2_PI     0.636619772367581343076 
#define M_2_SQRTPI 1.12837916709551257390 
#define M_SQRT2    1.41421356237309504880 
#define M_SQRT1_2  0.707106781186547524401 
// and these are screwed up
#define mm_abs(x) ((x < 0 ? -x : x))

#else // VC7
#define mm_abs(x) ((x < 0 ? -x : x))
#endif // VC6
// some useful functions
#define cbrt(x) pow((x), 1.0/3.0)
#define drand48() (rand()/(double)RAND_MAX)
#else // __real_os
#define mm_abs(x) ((x < 0 ? -x : x))
#endif // __win32


// a bit better naming
#define MM_EPSF FLT_EPSILON
#define MM_MINF FLT_MIN
#define MM_MAXF FLT_MAX
#define MM_EPSD DBL_EPSILON
#define MM_MIND DBL_MIN
#define MM_MAXD DBL_MAX

// useful macros
#define mm_rad2deg(x) (180.0/M_PI*(x))
#define mm_deg2rad(x) (M_PI/180.0*(x))
#define mm_sgn(x) ((x)>0 ? 1.0 : ((x)<0 ? -1.0 : 0))
#define mm_sq(x) ((x)*(x))

/*
 * cast defines
 */
#ifndef __win32
#define mm_castf2d mm_cast<float,double>
#define mm_castd2f mm_cast<double,float>
#define mm_castf2i mm_cast<float,int>
#define mm_casti2f mm_cast<int,float>
#define mm_castd2i mm_cast<double,int>
#define mm_casti2d mm_cast<int,double>
#endif

// Extra boolean operators
/*template <class T1, class T2>
inline bool xor( T1 a, T2 b ) {
        return( (a || b) && !(a && b) );
}*/

template <class T1, class T2>
inline bool nand( T1 a, T2 b ) {
        return( !( a && b ) );
}

template <class T1, class T2>
inline bool nor( T1 a, T2 b ) {
        return( !( a || b ) );
}

// Bit Operators
// - Many of these are taken from "http://www.sjbaker.org/steve/software/cute_code.html"

// Zero the least signficant '1' be in 'n'
inline uint zeroLeastSigOneBit(uint n) { 
        return (n&(n-1)); 
}

// Is 'n' a power of 2 integer?
// - Zero and One are considered to be powers of two
// - A power-of-two int has only one '1' bit, so zero'ing it should give zero back
inline bool isPowOfTwo(uint n) { 
        return (zeroLeastSigOneBit(n)==0); 
}

// How many 1's are in 'n'?
// This trick was found at:
// http://graphics.stanford.edu/~seander/bithacks.html
inline uint numOnesInWord(unsigned int n) {
        const uint S[] = {1, 2, 4, 8, 16}; // Magic Numbers
        const uint B[] = {0x55555555, 0x33333333, 0x0F0F0F0F, 0x00FF00FF, 0x0000FFFF};

        n = ((n >> S[0]) & B[0]) + (n & B[0]);//Use magic to find out how many 1's are set in this word
        n = ((n >> S[1]) & B[1]) + (n & B[1]);
        n = ((n >> S[2]) & B[2]) + (n & B[2]);
        n = ((n >> S[3]) & B[3]) + (n & B[3]);
        n = ((n >> S[4]) & B[4]) + (n & B[4]);

        return n;
}

// Compute val % pow(2,powOf2) w/out divides
// WARNING: Do NOT use on vals larger than sizeof(uint)!!
inline uint modPowOf2( uint val, uint powOf2 )
{
        unsigned int d = 1 << powOf2; // So d will be one of: 1, 2, 4, 8, 16, 32, ...
        return val & (d - 1); 
}

// Compute (a % b) w/out divides
// WARNING: 'b' MUST be a power of two!!!!!
// WARNING: Do NOT use on vals larger than sizeof(uint)!!
inline uint mod_fast( uint a, uint b )
{
        return a & (b - 1); 
}

// Return lg-base 2 of 'v'
// - If 'v' is power-of-two, 'lg2_fast(v)' is faster
inline uint lg2( uint v )
{
  assert( sizeof(v) == 4 );//Ensure 32-bit integer

  const uint b[] = {0xAAAAAAAA, 0xCCCCCCCC, 0xF0F0F0F0, 0xFF00FF00, 0xFFFF0000};
  const uint S[] = {1, 2, 4, 8, 16};
  int i;

  register uint c = 0;          // result of log2(v) will go here
  for (i = 4; i >= 0; i--)      // unroll for speed... 
  {
    if (v & b[i])
    {
      v >>= S[i];
      c |= S[i];
    } 
  }

  return c;
}

// Return lg-base 2 of 'v'
// - WARNING: 'v' MUST be a power of 2!
// - If 'v' is non-pow-of-two, use 'lg2(v)'      
inline uint lg2_fast( int v )
{
  const uint b[] = {0xAAAAAAAA, 0xCCCCCCCC, 0xF0F0F0F0, 0xFF00FF00, 0xFFFF0000};
        
  register uint c = ((v & b[0]) != 0);
  c |= ((v & b[4]) != 0) << 4;
  c |= ((v & b[3]) != 0) << 3;
  c |= ((v & b[2]) != 0) << 2;
  c |= ((v & b[1]) != 0) << 1;

  return c;
}

#ifdef WIN32 //We have to define this b/c VC++ doesn't have it
        inline double rint( double x ) //Round 'x' to the nearest integer
        {
                return (double)(int)(x + (x<0.0 ? -0.5 : +0.5));
        }
#endif

// minimum of 2 values
template <class T>
inline
T
min2 (const T x, const T y)
{
    return (x <= y ? x : y);
}

#define min2c min2<char>
#define min2uc min2<uchar>
#define min2b min2<char>
#define min2ub min2<uchar>
#define min2s min2<short>
#define min2us min2<ushort>
#define min2i min2<int>
#define min2ui min2<uint>
#define min2l min2<long>
#define min2ul min2<ulong>
#define min2ll min2<llong>
#define min2ull min2<ullong>
#define min2f min2<float>
#define min2d min2<double>

// minimum index of 2 values
template <class T>
inline
int
mini2 (const T x, const T y)
{
    return (x <= y ? 0 : 1);
}

#define mini2c mini2<char>
#define mini2uc mini2<uchar>
#define mini2b mini2<char>
#define mini2ub mini2<uchar>
#define mini2s mini2<short>
#define mini2us mini2<ushort>
#define mini2i mini2<int>
#define mini2ui mini2<uint>
#define mini2l mini2<long>
#define mini2ul mini2<ulong>
#define mini2ll mini2<llong>
#define mini2ull mini2<ullong>
#define mini2f mini2<float>
#define mini2d mini2<double>

// maximum of 2 values
template <class T>
inline
T
max2 (const T x, const T y)
{
    return (x >= y ? x : y);
}

#define max2c max2<char>
#define max2uc max2<uchar>
#define max2b max2<char>
#define max2ub max2<uchar>
#define max2s max2<short>
#define max2us max2<ushort>
#define max2i max2<int>
#define max2ui max2<uint>
#define max2l max2<long>
#define max2ul max2<ulong>
#define max2ll max2<llong>
#define max2ull max2<ullong>
#define max2f max2<float>
#define max2d max2<double>

// maximum index of 2 values
template <class T>
inline
int
maxi2 (const T x, const T y)
{
    return (x >= y ? 0 : 1);
}

#define maxi2c maxi2<char>
#define maxi2uc maxi2<uchar>
#define maxi2b maxi2<char>
#define maxi2ub maxi2<uchar>
#define maxi2s maxi2<short>
#define maxi2us maxi2<ushort>
#define maxi2i maxi2<int>
#define maxi2ui maxi2<uint>
#define maxi2l maxi2<long>
#define maxi2ul maxi2<ulong>
#define maxi2ll maxi2<llong>
#define maxi2ull maxi2<ullong>
#define maxi2f maxi2<float>
#define maxi2d maxi2<double>

// minimum of 3 values
template <class T>
inline
T
min3 (const T x, const T y, const T z)
{
    return (x <= y ?
            (x <= z ? x : z) : 
            (y <= z ? y : z));
}

#define min3c min3<char>
#define min3uc min3<uchar>
#define min3b min3<char>
#define min3ub min3<uchar>
#define min3s min3<short>
#define min3us min3<ushort>
#define min3i min3<int>
#define min3ui min3<uint>
#define min3l min3<long>
#define min3ul min3<ulong>
#define min3ll min3<llong>
#define min3ull min3<ullong>
#define min3f min3<float>
#define min3d min3<double>

// minimum index of 3 values
template <class T>
inline
int
mini3 (const T x, const T y, const T z)
{
    return (x <= y ? 
            (x <= z ? 0 : 2) : 
            (y <= z ? 1 : 2));
}

#define mini3c mini3<char>
#define mini3uc mini3<uchar>
#define mini3b mini3<char>
#define mini3ub mini3<uchar>
#define mini3s mini3<short>
#define mini3us mini3<ushort>
#define mini3i mini3<int>
#define mini3ui mini3<uint>
#define mini3l mini3<long>
#define mini3ul mini3<ulong>
#define mini3ll mini3<llong>
#define mini3ull mini3<ullong>
#define mini3f mini3<float>
#define mini3d mini3<double>

// maximum of 3 values
template <class T>
inline
T
max3 (const T x, const T y, const T z)
{
    return (x >= y ? 
            (x >= z ? x : z) : 
            (y >= z ? y : z));
}

#define max3c max3<char>
#define max3uc max3<uchar>
#define max3b max3<char>
#define max3ub max3<uchar>
#define max3s max3<short>
#define max3us max3<ushort>
#define max3i max3<int>
#define max3ui max3<uint>
#define max3l max3<long>
#define max3ul max3<ulong>
#define max3ll max3<llong>
#define max3ull max3<ullong>
#define max3f max3<float>
#define max3d max3<double>

// maximum index of 3 values
template <class T>
inline
int
maxi3 (const T x, const T y, const T z)
{
    return (x >= y ? 
            (x >= z ? 0 : 2) : 
            (y >= z ? 1 : 2));
}

#define maxi3c maxi3<char>
#define maxi3uc maxi3<uchar>
#define maxi3b maxi3<char>
#define maxi3ub maxi3<uchar>
#define maxi3s maxi3<short>
#define maxi3us maxi3<ushort>
#define maxi3i maxi3<int>
#define maxi3ui maxi3<uint>
#define maxi3l maxi3<long>
#define maxi3ul maxi3<ulong>
#define maxi3ll maxi3<llong>
#define maxi3ull maxi3<ullong>
#define maxi3f maxi3<float>
#define maxi3d maxi3<double>

// minimum of 4 values
template <class T>
inline
T
min4 (const T x, const T y, const T z, const T w)
{
    return (x <= y ? 
            (x <= z ? 
             (x <= w ? x : w) : 
             (z <= w ? z : w)) : 
            (y <= z ? 
             (y <= w ? y : w) : 
             (z <= w ? z : w)));
}

#define min4c min4<char>
#define min4uc min4<uchar>
#define min4b min4<char>
#define min4ub min4<uchar>
#define min4s min4<short>
#define min4us min4<ushort>
#define min4i min4<int>
#define min4ui min4<uint>
#define min4l min4<long>
#define min4ul min4<ulong>
#define min4ll min4<llong>
#define min4ull min4<ullong>
#define min4f min4<float>
#define min4d min4<double>

// minimum index of 4 values
template <class T>
inline
int
mini4 (const T x, const T y, const T z, const T w)
{
    return (x <= y ? 
            (x <= z ? 
             (x <= w ? 0 : 3) : 
             (z <= w ? 2 : 3)) : 
            (y <= z ? 
             (y <= w ? 1 : 3) 
             : (z <= w ? 2 : 3)));
}

#define mini4c mini4<char>
#define mini4uc mini4<uchar>
#define mini4b mini4<char>
#define mini4ub mini4<uchar>
#define mini4s mini4<short>
#define mini4us mini4<ushort>
#define mini4i mini4<int>
#define mini4ui mini4<uint>
#define mini4l mini4<long>
#define mini4ul mini4<ulong>
#define mini4ll mini4<llong>
#define mini4ull mini4<ullong>
#define mini4f mini4<float>
#define mini4d mini4<double>

// maximum of 4 values
template <class T>
inline
T
max4 (const T x, const T y, const T z, const T w)
{
    return (x >= y ? 
            (x >= z ? 
             (x >= w ? x : w) : 
             (z >= w ? z : w)) : 
            (y >= z ? 
             (y >= w ? y : w) : 
             (z >= w ? z : w)));
}

#define max4c max4<char>
#define max4uc max4<uchar>
#define max4b max4<char>
#define max4ub max4<uchar>
#define max4s max4<short>
#define max4us max4<ushort>
#define max4i max4<int>
#define max4ui max4<uint>
#define max4l max4<long>
#define max4ul max4<ulong>
#define max4ll max4<llong>
#define max4ull max4<ullong>
#define max4f max4<float>
#define max4d max4<double>

// maximum index of 4 values
template <class T>
inline
int
maxi4 (const T x, const T y, const T z, const T w)
{
    return (x >= y ? 
            (x >= z ? 
             (x >= w ? 0 : 3) : 
             (z >= w ? 2 : 3)) : 
            (y >= z ? 
             (y >= w ? 1 : 3) 
             : (z >= w ? 2 : 3)));
}

#define maxi4c maxi4<char>
#define maxi4uc maxi4<uchar>
#define maxi4b maxi4<char>
#define maxi4ub maxi4<uchar>
#define maxi4s maxi4<short>
#define maxi4us maxi4<ushort>
#define maxi4i maxi4<int>
#define maxi4ui maxi4<uint>
#define maxi4l maxi4<long>
#define maxi4ul maxi4<ulong>
#define maxi4ll maxi4<llong>
#define maxi4ull maxi4<ullong>
#define maxi4f maxi4<float>
#define maxi4d maxi4<double>

// minimum of 5 values
template <class T>
inline
T
min5 (T x, T y, T z, T w, T u)
{
    return (x <= y ? 
            (x <= z ? 
             (x <= w ? 
              (x <= u ? x : u) : 
              (w <= u ? w : u)) :
             (z <= w ? 
              (z <= u ? z : u) :
              (w <= u ? w : u))) : 
            (y <= z ? 
             (y <= w ? 
              (y <= u ? y : u) : 
              (w <= u ? w : u)) :
             (z <= w ? 
              (z <= u ? z : u) :
              (w <= u ? w : u))));
}

#define min5c min5<char>
#define min5uc min5<uchar>
#define min5b min5<char>
#define min5ub min5<uchar>
#define min5s min5<short>
#define min5us min5<ushort>
#define min5i min5<int>
#define min5ui min5<uint>
#define min5l min5<long>
#define min5ul min5<ulong>
#define min5ll min5<llong>
#define min5ull min5<ullong>
#define min5f min5<float>
#define min5d min5<double>

// minimum index of 5 values
template <class T>
inline
int
mini5 (T x, T y, T z, T w, T u)
{
    return (x <= y ? 
            (x <= z ? 
             (x <= w ? 
              (x <= u ? 0 : 4) : 
              (w <= u ? 3 : 4)) :
             (z <= w ? 
              (z <= u ? 2 : 4) :
              (w <= u ? 3 : 4))) : 
            (y <= z ? 
             (y <= w ? 
              (y <= u ? 1 : 4) : 
              (w <= u ? 3 : 4)) :
             (z <= w ? 
              (z <= u ? 2 : 4) :
              (w <= u ? 3 : 4))));
}

#define mini5c mini5<char>
#define mini5uc mini5<uchar>
#define mini5b mini5<char>
#define mini5ub mini5<uchar>
#define mini5s mini5<short>
#define mini5us mini5<ushort>
#define mini5i mini5<int>
#define mini5ui mini5<uint>
#define mini5l mini5<long>
#define mini5ul mini5<ulong>
#define mini5ll mini5<llong>
#define mini5ull mini5<ullong>
#define mini5f mini5<float>
#define mini5d mini5<double>

// maximum of 5 values
template <class T>
inline
T
max5 (T x, T y, T z, T w, T u)
{
    return (x >= y ? 
            (x >= z ? 
             (x >= w ? 
              (x >= u ? x : u) : 
              (w >= u ? w : u)) :
             (z >= w ? 
              (z >= u ? z : u) :
              (w >= u ? w : u))) : 
            (y >= z ? 
             (y >= w ? 
              (y >= u ? y : u) : 
              (w >= u ? w : u)) :
             (z >= w ? 
              (z >= u ? z : u) :
              (w >= u ? w : u))));
}

#define max5c max5<char>
#define max5uc max5<uchar>
#define max5b max5<char>
#define max5ub max5<uchar>
#define max5s max5<short>
#define max5us max5<ushort>
#define max5i max5<int>
#define max5ui max5<uint>
#define max5l max5<long>
#define max5ul max5<ulong>
#define max5ll max5<llong>
#define max5ull max5<ullong>
#define max5f max5<float>
#define max5d max4<double>

// maximum index of 5 values
template <class T>
inline
int
maxi5 (T x, T y, T z, T w, T u)
{
    return (x >= y ? 
            (x >= z ? 
             (x >= w ? 
              (x >= u ? 0 : 4) : 
              (w >= u ? 3 : 4)) :
             (z >= w ? 
              (z >= u ? 2 : 4) :
              (w >= u ? 3 : 4))) : 
            (y >= z ? 
             (y >= w ? 
              (y >= u ? 1 : 4) : 
              (w >= u ? 3 : 4)) :
             (z >= w ? 
              (z >= u ? 2 : 4) :
              (w >= u ? 3 : 4))));
}

#define maxi5c maxi5<char>
#define maxi5uc maxi5<uchar>
#define maxi5b maxi5<char>
#define maxi5ub maxi5<uchar>
#define maxi5s maxi5<short>
#define maxi5us maxi5<ushort>
#define maxi5i maxi5<int>
#define maxi5ui maxi5<uint>
#define maxi5l maxi5<long>
#define maxi5ul maxi5<ulong>
#define maxi5ll maxi5<llong>
#define maxi5ull maxi5<ullong>
#define maxi5f maxi5<float>
#define maxi5d maxi5<double>

// minimum of 6 values
template <class T>
inline
T
min6 (T x, T y, T z, T w, T u, T v)
{
    return (x <= y ? 
            (x <= z ? 
             (x <= w ? 
              (x <= u ? 
               (x <= v ? x : v) : 
               (u <= v ? u : v)) :
              (w <= u ? 
               (w <= v ? w : v) : 
               (u <= v ? u : v))) :
            (y <= z ? 
             (y <= w ? 
              (y <= u ? 
               (y <= v ? y : v) : 
               (u <= v ? u : v)) :
              (w <= u ? 
               (w <= v ? w : v) : 
               (u <= v ? u : v))) :
             (z <= w ? 
              (z <= u ? 
               (z <= v ? z : v) : 
               (u <= v ? u : v)) :
              (w <= u ? 
               (w <= v ? w : v) : 
               (u <= v ? u : v))))) :
            (y <= z ? 
             (y <= w ? 
              (y <= u ? 
               (y <= v ? y : v) : 
               (u <= v ? u : v)) :
              (w <= u ? 
               (w <= v ? w : v) : 
               (u <= v ? u : v))) :

             (z <= w ? 
              (z <= u ? 
               (z <= v ? z : v) : 
               (u <= v ? u : v)) :
              (w <= u ? 
               (w <= v ? w : v) : 
               (u <= v ? u : v)))));
}

#define min6c min6<char>
#define min6uc min6<uchar>
#define min6b min6<char>
#define min6ub min6<uchar>
#define min6s min6<short>
#define min6us min6<ushort>
#define min6i min6<int>
#define min6ui min6<uint>
#define min6l min6<long>
#define min6ul min6<ulong>
#define min6ll min6<llong>
#define min6ull min6<ullong>
#define min6f min6<float>
#define min6d min6<double>

// minimum index of 6 values
template <class T>
inline
int
mini6 (T x, T y, T z, T w, T u, T v)
{
    return (x <= y ? 
            (x <= z ? 
             (x <= w ? 
              (x <= u ? 
               (x <= v ? 0 : 5) : 
               (u <= v ? 4 : 5)) :
              (w <= u ? 
               (w <= v ? 3 : 5) : 
               (u <= v ? 4 : 5))) :
            (y <= z ? 
             (y <= w ? 
              (y <= u ? 
               (y <= v ? 1 : 5) : 
               (u <= v ? 4 : 5)) :
              (w <= u ? 
               (w <= v ? 3 : 5) : 
               (u <= v ? 4 : 5))) :
             (z <= w ? 
              (z <= u ? 
               (z <= v ? 2 : 5) : 
               (u <= v ? 4 : 5)) :
              (w <= u ? 
               (w <= v ? 3 : 5) : 
               (u <= v ? 4 : 5))))) :
            (y <= z ? 
             (y <= w ? 
              (y <= u ? 
               (y <= v ? 1 : 5) : 
               (u <= v ? 4 : 5)) :
              (w <= u ? 
               (w <= v ? 3 : 5) : 
               (u <= v ? 4 : 5))) :

             (z <= w ? 
              (z <= u ? 
               (z <= v ? 2 : 5) : 
               (u <= v ? 4 : 5)) :
              (w <= u ? 
               (w <= v ? 3 : 5) : 
               (u <= v ? 4 : 5)))));
}

#define mini6c   mini6<char>
#define mini6uc  mini6<uchar>
#define mini6b   mini6<char>
#define mini6ub  mini6<uchar>
#define mini6s   mini6<short>
#define mini6us  mini6<ushort>
#define mini6i   mini6<int>
#define mini6ui  mini6<uint>
#define mini6l   mini6<long>
#define mini6ul  mini6<ulong>
#define mini6ll  mini6<llong>
#define mini6ull mini6<ullong>
#define mini6f   mini6<float>
#define mini6d   mini6<double>

// maximum of 6 values
template <class T>
inline
T
max6 (T x, T y, T z, T w, T u, T v)
{
    return (x >= y ? 
            (x >= z ? 
             (x >= w ? 
              (x >= u ? 
               (x >= v ? x : v) : 
               (u >= v ? u : v)) :
              (w >= u ? 
               (w >= v ? w : v) : 
               (u >= v ? u : v))) :
            (y >= z ? 
             (y >= w ? 
              (y >= u ? 
               (y >= v ? y : v) : 
               (u >= v ? u : v)) :
              (w >= u ? 
               (w >= v ? w : v) : 
               (u >= v ? u : v))) :
             (z >= w ? 
              (z >= u ? 
               (z >= v ? z : v) : 
               (u >= v ? u : v)) :
              (w >= u ? 
               (w >= v ? w : v) : 
               (u >= v ? u : v))))) :
            (y >= z ? 
             (y >= w ? 
              (y >= u ? 
               (y >= v ? y : v) : 
               (u >= v ? u : v)) :
              (w >= u ? 
               (w >= v ? w : v) : 
               (u >= v ? u : v))) :

             (z >= w ? 
              (z >= u ? 
               (z >= v ? z : v) : 
               (u >= v ? u : v)) :
              (w >= u ? 
               (w >= v ? w : v) : 
               (u >= v ? u : v)))));
}

#define max6c max6<char>
#define max6uc max6<uchar>
#define max6b max6<char>
#define max6ub max6<uchar>
#define max6s max6<short>
#define max6us max6<ushort>
#define max6i max6<int>
#define max6ui max6<uint>
#define max6l max6<long>
#define max6ul max6<ulong>
#define max6ll max6<llong>
#define max6ull max6<ullong>
#define max6f max6<float>
#define max6d max6<double>

// maximum index of 6 values
template <class T>
inline
int
maxi6 (T x, T y, T z, T w, T u, T v)
{
    return (x >= y ? 
            (x >= z ? 
             (x >= w ? 
              (x >= u ? 
               (x >= v ? 0 : 5) : 
               (u >= v ? 4 : 5)) :
              (w >= u ? 
               (w >= v ? 3 : 5) : 
               (u >= v ? 4 : 5))) :
            (y >= z ? 
             (y >= w ? 
              (y >= u ? 
               (y >= v ? 1 : 5) : 
               (u >= v ? 4 : 5)) :
              (w >= u ? 
               (w >= v ? 3 : 5) : 
               (u >= v ? 4 : 5))) :
             (z >= w ? 
              (z >= u ? 
               (z >= v ? 2 : 5) : 
               (u >= v ? 4 : 5)) :
              (w >= u ? 
               (w >= v ? 3 : 5) : 
               (u >= v ? 4 : 5))))) :
            (y >= z ? 
             (y >= w ? 
              (y >= u ? 
               (y >= v ? 1 : 5) : 
               (u >= v ? 4 : 5)) :
              (w >= u ? 
               (w >= v ? 3 : 5) : 
               (u >= v ? 4 : 5))) :

             (z >= w ? 
              (z >= u ? 
               (z >= v ? 2 : 5) : 
               (u >= v ? 4 : 5)) :
              (w >= u ? 
               (w >= v ? 3 : 5) : 
               (u >= v ? 4 : 5)))));
}

#define maxi6c maxi6<char>
#define maxi6uc maxi6<uchar>
#define maxi6b maxi6<char>
#define maxi6ub maxi6<uchar>
#define maxi6s maxi6<short>
#define maxi6us maxi6<ushort>
#define maxi6i maxi6<int>
#define maxi6ui maxi6<uint>
#define maxi6l maxi6<long>
#define maxi6ul maxi6<ulong>
#define maxi6ll maxi6<llong>
#define maxi6ull maxi6<ullong>
#define maxi6f maxi6<float>
#define maxi6d maxi6<double>

// NaN
inline
float
nanf ()
{
    char b[4];
#if __sgi
    b[0] = (char)0x7f;
    b[1] = (char)0xc0;
    b[2] = 0;
    b[3] = 0;    
#else
    b[0] = 0;
    b[1] = 0;
    b[2] = (char)0xc0;
    b[3] = (char)0x7f;
#endif
    return *((float*)b);
}

// check for NaN
template <class T>
inline
bool
isnan (T x)
{
    return x - x;
}

#define isnanf isnan<float>
#define isnand isnan<double>

// string conversion routines
template <class T>
bool
str2 (const std::string& s, T* v, int n = 1)
{
    std::istringstream z(s);
    bool status = false;
    int i = 0;
    while (i < n && !status)
    {
        status = status || z.eof();
        z >> v[i];
        status = status || z.fail();
        i++;
    }
    return status;
}

template <class T>
bool
str2 (const std::string* s, T* v, int n = 1)
{
    if (!s) return true;
    return str2<T>(*s, v, n);
}

#define str2c str2<char>
#define str2uc str2<uchar>
#define str2b str2<char>
#define str2ub str2<uchar>
#define str2s str2<short>
#define str2us str2<ushort>
#define str2i str2<int>
#define str2ui str2<uint>
#define str2l str2<long>
#define str2ul str2<ulong>
#define str2ll str2<llong>
#define str2ull str2<ullong>
#define str2f str2<float>
#define str2d str2<double>

// integer exponential
inline
int
expi (int base, int exp)
{
    int i = 1;
    for (int j = 0; j<exp; j++)
        i *= base;
    return i;
}

// integer logarithm
inline
int
logi (int base, int num)
{
    int i = 0;
    while (num > 1)
    {
        num /= base;
        i++;
    }
    return i;
}

} // End of namespace gutz
#endif // mm_h

---

Send questions, comments, and bug reports to: