Vector3d.h

//
//  Vector3d.h
//
 
#ifndef __CardboardSDK_iOS__Vector3d__
#define __CardboardSDK_iOS__Vector3d__
 
class Vector3d
{
    friend class Matrix3x3d;
    friend class SO3Util;
 
  public:
    Vector3d();
    Vector3d(double x, double y, double z);
    Vector3d(const Vector3d &other);
    void set(double x, double y, double z);
    void setComponent(int i, double val);
    void setZero();
    void set(Vector3d other);
    void scale(double s);
    void normalize();
    static double dot(Vector3d a, Vector3d b);
    double length();
    bool sameValues(Vector3d other);
    static void add(Vector3d a, Vector3d b, Vector3d &result);
    static void sub(Vector3d a, Vector3d b, Vector3d &result);
    static void cross(Vector3d a, Vector3d b, Vector3d &result);
    static void ortho(Vector3d v, Vector3d &result);
    static int largestAbsComponent(Vector3d v);
    
    inline double getX() const { return x; }
    inline double getY() const { return y; }
    inline double getZ() const { return z; }
 
    Vector3d CrossProduct(Vector3d other)
    {
      return Vector3d(y * other.z - z * other.y, z * other.x - x * other.z, x * other.y - y * other.x);
    }
 
    Vector3d operator-()
    {
      return Vector3d(-x, -y, -z);
    }
 
    Vector3d operator+=(Vector3d other)
    {
      return Vector3d(x + other.x, y + other.y, z + other.z);
    }
 
    Vector3d operator-=(Vector3d other)
    {
      return Vector3d(x - other.x, y - other.y, z - other.z);
    }
 
    Vector3d operator*=(float scalar)
    {
      return Vector3d(x * scalar, y * scalar, z * scalar);
    }
 
    Vector3d operator/=(float scalar)
    {
      return Vector3d(x / scalar, y / scalar, z / scalar);
    }
 
    double x;
    double y;
    double z;
};
 
//-----------------------------------------------------------------------
// Vector3 binary operators
inline Vector3d operator+(Vector3d u, Vector3d v)
{
  return Vector3d(u.x + v.x, u.y + v.y, u.z + v.z);
}
 
inline Vector3d operator-(Vector3d u, Vector3d v)
{
  return u + (-v);
}
 
inline Vector3d operator*(Vector3d u, float scalar)
{
  return Vector3d(u.x * scalar, u.y * scalar, u.z * scalar);
}
 
inline Vector3d operator*(float scalar, Vector3d u)
{
  return Vector3d(u.x * scalar, u.y * scalar, u.z * scalar);
}
 
inline Vector3d operator/(Vector3d u, float scalar)
{
  return Vector3d(u.x / scalar, u.y / scalar, u.z / scalar);
}
 
#endif