_angle.h

Go to the documentation of this file.

/* ========================================================================
** Extended Template and Library
** Angle Abstraction Class Implementation
** $Id$
**
** Copyright (c) 2002 Robert B. Quattlebaum Jr.
** Copyright (c) 2007 Chris Moore
**
** This package is free software; you can redistribute it and/or
** modify it under the terms of the GNU General Public License as
** published by the Free Software Foundation; either version 2 of
** the License, or (at your option) any later version.
**
** This package is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
** General Public License for more details.
**
** === N O T E S ===========================================================
**
** This is an internal header file, included by other ETL headers.
** You should not attempt to use it directly.
**
** ========================================================================= */

/* === S T A R T =========================================================== */

#ifndef __ETL__ANGLE_H
#define __ETL__ANGLE_H

/* === H E A D E R S ======================================================= */

#include <cstdio>
#include <cmath>
#include <functional>

/* === M A C R O S ========================================================= */

#ifndef PI
# define PI (3.1415926535897932384626433832795029L)
# define HALF_PI (PI/2)
#endif

#define ANGLE_EPSILON (1.0e-6)

/* === T Y P E D E F S ===================================================== */

/* === C L A S S E S & S T R U C T S ======================================= */

_ETL_BEGIN_NAMESPACE

// ========================================================================
class angle
{
public:
    typedef float value_type;

protected:
    typedef value_type unit;

    unit v; 

public:

    /*
    ** Arithmetic Operators
    */

    const angle &
    operator+=(const angle &rhs)
    { v+=rhs.v; return *this; }

    const angle &
    operator-=(const angle &rhs)
    { v-=rhs.v; return *this; }

    const angle &
    operator*=(const unit &rhs)
    { v*=rhs; return *this; }

    const angle &
    operator/=(const unit &rhs)
    { v/=rhs; return *this; }

    angle
    operator+(const angle &rhs)const
    { return angle(*this)+=rhs; }


    angle
    operator-(const angle &rhs)const
    { return angle(*this)-=rhs; }


    angle
    operator*(const unit &rhs)const
    { return angle(*this)*=rhs; }

    angle
    operator/(const unit &rhs)const
    { return angle(*this)/=rhs; }

    angle
    operator-()const
    {
        angle ret;
        ret.v=-v;
        return ret;
    }

#ifdef ETL_NOT_USED


    angle
    operator~()const
    {
        angle ret;
        ret.v = v+PI;
        return ret.mod();
    }
#endif // ETL_NOT_USED

#ifdef ETL_WRAP_ANGLES

    bool
    operator<(const angle &rhs)const
    { return dist(rhs).v<(value_type)0.0; }

    bool
    operator>(const angle &rhs)const
    { return dist(rhs).v>(value_type)0.0; }

    bool
    operator<=(const angle &rhs)const
    { return dist(rhs).v<=(value_type)0.0; }

    bool
    operator>=(const angle &rhs)const
    { return dist(rhs).v>=(value_type)0.0; }

    bool
    operator==(const angle &rhs)const
    { return std::abs(dist(rhs).v)<ANGLE_EPSILON; }

    bool
    operator!=(const angle &rhs)const
    { return std::abs(dist(rhs).v)>ANGLE_EPSILON; }
#else // ETL_WRAP_ANGLES

    bool
    operator<(const angle &rhs)const
    { return v < rhs.v; }

    bool
    operator>(const angle &rhs)const
    { return v > rhs.v; }

    bool
    operator<=(const angle &rhs)const
    { return v <= rhs.v; }

    bool
    operator>=(const angle &rhs)const
    { return v >= rhs.v; }

    bool
    operator==(const angle &rhs)const
    { return std::abs(v - rhs.v)<ANGLE_EPSILON; }

    bool
    operator!=(const angle &rhs)const
        { return std::abs(v - rhs.v)>ANGLE_EPSILON; }
#endif // ETL_WRAP_ANGLES


    angle
    abs()const
    {
        angle ret;
        ret.v=std::abs(v);
        return ret;
    }

#ifdef ETL_WRAP_ANGLES


    angle
    dist(const angle &rhs)const
    {
        angle ret;
        ret.v=v-rhs.v;
        ret.v-=rot_floor(ret.v+PI);
        return ret;
    }


    angle
    mod()const
    {
        angle ret(*this);
        ret.v-=rot_floor(ret.v);
        return ret;
    }
#else // ETL_WRAP_ANGLES


    angle
    dist(const angle &rhs)const
    { return angle(*this)-=rhs; }


    angle
    mod()const
    {
        angle ret(*this);
        return ret;
    }
#endif // ETL_WRAP_ANGLES

    static angle
    zero()
    {
        angle ret;
        ret.v=0;
        return ret;
    }

    static angle
    one()
    {
        angle ret;
        ret.v=PI*2;
        return ret;
    }

    static angle
    half()
    {
        angle ret;
        ret.v=PI;
        return ret;
    }

    bool operator!()const { return std::abs(mod().v) < ANGLE_EPSILON; }

private:

#ifdef ETL_WRAP_ANGLES
    static value_type rot_floor(value_type x)
    { return static_cast<value_type>(std::floor(x/(PI*2))*PI*2); }
#endif // ETL_WRAP_ANGLES

public:
    /*
    ** Conversion Classes
    */

    class rad;
    class deg;
    class rot;

    /*
    ** Trigonometric Classes
    */

    class sin;
    class cos;
    class tan;

    /*
    ** Friend classes
    */

    friend class rad;
    friend class deg;
    friend class rot;
    friend class sin;
    friend class cos;
    friend class tan;

    /*
    ** Deprecated
    */

#ifndef ETL_NO_DEPRECATED
    typedef rad     radians;
    typedef deg     degrees;
    typedef rot     rotations;
#endif
}; // END of class angle

// ========================================================================
class angle::rad : public angle
{
public:
    explicit rad(const value_type &x) { v=x; }
    rad(const angle &a):angle(a) { }
    rad mod()const { return angle::mod(); }
    rad dist(const angle &rhs)const { return angle::dist(rhs); }
    value_type get()const { return v; }
#ifndef ETL_NO_DEPRECATED
    // operator value_type()const ETL_DEPRECATED_FUNCTION;
#endif
}; // END of class angle::radians
// inline angle::rad::operator angle::value_type()const { return get(); }

// ========================================================================
class angle::deg : public angle
{
public:
    explicit deg(const value_type &x) { v=x*((PI*2)/360); }
    deg(const angle &a):angle(a) { }
    deg mod()const { return angle::mod(); }
    deg dist(const angle &rhs)const { return angle::dist(rhs); }
    value_type get()const { return v*360/(PI*2); }
#ifndef ETL_NO_DEPRECATED
    // operator value_type()const ETL_DEPRECATED_FUNCTION;
#endif
}; // END of class angle::degrees
// inline angle::deg::operator angle::value_type()const { return get(); }

// ========================================================================
class angle::rot : public angle
{
public:
    explicit rot(const value_type &x) { v=x*(PI*2); }
    rot(const angle &a):angle(a) { }
    rot mod()const { return angle::mod(); }
    rot dist(const angle &rhs)const { return angle::dist(rhs); }
    value_type get()const { return v/(PI*2); }
#ifndef ETL_NO_DEPRECATED
    // operator value_type()const ETL_DEPRECATED_FUNCTION;
#endif
}; // END of class angle::rotations
// inline angle::rot::operator angle::value_type()const { return get(); }

// ========================================================================
class angle::sin : public angle
{
public:
    explicit sin(const value_type &x) { v=static_cast<value_type>(std::asin(x)); }
    sin(const angle &a):angle(a) { }
    sin mod()const { return angle::mod(); }
    sin dist(const angle &rhs)const { return angle::dist(rhs); }
    value_type get()const { return static_cast<value_type>(std::sin(v)); }
#ifndef ETL_NO_DEPRECATED
    // operator value_type()const ETL_DEPRECATED_FUNCTION;
#endif
}; // END of class angle::sin
// inline angle::sin::operator angle::value_type()const { return get(); }

// ========================================================================
class angle::cos : public angle
{
public:
    explicit cos(const value_type &x)   { v=(value_type)(std::acos(x)); }
    cos(const angle &a):angle(a) { }
    cos mod()const { return angle::mod(); }
    cos dist(const angle &rhs)const { return angle::dist(rhs); }
    value_type get()const { return (value_type)std::cos(v); }
#ifndef ETL_NO_DEPRECATED
    // operator value_type()const ETL_DEPRECATED_FUNCTION;
#endif
}; // END of class angle::cos
// inline angle::cos::operator angle::value_type()const { return get(); }

// ========================================================================
class angle::tan : public angle
{
public:
    explicit tan(const value_type &x)   { v=(value_type)(std::atan(x)); }
    tan(const value_type &y,const value_type &x) { v=(value_type)(std::atan2(y,x)); }
    tan(const angle &a):angle(a) { }
    tan mod()const { return angle::mod(); }
    tan dist(const angle &rhs)const { return angle::dist(rhs); }
    value_type get()const { return (value_type)std::tan(v); }
#ifndef ETL_NO_DEPRECATED
    // operator value_type()const ETL_DEPRECATED_FUNCTION;
#endif
}; // END of class angle::tan
// inline angle::tan::operator angle::value_type()const { return get(); }

_ETL_END_NAMESPACE

//#include <iostream>

template <typename T>
struct affine_combo<etl::angle, T>
{
    typedef T time_type;

    //affine_combo() { std::cerr<<"affine_combo<etl::angle,float>: I was created!"<<std::endl; }
    //~affine_combo() { std::cerr<<"affine_combo<etl::angle,float>: I was DELETED!"<<std::endl; }

    etl::angle operator()(const etl::angle &a,const etl::angle &b,const time_type &t)const
    {
        return b.dist(a)*(float)t+a;
    }

    etl::angle reverse(const etl::angle &x, const etl::angle &b, const time_type &t)const
    {
        return x.dist(b*(float)t)*(float)(time_type(1)/(time_type(1)-t));
    }
};

template <>
struct distance_func<etl::angle> : public std::binary_function<etl::angle, etl::angle, etl::angle>
{
    etl::angle operator()(const etl::angle &a,const etl::angle &b)const
    {
        etl::angle delta=b.dist(a);
        //if(delta<etl::angle::zero())
        //  return delta+etl::angle::one();
        return delta;
    }

    etl::angle cook(const etl::angle &x)const { return x; }
    etl::angle uncook(const etl::angle &x)const { return x; }
};

/* === E N D =============================================================== */

#endif