d2/point.h

   1 // Copyright 2002 David Hilvert <dhilvert@auricle.dyndns.org>,
   2 //                              <dhilvert@ugcs.caltech.edu>
   3
   4 /*  This file is part of the Anti-Lamenessing Engine.
   5
   6     The Anti-Lamenessing Engine is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 3 of the License, or
   9     (at your option) any later version.
  10
  11     The Anti-Lamenessing Engine is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with the Anti-Lamenessing Engine; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 #ifndef __d2point_h__
  22 #define __d2point_h__
  23
  24 /*
  25  * Structure to describe a point
  26  */
  27
  28 class point {
  29 private:
  30         ale_pos x[2];
  31
  32 public:
  33         point() {
  34         }
  35
  36         point(ale_pos x0, ale_pos x1) {
  37                 x[0] = x0;
  38                 x[1] = x1;
  39         }
  40
  41         const ale_pos &operator[](unsigned int i) const {
  42 #if 0
  43                 /*
  44                  * This may be expensive.
  45                  */
  46                 assert (i < 2);
  47 #endif
  48
  49                 return x[i];
  50         }
  51
  52         ale_pos &operator[](unsigned int i) {
  53 #if 0
  54                 /*
  55                  * This may be expensive.
  56                  */
  57                 assert (i < 2);
  58 #endif
  59
  60                 return x[i];
  61         }
  62
  63         point operator+(point p) const {
  64                 return point(p[0] + x[0], p[1] + x[1]);
  65         }
  66
  67         point operator-(point p) const {
  68                 return point(x[0] - p[0], x[1] - p[1]);
  69         }
  70
  71         point operator-() const {
  72                 return point(-x[0], -x[1]);
  73         }
  74
  75         point operator+=(point p) {
  76                 (*this) = (*this) + p;
  77
  78                 return *this;
  79         }
  80
  81         point operator-=(point p) {
  82                 (*this) = (*this) - p;
  83
  84                 return *this;
  85         }
  86
  87         point mult(ale_pos d) const {
  88                 return point(x[0] * d, x[1] * d);
  89         }
  90
  91         point operator*(point p) const {
  92                 /*
  93                  * element-wise multiplication
  94                  */
  95                 return point(x[0] * p[0], x[1] * p[1]);
  96         }
  97
  98         point operator *=(ale_pos d) {
  99                 (*this) = mult(d);
 100                 return *this;
 101         }
 102
 103         point operator/(ale_pos d) const {
 104                 return point(x[0] / d, x[1] / d);
 105         }
 106
 107         ale_pos normsq() const {
 108                 return x[0] * x[0] + x[1] * x[1];
 109         }
 110
 111         ale_pos norm() const {
 112                 return sqrt(normsq());
 113         }
 114
 115         ale_pos absmaxnorm() const {
 116                 ale_pos a = fabs(x[0]);
 117                 ale_pos b = fabs(x[1]);
 118
 119                 return (a > b) ? a : b;
 120         }
 121
 122         ale_pos lengthtosq(point p) const {
 123                 point diff = operator-(p);
 124
 125                 return diff[0] * diff[0] + diff[1] * diff[1];
 126         }
 127         ale_pos lengthto(point p) const {
 128                 return sqrt(lengthtosq(p));
 129         }
 130
 131         ale_pos dproduct(point p) const {
 132                 return (x[0] * p[0] + x[1] * p[1]);
 133         }
 134
 135         ale_pos anglebetw(point p, point q) {
 136                 /*
 137                  * by the law of cosines, the cosine is equal to:
 138                  *
 139                  *      (lengthtosq(p) + lengthtosq(q) - p.lengthtosq(q))
 140                  *    / (2 * lengthto(p) * lengthto(q))
 141                  */
 142
 143                 ale_pos to_p = lengthtosq(p);
 144                 ale_pos to_q = lengthtosq(q);
 145
 146                 ale_pos cos_of = (double) (to_p + to_q - p.lengthtosq(q))
 147                                / (2 * sqrt(to_p) * sqrt(to_q));
 148
 149                 return acos(cos_of);
 150         }
 151
 152         static point posinf() {
 153                 ale_pos a = +1;
 154                 ale_pos z = +0;
 155
 156                 a = a / z;
 157
 158                 assert (isinf(a) && a > 0);
 159
 160                 return point(a, a);
 161         }
 162
 163         static point neginf() {
 164                 point n = -posinf();
 165
 166                 assert (isinf(n[0]) && n[0] < 0);
 167
 168                 return n;
 169         }
 170
 171         void accumulate_max(point p) {
 172                 for (int d = 0; d < 2; d++)
 173                         if (p[d] > x[d])
 174                                 x[d] = p[d];
 175         }
 176
 177         void accumulate_min(point p) {
 178                 for (int d = 0; d < 2; d++)
 179                         if (p[d] < x[d])
 180                                 x[d] = p[d];
 181         }
 182
 183         static point undefined() {
 184                 double a = 0;
 185
 186                 point p(0, 0);
 187
 188                 return p / a;
 189         }
 190
 191         int defined() const {
 192                 return (!isnan(x[0])
 193                      && !isnan(x[1]));
 194         }
 195
 196         int finite() const {
 197                 return (::finite(x[0])
 198                      && ::finite(x[1]));
 199         }
 200
 201         static int defined(const point &p) {
 202                 return p.defined();
 203         }
 204 };
 205
 206 inline point operator*(const point &p, double d) {
 207         return p.mult(d);
 208 }
 209 inline point operator*(double d, const point &p) {
 210         return p.mult(d);
 211 }
 212 inline point operator*(float d, const point &p) {
 213         return p.mult(d);
 214 }
 215 #endif