$search

vec3d.cc

Go to the documentation of this file.

/*
  James R. Diebel
  Stanford University

  Started: 23 August 2004

  vec3d.cc - implementation for basic 3d vector class Vec3d

  Depends on vec3d.hh
*/

#include "bmtk/vec3d.hh"

namespace bmtk {

// Constructors
Vec3d::Vec3d() {
  x[0] = x[1] = x[2] = 0;
}
Vec3d::Vec3d(const float x0, const float x1, const float x2) {
  x[0] = x0; x[1] = x1; x[2] = x2;
}
Vec3d::Vec3d(const float a) {
  x[0] = x[1] = x[2] = a;
}
Vec3d::Vec3d(const Vec3d& v) {
  x[0] = v.x[0]; x[1] = v.x[1]; x[2] = v.x[2];
}
Vec3d::Vec3d(const float* x_) {
  x[0] = x_[0]; x[1] = x_[1]; x[2] = x_[2];
}

// Assignments
void Vec3d::set(const float x0, const float x1, const float x2) {
  x[0] = x0; x[1] = x1; x[2] = x2;
}
Vec3d Vec3d::operator = (const Vec3d& v) {
  x[0] = v.x[0]; x[1] = v.x[1]; x[2] = v.x[2];
  return *this;
}
Vec3d Vec3d::operator = (const float d[3]) {
  x[0] = d[0]; x[1] = d[1]; x[2] = d[2];
  return *this;
}
Vec3d Vec3d::operator = (float a) {
  x[0] = a; x[1] = a; x[2] = a;
  return *this;
}
Vec3d Vec3d::operator = (int a) {
  x[0] = a; x[1] = a; x[2] = float(a);
  return *this;
}

// Reference operator: zero-based square bracket referencing
float Vec3d::operator [] (const int index) const {
  if (index < 0 || index > 2) cerr << "Index our of bounds" << endl << flush;
  return x[index];
}
float& Vec3d::operator [] (const int index) {
  if (index < 0 || index > 2) cerr << "Index our of bounds" << endl << flush;
  return x[index];
}

// Return relative vectors (vector subtraction)
Vec3d Vec3d::to(const Vec3d& v) const {
  return Vec3d(v.x[0] - x[0], v.x[1] - x[1], v.x[2] - x[2]);
}
Vec3d Vec3d::from(const Vec3d& v) const {
  return Vec3d(x[0] - v.x[0], x[1] - v.x[1], x[2] - v.x[2]);
}

// Addition and subtraction: <vector> +/- <vector or scalar>
// note: does not perform <scalar> +/- <vector>
//       (see non-class functions below)
Vec3d Vec3d::operator + (const Vec3d& v) const {
  return Vec3d(x[0] + v.x[0], x[1] + v.x[1], x[2] + v.x[2]);
}
Vec3d Vec3d::operator + (const float a) const {
  return Vec3d(x[0] + a, x[1] + a, x[2] + a);
}
void Vec3d::operator += (const Vec3d& v) {
  x[0] += v.x[0]; x[1] += v.x[1]; x[2] += v.x[2];
}
void Vec3d::operator += (const float a) {
  x[0] += a; x[1] += a; x[2] += a;
}

Vec3d Vec3d::operator - (const Vec3d& v) const {
  return Vec3d(x[0] - v.x[0], x[1] - v.x[1], x[2] - v.x[2]);
}
Vec3d Vec3d::operator - (const float a) const {
  return Vec3d(x[0] - a, x[1] - a, x[2] - a);
}
void Vec3d::operator -= (const Vec3d& v) {
  x[0] -= v.x[0]; x[1] -= v.x[1]; x[2] -= v.x[2];
}
void Vec3d::operator -= (const float a) {
  x[0] -= a; x[1] -= a; x[2] -= a;
}
Vec3d Vec3d::operator - (void) const {
  return Vec3d(-x[0], -x[1], -x[2]);
}

// Multiplication and division by scalars: <vector> *// <scalar>
// note: does not perform <scalar> * <vector>
//       (see non-class functions below)
Vec3d Vec3d::operator * (const float a) const {
  return Vec3d(x[0]*a, x[1]*a, x[2]*a);
}
Vec3d Vec3d::operator / (const float a) const {
  float b = 1/a;
  return Vec3d(x[0]*b, x[1]*b, x[2]*b);
}
Vec3d Vec3d::operator * (const Vec3d v) const {
  return Vec3d(x[0]*v.x[0], x[1]*v.x[1], x[2]*v.x[2]);
}
Vec3d Vec3d::operator / (const Vec3d v) const {
  return Vec3d(x[0]/v.x[0], x[1]/v.x[1], x[2]/v.x[2]);
}
Vec3d Vec3d::operator *= (const float a) {
  x[0] *= a; x[1] *= a; x[2] *= a;
  return *this;
}
Vec3d Vec3d::operator /= (const float a) {
  float b = 1/a;
  x[0] *= b; x[1] *= b; x[2] *= b;
  return *this;
}
Vec3d Vec3d::operator *= (const Vec3d v) {
  x[0] *= v.x[0]; x[1] *= v.x[1]; x[2] *= v.x[2];
  return *this;
}
Vec3d Vec3d::operator /= (const Vec3d v) {
  x[0] /= v.x[0]; x[1] /= v.x[1]; x[2] /= v.x[2];
  return *this;
}

// Dot and Cross Products
float Vec3d::dot(const Vec3d& v) const {
  return v.x[0]*x[0] + v.x[1]*x[1] + v.x[2]*x[2];
}
Vec3d Vec3d::cross(const Vec3d& v) const {
  return Vec3d(x[1]*v.x[2]-x[2]*v.x[1],
         x[2]*v.x[0]-x[0]*v.x[2],
         x[0]*v.x[1]-x[1]*v.x[0]);
}

// Equality tests make sense
bool Vec3d::operator == (const Vec3d& v) const {
  return (x[0]==v.x[0] && x[1]==v.x[1] && x[2]==v.x[2]);
}
bool Vec3d::operator != (const Vec3d& v) const {
  return (x[0]!=v.x[0] || x[1]!=v.x[1] || x[2]!=v.x[2]);
}

// Length and Normalize
float Vec3d::len(void) const {
  return sqrt(len2());
}
float Vec3d::operator ~ (void) const {
  return len();
}
float Vec3d::len2(void) const {
  return (x[0]*x[0] + x[1]*x[1] + x[2]*x[2]);
}
float Vec3d::distTo(Vec3d& v) const {
  return to(v).len();
}
float Vec3d::dist2To(Vec3d& v) const {
  return to(v).len2();
}
void Vec3d::normalize(void) {
  float l = len();
  if (l > 0) {x[0] /= l; x[1] /= l; x[2] /= l;}
}

// Print routines
void Vec3d::print(void) {
  cout << "(" << x[0] << "," << x[1] << "," << x[2] << ")";
}
void Vec3d::printcr(void) {
  cout << "(" << x[0] << "," << x[1] << "," << x[2] << ")" << endl;
}
void Vec3d::printall(void) {
  cout << "|" << x[0] << "," << x[1] << "," << x[2] << "| = "
       << len() << endl;
}

// Define a few global operators to handle cases where
// a Vec3d is the second argument in a binary operator
Vec3d operator + (const float a, const Vec3d& v) {
  return Vec3d(a + v.x[0], a + v.x[1], a + v.x[2]);
}
Vec3d operator - (const float a, const Vec3d& v) {
  return Vec3d(a - v.x[0], a - v.x[1], a - v.x[2]);
}
Vec3d operator * (const float a, const Vec3d& v) {
  return Vec3d(a*v.x[0], a*v.x[1], a*v.x[2]);
}

// Define << operator to handle output to screen
ostream& operator << (ostream& os, const Vec3d& v) {
  return os << "(" << v.x[0] << "," << v.x[1] << "," << v.x[2] << ")";
}

} // namespace bmtk

---

bmtk
Author(s): Benjamin Pitzer
autogenerated on Mon Mar 4 11:05:51 2013