Add more degree based units

UnitsNet.Tests/CustomCode/AngleTests.cs

@@ -34,6 +34,12 @@ public class AngleTests : AngleTestsBase
 
         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 MicroradiansInOneDegree => Math.PI/2/90*1E6;

UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs

@@ -42,8 +42,11 @@ public abstract partial class AngleTestsBase
         protected abstract double DeciradiansInOneDegree { get; }
         protected abstract double DegreesInOneDegree { get; }
         protected abstract double GradiansInOneDegree { get; }
+        protected abstract double MicrodegreesInOneDegree { get; }
         protected abstract double MicroradiansInOneDegree { get; }
+        protected abstract double MillidegreesInOneDegree { get; }
         protected abstract double MilliradiansInOneDegree { get; }
+        protected abstract double NanodegreesInOneDegree { get; }
         protected abstract double NanoradiansInOneDegree { get; }
         protected abstract double RadiansInOneDegree { get; }
 
@@ -54,8 +57,11 @@ public abstract partial class AngleTestsBase
         protected virtual double DeciradiansTolerance { get { return 1e-5; } }
         protected virtual double DegreesTolerance { get { return 1e-5; } }
         protected virtual double GradiansTolerance { get { return 1e-5; } }
+        protected virtual double MicrodegreesTolerance { get { return 1e-5; } }
         protected virtual double MicroradiansTolerance { get { return 1e-5; } }
+        protected virtual double MillidegreesTolerance { get { return 1e-5; } }
         protected virtual double MilliradiansTolerance { get { return 1e-5; } }
+        protected virtual double NanodegreesTolerance { get { return 1e-5; } }
         protected virtual double NanoradiansTolerance { get { return 1e-5; } }
         protected virtual double RadiansTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
@@ -70,8 +76,11 @@ public void DegreeToAngleUnits()
             Assert.AreEqual(DeciradiansInOneDegree, degree.Deciradians, DeciradiansTolerance);
             Assert.AreEqual(DegreesInOneDegree, degree.Degrees, DegreesTolerance);
             Assert.AreEqual(GradiansInOneDegree, degree.Gradians, GradiansTolerance);
+            Assert.AreEqual(MicrodegreesInOneDegree, degree.Microdegrees, MicrodegreesTolerance);
             Assert.AreEqual(MicroradiansInOneDegree, degree.Microradians, MicroradiansTolerance);
+            Assert.AreEqual(MillidegreesInOneDegree, degree.Millidegrees, MillidegreesTolerance);
             Assert.AreEqual(MilliradiansInOneDegree, degree.Milliradians, MilliradiansTolerance);
+            Assert.AreEqual(NanodegreesInOneDegree, degree.Nanodegrees, NanodegreesTolerance);
             Assert.AreEqual(NanoradiansInOneDegree, degree.Nanoradians, NanoradiansTolerance);
             Assert.AreEqual(RadiansInOneDegree, degree.Radians, RadiansTolerance);
         }
@@ -85,8 +94,11 @@ public void FromValueAndUnit()
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Deciradian).Deciradians, DeciradiansTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Degree).Degrees, DegreesTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Gradian).Gradians, GradiansTolerance);
+            Assert.AreEqual(1, Angle.From(1, AngleUnit.Microdegree).Microdegrees, MicrodegreesTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Microradian).Microradians, MicroradiansTolerance);
+            Assert.AreEqual(1, Angle.From(1, AngleUnit.Millidegree).Millidegrees, MillidegreesTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Milliradian).Milliradians, MilliradiansTolerance);
+            Assert.AreEqual(1, Angle.From(1, AngleUnit.Nanodegree).Nanodegrees, NanodegreesTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Nanoradian).Nanoradians, NanoradiansTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Radian).Radians, RadiansTolerance);
         }
@@ -101,8 +113,11 @@ public void As()
             Assert.AreEqual(DeciradiansInOneDegree, degree.As(AngleUnit.Deciradian), DeciradiansTolerance);
             Assert.AreEqual(DegreesInOneDegree, degree.As(AngleUnit.Degree), DegreesTolerance);
             Assert.AreEqual(GradiansInOneDegree, degree.As(AngleUnit.Gradian), GradiansTolerance);
+            Assert.AreEqual(MicrodegreesInOneDegree, degree.As(AngleUnit.Microdegree), MicrodegreesTolerance);
             Assert.AreEqual(MicroradiansInOneDegree, degree.As(AngleUnit.Microradian), MicroradiansTolerance);
+            Assert.AreEqual(MillidegreesInOneDegree, degree.As(AngleUnit.Millidegree), MillidegreesTolerance);
             Assert.AreEqual(MilliradiansInOneDegree, degree.As(AngleUnit.Milliradian), MilliradiansTolerance);
+            Assert.AreEqual(NanodegreesInOneDegree, degree.As(AngleUnit.Nanodegree), NanodegreesTolerance);
             Assert.AreEqual(NanoradiansInOneDegree, degree.As(AngleUnit.Nanoradian), NanoradiansTolerance);
             Assert.AreEqual(RadiansInOneDegree, degree.As(AngleUnit.Radian), RadiansTolerance);
         }
@@ -117,8 +132,11 @@ public void ConversionRoundTrip()
             Assert.AreEqual(1, Angle.FromDeciradians(degree.Deciradians).Degrees, DeciradiansTolerance);
             Assert.AreEqual(1, Angle.FromDegrees(degree.Degrees).Degrees, DegreesTolerance);
             Assert.AreEqual(1, Angle.FromGradians(degree.Gradians).Degrees, GradiansTolerance);
+            Assert.AreEqual(1, Angle.FromMicrodegrees(degree.Microdegrees).Degrees, MicrodegreesTolerance);
             Assert.AreEqual(1, Angle.FromMicroradians(degree.Microradians).Degrees, MicroradiansTolerance);
+            Assert.AreEqual(1, Angle.FromMillidegrees(degree.Millidegrees).Degrees, MillidegreesTolerance);
             Assert.AreEqual(1, Angle.FromMilliradians(degree.Milliradians).Degrees, MilliradiansTolerance);
+            Assert.AreEqual(1, Angle.FromNanodegrees(degree.Nanodegrees).Degrees, NanodegreesTolerance);
             Assert.AreEqual(1, Angle.FromNanoradians(degree.Nanoradians).Degrees, NanoradiansTolerance);
             Assert.AreEqual(1, Angle.FromRadians(degree.Radians).Degrees, RadiansTolerance);
         }

UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs

@@ -31,8 +31,11 @@ public enum AngleUnit
         Deciradian,
         Degree,
         Gradian,
+        Microdegree,
         Microradian,
+        Millidegree,
         Milliradian,
+        Nanodegree,
         Nanoradian,
         Radian,
     }

UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs

@@ -102,6 +102,14 @@ public double Gradians
             get { return _degrees/0.9; }
         }
 
+        /// <summary>
+        ///     Get Angle in Microdegrees.
+        /// </summary>
+        public double Microdegrees
+        {
+            get { return (_degrees) / 1e-6d; }
+        }
+
         /// <summary>
         ///     Get Angle in Microradians.
         /// </summary>
@@ -110,6 +118,14 @@ public double Microradians
             get { return (_degrees/180*Math.PI) / 1e-6d; }
         }
 
+        /// <summary>
+        ///     Get Angle in Millidegrees.
+        /// </summary>
+        public double Millidegrees
+        {
+            get { return (_degrees) / 1e-3d; }
+        }
+
         /// <summary>
         ///     Get Angle in Milliradians.
         /// </summary>
@@ -118,6 +134,14 @@ public double Milliradians
             get { return (_degrees/180*Math.PI) / 1e-3d; }
         }
 
+        /// <summary>
+        ///     Get Angle in Nanodegrees.
+        /// </summary>
+        public double Nanodegrees
+        {
+            get { return (_degrees) / 1e-9d; }
+        }
+
         /// <summary>
         ///     Get Angle in Nanoradians.
         /// </summary>
@@ -191,6 +215,14 @@ public static Angle FromGradians(double gradians)
             return new Angle(gradians*0.9);
         }
 
+        /// <summary>
+        ///     Get Angle from Microdegrees.
+        /// </summary>
+        public static Angle FromMicrodegrees(double microdegrees)
+        {
+            return new Angle((microdegrees) * 1e-6d);
+        }
+
         /// <summary>
         ///     Get Angle from Microradians.
         /// </summary>
@@ -199,6 +231,14 @@ public static Angle FromMicroradians(double microradians)
             return new Angle((microradians*180/Math.PI) * 1e-6d);
         }
 
+        /// <summary>
+        ///     Get Angle from Millidegrees.
+        /// </summary>
+        public static Angle FromMillidegrees(double millidegrees)
+        {
+            return new Angle((millidegrees) * 1e-3d);
+        }
+
         /// <summary>
         ///     Get Angle from Milliradians.
         /// </summary>
@@ -207,6 +247,14 @@ public static Angle FromMilliradians(double milliradians)
             return new Angle((milliradians*180/Math.PI) * 1e-3d);
         }
 
+        /// <summary>
+        ///     Get Angle from Nanodegrees.
+        /// </summary>
+        public static Angle FromNanodegrees(double nanodegrees)
+        {
+            return new Angle((nanodegrees) * 1e-9d);
+        }
+
         /// <summary>
         ///     Get Angle from Nanoradians.
         /// </summary>
@@ -246,10 +294,16 @@ public static Angle From(double value, AngleUnit fromUnit)
                     return FromDegrees(value);
                 case AngleUnit.Gradian:
                     return FromGradians(value);
+                case AngleUnit.Microdegree:
+                    return FromMicrodegrees(value);
                 case AngleUnit.Microradian:
                     return FromMicroradians(value);
+                case AngleUnit.Millidegree:
+                    return FromMillidegrees(value);
                 case AngleUnit.Milliradian:
                     return FromMilliradians(value);
+                case AngleUnit.Nanodegree:
+                    return FromNanodegrees(value);
                 case AngleUnit.Nanoradian:
                     return FromNanoradians(value);
                 case AngleUnit.Radian:
@@ -399,10 +453,16 @@ public double As(AngleUnit unit)
                     return Degrees;
                 case AngleUnit.Gradian:
                     return Gradians;
+                case AngleUnit.Microdegree:
+                    return Microdegrees;
                 case AngleUnit.Microradian:
                     return Microradians;
+                case AngleUnit.Millidegree:
+                    return Millidegrees;
                 case AngleUnit.Milliradian:
                     return Milliradians;
+                case AngleUnit.Nanodegree:
+                    return Nanodegrees;
                 case AngleUnit.Nanoradian:
                     return Nanoradians;
                 case AngleUnit.Radian:

UnitsNet/GeneratedCode/UnitSystem.Default.g.cs

@@ -129,18 +129,36 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                                 new AbbreviationsForCulture("en-US", "g"),
                                 new AbbreviationsForCulture("ru-RU", "g"),
                             }),
+                        new CulturesForEnumValue((int) AngleUnit.Microdegree,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "μ°"),
+                                new AbbreviationsForCulture("ru-RU", "μ°"),
+                            }),
                         new CulturesForEnumValue((int) AngleUnit.Microradian,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "μrad"),
                                 new AbbreviationsForCulture("ru-RU", "μрад"),
                             }),
+                        new CulturesForEnumValue((int) AngleUnit.Millidegree,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "m°"),
+                                new AbbreviationsForCulture("ru-RU", "m°"),
+                            }),
                         new CulturesForEnumValue((int) AngleUnit.Milliradian,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "mrad"),
                                 new AbbreviationsForCulture("ru-RU", "mрад"),
                             }),
+                        new CulturesForEnumValue((int) AngleUnit.Nanodegree,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "n°"),
+                                new AbbreviationsForCulture("ru-RU", "n°"),
+                            }),
                         new CulturesForEnumValue((int) AngleUnit.Nanoradian,
                             new[]
                             {

UnitsNet/Scripts/UnitDefinitions/Angle.json

@@ -23,6 +23,7 @@
     {
       "SingularName": "Degree",
       "PluralName": "Degrees",
+      "Prefixes": [ "Nano", "Micro", "Milli" ],
       "FromUnitToBaseFunc": "x",
       "FromBaseToUnitFunc": "x",
       "Localization": [