DVector3.cs

using UnityEngine;
using M = System.Math;
// ReSharper disable InconsistentNaming
 
namespace ARLocation
{
    [System.Serializable]
    public struct DVector3
    {
        public double x;
        public double y;
        public double z;
 
        public DVector3(Vector3 v)
        {
            x = v.x;
            y = v.y;
            z = v.z;
        }
 
        public double magnitude
        {
            get
            {
                return M.Sqrt(x * x + y * y + z * z);
            }
        }
 
        public DVector3 normalized
        {
            get
            {
                var m = magnitude;
 
                if (m < 0.00000001)
                {
                    return new DVector3();
                }
 
                return new DVector3(x, y, z) / magnitude;
            }
        }
 
        public DVector3(double newX = 0.0, double newY = 0.0, double newZ = 0.0)
        {
            x = newX;
            y = newY;
            z = newZ;
        }
 
        public Vector3 toVector3()
        {
            return new Vector3((float)x, (float)y, (float)z);
        }
 
        public bool Equals(DVector3 v, double e = 0.00005)
        {
            return (M.Abs(x - v.x) <= e) && (M.Abs(y - v.y) <= e) && (M.Abs(z - v.z) <= e);
        }
 
        public void Normalize()
        {
            double m = magnitude;
            x /= m;
            y /= m;
            z /= m;
        }
 
        public void Set(double xx = 0.0, double yy = 0.0, double zz = 0.0)
        {
            x = xx;
            y = yy;
            z = zz;
        }
 
        override public string ToString()
        {
            return "(" + x + ", " + y + ", " + z + ")";
        }
 
        public static double Dot(DVector3 a, DVector3 b)
        {
            return a.x * b.x + a.y * b.y + a.z * b.z;
        }
 
        public static double Distance(DVector3 a, DVector3 b)
        {
            return M.Sqrt(a.x * b.x + a.y * b.y + a.z * b.z);
        }
 
        public static DVector3 Lerp(DVector3 a, DVector3 b, double t)
        {
            double s = M.Max(0, M.Min(t, 1));
            return a * (1 - s) + b * s;
        }
 
        public static DVector3 operator *(DVector3 a, double b)
        {
            return new DVector3(
                b * a.x,
                b * a.y,
                b * a.z
            );
        }
 
        public static DVector3 operator *(double b, DVector3 a)
        {
            return new DVector3(
                b * a.x,
                b * a.y,
                b * a.z
            );
        }
 
        public static DVector3 operator /(DVector3 a, double b)
        {
            return new DVector3(
                a.x / b,
                a.y / b,
                a.z / b
            );
        }
 
        public static DVector3 operator +(DVector3 a, DVector3 b)
        {
            return new DVector3(
                a.x + b.x,
                a.y + b.y,
                a.z + b.z
            );
        }
 
        public static DVector3 operator -(DVector3 a, DVector3 b)
        {
            return new DVector3(
                a.x - b.x,
                a.y - b.y,
                a.z - b.z
            );
        }
    }
}