---

nncmath.cpp

Go to the documentation of this file.

#include <math.h>
#include <iostream>

#include "nncmath.h"

using namespace std;

//define at file scope
double NNCMath::sinTable[SIN_TABLE_SIZE];
double NNCMath::cosTable[COS_TABLE_SIZE];
double NNCMath::tanTable[TAN_TABLE_SIZE];
double NNCMath::arcSinTable[ARC_SIN_TABLE_SIZE];
double NNCMath::arcCosTable[ARC_COS_TABLE_SIZE];
double NNCMath::arcTanTable[ARC_TAN_TABLE_SIZE];
double NNCMath::sRootTable[ROOT_TABLE_SIZE];
const double NNCMath::PI = 3.14159265358979323846;
const double NNCMath::TWO_PI = (2 * PI);
const double NNCMath::PI_OVER_TWO = (PI / 2);

//initialize static variables
void NNCMath::MathInit() {
  for (int i = 0; i < SIN_TABLE_SIZE; i++) {
    sinTable[i] = SIN_DEFAULT_VALUE;
  }
  for (int i = 0; i < COS_TABLE_SIZE; i++) {
    cosTable[i] = COS_DEFAULT_VALUE;
  }
  for (int i = 0; i < TAN_TABLE_SIZE; i++) {
    tanTable[i] = TAN_DEFAULT_VALUE;
  }
  for (int i = 0; i < ARC_SIN_TABLE_SIZE; i++) {
    arcSinTable[i] = ARC_SIN_DEFAULT_VALUE;
  }
  for (int i = 0; i < ARC_COS_TABLE_SIZE; i++) {
    arcCosTable[i] = ARC_COS_DEFAULT_VALUE;
  }
  for (int i = 0; i < ARC_TAN_TABLE_SIZE; i++) {
    arcTanTable[i] = ARC_TAN_DEFAULT_VALUE;
  }
  for (int i = 0; i < ROOT_TABLE_SIZE; i++) {
    sRootTable[i] = ROOT_DEFAULT_VALUE;
  }
}
    

//static functions

//creates a radian and calls the other Sin function
double NNCMath::Sin(degree d) { 
  radian radianValue;
  radianValue.value = d.value * PI / 180.0;
  return Sin(radianValue);
}

double NNCMath::Sin(radian r) { 
  double value;
  int valueCast;

  value = r.value;

  while (value > TWO_PI)
    value -= TWO_PI;

  while (value < 0)
    value += TWO_PI;
  
  valueCast = (int)(value * MULTIPLIER);
  if (valueCast > SIN_TABLE_SIZE - 1 || valueCast < 0) return sin(value);

  if (sinTable[valueCast] == SIN_DEFAULT_VALUE) {
    sinTable[valueCast] = sin(value);
  }
  
  return sinTable[valueCast];
}


double NNCMath::Cos(degree d){ 
  radian radianValue;
  radianValue.value = d.value * PI / 180.0;
  return Cos(radianValue);
}

double NNCMath::Cos(radian r) {
  double value;
  int valueCast;
  double check;
  
  value = r.value;

  while (value > TWO_PI) {
    value -= TWO_PI;
  }

  while (value < 0) {
    value += TWO_PI;
  }
  
  valueCast = (int)(value * MULTIPLIER);
  if (valueCast > COS_TABLE_SIZE - 1 || valueCast < 0) return 0.0;
  
  check = cosTable[valueCast];
  
  
  if (check == COS_DEFAULT_VALUE) {
    cosTable[valueCast] = cos(value);
  }
  
  return cosTable[valueCast];
}

double NNCMath::Tan(degree d){ 
  radian radianValue;
  radianValue.value = d.value * PI / 180.0;
  return Tan(radianValue);
}

double NNCMath::Tan(radian r) {
  double value;
  int valueCast;
  double check;
  
  value = r.value;

  while (value > TWO_PI) {
    value -= TWO_PI;
  }

  while (value < 0) {
    value += TWO_PI;
  }

  if (value == PI_OVER_TWO || value == -PI_OVER_TWO) return 0.0;

  valueCast = (int)(value * MULTIPLIER);
  if (valueCast > TAN_TABLE_SIZE - 1 || valueCast < 0) return 0.0;

  check = tanTable[valueCast];
  
  
  if (check == TAN_DEFAULT_VALUE) {
    tanTable[valueCast] = tan(value);
  }
  
  return tanTable[valueCast];
}

radian NNCMath::ArcSin(double d){ 
  radian r;
  int index;
  double temp;
  if (d > 1 || d < -1) r.value = 0.0;
  else {
        index = (int)(d * MULTIPLIER);
        if (arcSinTable[index] == ARC_SIN_DEFAULT_VALUE) {
                temp = asin(d);
                if (temp < 0) temp += TWO_PI;
                arcSinTable[index] = temp;
        }
        r.value = arcSinTable[index];
  }
  return r;
}

radian NNCMath::ArcCos(double d){ 
radian r;
  int index;
  if (d > 1 || d < -1) r.value = 0.0;
  else {
        index = (int)(d * MULTIPLIER);
        if (arcCosTable[index] == ARC_COS_DEFAULT_VALUE) {
                arcCosTable[index] = acos(d);
        }
        r.value = arcCosTable[index];
  }
  return r;
}

radian NNCMath::ArcTan(double d){ 
        radian r;
        int index;
        double temp;

        if (d >= 20) r.value = PI_OVER_TWO;
        else if (d <= -20) r.value = -PI_OVER_TWO;
        else {
                index = (int)( (d + 20) * MULTIPLIER);
                if (arcTanTable[index] == ARC_TAN_DEFAULT_VALUE) {
                        temp = atan(d);
                        //while (temp < 0) temp += TWO_PI;
                        arcTanTable[index] = temp;
                }
                r.value = arcTanTable[index];
        }
        return r;
}

double NNCMath::SRoot(double d){ return sqrt(d);}

---