functions.H

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_MATH_FUNCTIONS_H
#define ARCHON_MATH_FUNCTIONS_H

#include <cmath>

namespace Archon
{
  namespace Math
  {
    template<typename T> inline T clamp(T v, T l, T h)
    {
      return v < l ? l : v > h ? h : v;
    }

    template<typename T> inline T modulo(T x, T m);

    template<typename T> inline T modulo(T x, T m, long &n);

    template<typename T>
    inline T sq(T v)
    {
      return v*v;
    }

    template<typename T>
    inline T inv(T v)
    {
      return 1/v;
    }

    template<typename T>
    inline T length(T x, T y)
    {
      return sqrt(sq(x) + sq(y));
    }

    template<typename T>
    inline T angle(T x, T y)
    {
      if(x==0) return y==0 ? 0 : y>0 ? M_PI/2 : 3*M_PI/2;
      double a = atan(y/x);
      return x < 0 ? M_PI + a : y < 0 ? 2*M_PI + a : a;
    }

    template<typename T>
    inline T linInterp(double x, double x1, double x2, T y1, T y2)
    {
      return y1 + (y2-y1)*(x-x1)/(x2-x1);
    }

    template<typename T>
    void sort3(T x0, T x1, T x2, int &i0, int &i1, int &i2)
    {
      if(x1 > x0)
      {
        if(x2 > x1)      { i0 = 2; i1 = 1; i2 = 0; }
        else if(x2 > x0) { i0 = 1; i1 = 2; i2 = 0; }
        else             { i0 = 1; i1 = 0; i2 = 2; }
      }
      else
      {
        if(x2 > x0)      { i0 = 2; i1 = 0; i2 = 1; }
        else if(x2 > x1) { i0 = 0; i1 = 2; i2 = 1; }
        else             { i0 = 0; i1 = 1; i2 = 2; }
      }
    }


    template<> inline short modulo(short x, short m)
    {
      if(x<0 || x>=m) { x%=m; if(x<0) x+=m; }
      return x;
    }

    template<> inline int modulo(int x, int m)
    {
      if(x<0 || x>=m) { x%=m; if(x<0) x+=m; }
      return x;
    }

    template<> inline long modulo(long x, long m)
    {
      if(x<0 || x>=m) { x%=m; if(x<0) x+=m; }
      return x;
    }

    template<> inline float modulo(float x, float m)
    {
      if(0<=x && x<m) return x;
      x=fmodf(x, m);
      if(x<0) x+=m;
      // Prevent numeric instability from breaking 0 <= x < m.
      return 0<=x && x<m ? x : 0;
    }

    template<> inline double modulo(double x, double m)
    {
      if(0<=x && x<m) return x;
      x=fmod(x, m);
      if(x<0) x+=m;
      // Prevent numeric instability from breaking 0 <= x < m.
      return 0<=x && x<m ? x : 0;
    }

    template<> inline long double modulo(long double x, long double m)
    {
      if(0<=x && x<m) return x;
      x=fmodl(x, m);
      if(x<0) x+=m;
      // Prevent numeric instability from breaking 0 <= x < m.
      return 0<=x && x<m ? x : 0;
    }

    template<> inline short modulo(short x, short m, long &n)
    {
      if(x<0 || x>=m)
      {
        div_t d = div(x, m);
        x = d.rem;
        n = d.quot;
        if(x<0)
        {
          x+=m;
          --n;
        }
      }
      else n = 0;
      return x;
    }

    template<> inline int modulo(int x, int m, long &n)
    {
      if(x<0 || x>=m)
      {
        div_t d = div(x, m);
        x = d.rem;
        n = d.quot;
        if(x<0)
        {
          x+=m;
          --n;
        }
      }
      else n = 0;
      return x;
    }

    template<> inline long modulo(long x, long m, long &n)
    {
      if(x<0 || x>=m)
      {
        ldiv_t d = ldiv(x, m);
        x = d.rem;
        n = d.quot;
        if(x<0)
        {
          x+=m;
          --n;
        }
      }
      else n = 0;
      return x;
    }

    template<> inline float modulo(float x, float m, long &n)
    {
      // Be sure not to break  0 <= x < m.
      float y = modulo(x, m);
      n = static_cast<long>((x-y)/m + 0.5);
      return y;
    }

    template<> inline double modulo(double x, double m, long &n)
    {
      // Be sure not to break  0 <= x < m.
      double y = modulo(x, m);
      n = static_cast<long>((x-y)/m + 0.5);
      return y;
    }

    template<> inline long double modulo(long double x, long double m, long &n)
    {
      // Be sure not to break  0 <= x < m.
      long double y = modulo(x, m);
      n = static_cast<long>((x-y)/m + 0.5);
      return y;
    }


  }
}

#endif // ARCHON_MATH_FUNCTIONS_H

---