AuvMath.h

Go to the documentation of this file.

#ifndef AUVMATH_H_
#define AUVMATH_H_

#include <math.h>
#include "data/Point3D.h"
#include "data/Matrix3x3.h"

#ifndef M_2PI
#   define M_2PI       (6.28318530717958647692)
#endif

#ifndef M_1_2PI
#   define M_1_2PI     (0.15915494309189533577)
#endif

#ifndef UINT16_MAX
#   define UINT16_MAX  (65535)
#endif

#ifndef UINT32_MAX
#   define UINT32_MAX (4294967295U)
#endif

#ifndef D2R
#define D2R(x) ( ( x ) * M_PI / 180.0 )
#endif

#define R2D(x) ( ( x ) * 180.0 / M_PI)

#ifndef MIN
#   define MIN(a,b) ( ( ( a ) != ( a ) || ( a ) <= ( b ) ) ? ( a ) :  ( b ) != ( b ) || ( a ) > ( b ) ? ( b ) : ( a ) )
#endif

#ifndef MAX
#   define MAX(a,b) ( ( ( a ) != ( a ) ||  ( a ) >= ( b ) ) ? ( a ) : ( b ) != ( b ) || ( a ) < ( b ) ? ( b ) : ( a ) )
#endif

class AuvMath
{
public:

    // 2 times pi
    static const double TWOPI = M_PI  * 2.0;
    static const double DEG_TO_RAD;
    static const double RAD_TO_DEG;

    template <typename T>
    static T Limit( const T& value, const T& limit1, const T& limit2 );

    template <typename T>
    static bool InLimit( const T& value, const T& limit1, const T& limit2 );

    template <typename T>
    inline static T Min( const T& a, const T& b )
    {
        return MIN( a, b );
    }

    template <typename T>
    inline static T Max( const T& a, const T& b )
    {
        return MAX( a, b );
    }

    template <typename T>
    static T Square( T number )
    {
        return number * number;
    }

    template <typename T>
    inline static void Swap( T& a, T& b )
    {
        T t( a );
        a = b;
        b = t;
    }

    template<typename T>
    static T FlipEndian( T value );

    template <typename T>
    static T Round( const T& value, const T& divisor );

    template <typename T>
    static T Sign( const T& x );

    template <typename T>
    static T ModPi( const T& angle );

    template <typename T>
    static T NanZero( const T& value );

    template <typename T>
    static int FindLtEqIndex( const T* values, const T& value,
                              const unsigned int indexMin, const unsigned int indexMax );

    template <typename T>
    static T Interpolate1D( const T& x, const T& data0, const T& data1,
                            const T& x0, const T& x1 );

    template <typename T>
    static T Interpolate2D( const T& x, const T& y, T data[][ 2 ],
                            const T& x0, const T& x1, const T& y0, const T& y1 );

    template <typename T>
    static T Interpolate3D( const T& x, const T& y, const T& z,
                            T data[][ 2 ][ 2 ],
                            const T& x0, const T& x1,
                            const T& y0, const T& y1,
                            const T& z0, const T& z1 );

    template <typename T>
    static T Interpolate4D( const T& w, const T& x, const T& y,
                            const T& z, T data[][ 2 ][ 2 ][ 2 ],
                            const T& w0, const T& w1,
                            const T& x0, const T& x1,
                            const T& y0, const T& y1,
                            const T& z0, const T& z1 );

    static double BulkModulus( double salinity, double temperature, double pressure );

    static double Density( double salinity, double temperature, double pressure );

    static double OceanDepth( const double& pressure, const double& latitude );

    static double OceanPressure( const double& depth, const double& latitude );

    //
    // Simple sort routine, invented by Donald Shell 1959. It is 0(n^2).
    // The code is short, and appropriate for small arrays here.
    //
    template <typename T>
    static void ShellSort( T array[], int arraySize )
    {
        int i, j, increment;
        T temp;

        increment = 3;
        while( increment > 0 )
        {
            for( i = 0; i < arraySize; i++ )
            {
                j = i;
                temp = array[i];
                while( ( j >= increment ) && ( array[j - increment] > temp ) )
                {
                    array[j] = array[j - increment];
                    j = j - increment;
                }
                array[j] = temp;
            }
            if( increment / 2 != 0 )
                increment = increment / 2;
            else if( increment == 1 )
                increment = 0;
            else
                increment = 1;
        }
    }

    static bool AreaContains( float x, float y, int segments,
                              float* x0, float* y0, float* x1, float* y1 );

    static bool TriangleContains( float x, float y,
                                  float x0, float y0, float x1, float y1,
                                  float x2, float y2 );

    static void UnitVectorToAzimuthAndElevation( Point3D &uhat, float &azimuth, float &elevation );

    static void AzimuthAndElevationToUnitVector( float &azimuth, float &elevation, Point3D &uhat );

};

#endif /*AUVMATH_H_*/