---

/root/src/subsynth/syn/Util/Math.h

Go to the documentation of this file.

/****************** <SYN heading BEGIN do not edit this line> *****************
 *
 * subsynth - modular audio synthesizer
 * subsynth is (C) Copyright 2001-2002 by Kevin Meinert
 *
 * Original Author: Kevin Meinert
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library 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.
 *
 * -----------------------------------------------------------------
 * File:          $RCSfile: Math.h,v $
 * Date modified: $Date: 2002/04/14 19:55:49 $
 * Version:       $Revision: 1.9 $
 * -----------------------------------------------------------------
 *
 ****************** <SYN heading END do not edit this line> ******************/
#ifndef SYNMATH
#define SYNMATH
#include <assert.h>
#include <math.h>
namespace syn
{
   namespace Math
   {
      struct ADDEQUAL { inline static void oper( float& i, const float o ) { i += o; } };

      struct EQUAL { inline static void oper( float& i, const float o ) { i = o; } };

      struct MULTEQUAL { inline static void oper( float& i, const float o ) { i *= o; } };

      const float PI = 3.14159265358979323846f; //3.14159265358979323846264338327950288419716939937510;
      const float PI_OVER_2 = 1.57079632679489661923f;
      const float PI_OVER_4 = 0.78539816339744830962f;

      //----------------------------------------------------------------------------
      template <class T>
      inline T Min( const T& x, const T& y )
      {
         return ( x > y ) ? y : x;
      }
      template <class T>
      inline T Min( const T& x, const T& y, const T& z )
      {
         return Math::Min( Math::Min( x, y ), z );
      }
      template <class T>
      inline T Min( const T& w, const T& x, const T& y, const T& z )
      {
         return Math::Min( Math::Min( w, x ), Math::Min( y, z ) );
      }

      template <class T>
      inline T Max( const T& x, const T& y )
      {
         return ( x > y ) ? x : y;
      }
      template <class T>
      inline T Max( const T& x, const T& y, const T& z )
      {
         return Math::Max( Math::Max( x, y ), z );
      }
      template <class T>
      inline T Max( const T& w, const T& x, const T& y, const T& z )
      {
         return Math::Max( Math::Max( w, x ), Math::Max( y, z ) );
      }
      template <class T, typename U>
      inline void lerp( T& result, const U& lerp, const T& a, const T& b )
      {
          T size = b - a;
          result = ((U)a) + (((U)size) * lerp);
      }
      //----------------------------------------------------------------------------
      template <class T>
      inline T trunc( T val )
      {
         return T( (val < ((T)0)) ? Math::ceil( val ) : Math::floor( val ) );
      }
      template <class T>
      inline T round( T p )
      {
         return T( Math::floor( p + (T)0.5 ) );
      }
      /*
      inline float unitRandom()
      {
          //return float(random())/float(RAND_MAX);
         float ret_val;
         ret_val = drand48();
         assert( (ret_val >= 0.0f) && (ret_val <= 1.0f) );
         return drand48();
      }
      */

      /*
      inline float rangeRandom( float x1, float x2 )
      {
         float r = Math::unitRandom();
         float size = x2 - x1;
         return float( r * size + x1 );
      }
      */
      //----------------------------------------------------------------------------
      // don't allow non-float types, because their ret val wont be correct
      // i.e. with int, the int retval will be rounded up or down.
      //      we'd need a float retval to do it right, but we can't specialize by ret
      template <typename T>
      inline T aCos( T fValue );
      inline float aCos( float fValue )
      {
          if ( -1.0f < fValue )
          {
              if ( fValue < 1.0f )
                  return float( ::acosf( fValue ) );
              else
                  return 0.0f;
          }
          else
          {
              return (float)Math::PI;
          }
      }
      inline double aCos( double fValue )
      {
          if ( -1.0 < fValue )
          {
              if ( fValue < 1.0 )
                  return double( ::acos( fValue ) );
              else
                  return 0.0;
          }
          else
          {
              return (double)PI;
          }
      }
      //----------------------------------------------------------------------------
      template <typename T>
      inline T aSin( T fValue );
      inline float aSin( float fValue )
      {
          if ( -1.0f < fValue )
          {
              if ( fValue < 1.0f )
                  return float( ::asinf( fValue ) );
              else
                  return (float)-PI_OVER_2;
          }
          else
          {
              return (float)PI_OVER_2;
          }
      }
      inline double aSin( double fValue )
      {
          if ( -1.0 < fValue )
          {
              if ( fValue < 1.0 )
                  return double( ::asin( fValue ) );
              else
                  return (double)-PI_OVER_2;
          }
          else
          {
              return (double)PI_OVER_2;
          }
      }
      template <typename T>
      inline T aTan( T fValue );
      inline float aTan( float fValue )
      {
          return float( ::atanf( fValue ) );
      }
      inline double aTan( double fValue )
      {
          return ::atan( fValue );
      }
      //----------------------------------------------------------------------------
      template <typename T>
      inline T atan2( T fY, T fX );
      inline float aTan2( float fY, float fX )
      {
          return float( ::atan2f( fY, fX ) );
      }
      inline double aTan2( double fY, double fX )
      {
          return double( ::atan2( fY, fX ) );
      }
      //----------------------------------------------------------------------------
      template <typename T>
      inline T cos( T fValue );
      inline float cos( float fValue )
      {
          return float( ::cosf( fValue ) );
      }
      inline double cos( double fValue )
      {
          return double( ::cos( fValue ) );
      }
      //----------------------------------------------------------------------------
      template <typename T>
      inline T exp( T fValue );
      inline float exp( float fValue )
      {
          return float( ::expf( fValue ) );
      }
      inline double exp( double fValue )
      {
          return double( ::exp( fValue ) );
      }
      //----------------------------------------------------------------------------
      template <typename T>
      inline T log( T fValue );
      inline double log( double fValue )
      {
          return double( ::log( fValue ) );
      }
      inline float log( float fValue )
      {
          return float( ::logf( fValue ) );
      }
      //----------------------------------------------------------------------------
      inline double pow( double fBase, double fExponent)
      {
          return double( ::pow( fBase, fExponent ) );
      }
      inline float pow( float fBase, float fExponent)
      {
          return float( ::powf( fBase, fExponent ) );
      }
      template <typename T>
      inline T sin( T fValue );
      inline double sin( double fValue )
      {
          return double( ::sin( fValue ) );
      }
      inline float sin( float fValue )
      {
          return float( ::sinf( fValue ) );
      }
      template <typename T>
      inline T tan( T fValue );
      inline double tan( double fValue )
      {
          return double( ::tan( fValue ) );
      }
      inline float tan( float fValue )
      {
          return float( ::tanf( fValue ) );
      }
      template <typename T>
      inline T sqr( T fValue )
      {
          return T( fValue * fValue );
      }
      template <typename T>
      inline T sqrt( T fValue )
      {
          return T( ::sqrtf( ((float)fValue) ) );
      }
      inline double sqrt( double fValue )
      {
          return double( ::sqrt( fValue ) );
      }
      
      template <typename T>
      inline T abs( T iValue )
      {
         return T( iValue >= ((T)0) ? iValue : -iValue );
      }

      inline double fast_exp2( const double val ) 
      {
         // is the machine little endian?
         union
         {
            short   val;
            char    ch[sizeof( short )];
         } un;
         un.val = 256; // 0x10;
         // if un.ch[1] == 1 then we're little

         // return 2 to the power of val (exp base2)
         int    e;
         double ret;

         if (val >= 0)
         {
            e = int (val);
            ret = val - (e - 1);

            if (un.ch[1] == 1)
               ((*(1 + (int *) &ret)) &= ~(2047 << 20)) += (e + 1023) << 20;
            else
               ((*((int *) &ret)) &= ~(2047 << 20)) += (e + 1023) << 20;
         }
         else
         {
            e = int (val + 1023);
            ret = val - (e - 1024);

            if (un.ch[1] == 1)
               ((*(1 + (int *) &ret)) &= ~(2047 << 20)) += e << 20;
            else
               ((*((int *) &ret)) &= ~(2047 << 20)) += e << 20;
         }

         return ret;
      }

      inline float fast_log2( const float f )
      {
        assert( f > 0. );
        //assert( sizeof(f) == sizeof(int) );
        //assert( sizeof(f) == 4 );
        int i = (*(int *)&f);
        return (((i&0x7f800000)>>23)-0x7f)+(i&0x007fffff)/(float)0x800000;
      }
      
      template <typename T>
      inline T log2( const T f )
      {
        static const double conversion = ::log10( 2.0f );
        return (T)log10( (double)f ) / conversion;
      }

      //First the easy way which is usually good enough:
      //just use x squared or x cubed.

      //Second the more complicated way:
      /*

      These two functions reproduce a traditional professional
      mixer fader taper.

      VolumeToDB converts volume (0 to 100%) starting from the
      bottom of the fader into decibels. 
      DBtoVolume is the inverse.

      The taper is as follows from the top:
      The top of the fader is +10 dB
      100 to 52 : -5 dB per 12
      52 to 16 : -10 dB per 12
      16 to 4 : -20 dB per 12
      4 to 0 : fade to zero. (in these functions I go to -200dB
      which is effectively zero for up to 32 bit audio.)

      */

      inline float volumeToDB( float vol )
      {
              float db;

              vol = 100.0f - vol;

              if (vol <= 0.0f) {
                      db = 10.0f;
              } else if (vol < 48.0f) {
                      db = 10.0f - 5.0f/12.0f * vol;
              } else if (vol < 84.0f) {
                      db = -10.0f - 10.0f/12.0f * (vol - 48.0f);
              } else if (vol < 96.0f) {
                      db = -40.0f - 20.0f/12.0f * (vol - 84.0f);
              } else if (vol < 100.0f) {
                      db = -60.0f - 35.0f * (vol - 96.0f);
              } else db = -200.0f;
              return db;
      }

      inline float DBtoVolume( float db )
      {
              float vol;
              if (db >= 10.0f) {
                      vol = 0.0f;
              } else if (db > -10.0f) {
                      vol = -12.0f/5.0f * (db - 10.0f);
              } else if (db > -40.0f) {
                      vol = 48.0f - 12.0f/10.0f * (db + 10.0f);
              } else if (db > -60.0f) {
                      vol = 84.0f - 12.0f/20.0f * (db + 40.0f);
              } else if (db > -200.0f) {
                      vol = 96.0f - 1.0f/35.0f * (db + 60.0f);
              } else vol = 100.0f;

              vol = 100.0f - vol;

              return vol;
      }
   } // end of Math namespace
} // end of syn namespace

#endif

---