Add Information, BitRate, Duration, and Frequency relations (#1699)

## Motivation

Fixes #1652.

UnitsNet already generates quantity relation operators from
`Common/UnitRelations.json`, but a few natural relations around
information, bit rate, duration, and frequency were missing. This meant
formulas such as information per duration, bit rate over frequency, and
refresh period from frequency had to go through scalar properties
instead of staying in UnitsNet quantity types.

## Changes

- Add relations for `Information = BitRate * Duration`, `1 = Frequency *
Duration`, and `BitRate = Information * Frequency`.
- Regenerate the affected quantity operators for `Information`,
`BitRate`, `Duration`, and `Frequency`.
- Add regression tests in the existing quantity test files that own
those relation scenarios.
- Document where generated relation tests should live.

## Validation

- `dotnet test UnitsNet.Tests --filter
"FullyQualifiedName~BitRateTests|FullyQualifiedName~DurationTests|FullyQualifiedName~FrequencyTests|FullyQualifiedName~InformationTests"`

Author: angularsen

Common/UnitRelations.json

@@ -2,6 +2,7 @@
   "1 = Area.SquareMeter * ReciprocalArea.InverseSquareMeter",
   "1 = Density.KilogramPerCubicMeter * SpecificVolume.CubicMeterPerKilogram",
   "1 = ElectricResistivity.OhmMeter * ElectricConductivity.SiemensPerMeter",
+  "1 = Frequency.PerSecond * Duration.Second",
   "1 = Length.Meter * ReciprocalLength.InverseMeter",
   "Acceleration.MeterPerSecondSquared = Jerk.MeterPerSecondCubed * Duration.Second",
   "AmountOfSubstance.Mole = MolarFlow.MolePerSecond * Duration.Second",
@@ -14,6 +15,7 @@
   "AreaDensity.KilogramPerSquareMeter = Density.KilogramPerCubicMeter * Length.Meter",
   "AreaMomentOfInertia.MeterToTheFourth = Area.SquareMeter * Area.SquareMeter",
   "AreaMomentOfInertia.MeterToTheFourth = Volume.CubicMeter * Length.Meter",
+  "BitRate.BitPerSecond = Information.Bit * Frequency.PerSecond",
   "double = SpecificEnergy.JoulePerKilogram * BrakeSpecificFuelConsumption.KilogramPerJoule",
   "DynamicViscosity.NewtonSecondPerMeterSquared = Density.KilogramPerCubicMeter * KinematicViscosity.SquareMeterPerSecond",
   "ElectricCharge.AmpereHour = ElectricCurrent.Ampere * Duration.Hour",
@@ -35,6 +37,7 @@
   "ForcePerLength.NewtonPerMeter = Force.Newton * ReciprocalLength.InverseMeter",
   "ForcePerLength.NewtonPerMeter = Pressure.NewtonPerSquareMeter * Length.Meter",
   "ForcePerLength.NewtonPerMeter = SpecificWeight.NewtonPerCubicMeter * Area.SquareMeter",
+  "Information.Bit = BitRate.BitPerSecond * Duration.Second",
   "KinematicViscosity.SquareMeterPerSecond = Length.Meter * Speed.MeterPerSecond",
   "Length.Meter = Area.SquareMeter * ReciprocalLength.InverseMeter",
   "Length.Meter = Speed.MeterPerSecond * Duration.Second",

Docs/adding-operator-overloads.md

@@ -5,6 +5,12 @@ There is a large number of operator overloads, to facilitate strongly typed comp
 Operators that can be expressed as a multiplication, division, or inverse relation may be generated from
 `Common/UnitRelations.json`; see [Quantity relations](quantity-and-unit-definition-schema.md#quantity-relations).
 
+For generated relation tests, use the existing relation-test ownership pattern:
+
+- Multiplication tests go in `<LeftQuantity>Tests.cs`, where `LeftQuantity` is the first operand in the explicit `UnitRelations.json` entry. Put the inferred reversed multiplication test there too.
+- Inferred division tests go in `<ResultQuantity>Tests.cs`, because the generated division operators are exposed by the result quantity.
+- Inverse relation tests go in each quantity's own test file, because each side gets its own `Inverse()` method.
+
 1. Put operator overload in `Length.extra.cs` if the **first parameter** is `Length`
 2. Add a short xmldoc summary as per the example below. You can add more descriptions if it is useful.
 3. Add a unit test case and place it in the equivalent file `LengthTests.cs`.

UnitsNet.Tests/CustomCode/BitRateTests.cs

@@ -22,6 +22,7 @@
 
 
 using System;
+using Xunit;
 
 namespace UnitsNet.Tests.CustomCode
 {
@@ -72,5 +73,37 @@ public class BitRateTests : BitRateTestsBase
         protected override double ExbibitsPerSecondInOneBitPerSecond => 8.67361738E-19;
         protected override double ExbibytesPerSecondInOneBitPerSecond => 1.0842021724855E-19;
         protected override double ExbioctetsPerSecondInOneBitPerSecond => 1.0842021724855E-19;
+
+        [Fact]
+        public void BitRateTimesDurationEqualsInformation()
+        {
+            Information information = BitRate.FromKilobitsPerSecond(10) * Duration.FromSeconds(3);
+
+            Assert.Equal(30000, information.Bits);
+        }
+
+        [Fact]
+        public void DurationTimesBitRateEqualsInformation()
+        {
+            Information information = Duration.FromMilliseconds(500) * BitRate.FromKilobitsPerSecond(10);
+
+            Assert.Equal(5000, information.Bits);
+        }
+
+        [Fact]
+        public void BitRateDividedByFrequencyEqualsInformation()
+        {
+            Information information = BitRate.FromKilobitsPerSecond(16) / Frequency.FromHertz(2);
+
+            Assert.Equal(8000, information.Bits);
+        }
+
+        [Fact]
+        public void BitRateDividedByInformationEqualsFrequency()
+        {
+            Frequency frequency = BitRate.FromKilobitsPerSecond(16) / Information.FromKilobytes(1);
+
+            Assert.Equal(2, frequency.Hertz);
+        }
     }
 }

UnitsNet.Tests/CustomCode/DurationTests.cs

@@ -242,5 +242,13 @@ public void DurationTimesForceChangeRate()
             Force force = Duration.FromSeconds(10) * ForceChangeRate.FromNewtonsPerSecond(100);
             Assert.Equal(Force.FromNewtons(1000), force);
         }
+
+        [Fact]
+        public void DurationInverseEqualsFrequency()
+        {
+            Frequency frequency = Duration.FromMilliseconds(250).Inverse();
+
+            Assert.Equal(4, frequency.Hertz);
+        }
     }
 }

UnitsNet.Tests/CustomCode/FrequencyTests.cs

@@ -2,6 +2,7 @@
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System;
+using Xunit;
 
 namespace UnitsNet.Tests
 {
@@ -30,5 +31,13 @@ public class FrequencyTests : FrequencyTestsBase
         protected override double RadiansPerSecondInOneHertz => 2 * Math.PI;
 
         protected override double BeatsPerMinuteInOneHertz => 60;
+
+        [Fact]
+        public void FrequencyInverseEqualsDuration()
+        {
+            Duration duration = Frequency.FromHertz(2).Inverse();
+
+            Assert.Equal(0.5, duration.Seconds);
+        }
     }
 }

UnitsNet.Tests/CustomCode/InformationTests.cs

@@ -91,5 +91,37 @@ public void OneKBHas1000Bytes()
         {
             Assert.Equal(1000, Information.FromKilobytes(1).Bytes);
         }
+
+        [Fact]
+        public void InformationDividedByDurationEqualsBitRate()
+        {
+            BitRate bitRate = Information.FromKilobytes(3) / Duration.FromSeconds(2);
+
+            Assert.Equal(12000, bitRate.BitsPerSecond);
+        }
+
+        [Fact]
+        public void InformationDividedByBitRateEqualsDuration()
+        {
+            Duration duration = Information.FromMegabits(3) / BitRate.FromMegabitsPerSecond(2);
+
+            Assert.Equal(1.5, duration.Seconds);
+        }
+
+        [Fact]
+        public void InformationTimesFrequencyEqualsBitRate()
+        {
+            BitRate bitRate = Information.FromBytes(100) * Frequency.FromHertz(2);
+
+            Assert.Equal(1600, bitRate.BitsPerSecond);
+        }
+
+        [Fact]
+        public void FrequencyTimesInformationEqualsBitRate()
+        {
+            BitRate bitRate = Frequency.FromHertz(2) * Information.FromBytes(100);
+
+            Assert.Equal(1600, bitRate.BitsPerSecond);
+        }
     }
 }