Merge branch 'master' into feature/operator-overloading

Conflicts:
	UnitsNet.Tests/CustomCode/AngleTests.cs
	UnitsNet.Tests/CustomCode/MassFlowTests.cs
	UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs

Author: Erik Ovegard

.vs/config/applicationhost.config

@@ -123,6 +123,8 @@ Serialization
 **Important!** 
 We cannot guarantee backwards compatibility, although we will strive to do that on a "best effort" basis and bumping the major nuget version when a change is necessary.
 
+The base unit of any unit should be be treated as volatile as we have changed this several times in the history of this library already. Either to reduce precision errors of common units or to simplify code generation. An example is Mass, where the base unit was first Kilogram as this is the SI unit of mass, but in order to use powershell scripts to generate milligrams, nanograms etc. it was easier to choose Gram as the base unit of Mass.
+
 What It Is Not
 ===
 * It is not an equation solver

README.md

@@ -63,6 +63,31 @@ protected override double RadiansInOneDegree
             get { return Math.PI / 2 / 90; }
         }
 
+        protected override double NanoradiansInOneDegree
+        {
+            get { return (Math.PI / 2 / 90) * 1E9; }
+        }
+
+        protected override double MicroradiansInOneDegree
+        {
+            get { return (Math.PI / 2 / 90) * 1E6; }
+        }
+
+        protected override double MilliradiansInOneDegree
+        {
+            get { return (Math.PI / 2 / 90) * 1E3; }
+        }
+
+        protected override double CentiradiansInOneDegree
+        {
+            get { return (Math.PI / 2 / 90) * 1E2; }
+        }
+
+        protected override double DeciradiansInOneDegree
+        {
+            get { return (Math.PI / 2 / 90) * 1E1; }
+        }
+
         protected override double ArcsecondsInOneDegree
         {
             get

UnitsNet.Tests/CustomCode/AngleTests.cs

@@ -0,0 +1,35 @@
+// Copyright © 2007 by Initial Force AS.  All rights reserved.
+// https://github.com/InitialForce/UnitsNet
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+
+using System;
+
+namespace UnitsNet.Tests.CustomCode
+{
+    public class ForceChangeRateTests : ForceChangeRateTestsBase
+    {
+        // TODO Override properties in base class here
+        protected override double NewtonsPerSecondInOneNewtonPerSecond
+        {
+            get { return 1; }
+        }
+    }
+}

UnitsNet.Tests/CustomCode/ForceChangeRateTests.cs

@@ -53,19 +53,56 @@ public void DurationTimesMassFlowEqualsMass()
             Assert.AreEqual(mass, Mass.FromKilograms(80.0));
         }
 
-        protected override double KilogramsPerSecondInOneKilogramPerSecond
+        protected override double GramsPerSecondInOneGramPerSecond
         {
-            get
+            get { return 1; }
+        }
+
+        protected override double DecagramsPerSecondInOneGramPerSecond
             {
-                return 1.0;
+            get { return 1E-1; }
             }
+
+        protected override double HectogramsPerSecondInOneGramPerSecond
+        {
+            get { return 1E-2; }
+        }
+
+        protected override double KilogramsPerSecondInOneGramPerSecond
+        {
+            get { return 1E-3; }
+        }
+
+        protected override double DecigramsPerSecondInOneGramPerSecond
+        {
+            get { return 1E1; }
+        }
+
+        protected override double CentigramsPerSecondInOneGramPerSecond
+        {
+            get { return 1E2; }
+        }
+
+        protected override double MilligramsPerSecondInOneGramPerSecond
+        {
+            get { return 1E3; }
+        }
+
+        protected override double MicrogramsPerSecondInOneGramPerSecond
+        {
+            get { return 1E6; }
+        }
+
+        protected override double NanogramsPerSecondInOneGramPerSecond
+        {
+            get { return 1E9; }
         }
 
-        protected override double TonnesPerDayInOneKilogramPerSecond
+        protected override double TonnesPerDayInOneGramPerSecond
         {
             get
             {
-                return (60.0 * 60 * 24 / 1000);
+                return (60.0 * 60 * 24 / 1E6);
             }
         }
     }

UnitsNet.Tests/CustomCode/MassFlowTests.cs

@@ -69,22 +69,44 @@ public void ForceTimesRotationalSpeedEqualsPower()
             Assert.AreEqual(power, Power.FromWatts(20.0));
         }
 
-        protected override double RadiansPerSecondInOneRevolutionPerSecond
+        protected override double RadiansPerSecondInOneRadianPerSecond
         {
-            get
+            get { return 1; }
+        }
+
+        protected override double DeciradiansPerSecondInOneRadianPerSecond
             {
-                return 2 * Math.PI;
+            get { return 1E1; }
             }
+
+        protected override double CentiradiansPerSecondInOneRadianPerSecond
+        {
+            get { return 1E2; }
         }
 
-        protected override double RevolutionsPerMinuteInOneRevolutionPerSecond
+        protected override double MilliradiansPerSecondInOneRadianPerSecond
         {
-            get { return 1.0*60; }
+            get { return 1E3; }
         }
 
-        protected override double RevolutionsPerSecondInOneRevolutionPerSecond
+        protected override double MicroradiansPerSecondInOneRadianPerSecond
         {
-            get { return 1; }
+            get { return 1E6; }
+        }
+
+        protected override double NanoradiansPerSecondInOneRadianPerSecond
+        {
+            get { return 1E9; }
+    }
+
+        protected override double RevolutionsPerMinuteInOneRadianPerSecond
+        {
+            get { return (60*1) / (2 * Math.PI); }
+        }
+
+        protected override double RevolutionsPerSecondInOneRadianPerSecond
+        {
+            get { return 1/(2*Math.PI); }
         }
     }
 }

UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs

@@ -0,0 +1,74 @@
+// Copyright © 2007 by Initial Force AS.  All rights reserved.
+// https://github.com/InitialForce/UnitsNet
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+
+using System;
+
+namespace UnitsNet.Tests.CustomCode
+{
+    public class TemperatureChangeRateTests : TemperatureChangeRateTestsBase
+    {
+        protected override double DegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond
+        {
+            get { return 1; }
+        }
+
+        protected override double DecadegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond
+        {
+            get { return 1E-1; }
+        }
+
+        protected override double HectodegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond
+        {
+            get { return 1E-2; }
+        }
+
+        protected override double KilodegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond
+        {
+            get { return 1E-3; }
+        }
+
+        protected override double DecidegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond
+        {
+            get { return 1E1; }
+        }
+
+        protected override double CentidegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond
+        {
+            get { return 1E2; }
+        }
+
+        protected override double MillidegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond
+        {
+            get { return 1E3; }
+        }
+
+        protected override double MicrodegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond
+        {
+            get { return 1E6; }
+        }
+
+        protected override double NanodegreesCelsiusPerSecondInOneDegreeCelsiusPerSecond
+        {
+            get { return 1E9; }
+        }
+    }
+}

UnitsNet.Tests/CustomCode/TemperatureChangeRateTests.cs

@@ -38,15 +38,25 @@ public abstract partial class AngleTestsBase
     {
         protected abstract double ArcminutesInOneDegree { get; }
         protected abstract double ArcsecondsInOneDegree { get; }
+        protected abstract double CentiradiansInOneDegree { get; }
+        protected abstract double DeciradiansInOneDegree { get; }
         protected abstract double DegreesInOneDegree { get; }
         protected abstract double GradiansInOneDegree { get; }
+        protected abstract double MicroradiansInOneDegree { get; }
+        protected abstract double MilliradiansInOneDegree { get; }
+        protected abstract double NanoradiansInOneDegree { get; }
         protected abstract double RadiansInOneDegree { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
         protected virtual double ArcminutesTolerance { get { return 1e-5; } }
         protected virtual double ArcsecondsTolerance { get { return 1e-5; } }
+        protected virtual double CentiradiansTolerance { get { return 1e-5; } }
+        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 MicroradiansTolerance { get { return 1e-5; } }
+        protected virtual double MilliradiansTolerance { get { return 1e-5; } }
+        protected virtual double NanoradiansTolerance { get { return 1e-5; } }
         protected virtual double RadiansTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
@@ -56,8 +66,13 @@ public void DegreeToAngleUnits()
             Angle degree = Angle.FromDegrees(1);
             Assert.AreEqual(ArcminutesInOneDegree, degree.Arcminutes, ArcminutesTolerance);
             Assert.AreEqual(ArcsecondsInOneDegree, degree.Arcseconds, ArcsecondsTolerance);
+            Assert.AreEqual(CentiradiansInOneDegree, degree.Centiradians, CentiradiansTolerance);
+            Assert.AreEqual(DeciradiansInOneDegree, degree.Deciradians, DeciradiansTolerance);
             Assert.AreEqual(DegreesInOneDegree, degree.Degrees, DegreesTolerance);
             Assert.AreEqual(GradiansInOneDegree, degree.Gradians, GradiansTolerance);
+            Assert.AreEqual(MicroradiansInOneDegree, degree.Microradians, MicroradiansTolerance);
+            Assert.AreEqual(MilliradiansInOneDegree, degree.Milliradians, MilliradiansTolerance);
+            Assert.AreEqual(NanoradiansInOneDegree, degree.Nanoradians, NanoradiansTolerance);
             Assert.AreEqual(RadiansInOneDegree, degree.Radians, RadiansTolerance);
         }
 
@@ -66,8 +81,13 @@ public void FromValueAndUnit()
         {
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Arcminute).Arcminutes, ArcminutesTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Arcsecond).Arcseconds, ArcsecondsTolerance);
+            Assert.AreEqual(1, Angle.From(1, AngleUnit.Centiradian).Centiradians, CentiradiansTolerance);
+            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.Microradian).Microradians, MicroradiansTolerance);
+            Assert.AreEqual(1, Angle.From(1, AngleUnit.Milliradian).Milliradians, MilliradiansTolerance);
+            Assert.AreEqual(1, Angle.From(1, AngleUnit.Nanoradian).Nanoradians, NanoradiansTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Radian).Radians, RadiansTolerance);
         }
 
@@ -77,8 +97,13 @@ public void As()
             var degree = Angle.FromDegrees(1);
             Assert.AreEqual(ArcminutesInOneDegree, degree.As(AngleUnit.Arcminute), ArcminutesTolerance);
             Assert.AreEqual(ArcsecondsInOneDegree, degree.As(AngleUnit.Arcsecond), ArcsecondsTolerance);
+            Assert.AreEqual(CentiradiansInOneDegree, degree.As(AngleUnit.Centiradian), CentiradiansTolerance);
+            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(MicroradiansInOneDegree, degree.As(AngleUnit.Microradian), MicroradiansTolerance);
+            Assert.AreEqual(MilliradiansInOneDegree, degree.As(AngleUnit.Milliradian), MilliradiansTolerance);
+            Assert.AreEqual(NanoradiansInOneDegree, degree.As(AngleUnit.Nanoradian), NanoradiansTolerance);
             Assert.AreEqual(RadiansInOneDegree, degree.As(AngleUnit.Radian), RadiansTolerance);
         }
 
@@ -88,8 +113,13 @@ public void ConversionRoundTrip()
             Angle degree = Angle.FromDegrees(1);
             Assert.AreEqual(1, Angle.FromArcminutes(degree.Arcminutes).Degrees, ArcminutesTolerance);
             Assert.AreEqual(1, Angle.FromArcseconds(degree.Arcseconds).Degrees, ArcsecondsTolerance);
+            Assert.AreEqual(1, Angle.FromCentiradians(degree.Centiradians).Degrees, CentiradiansTolerance);
+            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.FromMicroradians(degree.Microradians).Degrees, MicroradiansTolerance);
+            Assert.AreEqual(1, Angle.FromMilliradians(degree.Milliradians).Degrees, MilliradiansTolerance);
+            Assert.AreEqual(1, Angle.FromNanoradians(degree.Nanoradians).Degrees, NanoradiansTolerance);
             Assert.AreEqual(1, Angle.FromRadians(degree.Radians).Degrees, RadiansTolerance);
         }