From bde08e1154533e9e21fd616082c3da8b314cfc05 Mon Sep 17 00:00:00 2001
From: ulflind <ulf.lindberg@stormgeo.com>
Date: Thu, 17 Dec 2015 09:54:37 +0100
Subject: [PATCH 01/10] Added som operators

---
 ...nitsNet.Serialization.JsonNet.Tests.csproj |  3 ++
 UnitsNet.Tests/CustomCode/LengthTests.cs      | 30 +++++++++++++++++++
 UnitsNet.Tests/CustomCode/MassTests.cs        | 13 ++++++++
 UnitsNet.Tests/CustomCode/PressureTests.cs    | 11 +++++++
 UnitsNet.Tests/CustomCode/SpeedTests.cs       | 17 +++++++++++
 UnitsNet.Tests/CustomCode/TorqueTests.cs      |  8 +++++
 UnitsNet.Tests/CustomCode/VolumeTests.cs      |  9 ++++++
 .../GeneratedCode/LengthTestsBase.g.cs        |  1 +
 .../CustomCode/UnitClasses/Angle.extra.cs     | 12 ++++++++
 .../CustomCode/UnitClasses/Length.extra.cs    | 22 ++++++++++++++
 UnitsNet/CustomCode/UnitClasses/Mass.extra.cs | 10 +++++++
 .../CustomCode/UnitClasses/Power.extra.cs     | 19 ++++++++++++
 .../CustomCode/UnitClasses/Pressure.extra.cs  | 19 ++++++++++++
 .../CustomCode/UnitClasses/Speed.extra.cs     | 21 +++++++++++++
 .../CustomCode/UnitClasses/Torque.extra.cs    | 17 +++++++++++
 .../CustomCode/UnitClasses/Volume.extra.cs    | 20 +++++++++++++
 16 files changed, 232 insertions(+)
 create mode 100644 UnitsNet/CustomCode/UnitClasses/Angle.extra.cs
 create mode 100644 UnitsNet/CustomCode/UnitClasses/Power.extra.cs
 create mode 100644 UnitsNet/CustomCode/UnitClasses/Pressure.extra.cs
 create mode 100644 UnitsNet/CustomCode/UnitClasses/Speed.extra.cs
 create mode 100644 UnitsNet/CustomCode/UnitClasses/Torque.extra.cs
 create mode 100644 UnitsNet/CustomCode/UnitClasses/Volume.extra.cs

diff --git a/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj b/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
index d24fc02fc6..7d6fe10699 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
+++ b/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
@@ -67,6 +67,9 @@
       <Name>UnitsNet.Net35</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/UnitsNet.Tests/CustomCode/LengthTests.cs b/UnitsNet.Tests/CustomCode/LengthTests.cs
index a880495060..f74bcdbce8 100644
--- a/UnitsNet.Tests/CustomCode/LengthTests.cs
+++ b/UnitsNet.Tests/CustomCode/LengthTests.cs
@@ -19,10 +19,39 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+using NUnit.Framework;
+
 namespace UnitsNet.Tests.CustomCode
 {
     public class LengthTests : LengthTestsBase
     {
+        [Test]
+        public void LengthTimesLengthEqualsArea()
+        {
+            var area = Length.FromMeters(10) * Length.FromMeters(2);
+            Assert.AreEqual(area, Area.FromSquareMeters(20));
+        }
+
+        [Test]
+        public void AreaTimesLengthEqualsArea()
+        {
+            var volume = Area.FromSquareMeters(10) * Length.FromMeters(3);
+            Assert.AreEqual(volume, Volume.FromCubicMeters(30));
+        }
+        [Test]
+        public void LengthTimesAreaEqualsArea()
+        {
+            var volume = Length.FromMeters(3) * Area.FromSquareMeters(9);
+            Assert.AreEqual(volume, Volume.FromCubicMeters(27));
+        }
+
+        [Test]
+        public void ForceTimesLengthEqualsTorque()
+        {
+            var volume = Length.FromMeters(3) * Area.FromSquareMeters(9);
+            Assert.AreEqual(volume, Volume.FromCubicMeters(27));
+        }
+
         protected override double CentimetersInOneMeter
         {
             get { return 100; }
@@ -87,5 +116,6 @@ protected override double YardsInOneMeter
         {
             get { return 1.09361; }
         }
+
     }
 }
\ No newline at end of file
diff --git a/UnitsNet.Tests/CustomCode/MassTests.cs b/UnitsNet.Tests/CustomCode/MassTests.cs
index f7a8f6ca0c..2971de9dc1 100644
--- a/UnitsNet.Tests/CustomCode/MassTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassTests.cs
@@ -18,11 +18,24 @@
 // 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 NUnit.Framework;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class MassTests : MassTestsBase
     {
+        [Test]
+        public void MassDividedByVolumeEqualsDensity()
+        {
+            var density = Mass.FromKilograms(18) / Volume.FromCubicMeters(3);
+            Assert.AreEqual(density, Density.FromKilogramsPerCubicMeter(6));
+        }
+        [Test]
+        public void MassTimesAccelerationEqualsForce()
+        {
+            var force = Mass.FromKilograms(18) * Acceleration.FromMeterPerSecondSquared(3);
+            Assert.AreEqual(force, Force.FromNewtons(54));
+        }
         protected override double CentigramsInOneKilogram
         {
             get { return 1E5; }
diff --git a/UnitsNet.Tests/CustomCode/PressureTests.cs b/UnitsNet.Tests/CustomCode/PressureTests.cs
index f48239f37f..b7d5b368fd 100644
--- a/UnitsNet.Tests/CustomCode/PressureTests.cs
+++ b/UnitsNet.Tests/CustomCode/PressureTests.cs
@@ -18,11 +18,22 @@
 // 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 NUnit.Framework;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class PressureTests : PressureTestsBase
     {
+
+
+        [Test]
+        public void PressureTimesAreaEqualsForce()
+        {
+            var force = Pressure.FromPascals(20) * Area.FromSquareMeters(3);
+            Assert.AreEqual(force, Force.FromNewtons(60));
+        }
+
+
         protected override double AtmospheresInOnePascal
         {
             get { return 9.8692*1E-6; }
diff --git a/UnitsNet.Tests/CustomCode/SpeedTests.cs b/UnitsNet.Tests/CustomCode/SpeedTests.cs
index 38db48de94..0a142a38b4 100644
--- a/UnitsNet.Tests/CustomCode/SpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpeedTests.cs
@@ -19,11 +19,28 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+using NUnit.Framework;
+using System;
+
 namespace UnitsNet.Tests.CustomCode
 {
     public class SpeedTests : SpeedTestsBase
     {
 
+        [Test]
+        public void SpeedDevidedByTimespanEqualsAcceleration()
+        {
+            var acceleration = Speed.FromMetersPerSecond(20) / TimeSpan.FromSeconds(2);
+            Assert.AreEqual(acceleration, Acceleration.FromMeterPerSecondSquared(10));
+        }
+        [Test]
+        public void SpeedTimesTimespanEqualsLength()
+        {
+            var length= Speed.FromMetersPerSecond(20) * TimeSpan.FromSeconds(2);
+            Assert.AreEqual(length, Length.FromMeters(40));
+        }
+
+
         protected override double FeetPerSecondInOneMeterPerSecond
         {
             get { return 3.28084; }
diff --git a/UnitsNet.Tests/CustomCode/TorqueTests.cs b/UnitsNet.Tests/CustomCode/TorqueTests.cs
index 1de0635088..d2138aaf7e 100644
--- a/UnitsNet.Tests/CustomCode/TorqueTests.cs
+++ b/UnitsNet.Tests/CustomCode/TorqueTests.cs
@@ -18,11 +18,19 @@
 // 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 NUnit.Framework;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class TorqueTests : TorqueTestsBase
     {
+        [Test]
+        public void TorqueDevidedByLengthEqualsForce()
+        {
+            var force = Torque.FromNewtonMeters(4) / Length.FromMeters(2);
+            Assert.AreEqual(force, Force.FromNewtons(2));
+        }
+
         protected override double KilogramForceCentimetersInOneNewtonMeter
         {
             get { return 10.1971621; }
diff --git a/UnitsNet.Tests/CustomCode/VolumeTests.cs b/UnitsNet.Tests/CustomCode/VolumeTests.cs
index a41f21ec79..b8c12c631e 100644
--- a/UnitsNet.Tests/CustomCode/VolumeTests.cs
+++ b/UnitsNet.Tests/CustomCode/VolumeTests.cs
@@ -19,10 +19,19 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+using NUnit.Framework;
+
 namespace UnitsNet.Tests.CustomCode
 {
     public class VolumeTests : VolumeTestsBase
     {
+        [Test]
+        public void VolumeTimesDensityEqualsMass()
+        {
+            var mass = Volume.FromCubicMeters(2) * Density.FromKilogramsPerCubicMeter(3);
+            Assert.AreEqual(mass, Mass.FromKilograms(6));
+        }
+        
         protected override double CentilitersInOneCubicMeter
         {
             get { return 1E5; }
diff --git a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs
index 200e7e538e..cbab74baf5 100644
--- a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs
@@ -235,5 +235,6 @@ public void EqualsReturnsFalseOnNull()
             Length meter = Length.FromMeters(1);
             Assert.IsFalse(meter.Equals(null));
         }
+
     }
 }
diff --git a/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs b/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs
new file mode 100644
index 0000000000..2c7297fa11
--- /dev/null
+++ b/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace UnitsNet
+{
+    public partial struct Angle
+    {
+        //public static RotationalSpeed operator/(Angle angle, TimeSpan timeSpan)
+        //{
+        //    return RotationalSpeed.FromRadiansPerSecond(angle.Radians/timeSpan.TotalSeconds);
+        //}
+    }
+}
diff --git a/UnitsNet/CustomCode/UnitClasses/Length.extra.cs b/UnitsNet/CustomCode/UnitClasses/Length.extra.cs
index 202e091720..0c55bc259b 100644
--- a/UnitsNet/CustomCode/UnitClasses/Length.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Length.extra.cs
@@ -37,6 +37,28 @@ public static Length FromFeetInches(double feet, double inches)
         {
             return FromInches((FeetToInches * feet) + inches);
         }
+
+        public static Speed operator/ (Length length, TimeSpan timeSpan)
+        {
+            return Speed.FromMetersPerSecond(length.Meters / timeSpan.TotalSeconds);
+        }
+        public static Area operator*(Length length1, Length length2)
+        {
+            return Area.FromSquareMeters(length1.Meters * length2.Meters);
+        }
+        public static Volume operator*(Area area, Length length)
+        {
+            return Volume.FromCubicMeters(area.SquareMeters * length.Meters);
+        }
+        public static Volume operator *(Length length, Area area)
+        {
+            return Volume.FromCubicMeters(area.SquareMeters * length.Meters);
+        }
+        public static Torque operator*(Force force, Length length)
+        {
+            return Torque.FromNewtonMeters(force.Newtons * length.Meters);
+        }
+
     }
 
     public class FeetInches
diff --git a/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs b/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs
index 276ee959a0..1edad3a4dc 100644
--- a/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs
@@ -61,6 +61,16 @@ public static Mass FromStonePounds(double stone, double pounds)
         {
             return FromPounds((StoneToPounds * stone) + pounds);
         }
+
+        public static Density operator /(Mass mass, Volume volume)
+        {
+            return Density.FromKilogramsPerCubicMeter(mass.Kilograms / volume.CubicMeters);
+        }
+        public static Force operator *(Mass mass, Acceleration acceleration)
+        {
+            return Force.FromNewtons(mass.Kilograms * acceleration.MeterPerSecondSquared);
+        }
+
     }
 
     public class StonePounds
diff --git a/UnitsNet/CustomCode/UnitClasses/Power.extra.cs b/UnitsNet/CustomCode/UnitClasses/Power.extra.cs
new file mode 100644
index 0000000000..54f8a03988
--- /dev/null
+++ b/UnitsNet/CustomCode/UnitClasses/Power.extra.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using UnitsNet.Units;
+
+namespace UnitsNet
+{
+    /// <summary>
+    /// Extension to the generated Length struct.
+    /// Makes it easier to work with Feet/Inches combinations, which are customarily used in the US and UK
+    /// to express body height. For example, someone is 5 feet 3 inches tall.
+    /// </summary>
+    public partial struct Power
+    {
+
+    }
+}
diff --git a/UnitsNet/CustomCode/UnitClasses/Pressure.extra.cs b/UnitsNet/CustomCode/UnitClasses/Pressure.extra.cs
new file mode 100644
index 0000000000..c9109b4d68
--- /dev/null
+++ b/UnitsNet/CustomCode/UnitClasses/Pressure.extra.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using UnitsNet.Units;
+
+namespace UnitsNet
+{
+
+    public partial struct Pressure
+    {
+        public static Force operator*(Pressure pressure, Area area)
+        {
+            return Force.FromNewtons(pressure.Pascals * area.SquareMeters);
+        }
+
+    }
+}
diff --git a/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs b/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs
new file mode 100644
index 0000000000..1e9c705d54
--- /dev/null
+++ b/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using UnitsNet.Units;
+
+namespace UnitsNet
+{
+    public partial struct Speed
+    {
+        public static Acceleration operator /(Speed speed, TimeSpan timeSpan)
+        {
+            return Acceleration.FromMeterPerSecondSquared(speed.MetersPerSecond / timeSpan.TotalSeconds);
+        }
+        public static Length operator*(Speed speed, TimeSpan timeSpan)
+        {
+            return Length.FromMeters(speed.MetersPerSecond * timeSpan.TotalSeconds);
+        }
+    }
+}
diff --git a/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs b/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs
new file mode 100644
index 0000000000..c526f3c68b
--- /dev/null
+++ b/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using UnitsNet.Units;
+
+namespace UnitsNet
+{
+    public partial struct Torque
+    {
+        public static Force operator /(Torque torque, Length length)
+        {
+            return Force.FromNewtons(torque.NewtonMeters/ length.Meters);
+        }
+    }
+}
diff --git a/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs b/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs
new file mode 100644
index 0000000000..5b70028433
--- /dev/null
+++ b/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using UnitsNet.Units;
+
+namespace UnitsNet
+{
+    public partial struct Volume
+    {
+
+        public static Mass operator*(Volume volume, Density density)
+        {
+            return Mass.FromKilograms(volume.CubicMeters * density.KilogramsPerCubicMeter);
+        }
+
+
+    }
+}

From fa488448d94bd0ed86270cfc4f17efe2173328dc Mon Sep 17 00:00:00 2001
From: ulflind <ulf.lindberg@stormgeo.com>
Date: Thu, 17 Dec 2015 14:57:27 +0100
Subject: [PATCH 02/10] something minor

---
 UnitsNet/CustomCode/UnitClasses/Length.extra.cs | 3 ++-
 UnitsNet/CustomCode/UnitClasses/Torque.extra.cs | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/UnitsNet/CustomCode/UnitClasses/Length.extra.cs b/UnitsNet/CustomCode/UnitClasses/Length.extra.cs
index 0c55bc259b..c24387b96c 100644
--- a/UnitsNet/CustomCode/UnitClasses/Length.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Length.extra.cs
@@ -21,7 +21,8 @@ public partial struct Length
         /// </summary>
         public FeetInches FeetInches
         {
-            get {
+            get
+            {
                 double totalInches = Inches;
                 double wholeFeet = Math.Floor(totalInches / FeetToInches);
                 double inches = totalInches % FeetToInches;
diff --git a/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs b/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs
index c526f3c68b..d0800ab7da 100644
--- a/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs
@@ -11,7 +11,7 @@ public partial struct Torque
     {
         public static Force operator /(Torque torque, Length length)
         {
-            return Force.FromNewtons(torque.NewtonMeters/ length.Meters);
+            return Force.FromNewtons(torque.NewtonMeters/length.Meters);
         }
     }
 }

From 9d1fcede667c5aed451ebc256041fe866a0a9328 Mon Sep 17 00:00:00 2001
From: ulflind <ulf.lindberg@stormgeo.com>
Date: Mon, 21 Dec 2015 15:13:44 +0100
Subject: [PATCH 03/10] Added operator for Angle

---
 UnitsNet.Tests/CustomCode/AngleTests.cs        | 8 ++++++++
 UnitsNet/CustomCode/UnitClasses/Angle.extra.cs | 8 ++++----
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/UnitsNet.Tests/CustomCode/AngleTests.cs b/UnitsNet.Tests/CustomCode/AngleTests.cs
index 59f9ff86a9..94125b8c1c 100644
--- a/UnitsNet.Tests/CustomCode/AngleTests.cs
+++ b/UnitsNet.Tests/CustomCode/AngleTests.cs
@@ -20,11 +20,19 @@
 // THE SOFTWARE.
 
 using System;
+using NUnit.Framework;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class AngleTests : AngleTestsBase
     {
+        [Test]
+        public void AngleDividedByTimeEqualsRotationalSpeed()
+        {
+            var rotationalSpeed = Angle.FromRadians(10)/TimeSpan.FromSeconds(5);
+            Assert.AreEqual(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(2));
+        }
+
         protected override double DegreesInOneDegree
         {
             get { return 1; }
diff --git a/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs b/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs
index 2c7297fa11..970820741b 100644
--- a/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs
@@ -4,9 +4,9 @@ namespace UnitsNet
 {
     public partial struct Angle
     {
-        //public static RotationalSpeed operator/(Angle angle, TimeSpan timeSpan)
-        //{
-        //    return RotationalSpeed.FromRadiansPerSecond(angle.Radians/timeSpan.TotalSeconds);
-        //}
+        public static RotationalSpeed operator /(Angle angle, TimeSpan timeSpan)
+        {
+            return RotationalSpeed.FromRadiansPerSecond(angle.Radians / timeSpan.TotalSeconds);
+        }
     }
 }

From d17c89f4fc733c47264bbf55652d703ee71a5f59 Mon Sep 17 00:00:00 2001
From: ulflind <ulf.lindberg@stormgeo.com>
Date: Tue, 22 Dec 2015 14:16:42 +0100
Subject: [PATCH 04/10] Changed kcal to cal and some other minor changes.

---
 UnitsNet.Tests/CustomCode/AngleTests.cs       |  30 +--
 UnitsNet.Tests/CustomCode/MassFlowTests.cs    |   4 +-
 .../CustomCode/SpecificEnergyTests.cs         |  22 +-
 .../GeneratedCode/AngleTestsBase.g.cs         |  24 +--
 .../GeneratedCode/MassFlowTestsBase.g.cs      |  86 ++++----
 .../SpecificEnergyTestsBase.g.cs              | 156 ++++++++-------
 UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs   |   4 +-
 .../GeneratedCode/Enums/MassFlowUnit.g.cs     |   2 +-
 .../Enums/SpecificEnergyUnit.g.cs             |  15 +-
 UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs |  76 +++----
 .../GeneratedCode/UnitClasses/MassFlow.g.cs   |  60 +++---
 .../UnitClasses/SpecificEnergy.g.cs           | 188 ++++++++++--------
 .../GeneratedCode/UnitSystem.Default.g.cs     |  41 ++--
 UnitsNet/Scripts/UnitDefinitions/Angle.json   |  12 +-
 .../Scripts/UnitDefinitions/MassFlow.json     |   4 +-
 .../UnitDefinitions/SpecificEnergy.json       |  19 +-
 16 files changed, 393 insertions(+), 350 deletions(-)

diff --git a/UnitsNet.Tests/CustomCode/AngleTests.cs b/UnitsNet.Tests/CustomCode/AngleTests.cs
index 59f9ff86a9..a9f3cd9957 100644
--- a/UnitsNet.Tests/CustomCode/AngleTests.cs
+++ b/UnitsNet.Tests/CustomCode/AngleTests.cs
@@ -25,6 +25,22 @@ namespace UnitsNet.Tests.CustomCode
 {
     public class AngleTests : AngleTestsBase
     {
+        protected override double ArcminutesInOneDegree
+        {
+            get
+            {
+                return 60.0;
+            }
+        }
+
+        protected override double ArcsecondsInOneDegree
+        {
+            get
+            {
+                return 3600.0;
+            }
+        }
+
         protected override double DegreesInOneDegree
         {
             get { return 1; }
@@ -35,25 +51,11 @@ protected override double GradiansInOneDegree
             get { return 400/360.0; }
         }
 
-        protected override double MinutesOfArcInOneDegree
-        {
-            get
-            {
-                return 60.0;
-            }
-        }
 
         protected override double RadiansInOneDegree
         {
             get { return Math.PI/2/90; }
         }
 
-        protected override double SecondsOfArcInOneDegree
-        {
-            get
-            {
-                return 3600.0;
-            }
-        }
     }
 }
\ No newline at end of file
diff --git a/UnitsNet.Tests/CustomCode/MassFlowTests.cs b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
index 087da8df69..1b934169b4 100644
--- a/UnitsNet.Tests/CustomCode/MassFlowTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
@@ -27,7 +27,7 @@ namespace UnitsNet.Tests.CustomCode
     public class MassFlowTests : MassFlowTestsBase
     {
         // TODO Override properties in base class here
-        protected override double KiloGramsPerSecondInOneKiloGramPerSecond
+        protected override double KilogramsPerSecondInOneKilogramPerSecond
         {
             get
             {
@@ -35,7 +35,7 @@ protected override double KiloGramsPerSecondInOneKiloGramPerSecond
             }
         }
 
-        protected override double TonnesPerDayInOneKiloGramPerSecond
+        protected override double TonnesPerDayInOneKilogramPerSecond
         {
             get
             {
diff --git a/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs b/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
index 9f8001bf11..c8843a97f5 100644
--- a/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
@@ -28,7 +28,7 @@ public class SpecificEnergyTests : SpecificEnergyTestsBase
     {
 
         // TODO Override properties in base class here
-        protected override double JoulesPerKiloGramInOneJoulePerKiloGram
+        protected override double JoulesPerKilogramInOneJoulePerKilogram
         {
             get
             {
@@ -36,7 +36,14 @@ protected override double JoulesPerKiloGramInOneJoulePerKiloGram
             }
         }
 
-        protected override double KiloCaloriesPerGramInOneJoulePerKiloGram
+        protected override double CaloriesPerGramInOneJoulePerKilogram
+        {
+            get
+            {
+                return 1.0 / (4.184E3);
+            }
+        }
+        protected override double KilocaloriesPerGramInOneJoulePerKilogram
         {
             get
             {
@@ -44,7 +51,7 @@ protected override double KiloCaloriesPerGramInOneJoulePerKiloGram
             }
         }
 
-        protected override double KilojoulesPerKiloGramInOneJoulePerKiloGram
+        protected override double KilojoulesPerKilogramInOneJoulePerKilogram
         {
             get
             {
@@ -52,7 +59,7 @@ protected override double KilojoulesPerKiloGramInOneJoulePerKiloGram
             }
         }
 
-        protected override double KilowattHoursPerKiloGramInOneJoulePerKiloGram
+        protected override double KilowattHoursPerKilogramInOneJoulePerKilogram
         {
             get
             {
@@ -60,7 +67,7 @@ protected override double KilowattHoursPerKiloGramInOneJoulePerKiloGram
             }
         }
 
-        protected override double MegajoulesPerKiloGramInOneJoulePerKiloGram
+        protected override double MegajoulesPerKilogramInOneJoulePerKilogram
         {
             get
             {
@@ -68,7 +75,7 @@ protected override double MegajoulesPerKiloGramInOneJoulePerKiloGram
             }
         }
 
-        protected override double MegawattHoursPerKiloGramInOneJoulePerKiloGram
+        protected override double MegawattHoursPerKilogramInOneJoulePerKilogram
         {
             get
             {
@@ -76,12 +83,13 @@ protected override double MegawattHoursPerKiloGramInOneJoulePerKiloGram
             }
         }
 
-        protected override double WattHoursPerKiloGramInOneJoulePerKiloGram
+        protected override double WattHoursPerKilogramInOneJoulePerKilogram
         {
             get
             {
                 return 1.0 / 3.6e3;
             }
         }
+
     }
 }
diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs
index 864ef2cb34..9582b7c16b 100644
--- a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs
@@ -36,61 +36,61 @@ namespace UnitsNet.Tests
 // ReSharper disable once PartialTypeWithSinglePart
     public abstract partial class AngleTestsBase
     {
+        protected abstract double ArcminutesInOneDegree { get; }
+        protected abstract double ArcsecondsInOneDegree { get; }
         protected abstract double DegreesInOneDegree { get; }
         protected abstract double GradiansInOneDegree { get; }
-        protected abstract double MinutesOfArcInOneDegree { get; }
         protected abstract double RadiansInOneDegree { get; }
-        protected abstract double SecondsOfArcInOneDegree { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
+        protected virtual double ArcminutesTolerance { get { return 1e-5; } }
+        protected virtual double ArcsecondsTolerance { get { return 1e-5; } }
         protected virtual double DegreesTolerance { get { return 1e-5; } }
         protected virtual double GradiansTolerance { get { return 1e-5; } }
-        protected virtual double MinutesOfArcTolerance { get { return 1e-5; } }
         protected virtual double RadiansTolerance { get { return 1e-5; } }
-        protected virtual double SecondsOfArcTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
         [Test]
         public void DegreeToAngleUnits()
         {
             Angle degree = Angle.FromDegrees(1);
+            Assert.AreEqual(ArcminutesInOneDegree, degree.Arcminutes, ArcminutesTolerance);
+            Assert.AreEqual(ArcsecondsInOneDegree, degree.Arcseconds, ArcsecondsTolerance);
             Assert.AreEqual(DegreesInOneDegree, degree.Degrees, DegreesTolerance);
             Assert.AreEqual(GradiansInOneDegree, degree.Gradians, GradiansTolerance);
-            Assert.AreEqual(MinutesOfArcInOneDegree, degree.MinutesOfArc, MinutesOfArcTolerance);
             Assert.AreEqual(RadiansInOneDegree, degree.Radians, RadiansTolerance);
-            Assert.AreEqual(SecondsOfArcInOneDegree, degree.SecondsOfArc, SecondsOfArcTolerance);
         }
 
         [Test]
         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.Degree).Degrees, DegreesTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Gradian).Gradians, GradiansTolerance);
-            Assert.AreEqual(1, Angle.From(1, AngleUnit.MinuteOfArc).MinutesOfArc, MinutesOfArcTolerance);
             Assert.AreEqual(1, Angle.From(1, AngleUnit.Radian).Radians, RadiansTolerance);
-            Assert.AreEqual(1, Angle.From(1, AngleUnit.SecondOfArc).SecondsOfArc, SecondsOfArcTolerance);
         }
 
         [Test]
         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(DegreesInOneDegree, degree.As(AngleUnit.Degree), DegreesTolerance);
             Assert.AreEqual(GradiansInOneDegree, degree.As(AngleUnit.Gradian), GradiansTolerance);
-            Assert.AreEqual(MinutesOfArcInOneDegree, degree.As(AngleUnit.MinuteOfArc), MinutesOfArcTolerance);
             Assert.AreEqual(RadiansInOneDegree, degree.As(AngleUnit.Radian), RadiansTolerance);
-            Assert.AreEqual(SecondsOfArcInOneDegree, degree.As(AngleUnit.SecondOfArc), SecondsOfArcTolerance);
         }
 
         [Test]
         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.FromDegrees(degree.Degrees).Degrees, DegreesTolerance);
             Assert.AreEqual(1, Angle.FromGradians(degree.Gradians).Degrees, GradiansTolerance);
-            Assert.AreEqual(1, Angle.FromMinutesOfArc(degree.MinutesOfArc).Degrees, MinutesOfArcTolerance);
             Assert.AreEqual(1, Angle.FromRadians(degree.Radians).Degrees, RadiansTolerance);
-            Assert.AreEqual(1, Angle.FromSecondsOfArc(degree.SecondsOfArc).Degrees, SecondsOfArcTolerance);
         }
 
         [Test]
diff --git a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs
index 5ab9694b66..c7999d864e 100644
--- a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs
@@ -36,79 +36,79 @@ namespace UnitsNet.Tests
 // ReSharper disable once PartialTypeWithSinglePart
     public abstract partial class MassFlowTestsBase
     {
-        protected abstract double KiloGramsPerSecondInOneKiloGramPerSecond { get; }
-        protected abstract double TonnesPerDayInOneKiloGramPerSecond { get; }
+        protected abstract double KilogramsPerSecondInOneKilogramPerSecond { get; }
+        protected abstract double TonnesPerDayInOneKilogramPerSecond { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
-        protected virtual double KiloGramsPerSecondTolerance { get { return 1e-5; } }
+        protected virtual double KilogramsPerSecondTolerance { get { return 1e-5; } }
         protected virtual double TonnesPerDayTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
         [Test]
-        public void KiloGramPerSecondToMassFlowUnits()
+        public void KilogramPerSecondToMassFlowUnits()
         {
-            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
-            Assert.AreEqual(KiloGramsPerSecondInOneKiloGramPerSecond, kilogrampersecond.KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(TonnesPerDayInOneKiloGramPerSecond, kilogrampersecond.TonnesPerDay, TonnesPerDayTolerance);
+            MassFlow kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
+            Assert.AreEqual(KilogramsPerSecondInOneKilogramPerSecond, kilogrampersecond.KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(TonnesPerDayInOneKilogramPerSecond, kilogrampersecond.TonnesPerDay, TonnesPerDayTolerance);
         }
 
         [Test]
         public void FromValueAndUnit()
         {
-            Assert.AreEqual(1, MassFlow.From(1, MassFlowUnit.KiloGramPerSecond).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
+            Assert.AreEqual(1, MassFlow.From(1, MassFlowUnit.KilogramPerSecond).KilogramsPerSecond, KilogramsPerSecondTolerance);
             Assert.AreEqual(1, MassFlow.From(1, MassFlowUnit.TonnePerDay).TonnesPerDay, TonnesPerDayTolerance);
         }
 
         [Test]
         public void As()
         {
-            var kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
-            Assert.AreEqual(KiloGramsPerSecondInOneKiloGramPerSecond, kilogrampersecond.As(MassFlowUnit.KiloGramPerSecond), KiloGramsPerSecondTolerance);
-            Assert.AreEqual(TonnesPerDayInOneKiloGramPerSecond, kilogrampersecond.As(MassFlowUnit.TonnePerDay), TonnesPerDayTolerance);
+            var kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
+            Assert.AreEqual(KilogramsPerSecondInOneKilogramPerSecond, kilogrampersecond.As(MassFlowUnit.KilogramPerSecond), KilogramsPerSecondTolerance);
+            Assert.AreEqual(TonnesPerDayInOneKilogramPerSecond, kilogrampersecond.As(MassFlowUnit.TonnePerDay), TonnesPerDayTolerance);
         }
 
         [Test]
         public void ConversionRoundTrip()
         {
-            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
-            Assert.AreEqual(1, MassFlow.FromKiloGramsPerSecond(kilogrampersecond.KiloGramsPerSecond).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(1, MassFlow.FromTonnesPerDay(kilogrampersecond.TonnesPerDay).KiloGramsPerSecond, TonnesPerDayTolerance);
+            MassFlow kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
+            Assert.AreEqual(1, MassFlow.FromKilogramsPerSecond(kilogrampersecond.KilogramsPerSecond).KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(1, MassFlow.FromTonnesPerDay(kilogrampersecond.TonnesPerDay).KilogramsPerSecond, TonnesPerDayTolerance);
         }
 
         [Test]
         public void ArithmeticOperators()
         {
-            MassFlow v = MassFlow.FromKiloGramsPerSecond(1);
-            Assert.AreEqual(-1, -v.KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(2, (MassFlow.FromKiloGramsPerSecond(3)-v).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(2, (v + v).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(10, (v*10).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(10, (10*v).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(2, (MassFlow.FromKiloGramsPerSecond(10)/5).KiloGramsPerSecond, KiloGramsPerSecondTolerance);
-            Assert.AreEqual(2, MassFlow.FromKiloGramsPerSecond(10)/MassFlow.FromKiloGramsPerSecond(5), KiloGramsPerSecondTolerance);
+            MassFlow v = MassFlow.FromKilogramsPerSecond(1);
+            Assert.AreEqual(-1, -v.KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(2, (MassFlow.FromKilogramsPerSecond(3)-v).KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(2, (v + v).KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(10, (v*10).KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(10, (10*v).KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(2, (MassFlow.FromKilogramsPerSecond(10)/5).KilogramsPerSecond, KilogramsPerSecondTolerance);
+            Assert.AreEqual(2, MassFlow.FromKilogramsPerSecond(10)/MassFlow.FromKilogramsPerSecond(5), KilogramsPerSecondTolerance);
         }
 
         [Test]
         public void ComparisonOperators()
         {
-            MassFlow oneKiloGramPerSecond = MassFlow.FromKiloGramsPerSecond(1);
-            MassFlow twoKiloGramsPerSecond = MassFlow.FromKiloGramsPerSecond(2);
-
-            Assert.True(oneKiloGramPerSecond < twoKiloGramsPerSecond);
-            Assert.True(oneKiloGramPerSecond <= twoKiloGramsPerSecond);
-            Assert.True(twoKiloGramsPerSecond > oneKiloGramPerSecond);
-            Assert.True(twoKiloGramsPerSecond >= oneKiloGramPerSecond);
-
-            Assert.False(oneKiloGramPerSecond > twoKiloGramsPerSecond);
-            Assert.False(oneKiloGramPerSecond >= twoKiloGramsPerSecond);
-            Assert.False(twoKiloGramsPerSecond < oneKiloGramPerSecond);
-            Assert.False(twoKiloGramsPerSecond <= oneKiloGramPerSecond);
+            MassFlow oneKilogramPerSecond = MassFlow.FromKilogramsPerSecond(1);
+            MassFlow twoKilogramsPerSecond = MassFlow.FromKilogramsPerSecond(2);
+
+            Assert.True(oneKilogramPerSecond < twoKilogramsPerSecond);
+            Assert.True(oneKilogramPerSecond <= twoKilogramsPerSecond);
+            Assert.True(twoKilogramsPerSecond > oneKilogramPerSecond);
+            Assert.True(twoKilogramsPerSecond >= oneKilogramPerSecond);
+
+            Assert.False(oneKilogramPerSecond > twoKilogramsPerSecond);
+            Assert.False(oneKilogramPerSecond >= twoKilogramsPerSecond);
+            Assert.False(twoKilogramsPerSecond < oneKilogramPerSecond);
+            Assert.False(twoKilogramsPerSecond <= oneKilogramPerSecond);
         }
 
         [Test]
         public void CompareToIsImplemented()
         {
-            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            MassFlow kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
             Assert.AreEqual(0, kilogrampersecond.CompareTo(kilogrampersecond));
             Assert.Greater(kilogrampersecond.CompareTo(MassFlow.Zero), 0);
             Assert.Less(MassFlow.Zero.CompareTo(kilogrampersecond), 0);
@@ -118,7 +118,7 @@ public void CompareToIsImplemented()
         [ExpectedException(typeof(ArgumentException))]
         public void CompareToThrowsOnTypeMismatch()
         {
-            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            MassFlow kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
 // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             kilogrampersecond.CompareTo(new object());
         }
@@ -127,7 +127,7 @@ public void CompareToThrowsOnTypeMismatch()
         [ExpectedException(typeof(ArgumentNullException))]
         public void CompareToThrowsOnNull()
         { 
-            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            MassFlow kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
 // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             kilogrampersecond.CompareTo(null);
         }
@@ -136,8 +136,8 @@ public void CompareToThrowsOnNull()
         [Test]
         public void EqualityOperators()
         {
-            MassFlow a = MassFlow.FromKiloGramsPerSecond(1);
-            MassFlow b = MassFlow.FromKiloGramsPerSecond(2);
+            MassFlow a = MassFlow.FromKilogramsPerSecond(1);
+            MassFlow b = MassFlow.FromKilogramsPerSecond(2);
 
 // ReSharper disable EqualExpressionComparison
             Assert.True(a == a); 
@@ -151,22 +151,22 @@ public void EqualityOperators()
         [Test]
         public void EqualsIsImplemented()
         {
-            MassFlow v = MassFlow.FromKiloGramsPerSecond(1);
-            Assert.IsTrue(v.Equals(MassFlow.FromKiloGramsPerSecond(1)));
+            MassFlow v = MassFlow.FromKilogramsPerSecond(1);
+            Assert.IsTrue(v.Equals(MassFlow.FromKilogramsPerSecond(1)));
             Assert.IsFalse(v.Equals(MassFlow.Zero));
         }
 
         [Test]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            MassFlow kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
             Assert.IsFalse(kilogrampersecond.Equals(new object()));
         }
 
         [Test]
         public void EqualsReturnsFalseOnNull()
         {
-            MassFlow kilogrampersecond = MassFlow.FromKiloGramsPerSecond(1);
+            MassFlow kilogrampersecond = MassFlow.FromKilogramsPerSecond(1);
             Assert.IsFalse(kilogrampersecond.Equals(null));
         }
     }
diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs
index 3abbda3723..b1a8db42f3 100644
--- a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs
@@ -36,109 +36,115 @@ namespace UnitsNet.Tests
 // ReSharper disable once PartialTypeWithSinglePart
     public abstract partial class SpecificEnergyTestsBase
     {
-        protected abstract double JoulesPerKiloGramInOneJoulePerKiloGram { get; }
-        protected abstract double KiloCaloriesPerGramInOneJoulePerKiloGram { get; }
-        protected abstract double KilojoulesPerKiloGramInOneJoulePerKiloGram { get; }
-        protected abstract double KilowattHoursPerKiloGramInOneJoulePerKiloGram { get; }
-        protected abstract double MegajoulesPerKiloGramInOneJoulePerKiloGram { get; }
-        protected abstract double MegawattHoursPerKiloGramInOneJoulePerKiloGram { get; }
-        protected abstract double WattHoursPerKiloGramInOneJoulePerKiloGram { get; }
+        protected abstract double CaloriesPerGramInOneJoulePerKilogram { get; }
+        protected abstract double JoulesPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double KilocaloriesPerGramInOneJoulePerKilogram { get; }
+        protected abstract double KilojoulesPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double KilowattHoursPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double MegajoulesPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double MegawattHoursPerKilogramInOneJoulePerKilogram { get; }
+        protected abstract double WattHoursPerKilogramInOneJoulePerKilogram { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
-        protected virtual double JoulesPerKiloGramTolerance { get { return 1e-5; } }
-        protected virtual double KiloCaloriesPerGramTolerance { get { return 1e-5; } }
-        protected virtual double KilojoulesPerKiloGramTolerance { get { return 1e-5; } }
-        protected virtual double KilowattHoursPerKiloGramTolerance { get { return 1e-5; } }
-        protected virtual double MegajoulesPerKiloGramTolerance { get { return 1e-5; } }
-        protected virtual double MegawattHoursPerKiloGramTolerance { get { return 1e-5; } }
-        protected virtual double WattHoursPerKiloGramTolerance { get { return 1e-5; } }
+        protected virtual double CaloriesPerGramTolerance { get { return 1e-5; } }
+        protected virtual double JoulesPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double KilocaloriesPerGramTolerance { get { return 1e-5; } }
+        protected virtual double KilojoulesPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double KilowattHoursPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double MegajoulesPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double MegawattHoursPerKilogramTolerance { get { return 1e-5; } }
+        protected virtual double WattHoursPerKilogramTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
         [Test]
-        public void JoulePerKiloGramToSpecificEnergyUnits()
+        public void JoulePerKilogramToSpecificEnergyUnits()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
-            Assert.AreEqual(JoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(KiloCaloriesPerGramInOneJoulePerKiloGram, jouleperkilogram.KiloCaloriesPerGram, KiloCaloriesPerGramTolerance);
-            Assert.AreEqual(KilojoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.KilojoulesPerKiloGram, KilojoulesPerKiloGramTolerance);
-            Assert.AreEqual(KilowattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.KilowattHoursPerKiloGram, KilowattHoursPerKiloGramTolerance);
-            Assert.AreEqual(MegajoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.MegajoulesPerKiloGram, MegajoulesPerKiloGramTolerance);
-            Assert.AreEqual(MegawattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.MegawattHoursPerKiloGram, MegawattHoursPerKiloGramTolerance);
-            Assert.AreEqual(WattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.WattHoursPerKiloGram, WattHoursPerKiloGramTolerance);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            Assert.AreEqual(CaloriesPerGramInOneJoulePerKilogram, jouleperkilogram.CaloriesPerGram, CaloriesPerGramTolerance);
+            Assert.AreEqual(JoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(KilocaloriesPerGramInOneJoulePerKilogram, jouleperkilogram.KilocaloriesPerGram, KilocaloriesPerGramTolerance);
+            Assert.AreEqual(KilojoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.KilojoulesPerKilogram, KilojoulesPerKilogramTolerance);
+            Assert.AreEqual(KilowattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.KilowattHoursPerKilogram, KilowattHoursPerKilogramTolerance);
+            Assert.AreEqual(MegajoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.MegajoulesPerKilogram, MegajoulesPerKilogramTolerance);
+            Assert.AreEqual(MegawattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.MegawattHoursPerKilogram, MegawattHoursPerKilogramTolerance);
+            Assert.AreEqual(WattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.WattHoursPerKilogram, WattHoursPerKilogramTolerance);
         }
 
         [Test]
         public void FromValueAndUnit()
         {
-            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.JoulePerKiloGram).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KiloCaloriePerGram).KiloCaloriesPerGram, KiloCaloriesPerGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KilojoulePerKiloGram).KilojoulesPerKiloGram, KilojoulesPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KilowattHourPerKiloGram).KilowattHoursPerKiloGram, KilowattHoursPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.MegajoulePerKiloGram).MegajoulesPerKiloGram, MegajoulesPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.MegawattHourPerKiloGram).MegawattHoursPerKiloGram, MegawattHoursPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.WattHourPerKiloGram).WattHoursPerKiloGram, WattHoursPerKiloGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.CaloriePerGram).CaloriesPerGram, CaloriesPerGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.JoulePerKilogram).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KilocaloriePerGram).KilocaloriesPerGram, KilocaloriesPerGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KilojoulePerKilogram).KilojoulesPerKilogram, KilojoulesPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.KilowattHourPerKilogram).KilowattHoursPerKilogram, KilowattHoursPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.MegajoulePerKilogram).MegajoulesPerKilogram, MegajoulesPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.MegawattHourPerKilogram).MegawattHoursPerKilogram, MegawattHoursPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.From(1, SpecificEnergyUnit.WattHourPerKilogram).WattHoursPerKilogram, WattHoursPerKilogramTolerance);
         }
 
         [Test]
         public void As()
         {
-            var jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
-            Assert.AreEqual(JoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.JoulePerKiloGram), JoulesPerKiloGramTolerance);
-            Assert.AreEqual(KiloCaloriesPerGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.KiloCaloriePerGram), KiloCaloriesPerGramTolerance);
-            Assert.AreEqual(KilojoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.KilojoulePerKiloGram), KilojoulesPerKiloGramTolerance);
-            Assert.AreEqual(KilowattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.KilowattHourPerKiloGram), KilowattHoursPerKiloGramTolerance);
-            Assert.AreEqual(MegajoulesPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.MegajoulePerKiloGram), MegajoulesPerKiloGramTolerance);
-            Assert.AreEqual(MegawattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.MegawattHourPerKiloGram), MegawattHoursPerKiloGramTolerance);
-            Assert.AreEqual(WattHoursPerKiloGramInOneJoulePerKiloGram, jouleperkilogram.As(SpecificEnergyUnit.WattHourPerKiloGram), WattHoursPerKiloGramTolerance);
+            var jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            Assert.AreEqual(CaloriesPerGramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.CaloriePerGram), CaloriesPerGramTolerance);
+            Assert.AreEqual(JoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.JoulePerKilogram), JoulesPerKilogramTolerance);
+            Assert.AreEqual(KilocaloriesPerGramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.KilocaloriePerGram), KilocaloriesPerGramTolerance);
+            Assert.AreEqual(KilojoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.KilojoulePerKilogram), KilojoulesPerKilogramTolerance);
+            Assert.AreEqual(KilowattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.KilowattHourPerKilogram), KilowattHoursPerKilogramTolerance);
+            Assert.AreEqual(MegajoulesPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.MegajoulePerKilogram), MegajoulesPerKilogramTolerance);
+            Assert.AreEqual(MegawattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.MegawattHourPerKilogram), MegawattHoursPerKilogramTolerance);
+            Assert.AreEqual(WattHoursPerKilogramInOneJoulePerKilogram, jouleperkilogram.As(SpecificEnergyUnit.WattHourPerKilogram), WattHoursPerKilogramTolerance);
         }
 
         [Test]
         public void ConversionRoundTrip()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
-            Assert.AreEqual(1, SpecificEnergy.FromJoulesPerKiloGram(jouleperkilogram.JoulesPerKiloGram).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.FromKiloCaloriesPerGram(jouleperkilogram.KiloCaloriesPerGram).JoulesPerKiloGram, KiloCaloriesPerGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.FromKilojoulesPerKiloGram(jouleperkilogram.KilojoulesPerKiloGram).JoulesPerKiloGram, KilojoulesPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.FromKilowattHoursPerKiloGram(jouleperkilogram.KilowattHoursPerKiloGram).JoulesPerKiloGram, KilowattHoursPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.FromMegajoulesPerKiloGram(jouleperkilogram.MegajoulesPerKiloGram).JoulesPerKiloGram, MegajoulesPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.FromMegawattHoursPerKiloGram(jouleperkilogram.MegawattHoursPerKiloGram).JoulesPerKiloGram, MegawattHoursPerKiloGramTolerance);
-            Assert.AreEqual(1, SpecificEnergy.FromWattHoursPerKiloGram(jouleperkilogram.WattHoursPerKiloGram).JoulesPerKiloGram, WattHoursPerKiloGramTolerance);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            Assert.AreEqual(1, SpecificEnergy.FromCaloriesPerGram(jouleperkilogram.CaloriesPerGram).JoulesPerKilogram, CaloriesPerGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromJoulesPerKilogram(jouleperkilogram.JoulesPerKilogram).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromKilocaloriesPerGram(jouleperkilogram.KilocaloriesPerGram).JoulesPerKilogram, KilocaloriesPerGramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromKilojoulesPerKilogram(jouleperkilogram.KilojoulesPerKilogram).JoulesPerKilogram, KilojoulesPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromKilowattHoursPerKilogram(jouleperkilogram.KilowattHoursPerKilogram).JoulesPerKilogram, KilowattHoursPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromMegajoulesPerKilogram(jouleperkilogram.MegajoulesPerKilogram).JoulesPerKilogram, MegajoulesPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromMegawattHoursPerKilogram(jouleperkilogram.MegawattHoursPerKilogram).JoulesPerKilogram, MegawattHoursPerKilogramTolerance);
+            Assert.AreEqual(1, SpecificEnergy.FromWattHoursPerKilogram(jouleperkilogram.WattHoursPerKilogram).JoulesPerKilogram, WattHoursPerKilogramTolerance);
         }
 
         [Test]
         public void ArithmeticOperators()
         {
-            SpecificEnergy v = SpecificEnergy.FromJoulesPerKiloGram(1);
-            Assert.AreEqual(-1, -v.JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(2, (SpecificEnergy.FromJoulesPerKiloGram(3)-v).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(2, (v + v).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(10, (v*10).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(10, (10*v).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(2, (SpecificEnergy.FromJoulesPerKiloGram(10)/5).JoulesPerKiloGram, JoulesPerKiloGramTolerance);
-            Assert.AreEqual(2, SpecificEnergy.FromJoulesPerKiloGram(10)/SpecificEnergy.FromJoulesPerKiloGram(5), JoulesPerKiloGramTolerance);
+            SpecificEnergy v = SpecificEnergy.FromJoulesPerKilogram(1);
+            Assert.AreEqual(-1, -v.JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(2, (SpecificEnergy.FromJoulesPerKilogram(3)-v).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(2, (v + v).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(10, (v*10).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(10, (10*v).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(2, (SpecificEnergy.FromJoulesPerKilogram(10)/5).JoulesPerKilogram, JoulesPerKilogramTolerance);
+            Assert.AreEqual(2, SpecificEnergy.FromJoulesPerKilogram(10)/SpecificEnergy.FromJoulesPerKilogram(5), JoulesPerKilogramTolerance);
         }
 
         [Test]
         public void ComparisonOperators()
         {
-            SpecificEnergy oneJoulePerKiloGram = SpecificEnergy.FromJoulesPerKiloGram(1);
-            SpecificEnergy twoJoulesPerKiloGram = SpecificEnergy.FromJoulesPerKiloGram(2);
-
-            Assert.True(oneJoulePerKiloGram < twoJoulesPerKiloGram);
-            Assert.True(oneJoulePerKiloGram <= twoJoulesPerKiloGram);
-            Assert.True(twoJoulesPerKiloGram > oneJoulePerKiloGram);
-            Assert.True(twoJoulesPerKiloGram >= oneJoulePerKiloGram);
-
-            Assert.False(oneJoulePerKiloGram > twoJoulesPerKiloGram);
-            Assert.False(oneJoulePerKiloGram >= twoJoulesPerKiloGram);
-            Assert.False(twoJoulesPerKiloGram < oneJoulePerKiloGram);
-            Assert.False(twoJoulesPerKiloGram <= oneJoulePerKiloGram);
+            SpecificEnergy oneJoulePerKilogram = SpecificEnergy.FromJoulesPerKilogram(1);
+            SpecificEnergy twoJoulesPerKilogram = SpecificEnergy.FromJoulesPerKilogram(2);
+
+            Assert.True(oneJoulePerKilogram < twoJoulesPerKilogram);
+            Assert.True(oneJoulePerKilogram <= twoJoulesPerKilogram);
+            Assert.True(twoJoulesPerKilogram > oneJoulePerKilogram);
+            Assert.True(twoJoulesPerKilogram >= oneJoulePerKilogram);
+
+            Assert.False(oneJoulePerKilogram > twoJoulesPerKilogram);
+            Assert.False(oneJoulePerKilogram >= twoJoulesPerKilogram);
+            Assert.False(twoJoulesPerKilogram < oneJoulePerKilogram);
+            Assert.False(twoJoulesPerKilogram <= oneJoulePerKilogram);
         }
 
         [Test]
         public void CompareToIsImplemented()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
             Assert.AreEqual(0, jouleperkilogram.CompareTo(jouleperkilogram));
             Assert.Greater(jouleperkilogram.CompareTo(SpecificEnergy.Zero), 0);
             Assert.Less(SpecificEnergy.Zero.CompareTo(jouleperkilogram), 0);
@@ -148,7 +154,7 @@ public void CompareToIsImplemented()
         [ExpectedException(typeof(ArgumentException))]
         public void CompareToThrowsOnTypeMismatch()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
 // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             jouleperkilogram.CompareTo(new object());
         }
@@ -157,7 +163,7 @@ public void CompareToThrowsOnTypeMismatch()
         [ExpectedException(typeof(ArgumentNullException))]
         public void CompareToThrowsOnNull()
         { 
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
 // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
             jouleperkilogram.CompareTo(null);
         }
@@ -166,8 +172,8 @@ public void CompareToThrowsOnNull()
         [Test]
         public void EqualityOperators()
         {
-            SpecificEnergy a = SpecificEnergy.FromJoulesPerKiloGram(1);
-            SpecificEnergy b = SpecificEnergy.FromJoulesPerKiloGram(2);
+            SpecificEnergy a = SpecificEnergy.FromJoulesPerKilogram(1);
+            SpecificEnergy b = SpecificEnergy.FromJoulesPerKilogram(2);
 
 // ReSharper disable EqualExpressionComparison
             Assert.True(a == a); 
@@ -181,22 +187,22 @@ public void EqualityOperators()
         [Test]
         public void EqualsIsImplemented()
         {
-            SpecificEnergy v = SpecificEnergy.FromJoulesPerKiloGram(1);
-            Assert.IsTrue(v.Equals(SpecificEnergy.FromJoulesPerKiloGram(1)));
+            SpecificEnergy v = SpecificEnergy.FromJoulesPerKilogram(1);
+            Assert.IsTrue(v.Equals(SpecificEnergy.FromJoulesPerKilogram(1)));
             Assert.IsFalse(v.Equals(SpecificEnergy.Zero));
         }
 
         [Test]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
             Assert.IsFalse(jouleperkilogram.Equals(new object()));
         }
 
         [Test]
         public void EqualsReturnsFalseOnNull()
         {
-            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKiloGram(1);
+            SpecificEnergy jouleperkilogram = SpecificEnergy.FromJoulesPerKilogram(1);
             Assert.IsFalse(jouleperkilogram.Equals(null));
         }
     }
diff --git a/UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs b/UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs
index ac96746f64..dd3c5a6ed7 100644
--- a/UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Enums/AngleUnit.g.cs
@@ -25,10 +25,10 @@ namespace UnitsNet.Units
     public enum AngleUnit
     {
         Undefined = 0,
+        Arcminute,
+        Arcsecond,
         Degree,
         Gradian,
-        MinuteOfArc,
         Radian,
-        SecondOfArc,
     }
 }
diff --git a/UnitsNet/GeneratedCode/Enums/MassFlowUnit.g.cs b/UnitsNet/GeneratedCode/Enums/MassFlowUnit.g.cs
index 1f7887259e..a5e9c951ce 100644
--- a/UnitsNet/GeneratedCode/Enums/MassFlowUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Enums/MassFlowUnit.g.cs
@@ -25,7 +25,7 @@ namespace UnitsNet.Units
     public enum MassFlowUnit
     {
         Undefined = 0,
-        KiloGramPerSecond,
+        KilogramPerSecond,
         TonnePerDay,
     }
 }
diff --git a/UnitsNet/GeneratedCode/Enums/SpecificEnergyUnit.g.cs b/UnitsNet/GeneratedCode/Enums/SpecificEnergyUnit.g.cs
index 09eeb9b8da..f20d5d3a71 100644
--- a/UnitsNet/GeneratedCode/Enums/SpecificEnergyUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Enums/SpecificEnergyUnit.g.cs
@@ -25,12 +25,13 @@ namespace UnitsNet.Units
     public enum SpecificEnergyUnit
     {
         Undefined = 0,
-        JoulePerKiloGram,
-        KiloCaloriePerGram,
-        KilojoulePerKiloGram,
-        KilowattHourPerKiloGram,
-        MegajoulePerKiloGram,
-        MegawattHourPerKiloGram,
-        WattHourPerKiloGram,
+        CaloriePerGram,
+        JoulePerKilogram,
+        KilocaloriePerGram,
+        KilojoulePerKilogram,
+        KilowattHourPerKilogram,
+        MegajoulePerKilogram,
+        MegawattHourPerKilogram,
+        WattHourPerKilogram,
     }
 }
diff --git a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs
index 9f16981d83..e1249c9a44 100644
--- a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs
+++ b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs
@@ -55,43 +55,43 @@ public static AngleUnit BaseUnit
         }
 
         /// <summary>
-        ///     Get Angle in Degrees.
+        ///     Get Angle in Arcminutes.
         /// </summary>
-        public double Degrees
+        public double Arcminutes
         {
-            get { return _degrees; }
+            get { return _degrees*60; }
         }
 
         /// <summary>
-        ///     Get Angle in Gradians.
+        ///     Get Angle in Arcseconds.
         /// </summary>
-        public double Gradians
+        public double Arcseconds
         {
-            get { return _degrees/0.9; }
+            get { return _degrees*3600; }
         }
 
         /// <summary>
-        ///     Get Angle in MinutesOfArc.
+        ///     Get Angle in Degrees.
         /// </summary>
-        public double MinutesOfArc
+        public double Degrees
         {
-            get { return _degrees*60; }
+            get { return _degrees; }
         }
 
         /// <summary>
-        ///     Get Angle in Radians.
+        ///     Get Angle in Gradians.
         /// </summary>
-        public double Radians
+        public double Gradians
         {
-            get { return _degrees/180*Math.PI; }
+            get { return _degrees/0.9; }
         }
 
         /// <summary>
-        ///     Get Angle in SecondsOfArc.
+        ///     Get Angle in Radians.
         /// </summary>
-        public double SecondsOfArc
+        public double Radians
         {
-            get { return _degrees*3600; }
+            get { return _degrees/180*Math.PI; }
         }
 
         #endregion
@@ -104,43 +104,43 @@ public static Angle Zero
         }
 
         /// <summary>
-        ///     Get Angle from Degrees.
+        ///     Get Angle from Arcminutes.
         /// </summary>
-        public static Angle FromDegrees(double degrees)
+        public static Angle FromArcminutes(double arcminutes)
         {
-            return new Angle(degrees);
+            return new Angle(arcminutes/60);
         }
 
         /// <summary>
-        ///     Get Angle from Gradians.
+        ///     Get Angle from Arcseconds.
         /// </summary>
-        public static Angle FromGradians(double gradians)
+        public static Angle FromArcseconds(double arcseconds)
         {
-            return new Angle(gradians*0.9);
+            return new Angle(arcseconds/3600);
         }
 
         /// <summary>
-        ///     Get Angle from MinutesOfArc.
+        ///     Get Angle from Degrees.
         /// </summary>
-        public static Angle FromMinutesOfArc(double minutesofarc)
+        public static Angle FromDegrees(double degrees)
         {
-            return new Angle(minutesofarc/60);
+            return new Angle(degrees);
         }
 
         /// <summary>
-        ///     Get Angle from Radians.
+        ///     Get Angle from Gradians.
         /// </summary>
-        public static Angle FromRadians(double radians)
+        public static Angle FromGradians(double gradians)
         {
-            return new Angle(radians*180/Math.PI);
+            return new Angle(gradians*0.9);
         }
 
         /// <summary>
-        ///     Get Angle from SecondsOfArc.
+        ///     Get Angle from Radians.
         /// </summary>
-        public static Angle FromSecondsOfArc(double secondsofarc)
+        public static Angle FromRadians(double radians)
         {
-            return new Angle(secondsofarc/3600);
+            return new Angle(radians*180/Math.PI);
         }
 
 
@@ -154,16 +154,16 @@ public static Angle From(double value, AngleUnit fromUnit)
         {
             switch (fromUnit)
             {
+                case AngleUnit.Arcminute:
+                    return FromArcminutes(value);
+                case AngleUnit.Arcsecond:
+                    return FromArcseconds(value);
                 case AngleUnit.Degree:
                     return FromDegrees(value);
                 case AngleUnit.Gradian:
                     return FromGradians(value);
-                case AngleUnit.MinuteOfArc:
-                    return FromMinutesOfArc(value);
                 case AngleUnit.Radian:
                     return FromRadians(value);
-                case AngleUnit.SecondOfArc:
-                    return FromSecondsOfArc(value);
 
                 default:
                     throw new NotImplementedException("fromUnit: " + fromUnit);
@@ -297,16 +297,16 @@ public double As(AngleUnit unit)
         {
             switch (unit)
             {
+                case AngleUnit.Arcminute:
+                    return Arcminutes;
+                case AngleUnit.Arcsecond:
+                    return Arcseconds;
                 case AngleUnit.Degree:
                     return Degrees;
                 case AngleUnit.Gradian:
                     return Gradians;
-                case AngleUnit.MinuteOfArc:
-                    return MinutesOfArc;
                 case AngleUnit.Radian:
                     return Radians;
-                case AngleUnit.SecondOfArc:
-                    return SecondsOfArc;
 
                 default:
                     throw new NotImplementedException("unit: " + unit);
diff --git a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs
index d3b0e38bb4..57429539c2 100644
--- a/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs
+++ b/UnitsNet/GeneratedCode/UnitClasses/MassFlow.g.cs
@@ -40,26 +40,26 @@ public partial struct MassFlow : IComparable, IComparable<MassFlow>
         /// <summary>
         ///     Base unit of MassFlow.
         /// </summary>
-        private readonly double _kiloGramsPerSecond;
+        private readonly double _kilogramsPerSecond;
 
         public MassFlow(double kilogramspersecond) : this()
         {
-            _kiloGramsPerSecond = kilogramspersecond;
+            _kilogramsPerSecond = kilogramspersecond;
         }
 
         #region Properties
 
         public static MassFlowUnit BaseUnit
         {
-            get { return MassFlowUnit.KiloGramPerSecond; }
+            get { return MassFlowUnit.KilogramPerSecond; }
         }
 
         /// <summary>
-        ///     Get MassFlow in KiloGramsPerSecond.
+        ///     Get MassFlow in KilogramsPerSecond.
         /// </summary>
-        public double KiloGramsPerSecond
+        public double KilogramsPerSecond
         {
-            get { return _kiloGramsPerSecond; }
+            get { return _kilogramsPerSecond; }
         }
 
         /// <summary>
@@ -67,7 +67,7 @@ public double KiloGramsPerSecond
         /// </summary>
         public double TonnesPerDay
         {
-            get { return _kiloGramsPerSecond/86.4000; }
+            get { return _kilogramsPerSecond/86.4000; }
         }
 
         #endregion
@@ -80,9 +80,9 @@ public static MassFlow Zero
         }
 
         /// <summary>
-        ///     Get MassFlow from KiloGramsPerSecond.
+        ///     Get MassFlow from KilogramsPerSecond.
         /// </summary>
-        public static MassFlow FromKiloGramsPerSecond(double kilogramspersecond)
+        public static MassFlow FromKilogramsPerSecond(double kilogramspersecond)
         {
             return new MassFlow(kilogramspersecond);
         }
@@ -106,8 +106,8 @@ public static MassFlow From(double value, MassFlowUnit fromUnit)
         {
             switch (fromUnit)
             {
-                case MassFlowUnit.KiloGramPerSecond:
-                    return FromKiloGramsPerSecond(value);
+                case MassFlowUnit.KilogramPerSecond:
+                    return FromKilogramsPerSecond(value);
                 case MassFlowUnit.TonnePerDay:
                     return FromTonnesPerDay(value);
 
@@ -134,37 +134,37 @@ public static string GetAbbreviation(MassFlowUnit unit, CultureInfo culture = nu
 
         public static MassFlow operator -(MassFlow right)
         {
-            return new MassFlow(-right._kiloGramsPerSecond);
+            return new MassFlow(-right._kilogramsPerSecond);
         }
 
         public static MassFlow operator +(MassFlow left, MassFlow right)
         {
-            return new MassFlow(left._kiloGramsPerSecond + right._kiloGramsPerSecond);
+            return new MassFlow(left._kilogramsPerSecond + right._kilogramsPerSecond);
         }
 
         public static MassFlow operator -(MassFlow left, MassFlow right)
         {
-            return new MassFlow(left._kiloGramsPerSecond - right._kiloGramsPerSecond);
+            return new MassFlow(left._kilogramsPerSecond - right._kilogramsPerSecond);
         }
 
         public static MassFlow operator *(double left, MassFlow right)
         {
-            return new MassFlow(left*right._kiloGramsPerSecond);
+            return new MassFlow(left*right._kilogramsPerSecond);
         }
 
         public static MassFlow operator *(MassFlow left, double right)
         {
-            return new MassFlow(left._kiloGramsPerSecond*(double)right);
+            return new MassFlow(left._kilogramsPerSecond*(double)right);
         }
 
         public static MassFlow operator /(MassFlow left, double right)
         {
-            return new MassFlow(left._kiloGramsPerSecond/(double)right);
+            return new MassFlow(left._kilogramsPerSecond/(double)right);
         }
 
         public static double operator /(MassFlow left, MassFlow right)
         {
-            return Convert.ToDouble(left._kiloGramsPerSecond/right._kiloGramsPerSecond);
+            return Convert.ToDouble(left._kilogramsPerSecond/right._kilogramsPerSecond);
         }
 
         #endregion
@@ -180,39 +180,39 @@ public int CompareTo(object obj)
 
         public int CompareTo(MassFlow other)
         {
-            return _kiloGramsPerSecond.CompareTo(other._kiloGramsPerSecond);
+            return _kilogramsPerSecond.CompareTo(other._kilogramsPerSecond);
         }
 
         public static bool operator <=(MassFlow left, MassFlow right)
         {
-            return left._kiloGramsPerSecond <= right._kiloGramsPerSecond;
+            return left._kilogramsPerSecond <= right._kilogramsPerSecond;
         }
 
         public static bool operator >=(MassFlow left, MassFlow right)
         {
-            return left._kiloGramsPerSecond >= right._kiloGramsPerSecond;
+            return left._kilogramsPerSecond >= right._kilogramsPerSecond;
         }
 
         public static bool operator <(MassFlow left, MassFlow right)
         {
-            return left._kiloGramsPerSecond < right._kiloGramsPerSecond;
+            return left._kilogramsPerSecond < right._kilogramsPerSecond;
         }
 
         public static bool operator >(MassFlow left, MassFlow right)
         {
-            return left._kiloGramsPerSecond > right._kiloGramsPerSecond;
+            return left._kilogramsPerSecond > right._kilogramsPerSecond;
         }
 
         public static bool operator ==(MassFlow left, MassFlow right)
         {
             // ReSharper disable once CompareOfFloatsByEqualityOperator
-            return left._kiloGramsPerSecond == right._kiloGramsPerSecond;
+            return left._kilogramsPerSecond == right._kilogramsPerSecond;
         }
 
         public static bool operator !=(MassFlow left, MassFlow right)
         {
             // ReSharper disable once CompareOfFloatsByEqualityOperator
-            return left._kiloGramsPerSecond != right._kiloGramsPerSecond;
+            return left._kilogramsPerSecond != right._kilogramsPerSecond;
         }
 
         public override bool Equals(object obj)
@@ -222,12 +222,12 @@ public override bool Equals(object obj)
                 return false;
             }
 
-            return _kiloGramsPerSecond.Equals(((MassFlow) obj)._kiloGramsPerSecond);
+            return _kilogramsPerSecond.Equals(((MassFlow) obj)._kilogramsPerSecond);
         }
 
         public override int GetHashCode()
         {
-            return _kiloGramsPerSecond.GetHashCode();
+            return _kilogramsPerSecond.GetHashCode();
         }
 
         #endregion
@@ -243,8 +243,8 @@ public double As(MassFlowUnit unit)
         {
             switch (unit)
             {
-                case MassFlowUnit.KiloGramPerSecond:
-                    return KiloGramsPerSecond;
+                case MassFlowUnit.KilogramPerSecond:
+                    return KilogramsPerSecond;
                 case MassFlowUnit.TonnePerDay:
                     return TonnesPerDay;
 
@@ -379,7 +379,7 @@ public static MassFlowUnit ParseUnit(string str, IFormatProvider formatProvider
         /// <returns>String representation.</returns>
         public override string ToString()
         {
-            return ToString(MassFlowUnit.KiloGramPerSecond);
+            return ToString(MassFlowUnit.KilogramPerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs
index 447ce6b37e..6482241d60 100644
--- a/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/UnitClasses/SpecificEnergy.g.cs
@@ -40,74 +40,82 @@ public partial struct SpecificEnergy : IComparable, IComparable<SpecificEnergy>
         /// <summary>
         ///     Base unit of SpecificEnergy.
         /// </summary>
-        private readonly double _joulesPerKiloGram;
+        private readonly double _joulesPerKilogram;
 
         public SpecificEnergy(double joulesperkilogram) : this()
         {
-            _joulesPerKiloGram = joulesperkilogram;
+            _joulesPerKilogram = joulesperkilogram;
         }
 
         #region Properties
 
         public static SpecificEnergyUnit BaseUnit
         {
-            get { return SpecificEnergyUnit.JoulePerKiloGram; }
+            get { return SpecificEnergyUnit.JoulePerKilogram; }
         }
 
         /// <summary>
-        ///     Get SpecificEnergy in JoulesPerKiloGram.
+        ///     Get SpecificEnergy in CaloriesPerGram.
         /// </summary>
-        public double JoulesPerKiloGram
+        public double CaloriesPerGram
         {
-            get { return _joulesPerKiloGram; }
+            get { return _joulesPerKilogram/4.184e3; }
         }
 
         /// <summary>
-        ///     Get SpecificEnergy in KiloCaloriesPerGram.
+        ///     Get SpecificEnergy in JoulesPerKilogram.
         /// </summary>
-        public double KiloCaloriesPerGram
+        public double JoulesPerKilogram
         {
-            get { return _joulesPerKiloGram/4.184e6; }
+            get { return _joulesPerKilogram; }
         }
 
         /// <summary>
-        ///     Get SpecificEnergy in KilojoulesPerKiloGram.
+        ///     Get SpecificEnergy in KilocaloriesPerGram.
         /// </summary>
-        public double KilojoulesPerKiloGram
+        public double KilocaloriesPerGram
         {
-            get { return (_joulesPerKiloGram) / 1e3d; }
+            get { return (_joulesPerKilogram/4.184e3) / 1e3d; }
         }
 
         /// <summary>
-        ///     Get SpecificEnergy in KilowattHoursPerKiloGram.
+        ///     Get SpecificEnergy in KilojoulesPerKilogram.
         /// </summary>
-        public double KilowattHoursPerKiloGram
+        public double KilojoulesPerKilogram
         {
-            get { return (_joulesPerKiloGram/3.6e3) / 1e3d; }
+            get { return (_joulesPerKilogram) / 1e3d; }
         }
 
         /// <summary>
-        ///     Get SpecificEnergy in MegajoulesPerKiloGram.
+        ///     Get SpecificEnergy in KilowattHoursPerKilogram.
         /// </summary>
-        public double MegajoulesPerKiloGram
+        public double KilowattHoursPerKilogram
         {
-            get { return (_joulesPerKiloGram) / 1e6d; }
+            get { return (_joulesPerKilogram/3.6e3) / 1e3d; }
         }
 
         /// <summary>
-        ///     Get SpecificEnergy in MegawattHoursPerKiloGram.
+        ///     Get SpecificEnergy in MegajoulesPerKilogram.
         /// </summary>
-        public double MegawattHoursPerKiloGram
+        public double MegajoulesPerKilogram
         {
-            get { return (_joulesPerKiloGram/3.6e3) / 1e6d; }
+            get { return (_joulesPerKilogram) / 1e6d; }
         }
 
         /// <summary>
-        ///     Get SpecificEnergy in WattHoursPerKiloGram.
+        ///     Get SpecificEnergy in MegawattHoursPerKilogram.
         /// </summary>
-        public double WattHoursPerKiloGram
+        public double MegawattHoursPerKilogram
         {
-            get { return _joulesPerKiloGram/3.6e3; }
+            get { return (_joulesPerKilogram/3.6e3) / 1e6d; }
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy in WattHoursPerKilogram.
+        /// </summary>
+        public double WattHoursPerKilogram
+        {
+            get { return _joulesPerKilogram/3.6e3; }
         }
 
         #endregion
@@ -120,57 +128,65 @@ public static SpecificEnergy Zero
         }
 
         /// <summary>
-        ///     Get SpecificEnergy from JoulesPerKiloGram.
+        ///     Get SpecificEnergy from CaloriesPerGram.
+        /// </summary>
+        public static SpecificEnergy FromCaloriesPerGram(double caloriespergram)
+        {
+            return new SpecificEnergy(caloriespergram*4.184e3);
+        }
+
+        /// <summary>
+        ///     Get SpecificEnergy from JoulesPerKilogram.
         /// </summary>
-        public static SpecificEnergy FromJoulesPerKiloGram(double joulesperkilogram)
+        public static SpecificEnergy FromJoulesPerKilogram(double joulesperkilogram)
         {
             return new SpecificEnergy(joulesperkilogram);
         }
 
         /// <summary>
-        ///     Get SpecificEnergy from KiloCaloriesPerGram.
+        ///     Get SpecificEnergy from KilocaloriesPerGram.
         /// </summary>
-        public static SpecificEnergy FromKiloCaloriesPerGram(double kilocaloriespergram)
+        public static SpecificEnergy FromKilocaloriesPerGram(double kilocaloriespergram)
         {
-            return new SpecificEnergy(kilocaloriespergram*4.184e6);
+            return new SpecificEnergy((kilocaloriespergram*4.184e3) * 1e3d);
         }
 
         /// <summary>
-        ///     Get SpecificEnergy from KilojoulesPerKiloGram.
+        ///     Get SpecificEnergy from KilojoulesPerKilogram.
         /// </summary>
-        public static SpecificEnergy FromKilojoulesPerKiloGram(double kilojoulesperkilogram)
+        public static SpecificEnergy FromKilojoulesPerKilogram(double kilojoulesperkilogram)
         {
             return new SpecificEnergy((kilojoulesperkilogram) * 1e3d);
         }
 
         /// <summary>
-        ///     Get SpecificEnergy from KilowattHoursPerKiloGram.
+        ///     Get SpecificEnergy from KilowattHoursPerKilogram.
         /// </summary>
-        public static SpecificEnergy FromKilowattHoursPerKiloGram(double kilowatthoursperkilogram)
+        public static SpecificEnergy FromKilowattHoursPerKilogram(double kilowatthoursperkilogram)
         {
             return new SpecificEnergy((kilowatthoursperkilogram*3.6e3) * 1e3d);
         }
 
         /// <summary>
-        ///     Get SpecificEnergy from MegajoulesPerKiloGram.
+        ///     Get SpecificEnergy from MegajoulesPerKilogram.
         /// </summary>
-        public static SpecificEnergy FromMegajoulesPerKiloGram(double megajoulesperkilogram)
+        public static SpecificEnergy FromMegajoulesPerKilogram(double megajoulesperkilogram)
         {
             return new SpecificEnergy((megajoulesperkilogram) * 1e6d);
         }
 
         /// <summary>
-        ///     Get SpecificEnergy from MegawattHoursPerKiloGram.
+        ///     Get SpecificEnergy from MegawattHoursPerKilogram.
         /// </summary>
-        public static SpecificEnergy FromMegawattHoursPerKiloGram(double megawatthoursperkilogram)
+        public static SpecificEnergy FromMegawattHoursPerKilogram(double megawatthoursperkilogram)
         {
             return new SpecificEnergy((megawatthoursperkilogram*3.6e3) * 1e6d);
         }
 
         /// <summary>
-        ///     Get SpecificEnergy from WattHoursPerKiloGram.
+        ///     Get SpecificEnergy from WattHoursPerKilogram.
         /// </summary>
-        public static SpecificEnergy FromWattHoursPerKiloGram(double watthoursperkilogram)
+        public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogram)
         {
             return new SpecificEnergy(watthoursperkilogram*3.6e3);
         }
@@ -186,20 +202,22 @@ public static SpecificEnergy From(double value, SpecificEnergyUnit fromUnit)
         {
             switch (fromUnit)
             {
-                case SpecificEnergyUnit.JoulePerKiloGram:
-                    return FromJoulesPerKiloGram(value);
-                case SpecificEnergyUnit.KiloCaloriePerGram:
-                    return FromKiloCaloriesPerGram(value);
-                case SpecificEnergyUnit.KilojoulePerKiloGram:
-                    return FromKilojoulesPerKiloGram(value);
-                case SpecificEnergyUnit.KilowattHourPerKiloGram:
-                    return FromKilowattHoursPerKiloGram(value);
-                case SpecificEnergyUnit.MegajoulePerKiloGram:
-                    return FromMegajoulesPerKiloGram(value);
-                case SpecificEnergyUnit.MegawattHourPerKiloGram:
-                    return FromMegawattHoursPerKiloGram(value);
-                case SpecificEnergyUnit.WattHourPerKiloGram:
-                    return FromWattHoursPerKiloGram(value);
+                case SpecificEnergyUnit.CaloriePerGram:
+                    return FromCaloriesPerGram(value);
+                case SpecificEnergyUnit.JoulePerKilogram:
+                    return FromJoulesPerKilogram(value);
+                case SpecificEnergyUnit.KilocaloriePerGram:
+                    return FromKilocaloriesPerGram(value);
+                case SpecificEnergyUnit.KilojoulePerKilogram:
+                    return FromKilojoulesPerKilogram(value);
+                case SpecificEnergyUnit.KilowattHourPerKilogram:
+                    return FromKilowattHoursPerKilogram(value);
+                case SpecificEnergyUnit.MegajoulePerKilogram:
+                    return FromMegajoulesPerKilogram(value);
+                case SpecificEnergyUnit.MegawattHourPerKilogram:
+                    return FromMegawattHoursPerKilogram(value);
+                case SpecificEnergyUnit.WattHourPerKilogram:
+                    return FromWattHoursPerKilogram(value);
 
                 default:
                     throw new NotImplementedException("fromUnit: " + fromUnit);
@@ -224,37 +242,37 @@ public static string GetAbbreviation(SpecificEnergyUnit unit, CultureInfo cultur
 
         public static SpecificEnergy operator -(SpecificEnergy right)
         {
-            return new SpecificEnergy(-right._joulesPerKiloGram);
+            return new SpecificEnergy(-right._joulesPerKilogram);
         }
 
         public static SpecificEnergy operator +(SpecificEnergy left, SpecificEnergy right)
         {
-            return new SpecificEnergy(left._joulesPerKiloGram + right._joulesPerKiloGram);
+            return new SpecificEnergy(left._joulesPerKilogram + right._joulesPerKilogram);
         }
 
         public static SpecificEnergy operator -(SpecificEnergy left, SpecificEnergy right)
         {
-            return new SpecificEnergy(left._joulesPerKiloGram - right._joulesPerKiloGram);
+            return new SpecificEnergy(left._joulesPerKilogram - right._joulesPerKilogram);
         }
 
         public static SpecificEnergy operator *(double left, SpecificEnergy right)
         {
-            return new SpecificEnergy(left*right._joulesPerKiloGram);
+            return new SpecificEnergy(left*right._joulesPerKilogram);
         }
 
         public static SpecificEnergy operator *(SpecificEnergy left, double right)
         {
-            return new SpecificEnergy(left._joulesPerKiloGram*(double)right);
+            return new SpecificEnergy(left._joulesPerKilogram*(double)right);
         }
 
         public static SpecificEnergy operator /(SpecificEnergy left, double right)
         {
-            return new SpecificEnergy(left._joulesPerKiloGram/(double)right);
+            return new SpecificEnergy(left._joulesPerKilogram/(double)right);
         }
 
         public static double operator /(SpecificEnergy left, SpecificEnergy right)
         {
-            return Convert.ToDouble(left._joulesPerKiloGram/right._joulesPerKiloGram);
+            return Convert.ToDouble(left._joulesPerKilogram/right._joulesPerKilogram);
         }
 
         #endregion
@@ -270,39 +288,39 @@ public int CompareTo(object obj)
 
         public int CompareTo(SpecificEnergy other)
         {
-            return _joulesPerKiloGram.CompareTo(other._joulesPerKiloGram);
+            return _joulesPerKilogram.CompareTo(other._joulesPerKilogram);
         }
 
         public static bool operator <=(SpecificEnergy left, SpecificEnergy right)
         {
-            return left._joulesPerKiloGram <= right._joulesPerKiloGram;
+            return left._joulesPerKilogram <= right._joulesPerKilogram;
         }
 
         public static bool operator >=(SpecificEnergy left, SpecificEnergy right)
         {
-            return left._joulesPerKiloGram >= right._joulesPerKiloGram;
+            return left._joulesPerKilogram >= right._joulesPerKilogram;
         }
 
         public static bool operator <(SpecificEnergy left, SpecificEnergy right)
         {
-            return left._joulesPerKiloGram < right._joulesPerKiloGram;
+            return left._joulesPerKilogram < right._joulesPerKilogram;
         }
 
         public static bool operator >(SpecificEnergy left, SpecificEnergy right)
         {
-            return left._joulesPerKiloGram > right._joulesPerKiloGram;
+            return left._joulesPerKilogram > right._joulesPerKilogram;
         }
 
         public static bool operator ==(SpecificEnergy left, SpecificEnergy right)
         {
             // ReSharper disable once CompareOfFloatsByEqualityOperator
-            return left._joulesPerKiloGram == right._joulesPerKiloGram;
+            return left._joulesPerKilogram == right._joulesPerKilogram;
         }
 
         public static bool operator !=(SpecificEnergy left, SpecificEnergy right)
         {
             // ReSharper disable once CompareOfFloatsByEqualityOperator
-            return left._joulesPerKiloGram != right._joulesPerKiloGram;
+            return left._joulesPerKilogram != right._joulesPerKilogram;
         }
 
         public override bool Equals(object obj)
@@ -312,12 +330,12 @@ public override bool Equals(object obj)
                 return false;
             }
 
-            return _joulesPerKiloGram.Equals(((SpecificEnergy) obj)._joulesPerKiloGram);
+            return _joulesPerKilogram.Equals(((SpecificEnergy) obj)._joulesPerKilogram);
         }
 
         public override int GetHashCode()
         {
-            return _joulesPerKiloGram.GetHashCode();
+            return _joulesPerKilogram.GetHashCode();
         }
 
         #endregion
@@ -333,20 +351,22 @@ public double As(SpecificEnergyUnit unit)
         {
             switch (unit)
             {
-                case SpecificEnergyUnit.JoulePerKiloGram:
-                    return JoulesPerKiloGram;
-                case SpecificEnergyUnit.KiloCaloriePerGram:
-                    return KiloCaloriesPerGram;
-                case SpecificEnergyUnit.KilojoulePerKiloGram:
-                    return KilojoulesPerKiloGram;
-                case SpecificEnergyUnit.KilowattHourPerKiloGram:
-                    return KilowattHoursPerKiloGram;
-                case SpecificEnergyUnit.MegajoulePerKiloGram:
-                    return MegajoulesPerKiloGram;
-                case SpecificEnergyUnit.MegawattHourPerKiloGram:
-                    return MegawattHoursPerKiloGram;
-                case SpecificEnergyUnit.WattHourPerKiloGram:
-                    return WattHoursPerKiloGram;
+                case SpecificEnergyUnit.CaloriePerGram:
+                    return CaloriesPerGram;
+                case SpecificEnergyUnit.JoulePerKilogram:
+                    return JoulesPerKilogram;
+                case SpecificEnergyUnit.KilocaloriePerGram:
+                    return KilocaloriesPerGram;
+                case SpecificEnergyUnit.KilojoulePerKilogram:
+                    return KilojoulesPerKilogram;
+                case SpecificEnergyUnit.KilowattHourPerKilogram:
+                    return KilowattHoursPerKilogram;
+                case SpecificEnergyUnit.MegajoulePerKilogram:
+                    return MegajoulesPerKilogram;
+                case SpecificEnergyUnit.MegawattHourPerKilogram:
+                    return MegawattHoursPerKilogram;
+                case SpecificEnergyUnit.WattHourPerKilogram:
+                    return WattHoursPerKilogram;
 
                 default:
                     throw new NotImplementedException("unit: " + unit);
@@ -479,7 +499,7 @@ public static SpecificEnergyUnit ParseUnit(string str, IFormatProvider formatPro
         /// <returns>String representation.</returns>
         public override string ToString()
         {
-            return ToString(SpecificEnergyUnit.JoulePerKiloGram);
+            return ToString(SpecificEnergyUnit.JoulePerKilogram);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs
index a34d158079..05b95214f1 100644
--- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs
+++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs
@@ -95,6 +95,16 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                 new UnitLocalization(typeof (AngleUnit),
                     new[]
                     {
+                        new CulturesForEnumValue((int) AngleUnit.Arcminute,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "'", "arcmin"),
+                            }),
+                        new CulturesForEnumValue((int) AngleUnit.Arcsecond,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "″", "arcsec"),
+                            }),
                         new CulturesForEnumValue((int) AngleUnit.Degree,
                             new[]
                             {
@@ -107,22 +117,12 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                                 new AbbreviationsForCulture("en-US", "g"),
                                 new AbbreviationsForCulture("ru-RU", "g"),
                             }),
-                        new CulturesForEnumValue((int) AngleUnit.MinuteOfArc,
-                            new[]
-                            {
-                                new AbbreviationsForCulture("en-US", "'", "min"),
-                            }),
                         new CulturesForEnumValue((int) AngleUnit.Radian,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "rad"),
                                 new AbbreviationsForCulture("ru-RU", "рад"),
                             }),
-                        new CulturesForEnumValue((int) AngleUnit.SecondOfArc,
-                            new[]
-                            {
-                                new AbbreviationsForCulture("en-US", "″", "sec"),
-                            }),
                     }),
                 new UnitLocalization(typeof (AreaUnit),
                     new[]
@@ -973,7 +973,7 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                 new UnitLocalization(typeof (MassFlowUnit),
                     new[]
                     {
-                        new CulturesForEnumValue((int) MassFlowUnit.KiloGramPerSecond,
+                        new CulturesForEnumValue((int) MassFlowUnit.KilogramPerSecond,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "kg/s"),
@@ -1335,37 +1335,42 @@ private static readonly ReadOnlyCollection<UnitLocalization> DefaultLocalization
                 new UnitLocalization(typeof (SpecificEnergyUnit),
                     new[]
                     {
-                        new CulturesForEnumValue((int) SpecificEnergyUnit.JoulePerKiloGram,
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.CaloriePerGram,
+                            new[]
+                            {
+                                new AbbreviationsForCulture("en-US", "cal/g"),
+                            }),
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.JoulePerKilogram,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "J/kg"),
                             }),
-                        new CulturesForEnumValue((int) SpecificEnergyUnit.KiloCaloriePerGram,
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.KilocaloriePerGram,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "kcal/g"),
                             }),
-                        new CulturesForEnumValue((int) SpecificEnergyUnit.KilojoulePerKiloGram,
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.KilojoulePerKilogram,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "kJ/kg"),
                             }),
-                        new CulturesForEnumValue((int) SpecificEnergyUnit.KilowattHourPerKiloGram,
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.KilowattHourPerKilogram,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "kWh/kg"),
                             }),
-                        new CulturesForEnumValue((int) SpecificEnergyUnit.MegajoulePerKiloGram,
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.MegajoulePerKilogram,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "MJ/kg"),
                             }),
-                        new CulturesForEnumValue((int) SpecificEnergyUnit.MegawattHourPerKiloGram,
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.MegawattHourPerKilogram,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "MWh/kg"),
                             }),
-                        new CulturesForEnumValue((int) SpecificEnergyUnit.WattHourPerKiloGram,
+                        new CulturesForEnumValue((int) SpecificEnergyUnit.WattHourPerKilogram,
                             new[]
                             {
                                 new AbbreviationsForCulture("en-US", "Wh/kg"),
diff --git a/UnitsNet/Scripts/UnitDefinitions/Angle.json b/UnitsNet/Scripts/UnitDefinitions/Angle.json
index 0900738be8..62757a6b63 100644
--- a/UnitsNet/Scripts/UnitDefinitions/Angle.json
+++ b/UnitsNet/Scripts/UnitDefinitions/Angle.json
@@ -36,26 +36,26 @@
             ]
         },
 		{
-            "SingularName": "MinuteOfArc",
-            "PluralName": "MinutesOfArc",
+            "SingularName": "Arcminute",
+            "PluralName": "Arcminutes",
             "FromUnitToBaseFunc": "x/60",
             "FromBaseToUnitFunc": "x*60",
             "Localization": [
                 {
                     "Culture": "en-US",
-                    "Abbreviations": ["'", "min"]
+                    "Abbreviations": ["'", "arcmin"]
                 }
             ]
         },
 		{
-            "SingularName": "SecondOfArc",
-            "PluralName": "SecondsOfArc",
+            "SingularName": "Arcsecond",
+            "PluralName": "Arcseconds",
             "FromUnitToBaseFunc": "x/3600",
             "FromBaseToUnitFunc": "x*3600",
             "Localization": [
                 {
                     "Culture": "en-US",
-                    "Abbreviations": ["″", "sec"]
+                    "Abbreviations": ["″", "arcsec"]
                 }
             ]
         },
diff --git a/UnitsNet/Scripts/UnitDefinitions/MassFlow.json b/UnitsNet/Scripts/UnitDefinitions/MassFlow.json
index 436802c78c..e36fe0eedc 100644
--- a/UnitsNet/Scripts/UnitDefinitions/MassFlow.json
+++ b/UnitsNet/Scripts/UnitDefinitions/MassFlow.json
@@ -4,8 +4,8 @@
     "XmlDoc": "",
     "Units": [
         {
-            "SingularName": "KiloGramPerSecond",
-            "PluralName": "KiloGramsPerSecond",
+            "SingularName": "KilogramPerSecond",
+            "PluralName": "KilogramsPerSecond",
             "FromUnitToBaseFunc": "x",
             "FromBaseToUnitFunc": "x",
             "Localization": [
diff --git a/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json b/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json
index de3719cb6c..efcc0ef30c 100644
--- a/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json
+++ b/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json
@@ -5,8 +5,8 @@
 	"XmlDocRemarks": "https://en.wikipedia.org/wiki/Specific_energy",
     "Units": [
         {
-            "SingularName": "JoulePerKiloGram",
-            "PluralName": "JoulesPerKiloGram",
+            "SingularName": "JoulePerKilogram",
+            "PluralName": "JoulesPerKilogram",
             "FromUnitToBaseFunc": "x",
             "FromBaseToUnitFunc": "x",
             "Prefixes": ["Kilo","Mega"],
@@ -18,20 +18,21 @@
             ]
         },
 		{
-            "SingularName": "KiloCaloriePerGram",
-            "PluralName": "KiloCaloriesPerGram",
-            "FromUnitToBaseFunc": "x*4.184e6",
-            "FromBaseToUnitFunc": "x/4.184e6",
+            "SingularName": "CaloriePerGram",
+            "PluralName": "CaloriesPerGram",
+            "FromUnitToBaseFunc": "x*4.184e3",
+            "FromBaseToUnitFunc": "x/4.184e3",
+			"Prefixes": ["Kilo"],
             "Localization": [
                 {
                     "Culture": "en-US",
-                    "Abbreviations": ["kcal/g"]
+                    "Abbreviations": ["cal/g"]
                 }
             ]
 		},
 		{
-            "SingularName": "WattHourPerKiloGram",
-            "PluralName": "WattHoursPerKiloGram",
+            "SingularName": "WattHourPerKilogram",
+            "PluralName": "WattHoursPerKilogram",
             "FromUnitToBaseFunc": "x*3.6e3",
             "FromBaseToUnitFunc": "x/3.6e3",
             "Prefixes": ["Kilo","Mega"],

From 27f8de78b80c3705c7b9f489f783df31bf6f28d3 Mon Sep 17 00:00:00 2001
From: ulflind <ulf.lindberg@stormgeo.com>
Date: Wed, 23 Dec 2015 10:05:44 +0100
Subject: [PATCH 05/10] Fix

---
 UnitsNet.Tests/CustomCode/AngleTests.cs | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/UnitsNet.Tests/CustomCode/AngleTests.cs b/UnitsNet.Tests/CustomCode/AngleTests.cs
index d7c08ae602..71675efc84 100644
--- a/UnitsNet.Tests/CustomCode/AngleTests.cs
+++ b/UnitsNet.Tests/CustomCode/AngleTests.cs
@@ -59,25 +59,11 @@ protected override double GradiansInOneDegree
             get { return 400/360.0; }
         }
 
-        protected override double MinutesOfArcInOneDegree
-        {
-            get
-            {
-                return 60.0;
-            }
-        }
 
         protected override double RadiansInOneDegree
         {
             get { return Math.PI/2/90; }
         }
 
-        protected override double SecondsOfArcInOneDegree
-        {
-            get
-            {
-                return 3600.0;
-            }
-        }
     }
 }
\ No newline at end of file

From 8f982871b2720be90536a5134a5f8abd8af94043 Mon Sep 17 00:00:00 2001
From: ulflind <ulf.lindberg@stormgeo.com>
Date: Wed, 23 Dec 2015 14:49:28 +0100
Subject: [PATCH 06/10] Added operators

---
 UnitsNet.Tests/CustomCode/AreaTests.cs        |  9 ++++++
 UnitsNet.Tests/CustomCode/ForceTests.cs       | 25 +++++++++++++++
 UnitsNet.Tests/CustomCode/MassFlowTests.cs    | 17 +++++++++-
 UnitsNet.Tests/CustomCode/MassTests.cs        |  8 +++++
 UnitsNet.Tests/CustomCode/PowerTests.cs       | 32 +++++++++++++++++++
 .../CustomCode/RotationalSpeedTests.cs        |  9 ++++++
 .../CustomCode/SpecificEnergyTests.cs         | 14 ++++++++
 UnitsNet.Tests/CustomCode/TorqueTests.cs      |  6 ++++
 UnitsNet.Tests/CustomCode/VolumeTests.cs      | 12 +++++++
 UnitsNet/CustomCode/UnitClasses/Area.extra.cs | 19 +++++++++++
 .../CustomCode/UnitClasses/Force.extra.cs     | 19 +++++++++++
 UnitsNet/CustomCode/UnitClasses/Mass.extra.cs |  4 +++
 .../CustomCode/UnitClasses/MassFlow.extra.cs  | 22 +++++++++++++
 .../CustomCode/UnitClasses/Power.extra.cs     | 20 ++++++++++++
 .../UnitClasses/RotationalSpeed.extra.cs      | 17 ++++++++++
 .../UnitClasses/SpecificEnergy.extra.cs       | 21 ++++++++++++
 .../CustomCode/UnitClasses/Speed.extra.cs     |  1 +
 .../CustomCode/UnitClasses/Torque.extra.cs    |  4 +++
 .../CustomCode/UnitClasses/Volume.extra.cs    |  9 +++++-
 19 files changed, 266 insertions(+), 2 deletions(-)
 create mode 100644 UnitsNet/CustomCode/UnitClasses/Area.extra.cs
 create mode 100644 UnitsNet/CustomCode/UnitClasses/MassFlow.extra.cs
 create mode 100644 UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs
 create mode 100644 UnitsNet/CustomCode/UnitClasses/SpecificEnergy.extra.cs

diff --git a/UnitsNet.Tests/CustomCode/AreaTests.cs b/UnitsNet.Tests/CustomCode/AreaTests.cs
index 4a91355e63..38800e5045 100644
--- a/UnitsNet.Tests/CustomCode/AreaTests.cs
+++ b/UnitsNet.Tests/CustomCode/AreaTests.cs
@@ -19,10 +19,19 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+using NUnit.Framework;
+
 namespace UnitsNet.Tests.CustomCode
 {
     public class AreaTests : AreaTestsBase
     {
+        [Test]
+        public void AreaDevidedByLengthEqualsLength()
+        {
+            var length = Area.FromSquareMeters(50) / Length.FromMeters(5);
+            Assert.AreEqual(length, Length.FromMeters(10));
+        }
+
         protected override double SquareCentimetersInOneSquareMeter
         {
             get { return 1E4; }
diff --git a/UnitsNet.Tests/CustomCode/ForceTests.cs b/UnitsNet.Tests/CustomCode/ForceTests.cs
index 15d24c10d1..768c0197a4 100644
--- a/UnitsNet.Tests/CustomCode/ForceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ForceTests.cs
@@ -18,11 +18,36 @@
 // 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 NUnit.Framework;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class ForceTests : ForceTestsBase
     {
+        [Test]
+        public void ForceTimesSpeedEqualsPower()
+        {
+            var power = Force.FromNewtons(27.0) * Speed.FromMetersPerSecond(10.0);
+            Assert.AreEqual(power, Power.FromWatts(270));
+        }
+        [Test]
+        public void SpeedTimesForceEqualsPower()
+        {
+            var power = Speed.FromMetersPerSecond(10.0)* Force.FromNewtons(27.0);
+            Assert.AreEqual(power, Power.FromWatts(270));
+        }
+        [Test]
+        public void ForceDevidedByMassEqualsAcceleration()
+        {
+            var acceleration= Force.FromNewtons(27)/Mass.FromKilograms(9);
+            Assert.AreEqual(acceleration, Acceleration.FromMeterPerSecondSquared(3));
+        }
+        [Test]
+        public void ForceDevidedByAreaEqualsPressure()
+        {
+            var pressure=Force.FromNewtons(81)/Area.FromSquareMeters(9);
+            Assert.AreEqual(pressure, Pressure.FromNewtonsPerSquareMeter(9));
+        }
         protected override double DyneInOneNewton
         {
             get { return 1E5; }
diff --git a/UnitsNet.Tests/CustomCode/MassFlowTests.cs b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
index 1b934169b4..411fb01a05 100644
--- a/UnitsNet.Tests/CustomCode/MassFlowTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
@@ -19,13 +19,28 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-
 using System;
+using NUnit.Framework;
+using UnitsNet.Units;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class MassFlowTests : MassFlowTestsBase
     {
+        // strange bug
+        [Test]
+        public void MassFlowTimesTimeSpanEqualsMass()
+        {
+            var mass = MassFlow.FromKilogramsPerSecond(20.0) * TimeSpan.FromSeconds(4.0);
+            Assert.AreEqual(mass, Mass.FromKilograms(80.0));
+        }
+        [Test]
+        public void TimeSpanTimesMassFlowEqualsMass()
+        {
+            var mass = TimeSpan.FromSeconds(4.0) * MassFlow.FromKilogramsPerSecond(20.0);
+            Assert.AreEqual(mass, Mass.FromKilograms(80.0));
+        }
+
         // TODO Override properties in base class here
         protected override double KilogramsPerSecondInOneKilogramPerSecond
         {
diff --git a/UnitsNet.Tests/CustomCode/MassTests.cs b/UnitsNet.Tests/CustomCode/MassTests.cs
index 2971de9dc1..049a3b576d 100644
--- a/UnitsNet.Tests/CustomCode/MassTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassTests.cs
@@ -19,11 +19,19 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 using NUnit.Framework;
+using System;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class MassTests : MassTestsBase
     {
+        [Test]
+        public void MassDividedByTimeEqualsMassFlow()
+        {
+            var massFlow= Mass.FromKilograms(18.0) / TimeSpan.FromSeconds(6);
+            Assert.AreEqual(massFlow, MassFlow.FromKilogramsPerSecond(3.0));
+        }
+
         [Test]
         public void MassDividedByVolumeEqualsDensity()
         {
diff --git a/UnitsNet.Tests/CustomCode/PowerTests.cs b/UnitsNet.Tests/CustomCode/PowerTests.cs
index 8fc9584039..9e3e47a3ca 100644
--- a/UnitsNet.Tests/CustomCode/PowerTests.cs
+++ b/UnitsNet.Tests/CustomCode/PowerTests.cs
@@ -18,11 +18,43 @@
 // 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 NUnit.Framework;
+using System;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class PowerTests : PowerTestsBase
     {
+        [Test]
+        public void PowerDevidedBySpeedEqualsForce()
+        {
+            var force= Power.FromWatts(15.0) / Speed.FromMetersPerSecond(3);
+            Assert.AreEqual(force, Force.FromNewtons(5));
+        }
+        [Test]
+        public void PowerDevidedByRotationalSpeedEqualsForce()
+        {
+            var torque = Power.FromWatts(15.0) / RotationalSpeed.FromRadiansPerSecond(3);
+            Assert.AreEqual(torque, Torque.FromNewtonMeters(5));
+        }
+        [Test]
+        public void PowerDevidedByTorqueEqualsRotationalSpeed()
+        {
+            var rotationalSpeed= Power.FromWatts(15.0) / Torque.FromNewtonMeters(3);
+            Assert.AreEqual(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(5));
+        }
+        [Test]
+        public void PowerTimesTimespanEqualsEnergy()
+        {
+            var energy = Power.FromWatts(5.0)*TimeSpan.FromSeconds(8.0);
+            Assert.AreEqual(energy, Energy.FromJoules(40.0));
+        }
+        [Test]
+        public void TimeSpanTimesPowerEqualsEnergy()
+        {
+            var energy = TimeSpan.FromSeconds(8.0)* Power.FromWatts(5.0);
+            Assert.AreEqual(energy, Energy.FromJoules(40.0));
+        }
         protected override double FemtowattsInOneWatt
         {
             get { return 1e15; }
diff --git a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
index 9d0e934f83..d435008f6e 100644
--- a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
@@ -20,11 +20,20 @@
 // THE SOFTWARE.
 
 using System;
+using NUnit.Framework;
 
 namespace UnitsNet.Tests.CustomCode
 {
+
     public class RotationalSpeedTests : RotationalSpeedTestsBase
     {
+        [Test]
+        public void RotationalSpeedTimesTimeSpanEqualsAngle()
+        {
+            var angle = RotationalSpeed.FromRadiansPerSecond(10.0)*TimeSpan.FromSeconds(9.0);
+            Assert.AreEqual(angle, Angle.FromRadians(90.0));
+        }
+
         protected override double RadiansPerSecondInOneRevolutionPerSecond
         {
             get
diff --git a/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs b/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
index c8843a97f5..54f380ece3 100644
--- a/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs
@@ -21,11 +21,25 @@
 
 
 using System;
+using NUnit.Framework;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class SpecificEnergyTests : SpecificEnergyTestsBase
     {
+        [Test]
+        public void SpecificEnergyTimesMassEqualsEnergy()
+        {
+            var energy = SpecificEnergy.FromJoulesPerKilogram(10.0) * Mass.FromKilograms(20.0);
+            Assert.AreEqual(energy, Energy.FromJoules(200.0));
+        }
+        [Test]
+        public void MassTimesSpecificEnergyEqualsEnergy()
+        {
+            var energy = Mass.FromKilograms(20.0)* SpecificEnergy.FromJoulesPerKilogram(10.0);
+            Assert.AreEqual(energy, Energy.FromJoules(200.0));
+        }
+
 
         // TODO Override properties in base class here
         protected override double JoulesPerKilogramInOneJoulePerKilogram
diff --git a/UnitsNet.Tests/CustomCode/TorqueTests.cs b/UnitsNet.Tests/CustomCode/TorqueTests.cs
index d2138aaf7e..dd227f7127 100644
--- a/UnitsNet.Tests/CustomCode/TorqueTests.cs
+++ b/UnitsNet.Tests/CustomCode/TorqueTests.cs
@@ -30,6 +30,12 @@ public void TorqueDevidedByLengthEqualsForce()
             var force = Torque.FromNewtonMeters(4) / Length.FromMeters(2);
             Assert.AreEqual(force, Force.FromNewtons(2));
         }
+        [Test]
+        public void TorqueDevidedByForceEqualsLength()
+        {
+            var length= Torque.FromNewtonMeters(4) / Force.FromNewtons(2);
+            Assert.AreEqual(length, Length.FromMeters(2));
+        }
 
         protected override double KilogramForceCentimetersInOneNewtonMeter
         {
diff --git a/UnitsNet.Tests/CustomCode/VolumeTests.cs b/UnitsNet.Tests/CustomCode/VolumeTests.cs
index b8c12c631e..b803490331 100644
--- a/UnitsNet.Tests/CustomCode/VolumeTests.cs
+++ b/UnitsNet.Tests/CustomCode/VolumeTests.cs
@@ -25,6 +25,18 @@ namespace UnitsNet.Tests.CustomCode
 {
     public class VolumeTests : VolumeTestsBase
     {
+        [Test]
+        public void VolumeDividedByLengthEqualsArea()
+        {
+            var area = Volume.FromCubicMeters(15) / Length.FromMeters(5);
+            Assert.AreEqual(area, Area.FromSquareMeters(3));
+        }
+        [Test]
+        public void VolumeDividedByAreaEqualsLength()
+        {
+            var length= Volume.FromCubicMeters(15) / Area.FromSquareMeters(5);
+            Assert.AreEqual(length, Length.FromMeters(3));
+        }
         [Test]
         public void VolumeTimesDensityEqualsMass()
         {
diff --git a/UnitsNet/CustomCode/UnitClasses/Area.extra.cs b/UnitsNet/CustomCode/UnitClasses/Area.extra.cs
new file mode 100644
index 0000000000..73be6314d7
--- /dev/null
+++ b/UnitsNet/CustomCode/UnitClasses/Area.extra.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using UnitsNet.Units;
+
+
+namespace UnitsNet
+{
+    public partial struct Area
+    {
+        public static Length operator/(Area area, Length length)
+        {
+            return Length.FromMeters(area.SquareMeters / length.Meters);
+        }
+
+    }
+}
diff --git a/UnitsNet/CustomCode/UnitClasses/Force.extra.cs b/UnitsNet/CustomCode/UnitClasses/Force.extra.cs
index 39f553c1e2..919ff4f869 100644
--- a/UnitsNet/CustomCode/UnitClasses/Force.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Force.extra.cs
@@ -18,11 +18,30 @@
 // 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 UnitsNet.Units;
 
 namespace UnitsNet
 {
     public partial struct Force
     {
+        public static Power operator*(Force force, Speed speed)
+        {
+            return Power.FromWatts(force.Newtons * speed.MetersPerSecond);
+        }
+        public static Power operator *(Speed speed, Force force)
+        {
+            return Power.FromWatts(force.Newtons * speed.MetersPerSecond);
+        }
+        public static Acceleration operator /(Force force, Mass mass)
+        {
+            return Acceleration.FromMeterPerSecondSquared(force.Newtons / mass.Kilograms);
+        }
+        public static Pressure operator /(Force force, Area area)
+        {
+            return Pressure.FromPascals(force.Newtons / area.SquareMeters);
+        }
+
+
         public static Force FromPressureByArea(Pressure p, Length2d area)
         {
             double metersSquared = area.Meters.X*area.Meters.Y;
diff --git a/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs b/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs
index 1edad3a4dc..23edad53db 100644
--- a/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs
@@ -62,6 +62,10 @@ public static Mass FromStonePounds(double stone, double pounds)
             return FromPounds((StoneToPounds * stone) + pounds);
         }
 
+        public static MassFlow operator/(Mass mass, TimeSpan timeSpan)
+        {
+            return MassFlow.FromKilogramsPerSecond(mass.Kilograms / timeSpan.TotalSeconds);
+        }
         public static Density operator /(Mass mass, Volume volume)
         {
             return Density.FromKilogramsPerCubicMeter(mass.Kilograms / volume.CubicMeters);
diff --git a/UnitsNet/CustomCode/UnitClasses/MassFlow.extra.cs b/UnitsNet/CustomCode/UnitClasses/MassFlow.extra.cs
new file mode 100644
index 0000000000..5897b00354
--- /dev/null
+++ b/UnitsNet/CustomCode/UnitClasses/MassFlow.extra.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using UnitsNet.Units;
+
+namespace UnitsNet
+{
+    public partial struct MassFlow
+    {
+
+        public static Mass operator *(MassFlow massFlow, TimeSpan time)
+        {
+            return Mass.FromKilograms(massFlow.KilogramsPerSecond * time.TotalSeconds);
+        }
+        public static Mass operator *(TimeSpan time, MassFlow massFlow)
+        {
+            return Mass.FromKilograms(massFlow.KilogramsPerSecond * time.TotalSeconds);
+        }
+    }
+}
diff --git a/UnitsNet/CustomCode/UnitClasses/Power.extra.cs b/UnitsNet/CustomCode/UnitClasses/Power.extra.cs
index 54f8a03988..3df8bbff7d 100644
--- a/UnitsNet/CustomCode/UnitClasses/Power.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Power.extra.cs
@@ -14,6 +14,26 @@ namespace UnitsNet
     /// </summary>
     public partial struct Power
     {
+        public static Energy operator*(Power power, TimeSpan time)
+        {
+            return Energy.FromJoules(power.Watts* time.TotalSeconds);
+        }
+        public static Energy operator *(TimeSpan time, Power power)
+        {
+            return Energy.FromJoules(power.Watts * time.TotalSeconds);
+        }
+        public static Force operator/(Power power, Speed speed)
+        {
+            return Force.FromNewtons(power.Watts / speed.MetersPerSecond);
+        }
+        public static Torque operator /(Power power, RotationalSpeed rotationalSpeed)
+        {
+            return Torque.FromNewtonMeters(power.Watts / rotationalSpeed.RadiansPerSecond);
+        }
+        public static RotationalSpeed operator/(Power power, Torque torque)
+        {
+            return RotationalSpeed.FromRadiansPerSecond(power.Watts / torque.NewtonMeters);
+        }
 
     }
 }
diff --git a/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs b/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs
new file mode 100644
index 0000000000..e34cbb45dc
--- /dev/null
+++ b/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using UnitsNet.Units;
+
+namespace UnitsNet
+{
+    public partial struct RotationalSpeed
+    {
+        public static Angle operator *(RotationalSpeed rotationalSpeed, TimeSpan timeSpan)
+        {
+            return Angle.FromRadians(rotationalSpeed.RadiansPerSecond * timeSpan.TotalSeconds);
+        }
+    }
+}
diff --git a/UnitsNet/CustomCode/UnitClasses/SpecificEnergy.extra.cs b/UnitsNet/CustomCode/UnitClasses/SpecificEnergy.extra.cs
new file mode 100644
index 0000000000..bacf6b7c9c
--- /dev/null
+++ b/UnitsNet/CustomCode/UnitClasses/SpecificEnergy.extra.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using UnitsNet.Units;
+
+namespace UnitsNet
+{
+    public partial struct SpecificEnergy
+    {
+        public static Energy operator*(SpecificEnergy specificEnergy, Mass mass)
+        {
+            return Energy.FromJoules(specificEnergy.JoulesPerKilogram * mass.Kilograms);
+        }
+        public static Energy operator *(Mass mass, SpecificEnergy specificEnergy)
+        {
+            return Energy.FromJoules(specificEnergy.JoulesPerKilogram * mass.Kilograms);
+        }
+    }
+}
diff --git a/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs b/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs
index 1e9c705d54..b60872b218 100644
--- a/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs
@@ -9,6 +9,7 @@ namespace UnitsNet
 {
     public partial struct Speed
     {
+
         public static Acceleration operator /(Speed speed, TimeSpan timeSpan)
         {
             return Acceleration.FromMeterPerSecondSquared(speed.MetersPerSecond / timeSpan.TotalSeconds);
diff --git a/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs b/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs
index d0800ab7da..8e2655a751 100644
--- a/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs
@@ -13,5 +13,9 @@ public partial struct Torque
         {
             return Force.FromNewtons(torque.NewtonMeters/length.Meters);
         }
+        public static Length operator /(Torque torque, Force force)
+        {
+            return Length.FromMeters(torque.NewtonMeters / force.Newtons);
+        }
     }
 }
diff --git a/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs b/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs
index 5b70028433..d900513d74 100644
--- a/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs
@@ -14,7 +14,14 @@ public partial struct Volume
         {
             return Mass.FromKilograms(volume.CubicMeters * density.KilogramsPerCubicMeter);
         }
-
+        public static Area operator/(Volume volume, Length length)
+        {
+            return Area.FromSquareMeters(volume.CubicMeters / length.Meters);
+        }
+        public static Length operator /(Volume volume, Area area)
+        {
+            return Length.FromMeters(volume.CubicMeters / area.SquareMeters);
+        }
 
     }
 }

From 65b2397b6358d9bc59d5dd14cd00874ed9a4706c Mon Sep 17 00:00:00 2001
From: Erik Ovegard <erik.ovegard@seaware.se>
Date: Tue, 26 Jan 2016 11:46:52 +0100
Subject: [PATCH 07/10] Code reviewed, added copyright headers and some more *
 overloading

---
 ...nitsNet.Serialization.JsonNet.Tests.csproj |  3 --
 UnitsNet.Tests/CustomCode/LengthTests.cs      | 15 +++++--
 UnitsNet.Tests/CustomCode/MassTests.cs        |  9 ++++
 UnitsNet.Tests/CustomCode/PressureTests.cs    |  8 +++-
 .../CustomCode/RotationalSpeedTests.cs        | 23 +++++++++-
 UnitsNet.Tests/CustomCode/SpeedTests.cs       | 19 ++++++--
 UnitsNet.Tests/CustomCode/VolumeTests.cs      |  2 +
 .../CustomCode/UnitClasses/Angle.extra.cs     | 23 +++++++++-
 UnitsNet/CustomCode/UnitClasses/Area.extra.cs | 27 +++++++++---
 .../CustomCode/UnitClasses/Force.extra.cs     |  4 +-
 .../CustomCode/UnitClasses/Length.extra.cs    |  8 ++--
 UnitsNet/CustomCode/UnitClasses/Mass.extra.cs |  6 +++
 .../CustomCode/UnitClasses/MassFlow.extra.cs  | 28 +++++++++---
 .../CustomCode/UnitClasses/Power.extra.cs     | 28 +++++++++---
 .../CustomCode/UnitClasses/Pressure.extra.cs  | 31 ++++++++++---
 .../UnitClasses/RotationalSpeed.extra.cs      | 43 ++++++++++++++++---
 .../UnitClasses/SpecificEnergy.extra.cs       | 26 ++++++++---
 .../CustomCode/UnitClasses/Speed.extra.cs     | 36 +++++++++++++---
 .../CustomCode/UnitClasses/Torque.extra.cs    | 26 ++++++++---
 .../CustomCode/UnitClasses/Volume.extra.cs    | 30 +++++++++----
 20 files changed, 315 insertions(+), 80 deletions(-)

diff --git a/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj b/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
index 7d6fe10699..d24fc02fc6 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
+++ b/UnitsNet.Serialization.JsonNet.Tests/UnitsNet.Serialization.JsonNet.Tests.csproj
@@ -67,9 +67,6 @@
       <Name>UnitsNet.Net35</Name>
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup>
-    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
-  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/UnitsNet.Tests/CustomCode/LengthTests.cs b/UnitsNet.Tests/CustomCode/LengthTests.cs
index 63596081ca..6d2e6261df 100644
--- a/UnitsNet.Tests/CustomCode/LengthTests.cs
+++ b/UnitsNet.Tests/CustomCode/LengthTests.cs
@@ -34,13 +34,13 @@ public void LengthTimesLengthEqualsArea()
         }
 
         [Test]
-        public void AreaTimesLengthEqualsArea()
+        public void AreaTimesLengthEqualsVolume()
         {
             var volume = Area.FromSquareMeters(10) * Length.FromMeters(3);
             Assert.AreEqual(volume, Volume.FromCubicMeters(30));
         }
         [Test]
-        public void LengthTimesAreaEqualsArea()
+        public void LengthTimesAreaEqualsVolume()
         {
             var volume = Length.FromMeters(3) * Area.FromSquareMeters(9);
             Assert.AreEqual(volume, Volume.FromCubicMeters(27));
@@ -49,8 +49,15 @@ public void LengthTimesAreaEqualsArea()
         [Test]
         public void ForceTimesLengthEqualsTorque()
         {
-            var volume = Length.FromMeters(3) * Area.FromSquareMeters(9);
-            Assert.AreEqual(volume, Volume.FromCubicMeters(27));
+            var torque = Force.FromNewtons(1) * Length.FromMeters(3);
+            Assert.AreEqual(torque, Torque.FromNewtonMeters(3));
+        }
+
+        [Test]
+        public void LengthTimesForceEqualsTorque()
+        {
+            var torque = Length.FromMeters(3) * Force.FromNewtons(1);
+            Assert.AreEqual(torque, Torque.FromNewtonMeters(3));
         }
 
         protected override double CentimetersInOneMeter
diff --git a/UnitsNet.Tests/CustomCode/MassTests.cs b/UnitsNet.Tests/CustomCode/MassTests.cs
index 049a3b576d..519cc9229b 100644
--- a/UnitsNet.Tests/CustomCode/MassTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassTests.cs
@@ -38,12 +38,21 @@ public void MassDividedByVolumeEqualsDensity()
             var density = Mass.FromKilograms(18) / Volume.FromCubicMeters(3);
             Assert.AreEqual(density, Density.FromKilogramsPerCubicMeter(6));
         }
+
         [Test]
         public void MassTimesAccelerationEqualsForce()
         {
             var force = Mass.FromKilograms(18) * Acceleration.FromMeterPerSecondSquared(3);
             Assert.AreEqual(force, Force.FromNewtons(54));
         }
+
+        [Test]
+        public void AccelerationTimesMassEqualsForce()
+        {
+            var force = Acceleration.FromMeterPerSecondSquared(3) * Mass.FromKilograms(18);
+            Assert.AreEqual(force, Force.FromNewtons(54));
+        }
+
         protected override double CentigramsInOneKilogram
         {
             get { return 1E5; }
diff --git a/UnitsNet.Tests/CustomCode/PressureTests.cs b/UnitsNet.Tests/CustomCode/PressureTests.cs
index b7d5b368fd..32c25ed9e2 100644
--- a/UnitsNet.Tests/CustomCode/PressureTests.cs
+++ b/UnitsNet.Tests/CustomCode/PressureTests.cs
@@ -24,8 +24,6 @@ namespace UnitsNet.Tests.CustomCode
 {
     public class PressureTests : PressureTestsBase
     {
-
-
         [Test]
         public void PressureTimesAreaEqualsForce()
         {
@@ -33,6 +31,12 @@ public void PressureTimesAreaEqualsForce()
             Assert.AreEqual(force, Force.FromNewtons(60));
         }
 
+        [Test]
+        public void AreaTimePressureEqualsForce()
+        {
+            var force = Area.FromSquareMeters(3) * Pressure.FromPascals(20);
+            Assert.AreEqual(force, Force.FromNewtons(60));
+        }
 
         protected override double AtmospheresInOnePascal
         {
diff --git a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
index d435008f6e..06e9281bb9 100644
--- a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
@@ -30,10 +30,31 @@ public class RotationalSpeedTests : RotationalSpeedTestsBase
         [Test]
         public void RotationalSpeedTimesTimeSpanEqualsAngle()
         {
-            var angle = RotationalSpeed.FromRadiansPerSecond(10.0)*TimeSpan.FromSeconds(9.0);
+            var angle = RotationalSpeed.FromRadiansPerSecond(10.0) * TimeSpan.FromSeconds(9.0);
             Assert.AreEqual(angle, Angle.FromRadians(90.0));
         }
 
+        [Test]
+        public void TimeSpanTimesRotationalSpeedEqualsAngle()
+        {
+            var angle = TimeSpan.FromSeconds(9.0) * RotationalSpeed.FromRadiansPerSecond(10.0) ;
+            Assert.AreEqual(angle, Angle.FromRadians(90.0));
+        }
+
+        [Test]
+        public void RotationalSpeedTimesForceEqualsPower()
+        {
+            var power = RotationalSpeed.FromRadiansPerSecond(10.0) * Force.FromNewtons(2.0);
+            Assert.AreEqual(power, Power.FromWatts(20.0));
+        }
+
+        [Test]
+        public void ForceTimesRotationalSpeedEqualsPower()
+        {
+            var power = Force.FromNewtons(2.0) * RotationalSpeed.FromRadiansPerSecond(10.0) ;
+            Assert.AreEqual(power, Power.FromWatts(20.0));
+        }
+
         protected override double RadiansPerSecondInOneRevolutionPerSecond
         {
             get
diff --git a/UnitsNet.Tests/CustomCode/SpeedTests.cs b/UnitsNet.Tests/CustomCode/SpeedTests.cs
index 086498afd7..4f071c5e42 100644
--- a/UnitsNet.Tests/CustomCode/SpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpeedTests.cs
@@ -20,28 +20,39 @@
 // THE SOFTWARE.
 
 using System;
-
 using NUnit.Framework;
-using System;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class SpeedTests : SpeedTestsBase
     {
-
         [Test]
         public void SpeedDevidedByTimespanEqualsAcceleration()
         {
             var acceleration = Speed.FromMetersPerSecond(20) / TimeSpan.FromSeconds(2);
             Assert.AreEqual(acceleration, Acceleration.FromMeterPerSecondSquared(10));
         }
+
         [Test]
-        public void SpeedTimesTimespanEqualsLength()
+        public void SpeedTimesTimeSpanEqualsLength()
         {
             var length= Speed.FromMetersPerSecond(20) * TimeSpan.FromSeconds(2);
             Assert.AreEqual(length, Length.FromMeters(40));
         }
 
+        [Test]
+        public void TimeSpanSpeedTimesEqualsLength()
+        {
+            var length = TimeSpan.FromSeconds(2) * Speed.FromMetersPerSecond(20);
+            Assert.AreEqual(length, Length.FromMeters(40));
+        }
+
+        [Test]
+        public void LengthDividedByTimeSpanEqualsSpeed()
+        {
+            var speed = Length.FromMeters(20) / TimeSpan.FromSeconds(2);
+            Assert.AreEqual(speed, Speed.FromMetersPerSecond(10));
+        }
 
         protected override double FeetPerSecondInOneMeterPerSecond
         {
diff --git a/UnitsNet.Tests/CustomCode/VolumeTests.cs b/UnitsNet.Tests/CustomCode/VolumeTests.cs
index b803490331..df84426c8b 100644
--- a/UnitsNet.Tests/CustomCode/VolumeTests.cs
+++ b/UnitsNet.Tests/CustomCode/VolumeTests.cs
@@ -31,12 +31,14 @@ public void VolumeDividedByLengthEqualsArea()
             var area = Volume.FromCubicMeters(15) / Length.FromMeters(5);
             Assert.AreEqual(area, Area.FromSquareMeters(3));
         }
+
         [Test]
         public void VolumeDividedByAreaEqualsLength()
         {
             var length= Volume.FromCubicMeters(15) / Area.FromSquareMeters(5);
             Assert.AreEqual(length, Length.FromMeters(3));
         }
+
         [Test]
         public void VolumeTimesDensityEqualsMass()
         {
diff --git a/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs b/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs
index 970820741b..b8b3d262e8 100644
--- a/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs
@@ -1,4 +1,25 @@
-using System;
+// 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
 {
diff --git a/UnitsNet/CustomCode/UnitClasses/Area.extra.cs b/UnitsNet/CustomCode/UnitClasses/Area.extra.cs
index 73be6314d7..1998ef2c0e 100644
--- a/UnitsNet/CustomCode/UnitClasses/Area.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Area.extra.cs
@@ -1,10 +1,23 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using UnitsNet.Units;
-
+// 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.
 
 namespace UnitsNet
 {
diff --git a/UnitsNet/CustomCode/UnitClasses/Force.extra.cs b/UnitsNet/CustomCode/UnitClasses/Force.extra.cs
index 919ff4f869..10e0e4f622 100644
--- a/UnitsNet/CustomCode/UnitClasses/Force.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Force.extra.cs
@@ -18,7 +18,6 @@
 // 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 UnitsNet.Units;
 
 namespace UnitsNet
 {
@@ -40,8 +39,7 @@ public partial struct Force
         {
             return Pressure.FromPascals(force.Newtons / area.SquareMeters);
         }
-
-
+        
         public static Force FromPressureByArea(Pressure p, Length2d area)
         {
             double metersSquared = area.Meters.X*area.Meters.Y;
diff --git a/UnitsNet/CustomCode/UnitClasses/Length.extra.cs b/UnitsNet/CustomCode/UnitClasses/Length.extra.cs
index c24387b96c..c076ccbc39 100644
--- a/UnitsNet/CustomCode/UnitClasses/Length.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Length.extra.cs
@@ -1,8 +1,5 @@
 using System;
-using System.Collections.Generic;
 using System.Globalization;
-using System.Linq;
-using System.Text;
 using UnitsNet.Units;
 
 namespace UnitsNet
@@ -60,6 +57,11 @@ public static Length FromFeetInches(double feet, double inches)
             return Torque.FromNewtonMeters(force.Newtons * length.Meters);
         }
 
+        public static Torque operator *(Length length, Force force)
+        {
+            return Torque.FromNewtonMeters(force.Newtons * length.Meters);
+        }
+
     }
 
     public class FeetInches
diff --git a/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs b/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs
index 23edad53db..113adc4efb 100644
--- a/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs
@@ -66,15 +66,21 @@ public static Mass FromStonePounds(double stone, double pounds)
         {
             return MassFlow.FromKilogramsPerSecond(mass.Kilograms / timeSpan.TotalSeconds);
         }
+
         public static Density operator /(Mass mass, Volume volume)
         {
             return Density.FromKilogramsPerCubicMeter(mass.Kilograms / volume.CubicMeters);
         }
+
         public static Force operator *(Mass mass, Acceleration acceleration)
         {
             return Force.FromNewtons(mass.Kilograms * acceleration.MeterPerSecondSquared);
         }
 
+        public static Force operator *(Acceleration acceleration, Mass mass)
+        {
+            return Force.FromNewtons(mass.Kilograms * acceleration.MeterPerSecondSquared);
+        }
     }
 
     public class StonePounds
diff --git a/UnitsNet/CustomCode/UnitClasses/MassFlow.extra.cs b/UnitsNet/CustomCode/UnitClasses/MassFlow.extra.cs
index 5897b00354..d4227eb8d8 100644
--- a/UnitsNet/CustomCode/UnitClasses/MassFlow.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/MassFlow.extra.cs
@@ -1,9 +1,25 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using UnitsNet.Units;
+// 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
 {
diff --git a/UnitsNet/CustomCode/UnitClasses/Power.extra.cs b/UnitsNet/CustomCode/UnitClasses/Power.extra.cs
index 3df8bbff7d..be99162f92 100644
--- a/UnitsNet/CustomCode/UnitClasses/Power.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Power.extra.cs
@@ -1,9 +1,25 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using UnitsNet.Units;
+// 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
 {
diff --git a/UnitsNet/CustomCode/UnitClasses/Pressure.extra.cs b/UnitsNet/CustomCode/UnitClasses/Pressure.extra.cs
index c9109b4d68..58e8cfb38e 100644
--- a/UnitsNet/CustomCode/UnitClasses/Pressure.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Pressure.extra.cs
@@ -1,13 +1,26 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using UnitsNet.Units;
+// 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.
 
 namespace UnitsNet
 {
-
     public partial struct Pressure
     {
         public static Force operator*(Pressure pressure, Area area)
@@ -15,5 +28,9 @@ public partial struct Pressure
             return Force.FromNewtons(pressure.Pascals * area.SquareMeters);
         }
 
+        public static Force operator *(Area area, Pressure pressure)
+        {
+            return Force.FromNewtons(pressure.Pascals * area.SquareMeters);
+        }
     }
 }
diff --git a/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs b/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs
index e34cbb45dc..596113d9a3 100644
--- a/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs
@@ -1,9 +1,25 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using UnitsNet.Units;
+// 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
 {
@@ -13,5 +29,20 @@ public partial struct RotationalSpeed
         {
             return Angle.FromRadians(rotationalSpeed.RadiansPerSecond * timeSpan.TotalSeconds);
         }
+
+        public static Angle operator *(TimeSpan timeSpan, RotationalSpeed rotationalSpeed)
+        {
+            return Angle.FromRadians(rotationalSpeed.RadiansPerSecond * timeSpan.TotalSeconds);
+        }
+
+        public static Power operator *(RotationalSpeed rotationalSpeed, Force force)
+        {
+            return Power.FromWatts(rotationalSpeed.RadiansPerSecond * force.Newtons);
+        }
+
+        public static Power operator *(Force force, RotationalSpeed rotationalSpeed)
+        {
+            return Power.FromWatts(rotationalSpeed.RadiansPerSecond * force.Newtons);
+        }
     }
 }
diff --git a/UnitsNet/CustomCode/UnitClasses/SpecificEnergy.extra.cs b/UnitsNet/CustomCode/UnitClasses/SpecificEnergy.extra.cs
index bacf6b7c9c..75fb518852 100644
--- a/UnitsNet/CustomCode/UnitClasses/SpecificEnergy.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/SpecificEnergy.extra.cs
@@ -1,9 +1,23 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using UnitsNet.Units;
+// 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.
 
 namespace UnitsNet
 {
diff --git a/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs b/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs
index b60872b218..1375b4869e 100644
--- a/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs
@@ -1,9 +1,25 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using UnitsNet.Units;
+// 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
 {
@@ -14,7 +30,13 @@ public partial struct Speed
         {
             return Acceleration.FromMeterPerSecondSquared(speed.MetersPerSecond / timeSpan.TotalSeconds);
         }
-        public static Length operator*(Speed speed, TimeSpan timeSpan)
+
+        public static Length operator *(Speed speed, TimeSpan timeSpan)
+        {
+            return Length.FromMeters(speed.MetersPerSecond * timeSpan.TotalSeconds);
+        }
+
+        public static Length operator *(TimeSpan timeSpan, Speed speed)
         {
             return Length.FromMeters(speed.MetersPerSecond * timeSpan.TotalSeconds);
         }
diff --git a/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs b/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs
index 8e2655a751..17b5cd8770 100644
--- a/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Torque.extra.cs
@@ -1,9 +1,23 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using UnitsNet.Units;
+// 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.
 
 namespace UnitsNet
 {
diff --git a/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs b/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs
index d900513d74..84bd54cc18 100644
--- a/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs
@@ -1,20 +1,34 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using UnitsNet.Units;
+// 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.
 
 namespace UnitsNet
 {
     public partial struct Volume
     {
 
-        public static Mass operator*(Volume volume, Density density)
+        public static Mass operator *(Volume volume, Density density)
         {
             return Mass.FromKilograms(volume.CubicMeters * density.KilogramsPerCubicMeter);
         }
-        public static Area operator/(Volume volume, Length length)
+        public static Area operator /(Volume volume, Length length)
         {
             return Area.FromSquareMeters(volume.CubicMeters / length.Meters);
         }

From ecec14d05e8a3ec0b0ee26befaf09d0e9a818e0a Mon Sep 17 00:00:00 2001
From: Erik Ovegard <erik.ovegard@seaware.se>
Date: Tue, 26 Jan 2016 12:48:05 +0100
Subject: [PATCH 08/10] Added support for Duration

---
 UnitsNet.Tests/CustomCode/AngleTests.cs       |  9 +++++-
 UnitsNet.Tests/CustomCode/MassFlowTests.cs    | 15 ++++++++--
 UnitsNet.Tests/CustomCode/MassTests.cs        |  9 +++++-
 UnitsNet.Tests/CustomCode/PowerTests.cs       | 16 +++++++++-
 .../CustomCode/RotationalSpeedTests.cs        | 14 +++++++++
 UnitsNet.Tests/CustomCode/SpeedTests.cs       | 30 ++++++++++++++++++-
 .../CustomCode/UnitClasses/Angle.extra.cs     |  5 ++++
 .../CustomCode/UnitClasses/Length.extra.cs    |  6 ++++
 UnitsNet/CustomCode/UnitClasses/Mass.extra.cs |  5 ++++
 .../CustomCode/UnitClasses/MassFlow.extra.cs  |  9 ++++++
 .../CustomCode/UnitClasses/Power.extra.cs     | 14 +++++++++
 .../UnitClasses/RotationalSpeed.extra.cs      | 10 +++++++
 .../CustomCode/UnitClasses/Speed.extra.cs     | 15 ++++++++++
 13 files changed, 151 insertions(+), 6 deletions(-)

diff --git a/UnitsNet.Tests/CustomCode/AngleTests.cs b/UnitsNet.Tests/CustomCode/AngleTests.cs
index a58f75ac11..fde81da08f 100644
--- a/UnitsNet.Tests/CustomCode/AngleTests.cs
+++ b/UnitsNet.Tests/CustomCode/AngleTests.cs
@@ -27,12 +27,19 @@ namespace UnitsNet.Tests.CustomCode
     public class AngleTests : AngleTestsBase
     {
         [Test]
-        public void AngleDividedByTimeEqualsRotationalSpeed()
+        public void AngleDividedByTimeSpanEqualsRotationalSpeed()
         {
             var rotationalSpeed = Angle.FromRadians(10)/TimeSpan.FromSeconds(5);
             Assert.AreEqual(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(2));
         }
 
+        [Test]
+        public void AngleDividedByDurationEqualsRotationalSpeed()
+        {
+            var rotationalSpeed = Angle.FromRadians(10) / Duration.FromSeconds(5);
+            Assert.AreEqual(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(2));
+        }
+
         protected override double DegreesInOneDegree
         {
             get { return 1; }
diff --git a/UnitsNet.Tests/CustomCode/MassFlowTests.cs b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
index 912f73529b..443e1a6594 100644
--- a/UnitsNet.Tests/CustomCode/MassFlowTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassFlowTests.cs
@@ -27,7 +27,6 @@ namespace UnitsNet.Tests.CustomCode
 {
     public class MassFlowTests : MassFlowTestsBase
     {
-        // strange bug
         [Test]
         public void MassFlowTimesTimeSpanEqualsMass()
         {
@@ -41,7 +40,19 @@ public void TimeSpanTimesMassFlowEqualsMass()
             Assert.AreEqual(mass, Mass.FromKilograms(80.0));
         }
 
-        // TODO Override properties in base class here
+        [Test]
+        public void MassFlowTimesDurationEqualsMass()
+        {
+            var mass = MassFlow.FromKilogramsPerSecond(20.0) * Duration.FromSeconds(4.0);
+            Assert.AreEqual(mass, Mass.FromKilograms(80.0));
+        }
+        [Test]
+        public void DurationTimesMassFlowEqualsMass()
+        {
+            var mass = Duration.FromSeconds(4.0) * MassFlow.FromKilogramsPerSecond(20.0);
+            Assert.AreEqual(mass, Mass.FromKilograms(80.0));
+        }
+
         protected override double KilogramsPerSecondInOneKilogramPerSecond
         {
             get
diff --git a/UnitsNet.Tests/CustomCode/MassTests.cs b/UnitsNet.Tests/CustomCode/MassTests.cs
index 519cc9229b..cfbc286a03 100644
--- a/UnitsNet.Tests/CustomCode/MassTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassTests.cs
@@ -26,12 +26,19 @@ namespace UnitsNet.Tests.CustomCode
     public class MassTests : MassTestsBase
     {
         [Test]
-        public void MassDividedByTimeEqualsMassFlow()
+        public void MassDividedByTimeSpanEqualsMassFlow()
         {
             var massFlow= Mass.FromKilograms(18.0) / TimeSpan.FromSeconds(6);
             Assert.AreEqual(massFlow, MassFlow.FromKilogramsPerSecond(3.0));
         }
 
+        [Test]
+        public void MassDividedByDurationEqualsMassFlow()
+        {
+            var massFlow = Mass.FromKilograms(18.0) / Duration.FromSeconds(6);
+            Assert.AreEqual(massFlow, MassFlow.FromKilogramsPerSecond(3.0));
+        }
+
         [Test]
         public void MassDividedByVolumeEqualsDensity()
         {
diff --git a/UnitsNet.Tests/CustomCode/PowerTests.cs b/UnitsNet.Tests/CustomCode/PowerTests.cs
index 9e3e47a3ca..63dffc7861 100644
--- a/UnitsNet.Tests/CustomCode/PowerTests.cs
+++ b/UnitsNet.Tests/CustomCode/PowerTests.cs
@@ -44,7 +44,7 @@ public void PowerDevidedByTorqueEqualsRotationalSpeed()
             Assert.AreEqual(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(5));
         }
         [Test]
-        public void PowerTimesTimespanEqualsEnergy()
+        public void PowerTimesTimeSpanEqualsEnergy()
         {
             var energy = Power.FromWatts(5.0)*TimeSpan.FromSeconds(8.0);
             Assert.AreEqual(energy, Energy.FromJoules(40.0));
@@ -55,6 +55,20 @@ public void TimeSpanTimesPowerEqualsEnergy()
             var energy = TimeSpan.FromSeconds(8.0)* Power.FromWatts(5.0);
             Assert.AreEqual(energy, Energy.FromJoules(40.0));
         }
+
+        [Test]
+        public void PowerTimesDurationEqualsEnergy()
+        {
+            var energy = Power.FromWatts(5.0) * Duration.FromSeconds(8.0);
+            Assert.AreEqual(energy, Energy.FromJoules(40.0));
+        }
+        [Test]
+        public void DurationTimesPowerEqualsEnergy()
+        {
+            var energy = Duration.FromSeconds(8.0) * Power.FromWatts(5.0);
+            Assert.AreEqual(energy, Energy.FromJoules(40.0));
+        }
+
         protected override double FemtowattsInOneWatt
         {
             get { return 1e15; }
diff --git a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
index 06e9281bb9..1e958f37f9 100644
--- a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
@@ -41,6 +41,20 @@ public void TimeSpanTimesRotationalSpeedEqualsAngle()
             Assert.AreEqual(angle, Angle.FromRadians(90.0));
         }
 
+        [Test]
+        public void RotationalSpeedTimesDurationEqualsAngle()
+        {
+            var angle = RotationalSpeed.FromRadiansPerSecond(10.0) * Duration.FromSeconds(9.0);
+            Assert.AreEqual(angle, Angle.FromRadians(90.0));
+        }
+
+        [Test]
+        public void DurationTimesRotationalSpeedEqualsAngle()
+        {
+            var angle = Duration.FromSeconds(9.0) * RotationalSpeed.FromRadiansPerSecond(10.0);
+            Assert.AreEqual(angle, Angle.FromRadians(90.0));
+        }
+
         [Test]
         public void RotationalSpeedTimesForceEqualsPower()
         {
diff --git a/UnitsNet.Tests/CustomCode/SpeedTests.cs b/UnitsNet.Tests/CustomCode/SpeedTests.cs
index 4f071c5e42..8a36a100d4 100644
--- a/UnitsNet.Tests/CustomCode/SpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpeedTests.cs
@@ -27,7 +27,7 @@ namespace UnitsNet.Tests.CustomCode
     public class SpeedTests : SpeedTestsBase
     {
         [Test]
-        public void SpeedDevidedByTimespanEqualsAcceleration()
+        public void SpeedDevidedByTimeSpanEqualsAcceleration()
         {
             var acceleration = Speed.FromMetersPerSecond(20) / TimeSpan.FromSeconds(2);
             Assert.AreEqual(acceleration, Acceleration.FromMeterPerSecondSquared(10));
@@ -40,6 +40,20 @@ public void SpeedTimesTimeSpanEqualsLength()
             Assert.AreEqual(length, Length.FromMeters(40));
         }
 
+        [Test]
+        public void SpeedDevidedByDurationEqualsAcceleration()
+        {
+            var acceleration = Speed.FromMetersPerSecond(20) / Duration.FromSeconds(2);
+            Assert.AreEqual(acceleration, Acceleration.FromMeterPerSecondSquared(10));
+        }
+
+        [Test]
+        public void SpeedTimesDurationEqualsLength()
+        {
+            var length = Speed.FromMetersPerSecond(20) * Duration.FromSeconds(2);
+            Assert.AreEqual(length, Length.FromMeters(40));
+        }
+
         [Test]
         public void TimeSpanSpeedTimesEqualsLength()
         {
@@ -54,6 +68,20 @@ public void LengthDividedByTimeSpanEqualsSpeed()
             Assert.AreEqual(speed, Speed.FromMetersPerSecond(10));
         }
 
+        [Test]
+        public void DurationSpeedTimesEqualsLength()
+        {
+            var length = Duration.FromSeconds(2) * Speed.FromMetersPerSecond(20);
+            Assert.AreEqual(length, Length.FromMeters(40));
+        }
+
+        [Test]
+        public void LengthDividedByDurationEqualsSpeed()
+        {
+            var speed = Length.FromMeters(20) / Duration.FromSeconds(2);
+            Assert.AreEqual(speed, Speed.FromMetersPerSecond(10));
+        }
+
         protected override double FeetPerSecondInOneMeterPerSecond
         {
             get { return 3.28084; }
diff --git a/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs b/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs
index b8b3d262e8..c4f65cebb7 100644
--- a/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Angle.extra.cs
@@ -29,5 +29,10 @@ public partial struct Angle
         {
             return RotationalSpeed.FromRadiansPerSecond(angle.Radians / timeSpan.TotalSeconds);
         }
+
+        public static RotationalSpeed operator /(Angle angle, Duration duration)
+        {
+            return RotationalSpeed.FromRadiansPerSecond(angle.Radians / duration.Seconds);
+        }
     }
 }
diff --git a/UnitsNet/CustomCode/UnitClasses/Length.extra.cs b/UnitsNet/CustomCode/UnitClasses/Length.extra.cs
index c076ccbc39..898d07c7ad 100644
--- a/UnitsNet/CustomCode/UnitClasses/Length.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Length.extra.cs
@@ -40,6 +40,12 @@ public static Length FromFeetInches(double feet, double inches)
         {
             return Speed.FromMetersPerSecond(length.Meters / timeSpan.TotalSeconds);
         }
+
+        public static Speed operator /(Length length, Duration duration)
+        {
+            return Speed.FromMetersPerSecond(length.Meters / duration.Seconds);
+        }
+
         public static Area operator*(Length length1, Length length2)
         {
             return Area.FromSquareMeters(length1.Meters * length2.Meters);
diff --git a/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs b/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs
index 113adc4efb..ba21f3a48f 100644
--- a/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Mass.extra.cs
@@ -67,6 +67,11 @@ public static Mass FromStonePounds(double stone, double pounds)
             return MassFlow.FromKilogramsPerSecond(mass.Kilograms / timeSpan.TotalSeconds);
         }
 
+        public static MassFlow operator /(Mass mass, Duration duration)
+        {
+            return MassFlow.FromKilogramsPerSecond(mass.Kilograms / duration.Seconds);
+        }
+
         public static Density operator /(Mass mass, Volume volume)
         {
             return Density.FromKilogramsPerCubicMeter(mass.Kilograms / volume.CubicMeters);
diff --git a/UnitsNet/CustomCode/UnitClasses/MassFlow.extra.cs b/UnitsNet/CustomCode/UnitClasses/MassFlow.extra.cs
index d4227eb8d8..8c87398640 100644
--- a/UnitsNet/CustomCode/UnitClasses/MassFlow.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/MassFlow.extra.cs
@@ -34,5 +34,14 @@ public partial struct MassFlow
         {
             return Mass.FromKilograms(massFlow.KilogramsPerSecond * time.TotalSeconds);
         }
+
+        public static Mass operator *(MassFlow massFlow, Duration duration)
+        {
+            return Mass.FromKilograms(massFlow.KilogramsPerSecond * duration.Seconds);
+        }
+        public static Mass operator *(Duration duration, MassFlow massFlow)
+        {
+            return Mass.FromKilograms(massFlow.KilogramsPerSecond * duration.Seconds);
+        }
     }
 }
diff --git a/UnitsNet/CustomCode/UnitClasses/Power.extra.cs b/UnitsNet/CustomCode/UnitClasses/Power.extra.cs
index be99162f92..a7ecf34918 100644
--- a/UnitsNet/CustomCode/UnitClasses/Power.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Power.extra.cs
@@ -34,18 +34,32 @@ public partial struct Power
         {
             return Energy.FromJoules(power.Watts* time.TotalSeconds);
         }
+
         public static Energy operator *(TimeSpan time, Power power)
         {
             return Energy.FromJoules(power.Watts * time.TotalSeconds);
         }
+
+        public static Energy operator *(Power power, Duration duration)
+        {
+            return Energy.FromJoules(power.Watts * duration.Seconds);
+        }
+
+        public static Energy operator *(Duration duration, Power power)
+        {
+            return Energy.FromJoules(power.Watts * duration.Seconds);
+        }
+
         public static Force operator/(Power power, Speed speed)
         {
             return Force.FromNewtons(power.Watts / speed.MetersPerSecond);
         }
+
         public static Torque operator /(Power power, RotationalSpeed rotationalSpeed)
         {
             return Torque.FromNewtonMeters(power.Watts / rotationalSpeed.RadiansPerSecond);
         }
+
         public static RotationalSpeed operator/(Power power, Torque torque)
         {
             return RotationalSpeed.FromRadiansPerSecond(power.Watts / torque.NewtonMeters);
diff --git a/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs b/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs
index 596113d9a3..e79f8039eb 100644
--- a/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs
@@ -35,6 +35,16 @@ public partial struct RotationalSpeed
             return Angle.FromRadians(rotationalSpeed.RadiansPerSecond * timeSpan.TotalSeconds);
         }
 
+        public static Angle operator *(RotationalSpeed rotationalSpeed, Duration duration)
+        {
+            return Angle.FromRadians(rotationalSpeed.RadiansPerSecond * duration.Seconds);
+        }
+
+        public static Angle operator *(Duration duration, RotationalSpeed rotationalSpeed)
+        {
+            return Angle.FromRadians(rotationalSpeed.RadiansPerSecond * duration.Seconds);
+        }
+
         public static Power operator *(RotationalSpeed rotationalSpeed, Force force)
         {
             return Power.FromWatts(rotationalSpeed.RadiansPerSecond * force.Newtons);
diff --git a/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs b/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs
index 1375b4869e..4f3080ee07 100644
--- a/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Speed.extra.cs
@@ -40,5 +40,20 @@ public partial struct Speed
         {
             return Length.FromMeters(speed.MetersPerSecond * timeSpan.TotalSeconds);
         }
+
+        public static Acceleration operator /(Speed speed, Duration duration)
+        {
+            return Acceleration.FromMeterPerSecondSquared(speed.MetersPerSecond / duration.Seconds);
+        }
+
+        public static Length operator *(Speed speed, Duration duration)
+        {
+            return Length.FromMeters(speed.MetersPerSecond * duration.Seconds);
+        }
+
+        public static Length operator *(Duration duration, Speed speed)
+        {
+            return Length.FromMeters(speed.MetersPerSecond * duration.Seconds);
+        }
     }
 }

From 9c00fc7d6c8abb353bf043c174b88713ea4c3673 Mon Sep 17 00:00:00 2001
From: Erik Ovegard <erik.ovegard@seaware.se>
Date: Tue, 26 Jan 2016 13:50:17 +0100
Subject: [PATCH 09/10] Added overloads for KinematicViscosity and some more
 for Density

---
 UnitsNet.Tests/CustomCode/DensityTests.cs     | 16 ++++++
 .../CustomCode/KinematicViscosityTests.cs     | 36 +++++++++++++
 .../CustomCode/UnitClasses/Density.extra.cs   | 37 +++++++++++++
 .../UnitClasses/KinematicViscosity.extra.cs   | 54 +++++++++++++++++++
 .../CustomCode/UnitClasses/Volume.extra.cs    |  6 +--
 5 files changed, 144 insertions(+), 5 deletions(-)
 create mode 100644 UnitsNet/CustomCode/UnitClasses/Density.extra.cs
 create mode 100644 UnitsNet/CustomCode/UnitClasses/KinematicViscosity.extra.cs

diff --git a/UnitsNet.Tests/CustomCode/DensityTests.cs b/UnitsNet.Tests/CustomCode/DensityTests.cs
index d18721efa4..8a28353782 100644
--- a/UnitsNet.Tests/CustomCode/DensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/DensityTests.cs
@@ -19,10 +19,26 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+using NUnit.Framework;
+
 namespace UnitsNet.Tests.CustomCode
 {
     public class DensityTests : DensityTestsBase
     {
+        [Test]
+        public static void DensityTimesVolumeEqualsMass()
+        {
+            var mass = Density.FromKilogramsPerCubicMeter(2) * Volume.FromCubicMeters(3);
+            Assert.AreEqual(mass, Mass.FromKilograms(6));
+        }
+
+        [Test]
+        public static void VolumeTimesDensityEqualsMass()
+        {
+            var mass = Volume.FromCubicMeters(3) * Density.FromKilogramsPerCubicMeter(2);
+            Assert.AreEqual(mass, Mass.FromKilograms(6));
+        }
+
         protected override double KilogramsPerCubicCentimeterInOneKilogramPerCubicMeter
         {
             get { return 1e-6; }
diff --git a/UnitsNet.Tests/CustomCode/KinematicViscosityTests.cs b/UnitsNet.Tests/CustomCode/KinematicViscosityTests.cs
index 6d1228fcd0..07e5b51bc0 100644
--- a/UnitsNet.Tests/CustomCode/KinematicViscosityTests.cs
+++ b/UnitsNet.Tests/CustomCode/KinematicViscosityTests.cs
@@ -20,12 +20,48 @@
 // THE SOFTWARE.
 
 
+using NUnit.Framework;
 using System;
 
 namespace UnitsNet.Tests.CustomCode
 {
     public class KinematicViscosityTests : KinematicViscosityTestsBase
     {
+        [Test]
+        public static void KinematicViscosityDividedByLengthEqualsSpeed()
+        {
+            var speed = KinematicViscosity.FromSquareMetersPerSecond(4) / Length.FromMeters(2);
+            Assert.AreEqual(speed, Speed.FromMetersPerSecond(2));
+        }
+
+        [Test]
+        public static void KinematicViscosityTimesTimeSpanEqualsArea()
+        {
+            var area = KinematicViscosity.FromSquareMetersPerSecond(4) * TimeSpan.FromSeconds(2);
+            Assert.AreEqual(area, Area.FromSquareMeters(8));
+        }
+
+        [Test]
+        public static void TimeSpanTimesKinematicViscosityEqualsArea()
+        {
+            var area = TimeSpan.FromSeconds(2) * KinematicViscosity.FromSquareMetersPerSecond(4);
+            Assert.AreEqual(area, Area.FromSquareMeters(8));
+        }
+
+        [Test]
+        public static void KinematicViscosityTimesDurationEqualsArea()
+        {
+            var area = KinematicViscosity.FromSquareMetersPerSecond(4) * Duration.FromSeconds(2);
+            Assert.AreEqual(area, Area.FromSquareMeters(8));
+        }
+
+        [Test]
+        public static void DurationTimesKinematicViscosityEqualsArea()
+        {
+            var area = Duration.FromSeconds(2) * KinematicViscosity.FromSquareMetersPerSecond(4);
+            Assert.AreEqual(area, Area.FromSquareMeters(8));
+        }
+
         #region Overrides of KinematicViscosityTestsBase
 
         protected override double CentistokesInOneSquareMeterPerSecond
diff --git a/UnitsNet/CustomCode/UnitClasses/Density.extra.cs b/UnitsNet/CustomCode/UnitClasses/Density.extra.cs
new file mode 100644
index 0000000000..d3dce43785
--- /dev/null
+++ b/UnitsNet/CustomCode/UnitClasses/Density.extra.cs
@@ -0,0 +1,37 @@
+// 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.
+
+namespace UnitsNet
+{
+    public partial struct Density
+    {
+        public static Mass operator *(Density density, Volume volume)
+        {
+            return Mass.FromKilograms(density.KilogramsPerCubicMeter * volume.CubicMeters);
+        }
+
+        public static Mass operator *(Volume volume, Density density)
+        {
+            return Mass.FromKilograms(density.KilogramsPerCubicMeter * volume.CubicMeters);
+        }
+    }
+}
+
diff --git a/UnitsNet/CustomCode/UnitClasses/KinematicViscosity.extra.cs b/UnitsNet/CustomCode/UnitClasses/KinematicViscosity.extra.cs
new file mode 100644
index 0000000000..dfad665249
--- /dev/null
+++ b/UnitsNet/CustomCode/UnitClasses/KinematicViscosity.extra.cs
@@ -0,0 +1,54 @@
+// 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
+{
+    public partial struct KinematicViscosity
+    {
+        public static Speed operator /(KinematicViscosity kinematicViscosity, Length length)
+        {
+            return Speed.FromMetersPerSecond(kinematicViscosity.SquareMetersPerSecond / length.Meters);
+        }
+
+        public static Area operator *(KinematicViscosity kinematicViscosity, TimeSpan timeSpan)
+        {
+            return Area.FromSquareMeters(kinematicViscosity.SquareMetersPerSecond * timeSpan.TotalSeconds);
+        }
+
+        public static Area operator *(TimeSpan timeSpan, KinematicViscosity kinematicViscosity)
+        {
+            return Area.FromSquareMeters(kinematicViscosity.SquareMetersPerSecond * timeSpan.TotalSeconds);
+        }
+
+        public static Area operator *(KinematicViscosity kinematicViscosity, Duration duration)
+        {
+            return Area.FromSquareMeters(kinematicViscosity.SquareMetersPerSecond * duration.Seconds);
+        }
+
+        public static Area operator *(Duration duration, KinematicViscosity kinematicViscosity)
+        {
+            return Area.FromSquareMeters(kinematicViscosity.SquareMetersPerSecond * duration.Seconds);
+        }
+    }
+}
+
diff --git a/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs b/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs
index 84bd54cc18..9af15083cb 100644
--- a/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/Volume.extra.cs
@@ -23,15 +23,11 @@ namespace UnitsNet
 {
     public partial struct Volume
     {
-
-        public static Mass operator *(Volume volume, Density density)
-        {
-            return Mass.FromKilograms(volume.CubicMeters * density.KilogramsPerCubicMeter);
-        }
         public static Area operator /(Volume volume, Length length)
         {
             return Area.FromSquareMeters(volume.CubicMeters / length.Meters);
         }
+
         public static Length operator /(Volume volume, Area area)
         {
             return Length.FromMeters(volume.CubicMeters / area.SquareMeters);

From 17940439adab3613caf5a67a479872e3f313d8b8 Mon Sep 17 00:00:00 2001
From: Erik Ovegard <erik.ovegard@stormgeo.com>
Date: Sun, 31 Jan 2016 12:20:48 +0100
Subject: [PATCH 10/10] Fixes after review by anjdreas

---
 UnitsNet.Tests/CustomCode/AreaTests.cs             |  2 +-
 UnitsNet.Tests/CustomCode/ForceTests.cs            |  4 ++--
 UnitsNet.Tests/CustomCode/PowerTests.cs            |  6 +++---
 UnitsNet.Tests/CustomCode/PressureTests.cs         |  2 +-
 UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs  | 14 --------------
 UnitsNet.Tests/CustomCode/SpeedTests.cs            |  6 +++---
 UnitsNet.Tests/CustomCode/TorqueTests.cs           |  4 ++--
 .../UnitClasses/RotationalSpeed.extra.cs           | 10 ----------
 .../Scripts/UnitDefinitions/SpecificEnergy.json    |  4 ++--
 9 files changed, 14 insertions(+), 38 deletions(-)

diff --git a/UnitsNet.Tests/CustomCode/AreaTests.cs b/UnitsNet.Tests/CustomCode/AreaTests.cs
index 38800e5045..ad3d03e9d1 100644
--- a/UnitsNet.Tests/CustomCode/AreaTests.cs
+++ b/UnitsNet.Tests/CustomCode/AreaTests.cs
@@ -26,7 +26,7 @@ namespace UnitsNet.Tests.CustomCode
     public class AreaTests : AreaTestsBase
     {
         [Test]
-        public void AreaDevidedByLengthEqualsLength()
+        public void AreaDividedByLengthEqualsLength()
         {
             var length = Area.FromSquareMeters(50) / Length.FromMeters(5);
             Assert.AreEqual(length, Length.FromMeters(10));
diff --git a/UnitsNet.Tests/CustomCode/ForceTests.cs b/UnitsNet.Tests/CustomCode/ForceTests.cs
index 768c0197a4..046e2e28a5 100644
--- a/UnitsNet.Tests/CustomCode/ForceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ForceTests.cs
@@ -37,13 +37,13 @@ public void SpeedTimesForceEqualsPower()
             Assert.AreEqual(power, Power.FromWatts(270));
         }
         [Test]
-        public void ForceDevidedByMassEqualsAcceleration()
+        public void ForceDividedByMassEqualsAcceleration()
         {
             var acceleration= Force.FromNewtons(27)/Mass.FromKilograms(9);
             Assert.AreEqual(acceleration, Acceleration.FromMeterPerSecondSquared(3));
         }
         [Test]
-        public void ForceDevidedByAreaEqualsPressure()
+        public void ForceDividedByAreaEqualsPressure()
         {
             var pressure=Force.FromNewtons(81)/Area.FromSquareMeters(9);
             Assert.AreEqual(pressure, Pressure.FromNewtonsPerSquareMeter(9));
diff --git a/UnitsNet.Tests/CustomCode/PowerTests.cs b/UnitsNet.Tests/CustomCode/PowerTests.cs
index 63dffc7861..7b2598a2ac 100644
--- a/UnitsNet.Tests/CustomCode/PowerTests.cs
+++ b/UnitsNet.Tests/CustomCode/PowerTests.cs
@@ -26,19 +26,19 @@ namespace UnitsNet.Tests.CustomCode
     public class PowerTests : PowerTestsBase
     {
         [Test]
-        public void PowerDevidedBySpeedEqualsForce()
+        public void PowerDividedBySpeedEqualsForce()
         {
             var force= Power.FromWatts(15.0) / Speed.FromMetersPerSecond(3);
             Assert.AreEqual(force, Force.FromNewtons(5));
         }
         [Test]
-        public void PowerDevidedByRotationalSpeedEqualsForce()
+        public void PowerDividedByRotationalSpeedEqualsForce()
         {
             var torque = Power.FromWatts(15.0) / RotationalSpeed.FromRadiansPerSecond(3);
             Assert.AreEqual(torque, Torque.FromNewtonMeters(5));
         }
         [Test]
-        public void PowerDevidedByTorqueEqualsRotationalSpeed()
+        public void PowerDividedByTorqueEqualsRotationalSpeed()
         {
             var rotationalSpeed= Power.FromWatts(15.0) / Torque.FromNewtonMeters(3);
             Assert.AreEqual(rotationalSpeed, RotationalSpeed.FromRadiansPerSecond(5));
diff --git a/UnitsNet.Tests/CustomCode/PressureTests.cs b/UnitsNet.Tests/CustomCode/PressureTests.cs
index 32c25ed9e2..2d15add7dd 100644
--- a/UnitsNet.Tests/CustomCode/PressureTests.cs
+++ b/UnitsNet.Tests/CustomCode/PressureTests.cs
@@ -32,7 +32,7 @@ public void PressureTimesAreaEqualsForce()
         }
 
         [Test]
-        public void AreaTimePressureEqualsForce()
+        public void AreaTimesPressureEqualsForce()
         {
             var force = Area.FromSquareMeters(3) * Pressure.FromPascals(20);
             Assert.AreEqual(force, Force.FromNewtons(60));
diff --git a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
index c2207eb7b8..ef4cab1214 100644
--- a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
@@ -55,20 +55,6 @@ public void DurationTimesRotationalSpeedEqualsAngle()
             Assert.AreEqual(angle, Angle.FromRadians(90.0));
         }
 
-        [Test]
-        public void RotationalSpeedTimesForceEqualsPower()
-        {
-            var power = RotationalSpeed.FromRadiansPerSecond(10.0) * Force.FromNewtons(2.0);
-            Assert.AreEqual(power, Power.FromWatts(20.0));
-        }
-
-        [Test]
-        public void ForceTimesRotationalSpeedEqualsPower()
-        {
-            var power = Force.FromNewtons(2.0) * RotationalSpeed.FromRadiansPerSecond(10.0) ;
-            Assert.AreEqual(power, Power.FromWatts(20.0));
-        }
-
         protected override double RadiansPerSecondInOneRadianPerSecond
         {
             get { return 1; }
diff --git a/UnitsNet.Tests/CustomCode/SpeedTests.cs b/UnitsNet.Tests/CustomCode/SpeedTests.cs
index 8a36a100d4..b2ab7cf06a 100644
--- a/UnitsNet.Tests/CustomCode/SpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpeedTests.cs
@@ -27,7 +27,7 @@ namespace UnitsNet.Tests.CustomCode
     public class SpeedTests : SpeedTestsBase
     {
         [Test]
-        public void SpeedDevidedByTimeSpanEqualsAcceleration()
+        public void SpeedDividedByTimeSpanEqualsAcceleration()
         {
             var acceleration = Speed.FromMetersPerSecond(20) / TimeSpan.FromSeconds(2);
             Assert.AreEqual(acceleration, Acceleration.FromMeterPerSecondSquared(10));
@@ -41,7 +41,7 @@ public void SpeedTimesTimeSpanEqualsLength()
         }
 
         [Test]
-        public void SpeedDevidedByDurationEqualsAcceleration()
+        public void SpeedDividedByDurationEqualsAcceleration()
         {
             var acceleration = Speed.FromMetersPerSecond(20) / Duration.FromSeconds(2);
             Assert.AreEqual(acceleration, Acceleration.FromMeterPerSecondSquared(10));
@@ -55,7 +55,7 @@ public void SpeedTimesDurationEqualsLength()
         }
 
         [Test]
-        public void TimeSpanSpeedTimesEqualsLength()
+        public void TimeSpanTimesSpeedEqualsLength()
         {
             var length = TimeSpan.FromSeconds(2) * Speed.FromMetersPerSecond(20);
             Assert.AreEqual(length, Length.FromMeters(40));
diff --git a/UnitsNet.Tests/CustomCode/TorqueTests.cs b/UnitsNet.Tests/CustomCode/TorqueTests.cs
index dd227f7127..44c78994c1 100644
--- a/UnitsNet.Tests/CustomCode/TorqueTests.cs
+++ b/UnitsNet.Tests/CustomCode/TorqueTests.cs
@@ -25,13 +25,13 @@ namespace UnitsNet.Tests.CustomCode
     public class TorqueTests : TorqueTestsBase
     {
         [Test]
-        public void TorqueDevidedByLengthEqualsForce()
+        public void TorqueDividedByLengthEqualsForce()
         {
             var force = Torque.FromNewtonMeters(4) / Length.FromMeters(2);
             Assert.AreEqual(force, Force.FromNewtons(2));
         }
         [Test]
-        public void TorqueDevidedByForceEqualsLength()
+        public void TorqueDividedByForceEqualsLength()
         {
             var length= Torque.FromNewtonMeters(4) / Force.FromNewtons(2);
             Assert.AreEqual(length, Length.FromMeters(2));
diff --git a/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs b/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs
index e79f8039eb..b3dd40faa7 100644
--- a/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs
+++ b/UnitsNet/CustomCode/UnitClasses/RotationalSpeed.extra.cs
@@ -44,15 +44,5 @@ public partial struct RotationalSpeed
         {
             return Angle.FromRadians(rotationalSpeed.RadiansPerSecond * duration.Seconds);
         }
-
-        public static Power operator *(RotationalSpeed rotationalSpeed, Force force)
-        {
-            return Power.FromWatts(rotationalSpeed.RadiansPerSecond * force.Newtons);
-        }
-
-        public static Power operator *(Force force, RotationalSpeed rotationalSpeed)
-        {
-            return Power.FromWatts(rotationalSpeed.RadiansPerSecond * force.Newtons);
-        }
     }
 }
diff --git a/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json b/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json
index afcb8bff20..91018d4b6b 100644
--- a/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json
+++ b/UnitsNet/Scripts/UnitDefinitions/SpecificEnergy.json
@@ -2,7 +2,7 @@
     "Name": "SpecificEnergy",
     "BaseUnit": "JoulePerKilogram",
     "XmlDoc": "The SpecificEnergy",
-	"XmlDocRemarks": "https://en.wikipedia.org/wiki/Specific_energy",
+    "XmlDocRemarks": "https://en.wikipedia.org/wiki/Specific_energy",
     "Units": [
         {
             "SingularName": "JoulePerKilogram",
@@ -22,7 +22,7 @@
             "PluralName": "CaloriesPerGram",
             "FromUnitToBaseFunc": "x*4.184e3",
             "FromBaseToUnitFunc": "x/4.184e3",
-			      "Prefixes": ["Kilo"],
+            "Prefixes": ["Kilo"],
             "Localization": [
                 {
                     "Culture": "en-US",