base_funcs2.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2004 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/

#ifndef BASE_FUNCS2_HH
#define BASE_FUNCS2_HH 1

namespace base {



INLINE bool FEQ( fp a, fp b ) { return ABS(a-b) < 0.001; }
INLINE bool FNE( fp a, fp b ) { return ABS(a-b) > 0.001; }
INLINE bool FEQ_FLOAT_LARGE( fp f ) { return ABS(f-FLOAT_LARGE) < 100.0; }
INLINE bool FEQ_FLOAT_SMALL( fp f ) { return ABS(f-FLOAT_SMALL) < 100.0; }

template<typename FP>
bool
FEQ( const FP a, const FP b )
{
    const FP diff = a - b;
    const FP scale = 1000.0;
    const uint64 tolerance = 5;  // 5 = 1000.0 * 0.005
    return uint64(ABS(diff * scale)) <= tolerance;
}

template<typename FP>
bool
FEQ( const FP a, const FP b, const uint fracDigits )
{
    const FP diff = a - b;
    const FP scale = pow( double(10.0), double(fracDigits) );
    const uint64 tolerance = uint64(scale * 0.005);
    return uint64(ABS(diff * scale)) <= tolerance;
}

INLINE int
Clamp( int i, int limit )
{
    if ( UX( i < 0 ) )
        return 0;
    else if ( UX( i > limit ) )
        return limit;
    else
        return i;
}

INLINE uint8
ClampFF( uint i )
{
    // gcc 4.x does inline an optimal x86 CMOV instruction.
    if ( EX(i < 0xff) )
        return uint8(i);
    else
        return 0xff;
}

INLINE uint8
ClampFF( int i )
{
    if ( i < 0 )
        return 0;
    else if ( i > 0xff )
        return 0xff;
    else
        return uint8(i);
}

INLINE uint8
ClampFF( fp f )
{
    if ( f >= 1.0 )
        return 0xff;
    else if ( f < 0.0 )
        return 0;
    else
        return uint8( f * 256.0 );
}

INLINE fp
Clamp1( fp f )
{
    if ( UX(f < 0.0) )
        return 0.0;
    else if ( UX(f > 1.0) )
        return 1.0;
    else
        return f;
}

INLINE fp
Clamp( fp f, fp low = 0.0, fp high = 1.0 )
{
    if ( UX( f < low ) )
        return low;
    else if ( UX( f > high ) )
        return high;
    else
        return f;
}

INLINE fp
PrintableMegabyte( const long bytes )
{
    // One fractional digit.
    return fp(long(bytes*10) / long(MEGABYTE)) / fp(10.0);
}


template<typename T>       T*       PTR(       vector<T>& v ) { return &v[0]; }
template<typename T> const T* CONST_PTR( const vector<T>& v ) { return &v[0]; } 

template<typename SEQCONT>
void Expand( SEQCONT& seqcont, uint idx )
{
ASSERT2( idx < MAX_ELEMS );

    // Be careful, resize() can implode a container too.
    if ( UX( idx >= seqcont.size() ) )
        seqcont.resize( idx + 1 );  // one more than index
}

template<typename T>
void
Remove( vector<T>& container, T item )  // STL vector
{
    // erase/remove idiom for STL vectors or deques.  erase() returns nothing.
    container.erase( std::remove( container.begin(), container.begin(), item ),
                     container.end() );
}

template<typename T>
void
Remove( deque<T>& container, T item )  // STL deque
{
    container.erase( std::remove( container.begin(), container.begin(), item ),
                     container.end() );
}

template<typename T>
void
Remove( list<T>& container, T item )  // STL list
{
    container.remove( item );
}

template<typename KEY>
void
Remove( set<KEY>& container, KEY item )  // STL set
{
    container.erase( item );
}

template<typename KEY,typename VAL>
void
Remove( map<KEY,VAL>& container, VAL item )  // STL map
{
    container.erase( item );
}

template<typename CONTAINER>
bool
IfDuplicate( const CONTAINER& c1, const CONTAINER& c2 )
{
    for ( typename CONTAINER::const_iterator i1 = c1.begin(); i1 != c1.end(); ++i1 )
    {
        if ( std::find( c2.begin(), c2.end(), *i1 ) != c2.end() )
            return true;
    }
    return false;
}

} // namespace base

#endif // BASE_FUNCS2_HH

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:06 2007