etl-dev 0.04.19-1 / usr / include / ETL / _fastangle.h

/*! ========================================================================
** Extended Template and Library
** Fast fastangle Abstraction Class Implementation
** $Id$
**
** Copyright (c) 2002 Robert B. Quattlebaum Jr.
**
** 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__FASTANGLE_H
#define __ETL__FASTANGLE_H

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

#include <cmath>
#include <ETL/fixed>

#include "_fastangle_tables.h"

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

#ifndef PI
# define PI (3.1415926535897932384626433832795029L)
#endif

#define ETL_FASTANGLE_INIT()

/* === 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	fastangle
** \brief	Optimized abstraction of the concept of an angle
**
** A more detailed description needs to be written.
*/
class fastangle
{
public:
	typedef double value_type;

protected:
	typedef fixed_base<ETL_FIXED_TYPE,ETL_FASTANGLE_LOOKUP_RES> unit;

	unit v;	//! Stored in rotations

public:

	/*
	** Arithmetic Operators
	*/

	//! fastangle Addition Operator
	fastangle
	operator+(const fastangle &rhs)const
	{
		fastangle ret;
		ret.v=v+rhs.v;
		return ret;
	}

	//! fastangle Subtraction Operator
	/*! \sa fastangle dist(const fastangle &) */
	fastangle
	operator-(const fastangle &rhs)const
	{
		fastangle ret;
		ret.v=v-rhs.v;
		return ret;
	}

	//! fastangle Scalar Multiplication Operator
	/*! This operator will multiply the given
		fastangle by the given scalar value. */
	fastangle
	operator*(const unit &rhs)const
	{
		fastangle ret;
		ret.v=v*rhs;
		return ret;
	}

	fastangle
	operator/(const unit &rhs)const
	{
		fastangle ret;
		ret.v=v/rhs;
		return ret;
	}

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

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

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

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

	//! fastangle Negation
	fastangle
	operator-()const
	{
		fastangle ret;
		ret.v=-v;
		return ret;
	}

	//! 180 degree rotation operator
	/*! Returns the fastangle directly opposite of
		the given fastangle, and will yield a result
		between 0 and 2PI */
	fastangle
	operator~()const
	{
		fastangle ret;
		ret.v=(unit)std::floor(v+0.5f);
		return ret;
	}

	/*! Returns true if the shortest
		fastangle between the left-hand and
		right-hand side is clockwise */
	bool
	operator<(const fastangle &rhs)const
	{ return v<rhs.v; }
//	{ return dist(rhs).v<(value_type)0.0; }

	/*! Returns true if the shortest
		fastangle between the left-hand and
		right-hand side is counter-clockwise */
	bool
	operator>(const fastangle &rhs)const
	{ return v>rhs.v; }
//	{ return dist(rhs).v>(value_type)0.0; }

	/*! Returns true if the shortest
		fastangle between the left-hand and
		right-hand side is clockwise,
		or if the angles are refer to the same
		point on the unit circle. */
	bool
	operator<=(const fastangle &rhs)const
	{ return v<=rhs.v; }
//	{ return dist(rhs).v<=(value_type)0.0; }

	/*! Returns true if the shortest
		fastangle between the left-hand and
		right-hand side is counter-clockwise,
		or if the angles are refer to the same
		point on the unit circle. */
	bool
	operator>=(const fastangle &rhs)const
	{ return v>=rhs.v; }
//	{ return dist(rhs).v>=(value_type)0.0; }

	/*! Returns true if the angles
		are refer to the same point
		on the unit circle. */
	bool
	operator==(const fastangle &rhs)const
	{ return v==rhs.v; }
//	{ return dist(rhs).v==(value_type)0.0; }

	/*! Returns false if the angles
		are refer to the same point
		on the unit circle. */
	bool
	operator!=(const fastangle &rhs)const
	{ return v!=rhs.v; }
//	{ return dist(rhs).v!=(value_type)0.0; }

	//! fastangle Difference Function
	/*! This function will return the
		shortest physical distance between
		two angles, from -PI/2 to PI/2
		\warning Not yet tested
		\sa fastangle operator-(const fastangle &) */
	fastangle
	dist(const fastangle &rhs)const
	{
		fastangle ret;
		ret.v=v-rhs.v;
		ret.v-=(unit)std::floor(ret.v+0.5f);
		return ret;
	}

	//! Rotation Modulus
	/*! This function will return the
		value of the fastangle between 0 and 2PI */
	fastangle
	mod()const
	{
		fastangle ret(*this);
		ret.v-=(unit)std::floor(ret.v);
		return ret;
	}

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

	bool operator!()const { return v==unit(0); }

	/*
	** Conversion Classes
	*/

	class radians;
	class degrees;
	class rotations;

	/*
	** Trigonometric Classes
	*/

	class sin;
	class cos;
	class tan;

	/*
	** Friend classes
	*/

	friend class radians;
	friend class degrees;
	friend class rotations;
	friend class sin;
	friend class cos;
	friend class tan;

	/*
	** Bleh...
	*/

	typedef radians		rad;
	typedef degrees		deg;
	typedef rotations	rot;

}; // END of class fastangle

/*! ========================================================================
** \class	fastangle::radians
** \brief	fastangle representation in radians
**
** A more detailed description needs to be written.
*/
class fastangle::radians : public fastangle
{
public:
	radians(const value_type &x) { v=x/((value_type)PI*2.0f); }
	radians(const fastangle &a):fastangle(a) { }
	radians	mod()const { return fastangle::mod(); }
	radians dist(const fastangle &rhs)const { return fastangle::dist(rhs); }
	operator value_type()const { return get(); }
	value_type get()const { return (value_type)v*(value_type)PI*2.0f; }
}; // END of class fastangle::radians

/*! ========================================================================
** \class	fastangle::degrees
** \brief	fastangle representation in degrees
**
** A more detailed description needs to be written.
*/
class fastangle::degrees : public fastangle
{
public:
	degrees(const value_type &x) { v=x/360; }
	degrees(const fastangle &a):fastangle(a) { }
	degrees	mod()const { return fastangle::mod(); }
	degrees dist(const fastangle &rhs)const { return fastangle::dist(rhs); }
	operator value_type()const { return get(); }
	value_type get()const { return v*360/*(value_type)(v-::floor(v))*360*/; }
}; // END of class fastangle::degrees

/*! ========================================================================
** \class	fastangle::rotations
** \brief	fastangle representation in rotations
**
** A more detailed description needs to be written.
*/
class fastangle::rotations : public fastangle
{
public:
	rotations(const value_type &x) { v=x; }
	rotations(const fastangle &a):fastangle(a) { }
	rotations mod()const { return fastangle::mod(); }
	rotations dist(const fastangle &rhs)const { return fastangle::dist(rhs); }
	operator value_type()const { return get(); }
	value_type get()const { return v; }
}; // END of class fastangle::rotations

/*! ========================================================================
** \class	fastangle::sin
** \brief	fastangle representation as a sine function
**
** A more detailed description needs to be written.
*/
class fastangle::sin : public fastangle
{
public:
	sin(const value_type &x)	{ v.data()=_fastangle_asin_table[(int)((x+1)*(value_type)(1<<(ETL_FASTANGLE_LOOKUP_RES-1)))]; }
	sin(const fastangle &a):fastangle(a) { }
	sin	mod()const { return fastangle::mod(); }
	sin dist(const fastangle &rhs)const { return fastangle::dist(rhs); }
	operator value_type()const { return get(); }
	value_type get()const { return (value_type)_fastangle_sin_table[v.data()&( (1<<ETL_FASTANGLE_LOOKUP_RES)-1)]; }
}; // END of class fastangle::sin

/*! ========================================================================
** \class	fastangle::cos
** \brief	fastangle representation as a cosine function
**
** A more detailed description needs to be written.
*/
class fastangle::cos : public fastangle
{
public:
	cos(const value_type &x)	{ v.data()=(1<<(ETL_FASTANGLE_LOOKUP_RES-2))-_fastangle_asin_table[(int)((x+1)*(value_type)(1<<(ETL_FASTANGLE_LOOKUP_RES-1)))]; }
	cos(const fastangle &a):fastangle(a) { }
	cos	mod()const { return fastangle::mod(); }
	cos dist(const fastangle &rhs)const { return fastangle::dist(rhs); }
	operator value_type()const { return get(); }
	value_type get()const { return (value_type)_fastangle_sin_table[(v.data()+(1<<(ETL_FASTANGLE_LOOKUP_RES-2)))&( (1<<ETL_FASTANGLE_LOOKUP_RES)-1)]; }
}; // END of class fastangle::cos

/*! ========================================================================
** \class	fastangle::tan
** \brief	fastangle representation as a tangent function
**
** A more detailed description needs to be written.
*/
class fastangle::tan : public fastangle
{
public:
	tan(const value_type &x)
	{
		if(x>1)
			v.data()=(1<<(ETL_FASTANGLE_LOOKUP_RES-2))-_fastangle_atan_table[(int)(((1.0/x)+1)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))];
		else if(x<-1)
			v.data()=-(1<<(ETL_FASTANGLE_LOOKUP_RES-1)) + (1<<(ETL_FASTANGLE_LOOKUP_RES-2)) - _fastangle_atan_table[(int)(((1.0/x)+1)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))];
		else
			v.data()=_fastangle_atan_table[(int)((x+1)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))];
	}

	tan(const value_type &y,const value_type &x)
	{
		if(x>=0 && y>=0) // First quadrant
		{
			if(y>x)
				v.data()=(1<<(ETL_FASTANGLE_LOOKUP_RES-2))-_fastangle_atan_table[(int)(((x/y)+1)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))];
			else
				v.data()=_fastangle_atan_table[(int)(((y/x)+1)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))];
		}
		else if(x>=0 && y<0) // Fourth quadrant
		{
			if(-y>x)
				v.data()=-(1<<(ETL_FASTANGLE_LOOKUP_RES-1)) + (1<<(ETL_FASTANGLE_LOOKUP_RES-2))-_fastangle_atan_table[(int)(((x/y)+1.0)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))];
			else
				v.data()=_fastangle_atan_table[(int)(((y/x)+1.0)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))];
		}
		else if(x<0 && y>=0) // Second quadrant
		{
			if(y>-x)
				v.data()=(1<<(ETL_FASTANGLE_LOOKUP_RES-2))-_fastangle_atan_table[(int)(((x/y)+1.0)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))];
			else
				v.data()=_fastangle_atan_table[(int)(((y/x)+1.0)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))]+(1<<(ETL_FASTANGLE_LOOKUP_RES-1));
		}
		else if(x<0 && y<0) // Third Quadrant
		{
			if(-y>-x)
				v.data()=(1<<(ETL_FASTANGLE_LOOKUP_RES-2))-_fastangle_atan_table[(int)(((x/y)+1.0)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))] - (1<<(ETL_FASTANGLE_LOOKUP_RES-1));
			else
				v.data()=_fastangle_atan_table[(int)(((y/x)+1.0)*(value_type)((1<<(ETL_FASTANGLE_LOOKUP_RES-1))-1))]-(1<<(ETL_FASTANGLE_LOOKUP_RES-1));
		}
		else v.data()=0;
	}
	tan(const fastangle &a):fastangle(a) { }
	tan	mod()const { return fastangle::mod(); }
	tan dist(const fastangle &rhs)const { return fastangle::dist(rhs); }
	operator value_type()const { return get(); }
	value_type get()const { return (value_type)_fastangle_tan_table[v.data()&( (1<<ETL_FASTANGLE_LOOKUP_RES)-1)]; }
}; // END of class fastangle::tan

_ETL_END_NAMESPACE

template <>
struct affine_combo<etl::fastangle,float>
{
	etl::fastangle operator()(const etl::fastangle &a,const etl::fastangle &b,const float &t)const
	{
		return b.dist(a)*t+a;
	}

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

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

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

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

#endif