00001 /*
00002 File: Vec2.h
00003
00004 Function: Defines a length-2 vector.
00005
00006 Author(s): Andrew Willmott
00007
00008 Copyright: (c) 1995-2000, Andrew Willmott
00009 */
00010
00011 #ifndef __Vec2__
00012 #define __Vec2__
00013
00014 #include "vl/VL.h"
00015 // Defines the actual type for TVec2 etc.
00016
00017
00018 // --- Vec2 Class -------------------------------------------------------------
00019
00020
00021 class TVec2
00022 {
00023 public:
00024
00025 // Constructors
00026
00027 inline TVec2();
00028 inline TVec2(TVReal x, TVReal y); // (x, y)
00029 inline TVec2(const TVec2 &v); // Copy constructor
00030 inline TVec2(ZeroOrOne k); // v[i] = vl_zero
00031 inline TVec2(Axis k); // v[k] = 1
00032
00033 // Accessor functions
00034
00035 inline TVReal &operator [] (Int i); // v[1] - Has no Index
00036 inline const TVReal &operator [] (Int i) const; // check
00037
00038 inline Int Elts() const { return(2); };
00039 inline TVReal *Ref() const; // Return ptr to data
00040
00041 // Assignment operators
00042
00043 inline TVec2 &operator = (const TVec2 &a);
00044 inline TVec2 &operator = (ZeroOrOne k);
00045 inline TVec2 &operator = (Axis k);
00046
00047 inline TVec2 &operator += (const TVec2 &a);
00048 inline TVec2 &operator -= (const TVec2 &a);
00049 inline TVec2 &operator *= (const TVec2 &a);
00050 inline TVec2 &operator *= (TVReal s);
00051 inline TVec2 &operator /= (const TVec2 &a);
00052 inline TVec2 &operator /= (TVReal s);
00053
00054 // Comparison operators
00055
00056 inline Bool operator == (const TVec2 &a) const; // v == a?
00057 inline Bool operator != (const TVec2 &a) const; // v != a?
00058
00059 // Arithmetic operators
00060
00061 inline TVec2 operator + (const TVec2 &a) const; // v + a
00062 inline TVec2 operator - (const TVec2 &a) const; // v - a
00063 inline TVec2 operator - () const; // -v
00064 inline TVec2 operator * (const TVec2 &a) const; // v * a (vx * ax, ...)
00065 inline TVec2 operator * (TVReal s) const; // v * s
00066 inline TVec2 operator / (const TVec2 &a) const; // v / a (vx / ax, ...)
00067 inline TVec2 operator / (TVReal s) const; // v / s
00068
00069 // Initialisers
00070
00071 inline TVec2 &MakeZero(); // Zero vector
00072 inline TVec2 &MakeUnit(Int i, TVReal k = vl_one);// I[i]
00073 inline TVec2 &MakeBlock(TVReal k = vl_one); // All-k vector
00074
00075 inline TVec2 &Normalise(); // normalise vector
00076
00077 // Private...
00078
00079 protected:
00080
00081 TVReal elt[2];
00082 };
00083
00084
00085 // --- Vec operators ----------------------------------------------------------
00086
00087 inline TVec2 operator * (TVReal s, const TVec2 &v);// s * v
00088 inline TVReal dot(const TVec2 &a, const TVec2 &b);// v . a
00089 inline TVReal len(const TVec2 &v); // || v ||
00090 inline TVReal sqrlen(const TVec2 &v); // v . v
00091 inline TVec2 norm(const TVec2 &v); // v / || v ||
00092 inline Void normalise(TVec2 &v); // v = norm(v)
00093 inline TVec2 cross(const TVec2 &v); // cross prod.
00094
00095 ostream &operator << (ostream &s, const TVec2 &v);
00096 istream &operator >> (istream &s, TVec2 &v);
00097
00098
00099 // --- Inlines ----------------------------------------------------------------
00100
00101
00102 inline TVReal &TVec2::operator [] (Int i)
00103 {
00104 CheckRange(i, 0, 2, "(Vec2::[i]) index out of range");
00105 return(elt[i]);
00106 }
00107
00108 inline const TVReal &TVec2::operator [] (Int i) const
00109 {
00110 CheckRange(i, 0, 2, "(Vec2::[i]) index out of range");
00111 return(elt[i]);
00112 }
00113
00114 inline TVec2::TVec2()
00115 {
00116 }
00117
00118 inline TVec2::TVec2(TVReal x, TVReal y)
00119 {
00120 elt[0] = x;
00121 elt[1] = y;
00122 }
00123
00124 inline TVec2::TVec2(const TVec2 &v)
00125 {
00126 elt[0] = v[0];
00127 elt[1] = v[1];
00128 }
00129
00130 inline TVReal *TVec2::Ref() const
00131 {
00132 return((TVReal *) elt);
00133 }
00134
00135 inline TVec2 &TVec2::operator = (const TVec2 &v)
00136 {
00137 elt[0] = v[0];
00138 elt[1] = v[1];
00139
00140 return(SELF);
00141 }
00142
00143 inline TVec2 &TVec2::operator += (const TVec2 &v)
00144 {
00145 elt[0] += v[0];
00146 elt[1] += v[1];
00147
00148 return(SELF);
00149 }
00150
00151 inline TVec2 &TVec2::operator -= (const TVec2 &v)
00152 {
00153 elt[0] -= v[0];
00154 elt[1] -= v[1];
00155
00156 return(SELF);
00157 }
00158
00159 inline TVec2 &TVec2::operator *= (const TVec2 &v)
00160 {
00161 elt[0] *= v[0];
00162 elt[1] *= v[1];
00163
00164 return(SELF);
00165 }
00166
00167 inline TVec2 &TVec2::operator *= (TVReal s)
00168 {
00169 elt[0] *= s;
00170 elt[1] *= s;
00171
00172 return(SELF);
00173 }
00174
00175 inline TVec2 &TVec2::operator /= (const TVec2 &v)
00176 {
00177 elt[0] /= v[0];
00178 elt[1] /= v[1];
00179
00180 return(SELF);
00181 }
00182
00183 inline TVec2 &TVec2::operator /= (TVReal s)
00184 {
00185 elt[0] /= s;
00186 elt[1] /= s;
00187
00188 return(SELF);
00189 }
00190
00191 inline TVec2 TVec2::operator + (const TVec2 &a) const
00192 {
00193 TVec2 result;
00194
00195 result[0] = elt[0] + a[0];
00196 result[1] = elt[1] + a[1];
00197
00198 return(result);
00199 }
00200
00201 inline TVec2 TVec2::operator - (const TVec2 &a) const
00202 {
00203 TVec2 result;
00204
00205 result[0] = elt[0] - a[0];
00206 result[1] = elt[1] - a[1];
00207
00208 return(result);
00209 }
00210
00211 inline TVec2 TVec2::operator - () const
00212 {
00213 TVec2 result;
00214
00215 result[0] = -elt[0];
00216 result[1] = -elt[1];
00217
00218 return(result);
00219 }
00220
00221 inline TVec2 TVec2::operator * (const TVec2 &a) const
00222 {
00223 TVec2 result;
00224
00225 result[0] = elt[0] * a[0];
00226 result[1] = elt[1] * a[1];
00227
00228 return(result);
00229 }
00230
00231 inline TVec2 TVec2::operator * (TVReal s) const
00232 {
00233 TVec2 result;
00234
00235 result[0] = elt[0] * s;
00236 result[1] = elt[1] * s;
00237
00238 return(result);
00239 }
00240
00241 inline TVec2 operator * (TVReal s, const TVec2 &v)
00242 {
00243 return(v * s);
00244 }
00245
00246 inline TVec2 TVec2::operator / (const TVec2 &a) const
00247 {
00248 TVec2 result;
00249
00250 result[0] = elt[0] / a[0];
00251 result[1] = elt[1] / a[1];
00252
00253 return(result);
00254 }
00255
00256 inline TVec2 TVec2::operator / (TVReal s) const
00257 {
00258 TVec2 result;
00259
00260 result[0] = elt[0] / s;
00261 result[1] = elt[1] / s;
00262
00263 return(result);
00264 }
00265
00266 inline TVReal dot(const TVec2 &a, const TVec2 &b)
00267 {
00268 return(a[0] * b[0] + a[1] * b[1]);
00269 }
00270
00271 inline TVec2 cross(const TVec2 &a)
00272 {
00273 TVec2 result;
00274
00275 result[0] = a[1];
00276 result[1] = -a[0];
00277
00278 return(result);
00279 }
00280
00281 inline TVReal len(const TVec2 &v)
00282 {
00283 return(sqrt(dot(v, v)));
00284 }
00285
00286 inline TVReal sqrlen(const TVec2 &v)
00287 {
00288 return(dot(v, v));
00289 }
00290
00291 inline TVec2 norm(const TVec2 &v)
00292 {
00293 Assert(sqrlen(v) > 0.0, "normalising length-zero vector");
00294 return(v / len(v));
00295 }
00296
00297 inline Void normalise(TVec2 &v)
00298 {
00299 v /= len(v);
00300 }
00301
00302 inline TVec2 &TVec2::MakeUnit(Int i, TVReal k)
00303 {
00304 if (i == 0)
00305 { elt[0] = k; elt[1] = vl_zero; }
00306 else if (i == 1)
00307 { elt[0] = vl_zero; elt[1] = k; }
00308 else
00309 _Error("(Vec2::Unit) illegal unit vector");
00310 return(SELF);
00311 }
00312
00313 inline TVec2 &TVec2::MakeZero()
00314 {
00315 elt[0] = vl_zero; elt[1] = vl_zero;
00316 return(SELF);
00317 }
00318
00319 inline TVec2 &TVec2::MakeBlock(TVReal k)
00320 {
00321 elt[0] = k; elt[1] = k;
00322 return(SELF);
00323 }
00324
00325 inline TVec2 &TVec2::Normalise()
00326 {
00327 Assert(sqrlen(SELF) > 0.0, "normalising length-zero vector");
00328 SELF /= len(SELF);
00329 return(SELF);
00330 }
00331
00332
00333 inline TVec2::TVec2(ZeroOrOne k)
00334 {
00335 elt[0] = k;
00336 elt[1] = k;
00337 }
00338
00339 inline TVec2::TVec2(Axis k)
00340 {
00341 MakeUnit(k, vl_one);
00342 }
00343
00344 inline TVec2 &TVec2::operator = (ZeroOrOne k)
00345 {
00346 elt[0] = k; elt[1] = k;
00347
00348 return(SELF);
00349 }
00350
00351 inline TVec2 &TVec2::operator = (Axis k)
00352 {
00353 MakeUnit(k, vl_1);
00354
00355 return(SELF);
00356 }
00357
00358 inline Bool TVec2::operator == (const TVec2 &a) const
00359 {
00360 return(elt[0] == a[0] && elt[1] == a[1]);
00361 }
00362
00363 inline Bool TVec2::operator != (const TVec2 &a) const
00364 {
00365 return(elt[0] != a[0] || elt[1] != a[1]);
00366 }
00367
00368 #endif
