136 lines
3.4 KiB
C++
Executable File
136 lines
3.4 KiB
C++
Executable File
//
|
|
// Math.hpp
|
|
// amoeba
|
|
//
|
|
// Created by Timothy Prepscius on 12/30/16.
|
|
// Copyright © 2016 Timothy Prepscius. All rights reserved.
|
|
//
|
|
|
|
#pragma once
|
|
|
|
#include "Vector3.inl"
|
|
#include "Vector2.hpp"
|
|
#include "Vector4.hpp"
|
|
#include "Real.inl"
|
|
|
|
|
|
namespace tjp {
|
|
namespace core {
|
|
namespace math {
|
|
|
|
template<typename Real>
|
|
inline auto distance_squared(const Vector3<Real> &l, const Vector3<Real> &r)
|
|
{
|
|
Real
|
|
a = r[0] - l[0],
|
|
b = r[1] - l[1],
|
|
c = r[2] - l[2];
|
|
|
|
return (a*a) + (b*b) + (c*c);
|
|
}
|
|
|
|
template<typename Real>
|
|
inline auto distance_squared(const Vector4<Real> &l, const Vector4<Real> &r)
|
|
{
|
|
Real
|
|
a = r[0] - l[0],
|
|
b = r[1] - l[1],
|
|
c = r[2] - l[2],
|
|
d = r[3] - l[3];
|
|
|
|
return (a*a) + (b*b) + (c*c) + (d*d);
|
|
}
|
|
|
|
|
|
template<typename Real>
|
|
inline auto distance_squared(const Vector2<Real> &l, const Vector2<Real> &r)
|
|
{
|
|
Real
|
|
a = r[0] - l[0],
|
|
b = r[1] - l[1];
|
|
|
|
return (a*a) + (b*b);
|
|
}
|
|
|
|
template<typename Real>
|
|
inline auto distance_squared(const Vector3<Real> &r, Real x, Real y, Real z)
|
|
{
|
|
Real a = r[0] - x;
|
|
a *= a;
|
|
|
|
Real b = r[1] - y;
|
|
b *= b;
|
|
|
|
Real c = r[2] - z;
|
|
c *= c;
|
|
|
|
return a + b + c;
|
|
}
|
|
|
|
template<typename Real>
|
|
inline auto distance(const Vector3<Real> &r, Real x, Real y, Real z)
|
|
{
|
|
return std::sqrt(distance_squared(r, x, y, z));
|
|
}
|
|
|
|
inline auto distance(const Vector3<r32> &l, const Vector3<r32> &r) { return sqrt(distance_squared(l, r)); }
|
|
inline auto distance(const Vector3<r64> &l, const Vector3<r64> &r) { return sqrt(distance_squared(l, r)); }
|
|
|
|
inline auto distance(const Vector2<r32> &l, const Vector2<r32> &r) { return sqrt(distance_squared(l, r)); }
|
|
inline auto distance(const Vector2<r64> &l, const Vector2<r64> &r) { return sqrt(distance_squared(l, r)); }
|
|
|
|
inline auto distance(const Vector4<r32> &l, const Vector4<r32> &r) { return sqrt(distance_squared(l, r)); }
|
|
inline auto distance(const Vector4<r64> &l, const Vector4<r64> &r) { return sqrt(distance_squared(l, r)); }
|
|
|
|
//
|
|
|
|
template<typename V>
|
|
auto distance_vector_signed(const V &l, const V &r)
|
|
{
|
|
return (r-l).length();
|
|
}
|
|
|
|
template<typename V>
|
|
V distance_integral_unsigned(const V &l, const V &r)
|
|
{
|
|
if (r > l)
|
|
return r - l;
|
|
|
|
return l - r;
|
|
}
|
|
|
|
template<typename V>
|
|
V distance_integral_signed(const V &l, const V &r)
|
|
{
|
|
return distance_integral_unsigned(l, r);
|
|
}
|
|
|
|
// ---------------------
|
|
|
|
inline auto distance(const Vector3<s32> &l, const Vector3<s32> &r) { return distance_vector_signed(l, r); }
|
|
inline auto distance(const Vector3<s64> &l, const Vector3<s64> &r) { return distance_vector_signed(l, r); }
|
|
inline auto distance(const Vector3<s128> &l, const Vector3<s128> &r) { return distance_vector_signed(l, r); }
|
|
|
|
inline auto distance(const r32 &l, const r32 &r) { return distance_integral_signed(l, r); }
|
|
inline auto distance(const r64 &l, const r64 &r) { return distance_integral_signed(l, r); }
|
|
inline auto distance(const s32 &l, const s32 &r) { return distance_integral_signed(l, r); }
|
|
inline auto distance(const s64 &l, const s64 &r) { return distance_integral_signed(l, r); }
|
|
inline auto distance(const s128 &l, const s128 &r) { return distance_integral_signed(l, r); }
|
|
|
|
inline auto distance(const u32 &l, const u32 &r) { return distance_integral_unsigned(l, r); }
|
|
inline auto distance(const u64 &l, const u64 &r) { return distance_integral_unsigned(l, r); }
|
|
inline auto distance(const u128 &l, const u128 &r) { return distance_integral_unsigned(l, r); }
|
|
|
|
|
|
template<typename Real>
|
|
auto distance_relative(const Real &l, const Real &r)
|
|
{
|
|
return distance(l, r);
|
|
}
|
|
|
|
|
|
} // namespace
|
|
} // namespace
|
|
} // namespace
|
|
|