Envelope.cpp File Reference

#include "Envelope.h"
#include <float.h>
#include <math.h>
#include <wx/wxcrtvararg.h>
#include <wx/brush.h>
#include <wx/pen.h>
#include <wx/textfile.h>
#include <wx/log.h>
#include <wx/utils.h>

Include dependency graph for Envelope.cpp:

Go to the source code of this file.

Functions
static double	InterpolatePoints (double y1, double y2, double factor, bool logarithmic)
static double	IntegrateInterpolated (double y1, double y2, double time, bool logarithmic)
static double	IntegrateInverseInterpolated (double y1, double y2, double time, bool logarithmic)
static double	SolveIntegrateInverseInterpolated (double y1, double y2, double time, double area, bool logarithmic)
static void	checkResult (int n, double a, double b)

Variables
static const double	VALUE_TOLERANCE = 0.001

Function Documentation

checkResult()

static void checkResult ( int  n, double  a, double  b  )

static

Definition at line 1417 of file Envelope.cpp.

{
   if( (a-b > 0 ? a-b : b-a) > 0.0000001 )
   {
      wxPrintf( "Envelope:  Result #%d is: %f, should be %f\n", n, a, b );
      //exit( -1 );
   }
}

Referenced by Envelope::testMe().

Here is the caller graph for this function:

IntegrateInterpolated()

static double IntegrateInterpolated ( double  y1, double  y2, double  time, bool  logarithmic  )

static

Definition at line 1117 of file Envelope.cpp.

{
   // Calculates: integral(interpolate(y1, y2, x), x = 0 .. time)
   // Integrating logarithmic interpolated segments is surprisingly simple. You can check this formula here:
   // http://www.wolframalpha.com/input/?i=integrate+10%5E%28log10%28y1%29*%28T-x%29%2FT%2Blog10%28y2%29*x%2FT%29+from+0+to+T
   // Again, the base you use for interpolation is irrelevant, the formula below should always use the natural
   // logarithm (i.e. 'log' in C/C++). If the denominator is too small, it's better to use linear interpolation
   // because the rounding errors would otherwise get too large. The threshold value is 1.0e-5 because at that
   // point the rounding errors become larger than the difference between linear and logarithmic (I tested this in Octave).
   if(logarithmic)
   {
      double l = log(y1 / y2);
      if(fabs(l) < 1.0e-5) // fall back to linear interpolation
         return (y1 + y2) * 0.5 * time;
      return (y1 - y2) / l * time;
   }
   else
   {
      return (y1 + y2) * 0.5 * time;
   }
}

Referenced by Envelope::Integral().

Here is the caller graph for this function:

IntegrateInverseInterpolated()

static double IntegrateInverseInterpolated ( double  y1, double  y2, double  time, bool  logarithmic  )

static

Definition at line 1138 of file Envelope.cpp.

{
   // Calculates: integral(1 / interpolate(y1, y2, x), x = 0 .. time)
   // This one is a bit harder. Linear:
   // http://www.wolframalpha.com/input/?i=integrate+1%2F%28y1*%28T-x%29%2FT%2By2*x%2FT%29+from+0+to+T
   // Logarithmic:
   // http://www.wolframalpha.com/input/?i=integrate+1%2F%2810%5E%28log10%28y1%29*%28T-x%29%2FT%2Blog10%28y2%29*x%2FT%29%29+from+0+to+T
   // Here both cases need a special case for y1 == y2. The threshold is 1.0e5 again, this is still the
   // best value in both cases.
   double l = log(y1 / y2);
   if(fabs(l) < 1.0e-5) // fall back to average
      return 2.0 / (y1 + y2) * time;
   if(logarithmic)
      return (y1 - y2) / (l * y1 * y2) * time;
   else
      return l / (y1 - y2) * time;
}

Referenced by Envelope::IntegralOfInverse(), and Envelope::SolveIntegralOfInverse().

Here is the caller graph for this function:

InterpolatePoints()

static double InterpolatePoints ( double  y1, double  y2, double  factor, bool  logarithmic  )

static

Definition at line 1109 of file Envelope.cpp.

{
   if(logarithmic)
      // you can use any base you want, it doesn't change the result
      return exp(log(y1) * (1.0 - factor) + log(y2) * factor);
   else
      return y1 * (1.0 - factor) + y2 * factor;
}

Referenced by Envelope::Integral(), Envelope::IntegralOfInverse(), and Envelope::SolveIntegralOfInverse().

Here is the caller graph for this function:

SolveIntegrateInverseInterpolated()

static double SolveIntegrateInverseInterpolated ( double  y1, double  y2, double  time, double  area, bool  logarithmic  )

static

Definition at line 1155 of file Envelope.cpp.

{
   // Calculates: solve (integral(1 / interpolate(y1, y2, x), x = 0 .. res) = area) for res
   // Don't try to derive these formulas by hand :). The threshold is 1.0e5 again.
   double a = area / time, res;
   if(logarithmic)
   {
      double l = log(y1 / y2);
      if(fabs(l) < 1.0e-5) // fall back to average
         res = a * (y1 + y2) * 0.5;
      else if(1.0 + a * y1 * l <= 0.0)
         res = 1.0;
      else
         res = log1p(a * y1 * l) / l;
   }
   else
   {
      if(fabs(y2 - y1) < 1.0e-5) // fall back to average
         res = a * (y1 + y2) * 0.5;
      else
         res = y1 * expm1(a * (y2 - y1)) / (y2 - y1);
   }
   return std::max(0.0, std::min(1.0, res)) * time;
}

References min().

Referenced by Envelope::SolveIntegralOfInverse().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

VALUE_TOLERANCE

const double VALUE_TOLERANCE = 0.001

static

Definition at line 42 of file Envelope.cpp.

Referenced by Envelope::RemoveUnneededPoints().