Possible Code Speed Optimisations?

Question

Ok so I have a my Trig class that I use to store a static table of values for faster execution of sin, cos, and tan functions in my program. Are there any comments and/or speed improvements that could be made over my current method? Thanks to previous answers, I am already feeling much more competent with C++.

Trig.h

#pragma once
#include <math.h>

class Trig
{
private:
    struct Table
    {
        static const int multiple = 10; // Accurately stores values to 1/10 of a degree
        double sin[360*multiple];
        Table();
    };
    static const Table table;
    static void shrinkRange(double*); // Shrinks degrees to range 0-359 for proper array indexing
public:
    static double sin(double);
    static double cos(double);
    static double tan(double);
};

Trig.cpp

#include "Trig.h"

Trig::Table::Table() // table constructor
{
    double const PI = 3.14159265358979323;
    double const degToRad = PI/180.0;
    double const incr = 1.0/multiple;
    int index = 0;
    for (double angle = 0; index != 360*table.multiple; angle += incr)
        Table::sin[index++] = _INC_MATH::sin(angle*degToRad);
}

Trig::Table const Trig::table; // initialize static table member

void Trig::shrinkRange(double* degrees)
{
    if (*degrees >= 360)
        *degrees -= 360*( (int)*degrees/360);
    if (*degrees < 0)
        *degrees += 360*( -(int)*degrees/360 + 1);
}

double Trig::sin(double degrees)
{
    shrinkRange(&degrees);
    degrees *= table.multiple;
    return Trig::table.sin[(int)(degrees+0.5)];
}

double Trig::cos(double degrees)
{
    return Trig::sin(degrees + 90);
}

double Trig::tan(double degrees)
{
    return Trig::sin(degrees)/Trig::cos(degrees);
}

Answer 1

C++ isn't Java. In this case, you cannot call a function or access a member on a class, because there are no class objects; you can access a static member simply by specifying its scope:

Trig::createTable();
Trig::COS_TABLE[120];

Also (but this is true in Java as well), you can automatically ensure the proper initialization by using dynamic initialization. If you really want to keep the current structure, you could add something like:

bool initted = (Trig::createTable(), true);

any where at namespace scope. More idiomatic would be to define an object type to contain the two tables, with a constructor which initialized them, and declare a static instance of this:

class Trig
{
public:
    struct Tables
    {
        double sin[360];
        double cos[360];
        Tables();
    };
    static Tables const tables;
    //  ...
};

Trig::Tables const Trig::tables;

Trig::Tables::Tables()
{
    double rad = PI / 180.0;
    for ( int angle = 0; angle != 360; ++ angle ) {
        sin[angle] = std::sin( angle * rad );
        cos[angle] = std::cos( angle * rad );
    }
}

No need to explicitly call Trig::createTable; the compiler takes care of this for you.

(Similar techniques are available in Java. For some reason, they are not often used, where as the above is very idiomatic C++.)

Answer 2

Trig::createTable();
double x = Trig::COS_Table[120];

Answer 3

In order to access a static you need to use :: i.e.

Trig::COS_TABLE

rather than Trig.COS_TABLE

However, a class that just contains statics is a tad odd in C++.

Answer 4

Static variable needs to be accessed using namespcae operator :: unlike . used in Java.

So, to call method createTable() without creating an object, use this syntax:

Trig::createTable();

As SIN_TABLE and COS_TABLE table are also static, use syntax as:

Trig::SIN_TABLE[120];
Trig::COS_TABLE[120];

Answer 5

Best, make your tables (non-static) members of a class for which you have a single static object:

#include <cmath>                         // include C++ header instead of C

namespace trig {                         // use a namespace instead of a class
  const double pi = 4*std::atan2(1.,1.); // avoid pre-processor macros
  namespace details {                    // hide details in inner namespace
    struct sin_cos_tables                // class holding tables
    {
      double SIN[360];
      double COS[360];
      sin_cos_tables()                   // default constructor: set tables
      {
        const double fac = pi/180;
        for(int angle = 0; angle != 360; ++angle)
        {
          SIN[angle] = std::sin(angle*fac);
          COS[angle] = std::cos(angle*fac);
        }
      }
    };
    static sin_cos_tables TABLES;        // static object constructed at start-up
  }
  static const double*SIN_TABLE = details::TABLES.SIN;  // for your convenience
  static const double*COS_TABLE = details::TABLES.COS;  // (not really necessary)
}

int main()
{
  double x = trig::SIN_TABLE[120];
}

this way, the tables are automatically created before your other (non-static) code runs.