Horus Doc || C++ Reference || Class Overview   Pixels   Images   Detector   Geometry   Registry || Doxygen's quick Index  

HxVec3Int Class Reference

Class definition vector of 3 integers. More...

#include <HxVec3Int.h>

Inheritance diagram for HxVec3Int::

HxPointZ List of all members.

Constructors

 HxVec3Int ()
 Default constructor. More...

 HxVec3Int (int x, int y, int z)
 Conversion from native type. More...

 HxVec3Int (const HxVec3Int &v)
 Copy constructor. More...


Inquiry

int dim () const
 Dimensionality. More...

int x () const
 Value of first element. More...

int y () const
 Value of second element. More...

int z () const
 Value of third element. More...

int getValue (int dimension) const
 Element in given dimension. More...

void setValue (int dimension, int value)

Conversion

 operator HxScalarInt () const
 Cast to HxScalarInt. More...

 operator HxScalarDouble () const
 Cast to HxScalarDouble. More...

 operator HxVec2Int () const
 Cast to HxVec2Int. More...

 operator HxVec2Double () const
 Cast to HxVec2Double. More...

 operator HxVec3Double () const
 Cast to HxVec3Double. More...

 operator HxComplex () const
 Cast to HxComplex. More...


Operators

Mathematical definition: Binary operations on pixel values

int operator== (const HxVec3Int &v) const
 Equal. More...

int operator!= (const HxVec3Int &v) const
 Not equal. More...

int operator< (const HxVec3Int &v) const
 Less than. More...

int operator<= (const HxVec3Int &v) const
 Less equal. More...

int operator> (const HxVec3Int &v) const
 Greater than. More...

int operator>= (const HxVec3Int &v) const
 Greater equal. More...

const HxVec3Int SMALL_VAL = HxVec3Int(0, 0, 0)
 A small value w.r.t to the comparison operators "<" and ">". More...

const HxVec3Int LARGE_VAL = HxVec3Int(200000000, 200000000, 200000000)
 A large value w.r.t to the comparison operators "<" and ">". More...


Unary operations

Mathematical definition: Unary operations on pixel values

HxVec3Int operator- () const
 Negation. More...

HxVec3Int complement () const
 Complement. More...

HxVec3Int abs () const
 Absolute value. More...

HxVec3Int ceil () const
 Ceiling. More...

HxVec3Int floor () const
 Floor. More...

HxVec3Int round () const
 Round. More...

HxScalarInt sum () const
 Sum. More...

HxScalarInt product () const
 Product. More...

HxScalarInt min () const
 Minimum. More...

HxScalarInt max () const
 Maximum. More...

HxScalarInt norm1 () const
 L1 norm. More...

HxScalarDouble norm2 () const
 L2 norm. More...

HxScalarInt normInf () const
 L infinity norm. More...

HxVec3Double sqrt () const
 Square root. More...

HxVec3Double sin () const
 Sine. More...

HxVec3Double cos () const
 Cosine. More...

HxVec3Double tan () const
 Tangent. More...

HxVec3Double asin () const
 Arc sine. More...

HxVec3Double acos () const
 Arc cosine. More...

HxVec3Double atan () const
 Arc tangent. More...

HxScalarDouble atan2 () const
 Arc tangent. More...

HxVec3Double sinh () const
 Hyperbolic sine. More...

HxVec3Double cosh () const
 Hyperbolic cosine. More...

HxVec3Double tanh () const
 Hyperbolic tangent. More...

HxVec3Double exp () const
 Exponent. More...

HxVec3Double log () const
 Natural logarithm. More...

HxVec3Double log10 () const
 Base 10 logarithm. More...


Binary operations

Mathematical definition: Binary operations on pixel values

HxVec3Int & operator+= (const HxVec3Int &v)
 Addition and assignment. More...

HxVec3Int & operator-= (const HxVec3Int &v)
 Subtraction and assignment. More...

HxVec3Int & operator *= (const HxVec3Int &v)
 Multiplication and assignment. More...

HxVec3Int & operator/= (const HxVec3Int &v)
 Division and assignment. More...

HxVec3Int min (const HxVec3Int &v) const
 Minimum. More...

HxVec3Int & minAssign (const HxVec3Int &v)
 Minimum and assignment. More...

HxVec3Int max (const HxVec3Int &v) const
 Maximum. More...

HxVec3Int & maxAssign (const HxVec3Int &v)
 Maximum and assignment. More...

HxVec3Int inf (const HxVec3Int &v) const
 Infimum. More...

HxVec3Int & infAssign (const HxVec3Int &v)
 Infimum and assignment. More...

HxVec3Int sup (const HxVec3Int &v) const
 Supremum. More...

HxVec3Int & supAssign (const HxVec3Int &v)
 Supremum and assignment. More...

HxVec3Int pow (const HxVec3Int &v) const
 Power. More...

HxVec3Int mod (const HxVec3Int &v) const
 Modulo. More...

HxVec3Int and (const HxVec3Int &v) const
 And. More...

HxVec3Int or (const HxVec3Int &v) const
 Or. More...

HxVec3Int xor (const HxVec3Int &v) const
 Xor. More...

HxVec3Int leftShift (const HxVec3Int &v) const
 Left shift. More...

HxVec3Int rightShift (const HxVec3Int &v) const
 Right shift. More...

HxScalarInt dot (const HxVec3Int &v) const
 Dot product. More...

HxVec3Int cross (const HxVec3Int &v) const
 Cross product. More...

HxVec3Int operator+ (const HxVec3Int &v1, const HxVec3Int &v2)
 Addition. More...

HxVec3Int operator- (const HxVec3Int &v1, const HxVec3Int &v2)
 Subtraction. More...

HxVec3Int operator * (const HxVec3Int &v1, const HxVec3Int &v2)
 Multiplication. More...

HxVec3Int operator/ (const HxVec3Int &v1, const HxVec3Int &v2)
 Division. More...


Output

STD_OSTREAM & put (STD_OSTREAM &os) const
 Print value on stream. More...

HxString toString () const
 Value as a string. More...


Public Methods

void * operator new (size_t, void *=0)

Detailed Description

Class definition vector of 3 integers.

Constructor & Destructor Documentation

HxVec3Int::HxVec3Int (    )  [inline]
 

Default constructor. 

00322 { 
00323 }

HxVec3Int::HxVec3Int (  int    x,
int    y,
int    z
)  [inline]
 

Conversion from native type. 

00327 {
00328     _values[0] = x;
00329     _values[1] = y;
00330     _values[2] = z;
00331 }

HxVec3Int::HxVec3Int (  const HxVec3Int &    v )  [inline]
 

Copy constructor. 

00335 {
00336     _values[0] = v._values[0];
00337     _values[1] = v._values[1];
00338     _values[2] = v._values[2];
00339 }

Member Function Documentation

int HxVec3Int::dim (    )  const [inline]
 

Dimensionality. 

00349 { 
00350     return 3;
00351 }

int HxVec3Int::x (    )  const [inline]
 

Value of first element. 

00355 { 
00356     return _values[0]; 
00357 }

int HxVec3Int::y (    )  const [inline]
 

Value of second element. 

00361 { 
00362     return _values[1]; 
00363 }

int HxVec3Int::z (    )  const [inline]
 

Value of third element. 

00367 { 
00368     return _values[2]; 
00369 }

int HxVec3Int::getValue (  int    dimension )  const [inline]
 

Element in given dimension. 

00373 { 
00374     return _values[dimension - 1]; 
00375 }

HxVec3Int::operator HxScalarInt (    )  const
 

Cast to HxScalarInt. 

00028 {
00029     return _values[0];
00030 }

HxVec3Int::operator HxScalarDouble (    )  const
 

Cast to HxScalarDouble. 

00033 {
00034     return (double) _values[0];
00035 }

HxVec3Int::operator HxVec2Int (    )  const
 

Cast to HxVec2Int. 

00039 {
00040     return HxVec2Int(_values[0], _values[1]);
00041 }

HxVec3Int::operator HxVec2Double (    )  const
 

Cast to HxVec2Double. 

00044 {
00045     return HxVec2Double(_values[0], _values[1]);
00046 }

HxVec3Int::operator HxVec3Double (    )  const
 

Cast to HxVec3Double. 

00049 {
00050     return HxVec3Double(_values[0], _values[1], _values[2]);
00051 }

HxVec3Int::operator HxComplex (    )  const
 

Cast to HxComplex. 

00054 {
00055     return HxComplex(_values[0], _values[1]);
00056 }

int HxVec3Int::operator== (  const HxVec3Int &    v )  const [inline]
 

Equal. 

00385 {
00386     return (_values[0] == v._values[0]) && (_values[1] == v._values[1]) &&
00387            (_values[2] == v._values[2]);
00388 }

int HxVec3Int::operator!= (  const HxVec3Int &    v )  const [inline]
 

Not equal. 

00392 {
00393     return (_values[0] != v._values[0]) || (_values[1] != v._values[1]) ||
00394            (_values[2] != v._values[2]);
00395 }

int HxVec3Int::operator< (  const HxVec3Int &    v )  const [inline]
 

Less than. 

00399 {
00400     return (::abs(_values[0]) + ::abs(_values[1]) + ::abs(_values[2])) <
00401            (::abs(v._values[0]) + ::abs(v._values[1]) + ::abs(v._values[2]));
00402 }

int HxVec3Int::operator<= (  const HxVec3Int &    v )  const [inline]
 

Less equal. 

00406 {
00407     return (::abs(_values[0]) + ::abs(_values[1]) + ::abs(_values[2])) <=
00408            (::abs(v._values[0]) + ::abs(v._values[1]) + ::abs(v._values[2]));
00409 }

int HxVec3Int::operator> (  const HxVec3Int &    v )  const [inline]
 

Greater than. 

00413 {
00414     return (::abs(_values[0]) + ::abs(_values[1]) + ::abs(_values[2])) >
00415            (::abs(v._values[0]) + ::abs(v._values[1]) + ::abs(v._values[2]));
00416 }

int HxVec3Int::operator>= (  const HxVec3Int &    v )  const [inline]
 

Greater equal. 

00420 {
00421     return (::abs(_values[0]) + ::abs(_values[1]) + ::abs(_values[2])) >=
00422            (::abs(v._values[0]) + ::abs(v._values[1]) + ::abs(v._values[2]));
00423 }

HxVec3Int HxVec3Int::operator- (    )  const [inline]
 

Negation. 

00427 {
00428     return HxVec3Int(-_values[0], -_values[1], -_values[2]);
00429 }

HxVec3Int HxVec3Int::complement (    )  const [inline]
 

Complement. 

00433 {
00434     return HxVec3Int(~_values[0], ~_values[1], ~_values[2]);
00435 }

HxVec3Int HxVec3Int::abs (    )  const [inline]
 

Absolute value. 

00439 {
00440     return HxVec3Int(::abs(_values[0]), ::abs(_values[1]), ::abs(_values[2]));
00441 }

HxVec3Int HxVec3Int::ceil (    )  const [inline]
 

Ceiling. 

00445 {
00446     return *this;
00447 }

HxVec3Int HxVec3Int::floor (    )  const [inline]
 

Floor. 

00451 {
00452     return *this;
00453 }

HxVec3Int HxVec3Int::round (    )  const [inline]
 

Round. 

00457 {
00458     return *this;
00459 }

HxScalarInt HxVec3Int::sum (    )  const [inline]
 

Sum. 

00463 {
00464     return _values[0] + _values[1] + _values[2];
00465 }

HxScalarInt HxVec3Int::product (    )  const [inline]
 

Product. 

00469 {
00470     return _values[0] * _values[1] * _values[2];
00471 }

HxScalarInt HxVec3Int::min (    )  const
 

Minimum. 

00060 {
00061     return (_values[0] < _values[1]) ?
00062         ((_values[0] < _values[2]) ? _values[0] : _values[2]) :
00063         ((_values[1] < _values[2]) ? _values[1] : _values[2]);
00064 }

HxScalarInt HxVec3Int::max (    )  const
 

Maximum. 

00068 {
00069     return (_values[0] > _values[1]) ?
00070         ((_values[0] > _values[2]) ? _values[0] : _values[2]) :
00071         ((_values[1] > _values[2]) ? _values[1] : _values[2]);
00072 }

HxScalarInt HxVec3Int::norm1 (    )  const
 

L1 norm. 

00076 {
00077     return ::abs(_values[0]) + ::abs(_values[1]) + ::abs(_values[2]);
00078 }

HxScalarDouble HxVec3Int::norm2 (    )  const
 

L2 norm. 

00082 {
00083     return ::sqrt(double(_values[0])*_values[0] +
00084                   double(_values[1])*_values[1] +
00085                   double(_values[2])*_values[2]);
00086 }

HxScalarInt HxVec3Int::normInf (    )  const
 

L infinity norm. 

00090 {
00091     return (::abs(_values[0]) > ::abs(_values[1])) ?
00092         ((::abs(_values[0]) > ::abs(_values[2])) ? ::abs(_values[0]) :
00093                                                         ::abs(_values[2])) :
00094         ((::abs(_values[1]) > ::abs(_values[2])) ? ::abs(_values[1]) :
00095                                                         ::abs(_values[2]));
00096 }

HxVec3Double HxVec3Int::sqrt (    )  const
 

Square root. 

00100 {
00101     return HxVec3Double(::sqrt(double(_values[0])),
00102                         ::sqrt(double(_values[1])),
00103                         ::sqrt(double(_values[2])));
00104 }

HxVec3Double HxVec3Int::sin (    )  const
 

Sine. 

00108 {
00109     return HxVec3Double(::sin(double(_values[0])),
00110                         ::sin(double(_values[1])),
00111                         ::sin(double(_values[2])));
00112 }

HxVec3Double HxVec3Int::cos (    )  const
 

Cosine. 

00116 {
00117     return HxVec3Double(::cos(double(_values[0])),
00118                         ::cos(double(_values[1])),
00119                         ::cos(double(_values[2])));
00120 }

HxVec3Double HxVec3Int::tan (    )  const
 

Tangent. 

00124 {
00125     return HxVec3Double(::tan(double(_values[0])),
00126                         ::tan(double(_values[1])),
00127                         ::tan(double(_values[2])));
00128 }

HxVec3Double HxVec3Int::asin (    )  const
 

Arc sine. 

00132 {
00133     return HxVec3Double(::asin(double(_values[0])),
00134                         ::asin(double(_values[1])),
00135                         ::asin(double(_values[2])));
00136 }

HxVec3Double HxVec3Int::acos (    )  const
 

Arc cosine. 

00140 {
00141     return HxVec3Double(::acos(double(_values[0])),
00142                         ::acos(double(_values[1])),
00143                         ::acos(double(_values[2])));
00144 }

HxVec3Double HxVec3Int::atan (    )  const
 

Arc tangent. 

00154 {
00155     return HxVec3Double(::atan(double(_values[0])),
00156                         ::atan(double(_values[1])),
00157                         ::atan(double(_values[2])));
00158 }

HxScalarDouble HxVec3Int::atan2 (    )  const
 

Arc tangent. 

00148 {
00149     return HxScalarDouble(::atan2(double(_values[0]), double(_values[1])));
00150 }

HxVec3Double HxVec3Int::sinh (    )  const
 

Hyperbolic sine. 

00162 {
00163     return HxVec3Double(::sinh(double(_values[0])),
00164                         ::sinh(double(_values[1])),
00165                         ::sinh(double(_values[2])));
00166 }

HxVec3Double HxVec3Int::cosh (    )  const
 

Hyperbolic cosine. 

00170 {
00171     return HxVec3Double(::cosh(double(_values[0])),
00172                         ::cosh(double(_values[1])),
00173                         ::cosh(double(_values[2])));
00174 }

HxVec3Double HxVec3Int::tanh (    )  const
 

Hyperbolic tangent. 

00178 {
00179     return HxVec3Double(::tanh(double(_values[0])),
00180                         ::tanh(double(_values[1])),
00181                         ::tanh(double(_values[2])));
00182 }

HxVec3Double HxVec3Int::exp (    )  const
 

Exponent. 

00186 {
00187     return HxVec3Double(::exp(double(_values[0])),
00188                         ::exp(double(_values[1])),
00189                         ::exp(double(_values[2])));
00190 }

HxVec3Double HxVec3Int::log (    )  const
 

Natural logarithm. 

00194 {
00195     return HxVec3Double(::log(double(_values[0])),
00196                         ::log(double(_values[1])),
00197                         ::log(double(_values[2])));
00198 }

HxVec3Double HxVec3Int::log10 (    )  const
 

Base 10 logarithm. 

00202 {
00203     return HxVec3Double(::log10(double(_values[0])),
00204                         ::log10(double(_values[1])),
00205                         ::log10(double(_values[2])));
00206 }

HxVec3Int & HxVec3Int::operator+= (  const HxVec3Int &    v )  [inline]
 

Addition and assignment. 

00475 {
00476     _values[0] += v._values[0];
00477     _values[1] += v._values[1];
00478     _values[2] += v._values[2];
00479     return *this;
00480 }

HxVec3Int & HxVec3Int::operator-= (  const HxVec3Int &    v )  [inline]
 

Subtraction and assignment. 

00484 {
00485     _values[0] -= v._values[0];
00486     _values[1] -= v._values[1];
00487     _values[2] -= v._values[2];
00488     return *this;
00489 }

HxVec3Int & HxVec3Int::operator *= (  const HxVec3Int &    v )  [inline]
 

Multiplication and assignment. 

00493 {
00494     _values[0] *= v._values[0];
00495     _values[1] *= v._values[1];
00496     _values[2] *= v._values[2];
00497     return *this;
00498 }

HxVec3Int & HxVec3Int::operator/= (  const HxVec3Int &    v )  [inline]
 

Division and assignment. 

00502 {
00503     _values[0] /= v._values[0];
00504     _values[1] /= v._values[1];
00505     _values[2] /= v._values[2];
00506     return *this;
00507 }

HxVec3Int HxVec3Int::min (  const HxVec3Int &    v )  const [inline]
 

Minimum. 

00543 {
00544     return (operator<(v)) ? (*this) : v;
00545 }

HxVec3Int & HxVec3Int::minAssign (  const HxVec3Int &    v )  [inline]
 

Minimum and assignment. 

00549 {
00550     if (operator<(v))
00551         return *this;
00552     operator=(v);
00553     return *this;
00554 }

HxVec3Int HxVec3Int::max (  const HxVec3Int &    v )  const [inline]
 

Maximum. 

00558 {
00559     return (operator>(v)) ? (*this) : v;
00560 }

HxVec3Int & HxVec3Int::maxAssign (  const HxVec3Int &    v )  [inline]
 

Maximum and assignment. 

00564 {
00565     if (operator>(v))
00566         return *this;
00567     operator=(v);
00568     return *this;
00569 }

HxVec3Int HxVec3Int::inf (  const HxVec3Int &    v )  const [inline]
 

Infimum. 

00573 {
00574     return HxVec3Int((_values[0] < v._values[0]) ? _values[0] : v._values[0],
00575                      (_values[1] < v._values[1]) ? _values[1] : v._values[1],
00576                      (_values[2] < v._values[2]) ? _values[2] : v._values[2]);
00577 }

HxVec3Int & HxVec3Int::infAssign (  const HxVec3Int &    v )  [inline]
 

Infimum and assignment. 

00581 {
00582     _values[0] = (_values[0] < v._values[0]) ? _values[0] : v._values[0];
00583     _values[1] = (_values[1] < v._values[1]) ? _values[1] : v._values[1];
00584     _values[2] = (_values[2] < v._values[2]) ? _values[2] : v._values[2];
00585     return *this;
00586 }

HxVec3Int HxVec3Int::sup (  const HxVec3Int &    v )  const [inline]
 

Supremum. 

00590 {
00591     return HxVec3Int((_values[0] > v._values[0]) ? _values[0] : v._values[0],
00592                      (_values[1] > v._values[1]) ? _values[1] : v._values[1],
00593                      (_values[2] > v._values[2]) ? _values[2] : v._values[2]);
00594 }

HxVec3Int & HxVec3Int::supAssign (  const HxVec3Int &    v )  [inline]
 

Supremum and assignment. 

00598 {
00599     _values[0] = (_values[0] > v._values[0]) ? _values[0] : v._values[0];
00600     _values[1] = (_values[1] > v._values[1]) ? _values[1] : v._values[1];
00601     _values[2] = (_values[2] > v._values[2]) ? _values[2] : v._values[2];
00602     return *this;
00603 }

HxVec3Int HxVec3Int::pow (  const HxVec3Int &    v )  const [inline]
 

Power. 

00607 {
00608     return HxVec3Int((int) (::pow(_values[0], v._values[0]) + 0.5),
00609                      (int) (::pow(_values[1], v._values[1]) + 0.5),
00610                      (int) (::pow(_values[2], v._values[2]) + 0.5));
00611 }

HxVec3Int HxVec3Int::mod (  const HxVec3Int &    v )  const [inline]
 

Modulo. 

00615 {
00616     return HxVec3Int(_values[0] % v._values[0],
00617                      _values[1] % v._values[1],
00618                      _values[2] % v._values[2]);
00619 }

HxVec3Int HxVec3Int::and (  const HxVec3Int &    v )  const [inline]
 

And. 

00623 {
00624     return HxVec3Int(_values[0] & v._values[0],
00625                      _values[1] & v._values[1],
00626                      _values[2] & v._values[2]);
00627 }

HxVec3Int HxVec3Int::or (  const HxVec3Int &    v )  const [inline]
 

Or. 

00631 {
00632     return HxVec3Int(_values[0] | v._values[0],
00633                      _values[1] | v._values[1],
00634                      _values[2] | v._values[2]);
00635 }

HxVec3Int HxVec3Int::xor (  const HxVec3Int &    v )  const [inline]
 

Xor. 

00639 {
00640     return HxVec3Int(_values[0] ^ v._values[0],
00641                      _values[1] ^ v._values[1],
00642                      _values[2] ^ v._values[2]);
00643 }

HxVec3Int HxVec3Int::leftShift (  const HxVec3Int &    v )  const [inline]
 

Left shift. 

00647 {
00648     return HxVec3Int(_values[0] << v._values[0],
00649                      _values[1] << v._values[1],
00650                      _values[2] << v._values[2]);
00651 }

HxVec3Int HxVec3Int::rightShift (  const HxVec3Int &    v )  const [inline]
 

Right shift. 

00655 {
00656     return HxVec3Int(_values[0] >> v._values[0],
00657                      _values[1] >> v._values[1],
00658                      _values[2] >> v._values[2]);
00659 }

HxScalarInt HxVec3Int::dot (  const HxVec3Int &    v )  const
 

Dot product. 

00210 {
00211     return (_values[0] * v._values[0]) +
00212            (_values[1] * v._values[1]) +
00213            (_values[2] * v._values[2]);
00214 }

HxVec3Int HxVec3Int::cross (  const HxVec3Int &    v )  const [inline]
 

Cross product. 

00663 {
00664     return HxVec3Int(_values[1] * v._values[2] - _values[2] * v._values[1],
00665                      _values[2] * v._values[0] - _values[0] * v._values[2],
00666                      _values[0] * v._values[1] - _values[1] * v._values[0]);
00667 }

STD_OSTREAM & HxVec3Int::put (  STD_OSTREAM &    os )  const
 

Print value on stream.

For global operator<< 

00218 {
00219     return os << "(" << _values[0] << "," << _values[1] << "," <<
00220         _values[2] << ")";
00221 }

HxString HxVec3Int::toString (    )  const
 

Value as a string. 

00224                           {
00225     return HxString("(") + makeString(_values[0]) + ", "
00226             + makeString(_values[1]) + ", "
00227             + makeString(_values[2]) + ")";
00228 }

Friends And Related Function Documentation

HxVec3Int operator+ (  const HxVec3Int &    v1,
const HxVec3Int &    v2
)  [friend]
 

Addition. 

00511 {
00512     return HxVec3Int(v1._values[0] + v2._values[0],
00513                      v1._values[1] + v2._values[1],
00514                      v1._values[2] + v2._values[2]);
00515 }

HxVec3Int operator- (  const HxVec3Int &    v1,
const HxVec3Int &    v2
)  [friend]
 

Subtraction. 

00519 {
00520     return HxVec3Int(v1._values[0] - v2._values[0],
00521                      v1._values[1] - v2._values[1],
00522                      v1._values[2] - v2._values[2]);
00523 }

HxVec3Int operator * (  const HxVec3Int &    v1,
const HxVec3Int &    v2
)  [friend]
 

Multiplication. 

00527 {
00528     return HxVec3Int(v1._values[0] * v2._values[0],
00529                      v1._values[1] * v2._values[1],
00530                      v1._values[2] * v2._values[2]);
00531 }

HxVec3Int operator/ (  const HxVec3Int &    v1,
const HxVec3Int &    v2
)  [friend]
 

Division. 

00535 {
00536     return HxVec3Int(v1._values[0] / v2._values[0],
00537                      v1._values[1] / v2._values[1],
00538                      v1._values[2] / v2._values[2]);
00539 }

Member Data Documentation

const HxVec3Int HxVec3Int::SMALL_VAL = HxVec3Int(0, 0, 0) [static]
 

A small value w.r.t to the comparison operators "<" and ">".

Not actually the minimum to avoid overflow.

const HxVec3Int HxVec3Int::LARGE_VAL = HxVec3Int(200000000, 200000000, 200000000) [static]
 

A large value w.r.t to the comparison operators "<" and ">".

Not actually the maximum to avoid overflow.

The documentation for this class was generated from the following files:
Generated on Mon Jan 27 15:49:12 2003 for C++Reference by doxygen1.2.12 written by Dimitri van Heesch, © 1997-2001