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                 assert (i < 2);
  43
  44                 return x[i];
  45         }
  46
  47         ale_pos &operator[](unsigned int i) {
  48                 assert (i < 2);
  49
  50                 return x[i];
  51         }
  52
  53         point operator+(point p) const {
  54                 return point(p[0] + x[0], p[1] + x[1]);
  55         }
  56
  57         point operator-(point p) const {
  58                 return point(x[0] - p[0], x[1] - p[1]);
  59         }
  60
  61         point operator-() const {
  62                 return point(-x[0], -x[1]);
  63         }
  64
  65         point operator+=(point p) {
  66                 (*this) = (*this) + p;
  67
  68                 return *this;
  69         }
  70
  71         point operator-=(point p) {
  72                 (*this) = (*this) - p;
  73
  74                 return *this;
  75         }
  76
  77         point mult(ale_real d) const {
  78                 return point(x[0] * d, x[1] * d);
  79         }
  80
  81         point operator*(point p) const {
  82                 /*
  83                  * element-wise multiplication
  84                  */
  85                 return point(x[0] * p[0], x[1] * p[1]);
  86         }
  87
  88         point operator *=(ale_real d) {
  89                 (*this) = mult(d);
  90                 return *this;
  91         }
  92
  93         point operator/(ale_real d) const {
  94                 return point(x[0] / d, x[1] / d);
  95         }
  96
  97         ale_pos normsq() const {
  98                 return x[0] * x[0] + x[1] * x[1];
  99         }
 100
 101         ale_pos norm() const {
 102                 return sqrt(normsq());
 103         }
 104
 105         ale_pos absmaxnorm() const {
 106                 ale_pos a = fabs(x[0]);
 107                 ale_pos b = fabs(x[1]);
 108
 109                 return (a > b) ? a : b;
 110         }
 111
 112         ale_pos lengthtosq(point p) const {
 113                 point diff = operator-(p);
 114
 115                 return diff[0] * diff[0] + diff[1] * diff[1];
 116         }
 117         ale_pos lengthto(point p) const {
 118                 return sqrt(lengthtosq(p));
 119         }
 120
 121         ale_pos dproduct(point p) const {
 122                 return (x[0] * p[0] + x[1] * p[1]);
 123         }
 124
 125         ale_pos anglebetw(point p, point q) {
 126                 /*
 127                  * by the law of cosines, the cosine is equal to:
 128                  *
 129                  *      (lengthtosq(p) + lengthtosq(q) - p.lengthtosq(q))
 130                  *    / (2 * lengthto(p) * lengthto(q))
 131                  */
 132
 133                 ale_pos to_p = lengthtosq(p);
 134                 ale_pos to_q = lengthtosq(q);
 135
 136                 ale_pos cos_of = (to_p + to_q - p.lengthtosq(q))
 137                                / (2 * sqrt(to_p) * sqrt(to_q));
 138
 139                 return acos(cos_of);
 140         }
 141
 142         static point posinf() {
 143                 double a = +1;
 144                 double z = +0;
 145
 146                 a = a / z;
 147
 148                 assert (isinf(a) && a > 0);
 149
 150                 return point(a, a);
 151         }
 152
 153         static point neginf() {
 154                 point n = -posinf();
 155
 156                 assert (isinf(n[0]) && n[0] < 0);
 157
 158                 return n;
 159         }
 160
 161         void accumulate_max(point p) {
 162                 for (int d = 0; d < 2; d++)
 163                         if (p[d] > x[d])
 164                                 x[d] = p[d];
 165         }
 166
 167         void accumulate_min(point p) {
 168                 for (int d = 0; d < 2; d++)
 169                         if (p[d] < x[d])
 170                                 x[d] = p[d];
 171         }
 172
 173         static point undefined() {
 174                 double a = 0;
 175
 176                 point p(0, 0);
 177
 178                 return p / a;
 179         }
 180
 181         int defined() const {
 182                 return (!isnan(x[0])
 183                      && !isnan(x[1]));
 184         }
 185
 186         int finite() const {
 187                 return (::finite(x[0])
 188                      && ::finite(x[1]));
 189         }
 190
 191         static int defined(const point &p) {
 192                 return p.defined();
 193         }
 194 };
 195
 196 inline point operator*(const point &p, double d) {
 197         return p.mult(d);
 198 }
 199 inline point operator*(double d, const point &p) {
 200         return p.mult(d);
 201 }
 202 inline point operator*(float d, const point &p) {
 203         return p.mult(d);
 204 }
 205 #endif