Pascal Serrarens
8e87e4ea77
git-subtree-dir: NanoBrain git-subtree-split: b3423b99a752cdabbc4e7c51565fb54425481feb
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
|