TAngle< T > Class Template Reference
[Representation of angles.]

Generic Angle Class. More...

#include <angle.h>

List of all members.

Accessors
	operator T () const throw ()
	Cast operator.
T	toRadian () const throw ()
	Return the value of the angle.
T	toDegree () const throw ()
	Return the value of the angle.
void	normalize (Range range) throw ()
	Normalize the angle over a given range.
void	negate () throw ()
	Negate the angle.
TAngle	operator+ () const throw ()
	Positive sign.
TAngle	operator- () const throw ()
	Negative sign.
TAngle &	operator+= (const TAngle &angle) throw ()
	Addition operator.
TAngle &	operator+= (const T &val) throw ()
	Add a value to this angle.
TAngle	operator+ (const TAngle &angle) throw ()
	Addition operator.
TAngle &	operator-= (const TAngle &angle) throw ()
	Substraction operator.
TAngle &	operator-= (const T &val) throw ()
	Substract a value from this angle.
TAngle	operator- (const TAngle &angle) throw ()
	Subtraction an angle from this angle.
TAngle &	operator *= (const TAngle &angle) throw ()
	Multiply an angle with this angle.
TAngle &	operator *= (const T &val) throw ()
	Multiply a value with this angle.
TAngle &	operator/= (const TAngle &angle) throw (Exception::DivisionByZero)
	Division operator.
TAngle &	operator/= (const T &val) throw (Exception::DivisionByZero)
	Divide this angle by a value.
TAngle	operator/ (const TAngle &val) throw (Exception::DivisionByZero)
	Divide this angle by a value.
T	toRadian (const T &degree) throw ()
	Calculate radians from degrees.
T	toDegree (const T &radian) throw ()
	Calculate degrees from radians.
Public Types
Enums
enum	Range { RANGE__UNLIMITED = 0, RANGE__UNSIGNED = 1, RANGE__SIGNED = 2 }
	form of the angle range: RANGE__UNLIMITED = 0 no limitations RANGE__UNSIGNED = 1 0 <= angle <= 360, 0 <= angle <= PI * 2 RANGE__SIGNED = 2 -180 <= angle <= 180, -PI <= angle <= PI
Public Member Functions
Constructors and Destructors
	TAngle () throw ()
	Default constructor.
	TAngle (const TAngle &angle) throw ()
	Copy constructor.
	TAngle (const T &new_value, bool radian=true) throw ()
	Detailed constructor.
virtual	~TAngle () throw ()
	Destructor.
virtual void	clear () throw ()
	Clear method The value is set to 0.
Assignment
void	swap (TAngle &angle) throw ()
	Swap the contents of two angles.
void	set (const T &new_value, bool radian=true) throw ()
	Assign a new value to the angle.
void	set (const TAngle &angle) throw ()
	Assign an Angle object from another.
TAngle &	operator= (const TAngle &angle) throw ()
	Assignment operator.
TAngle &	operator= (const T &new_value) throw ()
	Assignment operator for floats.
void	get (TAngle &angle) const throw ()
	Assign the value to another angle.
void	get (T &val, bool radian=true) const throw ()
	Assign the value to a variable of type T.
Predicates
bool	operator== (const TAngle &angle) const throw ()
	Equality operator.
bool	operator!= (const TAngle &angle) const throw ()
	Inequality operator This test uses Maths::isNotEqual instead of comparing the values directly.
bool	operator< (const TAngle &angle) const throw ()
	Is less operator.
bool	operator< (const T &val) const throw ()
	Is less operator.
bool	operator<= (const TAngle &angle) const throw ()
	Is less or equal operator.
bool	operator>= (const TAngle &angle) const throw ()
	Is greater or equal operator.
bool	operator> (const TAngle &angle) const throw ()
	Is greater operator.
bool	isEquivalent (TAngle angle) const throw ()
	Test whether two angles are equivalent.
Debugging and Diagnostics
bool	isValid () const throw ()
	Test whether instance is valid.
void	dump (std::ostream &s=std::cout, Size depth=0) const throw ()
	Internal state dump.
Public Attributes
Attributes
T	value
	The value.

---

Detailed Description

template<typename T>
class TAngle< T >

Generic Angle Class.

Use this class to describe angles. The TAngle class permits the conversion from degree to radians and is the return type of all functions used to calculate angles.

---

Constructor & Destructor Documentation

template<typename T> TAngle< T >::TAngle (   )  throw ()

Default constructor. Creates a new angle object. Its value is set to 0.

template<typename T> TAngle< T >::TAngle (  const TAngle< T > &  angle  )  throw ()

Copy constructor. Create a copy of a TAngle object. Copies are always shallow. Parameters: angle  the object to be copied

template<typename T> TAngle< T >::TAngle (  const T &  new_value, bool  radian = true )  throw () [explicit]

Detailed constructor. Create a new angle object and set its value to new_value. radian determines whether new_value is in radians or in degrees. Parameters: new_value  the value of the angle object radian  true if new_value is in radians, false otherwise

template<typename T> virtual TAngle< T >::~TAngle (   )  throw () [virtual]

Destructor.

---

Member Function Documentation

template<typename T> virtual void TAngle< T >::clear (   )  throw () [virtual]

Clear method The value is set to 0.

template<typename T> void TAngle< T >::dump (  std::ostream &  s = std::cout, Size  depth = 0 )  const throw ()

Internal state dump. Dump the current internal state of {*this} to the output ostream s with dumping depth depth . Parameters: s  - output stream where to output the internal state of {*this} depth  - the dumping depth

template<typename T> void TAngle< T >::get (  T &  val, bool  radian = true )  const throw ()

Assign the value to a variable of type T. Parameters: val  the variable to assign the value to radian  if set to true assigns the value in radians (default).

template<typename T> void TAngle< T >::get (  TAngle< T > &  angle  )  const throw ()

Assign the value to another angle. Parameters: angle  the angle to assign the value to

template<typename T> bool TAngle< T >::isEquivalent (  TAngle< T >  angle  )  const throw ()

Test whether two angles are equivalent. Both angles are normalized and afterwards compared with Maths::isEqual instead of comparing the values directly. Parameters: angle  the angle to compare with Returns: bool, true if {*this} angle is equal to value

template<typename T> bool TAngle< T >::isValid (   )  const throw ()

Test whether instance is valid. Always returns true Returns: bool true

template<typename T> void TAngle< T >::normalize (  Range  range  )  throw ()

Normalize the angle over a given range. RANGE__UNLIMITED = 0 no limitations. RANGE__UNSIGNED = 1 . RANGE__SIGNED = 2 . Parameters: range  the range of the angle

template<typename T> TAngle< T > & TAngle< T >::operator *= (  const T &  val  )  throw ()

Multiply a value with this angle. Parameters: val  the value to multiply by Returns: TAngle, {*this}

template<typename T> TAngle< T > & TAngle< T >::operator *= (  const TAngle< T > &  angle  )  throw ()

Multiply an angle with this angle. Parameters: angle  the angle to multiply by Returns: TAngle, {*this}

template<typename T> TAngle< T >::operator T (   )  const throw ()

Cast operator. Returns: value in radians

template<typename T> bool TAngle< T >::operator!= (  const TAngle< T > &  angle  )  const throw ()

Inequality operator This test uses Maths::isNotEqual instead of comparing the values directly. Parameters: angle  the angle to compare with Returns: bool, true if the two angles are not equal

template<typename T> TAngle< T > TAngle< T >::operator+ (  const TAngle< T > &  angle  )  throw ()

Addition operator. Parameters: angle  the angle to add Returns: TAngle, the new angle

template<typename T> TAngle< T > TAngle< T >::operator+ (   )  const throw ()

Positive sign.

template<typename T> TAngle< T > & TAngle< T >::operator+= (  const T &  val  )  throw ()

Add a value to this angle. Parameters: val  the value to add Returns: TAngle, {*this}

template<typename T> TAngle< T > & TAngle< T >::operator+= (  const TAngle< T > &  angle  )  throw ()

Addition operator. Parameters: angle  the angle to add Returns: TAngle, {*this}

template<typename T> TAngle< T > TAngle< T >::operator- (  const TAngle< T > &  angle  )  throw ()

Subtraction an angle from this angle. Parameters: angle  the angle to substract Returns: TAngle, the new angle

template<typename T> TAngle< T > TAngle< T >::operator- (   )  const throw ()

Negative sign.

template<typename T> TAngle< T > & TAngle< T >::operator-= (  const T &  val  )  throw ()

Substract a value from this angle. Parameters: val  the value to substract Returns: TAngle, {*this}

template<typename T> TAngle< T > & TAngle< T >::operator-= (  const TAngle< T > &  angle  )  throw ()

Substraction operator. Parameters: angle  the angle to substract Returns: TAngle, {*this}

template<typename T> TAngle< T > TAngle< T >::operator/ (  const TAngle< T > &  val  )  throw (Exception::DivisionByZero)

Divide this angle by a value. Parameters: val  the angle to divide by Returns: TAngle, the new angle

template<typename T> TAngle< T > & TAngle< T >::operator/= (  const T &  val  )  throw (Exception::DivisionByZero)

Divide this angle by a value. Parameters: val  the angle to divide by Returns: TAngle, {*this}

template<typename T> TAngle< T > & TAngle< T >::operator/= (  const TAngle< T > &  angle  )  throw (Exception::DivisionByZero)

Division operator. Parameters: angle  the angle to divide by Returns: TAngle, {*this}

template<typename T> bool TAngle< T >::operator< (  const T &  val  )  const throw ()

Is less operator. This test uses Maths::isLess instead of comparing the values directly. Parameters: val  the value to compare with Returns: bool, true if {*this} angle is smaller than value

template<typename T> bool TAngle< T >::operator< (  const TAngle< T > &  angle  )  const throw ()

Is less operator. This test uses Maths::isLess instead of comparing the values directly. Parameters: angle  the angle to compare with Returns: bool, true if {*this} angle is smaller than value

template<typename T> bool TAngle< T >::operator<= (  const TAngle< T > &  angle  )  const throw ()

Is less or equal operator. This test uses Maths::isLessOrEqual instead of comparing the values directly. Parameters: angle  the angle to compare with Returns: bool, true if {*this} angle is smaller or equal than value

template<typename T> TAngle< T > & TAngle< T >::operator= (  const T &  new_value  )  throw ()

Assignment operator for floats. Assign a float value to the angle. The assigned value has to be in radians! Parameters: new_value  the new value

template<typename T> bool TAngle< T >::operator== (  const TAngle< T > &  angle  )  const throw ()

Equality operator. This test uses Maths::isEqual instead of comparing the values directly. Parameters: angle  the angle to compare with Returns: bool, true if the two angles are equal

template<typename T> bool TAngle< T >::operator> (  const TAngle< T > &  angle  )  const throw ()

Is greater operator. This test uses Maths::isGreater instead of comparing the values directly. Parameters: angle  the angle to compare with Returns: bool, true if {*this} angle is greater than value

template<typename T> bool TAngle< T >::operator>= (  const TAngle< T > &  angle  )  const throw ()

Is greater or equal operator. This test uses Maths::isGreaterOrEqual instead of comparing the values directly. Parameters: angle  the angle to compare with Returns: bool, true if {*this} angle is greater or equal than value

template<typename T> void TAngle< T >::set (  const TAngle< T > &  angle  )  throw ()

Assign an Angle object from another. Parameters: angle  the angle object to be assigned from

template<typename T> void TAngle< T >::set (  const T &  new_value, bool  radian = true )  throw ()

Assign a new value to the angle. radian determines whether new_value is in radians or in degrees. Parameters: new_value  the value of the angle object radian  true if new_value is in radians, false otherwise

template<typename T> void TAngle< T >::swap (  TAngle< T > &  angle  )  throw ()

Swap the contents of two angles.

template<typename T> T TAngle< T >::toDegree (  const T &  radian  )  throw () [static]

Calculate degrees from radians. Parameters: radian  the value in radians Returns: T the value in degrees

template<typename T> T TAngle< T >::toDegree (   )  const throw ()

Return the value of the angle. Returns: value in degrees

template<typename T> T TAngle< T >::toRadian (  const T &  degree  )  throw () [static]

Calculate radians from degrees. Parameters: degree  the value in degrees Returns: T the value in radians

template<typename T> T TAngle< T >::toRadian (   )  const throw ()

Return the value of the angle. Returns: value in radians