Trig.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Math/Alge/Alge.h"

namespace honey
{

template<class Real> class Interp_;

template<class Real>
class SinTable
{
    typedef typename Numeral<Real>::Real_ Real_;
    typedef Alge_<Real>     Alge;
    typedef Interp_<Real>   Interp;

public:
    SinTable()                                                      : _size(0) {}

    void resize(int size);
    int size() const                                                { return _size; }

    Real sin(Real x) const;
    Real asin(Real x) const;
    Real cos(Real x) const                                          { return sin(Real_::piHalf - x); }
    Real acos(Real x) const                                         { return Real_::piHalf - asin(x); }
    Real tan(Real x) const                                          { return sin(x) / cos(x); }
    Real atan(Real x) const                                         { return asin(x / Alge::sqrt(1 + x*x)); }
    Real atan2(Real y, Real x) const;

private:
    typedef vector<Real> List;

    Real linear(const List& list, Real idx) const                   { int cur = idx; return Interp::linear(idx-cur, list[cur], list[(cur+1)%_size]); }

    List _sin;
    List _asin;
    int  _size;
    int  _radToSin;
    int  _xToAsin;
};

extern template class SinTable<Float>;
extern template class SinTable<Double>;
extern template class SinTable<Quad>;


template<class Real>
class Trig_
{
    typedef typename Numeral<Real>::Real_ Real_;
    typedef Alge_<Real> Alge;

public:
    static void enableSinTable(bool enable, int size = -1);

    static Real sin(Real x)                                         { auto& t = inst(); return t._tableEnable ? t._table.sin(x) : Real_::sin(x); }
    static Real asin(Real x)                                        { auto& t = inst(); return t._tableEnable ? t._table.asin(x) : Real_::asin(x); }

    static Real cos(Real x)                                         { auto& t = inst(); return t._tableEnable ? t._table.cos(x) : Real_::cos(x); }
    static Real acos(Real x)                                        { auto& t = inst(); return t._tableEnable ? t._table.acos(x) : Real_::acos(x); }

    static Real tan(Real x)                                         { auto& t = inst(); return t._tableEnable ? t._table.tan(x) : Real_::tan(x); }
    static Real atan(Real x)                                        { auto& t = inst(); return t._tableEnable ? t._table.atan(x) : Real_::atan(x); }
    static Real atan2(Real y, Real x)                               { auto& t = inst(); return t._tableEnable ? t._table.atan2(y,x) : Real_::atan2(y,x); }

    static Real radian(Real degree)                                 { return degree * Real_::pi / 180; }
    static Real degree(Real radian)                                 { return radian * 180 / Real_::pi; }

    static Real normalizeAngle(Real angle)                          { return Alge::modNormalize(Real_::pi, angle); }
    static Real alignAngle(Real angleFrom, Real angleTo)            { return Alge::modDistSigned(Real_::pi, angleFrom, angleTo); }
    static Real distanceAngle(Real angle, Real angle2)              { return Alge::abs(alignAngle(angle, angle2)); }

private:
    Trig_()                                                         : _tableEnable(false) {}

    static mt_global(Trig_, inst,);

    SinTable<Real> _table;
    bool _tableEnable;

    static const int tableSizeDefault = 1 << 13;    
};

typedef Trig_<Real>         Trig;
typedef Trig_<Float>        Trig_f;
typedef Trig_<Double>       Trig_d;
typedef Trig_<Quad>         Trig_q;

extern template class Trig_<Float>;
extern template class Trig_<Double>;
extern template class Trig_<Quad>;

}