841d923fed
672f8bf Spherical Average a278b7d Fix/Improve ToVector3 09d34d1 Prepare for spherical average b19e504 (A little) Performance improvements 2b0433f Fix normalizing direction 3e115cc Fix Direction.ToVector3 0eeedd2 Vector3 conversion fixes 3024562 Fix Unity warnings aa23d57 Fix roaming boid cdfe039 Improve Unity compatibility git-subtree-dir: Assets/NanoBrain/LinearAlgebra git-subtree-split: 672f8bfca1b1e0bc312df41142fa3c4447ce6dba
502 lines
21 KiB
C#
502 lines
21 KiB
C#
#if !UNITY_5_6_OR_NEWER
|
|
using System;
|
|
using System.Formats.Asn1;
|
|
using NUnit.Framework;
|
|
|
|
namespace LinearAlgebra.Test {
|
|
public class AngleTests {
|
|
[SetUp]
|
|
public void Setup() {
|
|
}
|
|
|
|
[Test]
|
|
public void Construct() {
|
|
// Degrees
|
|
float angle = 0.0f;
|
|
AngleFloat a = AngleFloat.Degrees(angle);
|
|
Assert.AreEqual(angle, a.inDegrees);
|
|
|
|
angle = -180.0f;
|
|
a = AngleFloat.Degrees(angle);
|
|
Assert.AreEqual(angle, a.inDegrees);
|
|
|
|
angle = 270.0f;
|
|
a = AngleFloat.Degrees(angle);
|
|
Assert.AreEqual(-90, a.inDegrees);
|
|
|
|
angle = -270.0f;
|
|
a = AngleFloat.Degrees(angle);
|
|
Assert.AreEqual(90, a.inDegrees);
|
|
|
|
// Radians
|
|
angle = 0.0f;
|
|
a = AngleFloat.Radians(angle);
|
|
Assert.AreEqual(angle, a.inRadians);
|
|
|
|
angle = (float)-Math.PI;
|
|
a = AngleFloat.Radians(angle);
|
|
Assert.AreEqual(angle, a.inRadians);
|
|
|
|
angle = (float)Math.PI * 1.5f;
|
|
a = AngleFloat.Radians(angle);
|
|
Assert.AreEqual(-Math.PI * 0.5f, a.inRadians, 1.0E-05F);
|
|
|
|
// Revolutions
|
|
angle = 0.0f;
|
|
a = AngleFloat.Revolutions(angle);
|
|
Assert.AreEqual(angle, a.inRevolutions);
|
|
|
|
angle = -0.5f;
|
|
a = AngleFloat.Revolutions(angle);
|
|
Assert.AreEqual(angle, a.inRevolutions);
|
|
|
|
angle = 0.75f;
|
|
a = AngleFloat.Revolutions(angle);
|
|
Assert.AreEqual(-0.25f, a.inRevolutions);
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void Revolutions() {
|
|
AngleFloat a;
|
|
|
|
// Test zero
|
|
a = AngleFloat.Revolutions(0.0f);
|
|
Assert.AreEqual(0.0f, a.inRevolutions);
|
|
|
|
// Test positive values within range
|
|
a = AngleFloat.Revolutions(0.25f);
|
|
Assert.AreEqual(0.25f, a.inRevolutions);
|
|
|
|
a = AngleFloat.Revolutions(0.5f);
|
|
Assert.AreEqual(-0.5f, a.inRevolutions);
|
|
|
|
// Test negative values within range
|
|
a = AngleFloat.Revolutions(-0.25f);
|
|
Assert.AreEqual(-0.25f, a.inRevolutions);
|
|
|
|
a = AngleFloat.Revolutions(-0.5f);
|
|
Assert.AreEqual(-0.5f, a.inRevolutions);
|
|
|
|
// Test values outside range (positive)
|
|
a = AngleFloat.Revolutions(1.0f);
|
|
Assert.AreEqual(0.0f, a.inRevolutions);
|
|
|
|
a = AngleFloat.Revolutions(1.25f);
|
|
Assert.AreEqual(0.25f, a.inRevolutions);
|
|
|
|
a = AngleFloat.Revolutions(1.75f);
|
|
Assert.AreEqual(-0.25f, a.inRevolutions);
|
|
|
|
// Test values outside range (negative)
|
|
a = AngleFloat.Revolutions(-1.0f);
|
|
Assert.AreEqual(0.0f, a.inRevolutions);
|
|
|
|
a = AngleFloat.Revolutions(-1.25f);
|
|
Assert.AreEqual(-0.25f, a.inRevolutions);
|
|
|
|
a = AngleFloat.Revolutions(-1.75f);
|
|
Assert.AreEqual(0.25f, a.inRevolutions);
|
|
|
|
// Test infinity
|
|
a = AngleFloat.Revolutions(float.PositiveInfinity);
|
|
Assert.AreEqual(float.PositiveInfinity, a.inRevolutions);
|
|
|
|
a = AngleFloat.Revolutions(float.NegativeInfinity);
|
|
Assert.AreEqual(float.NegativeInfinity, a.inRevolutions);
|
|
}
|
|
|
|
[Test]
|
|
public void Equality() {
|
|
// Test equality operator
|
|
Assert.IsTrue(AngleFloat.Degrees(90) == AngleFloat.Degrees(90), "90 == 90");
|
|
Assert.IsFalse(AngleFloat.Degrees(90) == AngleFloat.Degrees(45), "90 == 45");
|
|
Assert.IsTrue(AngleFloat.Degrees(0) == AngleFloat.Degrees(0), "0 == 0");
|
|
Assert.IsTrue(AngleFloat.Degrees(-180) == AngleFloat.Degrees(-180), "-180 == -180");
|
|
|
|
// Test inequality operator
|
|
Assert.IsTrue(AngleFloat.Degrees(90) != AngleFloat.Degrees(45), "90 != 45");
|
|
Assert.IsFalse(AngleFloat.Degrees(90) != AngleFloat.Degrees(90), "90 != 90");
|
|
Assert.IsTrue(AngleFloat.Degrees(0) != AngleFloat.Degrees(1), "0 != 1");
|
|
|
|
// Test greater than operator
|
|
Assert.IsTrue(AngleFloat.Degrees(90) > AngleFloat.Degrees(45), "90 > 45");
|
|
Assert.IsFalse(AngleFloat.Degrees(45) > AngleFloat.Degrees(90), "45 > 90");
|
|
Assert.IsFalse(AngleFloat.Degrees(90) > AngleFloat.Degrees(90), "90 > 90");
|
|
|
|
// Test greater than or equal operator
|
|
Assert.IsTrue(AngleFloat.Degrees(90) >= AngleFloat.Degrees(45), "90 >= 45");
|
|
Assert.IsTrue(AngleFloat.Degrees(90) >= AngleFloat.Degrees(90), "90 >= 90");
|
|
Assert.IsFalse(AngleFloat.Degrees(45) >= AngleFloat.Degrees(90), "45 >= 90");
|
|
|
|
// Test less than operator
|
|
Assert.IsTrue(AngleFloat.Degrees(45) < AngleFloat.Degrees(90), "45 < 90");
|
|
Assert.IsFalse(AngleFloat.Degrees(90) < AngleFloat.Degrees(45), "90 < 45");
|
|
Assert.IsFalse(AngleFloat.Degrees(90) < AngleFloat.Degrees(90), "90 < 90");
|
|
|
|
// Test less than or equal operator
|
|
Assert.IsTrue(AngleFloat.Degrees(45) <= AngleFloat.Degrees(90), "45 <= 90");
|
|
Assert.IsTrue(AngleFloat.Degrees(90) <= AngleFloat.Degrees(90), "90 <= 90");
|
|
Assert.IsFalse(AngleFloat.Degrees(90) <= AngleFloat.Degrees(45), "90 <= 45");
|
|
}
|
|
|
|
// [Test]
|
|
// public void Normalize() {
|
|
// float r = 0;
|
|
|
|
// r = Angle.Normalize(90);
|
|
// Assert.AreEqual(r, 90, "Normalize 90");
|
|
|
|
// r = Angle.Normalize(-90);
|
|
// Assert.AreEqual(r, -90, "Normalize -90");
|
|
|
|
// r = Angle.Normalize(270);
|
|
// Assert.AreEqual(r, -90, "Normalize 270");
|
|
|
|
// r = Angle.Normalize(270 + 360);
|
|
// Assert.AreEqual(r, -90, "Normalize 270+360");
|
|
|
|
// r = Angle.Normalize(-270);
|
|
// Assert.AreEqual(r, 90, "Normalize -270");
|
|
|
|
// r = Angle.Normalize(-270 - 360);
|
|
// Assert.AreEqual(r, 90, "Normalize -270-360");
|
|
|
|
// r = Angle.Normalize(0);
|
|
// Assert.AreEqual(r, 0, "Normalize 0");
|
|
|
|
// r = Angle.Normalize(float.PositiveInfinity);
|
|
// Assert.AreEqual(r, float.PositiveInfinity, "Normalize INFINITY");
|
|
|
|
// r = Angle.Normalize(float.NegativeInfinity);
|
|
// Assert.AreEqual(r, float.NegativeInfinity, "Normalize INFINITY");
|
|
// }
|
|
|
|
[Test]
|
|
public void Clamp() {
|
|
float r = 0;
|
|
|
|
r = AngleFloat.Clamp(AngleFloat.Degrees(1), AngleFloat.Degrees(0), AngleFloat.Degrees(2));
|
|
Assert.AreEqual(1, r, "Clamp 1 0 2");
|
|
|
|
r = AngleFloat.Clamp(AngleFloat.Degrees(-1), AngleFloat.Degrees(0), AngleFloat.Degrees(2));
|
|
Assert.AreEqual(0, r, "Clamp -1 0 2");
|
|
|
|
r = AngleFloat.Clamp(AngleFloat.Degrees(3), AngleFloat.Degrees(0), AngleFloat.Degrees(2));
|
|
Assert.AreEqual(2, r, "Clamp 3 0 2");
|
|
|
|
r = AngleFloat.Clamp(AngleFloat.Degrees(1), AngleFloat.Degrees(0), AngleFloat.Degrees(0));
|
|
Assert.AreEqual(0, r, "Clamp 1 0 0");
|
|
|
|
r = AngleFloat.Clamp(AngleFloat.Degrees(0), AngleFloat.Degrees(0), AngleFloat.Degrees(0));
|
|
Assert.AreEqual(0, r, "Clamp 0 0 0");
|
|
|
|
r = AngleFloat.Clamp(AngleFloat.Degrees(0), AngleFloat.Degrees(1), AngleFloat.Degrees(-1));
|
|
Assert.AreEqual(1, r, "Clamp 0 1 -1");
|
|
|
|
r = AngleFloat.Clamp(AngleFloat.Degrees(1), AngleFloat.Degrees(0), AngleFloat.Degrees(float.PositiveInfinity));
|
|
Assert.AreEqual(1, r, "Clamp 1 0 INFINITY");
|
|
|
|
r = AngleFloat.Clamp(AngleFloat.Degrees(1), AngleFloat.Degrees(float.NegativeInfinity), AngleFloat.Degrees(1));
|
|
Assert.AreEqual(1, r, "Clamp 1 -INFINITY 1");
|
|
}
|
|
|
|
[Test]
|
|
public void Cos() {
|
|
// Test zero
|
|
Assert.AreEqual(1.0f, AngleFloat.Cos(AngleFloat.Degrees(0)), 1.0E-05F, "Cos(0°)");
|
|
|
|
// Test 90 degrees
|
|
Assert.AreEqual(0.0f, AngleFloat.Cos(AngleFloat.Degrees(90)), 1.0E-05F, "Cos(90°)");
|
|
|
|
// Test 180 degrees
|
|
Assert.AreEqual(-1.0f, AngleFloat.Cos(AngleFloat.Degrees(180)), 1.0E-05F, "Cos(180°)");
|
|
|
|
// Test 270 degrees
|
|
Assert.AreEqual(0.0f, AngleFloat.Cos(AngleFloat.Degrees(270)), 1.0E-05F, "Cos(270°)");
|
|
|
|
// Test 45 degrees
|
|
Assert.AreEqual(MathF.Sqrt(2) / 2, AngleFloat.Cos(AngleFloat.Degrees(45)), 1.0E-05F, "Cos(45°)");
|
|
|
|
// Test negative angle
|
|
Assert.AreEqual(1.0f, AngleFloat.Cos(AngleFloat.Degrees(-360)), 1.0E-05F, "Cos(-360°)");
|
|
|
|
// Test using radians
|
|
Assert.AreEqual(1.0f, AngleFloat.Cos(AngleFloat.Radians(0)), 1.0E-05F, "Cos(0 rad)");
|
|
Assert.AreEqual(0.0f, AngleFloat.Cos(AngleFloat.Radians((float)Math.PI / 2)), 1.0E-05F, "Cos(π/2)");
|
|
Assert.AreEqual(-1.0f, AngleFloat.Cos(AngleFloat.Radians((float)Math.PI)), 1.0E-05F, "Cos(π)");
|
|
}
|
|
|
|
[Test]
|
|
public void Sin() {
|
|
// Test zero
|
|
Assert.AreEqual(0.0f, AngleFloat.Sin(AngleFloat.Degrees(0)), 1.0E-05F, "Sin(0°)");
|
|
|
|
// Test 90 degrees
|
|
Assert.AreEqual(1.0f, AngleFloat.Sin(AngleFloat.Degrees(90)), 1.0E-05F, "Sin(90°)");
|
|
|
|
// Test 180 degrees
|
|
Assert.AreEqual(0.0f, AngleFloat.Sin(AngleFloat.Degrees(180)), 1.0E-05F, "Sin(180°)");
|
|
|
|
// Test 270 degrees
|
|
Assert.AreEqual(-1.0f, AngleFloat.Sin(AngleFloat.Degrees(270)), 1.0E-05F, "Sin(270°)");
|
|
|
|
// Test 45 degrees
|
|
Assert.AreEqual(MathF.Sqrt(2) / 2, AngleFloat.Sin(AngleFloat.Degrees(45)), 1.0E-05F, "Sin(45°)");
|
|
|
|
// Test negative angle
|
|
Assert.AreEqual(0.0f, AngleFloat.Sin(AngleFloat.Degrees(-360)), 1.0E-05F, "Sin(-360°)");
|
|
|
|
// Test using radians
|
|
Assert.AreEqual(0.0f, AngleFloat.Sin(AngleFloat.Radians(0)), 1.0E-05F, "Sin(0 rad)");
|
|
Assert.AreEqual(1.0f, AngleFloat.Sin(AngleFloat.Radians((float)Math.PI / 2)), 1.0E-05F, "Sin(π/2)");
|
|
Assert.AreEqual(0.0f, AngleFloat.Sin(AngleFloat.Radians((float)Math.PI)), 1.0E-05F, "Sin(π)");
|
|
}
|
|
|
|
[Test]
|
|
public void Tan() {
|
|
// Test zero
|
|
Assert.AreEqual(0.0f, AngleFloat.Tan(AngleFloat.Degrees(0)), 1.0E-05F, "Tan(0°)");
|
|
|
|
// Test 45 degrees
|
|
Assert.AreEqual(1.0f, AngleFloat.Tan(AngleFloat.Degrees(45)), 1.0E-05F, "Tan(45°)");
|
|
|
|
// Test -45 degrees
|
|
Assert.AreEqual(-1.0f, AngleFloat.Tan(AngleFloat.Degrees(-45)), 1.0E-05F, "Tan(-45°)");
|
|
|
|
// Test using radians
|
|
Assert.AreEqual(0.0f, AngleFloat.Tan(AngleFloat.Radians(0)), 1.0E-05F, "Tan(0 rad)");
|
|
Assert.AreEqual(1.0f, AngleFloat.Tan(AngleFloat.Radians((float)Math.PI / 4)), 1.0E-05F, "Tan(π/4)");
|
|
}
|
|
|
|
[Test]
|
|
public void Acos() {
|
|
// Test 1 (0 degrees)
|
|
Assert.AreEqual(0.0f, AngleFloat.Acos(1.0f).inRadians, 1.0E-05F, "Acos(1)");
|
|
|
|
// Test 0 (90 degrees or π/2 radians)
|
|
Assert.AreEqual((float)Math.PI / 2, AngleFloat.Acos(0.0f).inRadians, 1.0E-05F, "Acos(0)");
|
|
|
|
// Test -1 (-180 degrees or π radians)
|
|
Assert.AreEqual((float)-Math.PI, AngleFloat.Acos(-1.0f).inRadians, 1.0E-05F, "Acos(-1)");
|
|
|
|
// Test 0.5 (60 degrees or π/3 radians)
|
|
Assert.AreEqual((float)Math.PI / 3, AngleFloat.Acos(0.5f).inRadians, 1.0E-05F, "Acos(0.5)");
|
|
|
|
// Test sqrt(2)/2 (45 degrees or π/4 radians)
|
|
Assert.AreEqual((float)Math.PI / 4, AngleFloat.Acos(MathF.Sqrt(2) / 2).inRadians, 1.0E-05F, "Acos(√2/2)");
|
|
}
|
|
|
|
[Test]
|
|
public void Asin() {
|
|
// Test 0 (0 degrees)
|
|
Assert.AreEqual(0.0f, AngleFloat.Asin(0.0f).inRadians, 1.0E-05F, "Asin(0)");
|
|
|
|
// Test 1 (90 degrees or π/2 radians)
|
|
Assert.AreEqual((float)Math.PI / 2, AngleFloat.Asin(1.0f).inRadians, 1.0E-05F, "Asin(1)");
|
|
|
|
// Test -1 (-90 degrees or -π/2 radians)
|
|
Assert.AreEqual(-(float)Math.PI / 2, AngleFloat.Asin(-1.0f).inRadians, 1.0E-05F, "Asin(-1)");
|
|
|
|
// Test 0.5 (30 degrees or π/6 radians)
|
|
Assert.AreEqual((float)Math.PI / 6, AngleFloat.Asin(0.5f).inRadians, 1.0E-05F, "Asin(0.5)");
|
|
|
|
// Test sqrt(2)/2 (45 degrees or π/4 radians)
|
|
Assert.AreEqual((float)Math.PI / 4, AngleFloat.Asin(MathF.Sqrt(2) / 2).inRadians, 1.0E-05F, "Asin(√2/2)");
|
|
}
|
|
|
|
|
|
[Test]
|
|
public void Atan() {
|
|
// Test zero
|
|
Assert.AreEqual(0.0f, AngleFloat.Atan(0.0f).inRadians, 1.0E-05F, "Atan(0)");
|
|
|
|
// Test 1 (45 degrees or π/4 radians)
|
|
Assert.AreEqual((float)Math.PI / 4, AngleFloat.Atan(1.0f).inRadians, 1.0E-05F, "Atan(1)");
|
|
|
|
// Test -1 (-45 degrees or -π/4 radians)
|
|
Assert.AreEqual(-(float)Math.PI / 4, AngleFloat.Atan(-1.0f).inRadians, 1.0E-05F, "Atan(-1)");
|
|
|
|
// Test sqrt(3) (60 degrees or π/3 radians)
|
|
Assert.AreEqual((float)Math.PI / 3, AngleFloat.Atan(MathF.Sqrt(3)).inRadians, 1.0E-05F, "Atan(√3)");
|
|
|
|
// Test 1/sqrt(3) (30 degrees or π/6 radians)
|
|
Assert.AreEqual((float)Math.PI / 6, AngleFloat.Atan(1.0f / MathF.Sqrt(3)).inRadians, 1.0E-05F, "Atan(1/√3)");
|
|
|
|
// Test positive infinity
|
|
Assert.AreEqual((float)Math.PI / 2, AngleFloat.Atan(float.PositiveInfinity).inRadians, 1.0E-05F, "Atan(+∞)");
|
|
|
|
// Test negative infinity
|
|
Assert.AreEqual(-(float)Math.PI / 2, AngleFloat.Atan(float.NegativeInfinity).inRadians, 1.0E-05F, "Atan(-∞)");
|
|
}
|
|
|
|
[Test]
|
|
public void Atan2() {
|
|
// Test basic quadrant I
|
|
Assert.AreEqual((float)Math.PI / 4, AngleFloat.Atan2(1.0f, 1.0f).inRadians, 1.0E-05F, "Atan2(1, 1)");
|
|
|
|
// Test quadrant II
|
|
Assert.AreEqual(3 * (float)Math.PI / 4, AngleFloat.Atan2(1.0f, -1.0f).inRadians, 1.0E-05F, "Atan2(1, -1)");
|
|
|
|
// Test quadrant III
|
|
Assert.AreEqual(-(float)Math.PI * 0.75f, AngleFloat.Atan2(-1.0f, -1.0f).inRadians, 1.0E-05F, "Atan2(-1, -1)");
|
|
|
|
// Test quadrant IV
|
|
Assert.AreEqual(-(float)Math.PI / 4, AngleFloat.Atan2(-1.0f, 1.0f).inRadians, 1.0E-05F, "Atan2(-1, 1)");
|
|
|
|
// Test positive x-axis
|
|
Assert.AreEqual(0.0f, AngleFloat.Atan2(0.0f, 1.0f).inRadians, 1.0E-05F, "Atan2(0, 1)");
|
|
|
|
// Test positive y-axis
|
|
Assert.AreEqual((float)Math.PI / 2, AngleFloat.Atan2(1.0f, 0.0f).inRadians, 1.0E-05F, "Atan2(1, 0)");
|
|
|
|
// Test negative y-axis
|
|
Assert.AreEqual(-(float)Math.PI / 2, AngleFloat.Atan2(-1.0f, 0.0f).inRadians, 1.0E-05F, "Atan2(-1, 0)");
|
|
|
|
// Test origin
|
|
Assert.AreEqual(0.0f, AngleFloat.Atan2(0.0f, 0.0f).inRadians, 1.0E-05F, "Atan2(0, 0)");
|
|
|
|
// Test with different magnitudes
|
|
Assert.AreEqual((float)Math.PI / 3, AngleFloat.Atan2(MathF.Sqrt(3), 1.0f).inRadians, 1.0E-05F, "Atan2(√3, 1)");
|
|
|
|
// Test negative x-axis
|
|
Assert.AreEqual((float)-Math.PI, AngleFloat.Atan2(0.0f, -1.0f).inRadians, 1.0E-05F, "Atan2(0, -1)");
|
|
}
|
|
|
|
[Test]
|
|
public void Multiplication() {
|
|
AngleFloat r = AngleFloat.zero;
|
|
|
|
// Angle * float
|
|
r = AngleFloat.Degrees(90) * 2;
|
|
Assert.AreEqual(-180, r.inDegrees, "Multiply 90 * 2");
|
|
|
|
r = AngleFloat.Degrees(45) * 0.5f;
|
|
Assert.AreEqual(22.5f, r.inDegrees, "Multiply 45 * 0.5");
|
|
|
|
r = AngleFloat.Degrees(90) * 0;
|
|
Assert.AreEqual(0, r.inDegrees, "Multiply 90 * 0");
|
|
|
|
r = AngleFloat.Degrees(-90) * 2;
|
|
Assert.AreEqual(-180, r.inDegrees, "Multiply -90 * 2");
|
|
|
|
r = AngleFloat.Degrees(270) * 2;
|
|
Assert.AreEqual(-180, r.inDegrees, "Multiply 270 * 2 (normalized)");
|
|
|
|
// float * Angle
|
|
r = 2 * AngleFloat.Degrees(90);
|
|
Assert.AreEqual(-180, r.inDegrees, "Multiply 2 * 90");
|
|
|
|
r = 0.5f * AngleFloat.Degrees(45);
|
|
Assert.AreEqual(22.5, r.inDegrees, "Multiply 0.5 * 45");
|
|
|
|
r = 0 * AngleFloat.Degrees(90);
|
|
Assert.AreEqual(0, r.inDegrees, "Multiply 0 * 90");
|
|
|
|
r = 2 * AngleFloat.Degrees(-90);
|
|
Assert.AreEqual(-180, r.inDegrees, "Multiply 2 * -90");
|
|
|
|
// Negative factor
|
|
r = AngleFloat.Degrees(90) * -1;
|
|
Assert.AreEqual(-90, r.inDegrees, "Multiply 90 * -1");
|
|
|
|
r = -1 * AngleFloat.Degrees(90);
|
|
Assert.AreEqual(-90, r.inDegrees, "Multiply -1 * 90");
|
|
}
|
|
|
|
[Test]
|
|
public void MoveTowards() {
|
|
AngleFloat r = AngleFloat.zero;
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(90), 30);
|
|
Assert.AreEqual(30, r.inDegrees, "MoveTowards 0 90 30");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(90), 90);
|
|
Assert.AreEqual(90, r.inDegrees, "MoveTowards 0 90 90");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(90), 180);
|
|
Assert.AreEqual(90, r.inDegrees, "MoveTowards 0 90 180");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(90), 270);
|
|
Assert.AreEqual(90, r.inDegrees, "MoveTowrads 0 90 270");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(90), -30);
|
|
Assert.AreEqual(0, r.inDegrees, "MoveTowards 0 90 -30");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(-90), -30);
|
|
Assert.AreEqual(0, r.inDegrees, "MoveTowards 0 -90 -30");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(-90), -90);
|
|
Assert.AreEqual(0, r.inDegrees, "MoveTowards 0 -90 -90");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(-90), -180);
|
|
Assert.AreEqual(0, r.inDegrees, "MoveTowards 0 -90 -180");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(-90), -270);
|
|
Assert.AreEqual(0, r.inDegrees, "MoveTowrads 0 -90 -270");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(90), 0);
|
|
Assert.AreEqual(0, r.inDegrees, "MoveTowards 0 90 0");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(0), 0);
|
|
Assert.AreEqual(0, r.inDegrees, "MoveTowards 0 0 0");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(0), 30);
|
|
Assert.AreEqual(0, r.inDegrees, "MoveTowrads 0 0 30");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(90), float.PositiveInfinity);
|
|
Assert.AreEqual(90, r.inDegrees, "MoveTowards 0 90 INFINITY");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(float.PositiveInfinity), 30);
|
|
Assert.AreEqual(30, r.inDegrees, "MoveTowrads 0 INFINITY 30");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(-90), float.NegativeInfinity);
|
|
Assert.AreEqual(0, r.inDegrees, "MoveTowards 0 -90 -INFINITY");
|
|
|
|
r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(float.NegativeInfinity), -30);
|
|
Assert.AreEqual(0, r.inDegrees, "MoveTowrads 0 -INFINITY -30");
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void Difference() {
|
|
float r = 0;
|
|
|
|
r = Angles.Difference(0, 90);
|
|
Assert.AreEqual(90, r, "Difference 0 90");
|
|
|
|
r = Angles.Difference(0, -90);
|
|
Assert.AreEqual(-90, r, "Difference 0 -90");
|
|
|
|
r = Angles.Difference(0, 270);
|
|
Assert.AreEqual(-90, r, "Difference 0 270");
|
|
|
|
r = Angles.Difference(0, -270);
|
|
Assert.AreEqual(90, r, "Difference 0 -270");
|
|
|
|
r = Angles.Difference(90, 0);
|
|
Assert.AreEqual(-90, r, "Difference 90 0");
|
|
|
|
r = Angles.Difference(-90, 0);
|
|
Assert.AreEqual(90, r, "Difference -90 0");
|
|
|
|
r = Angles.Difference(0, 0);
|
|
Assert.AreEqual(0, r, "Difference 0 0");
|
|
|
|
r = Angles.Difference(90, 90);
|
|
Assert.AreEqual(0, r, "Difference 90 90");
|
|
|
|
r = Angles.Difference(0, float.PositiveInfinity);
|
|
Assert.AreEqual(float.PositiveInfinity, r, "Difference 0 INFINITY");
|
|
|
|
r = Angles.Difference(0, float.NegativeInfinity);
|
|
Assert.AreEqual(float.NegativeInfinity, r, "Difference 0 -INFINITY");
|
|
|
|
r = Angles.Difference(float.NegativeInfinity, float.PositiveInfinity);
|
|
Assert.AreEqual(float.PositiveInfinity, r, "Difference -INFINITY INFINITY");
|
|
}
|
|
}
|
|
|
|
}
|
|
#endif
|