Merge remote-tracking branch 'gpetrou/Angles'

Author: angularsen

Src/UnitsNet/Angle.cs

@@ -0,0 +1,164 @@
+using System;
+
+namespace UnitsNet
+{
+    public struct Angle : IComparable, IComparable<Angle>
+    {
+        private const double RadiansToDegreesRatio = Math.PI / 180.0;
+        private const double GradiansToDegreesRatio = 1 / 0.9;
+        
+        public readonly double Degrees;
+
+        public Angle(double degrees)
+        {
+            Degrees = degrees;
+        }
+
+        #region Unit Properties
+
+        public double Radians
+        {
+            get { return Degrees * RadiansToDegreesRatio; }
+        }
+
+        public double Gradians
+        {
+            get { return Degrees * GradiansToDegreesRatio; }
+        }
+        
+        #endregion
+
+        #region Static
+        
+        public static Angle Zero
+        {
+            get { return new Angle(0); }
+        }
+
+        public static Angle FromDegrees(double degrees)
+        {
+            return new Angle(degrees);
+        }
+
+        public static Angle FromRadians(double radians)
+        {
+            return new Angle(radians / RadiansToDegreesRatio);
+        }
+
+        public static Angle FromGradians(double gradians)
+        {
+            return new Angle(gradians / GradiansToDegreesRatio);
+        }
+        
+        #endregion
+
+        #region Arithmetic operators
+
+        public static Angle operator -(Angle right)
+        {
+            return FromDegrees(-right.Degrees);
+        }
+
+        public static Angle operator +(Angle left, Angle right)
+        {
+            return FromDegrees(left.Degrees + right.Degrees);
+        }
+
+        public static Angle operator -(Angle left, Angle right)
+        {
+            return FromDegrees(left.Degrees - right.Degrees);
+        }
+
+        public static Angle operator *(double left, Angle right)
+        {
+            return FromDegrees(left * right.Degrees);
+        }
+
+        public static Angle operator *(Angle left, double right)
+        {
+            return FromDegrees(left.Degrees * right);
+        }
+
+        public static Angle operator /(Angle left, double right)
+        {
+            return FromDegrees(left.Degrees / right);
+        }
+
+        public static double operator /(Angle left, Angle right)
+        {
+            return left.Degrees / right.Degrees;
+        }
+
+        #endregion
+
+        #region Comparable operators
+
+        public static bool operator <=(Angle left, Angle right)
+        {
+            return left.Degrees <= right.Degrees;
+        }
+
+        public static bool operator >=(Angle left, Angle right)
+        {
+            return left.Degrees >= right.Degrees;
+        }
+
+        public static bool operator <(Angle left, Angle right)
+        {
+            return left.Degrees < right.Degrees;
+        }
+
+        public static bool operator >(Angle left, Angle right)
+        {
+            return left.Degrees > right.Degrees;
+        }
+
+        public static bool operator ==(Angle left, Angle right)
+        {
+            return left.Degrees == right.Degrees;
+        }
+
+        public static bool operator !=(Angle left, Angle right)
+        {
+            return !(left.Degrees == right.Degrees);
+        }
+
+        #endregion
+
+        #region Equality / IComparable
+
+        public int CompareTo(object obj)
+        {
+            if (obj == null) throw new ArgumentNullException("obj");
+            if (!(obj is Angle)) throw new ArgumentException("Expected type Angle.", "obj");
+            return CompareTo((Angle)obj);
+        }
+
+        public int CompareTo(Angle other)
+        {
+            return Degrees.CompareTo(other.Degrees);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null || !(obj is Angle))
+            {
+                return false;
+            }
+
+            return Degrees.CompareTo(((Angle)obj).Degrees) == 0;
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        #endregion
+
+        public override string ToString()
+        {
+            return Degrees + " °";
+        }
+    }
+}

Src/UnitsNet/Unit.cs

@@ -103,6 +103,11 @@ public enum Unit
         SquareFoot,
         SquareInch,
 
+        // Angle
+        Degree,
+        Radian,
+        Gradian,
+
         // Volume
         CubicKilometer,
         CubicMeter,

Src/UnitsNet/UnitConverter.cs

@@ -44,6 +44,7 @@ public static double Convert(double value, Unit fromUnit, Unit toUnit)
             double newValue;
             if (TryConvertLength(value, fromUnit, toUnit, out newValue)) return newValue;
             if (TryConvertArea(value, fromUnit, toUnit, out newValue)) return newValue;
+            if (TryConvertAngle(value, fromUnit, toUnit, out newValue)) return newValue;
             if (TryConvertVolume(value, fromUnit, toUnit, out newValue)) return newValue;
             if (TryConvertMass(value, fromUnit, toUnit, out newValue)) return newValue;
             if (TryConvertPressure(value, fromUnit, toUnit, out newValue)) return newValue;
@@ -74,6 +75,8 @@ public static bool TryConvert(double value, Unit fromUnit, Unit toUnit, out doub
             }
 
             if (TryConvertLength(value, fromUnit, toUnit, out newValue)) return true;
+            if (TryConvertArea(value, fromUnit, toUnit, out newValue)) return true;
+            if (TryConvertAngle(value, fromUnit, toUnit, out newValue)) return true;
             if (TryConvertVolume(value, fromUnit, toUnit, out newValue)) return true;
             if (TryConvertMass(value, fromUnit, toUnit, out newValue)) return true;
             if (TryConvertPressure(value, fromUnit, toUnit, out newValue)) return true;
@@ -244,6 +247,22 @@ private static bool TryConvertArea(double value, Unit fromUnit, Unit toUnit, out
             }
         }
 
+        private static bool TryConvertAngle(double value, Unit fromUnit, Unit toUnit, out double newValue)
+        {
+            switch (fromUnit)
+            {
+                case Unit.Degree:
+                    return TryConvert(Angle.FromDegrees(value), toUnit, out newValue);
+                case Unit.Radian:
+                    return TryConvert(Angle.FromRadians(value), toUnit, out newValue);
+                case Unit.Gradian:
+                    return TryConvert(Angle.FromGradians(value), toUnit, out newValue);
+                default:
+                    newValue = 0;
+                    return false;
+            }
+        }
+
         private static bool TryConvertVolume(double value, Unit fromUnit, Unit toUnit, out double newValue)
         {
             switch (fromUnit)
@@ -415,6 +434,25 @@ private static bool TryConvert(Area volume, Unit toUnit, out double newValue)
             }
         }
 
+        private static bool TryConvert(Angle angle, Unit toUnit, out double newValue)
+        {
+            switch (toUnit)
+            {
+                case Unit.Degree:
+                    newValue = angle.Degrees;
+                    return true;
+                case Unit.Radian:
+                    newValue = angle.Radians;
+                    return true;
+                case Unit.Gradian:
+                    newValue = angle.Gradians;
+                    return true;
+                default:
+                    newValue = 0;
+                    return false;
+            }
+        }
+
         private static bool TryConvert(Volume volume, Unit toUnit, out double newValue)
         {
             switch (toUnit)

Src/UnitsNet/UnitsNet.net35.csproj

@@ -38,6 +38,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Angle.cs" />
     <Compile Include="Area.cs" />
     <Compile Include="ElectricPotential.cs" />
     <Compile Include="EnumUtils.cs" />

Src/UnitsNet/UnitsNet.pcl.csproj

@@ -35,6 +35,7 @@
     <!-- A reference to the entire .NET Framework is automatically included -->
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Angle.cs" />
     <Compile Include="Area.cs" />
     <Compile Include="ElectricPotential.cs" />
     <Compile Include="EnumUtils.cs" />

Src/UnitsNet/UnitsNet.sl4.csproj

@@ -56,6 +56,7 @@
     <Reference Include="System.Windows.Browser" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Angle.cs" />
     <Compile Include="Area.cs" />
     <Compile Include="EnumUtils.cs" />
     <Compile Include="Force.cs" />

Tests/AngleTest.cs

@@ -0,0 +1,117 @@
+using System;
+using NUnit.Framework;
+
+namespace UnitsNet.Tests.net35
+{
+    [TestFixture]
+    public class AngleTests
+    {
+        private const double Delta = 1E-5;
+        private readonly Angle _degrees90 = Angle.FromDegrees(90);
+
+        [Test]
+        public void DegreesToAngleUnits()
+        {
+            Assert.AreEqual(Math.PI / 2, _degrees90.Radians, Delta);
+            Assert.AreEqual(100, _degrees90.Gradians, Delta);
+        }
+
+        [Test]
+        public void AngleUnitsRoundTrip()
+        {
+            Assert.AreEqual(90, Angle.FromRadians(_degrees90.Radians).Degrees, Delta);
+            Assert.AreEqual(90, Angle.FromGradians(_degrees90.Gradians).Degrees, Delta);
+        }
+
+        [Test]
+        public void ArithmeticOperatorsRoundtrip()
+        {
+            Angle a = Angle.FromDegrees(90);
+            Assert.AreEqual(-90, -a.Degrees, Delta);
+            Assert.AreEqual(180, (Angle.FromDegrees(270)-a).Degrees, Delta);
+            Assert.AreEqual(180, (a + a).Degrees, Delta);
+            Assert.AreEqual(900, (a * 10).Degrees, Delta);
+            Assert.AreEqual(900, (10 * a).Degrees, Delta);
+            Assert.AreEqual(18.0, (Angle.FromDegrees(90) / 5).Degrees, Delta);
+            Assert.AreEqual(18.0, Angle.FromDegrees(90) / Angle.FromDegrees(5), Delta);
+        }
+
+        [Test]
+        public void ComparisonOperators()
+        {
+            Angle degrees90 = Angle.FromDegrees(90);
+            Angle degrees180 = Angle.FromDegrees(180);
+
+            Assert.True(degrees90 < degrees180);
+            Assert.True(degrees90 <= degrees180);
+            Assert.True(degrees180 > degrees90);
+            Assert.True(degrees180 >= degrees90);
+
+            Assert.False(degrees90 > degrees180);
+            Assert.False(degrees90 >= degrees180);
+            Assert.False(degrees180 < degrees90);
+            Assert.False(degrees180 <= degrees90);
+        }
+
+        [Test]
+        public void CompareToIsImplemented()
+        {
+            Angle degree = Angle.FromDegrees(1);
+            Assert.AreEqual(0, degree.CompareTo(degree));
+            Assert.Greater(degree.CompareTo(Angle.Zero), 0);
+            Assert.Less(Angle.Zero.CompareTo(degree), 0);
+        }
+
+        [Test]
+        [ExpectedException(typeof(ArgumentException))]
+        public void CompareToThrowsOnTypeMismatch()
+        {
+            Angle angle = Angle.FromDegrees(90);
+            angle.CompareTo(new object());
+        }
+
+        [Test]
+        [ExpectedException(typeof(ArgumentNullException))]
+        public void CompareToThrowsOnNull()
+        {
+            Angle angle = Angle.FromDegrees(90);
+            angle.CompareTo(null);
+        }
+
+
+        [Test]
+        public void EqualityOperators()
+        {
+            Angle a = Angle.FromDegrees(90);
+            Angle b = Angle.FromDegrees(180);
+
+            Assert.True(a == a); 
+            Assert.True(a != b);
+
+            Assert.False(a == b);
+            Assert.False(a != a);
+        }
+
+        [Test]
+        public void EqualsIsImplemented()
+        {
+            Angle a = Angle.FromDegrees(90);
+            Assert.IsTrue(a.Equals(Angle.FromDegrees(90)));
+            Assert.IsFalse(a.Equals(Angle.Zero));
+        }
+
+        [Test]
+        public void EqualsReturnsFalseOnTypeMismatch()
+        {
+            Angle angle = Angle.FromDegrees(0);
+            Assert.IsFalse(angle.Equals(new object()));
+        }
+
+        [Test]
+        public void EqualsReturnsFalseOnNull()
+        {
+            Angle angle = Angle.FromDegrees(0);
+            Assert.IsFalse(angle.Equals(null));
+        }
+    }
+}

Tests/UnitsNet.Tests.net35.csproj

@@ -44,6 +44,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AngleTest.cs" />
     <Compile Include="AreaTests.cs" />
     <Compile Include="VolumeTests.cs" />
     <Compile Include="Length2dTests.cs" />