libcruft-util/vector.cpp

234 lines
4.4 KiB
C++

/*
* This file is part of libgim.
*
* libgim is free software: you can redistribute it and/or modify it under the
* terms of the GNU General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later
* version.
*
* libgim is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License
* along with libgim. If not, see <http://www.gnu.org/licenses/>.
*
* Copyright 2011 Danny Robson <danny@nerdcruft.net>
*/
#include "vector.hpp"
#include "debug.hpp"
#include "maths.hpp"
#include <algorithm>
#include <cmath>
#include <limits>
#include <numeric>
using namespace util;
util::vector
util::vector::operator* (double rhs) const {
return { rhs * x, rhs * y, rhs * z };
}
vector&
vector::operator*= (double rhs) {
x *= rhs;
y *= rhs;
z *= rhs;
return *this;
}
util::vector
util::vector::operator* (const vector &rhs) const {
return { x * rhs.x, y * rhs.y, z * rhs.z };
}
util::vector&
util::vector::operator*= (const vector &rhs) {
x *= rhs.x;
y *= rhs.y;
z *= rhs.z;
return *this;
}
vector
vector::operator+ (const vector &rhs) const {
return { x + rhs.x, y + rhs.y, z + rhs.z };
}
vector
vector::operator- (void) const {
return { -x, -y, -z };
}
vector
vector::operator- (const vector &rhs) const
{ return { x - rhs.x, y - rhs.y, z - rhs.z }; }
vector&
vector::operator-= (const vector &rhs) {
x -= rhs.x;
y -= rhs.y;
z -= rhs.z;
return *this;
}
vector&
vector::operator+= (const vector &rhs) {
x += rhs.x;
y += rhs.y;
z += rhs.z;
return *this;
}
vector&
vector::operator= (const vector &rhs) {
x = rhs.x;
y = rhs.y;
z = rhs.z;
return *this;
}
bool
vector::operator== (const vector &rhs) const {
return almost_equal (x, rhs.x) &&
almost_equal (y, rhs.y) &&
almost_equal (z, rhs.z);
}
double
vector::magnitude (void) const {
return sqrt (x * x + y * y + z * z);
}
double
vector::magnitude2 (void) const {
return x * x + y * y + z * z;
}
double
vector::dot (const vector &rhs) const {
return x * rhs.x + y * rhs.y + z * rhs.z;
}
vector
vector::cross (const vector &rhs) const {
return { y * rhs.z - z * rhs.y,
z * rhs.x - x * rhs.z,
x * rhs.y - y * rhs.x };
}
vector&
vector::normalise (void) {
double mag = magnitude ();
x /= mag;
y /= mag;
z /= mag;
return *this;
}
vector
vector::normalised (void) const {
double mag = magnitude ();
return { x / mag, y / mag, z / mag };
}
vector
vector::spherical_to_cartesian (const vector &s) {
return {
s.x * sin (s.y) * cos (s.z),
s.x * sin (s.y) * sin (s.z),
s.x * cos (s.y),
};
}
vector
vector::cartesian_to_spherical (const vector &c) {
double mag = c.magnitude ();
return {
mag,
acos (c.z / mag),
atan2 (c.y, c.x)
};
}
void
vector::sanity (void) const {
check_soft (!std::isnan (x));
check_soft (!std::isnan (y));
check_soft (!std::isnan (z));
}
util::vector
util::operator* (double a, const util::vector &b)
{ return b * a; }
std::ostream&
util::operator<< (std::ostream &os, const util::vector &v) {
os << "vec(" << v.x << ", " << v.y << ", " << v.z << ")";
return os;
}
const json::node&
util::operator>> (const json::node &node, util::vector &v) {
const json::array &array = node.as_array ();
switch (array.size ()) {
case 1:
v.x = array[0].as_number ();
v.y = std::numeric_limits<double>::quiet_NaN ();
v.z = std::numeric_limits<double>::quiet_NaN ();
return node;
case 2: v.y = array[1].as_number ();
v.x = array[0].as_number ();
v.y = array[1].as_number ();
v.z = std::numeric_limits<double>::quiet_NaN ();
return node;
case 3: v.z = array[2].as_number ();
v.x = array[0].as_number ();
v.y = array[1].as_number ();
v.z = array[2].as_number ();
return node;
default:
throw std::runtime_error ("Invalid dimensionality for json-to-vector");
}
}