From ef14198c3ea8fc212902c973052130c81ef62d39 Mon Sep 17 00:00:00 2001 From: Jeff Walker Date: Wed, 26 Feb 2020 16:52:57 -0800 Subject: [PATCH] add 'per second' unit to Frequency (#753) --- Common/UnitDefinitions/Frequency.json | 12 +++++++++ .../NumberToFrequencyExtensionsTest.g.cs | 4 +++ .../NumberToFrequencyExtensions.g.cs | 4 +++ UnitsNet.Tests/CustomCode/FrequencyTests.cs | 2 ++ .../TestsBase/FrequencyTestsBase.g.cs | 27 ++++++++++++++----- .../GeneratedCode/Quantities/Frequency.g.cs | 17 ++++++++++++ .../GeneratedCode/UnitAbbreviationsCache.g.cs | 1 + .../GeneratedCode/Units/FrequencyUnit.g.cs | 1 + .../GeneratedCode/Quantities/Frequency.g.cs | 17 ++++++++++++ .../GeneratedCode/UnitAbbreviationsCache.g.cs | 1 + UnitsNet/GeneratedCode/UnitConverter.g.cs | 2 ++ .../GeneratedCode/Units/FrequencyUnit.g.cs | 1 + 12 files changed, 83 insertions(+), 6 deletions(-) diff --git a/Common/UnitDefinitions/Frequency.json b/Common/UnitDefinitions/Frequency.json index 2a98a69c5d..4769c8c296 100644 --- a/Common/UnitDefinitions/Frequency.json +++ b/Common/UnitDefinitions/Frequency.json @@ -67,6 +67,18 @@ "Abbreviations": [ "bpm" ] } ] + }, + { + "SingularName": "PerSecond", + "PluralName": "PerSecond", + "FromUnitToBaseFunc": "x", + "FromBaseToUnitFunc": "x", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "s⁻¹" ] + } + ] } ] } diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs index 936cea2dc2..77824e7c6a 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs @@ -52,6 +52,10 @@ public void NumberToKilohertzTest() => public void NumberToMegahertzTest() => Assert.Equal(Frequency.FromMegahertz(2), 2.Megahertz()); + [Fact] + public void NumberToPerSecondTest() => + Assert.Equal(Frequency.FromPerSecond(2), 2.PerSecond()); + [Fact] public void NumberToRadiansPerSecondTest() => Assert.Equal(Frequency.FromRadiansPerSecond(2), 2.RadiansPerSecond()); diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs index 9ee226c0e3..0bf4187ea5 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs @@ -54,6 +54,10 @@ public static Frequency Kilohertz(this T value) => public static Frequency Megahertz(this T value) => Frequency.FromMegahertz(Convert.ToDouble(value)); + /// + public static Frequency PerSecond(this T value) => + Frequency.FromPerSecond(Convert.ToDouble(value)); + /// public static Frequency RadiansPerSecond(this T value) => Frequency.FromRadiansPerSecond(Convert.ToDouble(value)); diff --git a/UnitsNet.Tests/CustomCode/FrequencyTests.cs b/UnitsNet.Tests/CustomCode/FrequencyTests.cs index 41253fe566..f030b07c5b 100644 --- a/UnitsNet.Tests/CustomCode/FrequencyTests.cs +++ b/UnitsNet.Tests/CustomCode/FrequencyTests.cs @@ -17,6 +17,8 @@ public class FrequencyTests : FrequencyTestsBase protected override double TerahertzInOneHertz => 1e-12; + protected override double PerSecondInOneHertz => 1; + protected override double CyclesPerHourInOneHertz => 3600; protected override double CyclesPerMinuteInOneHertz => 60; diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs index 574f9b5708..fc354934c0 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/FrequencyTestsBase.g.cs @@ -43,6 +43,7 @@ public abstract partial class FrequencyTestsBase protected abstract double HertzInOneHertz { get; } protected abstract double KilohertzInOneHertz { get; } protected abstract double MegahertzInOneHertz { get; } + protected abstract double PerSecondInOneHertz { get; } protected abstract double RadiansPerSecondInOneHertz { get; } protected abstract double TerahertzInOneHertz { get; } @@ -54,6 +55,7 @@ public abstract partial class FrequencyTestsBase protected virtual double HertzTolerance { get { return 1e-5; } } protected virtual double KilohertzTolerance { get { return 1e-5; } } protected virtual double MegahertzTolerance { get { return 1e-5; } } + protected virtual double PerSecondTolerance { get { return 1e-5; } } protected virtual double RadiansPerSecondTolerance { get { return 1e-5; } } protected virtual double TerahertzTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global @@ -124,6 +126,7 @@ public void HertzToFrequencyUnits() AssertEx.EqualTolerance(HertzInOneHertz, hertz.Hertz, HertzTolerance); AssertEx.EqualTolerance(KilohertzInOneHertz, hertz.Kilohertz, KilohertzTolerance); AssertEx.EqualTolerance(MegahertzInOneHertz, hertz.Megahertz, MegahertzTolerance); + AssertEx.EqualTolerance(PerSecondInOneHertz, hertz.PerSecond, PerSecondTolerance); AssertEx.EqualTolerance(RadiansPerSecondInOneHertz, hertz.RadiansPerSecond, RadiansPerSecondTolerance); AssertEx.EqualTolerance(TerahertzInOneHertz, hertz.Terahertz, TerahertzTolerance); } @@ -159,13 +162,17 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity06.Megahertz, MegahertzTolerance); Assert.Equal(FrequencyUnit.Megahertz, quantity06.Unit); - var quantity07 = Frequency.From(1, FrequencyUnit.RadianPerSecond); - AssertEx.EqualTolerance(1, quantity07.RadiansPerSecond, RadiansPerSecondTolerance); - Assert.Equal(FrequencyUnit.RadianPerSecond, quantity07.Unit); + var quantity07 = Frequency.From(1, FrequencyUnit.PerSecond); + AssertEx.EqualTolerance(1, quantity07.PerSecond, PerSecondTolerance); + Assert.Equal(FrequencyUnit.PerSecond, quantity07.Unit); - var quantity08 = Frequency.From(1, FrequencyUnit.Terahertz); - AssertEx.EqualTolerance(1, quantity08.Terahertz, TerahertzTolerance); - Assert.Equal(FrequencyUnit.Terahertz, quantity08.Unit); + var quantity08 = Frequency.From(1, FrequencyUnit.RadianPerSecond); + AssertEx.EqualTolerance(1, quantity08.RadiansPerSecond, RadiansPerSecondTolerance); + Assert.Equal(FrequencyUnit.RadianPerSecond, quantity08.Unit); + + var quantity09 = Frequency.From(1, FrequencyUnit.Terahertz); + AssertEx.EqualTolerance(1, quantity09.Terahertz, TerahertzTolerance); + Assert.Equal(FrequencyUnit.Terahertz, quantity09.Unit); } @@ -193,6 +200,7 @@ public void As() AssertEx.EqualTolerance(HertzInOneHertz, hertz.As(FrequencyUnit.Hertz), HertzTolerance); AssertEx.EqualTolerance(KilohertzInOneHertz, hertz.As(FrequencyUnit.Kilohertz), KilohertzTolerance); AssertEx.EqualTolerance(MegahertzInOneHertz, hertz.As(FrequencyUnit.Megahertz), MegahertzTolerance); + AssertEx.EqualTolerance(PerSecondInOneHertz, hertz.As(FrequencyUnit.PerSecond), PerSecondTolerance); AssertEx.EqualTolerance(RadiansPerSecondInOneHertz, hertz.As(FrequencyUnit.RadianPerSecond), RadiansPerSecondTolerance); AssertEx.EqualTolerance(TerahertzInOneHertz, hertz.As(FrequencyUnit.Terahertz), TerahertzTolerance); } @@ -230,6 +238,10 @@ public void ToUnit() AssertEx.EqualTolerance(MegahertzInOneHertz, (double)megahertzQuantity.Value, MegahertzTolerance); Assert.Equal(FrequencyUnit.Megahertz, megahertzQuantity.Unit); + var persecondQuantity = hertz.ToUnit(FrequencyUnit.PerSecond); + AssertEx.EqualTolerance(PerSecondInOneHertz, (double)persecondQuantity.Value, PerSecondTolerance); + Assert.Equal(FrequencyUnit.PerSecond, persecondQuantity.Unit); + var radianpersecondQuantity = hertz.ToUnit(FrequencyUnit.RadianPerSecond); AssertEx.EqualTolerance(RadiansPerSecondInOneHertz, (double)radianpersecondQuantity.Value, RadiansPerSecondTolerance); Assert.Equal(FrequencyUnit.RadianPerSecond, radianpersecondQuantity.Unit); @@ -250,6 +262,7 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Frequency.FromHertz(hertz.Hertz).Hertz, HertzTolerance); AssertEx.EqualTolerance(1, Frequency.FromKilohertz(hertz.Kilohertz).Hertz, KilohertzTolerance); AssertEx.EqualTolerance(1, Frequency.FromMegahertz(hertz.Megahertz).Hertz, MegahertzTolerance); + AssertEx.EqualTolerance(1, Frequency.FromPerSecond(hertz.PerSecond).Hertz, PerSecondTolerance); AssertEx.EqualTolerance(1, Frequency.FromRadiansPerSecond(hertz.RadiansPerSecond).Hertz, RadiansPerSecondTolerance); AssertEx.EqualTolerance(1, Frequency.FromTerahertz(hertz.Terahertz).Hertz, TerahertzTolerance); } @@ -398,6 +411,7 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Assert.Equal("1 Hz", new Frequency(1, FrequencyUnit.Hertz).ToString()); Assert.Equal("1 kHz", new Frequency(1, FrequencyUnit.Kilohertz).ToString()); Assert.Equal("1 MHz", new Frequency(1, FrequencyUnit.Megahertz).ToString()); + Assert.Equal("1 s⁻¹", new Frequency(1, FrequencyUnit.PerSecond).ToString()); Assert.Equal("1 rad/s", new Frequency(1, FrequencyUnit.RadianPerSecond).ToString()); Assert.Equal("1 THz", new Frequency(1, FrequencyUnit.Terahertz).ToString()); } @@ -420,6 +434,7 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 Hz", new Frequency(1, FrequencyUnit.Hertz).ToString(swedishCulture)); Assert.Equal("1 kHz", new Frequency(1, FrequencyUnit.Kilohertz).ToString(swedishCulture)); Assert.Equal("1 MHz", new Frequency(1, FrequencyUnit.Megahertz).ToString(swedishCulture)); + Assert.Equal("1 s⁻¹", new Frequency(1, FrequencyUnit.PerSecond).ToString(swedishCulture)); Assert.Equal("1 rad/s", new Frequency(1, FrequencyUnit.RadianPerSecond).ToString(swedishCulture)); Assert.Equal("1 THz", new Frequency(1, FrequencyUnit.Terahertz).ToString(swedishCulture)); } diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs index 4f89f48ee3..9488049161 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs @@ -190,6 +190,11 @@ private Frequency(double value, FrequencyUnit unit) /// public double Megahertz => As(FrequencyUnit.Megahertz); + /// + /// Get Frequency in PerSecond. + /// + public double PerSecond => As(FrequencyUnit.PerSecond); + /// /// Get Frequency in RadiansPerSecond. /// @@ -301,6 +306,16 @@ public static Frequency FromMegahertz(double megahertz) return new Frequency(value, FrequencyUnit.Megahertz); } /// + /// Get Frequency from PerSecond. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Frequency FromPerSecond(double persecond) + { + double value = (double) persecond; + return new Frequency(value, FrequencyUnit.PerSecond); + } + /// /// Get Frequency from RadiansPerSecond. /// /// If value is NaN or Infinity. @@ -618,6 +633,7 @@ private double AsBaseUnit() case FrequencyUnit.Hertz: return _value; case FrequencyUnit.Kilohertz: return (_value) * 1e3d; case FrequencyUnit.Megahertz: return (_value) * 1e6d; + case FrequencyUnit.PerSecond: return _value; case FrequencyUnit.RadianPerSecond: return _value/6.2831853072; case FrequencyUnit.Terahertz: return (_value) * 1e12d; default: @@ -641,6 +657,7 @@ private double AsBaseNumericType(FrequencyUnit unit) case FrequencyUnit.Hertz: return baseUnitValue; case FrequencyUnit.Kilohertz: return (baseUnitValue) / 1e3d; case FrequencyUnit.Megahertz: return (baseUnitValue) / 1e6d; + case FrequencyUnit.PerSecond: return baseUnitValue; case FrequencyUnit.RadianPerSecond: return baseUnitValue*6.2831853072; case FrequencyUnit.Terahertz: return (baseUnitValue) / 1e12d; default: diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs index 1b1a82a8c8..b1080808ef 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -435,6 +435,7 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(FrequencyUnit), (int)FrequencyUnit.Hertz, new string[]{"Hz"}), ("en-US", typeof(FrequencyUnit), (int)FrequencyUnit.Kilohertz, new string[]{"kHz"}), ("en-US", typeof(FrequencyUnit), (int)FrequencyUnit.Megahertz, new string[]{"MHz"}), + ("en-US", typeof(FrequencyUnit), (int)FrequencyUnit.PerSecond, new string[]{"s⁻¹"}), ("en-US", typeof(FrequencyUnit), (int)FrequencyUnit.RadianPerSecond, new string[]{"rad/s"}), ("en-US", typeof(FrequencyUnit), (int)FrequencyUnit.Terahertz, new string[]{"THz"}), ("en-US", typeof(FuelEfficiencyUnit), (int)FuelEfficiencyUnit.KilometerPerLiter, new string[]{"km/L"}), diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/FrequencyUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/FrequencyUnit.g.cs index 7b4bf626a6..4c0f9bcfe9 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/FrequencyUnit.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/FrequencyUnit.g.cs @@ -33,6 +33,7 @@ public enum FrequencyUnit Hertz, Kilohertz, Megahertz, + PerSecond, RadianPerSecond, Terahertz, } diff --git a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs index eaba02d254..3965121cac 100644 --- a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs @@ -57,6 +57,7 @@ static Frequency() new UnitInfo(FrequencyUnit.Hertz, BaseUnits.Undefined), new UnitInfo(FrequencyUnit.Kilohertz, BaseUnits.Undefined), new UnitInfo(FrequencyUnit.Megahertz, BaseUnits.Undefined), + new UnitInfo(FrequencyUnit.PerSecond, BaseUnits.Undefined), new UnitInfo(FrequencyUnit.RadianPerSecond, BaseUnits.Undefined), new UnitInfo(FrequencyUnit.Terahertz, BaseUnits.Undefined), }, @@ -206,6 +207,11 @@ public Frequency(double value, UnitSystem unitSystem) /// public double Megahertz => As(FrequencyUnit.Megahertz); + /// + /// Get Frequency in PerSecond. + /// + public double PerSecond => As(FrequencyUnit.PerSecond); + /// /// Get Frequency in RadiansPerSecond. /// @@ -309,6 +315,15 @@ public static Frequency FromMegahertz(QuantityValue megahertz) return new Frequency(value, FrequencyUnit.Megahertz); } /// + /// Get Frequency from PerSecond. + /// + /// If value is NaN or Infinity. + public static Frequency FromPerSecond(QuantityValue persecond) + { + double value = (double) persecond; + return new Frequency(value, FrequencyUnit.PerSecond); + } + /// /// Get Frequency from RadiansPerSecond. /// /// If value is NaN or Infinity. @@ -762,6 +777,7 @@ private double GetValueInBaseUnit() case FrequencyUnit.Hertz: return _value; case FrequencyUnit.Kilohertz: return (_value) * 1e3d; case FrequencyUnit.Megahertz: return (_value) * 1e6d; + case FrequencyUnit.PerSecond: return _value; case FrequencyUnit.RadianPerSecond: return _value/6.2831853072; case FrequencyUnit.Terahertz: return (_value) * 1e12d; default: @@ -796,6 +812,7 @@ private double GetValueAs(FrequencyUnit unit) case FrequencyUnit.Hertz: return baseUnitValue; case FrequencyUnit.Kilohertz: return (baseUnitValue) / 1e3d; case FrequencyUnit.Megahertz: return (baseUnitValue) / 1e6d; + case FrequencyUnit.PerSecond: return baseUnitValue; case FrequencyUnit.RadianPerSecond: return baseUnitValue*6.2831853072; case FrequencyUnit.Terahertz: return (baseUnitValue) / 1e12d; default: diff --git a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs index de25099c97..100ee56720 100644 --- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -435,6 +435,7 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(FrequencyUnit), (int)FrequencyUnit.Hertz, new string[]{"Hz"}), ("en-US", typeof(FrequencyUnit), (int)FrequencyUnit.Kilohertz, new string[]{"kHz"}), ("en-US", typeof(FrequencyUnit), (int)FrequencyUnit.Megahertz, new string[]{"MHz"}), + ("en-US", typeof(FrequencyUnit), (int)FrequencyUnit.PerSecond, new string[]{"s⁻¹"}), ("en-US", typeof(FrequencyUnit), (int)FrequencyUnit.RadianPerSecond, new string[]{"rad/s"}), ("en-US", typeof(FrequencyUnit), (int)FrequencyUnit.Terahertz, new string[]{"THz"}), ("en-US", typeof(FuelEfficiencyUnit), (int)FuelEfficiencyUnit.KilometerPerLiter, new string[]{"km/L"}), diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs index 2b8c85ff25..2b15028ffd 100644 --- a/UnitsNet/GeneratedCode/UnitConverter.g.cs +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -654,6 +654,8 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(FrequencyUnit.Kilohertz, Frequency.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Megahertz, q => q.ToUnit(FrequencyUnit.Megahertz)); unitConverter.SetConversionFunction(FrequencyUnit.Megahertz, Frequency.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.PerSecond, q => q.ToUnit(FrequencyUnit.PerSecond)); + unitConverter.SetConversionFunction(FrequencyUnit.PerSecond, Frequency.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.RadianPerSecond, q => q.ToUnit(FrequencyUnit.RadianPerSecond)); unitConverter.SetConversionFunction(FrequencyUnit.RadianPerSecond, Frequency.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Frequency.BaseUnit, FrequencyUnit.Terahertz, q => q.ToUnit(FrequencyUnit.Terahertz)); diff --git a/UnitsNet/GeneratedCode/Units/FrequencyUnit.g.cs b/UnitsNet/GeneratedCode/Units/FrequencyUnit.g.cs index 7b4bf626a6..4c0f9bcfe9 100644 --- a/UnitsNet/GeneratedCode/Units/FrequencyUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/FrequencyUnit.g.cs @@ -33,6 +33,7 @@ public enum FrequencyUnit Hertz, Kilohertz, Megahertz, + PerSecond, RadianPerSecond, Terahertz, }