Add operators for energy quantities (#1105)

* added operators to work with entropy

* Add convenience operator to multiply energy times frequency

* added operators to work with Energy, Entropy, SpecificEnergy, SpecificEntropy, Mass, and TemperatureDelta

* changed unit test factor of 1 because it does not cover the wrong operator being used, e.g. division instead of multiplication

* changed multiplication order of SpecificEntropy times Mass equals Entropy to improve readability

Author: JMarianczuk

UnitsNet.Tests/CustomCode/EnergyTests.cs

@@ -120,5 +120,47 @@ public void EnergyDividedByDurationEqualsPower()
             Power p = Energy.FromWattHours(20) / Duration.FromHours(5);
             Assert.Equal(4, p.Watts);
         }
+
+        [Fact]
+        public void EnergyTimesFrequencyEqualsPower()
+        {
+            Power p = Energy.FromJoules(25) * Frequency.FromPerSecond(5);
+            Assert.Equal(125, p.Watts);
+        }
+
+        [Fact]
+        public void FrequencyTimesEnergyEqualsPower()
+        {
+            Power p = Frequency.FromCyclesPerHour(100) * Energy.FromWattHours(2);
+            Assert.Equal(200, p.Watts);
+        }
+
+        [Fact]
+        public void EnergyDividedByTemperatureDeltaEqualsEntropy()
+        {
+            Entropy e = Energy.FromJoules(16) / TemperatureDelta.FromKelvins(8);
+            Assert.Equal(Entropy.FromJoulesPerKelvin(2), e);
+        }
+
+        [Fact]
+        public void EnergyDividedByEntropyEqualsTemperatureDelta()
+        {
+            TemperatureDelta t = Energy.FromJoules(15) / Entropy.FromJoulesPerKelvin(3);
+            Assert.Equal(TemperatureDelta.FromKelvins(5), t);
+        }
+
+        [Fact]
+        public void EnergyDividedByMassEqualsSpecificEnergy()
+        {
+            SpecificEnergy e = Energy.FromJoules(10) / Mass.FromKilograms(2);
+            Assert.Equal(SpecificEnergy.FromJoulesPerKilogram(5), e);
+        }
+
+        [Fact]
+        public void EnergyDividedBySpecificEnergyEqualsMass()
+        {
+            Mass m = Energy.FromJoules(24) / SpecificEnergy.FromJoulesPerKilogram(8);
+            Assert.Equal(Mass.FromKilograms(3), m);
+        }
     }
 }

UnitsNet.Tests/CustomCode/EntropyTests.cs

@@ -22,6 +22,7 @@
 
 
 using System;
+using Xunit;
 
 namespace UnitsNet.Tests.CustomCode
 {
@@ -35,5 +36,12 @@ public class EntropyTests : EntropyTestsBase
         protected override double KilojoulesPerDegreeCelsiusInOneJoulePerKelvin => 1e-3;
         protected override double KilojoulesPerKelvinInOneJoulePerKelvin => 1e-3;
         protected override double MegajoulesPerKelvinInOneJoulePerKelvin => 1e-6;
+
+        [Fact]
+        public void EntropyDividedByMassEqualsSpecificEntropy()
+        {
+            SpecificEntropy specificEntropy = Entropy.FromJoulesPerKelvin(9) / Mass.FromKilograms(3);
+            Assert.Equal(SpecificEntropy.FromJoulesPerKilogramKelvin(3), specificEntropy);
+        }
     }
 }

UnitsNet.Tests/CustomCode/SpecificEnergyTests.cs

@@ -80,5 +80,12 @@ public void SpecificEnergyTimesBrakeSpecificFuelConsumptionEqualsEnergy()
             double value = SpecificEnergy.FromJoulesPerKilogram(10.0) * BrakeSpecificFuelConsumption.FromKilogramsPerJoule(20.0);
             Assert.Equal(200d, value);
         }
+
+        [Fact]
+        public void SpecificEnergyDividedByTemperatureDeltaEqualsSpecificEntropy()
+        {
+            SpecificEntropy specificEntropy = SpecificEnergy.FromJoulesPerKilogram(4) / TemperatureDelta.FromKelvins(0.5);
+            Assert.Equal(SpecificEntropy.FromJoulesPerKilogramKelvin(8), specificEntropy);
+        }
     }
 }

UnitsNet.Tests/CustomCode/SpecificEntropyTests.cs

@@ -22,6 +22,7 @@
 
 
 using System;
+using Xunit;
 
 namespace UnitsNet.Tests.CustomCode
 {
@@ -37,5 +38,19 @@ public class SpecificEntropyTests : SpecificEntropyTestsBase
         protected override double CaloriesPerGramKelvinInOneJoulePerKilogramKelvin => 2.390057e-4;
         protected override double KilocaloriesPerGramKelvinInOneJoulePerKilogramKelvin => 2.390057e-7;
         protected override double BtusPerPoundFahrenheitInOneJoulePerKilogramKelvin => 2.3884589662749594e-4;
+
+        [Fact]
+        public void SpecificEntropyTimesMassEqualsEntropy()
+        {
+            Entropy e = SpecificEntropy.FromJoulesPerKilogramKelvin(24) * Mass.FromKilograms(2);
+            Assert.Equal(Entropy.FromJoulesPerKelvin(48), e);
+        }
+
+        [Fact]
+        public void MassTimesSpecificEntropyEqualsEntropy()
+        {
+            Entropy e = Mass.FromKilograms(5) * SpecificEntropy.FromJoulesPerKilogramKelvin(7);
+            Assert.Equal(Entropy.FromJoulesPerKelvin(35), e);
+        }
     }
 }

UnitsNet.Tests/CustomCode/TemperatureDeltaTests.cs

@@ -38,10 +38,31 @@ public class TemperatureDeltaTests : TemperatureDeltaTestsBase
         protected override double MillidegreesCelsiusInOneKelvin => 1E3;
 
         [Fact]
-        public void TemperatureDeltaTimesSpecificEntropyEqualsSpecificEnergy()
+        public void SpecificEntropyTimesTemperatureDeltaEqualsSpecificEnergy()
         {
             SpecificEnergy specificEnergy =  SpecificEntropy.FromJoulesPerKilogramKelvin(10) * TemperatureDelta.FromKelvins(6);
-            Assert.Equal(specificEnergy, SpecificEnergy.FromJoulesPerKilogram(60));
+            Assert.Equal(SpecificEnergy.FromJoulesPerKilogram(60), specificEnergy);
+        }
+
+        [Fact]
+        public void TemperatureDeltaTimesSpecificEntropyEqualsSpecificEnergy()
+        {
+            SpecificEnergy specificEnergy = TemperatureDelta.FromKelvins(10) * SpecificEntropy.FromJoulesPerKilogramKelvin(14);
+            Assert.Equal(SpecificEnergy.FromJoulesPerKilogram(140), specificEnergy);
+        }
+
+        [Fact]
+        public void EntropyTimesTemperatureDeltaEqualsEnergy()
+        {
+            Energy energy = Entropy.FromKilojoulesPerKelvin(3) * TemperatureDelta.FromKelvins(7);
+            Assert.Equal(Energy.FromKilojoules(21), energy);
+        }
+
+        [Fact]
+        public void TemperatureDeltaTimesEntropyEqualsEnergy()
+        {
+            Energy energy = TemperatureDelta.FromKelvins(20) * Entropy.FromJoulesPerKelvin(4);
+            Assert.Equal(Energy.FromJoules(80), energy);
         }
     }
 }

UnitsNet/CustomCode/Quantities/Energy.extra.cs

@@ -18,5 +18,41 @@ public partial struct Energy
         {
             return Power.FromWatts(energy.Joules / duration.Seconds);
         }
+
+        /// <summary>Get <see cref="Power"/> from <see cref="Energy"/> times <see cref="Frequency"/>.</summary>
+        public static Power operator *(Energy energy, Frequency frequency)
+        {
+            return Power.FromWatts(energy.Joules * frequency.PerSecond);
+        }
+
+        /// <summary>Get <see cref="Power"/> from <see cref="Frequency"/> times <see cref="Power"/>.</summary>
+        public static Power operator *(Frequency frequency, Energy energy)
+        {
+            return Power.FromWatts(energy.Joules * frequency.PerSecond);
+        }
+
+        /// <summary>Get <see cref="Entropy"/> from <see cref="Energy"/> divided by <see cref="TemperatureDelta"/> </summary>
+        public static Entropy operator /(Energy energy, TemperatureDelta temperatureDelta)
+        {
+            return Entropy.FromJoulesPerKelvin(energy.Joules / temperatureDelta.Kelvins);
+        }
+
+        /// <summary>Get <see cref="TemperatureDelta"/> from <see cref="Energy"/> divided by <see cref="Entropy"/>.</summary>
+        public static TemperatureDelta operator /(Energy energy, Entropy entropy)
+        {
+            return TemperatureDelta.FromKelvins(energy.Joules / entropy.JoulesPerKelvin);
+        }
+        
+        /// <summary>Get <see cref="SpecificEnergy"/> from <see cref="Energy"/> divided by <see cref="Mass"/> </summary>
+        public static SpecificEnergy operator /(Energy energy, Mass mass)
+        {
+            return SpecificEnergy.FromJoulesPerKilogram(energy.Joules / mass.Kilograms);
+        }
+        
+        /// <summary>Get <see cref="Mass"/> from <see cref="Energy"/> divided by <see cref="SpecificEnergy"/>.</summary>
+        public static Mass operator /(Energy energy, SpecificEnergy specificEnergy)
+        {
+            return Mass.FromKilograms(energy.Joules / specificEnergy.JoulesPerKilogram);
+        }
     }
 }

UnitsNet/CustomCode/Quantities/Entropy.extra.cs

@@ -0,0 +1,14 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen ([email protected]). Maintained at https://github.com/angularsen/UnitsNet.
+
+namespace UnitsNet
+{
+    public partial struct Entropy
+    {
+        /// <summary>Get <see cref="SpecificEntropy"/> from <see cref="Entropy"/> divided by <see cref="Mass"/>.</summary>
+        public static SpecificEntropy operator /(Entropy entropy, Mass mass)
+        {
+            return SpecificEntropy.FromJoulesPerKilogramKelvin(entropy.JoulesPerKelvin / mass.Kilograms);
+        }
+    }
+}

UnitsNet/CustomCode/Quantities/SpecificEnergy.extra.cs

@@ -34,5 +34,11 @@ public partial struct SpecificEnergy
         {
             return Power.FromWatts(massFlow.KilogramsPerSecond * specificEnergy.JoulesPerKilogram);
         }
+        
+        /// <summary>Get <see cref="SpecificEntropy"/> from <see cref="SpecificEnergy"/> divided by <see cref="TemperatureDelta"/>.</summary>
+        public static SpecificEntropy operator /(SpecificEnergy specificEnergy, TemperatureDelta temperatureDelta)
+        {
+            return SpecificEntropy.FromJoulesPerKilogramKelvin(specificEnergy.JoulesPerKilogram / temperatureDelta.Kelvins);
+        }
     }
 }

UnitsNet/CustomCode/Quantities/SpecificEntropy.extra.cs

@@ -0,0 +1,20 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen ([email protected]). Maintained at https://github.com/angularsen/UnitsNet.
+
+namespace UnitsNet
+{
+    public partial struct SpecificEntropy
+    {
+        /// <summary>Get <see cref="Entropy"/> from <see cref="SpecificEntropy"/> times <see cref="Mass"/>.</summary>
+        public static Entropy operator *(SpecificEntropy specificEntropy, Mass mass)
+        {
+            return Entropy.FromJoulesPerKelvin(specificEntropy.JoulesPerKilogramKelvin * mass.Kilograms);
+        }
+
+        /// <summary>Get <see cref="Entropy"/> from <see cref="Mass"/> times <see cref="SpecificEntropy"/>.</summary>
+        public static Entropy operator *(Mass mass, SpecificEntropy specificEntropy)
+        {
+            return Entropy.FromJoulesPerKelvin(specificEntropy.JoulesPerKilogramKelvin * mass.Kilograms);
+        }
+    }
+}

UnitsNet/CustomCode/Quantities/TemperatureDelta.extra.cs

@@ -22,5 +22,17 @@ public partial struct TemperatureDelta
         {
             return specificEntropy * temperatureDelta;
         }
+
+        /// <summary>Get <see cref="Energy"/> from <see cref="Entropy"/> times <see cref="TemperatureDelta"/>.</summary>
+        public static Energy operator *(Entropy entropy, TemperatureDelta temperatureDelta)
+        {
+            return Energy.FromJoules(entropy.JoulesPerKelvin * temperatureDelta.Kelvins);
+        }
+        
+        /// <summary>Get <see cref="Energy"/> from <see cref="TemperatureDelta"/> times <see cref="Entropy"/>.</summary>
+        public static Energy operator *(TemperatureDelta temperatureDelta, Entropy entropy)
+        {
+            return Energy.FromJoules(entropy.JoulesPerKelvin * temperatureDelta.Kelvins);
+        }
     }
 }