Search  

---

C:/temp/src/j2k/Beta/Math/Scale.hpp

Go to the documentation of this file.

#ifndef __J2K__Scale_HPP__
#define __J2K__Scale_HPP__

#include <j2k/Fred/Basic.hpp>
#include <math.h>

// Global C function currently.

int Scale( double XMin, double XMax, int N, double* SMin, double* Step ) 
{
  int     negScale;       //  Negative scale flag
  int     nbScaleSub;     //  Number of scale subintervals 
  double  initStep;       //  Initial step
  double  scaleStep;      //  Scaled step 
  double  temp;           //  Temporary value
  double  scaleFactor;    //  Scaling back factor 
  double  scaleMax;       //  Scale maximum value 
  int     t;              //  teration counter 
  int     i;              //  Neat step counter
     
  //  Neat steps
  int Steps[] = {
     10, 12, 15, 16, 20, 25, 30, 40, 50, 60, 75, 80, 100, 120, 150};

  int NS = sizeof(Steps) / sizeof(Steps[0]);
     
  //  Some checks
  if ( XMin > XMax ) {
    temp = XMin;
    XMin = XMax;
    XMax = temp;
  }

  if ( XMin == XMax ) {
    if ( XMin == 0.0 ) {
      XMax = 1.0;
    } else {
      XMax = XMin + fabs(XMin) / 10.0;
    }
  }
     
  //  Reduce to postive scale case if possible 
  if ( XMax <= 0 ) {
    negScale = 1;
    temp   = XMin;
    XMin    = -XMax;
    XMax    = -temp;
  } else {
    negScale = 0;
  }
     
  if ( N < 2 ) {
    N = 2;
  }

  nbScaleSub = N - 1;
     
  for (t = 0; t < 3; t++) {
    //  Compute intial and scaled steps 
    intStep   = (XMax - XMin) / nbScaleSub;
    scaleStep = intStep;
     
    for (; scaleStep <  10.0; scaleStep *= 10.0); 
    for (; scaleStep > 100.0; scaleStep /= 10.0);
     
    //  Find a sutable neat step
    for (i = 0; i < NS && scaleStep > Steps [i]; i++); 
    scaleFactor = intStep / scaleStep;
     
    //  Compute step and scale minimum value 
    do {
      *Step  = scaleFactor * Steps [i];
      *SMin  = floor (XMin / *Step) * *Step; 
      scaleMax = *SMin + nbScaleSub * *Step;

      if (XMax <= scaleMax) {  //  Function max is in the range: work done
        if (negScale) *SMin = -scaleMax;
        *Step *= nbScaleSub / (N - 1);
        return 1;
       }

     i++;

    } while (i < NS);
     
    //  Double number of intervals
    nbScaleSub *= 2;
  }
     
  //  Could not solve the problem
  return 0;
}

#endif

---