Merge pull request #406 from baxcoders/Angle

angularsen · web-flow · commit b2b9b1cc0270 · 2018-02-12T22:17:13.000+01:00
Added Revolution to Angle
diff --git a/UnitsNet.Tests/CustomCode/AngleTests.cs b/UnitsNet.Tests/CustomCode/AngleTests.cs
@@ -28,42 +28,44 @@ public class AngleTests : AngleTestsBase
     {
         protected override double DegreesInOneDegree => 1;
 
-        protected override double GradiansInOneDegree => 400/360.0;
+        protected override double GradiansInOneDegree => 400 / 360.0;
 
         protected override double ArcminutesInOneDegree => 60.0;
 
-        protected override double RadiansInOneDegree => Math.PI/2/90;
+        protected override double RadiansInOneDegree => Math.PI / 2 / 90;
 
         protected override double MillidegreesInOneDegree => 1E3;
 
         protected override double MicrodegreesInOneDegree => 1E6;
 
         protected override double NanodegreesInOneDegree => 1E9;
 
-        protected override double NanoradiansInOneDegree => Math.PI/2/90*1E9;
+        protected override double NanoradiansInOneDegree => Math.PI / 2 / 90 * 1E9;
 
-        protected override double MicroradiansInOneDegree => Math.PI/2/90*1E6;
+        protected override double MicroradiansInOneDegree => Math.PI / 2 / 90 * 1E6;
 
-        protected override double MilliradiansInOneDegree => Math.PI/2/90*1E3;
+        protected override double MilliradiansInOneDegree => Math.PI / 2 / 90 * 1E3;
 
-        protected override double CentiradiansInOneDegree => Math.PI/2/90*1E2;
+        protected override double CentiradiansInOneDegree => Math.PI / 2 / 90 * 1E2;
 
-        protected override double DeciradiansInOneDegree => Math.PI/2/90*1E1;
+        protected override double DeciradiansInOneDegree => Math.PI / 2 / 90 * 1E1;
 
         protected override double ArcsecondsInOneDegree => 3600.0;
 
+        protected override double RevolutionsInOneDegree => 2.77E-3;
+
         [Fact]
         public void AngleDividedByDurationEqualsRotationalSpeed()
         {
-            RotationalSpeed rotationalSpeed = Angle.FromRadians(10)/Duration.FromSeconds(5);
+            RotationalSpeed rotationalSpeed = Angle.FromRadians(10) / Duration.FromSeconds(5);
             Assert.Equal(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(2));
         }
 
         [Fact]
         public void AngleDividedByTimeSpanEqualsRotationalSpeed()
         {
-            RotationalSpeed rotationalSpeed = Angle.FromRadians(10)/TimeSpan.FromSeconds(5);
+            RotationalSpeed rotationalSpeed = Angle.FromRadians(10) / TimeSpan.FromSeconds(5);
             Assert.Equal(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(2));
         }
     }
-}
+}
diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs
@@ -65,6 +65,7 @@ public abstract partial class AngleTestsBase
         protected abstract double NanodegreesInOneDegree { get; }
         protected abstract double NanoradiansInOneDegree { get; }
         protected abstract double RadiansInOneDegree { get; }
+        protected abstract double RevolutionsInOneDegree { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
         protected virtual double ArcminutesTolerance { get { return 1e-5; } }
@@ -80,6 +81,7 @@ public abstract partial class AngleTestsBase
         protected virtual double NanodegreesTolerance { get { return 1e-5; } }
         protected virtual double NanoradiansTolerance { get { return 1e-5; } }
         protected virtual double RadiansTolerance { get { return 1e-5; } }
+        protected virtual double RevolutionsTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
         [Fact]
@@ -99,6 +101,7 @@ public void DegreeToAngleUnits()
             AssertEx.EqualTolerance(NanodegreesInOneDegree, degree.Nanodegrees, NanodegreesTolerance);
             AssertEx.EqualTolerance(NanoradiansInOneDegree, degree.Nanoradians, NanoradiansTolerance);
             AssertEx.EqualTolerance(RadiansInOneDegree, degree.Radians, RadiansTolerance);
+            AssertEx.EqualTolerance(RevolutionsInOneDegree, degree.Revolutions, RevolutionsTolerance);
         }
 
         [Fact]
@@ -117,6 +120,7 @@ public void FromValueAndUnit()
             AssertEx.EqualTolerance(1, Angle.From(1, AngleUnit.Nanodegree).Nanodegrees, NanodegreesTolerance);
             AssertEx.EqualTolerance(1, Angle.From(1, AngleUnit.Nanoradian).Nanoradians, NanoradiansTolerance);
             AssertEx.EqualTolerance(1, Angle.From(1, AngleUnit.Radian).Radians, RadiansTolerance);
+            AssertEx.EqualTolerance(1, Angle.From(1, AngleUnit.Revolution).Revolutions, RevolutionsTolerance);
         }
 
         [Fact]
@@ -136,6 +140,7 @@ public void As()
             AssertEx.EqualTolerance(NanodegreesInOneDegree, degree.As(AngleUnit.Nanodegree), NanodegreesTolerance);
             AssertEx.EqualTolerance(NanoradiansInOneDegree, degree.As(AngleUnit.Nanoradian), NanoradiansTolerance);
             AssertEx.EqualTolerance(RadiansInOneDegree, degree.As(AngleUnit.Radian), RadiansTolerance);
+            AssertEx.EqualTolerance(RevolutionsInOneDegree, degree.As(AngleUnit.Revolution), RevolutionsTolerance);
         }
 
         [Fact]
@@ -155,6 +160,7 @@ public void ConversionRoundTrip()
             AssertEx.EqualTolerance(1, Angle.FromNanodegrees(degree.Nanodegrees).Degrees, NanodegreesTolerance);
             AssertEx.EqualTolerance(1, Angle.FromNanoradians(degree.Nanoradians).Degrees, NanoradiansTolerance);
             AssertEx.EqualTolerance(1, Angle.FromRadians(degree.Radians).Degrees, RadiansTolerance);
+            AssertEx.EqualTolerance(1, Angle.FromRevolutions(degree.Revolutions).Degrees, RevolutionsTolerance);
         }
 
         [Fact]
diff --git a/UnitsNet/GeneratedCode/Extensions/Number/NumberToAngleExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/Number/NumberToAngleExtensions.g.cs
@@ -486,6 +486,40 @@ public static class NumberToAngleExtensions
 
         #endregion
 
+        #region Revolution
+
+        /// <inheritdoc cref="Angle.FromRevolutions(double)"/>
+        public static Angle Revolutions(this int value) => Angle.FromRevolutions(value);
+
+        /// <inheritdoc cref="Angle.FromRevolutions(double?)"/>
+        public static Angle? Revolutions(this int? value) => Angle.FromRevolutions(value);
+
+        /// <inheritdoc cref="Angle.FromRevolutions(double)"/>
+        public static Angle Revolutions(this long value) => Angle.FromRevolutions(value);
+
+        /// <inheritdoc cref="Angle.FromRevolutions(double?)"/>
+        public static Angle? Revolutions(this long? value) => Angle.FromRevolutions(value);
+
+        /// <inheritdoc cref="Angle.FromRevolutions(double)"/>
+        public static Angle Revolutions(this double value) => Angle.FromRevolutions(value);
+
+        /// <inheritdoc cref="Angle.FromRevolutions(double?)"/>
+        public static Angle? Revolutions(this double? value) => Angle.FromRevolutions(value);
+
+        /// <inheritdoc cref="Angle.FromRevolutions(double)"/>
+        public static Angle Revolutions(this float value) => Angle.FromRevolutions(value);
+
+        /// <inheritdoc cref="Angle.FromRevolutions(double?)"/>
+        public static Angle? Revolutions(this float? value) => Angle.FromRevolutions(value);
+
+        /// <inheritdoc cref="Angle.FromRevolutions(double)"/>
+        public static Angle Revolutions(this decimal value) => Angle.FromRevolutions(Convert.ToDouble(value));
+
+        /// <inheritdoc cref="Angle.FromRevolutions(double?)"/>
+        public static Angle? Revolutions(this decimal? value) => Angle.FromRevolutions(value == null ? (double?)null : Convert.ToDouble(value.Value));
+
+        #endregion
+
     }
 }
 #endif
diff --git a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
@@ -233,6 +233,14 @@ public double Radians
             get { return _degrees/180*Math.PI; }
         }
 
+        /// <summary>
+        ///     Get Angle in Revolutions.
+        /// </summary>
+        public double Revolutions
+        {
+            get { return _degrees/360; }
+        }
+
         #endregion
 
         #region Static
@@ -476,6 +484,24 @@ public static Angle FromRadians(QuantityValue radians)
         }
 #endif
 
+        /// <summary>
+        ///     Get Angle from Revolutions.
+        /// </summary>
+#if WINDOWS_UWP
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static Angle FromRevolutions(double revolutions)
+        {
+            double value = (double) revolutions;
+            return new Angle(value*360);
+        }
+#else
+        public static Angle FromRevolutions(QuantityValue revolutions)
+        {
+            double value = (double) revolutions;
+            return new Angle((value*360));
+        }
+#endif
+
         // Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx
 #if !WINDOWS_UWP
         /// <summary>
@@ -673,6 +699,21 @@ public static Angle FromRadians(QuantityValue radians)
             }
         }
 
+        /// <summary>
+        ///     Get nullable Angle from nullable Revolutions.
+        /// </summary>
+        public static Angle? FromRevolutions(QuantityValue? revolutions)
+        {
+            if (revolutions.HasValue)
+            {
+                return FromRevolutions(revolutions.Value);
+            }
+            else
+            {
+                return null;
+            }
+        }
+
 #endif
 
         /// <summary>
@@ -717,6 +758,8 @@ public static Angle From(QuantityValue value, AngleUnit fromUnit)
                     return FromNanoradians(value);
                 case AngleUnit.Radian:
                     return FromRadians(value);
+                case AngleUnit.Revolution:
+                    return FromRevolutions(value);
 
                 default:
                     throw new NotImplementedException("fromUnit: " + fromUnit);
@@ -765,6 +808,8 @@ public static Angle From(QuantityValue value, AngleUnit fromUnit)
                     return FromNanoradians(value.Value);
                 case AngleUnit.Radian:
                     return FromRadians(value.Value);
+                case AngleUnit.Revolution:
+                    return FromRevolutions(value.Value);
 
                 default:
                     throw new NotImplementedException("fromUnit: " + fromUnit);
@@ -964,6 +1009,8 @@ public double As(AngleUnit unit)
                     return Nanoradians;
                 case AngleUnit.Radian:
                     return Radians;
+                case AngleUnit.Revolution:
+                    return Revolutions;
 
                 default:
                     throw new NotImplementedException("unit: " + unit);
diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs
@@ -297,6 +297,12 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                                 new AbbreviationsForCulture("en-US", "rad"),
                                 new AbbreviationsForCulture("ru-RU", "рад"),
                             }),
+                        new CulturesForEnumValue((int) AngleUnit.Revolution,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "r"),
+                                new AbbreviationsForCulture("ru-RU", "r"),
+                            }),
                     }),
                 new UnitLocalization(typeof (ApparentEnergyUnit),
                     new[]
@@ -424,15 +430,6 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                                 new AbbreviationsForCulture("en-US", "kg/m²"),
                             }),
                     }),
-                new UnitLocalization(typeof (AreaDensityUnit),
-                    new[]
-                    {
-                        new CulturesForEnumValue((int) AreaDensityUnit.KilogramPerSquareMeter,
-                            new[]
-                            {
-                                new AbbreviationsForCulture("en-US", "kg/m²"),
-                            }),
-                    }),
                 new UnitLocalization(typeof (AreaMomentOfInertiaUnit),
                     new[]
                     {
diff --git a/UnitsNet/GeneratedCode/Units/AngleUnit.g.cs b/UnitsNet/GeneratedCode/Units/AngleUnit.g.cs
@@ -55,5 +55,6 @@ public enum AngleUnit
         Nanodegree,
         Nanoradian,
         Radian,
+        Revolution,
     }
 }
diff --git a/UnitsNet/UnitDefinitions/Angle.json b/UnitsNet/UnitDefinitions/Angle.json
@@ -76,6 +76,22 @@
           "Abbreviations": [ "g" ]
         }
       ]
+    },
+    {
+      "SingularName": "Revolution",
+      "PluralName": "Revolutions",
+      "FromUnitToBaseFunc": "x*360",
+      "FromBaseToUnitFunc": "x/360",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "r" ]
+        },
+        {
+          "Culture": "ru-RU",
+          "Abbreviations": [ "r" ]
+        }
+      ]
     }
   ]
 }

Original file line number	Diff line number	Diff line change
`@@ -55,5 +55,6 @@ public enum AngleUnit`
`55`	`55`	`Nanodegree,`
`56`	`56`	`Nanoradian,`
`57`	`57`	`Radian,`
	`58`	`+ Revolution,`
`58`	`59`	`}`
`59`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -76,6 +76,22 @@`
`76`	`76`	`"Abbreviations": [ "g" ]`
`77`	`77`	`}`
`78`	`78`	`]`
	`79`	`+ },`
	`80`	`+ {`
	`81`	`+ "SingularName": "Revolution",`
	`82`	`+ "PluralName": "Revolutions",`
	`83`	`+ "FromUnitToBaseFunc": "x*360",`
	`84`	`+ "FromBaseToUnitFunc": "x/360",`
	`85`	`+ "Localization": [`
	`86`	`+ {`
	`87`	`+ "Culture": "en-US",`
	`88`	`+ "Abbreviations": [ "r" ]`
	`89`	`+ },`
	`90`	`+ {`
	`91`	`+ "Culture": "ru-RU",`
	`92`	`+ "Abbreviations": [ "r" ]`
	`93`	`+ }`
	`94`	`+ ]`
`79`	`95`	`}`
`80`	`96`	`]`
`81`	`97`	`}`