coordinate_2d.tpp
/*
CLAW - a C++ Library Absolutely Wonderful
CLAW is a free library without any particular aim but being useful to
anyone.
Copyright (C) 2005-2011 Julien Jorge
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
contact: julien.jorge@gamned.org
*/
/**
* \file coordinate_2d.tpp
* \brief Implementation of claw::math::coordinate_2d class.
* \author Julien Jorge
*/
#include <cmath>
/*----------------------------------------------------------------------------*/
/**
* \brief Constructor.
*/
template<typename T>
claw::math::coordinate_2d<T>::coordinate_2d()
{
} // coordinate_2d::coordinate_2d() [constructor]
/*----------------------------------------------------------------------------*/
/**
* \brief Copy constructor.
*/
template<typename T>
template<typename U>
claw::math::coordinate_2d<T>::coordinate_2d(const coordinate_2d<U>& that)
: x(that.x), y(that.y)
{
} // coordinate_2d::coordinate_2d() [copy constructor]
/*----------------------------------------------------------------------------*/
/**
* \brief Constructor with initialization.
* \param _x x value.
* \param _y y Value.
*/
template<typename T>
claw::math::coordinate_2d<T>::coordinate_2d
(const value_type& _x, const value_type& _y)
: x(_x), y(_y)
{
} // coordinate_2d::coordinate_2d() [constructor whit values]
/*----------------------------------------------------------------------------*/
/**
* \brief Get a copy of the rectangle by converting its members to a given type.
*
* Consider the following code:
*
* <tt> coordinate_2d<float> a;
*
* ...
*
* coordinate_2d<int> b(a); </tt>
*
* The copy constructor will be called, and your compiler should print some
* warnings in your console. These warnings have a meaning, so we don't wan't to
* make them disapear by adding explicit type conversion inside the
* coordinate_2d class nor adding a cast operator that will be used silently by
* the compiler.
*
* If you really want to convert the type, this method will explicitly cast the
* member variables.
*/
template<class T>
template<typename U>
claw::math::coordinate_2d<U>
claw::math::coordinate_2d<T>::cast_value_type_to() const
{
return claw::math::coordinate_2d<U>( (U)x, (U)y );
} // coordinate_2d::cast_value_type_to()
/*----------------------------------------------------------------------------*/
/**
* \brief Sets new values to the coordinate.
* \param _x New x value.
* \param _y New y Value.
*/
template<typename T>
void
claw::math::coordinate_2d<T>::set(const value_type& _x, const value_type& _y)
{
x = _x;
y = _y;
} // coordinate_2d::set()
/*----------------------------------------------------------------------------*/
/**
* \brief Get the distance separing two coordinates.
* \param p The second coordinate
*/
template<typename T>
typename claw::math::coordinate_2d<T>::value_type
claw::math::coordinate_2d<T>::distance(const self_type& p) const
{
return (value_type)sqrt( (p.x - x)*(p.x - x) + (p.y - y)*(p.y - y) );
} // coordinate_2d::distance()
/*----------------------------------------------------------------------------*/
/**
* \brief Rotate this point around an other point.
* \param center The other point.
* \param angle The angle of the rotation.
*/
template<typename T>
void
claw::math::coordinate_2d<T>::rotate( const self_type& center, double angle )
{
self_type result(center);
result.x +=
(x - center.x) * std::cos(angle) - (y - center.y) * std::sin(angle);
result.y +=
(x - center.x) * std::sin(angle) + (y - center.y) * std::cos(angle);
*this = result;
} // coordinate_2d::rotate()
/*----------------------------------------------------------------------------*/
/**
* \brief Get the angle of the slope starting from this and ending with an other
* coordinate.
* \param to The other point.
*/
template<typename T>
double claw::math::coordinate_2d<T>::slope_angle( const self_type& to ) const
{
return std::atan2( to.y - y, to.x - x );
} // coordinate_2d::slope_angle()
/*----------------------------------------------------------------------------*/
/**
* \brief Equality operator.
* \param that Coordinate to compare to.
*/
template<typename T>
bool claw::math::coordinate_2d<T>::operator==(const self_type& that) const
{
return (x == that.x) && (y == that.y);
} // coordinate_2d::operator==()
/*----------------------------------------------------------------------------*/
/**
* \brief Difference operator.
* \param that Coordinate to compare to.
*/
template<typename T>
bool claw::math::coordinate_2d<T>::operator!=(const self_type& that) const
{
return !(*this == that);
} // coordinate_2d::operator!=()
/*----------------------------------------------------------------------------*/
/**
* \brief Addition.
* \param that Coordinate to add.
*/
template<typename T>
claw::math::coordinate_2d<T>
claw::math::coordinate_2d<T>::operator+(const self_type& that) const
{
return self_type( x + that.x, y + that.y );
} // coordinate_2d::operator+()
/*----------------------------------------------------------------------------*/
/**
* \brief Subtraction.
* \param that Coordinate to subtract.
*/
template<typename T>
claw::math::coordinate_2d<T>
claw::math::coordinate_2d<T>::operator-(const self_type& that) const
{
return self_type( x - that.x, y - that.y );
} // coordinate_2d::operator-()
/*----------------------------------------------------------------------------*/
/**
* \brief Add a coordinate.
* \param that Coordinate to add.
*/
template<typename T>
claw::math::coordinate_2d<T>&
claw::math::coordinate_2d<T>::operator+=(const self_type& that)
{
x += that.x;
y += that.y;
return *this;
} // coordinate_2d::operator+=()
/*----------------------------------------------------------------------------*/
/**
* \brief Subtract a coordinate.
* \param that Coordinate to subtract.
*/
template<typename T>
claw::math::coordinate_2d<T>&
claw::math::coordinate_2d<T>::operator-=(const self_type& that)
{
x -= that.x;
y -= that.y;
return *this;
} // coordinate_2d::operator-=()
/*----------------------------------------------------------------------------*/
/**
* \brief Multiplication.
* \param v Factor.
*/
template<typename T>
claw::math::coordinate_2d<T>
claw::math::coordinate_2d<T>::operator*(const value_type& v) const
{
return self_type( x * v, y * v );
} // coordinate_2d::operator*()
/*----------------------------------------------------------------------------*/
/**
* \brief Division.
* \param v Divider.
*/
template<typename T>
claw::math::coordinate_2d<T>
claw::math::coordinate_2d<T>::operator/(const value_type& v) const
{
return self_type( x / v, y / v );
} // coordinate_2d::operator/()
/*----------------------------------------------------------------------------*/
/**
* \brief Multiply the coordinates.
* \param v Factor.
*/
template<typename T>
claw::math::coordinate_2d<T>&
claw::math::coordinate_2d<T>::operator*=(const value_type& v)
{
x *= v;
y *= v;
return *this;
} // coordinate_2d::operator*=()
/*----------------------------------------------------------------------------*/
/**
* \brief Divide the coordinates.
* \param v Divider.
*/
template<typename T>
claw::math::coordinate_2d<T>&
claw::math::coordinate_2d<T>::operator/=(const value_type& v)
{
x /= v;
y /= v;
return *this;
} // coordinate_2d::operator/=()
/*----------------------------------------------------------------------------*/
/**
* \brief Unary minus.
* \param that The operand...
*/
template<typename T>
claw::math::coordinate_2d<T>
claw::math::operator-( const claw::math::coordinate_2d<T>& that )
{
return claw::math::coordinate_2d<T>(-that.x, -that.y);
} // operator-() [coordinate_2d]
/*----------------------------------------------------------------------------*/
/**
* \brief Multiply coordinates.
* \param v The multiplicator.
* \param self The coordinates to multiply.
*/
template<typename T, typename U>
claw::math::coordinate_2d<T>
claw::math::operator*( U v, const coordinate_2d<T>& self )
{
return self * typename coordinate_2d<T>::value_type(v);
} // operator*() [coordinate_2d]