graphiq/library/geometric/angle.h

   1 #ifndef ANGLE_CLASS
   2 #define ANGLE_CLASS
   3
   4 /*****************************************************************************\
   5 *                                                                             *
   6 *  Name   : angle                                                             *
   7 *  Author : Chris Koeritz                                                     *
   8 *                                                                             *
   9 *******************************************************************************
  10 * Copyright (c) 1992-$now By Author.  This program is free software; you can  *
  11 * redistribute it and/or modify it under the terms of the GNU General Public  *
  12 * License as published by the Free Software Foundation; either version 2 of   *
  13 * the License or (at your option) any later version.  This is online at:      *
  14 *     http://www.fsf.org/copyleft/gpl.html                                    *
  15 * Please send any updates to: fred@gruntose.com                               *
  16 \*****************************************************************************/
  17
  18 #include <basis/byte_array.h>
  19 #include <basis/common_outcomes.h>
  20 #include <basis/contracts.h>
  21 #include <structures/object_packers.h>
  22
  23 #include <math.h>
  24
  25 namespace geometric {
  26
  27 //! Represents a geometric angle.
  28
  29 //! angles can be measured in degrees or radians in this class.
  30 enum angular_units { DEGREES, RADIANS };
  31
  32 template <class contents>
  33 class angle : public basis::packable
  34 {
  35 public:
  36   DEFINE_CLASS_NAME("angle");
  37
  38   angle(contents inital_rotation = 0, angular_units unit = RADIANS);
  39     //!< constructs a new angle with "initial_rotation" in the "unit".
  40
  41   void set(contents a, angular_units unit);
  42     //!< sets the angle to a new rotation "a" in the "unit".
  43   contents get(angular_units unit) const;
  44     //!< retrieves the current angular measure.
  45
  46   angle operator - (void) const;
  47     //!< returns the negation of this angle.
  48
  49   angle operator + (const angle &to_add) const;
  50   angle operator - (const angle &to_subtract) const;
  51   angle operator * (contents to_multiply) const;
  52   angle operator / (contents to_divide) const;
  53   angle &operator += (const angle &to_add);
  54   angle &operator -= (const angle &to_subtract);
  55   angle &operator *= (contents to_multiply);
  56   angle &operator /= (contents to_divide);
  57
  58   contents sine() const;
  59     //!< returns the sin function of this angle.
  60   contents cosine() const;
  61     //!< returns the cos function of this angle.
  62   contents tangent() const;
  63     //!< returns the tan function of this angle.
  64
  65   static angle arctangent(contents opposite, contents adjacent,
  66           basis::outcome &retval);
  67     //!< returns the atan of the angle.
  68     /*!< the outcome will be set to OKAY if the function operated successfully.
  69     otherwise it will be set to BAD_INPUT. */
  70   static angle arccosine(contents adjacent, contents hypotenuse,
  71           basis::outcome &retval);
  72     //!< returns the acos of the angle.
  73   static angle arcsine(contents opposite, contents hypotenuse,
  74           basis::outcome &retval);
  75     //!< returns the asin of the angle.
  76
  77   virtual int packed_size() const;
  78   virtual void pack(basis::byte_array &packed_form) const;
  79     //!< packs the angle for shipping in bytes.
  80   virtual bool unpack(basis::byte_array &packed_form);
  81     //!< unpacks the angle from the "packed_form".
  82
  83 private:
  84   contents _theta;  //!< the held angular measure.
  85
  86   contents to_internal(contents initial, angular_units unit) const;
  87     //!< converts the angle into the units we use inside the class.
  88   contents from_internal(contents initial, angular_units unit) const;
  89     //!< converts the angle from our internal measure into "unit" measure.
  90 };
  91
  92 //////////////
  93
  94 //! double_angle provides a non-templated class for forward declarations.
  95
  96 class double_angle : public angle<double>
  97 {
  98 public:
  99   double_angle(double init = 0, angular_units unit = RADIANS)
 100       : angle<double>(init, unit) {}
 101   double_angle(const angle<double> &to_copy) : angle<double>(to_copy) {}
 102 };
 103
 104 //////////////
 105
 106 // implementation of larger methods below.
 107
 108 template <class contents>
 109 angle<contents>::angle(contents a, angular_units unit) { set(a, unit); }
 110
 111 template <class contents>
 112 angle<contents> angle<contents>::operator - (void) const
 113 { angle<contents> to_return(*this); to_return *= -1; return to_return; }
 114
 115 template <class contents>
 116 angle<contents> angle<contents>::operator + (const angle<contents> &a) const
 117 { angle<contents> to_return(*this); to_return += a; return to_return; }
 118
 119 template <class contents>
 120 angle<contents> angle<contents>::operator - (const angle<contents> &a) const
 121 { angle<contents> to_return(*this); to_return -= a; return to_return; }
 122
 123 template <class contents>
 124 angle<contents> angle<contents>::operator * (contents to_multiply) const
 125 {
 126   angle<contents> to_return(*this);
 127   to_return *= to_multiply;
 128   return to_return;
 129 }
 130
 131 template <class contents>
 132 angle<contents> angle<contents>::operator / (contents to_divide) const
 133 { angle<contents> to_return(*this); to_return /= to_divide; return to_return; }
 134
 135 template <class contents>
 136 angle<contents> &angle<contents>::operator += (const angle<contents> &a)
 137 { _theta += a._theta; return *this; }
 138
 139 template <class contents>
 140 angle<contents> &angle<contents>::operator -= (const angle<contents> &a)
 141 { _theta -= a._theta; return *this; }
 142
 143 template <class contents>
 144 angle<contents> &angle<contents>::operator *= (contents f)
 145 { _theta *= f; return *this; }
 146
 147 template <class contents>
 148 angle<contents> &angle<contents>::operator /= (contents f)
 149 { _theta /= f; return *this; }
 150
 151 template <class contents>
 152 contents angle<contents>::sine() const { return sin(_theta); }
 153
 154 template <class contents>
 155 contents angle<contents>::cosine() const { return cos(_theta); }
 156
 157 template <class contents>
 158 contents angle<contents>::tangent() const { return tan(_theta); }
 159
 160 template <class contents>
 161 int angle<contents>::packed_size() const
 162 {
 163   basis::byte_array temp;
 164 //hmmm: inefficient!
 165   pack(temp);
 166   return temp.length();
 167 }
 168
 169 template <class contents>
 170 void angle<contents>::pack(basis::byte_array &packed_form) const
 171 { structures::attach(packed_form, _theta); }
 172
 173 template <class contents>
 174 bool angle<contents>::unpack(basis::byte_array &packed_form)
 175 { return structures::detach(packed_form, _theta); }
 176
 177 template <class contents>
 178 contents angle<contents>::to_internal(contents a, angular_units unit) const
 179 {
 180   switch(unit) {
 181     case RADIANS: return a;
 182     case DEGREES: return a * PI_APPROX / 180.0;
 183     default: return 0;
 184   }
 185 }
 186
 187 template <class contents>
 188 contents angle<contents>::from_internal(contents a, angular_units unit) const
 189 {
 190   switch(unit) {
 191     case RADIANS: return a;
 192     case DEGREES: return a * 180.0 / PI_APPROX;
 193     default: return 0;
 194   }
 195 }
 196
 197 template <class contents>
 198 void angle<contents>::set(contents a, angular_units unit)
 199 { _theta = to_internal(a, unit); }
 200
 201 template <class contents>
 202 contents angle<contents>::get(angular_units unit) const
 203 { return from_internal(_theta, unit); }
 204
 205 template <class contents>
 206 angle<contents> angle<contents>::arccosine(contents adjacent,
 207     contents hypotenuse, basis::outcome &retval)
 208 {
 209   contents d = adjacent / hypotenuse;
 210   retval = basis::common::BAD_INPUT;
 211   bounds_return(d, -1.0, 1.0, angle<contents>());
 212   retval = basis::common::OKAY;
 213   return angle<contents>(acos(d), RADIANS);
 214 }
 215
 216 template <class contents>
 217 angle<contents> angle<contents>::arcsine(contents opposite, contents hypotenuse,
 218     basis::outcome &retval)
 219 {
 220   contents d = opposite / hypotenuse;
 221   retval = basis::common::BAD_INPUT;
 222   bounds_return(d, -1.0, 1.0, angle<contents>());
 223   retval = basis::common::OKAY;
 224   return angle<contents>(asin(d), RADIANS);
 225 }
 226
 227 template <class contents>
 228 angle<contents> angle<contents>::arctangent(contents opposite, contents adjacent,
 229     basis::outcome &retval)
 230 {
 231   retval = basis::common::BAD_INPUT;
 232   if ( (adjacent == 0.0) && (opposite == 0.0) ) return angle<contents>();
 233   retval = basis::common::OKAY;
 234   return angle<contents>(atan2(opposite, adjacent), RADIANS);
 235 }
 236
 237 } // namespace.
 238
 239 #endif
 240