Class MathOps

Inheritance

System.Object

MathOps

Inherited Members

System.Object.Equals(System.Object)

System.Object.Equals(System.Object, System.Object)

System.Object.GetHashCode()

System.Object.GetType()

System.Object.MemberwiseClone()

System.Object.ReferenceEquals(System.Object, System.Object)

System.Object.ToString()

Namespace: Vim.Math3d

Assembly: Vim.Math3D.dll

public static class MathOps

Methods

Abs(Double)

public static double Abs(this double x)

Abs(Int32)

public static int Abs(this int a)

Abs(Int64)

public static long Abs(this long a)

Abs(Single)

public static float Abs(this float x)

Abs(DVector2)

public static DVector2 Abs(this DVector2 v)

Abs(DVector3)

public static DVector3 Abs(this DVector3 v)

Abs(DVector4)

public static DVector4 Abs(this DVector4 v)

Abs(Vector2)

public static Vector2 Abs(this Vector2 v)

Abs(Vector3)

public static Vector3 Abs(this Vector3 v)

Abs(Vector4)

public static Vector4 Abs(this Vector4 v)

Acos(Double)

public static double Acos(this double x)

Acos(Single)

public static float Acos(this float x)

Acos(DVector2)

public static DVector2 Acos(this DVector2 v)

Acos(DVector3)

public static DVector3 Acos(this DVector3 v)

Acos(DVector4)

public static DVector4 Acos(this DVector4 v)

Acos(Vector2)

public static Vector2 Acos(this Vector2 v)

Acos(Vector3)

public static Vector3 Acos(this Vector3 v)

Acos(Vector4)

public static Vector4 Acos(this Vector4 v)

Add(Double, Double)

public static double Add(this double v1, double v2)

Add(Int32, Int32)

public static int Add(this int v1, int v2)

Add(Int64, Int64)

public static long Add(this long v1, long v2)

Add(Single, Single)

public static float Add(this float v1, float v2)

Add(DVector2, DVector2)

public static DVector2 Add(this DVector2 v1, DVector2 v2)

Add(DVector3, DVector3)

public static DVector3 Add(this DVector3 v1, DVector3 v2)

Add(DVector4, DVector4)

public static DVector4 Add(this DVector4 v1, DVector4 v2)

Add(Vector2, Vector2)

public static Vector2 Add(this Vector2 v1, Vector2 v2)

Add(Vector3, Vector3)

public static Vector3 Add(this Vector3 v1, Vector3 v2)

Add(Vector4, Vector4)

public static Vector4 Add(this Vector4 v1, Vector4 v2)

AlmostEquals(Double, Double, Single)

public static bool AlmostEquals(this double v1, double v2, float tolerance = 1E-07F)

AlmostEquals(Single, Single, Single)

public static bool AlmostEquals(this float v1, float v2, float tolerance = 1E-07F)

AlmostZero(Double, Single)

public static bool AlmostZero(this double v, float tolerance = 1E-07F)

AlmostZero(Single, Single)

public static bool AlmostZero(this float v, float tolerance = 1E-07F)

Along(Vector3, Single)

public static Vector3 Along(this Vector3 v, float d)

AlongX(Single)

public static Vector3 AlongX(this float self)

AlongY(Single)

public static Vector3 AlongY(this float self)

AlongZ(Single)

public static Vector3 AlongZ(this float self)

And(Boolean, Boolean)

public static bool And(this bool a, bool b)

And(Int32, Int32)

public static int And(this int a, int b)

And(Int64, Int64)

public static long And(this long a, long b)

Angle(Vector3, Vector3, Single)

public static float Angle(this Vector3 v1, Vector3 v2, float tolerance = 1E-07F)

Asin(Double)

public static double Asin(this double x)

Asin(Single)

public static float Asin(this float x)

Asin(DVector2)

public static DVector2 Asin(this DVector2 v)

Asin(DVector3)

public static DVector3 Asin(this DVector3 v)

Asin(DVector4)

public static DVector4 Asin(this DVector4 v)

Asin(Vector2)

public static Vector2 Asin(this Vector2 v)

Asin(Vector3)

public static Vector3 Asin(this Vector3 v)

Asin(Vector4)

public static Vector4 Asin(this Vector4 v)

Atan(Double)

public static double Atan(this double x)

Atan(Single)

public static float Atan(this float x)

Atan(DVector2)

public static DVector2 Atan(this DVector2 v)

Atan(DVector3)

public static DVector3 Atan(this DVector3 v)

Atan(DVector4)

public static DVector4 Atan(this DVector4 v)

Atan(Vector2)

public static Vector2 Atan(this Vector2 v)

Atan(Vector3)

public static Vector3 Atan(this Vector3 v)

Atan(Vector4)

public static Vector4 Atan(this Vector4 v)

Average(IEnumerable<DVector2>)

public static DVector2 Average(this IEnumerable<DVector2> self)

Average(IEnumerable<DVector3>)

public static DVector3 Average(this IEnumerable<DVector3> self)

Average(IEnumerable<DVector4>)

public static DVector4 Average(this IEnumerable<DVector4> self)

Average(IEnumerable<Vector2>)

public static Vector2 Average(this IEnumerable<Vector2> self)

Average(IEnumerable<Vector3>)

public static Vector3 Average(this IEnumerable<Vector3> self)

Average(IEnumerable<Vector4>)

public static Vector4 Average(this IEnumerable<Vector4> self)

Average(Double, Double)

public static double Average(this double v1, double v2)

Average(Single, Single)

public static float Average(this float v1, float v2)

Average(DVector2, DVector2)

public static DVector2 Average(this DVector2 v1, DVector2 v2)

Average(DVector3, DVector3)

public static DVector3 Average(this DVector3 v1, DVector3 v2)

Average(DVector4, DVector4)

public static DVector4 Average(this DVector4 v1, DVector4 v2)

Average(Stats<DVector2>)

public static DVector2 Average(this Stats<DVector2> self)

Average(Stats<DVector3>)

public static DVector3 Average(this Stats<DVector3> self)

Average(Stats<DVector4>)

public static DVector4 Average(this Stats<DVector4> self)

Average(Stats<Vector2>)

public static Vector2 Average(this Stats<Vector2> self)

Average(Stats<Vector3>)

public static Vector3 Average(this Stats<Vector3> self)

Average(Stats<Vector4>)

public static Vector4 Average(this Stats<Vector4> self)

Average(Vector2, Vector2)

public static Vector2 Average(this Vector2 v1, Vector2 v2)

Average(Vector3, Vector3)

public static Vector3 Average(this Vector3 v1, Vector3 v2)

Average(Vector4, Vector4)

public static Vector4 Average(this Vector4 v1, Vector4 v2)

Barycentric(Double, Double, Double, Single, Single)

public static double Barycentric(this double v1, double v2, double v3, float u, float v)

Barycentric(Single, Single, Single, Single, Single)

public static float Barycentric(this float v1, float v2, float v3, float u, float v)

Barycentric(DVector2, DVector2, DVector2, Single, Single)

public static DVector2 Barycentric(this DVector2 v1, DVector2 v2, DVector2 v3, float u, float v)

Barycentric(DVector3, DVector3, DVector3, Single, Single)

public static DVector3 Barycentric(this DVector3 v1, DVector3 v2, DVector3 v3, float u, float v)

Barycentric(DVector4, DVector4, DVector4, Single, Single)

public static DVector4 Barycentric(this DVector4 v1, DVector4 v2, DVector4 v3, float u, float v)

Barycentric(Vector2, Vector2, Vector2, Single, Single)

public static Vector2 Barycentric(this Vector2 v1, Vector2 v2, Vector2 v3, float u, float v)

Barycentric(Vector3, Vector3, Vector3, Single, Single)

public static Vector3 Barycentric(this Vector3 v1, Vector3 v2, Vector3 v3, float u, float v)

Barycentric(Vector4, Vector4, Vector4, Single, Single)

public static Vector4 Barycentric(this Vector4 v1, Vector4 v2, Vector4 v3, float u, float v)

CatmullRom(Single, Single, Single, Single, Single)

Performs a Catmull-Rom interpolation using the specified positions.

public static float CatmullRom(this float value1, float value2, float value3, float value4, float amount)

CatmullRom(Vector3, Vector3, Vector3, Vector3, Single)

Creates a new Vector3 that contains CatmullRom interpolation of the specified vectors.

public static Vector3 CatmullRom(this Vector3 value1, Vector3 value2, Vector3 value3, Vector3 value4, float amount)

Ceiling(Double)

public static double Ceiling(this double x)

Ceiling(Single)

public static float Ceiling(this float x)

Ceiling(DVector2)

public static DVector2 Ceiling(this DVector2 v)

Ceiling(DVector3)

public static DVector3 Ceiling(this DVector3 v)

Ceiling(DVector4)

public static DVector4 Ceiling(this DVector4 v)

Ceiling(Vector2)

public static Vector2 Ceiling(this Vector2 v)

Ceiling(Vector3)

public static Vector3 Ceiling(this Vector3 v)

Ceiling(Vector4)

public static Vector4 Ceiling(this Vector4 v)

Clamp(Double, Double, Double)

public static double Clamp(this double v, double min, double max)

Clamp(Int32, Int32, Int32)

public static int Clamp(this int v, int min, int max)

Clamp(Int64, Int64, Int64)

public static long Clamp(this long v, long min, long max)

Clamp(Single, Single, Single)

public static float Clamp(this float v, float min, float max)

Clamp(DVector2, DVector2, DVector2)

public static DVector2 Clamp(this DVector2 v, DVector2 min, DVector2 max)

Clamp(DVector3, DVector3, DVector3)

public static DVector3 Clamp(this DVector3 v, DVector3 min, DVector3 max)

Clamp(DVector4, DVector4, DVector4)

public static DVector4 Clamp(this DVector4 v, DVector4 min, DVector4 max)

Clamp(Vector2, Vector2, Vector2)

public static Vector2 Clamp(this Vector2 v, Vector2 min, Vector2 max)

Clamp(Vector3, Vector3, Vector3)

public static Vector3 Clamp(this Vector3 v, Vector3 min, Vector3 max)

Clamp(Vector4, Vector4, Vector4)

public static Vector4 Clamp(this Vector4 v, Vector4 min, Vector4 max)

ClampLower(Double, Double)

public static double ClampLower(this double v, double min)

ClampLower(Single, Single)

public static float ClampLower(this float v, float min)

ClampLower(DVector2, DVector2)

public static DVector2 ClampLower(this DVector2 v, DVector2 min)

ClampLower(DVector3, DVector3)

public static DVector3 ClampLower(this DVector3 v, DVector3 min)

ClampLower(DVector4, DVector4)

public static DVector4 ClampLower(this DVector4 v, DVector4 min)

ClampLower(Vector2, Vector2)

public static Vector2 ClampLower(this Vector2 v, Vector2 min)

ClampLower(Vector3, Vector3)

public static Vector3 ClampLower(this Vector3 v, Vector3 min)

ClampLower(Vector4, Vector4)

public static Vector4 ClampLower(this Vector4 v, Vector4 min)

ClampUpper(Double, Double)

public static double ClampUpper(this double v, double max)

ClampUpper(Single, Single)

public static float ClampUpper(this float v, float max)

ClampUpper(DVector2, DVector2)

public static DVector2 ClampUpper(this DVector2 v, DVector2 max)

ClampUpper(DVector3, DVector3)

public static DVector3 ClampUpper(this DVector3 v, DVector3 max)

ClampUpper(DVector4, DVector4)

public static DVector4 ClampUpper(this DVector4 v, DVector4 max)

ClampUpper(Vector2, Vector2)

public static Vector2 ClampUpper(this Vector2 v, Vector2 max)

ClampUpper(Vector3, Vector3)

public static Vector3 ClampUpper(this Vector3 v, Vector3 max)

ClampUpper(Vector4, Vector4)

public static Vector4 ClampUpper(this Vector4 v, Vector4 max)

Colinear(Vector3, Vector3, Single)

public static bool Colinear(this Vector3 v1, Vector3 v2, float tolerance = 1E-07F)

Coplanar(Vector3, Vector3, Vector3, Vector3, Single)

Returns true if the four points are co-planar.

public static bool Coplanar(Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, float epsilon = 1E-07F)

Cos(Double)

public static double Cos(this double x)

Cos(Single)

public static float Cos(this float x)

Cos(DVector2)

public static DVector2 Cos(this DVector2 v)

Cos(DVector3)

public static DVector3 Cos(this DVector3 v)

Cos(DVector4)

public static DVector4 Cos(this DVector4 v)

Cos(Vector2)

public static Vector2 Cos(this Vector2 v)

Cos(Vector3)

public static Vector3 Cos(this Vector3 v)

Cos(Vector4)

public static Vector4 Cos(this Vector4 v)

Cosh(Double)

public static double Cosh(this double x)

Cosh(Single)

public static float Cosh(this float x)

Cosh(DVector2)

public static DVector2 Cosh(this DVector2 v)

Cosh(DVector3)

public static DVector3 Cosh(this DVector3 v)

Cosh(DVector4)

public static DVector4 Cosh(this DVector4 v)

Cosh(Vector2)

public static Vector2 Cosh(this Vector2 v)

Cosh(Vector3)

public static Vector3 Cosh(this Vector3 v)

Cosh(Vector4)

public static Vector4 Cosh(this Vector4 v)

Cross(Vector3, Vector3)

public static Vector3 Cross(Vector3 a, Vector3 b)

Cube(Double)

public static double Cube(this double x)

Cube(Int32)

public static int Cube(this int x)

Cube(Int64)

public static long Cube(this long x)

Cube(Single)

public static float Cube(this float x)

Cube(DVector2)

public static DVector2 Cube(this DVector2 v)

Cube(DVector3)

public static DVector3 Cube(this DVector3 v)

Cube(DVector4)

public static DVector4 Cube(this DVector4 v)

Cube(Vector2)

public static Vector2 Cube(this Vector2 v)

Cube(Vector3)

public static Vector3 Cube(this Vector3 v)

Cube(Vector4)

public static Vector4 Cube(this Vector4 v)

Distance(Double, Double)

public static double Distance(this double v1, double v2)

Distance(Single, Single)

public static float Distance(this float v1, float v2)

Distance(DVector2, DVector2)

public static double Distance(this DVector2 v1, DVector2 v2)

Distance(DVector3, DVector3)

public static double Distance(this DVector3 v1, DVector3 v2)

Distance(DVector4, DVector4)

public static double Distance(this DVector4 v1, DVector4 v2)

Distance(Vector2, Vector2)

public static float Distance(this Vector2 v1, Vector2 v2)

Distance(Vector3, Vector3)

public static float Distance(this Vector3 v1, Vector3 v2)

Distance(Vector4, Vector4)

public static float Distance(this Vector4 v1, Vector4 v2)

DistanceSquared(DVector2, DVector2)

public static double DistanceSquared(this DVector2 v1, DVector2 v2)

DistanceSquared(DVector3, DVector3)

public static double DistanceSquared(this DVector3 v1, DVector3 v2)

DistanceSquared(DVector4, DVector4)

public static double DistanceSquared(this DVector4 v1, DVector4 v2)

DistanceSquared(Vector2, Vector2)

public static float DistanceSquared(this Vector2 v1, Vector2 v2)

DistanceSquared(Vector3, Vector3)

public static float DistanceSquared(this Vector3 v1, Vector3 v2)

DistanceSquared(Vector4, Vector4)

public static float DistanceSquared(this Vector4 v1, Vector4 v2)

Divide(Double, Double)

public static double Divide(this double v1, double v2)

Divide(Int32, Int32)

public static int Divide(this int v1, int v2)

Divide(Int64, Int64)

public static long Divide(this long v1, long v2)

Divide(Single, Single)

public static float Divide(this float v1, float v2)

Divide(DVector2, DVector2)

public static DVector2 Divide(this DVector2 v1, DVector2 v2)

Divide(DVector3, DVector3)

public static DVector3 Divide(this DVector3 v1, DVector3 v2)

Divide(DVector4, DVector4)

public static DVector4 Divide(this DVector4 v1, DVector4 v2)

Divide(Vector2, Vector2)

public static Vector2 Divide(this Vector2 v1, Vector2 v2)

Divide(Vector3, Vector3)

public static Vector3 Divide(this Vector3 v1, Vector3 v2)

Divide(Vector4, Vector4)

public static Vector4 Divide(this Vector4 v1, Vector4 v2)

DivideRoundUp(Int32, Int32)

public static int DivideRoundUp(this int a, int b)

DivideRoundUp(Int64, Int64)

public static long DivideRoundUp(this long a, long b)

Dot(DVector2, DVector2)

public static double Dot(this DVector2 v1, DVector2 v2)

Dot(DVector3, DVector3)

public static double Dot(this DVector3 v1, DVector3 v2)

Dot(DVector4, DVector4)

public static double Dot(this DVector4 v1, DVector4 v2)

Dot(Vector2, Vector2)

public static float Dot(this Vector2 v1, Vector2 v2)

Dot(Vector3, Vector3)

public static float Dot(this Vector3 v1, Vector3 v2)

Dot(Vector4, Vector4)

public static float Dot(this Vector4 v1, Vector4 v2)

Eq(Boolean, Boolean)

public static bool Eq(this bool a, bool b)

Eq(Double, Double)

public static bool Eq(this double v1, double v2)

Eq(Int32, Int32)

public static bool Eq(this int v1, int v2)

Eq(Int64, Int64)

public static bool Eq(this long v1, long v2)

Eq(Single, Single)

public static bool Eq(this float v1, float v2)

Exp(Double)

public static double Exp(this double x)

Exp(Single)

public static float Exp(this float x)

Exp(DVector2)

public static DVector2 Exp(this DVector2 v)

Exp(DVector3)

public static DVector3 Exp(this DVector3 v)

Exp(DVector4)

public static DVector4 Exp(this DVector4 v)

Exp(Vector2)

public static Vector2 Exp(this Vector2 v)

Exp(Vector3)

public static Vector3 Exp(this Vector3 v)

Exp(Vector4)

public static Vector4 Exp(this Vector4 v)

Extents(IEnumerable<DVector2>)

public static DVector2 Extents(this IEnumerable<DVector2> self)

Extents(IEnumerable<DVector3>)

public static DVector3 Extents(this IEnumerable<DVector3> self)

Extents(IEnumerable<DVector4>)

public static DVector4 Extents(this IEnumerable<DVector4> self)

Extents(IEnumerable<Vector2>)

public static Vector2 Extents(this IEnumerable<Vector2> self)

Extents(IEnumerable<Vector3>)

public static Vector3 Extents(this IEnumerable<Vector3> self)

Extents(IEnumerable<Vector4>)

public static Vector4 Extents(this IEnumerable<Vector4> self)

Extents(Stats<DVector2>)

public static DVector2 Extents(this Stats<DVector2> self)

Extents(Stats<DVector3>)

public static DVector3 Extents(this Stats<DVector3> self)

Extents(Stats<DVector4>)

public static DVector4 Extents(this Stats<DVector4> self)

Extents(Stats<Vector2>)

public static Vector2 Extents(this Stats<Vector2> self)

Extents(Stats<Vector3>)

public static Vector3 Extents(this Stats<Vector3> self)

Extents(Stats<Vector4>)

public static Vector4 Extents(this Stats<Vector4> self)

Floor(Double)

public static double Floor(this double x)

Floor(Single)

public static float Floor(this float x)

Floor(DVector2)

public static DVector2 Floor(this DVector2 v)

Floor(DVector3)

public static DVector3 Floor(this DVector3 v)

Floor(DVector4)

public static DVector4 Floor(this DVector4 v)

Floor(Vector2)

public static Vector2 Floor(this Vector2 v)

Floor(Vector3)

public static Vector3 Floor(this Vector3 v)

Floor(Vector4)

public static Vector4 Floor(this Vector4 v)

Gt(Double, Double)

public static bool Gt(this double v1, double v2)

Gt(Int32, Int32)

public static bool Gt(this int v1, int v2)

Gt(Int64, Int64)

public static bool Gt(this long v1, long v2)

Gt(Single, Single)

public static bool Gt(this float v1, float v2)

GtEq(Double, Double)

public static bool GtEq(this double v1, double v2)

GtEq(Int32, Int32)

public static bool GtEq(this int v1, int v2)

GtEq(Int64, Int64)

public static bool GtEq(this long v1, long v2)

GtEq(Single, Single)

public static bool GtEq(this float v1, float v2)

Hermite(Single, Single, Single, Single, Single)

Performs a Hermite spline interpolation.

public static float Hermite(this float value1, float tangent1, float value2, float tangent2, float amount)

Hermite(Vector3, Vector3, Vector3, Vector3, Single)

Creates a new Vector3 that contains hermite spline interpolation.

public static Vector3 Hermite(this Vector3 value1, Vector3 tangent1, Vector3 value2, Vector3 tangent2, float amount)

Inverse(Double)

public static double Inverse(this double x)

Inverse(Single)

public static float Inverse(this float x)

Inverse(DVector2)

public static DVector2 Inverse(this DVector2 v)

Inverse(DVector3)

public static DVector3 Inverse(this DVector3 v)

Inverse(DVector4)

public static DVector4 Inverse(this DVector4 v)

Inverse(Matrix4x4)

public static Matrix4x4 Inverse(this Matrix4x4 m)

Inverse(Vector2)

public static Vector2 Inverse(this Vector2 v)

Inverse(Vector3)

public static Vector3 Inverse(this Vector3 v)

Inverse(Vector4)

public static Vector4 Inverse(this Vector4 v)

InverseLerp(Double, Double, Double)

public static double InverseLerp(this double v, double a, double b)

InverseLerp(Single, Single, Single)

public static float InverseLerp(this float v, float a, float b)

InverseLerp(DVector2, DVector2, DVector2)

public static DVector2 InverseLerp(this DVector2 v, DVector2 a, DVector2 b)

InverseLerp(DVector3, DVector3, DVector3)

public static DVector3 InverseLerp(this DVector3 v, DVector3 a, DVector3 b)

InverseLerp(DVector4, DVector4, DVector4)

public static DVector4 InverseLerp(this DVector4 v, DVector4 a, DVector4 b)

InverseLerp(Vector2, Vector2, Vector2)

public static Vector2 InverseLerp(this Vector2 v, Vector2 a, Vector2 b)

InverseLerp(Vector3, Vector3, Vector3)

public static Vector3 InverseLerp(this Vector3 v, Vector3 a, Vector3 b)

InverseLerp(Vector4, Vector4, Vector4)

public static Vector4 InverseLerp(this Vector4 v, Vector4 a, Vector4 b)

IsBackFace(Vector3, Vector3)

public static bool IsBackFace(this Vector3 normal, Vector3 lineOfSight)

IsEven(Int32)

public static bool IsEven(this int n)

IsEven(Int64)

public static bool IsEven(this long n)

IsInfinity(Double)

public static bool IsInfinity(this double v)

IsInfinity(Int32)

public static bool IsInfinity(this int n)

IsInfinity(Int64)

public static bool IsInfinity(this long n)

IsInfinity(Single)

public static bool IsInfinity(this float v)

IsNaN(Double)

public static bool IsNaN(this double v)

IsNaN(Int32)

public static bool IsNaN(this int n)

IsNaN(Int64)

public static bool IsNaN(this long n)

IsNaN(Single)

public static bool IsNaN(this float v)

IsNonZeroAndValid(Single, Single)

public static bool IsNonZeroAndValid(this float self, float tolerance = 1E-07F)

IsNonZeroAndValid(Vector3)

public static bool IsNonZeroAndValid(this Vector3 self)

IsOdd(Int32)

public static bool IsOdd(this int n)

IsOdd(Int64)

public static bool IsOdd(this long n)

IsPerpendicular(Vector3, Vector3, Single)

public static bool IsPerpendicular(this Vector3 v1, Vector3 v2, float tolerance = 1E-07F)

IsPowerOfTwo(Int32)

public static bool IsPowerOfTwo(this int v)

IsPowerOfTwo(Int64)

public static bool IsPowerOfTwo(this long v)

IsZeroOrInvalid(Vector3)

public static bool IsZeroOrInvalid(this Vector3 self)

Length(DVector2)

public static double Length(this DVector2 v)

Length(DVector3)

public static double Length(this DVector3 v)

Length(DVector4)

public static double Length(this DVector4 v)

Length(Vector2)

public static float Length(this Vector2 v)

Length(Vector3)

public static float Length(this Vector3 v)

Length(Vector4)

public static float Length(this Vector4 v)

LengthSquared(DVector2)

public static double LengthSquared(this DVector2 v)

LengthSquared(DVector3)

public static double LengthSquared(this DVector3 v)

LengthSquared(DVector4)

public static double LengthSquared(this DVector4 v)

LengthSquared(Vector2)

public static float LengthSquared(this Vector2 v)

LengthSquared(Vector3)

public static float LengthSquared(this Vector3 v)

LengthSquared(Vector4)

public static float LengthSquared(this Vector4 v)

Lerp(Double, Double, Single)

public static double Lerp(this double v1, double v2, float t)

Lerp(Single, Single, Single)

public static float Lerp(this float v1, float v2, float t)

Lerp(DVector2, DVector2, Single)

public static DVector2 Lerp(this DVector2 v1, DVector2 v2, float t)

Lerp(DVector3, DVector3, Single)

public static DVector3 Lerp(this DVector3 v1, DVector3 v2, float t)

Lerp(DVector4, DVector4, Single)

public static DVector4 Lerp(this DVector4 v1, DVector4 v2, float t)

Lerp(Vector2, Vector2, Single)

public static Vector2 Lerp(this Vector2 v1, Vector2 v2, float t)

Lerp(Vector3, Vector3, Single)

public static Vector3 Lerp(this Vector3 v1, Vector3 v2, float t)

Lerp(Vector4, Vector4, Single)

public static Vector4 Lerp(this Vector4 v1, Vector4 v2, float t)

LerpPrecise(Double, Double, Single)

public static double LerpPrecise(this double v1, double v2, float t)

LerpPrecise(Single, Single, Single)

public static float LerpPrecise(this float v1, float v2, float t)

LerpPrecise(DVector2, DVector2, Single)

public static DVector2 LerpPrecise(this DVector2 v1, DVector2 v2, float t)

LerpPrecise(DVector3, DVector3, Single)

public static DVector3 LerpPrecise(this DVector3 v1, DVector3 v2, float t)

LerpPrecise(DVector4, DVector4, Single)

public static DVector4 LerpPrecise(this DVector4 v1, DVector4 v2, float t)

LerpPrecise(Vector2, Vector2, Single)

public static Vector2 LerpPrecise(this Vector2 v1, Vector2 v2, float t)

LerpPrecise(Vector3, Vector3, Single)

public static Vector3 LerpPrecise(this Vector3 v1, Vector3 v2, float t)

LerpPrecise(Vector4, Vector4, Single)

public static Vector4 LerpPrecise(this Vector4 v1, Vector4 v2, float t)

Log(Double)

public static double Log(this double x)

Log(Single)

public static float Log(this float x)

Log(DVector2)

public static DVector2 Log(this DVector2 v)

Log(DVector3)

public static DVector3 Log(this DVector3 v)

Log(DVector4)

public static DVector4 Log(this DVector4 v)

Log(Vector2)

public static Vector2 Log(this Vector2 v)

Log(Vector3)

public static Vector3 Log(this Vector3 v)

Log(Vector4)

public static Vector4 Log(this Vector4 v)

Log10(Double)

public static double Log10(this double x)

Log10(Single)

public static float Log10(this float x)

Log10(DVector2)

public static DVector2 Log10(this DVector2 v)

Log10(DVector3)

public static DVector3 Log10(this DVector3 v)

Log10(DVector4)

public static DVector4 Log10(this DVector4 v)

Log10(Vector2)

public static Vector2 Log10(this Vector2 v)

Log10(Vector3)

public static Vector3 Log10(this Vector3 v)

Log10(Vector4)

public static Vector4 Log10(this Vector4 v)

Lt(Double, Double)

public static bool Lt(this double v1, double v2)

Lt(Int32, Int32)

public static bool Lt(this int v1, int v2)

Lt(Int64, Int64)

public static bool Lt(this long v1, long v2)

Lt(Single, Single)

public static bool Lt(this float v1, float v2)

LtEq(Double, Double)

public static bool LtEq(this double v1, double v2)

LtEq(Int32, Int32)

public static bool LtEq(this int v1, int v2)

LtEq(Int64, Int64)

public static bool LtEq(this long v1, long v2)

LtEq(Single, Single)

public static bool LtEq(this float v1, float v2)

Magnitude(Double)

public static double Magnitude(this double x)

Magnitude(Int32)

public static int Magnitude(this int x)

Magnitude(Int64)

public static long Magnitude(this long x)

Magnitude(Single)

public static float Magnitude(this float x)

MagnitudeSquared(Double)

public static double MagnitudeSquared(this double x)

MagnitudeSquared(Int32)

public static int MagnitudeSquared(this int x)

MagnitudeSquared(Int64)

public static long MagnitudeSquared(this long x)

MagnitudeSquared(Single)

public static float MagnitudeSquared(this float x)

Max(IEnumerable<DVector2>)

public static DVector2 Max(this IEnumerable<DVector2> self)

Max(IEnumerable<DVector3>)

public static DVector3 Max(this IEnumerable<DVector3> self)

Max(IEnumerable<DVector4>)

public static DVector4 Max(this IEnumerable<DVector4> self)

Max(IEnumerable<Vector2>)

public static Vector2 Max(this IEnumerable<Vector2> self)

Max(IEnumerable<Vector3>)

public static Vector3 Max(this IEnumerable<Vector3> self)

Max(IEnumerable<Vector4>)

public static Vector4 Max(this IEnumerable<Vector4> self)

Max(Double, Double)

public static double Max(this double v1, double v2)

Max(Int32, Int32)

public static int Max(this int v1, int v2)

Max(Int64, Int64)

public static long Max(this long v1, long v2)

Max(Single, Single)

public static float Max(this float v1, float v2)

Max(DVector2, DVector2)

public static DVector2 Max(this DVector2 v1, DVector2 v2)

Max(DVector3, DVector3)

public static DVector3 Max(this DVector3 v1, DVector3 v2)

Max(DVector4, DVector4)

public static DVector4 Max(this DVector4 v1, DVector4 v2)

Max(Vector2, Vector2)

public static Vector2 Max(this Vector2 v1, Vector2 v2)

Max(Vector3, Vector3)

public static Vector3 Max(this Vector3 v1, Vector3 v2)

Max(Vector4, Vector4)

public static Vector4 Max(this Vector4 v1, Vector4 v2)

Middle(IEnumerable<DVector2>)

public static DVector2 Middle(this IEnumerable<DVector2> self)

Middle(IEnumerable<DVector3>)

public static DVector3 Middle(this IEnumerable<DVector3> self)

Middle(IEnumerable<DVector4>)

public static DVector4 Middle(this IEnumerable<DVector4> self)

Middle(IEnumerable<Vector2>)

public static Vector2 Middle(this IEnumerable<Vector2> self)

Middle(IEnumerable<Vector3>)

public static Vector3 Middle(this IEnumerable<Vector3> self)

Middle(IEnumerable<Vector4>)

public static Vector4 Middle(this IEnumerable<Vector4> self)

Middle(Stats<DVector2>)

public static DVector2 Middle(this Stats<DVector2> self)

Middle(Stats<DVector3>)

public static DVector3 Middle(this Stats<DVector3> self)

Middle(Stats<DVector4>)

public static DVector4 Middle(this Stats<DVector4> self)

Middle(Stats<Vector2>)

public static Vector2 Middle(this Stats<Vector2> self)

Middle(Stats<Vector3>)

public static Vector3 Middle(this Stats<Vector3> self)

Middle(Stats<Vector4>)

public static Vector4 Middle(this Stats<Vector4> self)

Min(IEnumerable<DVector2>)

public static DVector2 Min(this IEnumerable<DVector2> self)

Min(IEnumerable<DVector3>)

public static DVector3 Min(this IEnumerable<DVector3> self)

Min(IEnumerable<DVector4>)

public static DVector4 Min(this IEnumerable<DVector4> self)

Min(IEnumerable<Vector2>)

public static Vector2 Min(this IEnumerable<Vector2> self)

Min(IEnumerable<Vector3>)

public static Vector3 Min(this IEnumerable<Vector3> self)

Min(IEnumerable<Vector4>)

public static Vector4 Min(this IEnumerable<Vector4> self)

Min(Double, Double)

public static double Min(this double v1, double v2)

Min(Int32, Int32)

public static int Min(this int v1, int v2)

Min(Int64, Int64)

public static long Min(this long v1, long v2)

Min(Single, Single)

public static float Min(this float v1, float v2)

Min(DVector2, DVector2)

public static DVector2 Min(this DVector2 v1, DVector2 v2)

Min(DVector3, DVector3)

public static DVector3 Min(this DVector3 v1, DVector3 v2)

Min(DVector4, DVector4)

public static DVector4 Min(this DVector4 v1, DVector4 v2)

Min(Vector2, Vector2)

public static Vector2 Min(this Vector2 v1, Vector2 v2)

Min(Vector3, Vector3)

public static Vector3 Min(this Vector3 v1, Vector3 v2)

Min(Vector4, Vector4)

public static Vector4 Min(this Vector4 v1, Vector4 v2)

Multiply(Double, Double)

public static double Multiply(this double v1, double v2)

Multiply(Int32, Int32)

public static int Multiply(this int v1, int v2)

Multiply(Int64, Int64)

public static long Multiply(this long v1, long v2)

Multiply(Single, Single)

public static float Multiply(this float v1, float v2)

Multiply(DVector2, DVector2)

public static DVector2 Multiply(this DVector2 v1, DVector2 v2)

Multiply(DVector3, DVector3)

public static DVector3 Multiply(this DVector3 v1, DVector3 v2)

Multiply(DVector4, DVector4)

public static DVector4 Multiply(this DVector4 v1, DVector4 v2)

Multiply(Vector2, Vector2)

public static Vector2 Multiply(this Vector2 v1, Vector2 v2)

Multiply(Vector3, Vector3)

public static Vector3 Multiply(this Vector3 v1, Vector3 v2)

Multiply(Vector4, Vector4)

public static Vector4 Multiply(this Vector4 v1, Vector4 v2)

NAnd(Boolean, Boolean)

public static bool NAnd(this bool a, bool b)

NAnd(Int32, Int32)

public static int NAnd(this int a, int b)

NAnd(Int64, Int64)

public static long NAnd(this long a, long b)

Negate(Double)

public static double Negate(this double v)

Negate(Int32)

public static int Negate(this int v)

Negate(Int64)

public static long Negate(this long v)

Negate(Single)

public static float Negate(this float v)

Negate(DVector2)

public static DVector2 Negate(this DVector2 v)

Negate(DVector3)

public static DVector3 Negate(this DVector3 v)

Negate(DVector4)

public static DVector4 Negate(this DVector4 v)

Negate(Vector2)

public static Vector2 Negate(this Vector2 v)

Negate(Vector3)

public static Vector3 Negate(this Vector3 v)

Negate(Vector4)

public static Vector4 Negate(this Vector4 v)

NEq(Boolean, Boolean)

public static bool NEq(this bool a, bool b)

NEq(Double, Double)

public static bool NEq(this double v1, double v2)

NEq(Int32, Int32)

public static bool NEq(this int v1, int v2)

NEq(Int64, Int64)

public static bool NEq(this long v1, long v2)

NEq(Single, Single)

public static bool NEq(this float v1, float v2)

NOr(Boolean, Boolean)

public static bool NOr(this bool a, bool b)

NOr(Int32, Int32)

public static int NOr(this int a, int b)

NOr(Int64, Int64)

public static long NOr(this long a, long b)

Normalize(DVector2)

public static DVector2 Normalize(this DVector2 v)

Normalize(DVector3)

public static DVector3 Normalize(this DVector3 v)

Normalize(DVector4)

public static DVector4 Normalize(this DVector4 v)

Normalize(Vector2)

public static Vector2 Normalize(this Vector2 v)

Normalize(Vector3)

public static Vector3 Normalize(this Vector3 v)

Normalize(Vector4)

public static Vector4 Normalize(this Vector4 v)

Not(Boolean)

public static bool Not(this bool a)

Not(Int32)

public static int Not(this int a)

Not(Int64)

public static long Not(this long a)

Or(Boolean, Boolean)

public static bool Or(this bool a, bool b)

Or(Int32, Int32)

public static int Or(this int a, int b)

Or(Int64, Int64)

public static long Or(this long a, long b)

Percentage(Double, Double)

Expresses two vlaues as a ratio

public static double Percentage(double denominator, double numerator)

Projection(Vector3, Vector3)

public static Vector3 Projection(this Vector3 v1, Vector3 v2)

RayFromProjectionMatrix(Matrix4x4, Vector2)

public static Ray RayFromProjectionMatrix(this Matrix4x4 projection, Vector2 normalisedScreenCoordinates)

Reflect(Vector2, Vector2)

Returns the reflection of a vector off a surface that has the specified normal.

public static Vector2 Reflect(Vector2 vector, Vector2 normal)

Reflect(Vector3, Vector3)

Returns the reflection of a vector off a surface that has the specified normal.

public static Vector3 Reflect(Vector3 vector, Vector3 normal)

Rejection(Vector3, Vector3)

public static Vector3 Rejection(this Vector3 v1, Vector3 v2)

Rotate(Vector3, Vector3, Single)

public static Vector3 Rotate(this Vector3 self, Vector3 axis, float angle)

Round(Double)

public static double Round(this double x)

Round(Single)

public static float Round(this float x)

Round(DVector2)

public static DVector2 Round(this DVector2 v)

Round(DVector3)

public static DVector3 Round(this DVector3 v)

Round(DVector4)

public static DVector4 Round(this DVector4 v)

Round(Vector2)

public static Vector2 Round(this Vector2 v)

Round(Vector3)

public static Vector3 Round(this Vector3 v)

Round(Vector4)

public static Vector4 Round(this Vector4 v)

SafeNormalize(DVector2)

public static DVector2 SafeNormalize(this DVector2 v)

SafeNormalize(DVector3)

public static DVector3 SafeNormalize(this DVector3 v)

SafeNormalize(DVector4)

public static DVector4 SafeNormalize(this DVector4 v)

SafeNormalize(Vector2)

public static Vector2 SafeNormalize(this Vector2 v)

SafeNormalize(Vector3)

public static Vector3 SafeNormalize(this Vector3 v)

SafeNormalize(Vector4)

public static Vector4 SafeNormalize(this Vector4 v)

Sign(Double)

public static int Sign(this double x)

Sign(Single)

public static int Sign(this float x)

SignedAngle(Vector3, Vector3)

public static float SignedAngle(this Vector3 from, Vector3 to)

SignedAngle(Vector3, Vector3, Vector3)

public static float SignedAngle(Vector3 from, Vector3 to, Vector3 axis)

Sin(Double)

public static double Sin(this double x)

Sin(Single)

public static float Sin(this float x)

Sin(DVector2)

public static DVector2 Sin(this DVector2 v)

Sin(DVector3)

public static DVector3 Sin(this DVector3 v)

Sin(DVector4)

public static DVector4 Sin(this DVector4 v)

Sin(Vector2)

public static Vector2 Sin(this Vector2 v)

Sin(Vector3)

public static Vector3 Sin(this Vector3 v)

Sin(Vector4)

public static Vector4 Sin(this Vector4 v)

Sinh(Double)

public static double Sinh(this double x)

Sinh(Single)

public static float Sinh(this float x)

Sinh(DVector2)

public static DVector2 Sinh(this DVector2 v)

Sinh(DVector3)

public static DVector3 Sinh(this DVector3 v)

Sinh(DVector4)

public static DVector4 Sinh(this DVector4 v)

Sinh(Vector2)

public static Vector2 Sinh(this Vector2 v)

Sinh(Vector3)

public static Vector3 Sinh(this Vector3 v)

Sinh(Vector4)

public static Vector4 Sinh(this Vector4 v)

Smoothstep(Double)

public static double Smoothstep(this double v)

Smoothstep(Single)

public static float Smoothstep(this float v)

SmoothStep(Single, Single, Single)

Interpolates between two values using a cubic equation (Hermite), clamping the amount to 0 to 1

public static float SmoothStep(this float value1, float value2, float amount)

SmoothStep(Vector3, Vector3, Single)

Creates a new Vector3 that contains cubic interpolation of the specified vectors.

public static Vector3 SmoothStep(this Vector3 value1, Vector3 value2, float amount)

Sqr(Double)

public static double Sqr(this double x)

Sqr(Int32)

public static int Sqr(this int x)

Sqr(Int64)

public static long Sqr(this long x)

Sqr(Single)

public static float Sqr(this float x)

Sqr(DVector2)

public static DVector2 Sqr(this DVector2 v)

Sqr(DVector3)

public static DVector3 Sqr(this DVector3 v)

Sqr(DVector4)

public static DVector4 Sqr(this DVector4 v)

Sqr(Vector2)

public static Vector2 Sqr(this Vector2 v)

Sqr(Vector3)

public static Vector3 Sqr(this Vector3 v)

Sqr(Vector4)

public static Vector4 Sqr(this Vector4 v)

Sqrt(Double)

public static double Sqrt(this double x)

Sqrt(Single)

public static float Sqrt(this float x)

Sqrt(DVector2)

public static DVector2 Sqrt(this DVector2 v)

Sqrt(DVector3)

public static DVector3 Sqrt(this DVector3 v)

Sqrt(DVector4)

public static DVector4 Sqrt(this DVector4 v)

Sqrt(Vector2)

public static Vector2 Sqrt(this Vector2 v)

Sqrt(Vector3)

public static Vector3 Sqrt(this Vector3 v)

Sqrt(Vector4)

public static Vector4 Sqrt(this Vector4 v)

SquareRoot(DVector2)

public static DVector2 SquareRoot(this DVector2 v)

SquareRoot(DVector3)

public static DVector3 SquareRoot(this DVector3 v)

SquareRoot(DVector4)

public static DVector4 SquareRoot(this DVector4 v)

SquareRoot(Vector2)

public static Vector2 SquareRoot(this Vector2 v)

SquareRoot(Vector3)

public static Vector3 SquareRoot(this Vector3 v)

SquareRoot(Vector4)

public static Vector4 SquareRoot(this Vector4 v)

Stats(IEnumerable<DVector2>)

public static Stats<DVector2> Stats(this IEnumerable<DVector2> self)

Stats(IEnumerable<DVector3>)

public static Stats<DVector3> Stats(this IEnumerable<DVector3> self)

Stats(IEnumerable<DVector4>)

public static Stats<DVector4> Stats(this IEnumerable<DVector4> self)

Stats(IEnumerable<Vector2>)

public static Stats<Vector2> Stats(this IEnumerable<Vector2> self)

Stats(IEnumerable<Vector3>)

public static Stats<Vector3> Stats(this IEnumerable<Vector3> self)

Stats(IEnumerable<Vector4>)

public static Stats<Vector4> Stats(this IEnumerable<Vector4> self)

Subtract(Double, Double)

public static double Subtract(this double v1, double v2)

Subtract(Int32, Int32)

public static int Subtract(this int v1, int v2)

Subtract(Int64, Int64)

public static long Subtract(this long v1, long v2)

Subtract(Single, Single)

public static float Subtract(this float v1, float v2)

Subtract(DVector2, DVector2)

public static DVector2 Subtract(this DVector2 v1, DVector2 v2)

Subtract(DVector3, DVector3)

public static DVector3 Subtract(this DVector3 v1, DVector3 v2)

Subtract(DVector4, DVector4)

public static DVector4 Subtract(this DVector4 v1, DVector4 v2)

Subtract(Vector2, Vector2)

public static Vector2 Subtract(this Vector2 v1, Vector2 v2)

Subtract(Vector3, Vector3)

public static Vector3 Subtract(this Vector3 v1, Vector3 v2)

Subtract(Vector4, Vector4)

public static Vector4 Subtract(this Vector4 v1, Vector4 v2)

Sum(IEnumerable<DVector2>)

public static DVector2 Sum(this IEnumerable<DVector2> self)

Sum(IEnumerable<DVector3>)

public static DVector3 Sum(this IEnumerable<DVector3> self)

Sum(IEnumerable<DVector4>)

public static DVector4 Sum(this IEnumerable<DVector4> self)

Sum(IEnumerable<Vector2>)

public static Vector2 Sum(this IEnumerable<Vector2> self)

Sum(IEnumerable<Vector3>)

public static Vector3 Sum(this IEnumerable<Vector3> self)

Sum(IEnumerable<Vector4>)

public static Vector4 Sum(this IEnumerable<Vector4> self)

Tan(Double)

public static double Tan(this double x)

Tan(Single)

public static float Tan(this float x)

Tan(DVector2)

public static DVector2 Tan(this DVector2 v)

Tan(DVector3)

public static DVector3 Tan(this DVector3 v)

Tan(DVector4)

public static DVector4 Tan(this DVector4 v)

Tan(Vector2)

public static Vector2 Tan(this Vector2 v)

Tan(Vector3)

public static Vector3 Tan(this Vector3 v)

Tan(Vector4)

public static Vector4 Tan(this Vector4 v)

Tanh(Double)

public static double Tanh(this double x)

Tanh(Single)

public static float Tanh(this float x)

Tanh(DVector2)

public static DVector2 Tanh(this DVector2 v)

Tanh(DVector3)

public static DVector3 Tanh(this DVector3 v)

Tanh(DVector4)

public static DVector4 Tanh(this DVector4 v)

Tanh(Vector2)

public static Vector2 Tanh(this Vector2 v)

Tanh(Vector3)

public static Vector3 Tanh(this Vector3 v)

Tanh(Vector4)

public static Vector4 Tanh(this Vector4 v)

ToAABoxArray(Single[])

public static AABox[] ToAABoxArray(this float[] m)

ToBox(IEnumerable<Vector3>)

Returns the bounding box for a series of points

public static AABox ToBox(this IEnumerable<Vector3> points)

ToBox(Stats<DVector3>)

Returns the bounding box, given stats on a DVector3

public static DAABox ToBox(this Stats<DVector3> stats)

ToBox(Stats<Vector3>)

Returns the bounding box, given stats on a Vector3

public static AABox ToBox(this Stats<Vector3> stats)

ToDegrees(Double)

public static double ToDegrees(this double x)

ToDegrees(Single)

public static float ToDegrees(this float x)

ToDegrees(DVector2)

public static DVector2 ToDegrees(this DVector2 v)

ToDegrees(DVector3)

public static DVector3 ToDegrees(this DVector3 v)

ToDegrees(DVector4)

public static DVector4 ToDegrees(this DVector4 v)

ToDegrees(Vector2)

public static Vector2 ToDegrees(this Vector2 v)

ToDegrees(Vector3)

public static Vector3 ToDegrees(this Vector3 v)

ToDegrees(Vector4)

public static Vector4 ToDegrees(this Vector4 v)

ToFloats(Matrix4x4)

public static float[] ToFloats(this Matrix4x4 m)

ToFloats(Matrix4x4[])

public static float[] ToFloats(this Matrix4x4[] matrixArray)

ToLine(Vector3)

public static Line ToLine(this Vector3 v)

ToMatrix(Single[])

public static Matrix4x4 ToMatrix(this float[] m)

ToMatrix(Quaternion)

Returns a rotation matrix.

public static Matrix4x4 ToMatrix(this Quaternion self)

ToMatrix(Transform)

Returns a matri for translation and then rotation.

public static Matrix4x4 ToMatrix(this Transform self)

ToMatrix(Vector3)

Returns a translation matrix.

public static Matrix4x4 ToMatrix(this Vector3 self)

ToMatrixArray(Single[])

public static Matrix4x4[] ToMatrixArray(this float[] m)

ToNearestPowOf2(Int32)

Calculate the nearest power of 2 from the input number

public static int ToNearestPowOf2(int x)

ToRadians(Double)

public static double ToRadians(this double x)

ToRadians(Single)

public static float ToRadians(this float x)

ToRadians(DVector2)

public static DVector2 ToRadians(this DVector2 v)

ToRadians(DVector3)

public static DVector3 ToRadians(this DVector3 v)

ToRadians(DVector4)

public static DVector4 ToRadians(this DVector4 v)

ToRadians(Vector2)

public static Vector2 ToRadians(this Vector2 v)

ToRadians(Vector3)

public static Vector3 ToRadians(this Vector3 v)

ToRadians(Vector4)

public static Vector4 ToRadians(this Vector4 v)

ToVector2(Single)

public static Vector2 ToVector2(this float v)

ToVector2(Int2)

public static Vector2 ToVector2(this Int2 t)

ToVector2(Vector3)

public static Vector2 ToVector2(this Vector3 v)

ToVector2(Vector4)

public static Vector2 ToVector2(this Vector4 v)

ToVector3(Single)

public static Vector3 ToVector3(this float v)

ToVector3(Int3)

public static Vector3 ToVector3(this Int3 t)

ToVector3(Vector2)

public static Vector3 ToVector3(this Vector2 v)

ToVector3(Vector4)

public static Vector3 ToVector3(this Vector4 v)

ToVector4(Single)

public static Vector4 ToVector4(this float v)

ToVector4(Vector2)

public static Vector4 ToVector4(this Vector2 v)

ToVector4(Vector3)

public static Vector4 ToVector4(this Vector3 v)

Transform(Vector2, Matrix4x4)

Transforms a vector by the given matrix.

public static Vector2 Transform(this Vector2 position, Matrix4x4 matrix)

Transform(Vector2, Quaternion)

Transforms a vector by the given Quaternion rotation value.

public static Vector2 Transform(this Vector2 value, Quaternion rotation)

Transform(Vector3, Quaternion)

Transforms a vector by the given Quaternion rotation value.

public static Vector3 Transform(this Vector3 value, Quaternion rotation)

Transform(Vector4, Matrix4x4)

Transforms a vector by the given Quaternion rotation value.

public static Vector4 Transform(this Vector4 value, Matrix4x4 matrix)

Transform(Vector4, Quaternion)

Transforms a vector by the given Quaternion rotation value.

public static Vector4 Transform(this Vector4 value, Quaternion rotation)

TransformNormal(Vector2, Matrix4x4)

Transforms a vector normal by the given matrix.

public static Vector2 TransformNormal(Vector2 normal, Matrix4x4 matrix)

TransformNormal(Vector3, Matrix4x4)

Transforms a vector normal by the given matrix.

public static Vector3 TransformNormal(Vector3 normal, Matrix4x4 matrix)

TransformNormal(Vector4, Matrix4x4)

Transforms a vector normal by the given matrix.

public static Vector4 TransformNormal(Vector4 normal, Matrix4x4 matrix)

TransformToVector4(Vector2, Matrix4x4)

Transforms a vector by the given matrix.

public static Vector4 TransformToVector4(Vector2 position, Matrix4x4 matrix)

TransformToVector4(Vector2, Quaternion)

Transforms a vector by the given Quaternion rotation value.

public static Vector4 TransformToVector4(Vector2 value, Quaternion rotation)

TransformToVector4(Vector3, Matrix4x4)

Transforms a vector by the given matrix.

public static Vector4 TransformToVector4(Vector3 position, Matrix4x4 matrix)

TransformToVector4(Vector3, Quaternion)

Transforms a vector by the given Quaternion rotation value.

public static Vector4 TransformToVector4(Vector3 value, Quaternion rotation)

Truncate(Double)

public static double Truncate(this double x)

Truncate(Single)

public static float Truncate(this float x)

Truncate(DVector2)

public static DVector2 Truncate(this DVector2 v)

Truncate(DVector3)

public static DVector3 Truncate(this DVector3 v)

Truncate(DVector4)

public static DVector4 Truncate(this DVector4 v)

Truncate(Vector2)

public static Vector2 Truncate(this Vector2 v)

Truncate(Vector3)

public static Vector3 Truncate(this Vector3 v)

Truncate(Vector4)

public static Vector4 Truncate(this Vector4 v)

Within(Double, Double, Double)

public static bool Within(this double v, double min, double max)

Within(Int32, Int32, Int32)

public static bool Within(this int v, int min, int max)

Within(Int64, Int64, Int64)

public static bool Within(this long v, long min, long max)

Within(Single, Single, Single)

public static bool Within(this float v, float min, float max)

WrapAngle(Single)

Reduces a given angle to a value between π and -π.

public static float WrapAngle(this float angle)

XOr(Boolean, Boolean)

public static bool XOr(this bool a, bool b)

XOr(Int32, Int32)

public static int XOr(this int a, int b)

XOr(Int64, Int64)

public static long XOr(this long a, long b)