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