Максимально быстрый вариант вычисления sinf/cosf

/////////////////////////////////////////////////////////////////////////////////////////
//Напишите предрасчетный (максимальность быстрый) вариант вычисления sinf/cosf по таблице 
//с точностью до сотых.
/////////////////////////////////////////////////////////////////////////////////////////
#include <cmath>
#include <iostream>
#include <map>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::map    < float,    float   >   T_sin_cos_of;
/////////////////////////////////////////////////////////////////////////////////////////
const   float   PI      =   acos( -1.0f );
const   float   _2_PI   =   PI * 2.0f;
/////////////////////////////////////////////////////////////////////////////////////////
T_sin_cos_of    fill_and_get_sin_of()
{
    T_sin_cos_of    sin_of;
 
    for( float  sin_x = 0.0; sin_x <= 1.0; sin_x += 0.01f )
    {
        float  x   =   asin( sin_x );
        float  x1  =   PI - x;
 
        sin_of[ x       ]   =   sin_x;
        sin_of[ x + PI  ]   =   -sin_x;
 
        sin_of[ x1      ]   =   sin_x;
        sin_of[ x1 + PI ]   =   -sin_x;
    }
 
    return  sin_of;
}
/////////////////////////////////////////////////////////////////////////////////////////
float  input_and_get_x()
{
    std::cout   <<  "x = ";
    float   x;
    std::cin    >>  x;
    return  x;
}
/////////////////////////////////////////////////////////////////////////////////////////
float   get_table_sin( float    x )
{
    static  const   T_sin_cos_of    sin_of  =   fill_and_get_sin_of();
 
    if( x < 0 )
    {
        return  -get_table_sin(-x);
    }
 
    auto    it  =   sin_of.lower_bound
                        (
                            fmod( x, _2_PI )
                        );
 
    return  it  ==  sin_of.end()
                ?   sin_of.rbegin()->second
                :   it->second;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_sin_cos_of    fill_and_get_cos_of()
{
    T_sin_cos_of    cos_of;
 
    for( float  cos_x = -1.0; cos_x <= 1.0; cos_x += 0.01f )
    {
        float  x   =   acos( cos_x );
        float  x1  =   _2_PI - x;
 
        cos_of[ x   ]   =   cos_x;
        cos_of[ x1  ]   =   cos_x;
    }
 
    return  cos_of;
}
/////////////////////////////////////////////////////////////////////////////////////////
float   get_table_cos( float    x )
{
    static  const   T_sin_cos_of    cos_of  =   fill_and_get_cos_of();
 
    x   =   abs(x);
 
    auto    it  =   cos_of.lower_bound
                        (
                            fmod( x, _2_PI )
                        );
 
    return  it  ==  cos_of.end()
                ?   cos_of.rbegin()->second
                :   it->second;
}
/////////////////////////////////////////////////////////////////////////////////////////
void    test_sin()
{
    float   delta       =   0;
    float   delta_max   =   0;
 
    for( float  x = -100.0f; x <= 100.0; x += 0.001f )
    {
        delta   =   abs (
                            sin(x)  -   get_table_sin(x)
                        );
 
        if( delta > delta_max )
        {
            delta_max   =   delta;
        }
    }//for
 
    std::cout   <<  "Максимальная погрешность табличного синуса составляет\t\t"
                <<  delta_max
                <<  std::endl;
}
/////////////////////////////////////////////////////////////////////////////////////////
void    test_cos()
{
    float   delta       =   0;
    float   delta_max   =   0;
 
    float   x_for_max   =   0;
 
    for( float  x = -100.0; x <= 100.0; x += 0.001f )
    {
        delta   =   abs (
                            cos(x)  -   get_table_cos(x)
                        );
 
        if( delta > delta_max )
        {
            delta_max   =   delta;
            x_for_max   =   x;
        }
    }//for
 
    std::cout   <<  "Максимальная погрешность табличного косинуса составляет\t\t"
                <<  delta_max
                <<  std::endl;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
 
    test_sin();
    test_cos();
 
    for(;;)
    {
        float   x       =   input_and_get_x     ();
        float   sit_x   =   get_table_sin       (x);
        float   cos_x   =   get_table_cos       (x);
 
        std::cout   <<  "sin("
                    <<  x
                    <<  ") = "
                    <<  sit_x
                    <<  std::endl
                    <<  "cos("
                    <<  x
                    <<  ") = "
                    <<  cos_x
                    <<  std::endl
                    <<  "sin^2 + cos^2 = "
                    <<  sit_x * sit_x + cos_x * cos_x
                    <<  std::endl
                    <<  std::endl;
    }//for
}

double tbSin[91];
 
void InitSin()
{
 for(int i=0;i<=90;i++)
   tbSin[i]=sin((double)i*3.1415 /180.0);
}
 
double MySin(int ag)
{
return  tbSin[ag];
}