coordinate_2d.tpp

Go to the documentation of this file.

/*
  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
*/
#include <cmath>

/*----------------------------------------------------------------------------*/
template<typename T>
claw::math::coordinate_2d<T>::coordinate_2d()
{

} // coordinate_2d::coordinate_2d() [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]

/*----------------------------------------------------------------------------*/
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]

/*----------------------------------------------------------------------------*/
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()

/*----------------------------------------------------------------------------*/
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()

/*----------------------------------------------------------------------------*/
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()

/*----------------------------------------------------------------------------*/
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()

/*----------------------------------------------------------------------------*/
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()

/*----------------------------------------------------------------------------*/
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==()

/*----------------------------------------------------------------------------*/
template<typename T>
bool claw::math::coordinate_2d<T>::operator!=(const self_type& that) const
{
  return !(*this == that);
} // coordinate_2d::operator!=()

/*----------------------------------------------------------------------------*/
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+()

/*----------------------------------------------------------------------------*/
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-()

/*----------------------------------------------------------------------------*/
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+=()

/*----------------------------------------------------------------------------*/
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-=()

/*----------------------------------------------------------------------------*/
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*()

/*----------------------------------------------------------------------------*/
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/()

/*----------------------------------------------------------------------------*/
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*=()

/*----------------------------------------------------------------------------*/
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/=()

/*----------------------------------------------------------------------------*/
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]

/*----------------------------------------------------------------------------*/
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]