Merge pull request #162 from eriove/feature/massflowoverloads

Add overloads for MassFlow and fuel consumption

Author: angularsen

UnitsNet.Tests/CustomCode/BrakeSpecificFuelConsumptionTests.cs

@@ -46,5 +46,12 @@ public void DoubleDividedByBrakeSpecificFuelConsumptionEqualsSpecificEnergy()
             SpecificEnergy massFlow = 2.0 / BrakeSpecificFuelConsumption.FromKilogramsPerJoule(4.0);
             Assert.AreEqual(SpecificEnergy.FromJoulesPerKilogram(0.5), massFlow);
         }
+
+        [Test]
+        public void BrakeSpecificFuelConsumptionTimesSpecificEnergyEqualsEnergy()
+        {
+            double value = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(20.0) * SpecificEnergy.FromJoulesPerKilogram(10.0);
+            Assert.AreEqual(value, 200.0);
+        }
     }
 }

UnitsNet.Tests/CustomCode/MassFlowTests.cs

@@ -87,5 +87,12 @@ public void MassFlowDividedByPowerEqualsBrakeSpecificFuelConsumption()
             BrakeSpecificFuelConsumption bsfc = MassFlow.FromTonnesPerDay(20) / Power.FromKilowatts(20.0 / 24.0 * 1e6 / 180.0);
             Assert.AreEqual(bsfc.GramsPerKiloWattHour, 180.0, 1e-11);
         }
+
+        [Test]
+        public void MassFlowTimesSpecificEnergyEqualsPower()
+        {
+            Power power = MassFlow.FromKilogramsPerSecond(20.0) * SpecificEnergy.FromJoulesPerKilogram(10.0);
+            Assert.AreEqual(power, Power.FromWatts(200.0));
+        }
     }
 }

UnitsNet.Tests/CustomCode/PowerTests.cs

@@ -113,5 +113,19 @@ public void PowerTimesBrakeSpecificFuelConsumptionEqualsMassFlow()
             MassFlow massFlow = Power.FromKilowatts(20.0 / 24.0 * 1e6 / 180.0) * BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(180.0);
             Assert.AreEqual(massFlow.TonnesPerDay, 20.0, 1e-11);
         }
+
+        [Test]
+        public void PowerDividedByMassFlowEqualsSpecificEnergy()
+        {
+            SpecificEnergy specificEnergy = Power.FromWatts(15.0) / MassFlow.FromKilogramsPerSecond(3);
+            Assert.AreEqual(specificEnergy, SpecificEnergy.FromJoulesPerKilogram(5));
+        }
+
+        [Test]
+        public void PowerDividedBySpecificEnergyEqualsMassFlow()
+        {
+            MassFlow massFlow = Power.FromWatts(15.0) / SpecificEnergy.FromJoulesPerKilogram(3);
+            Assert.AreEqual(massFlow, MassFlow.FromKilogramsPerSecond(5));
+        }
     }
 }

UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs

@@ -62,5 +62,19 @@ public void DoubleDividedBySpecificEnergyEqualsBrakeSpecificFuelConsumption()
             BrakeSpecificFuelConsumption bsfc = 2.0 / SpecificEnergy.FromJoulesPerKilogram(4.0);
             Assert.AreEqual(BrakeSpecificFuelConsumption.FromKilogramsPerJoule(0.5), bsfc);
         }
+
+        [Test]
+        public void SpecificEnergyTimesMassFlowEqualsPower()
+        {
+            Power power = SpecificEnergy.FromJoulesPerKilogram(10.0) * MassFlow.FromKilogramsPerSecond(20.0);
+            Assert.AreEqual(power, Power.FromWatts(200.0));
+        }
+
+        [Test]
+        public void SpecificEnergyTimesBrakeSpecificFuelConsumptionEqualsEnergy()
+        {
+            double value = SpecificEnergy.FromJoulesPerKilogram(10.0) * BrakeSpecificFuelConsumption.FromKilogramsPerJoule(20.0);
+            Assert.AreEqual(value, 200.0);
+        }
     }
 }

UnitsNet/CustomCode/UnitClasses/BrakeSpecificFuelConsumption.extra.cs

@@ -32,5 +32,10 @@ public partial struct BrakeSpecificFuelConsumption
         {
             return SpecificEnergy.FromJoulesPerKilogram(value / bsfc.KilogramsPerJoule);
         }
+
+        public static double operator *(BrakeSpecificFuelConsumption bsfc, SpecificEnergy specificEnergy)
+        {
+            return specificEnergy.JoulesPerKilogram * bsfc.KilogramsPerJoule;
+        }
     }
 }

UnitsNet/CustomCode/UnitClasses/MassFlow.extra.cs

@@ -54,5 +54,10 @@ public partial struct MassFlow
         {
             return BrakeSpecificFuelConsumption.FromKilogramsPerJoule(massFlow.KilogramsPerSecond / power.Watts);
         }
+
+        public static Power operator *(MassFlow massFlow, SpecificEnergy specificEnergy)
+        {
+            return Power.FromWatts(massFlow.KilogramsPerSecond * specificEnergy.JoulesPerKilogram);
+        }
     }
 }

UnitsNet/CustomCode/UnitClasses/Power.extra.cs

@@ -69,5 +69,15 @@ public partial struct Power
         {
             return MassFlow.FromKilogramsPerSecond(bsfc.KilogramsPerJoule * power.Watts);
         }
+
+        public static SpecificEnergy operator /(Power power, MassFlow massFlow)
+        {
+            return SpecificEnergy.FromJoulesPerKilogram(power.Watts / massFlow.KilogramsPerSecond);
+        }
+
+        public static MassFlow operator /(Power power, SpecificEnergy specificEnergy)
+        {
+            return MassFlow.FromKilogramsPerSecond(power.Watts / specificEnergy.JoulesPerKilogram);
+        }
     }
 }

UnitsNet/CustomCode/UnitClasses/SpecificEnergy.extra.cs

@@ -33,9 +33,19 @@ public partial struct SpecificEnergy
             return Energy.FromJoules(specificEnergy.JoulesPerKilogram*mass.Kilograms);
         }
 
-        public static BrakeSpecificFuelConsumption operator /(double value, SpecificEnergy  bsfc)
+        public static BrakeSpecificFuelConsumption operator /(double value, SpecificEnergy specificEnergy)
         {
-            return BrakeSpecificFuelConsumption.FromKilogramsPerJoule(value / bsfc.JoulesPerKilogram);
+            return BrakeSpecificFuelConsumption.FromKilogramsPerJoule(value / specificEnergy.JoulesPerKilogram);
+        }
+
+        public static double operator *(SpecificEnergy specificEnergy, BrakeSpecificFuelConsumption bsfc)
+        {
+            return specificEnergy.JoulesPerKilogram * bsfc.KilogramsPerJoule;
+        }
+
+        public static Power operator *(SpecificEnergy specificEnergy, MassFlow massFlow)
+        {
+            return Power.FromWatts(massFlow.KilogramsPerSecond * specificEnergy.JoulesPerKilogram);
         }
     }
 }