point.cpp

Go to the documentation of this file.

#ifndef POINT_IMPLEMENTATION
#define POINT_IMPLEMENTATION

/*****************************************************************************\
*                                                                             *
*  Name   : point                                                             *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1992-$now By Author.  This program 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 is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "angle.cpp"
#include "math_bits.h"
#include "point.h"

#include <basis/function.h>
#include <basis/istring.h>

#include <math.h>

// notes:
//
// - there is an odd breaking up of the expressions where we're taking a
//   square root because ms visual studio 7 has a bug of some sort that
//   convinces it that angle<int> is being used in there, although it's not.
//   these lines use a temporary named "sumsquar" to deconfuse the compiler. 

namespace geometric {

template <class numeric_type>
point<numeric_type>::point(numeric_type x, numeric_type y) { set(x, y); }

template <class numeric_type>
point<numeric_type>::point(numeric_type r, double_angle theta)
{ set(r, theta); }

template <class numeric_type>
istring point<numeric_type>::text_form() const
{
  numeric_type temp = 0;
  istring specifier(numeric_specifier(temp));
  istring sprintf_template(istring::SPRINTF, "(%s, %s)", specifier.s(), specifier.s());
  return istring(istring::SPRINTF, sprintf_template.s(), x(), y());
}

template <class numeric_type>
void point<numeric_type>::set(numeric_type x, numeric_type y)
{ _x = x; _y = y; }

template <class numeric_type>
numeric_type point<numeric_type>::r() const
{
  const double sumsquar = square(x()) + square(y());
  return numeric_type(sqrt(sumsquar)); 
}

template <class numeric_type>
void point<numeric_type>::set(numeric_type r, double_angle theta)
{ set(numeric_type(r * theta.cosine()), numeric_type(r * theta.sine())); }

template <class numeric_type>
numeric_type point<numeric_type>::distance(const point &p2) const
{
  const double sumsquar = square(p2.x() - x()) + square(p2.y() - y());
  return numeric_type(sqrt(sumsquar));
}

template <class numeric_type>
double_angle point<numeric_type>::theta() const
{
  outcome retval;
  return double_angle::arctangent(y(), x(), retval);
}

template <class contents>
void point<contents>::pack(byte_array &packed_form) const
{
  basis::attach(packed_form, _x);
  basis::attach(packed_form, _y);
}

template <class contents>
bool point<contents>::unpack(byte_array &packed_form)
{
  if (!basis::detach(packed_form, _x)) return false;
  if (!basis::detach(packed_form, _y)) return false;
  return true;
}

template <class numeric_type>
numeric_type point<numeric_type>::magnitude() const
{
  const double sumsquar = square(x()) + square(y());
  return numeric_type(sqrt(sumsquar)); 
}

template <class numeric_type>
point<numeric_type> point<numeric_type>::operator + (const point &arg2) const
{ return point<numeric_type>(x() + arg2.x(), y() + arg2.y()); }

template <class numeric_type>
point<numeric_type> point<numeric_type>::operator - (const point &arg2) const
{ return point<numeric_type>(x() - arg2.x(), y() - arg2.y()); }

template <class numeric_type>
point<numeric_type> &point<numeric_type>::operator += (const point &arg2)
{ _x += arg2.x(); _y += arg2.y(); return *this; }

template <class numeric_type>
point<numeric_type> &point<numeric_type>::operator -= (const point &arg2)
{ _x -= arg2.x(); _y -= arg2.y(); return *this; }

template <class numeric_type>
bool point<numeric_type>::operator == (const point &arg2) const
{
// this bit should be part of the floating point stuff...
  double epsilon = 1e-10;
  return (absolute_value(x() - arg2.x()) <= epsilon)
      && (absolute_value(y() - arg2.y()) <= epsilon);
}

//move to header.
template <class numeric_type>
bool point<numeric_type>::operator != (const point &arg2) const
{ return !(*this == arg2); }

template <class numeric_type>
point<numeric_type> point<numeric_type>::rotate
    (const double_angle &theta) const
{
  numeric_type tempX = x();
  numeric_type tempY = y();
  numeric_type temp1 = numeric_type(tempX * theta.cosine()
      - tempY * theta.sine());
  numeric_type temp2 = numeric_type(tempX * theta.sine() 
      + tempY * theta.cosine());
  return point<numeric_type>(temp1, temp2);
}

template <class numeric_type>
bool point<numeric_type>::from_text(const istring &_text)
{
  numeric_type x = 0, y = 0;
  istring text(_text);
  // chop junk off the front.
  text = crop_non_numeric(text);
  // scan the string for values.
  x = text.convert(x);
  // remove the number.
  text = crop_numeric(text);
  // chop off more junk.
  text = crop_non_numeric(text);
  // get the next number.
  y = text.convert(y);
  set(x, y);
  return true;
}

} // namespace.

#endif

---