Added operators

ulflind · ulflind · commit 8f982871b272 · 2015-12-23T14:49:28.000+01:00
diff --git 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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

Original file line number	Diff line number	Diff line change
`@@ -19,10 +19,19 @@`
`19`	`19`	`// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN`
`20`	`20`	`// THE SOFTWARE.`
`21`	`21`
	`22`	`+using NUnit.Framework;`
	`23`	`+`
`22`	`24`	`namespace UnitsNet.Tests.CustomCode`
`23`	`25`	`{`
`24`	`26`	`public class AreaTests : AreaTestsBase`
`25`	`27`	`{`
	`28`	`+ [Test]`
	`29`	`+ public void AreaDevidedByLengthEqualsLength()`
	`30`	`+ {`
	`31`	`+ var length = Area.FromSquareMeters(50) / Length.FromMeters(5);`
	`32`	`+ Assert.AreEqual(length, Length.FromMeters(10));`
	`33`	`+ }`
	`34`	`+`
`26`	`35`	`protected override double SquareCentimetersInOneSquareMeter`
`27`	`36`	`{`
`28`	`37`	`get { return 1E4; }`
Original file line number	Diff line number	Diff line change
`@@ -19,11 +19,19 @@`
`19`	`19`	`// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN`
`20`	`20`	`// THE SOFTWARE.`
`21`	`21`	`using NUnit.Framework;`
	`22`	`+using System;`
`22`	`23`
`23`	`24`	`namespace UnitsNet.Tests.CustomCode`
`24`	`25`	`{`
`25`	`26`	`public class MassTests : MassTestsBase`
`26`	`27`	`{`
	`28`	`+ [Test]`
	`29`	`+ public void MassDividedByTimeEqualsMassFlow()`
	`30`	`+ {`
	`31`	`+ var massFlow= Mass.FromKilograms(18.0) / TimeSpan.FromSeconds(6);`
	`32`	`+ Assert.AreEqual(massFlow, MassFlow.FromKilogramsPerSecond(3.0));`
	`33`	`+ }`
	`34`	`+`
`27`	`35`	`[Test]`
`28`	`36`	`public void MassDividedByVolumeEqualsDensity()`
`29`	`37`	`{`
Original file line number	Diff line number	Diff line change
`@@ -20,11 +20,20 @@`
`20`	`20`	`// THE SOFTWARE.`
`21`	`21`
`22`	`22`	`using System;`
	`23`	`+using NUnit.Framework;`
`23`	`24`
`24`	`25`	`namespace UnitsNet.Tests.CustomCode`
`25`	`26`	`{`
	`27`	`+`
`26`	`28`	`public class RotationalSpeedTests : RotationalSpeedTestsBase`
`27`	`29`	`{`
	`30`	`+ [Test]`
	`31`	`+ public void RotationalSpeedTimesTimeSpanEqualsAngle()`
	`32`	`+ {`
	`33`	`+ var angle = RotationalSpeed.FromRadiansPerSecond(10.0)*TimeSpan.FromSeconds(9.0);`
	`34`	`+ Assert.AreEqual(angle, Angle.FromRadians(90.0));`
	`35`	`+ }`
	`36`	`+`
`28`	`37`	`protected override double RadiansPerSecondInOneRevolutionPerSecond`
`29`	`38`	`{`
`30`	`39`	`get`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,12 @@ public void TorqueDevidedByLengthEqualsForce()`
`30`	`30`	`var force = Torque.FromNewtonMeters(4) / Length.FromMeters(2);`
`31`	`31`	`Assert.AreEqual(force, Force.FromNewtons(2));`
`32`	`32`	`}`
	`33`	`+ [Test]`
	`34`	`+ public void TorqueDevidedByForceEqualsLength()`
	`35`	`+ {`
	`36`	`+ var length= Torque.FromNewtonMeters(4) / Force.FromNewtons(2);`
	`37`	`+ Assert.AreEqual(length, Length.FromMeters(2));`
	`38`	`+ }`
`33`	`39`
`34`	`40`	`protected override double KilogramForceCentimetersInOneNewtonMeter`
`35`	`41`	`{`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,18 @@ namespace UnitsNet.Tests.CustomCode`
`25`	`25`	`{`
`26`	`26`	`public class VolumeTests : VolumeTestsBase`
`27`	`27`	`{`
	`28`	`+ [Test]`
	`29`	`+ public void VolumeDividedByLengthEqualsArea()`
	`30`	`+ {`
	`31`	`+ var area = Volume.FromCubicMeters(15) / Length.FromMeters(5);`
	`32`	`+ Assert.AreEqual(area, Area.FromSquareMeters(3));`
	`33`	`+ }`
	`34`	`+ [Test]`
	`35`	`+ public void VolumeDividedByAreaEqualsLength()`
	`36`	`+ {`
	`37`	`+ var length= Volume.FromCubicMeters(15) / Area.FromSquareMeters(5);`
	`38`	`+ Assert.AreEqual(length, Length.FromMeters(3));`
	`39`	`+ }`
`28`	`40`	`[Test]`
`29`	`41`	`public void VolumeTimesDensityEqualsMass()`
`30`	`42`	`{`