From 88cebd9e19591fd6d5dcea4670a3719d14dcad9e Mon Sep 17 00:00:00 2001 From: v'Karas Date: Wed, 28 Jun 2023 18:42:50 +0200 Subject: [PATCH 1/4] Added BarPerSecond and BarPerMinute, with 'Milli' to PressureChangeRate. As Bar is commonly used for hydraulics and I could really use it to display pressure changes in our 'normal' unit. I don't know any russian, but i copy&pasted the abbreviations from the other units, verification needed? Added 'Milli' to AmperePerSecond and added AmperePerMinute with 'Milli' to ElectricCurrentGradient to display some slower and minor changes in current. Added the missing BaseUnits in AmperePerSecond and enabled SupportSIUnitSystem in the tests. I hope that is Ok? (As it uses Ampere and Second it should as of my understanding of UnitsNet) --- .../ElectricCurrentGradient.json | 22 ++ .../UnitDefinitions/PressureChangeRate.json | 38 ++- Common/UnitEnumValues.g.json | 11 +- .../Quantities/ElectricCurrentGradient.g.cs | 39 +++ .../Quantities/PressureChangeRate.g.cs | 52 +++ .../Units/ElectricCurrentGradientUnit.g.cs | 3 + .../Units/PressureChangeRateUnit.g.cs | 4 + ...ElectricCurrentGradientExtensionsTest.g.cs | 12 + ...berToPressureChangeRateExtensionsTest.g.cs | 16 + ...erToElectricCurrentGradientExtensions.g.cs | 12 + .../NumberToPressureChangeRateExtensions.g.cs | 16 + .../ElectricCurrentGradientTests.cs | 6 +- .../CustomCode/PressureChangeRateTests.cs | 8 + .../GeneratedCode/IQuantityTests.g.cs | 2 +- .../ElectricCurrentGradientTestsBase.g.cs | 123 ++++++- .../PressureChangeRateTestsBase.g.cs | 322 +++++++++++++++--- .../Quantities/ElectricCurrentGradient.g.cs | 62 +++- .../Quantities/PressureChangeRate.g.cs | 80 +++++ .../Resources/ElectricCurrentGradient.restext | 3 + .../Resources/PressureChangeRate.restext | 4 + .../PressureChangeRate.ru-RU.restext | 4 + .../Units/ElectricCurrentGradientUnit.g.cs | 3 + .../Units/PressureChangeRateUnit.g.cs | 4 + 23 files changed, 794 insertions(+), 52 deletions(-) diff --git a/Common/UnitDefinitions/ElectricCurrentGradient.json b/Common/UnitDefinitions/ElectricCurrentGradient.json index 8a127e3097..28476d2d0d 100644 --- a/Common/UnitDefinitions/ElectricCurrentGradient.json +++ b/Common/UnitDefinitions/ElectricCurrentGradient.json @@ -10,8 +10,13 @@ { "SingularName": "AmperePerSecond", "PluralName": "AmperesPerSecond", + "BaseUnits": { + "T": "Second", + "I": "Ampere" + }, "FromUnitToBaseFunc": "{x}", "FromBaseToUnitFunc": "{x}", + "Prefixes": [ "Milli" ], "Localization": [ { "Culture": "en-US", @@ -19,6 +24,23 @@ } ] }, + { + "SingularName": "AmperePerMinute", + "PluralName": "AmperesPerMinute", + "BaseUnits": { + "T": "Minute", + "I": "Ampere" + }, + "FromUnitToBaseFunc": "{x} / 60", + "FromBaseToUnitFunc": "{x} * 60", + "Prefixes": [ "Milli" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "A/min" ] + } + ] + }, { "SingularName": "AmperePerMillisecond", "PluralName": "AmperesPerMillisecond", diff --git a/Common/UnitDefinitions/PressureChangeRate.json b/Common/UnitDefinitions/PressureChangeRate.json index 6f60ee8d25..e93ec26813 100644 --- a/Common/UnitDefinitions/PressureChangeRate.json +++ b/Common/UnitDefinitions/PressureChangeRate.json @@ -42,7 +42,7 @@ } ] }, - { + { "SingularName": "MillimeterOfMercuryPerSecond", "PluralName": "MillimetersOfMercuryPerSecond", "FromUnitToBaseFunc": "{x} * 133.322", @@ -74,7 +74,7 @@ } ] }, - { + { "SingularName": "PoundForcePerSquareInchPerSecond", "PluralName": "PoundsForcePerSquareInchPerSecond", "FromUnitToBaseFunc": "{x} * 6.894757293168361e3", @@ -111,6 +111,40 @@ "AbbreviationsForPrefixes": { "Kilo": [ "ksi/мин", "kipf/in²/мин" ]} } ] + }, + { + "SingularName": "BarPerSecond", + "PluralName": "BarsPerSecond", + "FromUnitToBaseFunc": "{x} * 1e5", + "FromBaseToUnitFunc": "{x} / 1e5", + "Prefixes": [ "Milli" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "bar/s" ] + }, + { + "Culture": "ru-RU", + "Abbreviations": [ "бар/с" ] + } + ] + }, + { + "SingularName": "BarPerMinute", + "PluralName": "BarsPerMinute", + "FromUnitToBaseFunc": "{x} * 1e5 / 60", + "FromBaseToUnitFunc": "{x} / 1e5 * 60", + "Prefixes": [ "Milli" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "bar/min" ] + }, + { + "Culture": "ru-RU", + "Abbreviations": [ "бар/мин" ] + } + ] } ] } \ No newline at end of file diff --git a/Common/UnitEnumValues.g.json b/Common/UnitEnumValues.g.json index cf00ffce0d..91388a2fbb 100644 --- a/Common/UnitEnumValues.g.json +++ b/Common/UnitEnumValues.g.json @@ -298,7 +298,10 @@ "AmperePerMicrosecond": 1, "AmperePerMillisecond": 2, "AmperePerNanosecond": 3, - "AmperePerSecond": 4 + "AmperePerSecond": 4, + "AmperePerMinute": 11, + "MilliamperePerMinute": 6, + "MilliamperePerSecond": 14 }, "ElectricField": { "VoltPerMeter": 1 @@ -1153,7 +1156,11 @@ "PascalPerMinute": 11, "PascalPerSecond": 12, "PoundForcePerSquareInchPerMinute": 13, - "PoundForcePerSquareInchPerSecond": 14 + "PoundForcePerSquareInchPerSecond": 14, + "BarPerMinute": 16, + "BarPerSecond": 23, + "MillibarPerMinute": 24, + "MillibarPerSecond": 20 }, "Ratio": { "DecimalFraction": 1, diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs index cbd99cb602..2acfe09a14 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs @@ -89,6 +89,11 @@ public ElectricCurrentGradient(double value, ElectricCurrentGradientUnit unit) /// public double AmperesPerMillisecond => As(ElectricCurrentGradientUnit.AmperePerMillisecond); + /// + /// Gets a value of this quantity converted into + /// + public double AmperesPerMinute => As(ElectricCurrentGradientUnit.AmperePerMinute); + /// /// Gets a value of this quantity converted into /// @@ -99,6 +104,16 @@ public ElectricCurrentGradient(double value, ElectricCurrentGradientUnit unit) /// public double AmperesPerSecond => As(ElectricCurrentGradientUnit.AmperePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double MilliamperesPerMinute => As(ElectricCurrentGradientUnit.MilliamperePerMinute); + + /// + /// Gets a value of this quantity converted into + /// + public double MilliamperesPerSecond => As(ElectricCurrentGradientUnit.MilliamperePerSecond); + #endregion #region Static Factory Methods @@ -115,6 +130,12 @@ public ElectricCurrentGradient(double value, ElectricCurrentGradientUnit unit) /// If value is NaN or Infinity. public static ElectricCurrentGradient FromAmperesPerMillisecond(double amperespermillisecond) => new ElectricCurrentGradient(amperespermillisecond, ElectricCurrentGradientUnit.AmperePerMillisecond); + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static ElectricCurrentGradient FromAmperesPerMinute(double amperesperminute) => new ElectricCurrentGradient(amperesperminute, ElectricCurrentGradientUnit.AmperePerMinute); + /// /// Creates a from . /// @@ -127,6 +148,18 @@ public ElectricCurrentGradient(double value, ElectricCurrentGradientUnit unit) /// If value is NaN or Infinity. public static ElectricCurrentGradient FromAmperesPerSecond(double amperespersecond) => new ElectricCurrentGradient(amperespersecond, ElectricCurrentGradientUnit.AmperePerSecond); + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static ElectricCurrentGradient FromMilliamperesPerMinute(double milliamperesperminute) => new ElectricCurrentGradient(milliamperesperminute, ElectricCurrentGradientUnit.MilliamperePerMinute); + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static ElectricCurrentGradient FromMilliamperesPerSecond(double milliamperespersecond) => new ElectricCurrentGradient(milliamperespersecond, ElectricCurrentGradientUnit.MilliamperePerSecond); + /// /// Dynamically convert from value and unit enum to . /// @@ -169,8 +202,11 @@ private double GetValueInBaseUnit() { ElectricCurrentGradientUnit.AmperePerMicrosecond => _value * 1E6, ElectricCurrentGradientUnit.AmperePerMillisecond => _value * 1E3, + ElectricCurrentGradientUnit.AmperePerMinute => _value / 60, ElectricCurrentGradientUnit.AmperePerNanosecond => _value * 1E9, ElectricCurrentGradientUnit.AmperePerSecond => _value, + ElectricCurrentGradientUnit.MilliamperePerMinute => (_value / 60) * 1e-3d, + ElectricCurrentGradientUnit.MilliamperePerSecond => (_value) * 1e-3d, _ => throw new NotImplementedException($"Can not convert {Unit} to base units.") }; } @@ -186,8 +222,11 @@ private double GetValueAs(ElectricCurrentGradientUnit unit) { ElectricCurrentGradientUnit.AmperePerMicrosecond => baseUnitValue / 1E6, ElectricCurrentGradientUnit.AmperePerMillisecond => baseUnitValue / 1E3, + ElectricCurrentGradientUnit.AmperePerMinute => baseUnitValue * 60, ElectricCurrentGradientUnit.AmperePerNanosecond => baseUnitValue / 1E9, ElectricCurrentGradientUnit.AmperePerSecond => baseUnitValue, + ElectricCurrentGradientUnit.MilliamperePerMinute => (baseUnitValue * 60) / 1e-3d, + ElectricCurrentGradientUnit.MilliamperePerSecond => (baseUnitValue) / 1e-3d, _ => throw new NotImplementedException($"Can not convert {Unit} to {unit}.") }; } diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/PressureChangeRate.g.cs index 2baa14fb03..49dd51baac 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/PressureChangeRate.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/PressureChangeRate.g.cs @@ -84,6 +84,16 @@ public PressureChangeRate(double value, PressureChangeRateUnit unit) /// public double AtmospheresPerSecond => As(PressureChangeRateUnit.AtmospherePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double BarsPerMinute => As(PressureChangeRateUnit.BarPerMinute); + + /// + /// Gets a value of this quantity converted into + /// + public double BarsPerSecond => As(PressureChangeRateUnit.BarPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -124,6 +134,16 @@ public PressureChangeRate(double value, PressureChangeRateUnit unit) /// public double MegapoundsForcePerSquareInchPerSecond => As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double MillibarsPerMinute => As(PressureChangeRateUnit.MillibarPerMinute); + + /// + /// Gets a value of this quantity converted into + /// + public double MillibarsPerSecond => As(PressureChangeRateUnit.MillibarPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -159,6 +179,18 @@ public PressureChangeRate(double value, PressureChangeRateUnit unit) /// If value is NaN or Infinity. public static PressureChangeRate FromAtmospheresPerSecond(double atmospherespersecond) => new PressureChangeRate(atmospherespersecond, PressureChangeRateUnit.AtmospherePerSecond); + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static PressureChangeRate FromBarsPerMinute(double barsperminute) => new PressureChangeRate(barsperminute, PressureChangeRateUnit.BarPerMinute); + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static PressureChangeRate FromBarsPerSecond(double barspersecond) => new PressureChangeRate(barspersecond, PressureChangeRateUnit.BarPerSecond); + /// /// Creates a from . /// @@ -207,6 +239,18 @@ public PressureChangeRate(double value, PressureChangeRateUnit unit) /// If value is NaN or Infinity. public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(double megapoundsforcepersquareinchpersecond) => new PressureChangeRate(megapoundsforcepersquareinchpersecond, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static PressureChangeRate FromMillibarsPerMinute(double millibarsperminute) => new PressureChangeRate(millibarsperminute, PressureChangeRateUnit.MillibarPerMinute); + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static PressureChangeRate FromMillibarsPerSecond(double millibarspersecond) => new PressureChangeRate(millibarspersecond, PressureChangeRateUnit.MillibarPerSecond); + /// /// Creates a from . /// @@ -278,6 +322,8 @@ private double GetValueInBaseUnit() return Unit switch { PressureChangeRateUnit.AtmospherePerSecond => _value * 1.01325 * 1e5, + PressureChangeRateUnit.BarPerMinute => _value * 1e5 / 60, + PressureChangeRateUnit.BarPerSecond => _value * 1e5, PressureChangeRateUnit.KilopascalPerMinute => (_value / 60) * 1e3d, PressureChangeRateUnit.KilopascalPerSecond => (_value) * 1e3d, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute => (_value * 6.894757293168361e3 / 60) * 1e3d, @@ -286,6 +332,8 @@ private double GetValueInBaseUnit() PressureChangeRateUnit.MegapascalPerSecond => (_value) * 1e6d, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute => (_value * 6.894757293168361e3 / 60) * 1e6d, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond => (_value * 6.894757293168361e3) * 1e6d, + PressureChangeRateUnit.MillibarPerMinute => (_value * 1e5 / 60) * 1e-3d, + PressureChangeRateUnit.MillibarPerSecond => (_value * 1e5) * 1e-3d, PressureChangeRateUnit.MillimeterOfMercuryPerSecond => _value * 133.322, PressureChangeRateUnit.PascalPerMinute => _value / 60, PressureChangeRateUnit.PascalPerSecond => _value, @@ -305,6 +353,8 @@ private double GetValueAs(PressureChangeRateUnit unit) return unit switch { PressureChangeRateUnit.AtmospherePerSecond => baseUnitValue / (1.01325 * 1e5), + PressureChangeRateUnit.BarPerMinute => baseUnitValue / 1e5 * 60, + PressureChangeRateUnit.BarPerSecond => baseUnitValue / 1e5, PressureChangeRateUnit.KilopascalPerMinute => (baseUnitValue * 60) / 1e3d, PressureChangeRateUnit.KilopascalPerSecond => (baseUnitValue) / 1e3d, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute => (baseUnitValue / 6.894757293168361e3 * 60) / 1e3d, @@ -313,6 +363,8 @@ private double GetValueAs(PressureChangeRateUnit unit) PressureChangeRateUnit.MegapascalPerSecond => (baseUnitValue) / 1e6d, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute => (baseUnitValue / 6.894757293168361e3 * 60) / 1e6d, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond => (baseUnitValue / 6.894757293168361e3) / 1e6d, + PressureChangeRateUnit.MillibarPerMinute => (baseUnitValue / 1e5 * 60) / 1e-3d, + PressureChangeRateUnit.MillibarPerSecond => (baseUnitValue / 1e5) / 1e-3d, PressureChangeRateUnit.MillimeterOfMercuryPerSecond => baseUnitValue / 133.322, PressureChangeRateUnit.PascalPerMinute => baseUnitValue * 60, PressureChangeRateUnit.PascalPerSecond => baseUnitValue, diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCurrentGradientUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCurrentGradientUnit.g.cs index eb247e6cfc..64607d4ef8 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCurrentGradientUnit.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Units/ElectricCurrentGradientUnit.g.cs @@ -27,8 +27,11 @@ public enum ElectricCurrentGradientUnit { AmperePerMicrosecond = 1, AmperePerMillisecond = 2, + AmperePerMinute = 11, AmperePerNanosecond = 3, AmperePerSecond = 4, + MilliamperePerMinute = 6, + MilliamperePerSecond = 14, } #pragma warning restore 1591 diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/PressureChangeRateUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/PressureChangeRateUnit.g.cs index fed99a6a4a..8593e5b890 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Units/PressureChangeRateUnit.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Units/PressureChangeRateUnit.g.cs @@ -26,6 +26,8 @@ namespace UnitsNet.Units public enum PressureChangeRateUnit { AtmospherePerSecond = 1, + BarPerMinute = 16, + BarPerSecond = 23, KilopascalPerMinute = 2, KilopascalPerSecond = 3, KilopoundForcePerSquareInchPerMinute = 4, @@ -34,6 +36,8 @@ public enum PressureChangeRateUnit MegapascalPerSecond = 7, MegapoundForcePerSquareInchPerMinute = 8, MegapoundForcePerSquareInchPerSecond = 9, + MillibarPerMinute = 24, + MillibarPerSecond = 20, MillimeterOfMercuryPerSecond = 10, PascalPerMinute = 11, PascalPerSecond = 12, diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs index 572f362d8c..1cd9689c6f 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs @@ -32,6 +32,10 @@ public void NumberToAmperesPerMicrosecondTest() => public void NumberToAmperesPerMillisecondTest() => Assert.Equal(ElectricCurrentGradient.FromAmperesPerMillisecond(2), 2.AmperesPerMillisecond()); + [Fact] + public void NumberToAmperesPerMinuteTest() => + Assert.Equal(ElectricCurrentGradient.FromAmperesPerMinute(2), 2.AmperesPerMinute()); + [Fact] public void NumberToAmperesPerNanosecondTest() => Assert.Equal(ElectricCurrentGradient.FromAmperesPerNanosecond(2), 2.AmperesPerNanosecond()); @@ -40,5 +44,13 @@ public void NumberToAmperesPerNanosecondTest() => public void NumberToAmperesPerSecondTest() => Assert.Equal(ElectricCurrentGradient.FromAmperesPerSecond(2), 2.AmperesPerSecond()); + [Fact] + public void NumberToMilliamperesPerMinuteTest() => + Assert.Equal(ElectricCurrentGradient.FromMilliamperesPerMinute(2), 2.MilliamperesPerMinute()); + + [Fact] + public void NumberToMilliamperesPerSecondTest() => + Assert.Equal(ElectricCurrentGradient.FromMilliamperesPerSecond(2), 2.MilliamperesPerSecond()); + } } diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs index 8d3b5e8358..2fda90663a 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs @@ -28,6 +28,14 @@ public class NumberToPressureChangeRateExtensionsTests public void NumberToAtmospheresPerSecondTest() => Assert.Equal(PressureChangeRate.FromAtmospheresPerSecond(2), 2.AtmospheresPerSecond()); + [Fact] + public void NumberToBarsPerMinuteTest() => + Assert.Equal(PressureChangeRate.FromBarsPerMinute(2), 2.BarsPerMinute()); + + [Fact] + public void NumberToBarsPerSecondTest() => + Assert.Equal(PressureChangeRate.FromBarsPerSecond(2), 2.BarsPerSecond()); + [Fact] public void NumberToKilopascalsPerMinuteTest() => Assert.Equal(PressureChangeRate.FromKilopascalsPerMinute(2), 2.KilopascalsPerMinute()); @@ -60,6 +68,14 @@ public void NumberToMegapoundsForcePerSquareInchPerMinuteTest() => public void NumberToMegapoundsForcePerSquareInchPerSecondTest() => Assert.Equal(PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(2), 2.MegapoundsForcePerSquareInchPerSecond()); + [Fact] + public void NumberToMillibarsPerMinuteTest() => + Assert.Equal(PressureChangeRate.FromMillibarsPerMinute(2), 2.MillibarsPerMinute()); + + [Fact] + public void NumberToMillibarsPerSecondTest() => + Assert.Equal(PressureChangeRate.FromMillibarsPerSecond(2), 2.MillibarsPerSecond()); + [Fact] public void NumberToMillimetersOfMercuryPerSecondTest() => Assert.Equal(PressureChangeRate.FromMillimetersOfMercuryPerSecond(2), 2.MillimetersOfMercuryPerSecond()); diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs index 9888b10a5e..054ab6dbc9 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs @@ -36,6 +36,10 @@ public static ElectricCurrentGradient AmperesPerMicrosecond(this T value) => public static ElectricCurrentGradient AmperesPerMillisecond(this T value) => ElectricCurrentGradient.FromAmperesPerMillisecond(Convert.ToDouble(value)); + /// + public static ElectricCurrentGradient AmperesPerMinute(this T value) => + ElectricCurrentGradient.FromAmperesPerMinute(Convert.ToDouble(value)); + /// public static ElectricCurrentGradient AmperesPerNanosecond(this T value) => ElectricCurrentGradient.FromAmperesPerNanosecond(Convert.ToDouble(value)); @@ -44,5 +48,13 @@ public static ElectricCurrentGradient AmperesPerNanosecond(this T value) => public static ElectricCurrentGradient AmperesPerSecond(this T value) => ElectricCurrentGradient.FromAmperesPerSecond(Convert.ToDouble(value)); + /// + public static ElectricCurrentGradient MilliamperesPerMinute(this T value) => + ElectricCurrentGradient.FromMilliamperesPerMinute(Convert.ToDouble(value)); + + /// + public static ElectricCurrentGradient MilliamperesPerSecond(this T value) => + ElectricCurrentGradient.FromMilliamperesPerSecond(Convert.ToDouble(value)); + } } diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs index 0cb9d7e301..9f3ab50c40 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs @@ -32,6 +32,14 @@ public static class NumberToPressureChangeRateExtensions public static PressureChangeRate AtmospheresPerSecond(this T value) => PressureChangeRate.FromAtmospheresPerSecond(Convert.ToDouble(value)); + /// + public static PressureChangeRate BarsPerMinute(this T value) => + PressureChangeRate.FromBarsPerMinute(Convert.ToDouble(value)); + + /// + public static PressureChangeRate BarsPerSecond(this T value) => + PressureChangeRate.FromBarsPerSecond(Convert.ToDouble(value)); + /// public static PressureChangeRate KilopascalsPerMinute(this T value) => PressureChangeRate.FromKilopascalsPerMinute(Convert.ToDouble(value)); @@ -64,6 +72,14 @@ public static PressureChangeRate MegapoundsForcePerSquareInchPerMinute(this T public static PressureChangeRate MegapoundsForcePerSquareInchPerSecond(this T value) => PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(Convert.ToDouble(value)); + /// + public static PressureChangeRate MillibarsPerMinute(this T value) => + PressureChangeRate.FromMillibarsPerMinute(Convert.ToDouble(value)); + + /// + public static PressureChangeRate MillibarsPerSecond(this T value) => + PressureChangeRate.FromMillibarsPerSecond(Convert.ToDouble(value)); + /// public static PressureChangeRate MillimetersOfMercuryPerSecond(this T value) => PressureChangeRate.FromMillimetersOfMercuryPerSecond(Convert.ToDouble(value)); diff --git a/UnitsNet.Tests/CustomCode/ElectricCurrentGradientTests.cs b/UnitsNet.Tests/CustomCode/ElectricCurrentGradientTests.cs index 36d28528e0..17b75ad3ce 100644 --- a/UnitsNet.Tests/CustomCode/ElectricCurrentGradientTests.cs +++ b/UnitsNet.Tests/CustomCode/ElectricCurrentGradientTests.cs @@ -27,10 +27,14 @@ namespace UnitsNet.Tests.CustomCode { public class ElectricCurrentGradientTests : ElectricCurrentGradientTestsBase { - protected override bool SupportsSIUnitSystem => false; + protected override bool SupportsSIUnitSystem => true; protected override double AmperesPerSecondInOneAmperePerSecond => 1; protected override double AmperesPerMillisecondInOneAmperePerSecond => 1e-03; protected override double AmperesPerMicrosecondInOneAmperePerSecond => 1e-06; protected override double AmperesPerNanosecondInOneAmperePerSecond => 1e-09; + + protected override double AmperesPerMinuteInOneAmperePerSecond => 60; + protected override double MilliamperesPerMinuteInOneAmperePerSecond => 6e4; + protected override double MilliamperesPerSecondInOneAmperePerSecond => 1e3; } } diff --git a/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs b/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs index 6b0a5c9dcf..99c93b7202 100644 --- a/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs +++ b/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs @@ -33,5 +33,13 @@ public class PressureChangeRateTests : PressureChangeRateTestsBase protected override double PascalsPerMinuteInOnePascalPerSecond => 60; protected override double MillimetersOfMercuryPerSecondInOnePascalPerSecond => 7.500637554192106e-3; + + protected override double BarsPerMinuteInOnePascalPerSecond => 6e-4; + + protected override double BarsPerSecondInOnePascalPerSecond => 1e-5; + + protected override double MillibarsPerMinuteInOnePascalPerSecond => 0.6; + + protected override double MillibarsPerSecondInOnePascalPerSecond => 1e-2; } } diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs index e7698f7726..aacd406d16 100644 --- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs +++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs @@ -59,7 +59,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity) Assertion(3, ElectricConductivityUnit.SiemensPerMeter, Quantity.From(3, ElectricConductivityUnit.SiemensPerMeter)); Assertion(3, ElectricCurrentUnit.Picoampere, Quantity.From(3, ElectricCurrentUnit.Picoampere)); Assertion(3, ElectricCurrentDensityUnit.AmperePerSquareMeter, Quantity.From(3, ElectricCurrentDensityUnit.AmperePerSquareMeter)); - Assertion(3, ElectricCurrentGradientUnit.AmperePerSecond, Quantity.From(3, ElectricCurrentGradientUnit.AmperePerSecond)); + Assertion(3, ElectricCurrentGradientUnit.MilliamperePerSecond, Quantity.From(3, ElectricCurrentGradientUnit.MilliamperePerSecond)); Assertion(3, ElectricFieldUnit.VoltPerMeter, Quantity.From(3, ElectricFieldUnit.VoltPerMeter)); Assertion(3, ElectricInductanceUnit.Picohenry, Quantity.From(3, ElectricInductanceUnit.Picohenry)); Assertion(3, ElectricPotentialUnit.Volt, Quantity.From(3, ElectricPotentialUnit.Volt)); diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs index 309d178337..9f712eba0f 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ElectricCurrentGradientTestsBase.g.cs @@ -40,14 +40,20 @@ public abstract partial class ElectricCurrentGradientTestsBase : QuantityTestsBa { protected abstract double AmperesPerMicrosecondInOneAmperePerSecond { get; } protected abstract double AmperesPerMillisecondInOneAmperePerSecond { get; } + protected abstract double AmperesPerMinuteInOneAmperePerSecond { get; } protected abstract double AmperesPerNanosecondInOneAmperePerSecond { get; } protected abstract double AmperesPerSecondInOneAmperePerSecond { get; } + protected abstract double MilliamperesPerMinuteInOneAmperePerSecond { get; } + protected abstract double MilliamperesPerSecondInOneAmperePerSecond { get; } // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double AmperesPerMicrosecondTolerance { get { return 1e-5; } } protected virtual double AmperesPerMillisecondTolerance { get { return 1e-5; } } + protected virtual double AmperesPerMinuteTolerance { get { return 1e-5; } } protected virtual double AmperesPerNanosecondTolerance { get { return 1e-5; } } protected virtual double AmperesPerSecondTolerance { get { return 1e-5; } } + protected virtual double MilliamperesPerMinuteTolerance { get { return 1e-5; } } + protected virtual double MilliamperesPerSecondTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(ElectricCurrentGradientUnit unit) @@ -56,8 +62,11 @@ public abstract partial class ElectricCurrentGradientTestsBase : QuantityTestsBa { ElectricCurrentGradientUnit.AmperePerMicrosecond => (AmperesPerMicrosecondInOneAmperePerSecond, AmperesPerMicrosecondTolerance), ElectricCurrentGradientUnit.AmperePerMillisecond => (AmperesPerMillisecondInOneAmperePerSecond, AmperesPerMillisecondTolerance), + ElectricCurrentGradientUnit.AmperePerMinute => (AmperesPerMinuteInOneAmperePerSecond, AmperesPerMinuteTolerance), ElectricCurrentGradientUnit.AmperePerNanosecond => (AmperesPerNanosecondInOneAmperePerSecond, AmperesPerNanosecondTolerance), ElectricCurrentGradientUnit.AmperePerSecond => (AmperesPerSecondInOneAmperePerSecond, AmperesPerSecondTolerance), + ElectricCurrentGradientUnit.MilliamperePerMinute => (MilliamperesPerMinuteInOneAmperePerSecond, MilliamperesPerMinuteTolerance), + ElectricCurrentGradientUnit.MilliamperePerSecond => (MilliamperesPerSecondInOneAmperePerSecond, MilliamperesPerSecondTolerance), _ => throw new NotSupportedException() }; } @@ -66,8 +75,11 @@ public abstract partial class ElectricCurrentGradientTestsBase : QuantityTestsBa { new object[] { ElectricCurrentGradientUnit.AmperePerMicrosecond }, new object[] { ElectricCurrentGradientUnit.AmperePerMillisecond }, + new object[] { ElectricCurrentGradientUnit.AmperePerMinute }, new object[] { ElectricCurrentGradientUnit.AmperePerNanosecond }, new object[] { ElectricCurrentGradientUnit.AmperePerSecond }, + new object[] { ElectricCurrentGradientUnit.MilliamperePerMinute }, + new object[] { ElectricCurrentGradientUnit.MilliamperePerSecond }, }; [Fact] @@ -132,8 +144,11 @@ public void AmperePerSecondToElectricCurrentGradientUnits() ElectricCurrentGradient amperepersecond = ElectricCurrentGradient.FromAmperesPerSecond(1); AssertEx.EqualTolerance(AmperesPerMicrosecondInOneAmperePerSecond, amperepersecond.AmperesPerMicrosecond, AmperesPerMicrosecondTolerance); AssertEx.EqualTolerance(AmperesPerMillisecondInOneAmperePerSecond, amperepersecond.AmperesPerMillisecond, AmperesPerMillisecondTolerance); + AssertEx.EqualTolerance(AmperesPerMinuteInOneAmperePerSecond, amperepersecond.AmperesPerMinute, AmperesPerMinuteTolerance); AssertEx.EqualTolerance(AmperesPerNanosecondInOneAmperePerSecond, amperepersecond.AmperesPerNanosecond, AmperesPerNanosecondTolerance); AssertEx.EqualTolerance(AmperesPerSecondInOneAmperePerSecond, amperepersecond.AmperesPerSecond, AmperesPerSecondTolerance); + AssertEx.EqualTolerance(MilliamperesPerMinuteInOneAmperePerSecond, amperepersecond.MilliamperesPerMinute, MilliamperesPerMinuteTolerance); + AssertEx.EqualTolerance(MilliamperesPerSecondInOneAmperePerSecond, amperepersecond.MilliamperesPerSecond, MilliamperesPerSecondTolerance); } [Fact] @@ -147,13 +162,25 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity01.AmperesPerMillisecond, AmperesPerMillisecondTolerance); Assert.Equal(ElectricCurrentGradientUnit.AmperePerMillisecond, quantity01.Unit); - var quantity02 = ElectricCurrentGradient.From(1, ElectricCurrentGradientUnit.AmperePerNanosecond); - AssertEx.EqualTolerance(1, quantity02.AmperesPerNanosecond, AmperesPerNanosecondTolerance); - Assert.Equal(ElectricCurrentGradientUnit.AmperePerNanosecond, quantity02.Unit); + var quantity02 = ElectricCurrentGradient.From(1, ElectricCurrentGradientUnit.AmperePerMinute); + AssertEx.EqualTolerance(1, quantity02.AmperesPerMinute, AmperesPerMinuteTolerance); + Assert.Equal(ElectricCurrentGradientUnit.AmperePerMinute, quantity02.Unit); - var quantity03 = ElectricCurrentGradient.From(1, ElectricCurrentGradientUnit.AmperePerSecond); - AssertEx.EqualTolerance(1, quantity03.AmperesPerSecond, AmperesPerSecondTolerance); - Assert.Equal(ElectricCurrentGradientUnit.AmperePerSecond, quantity03.Unit); + var quantity03 = ElectricCurrentGradient.From(1, ElectricCurrentGradientUnit.AmperePerNanosecond); + AssertEx.EqualTolerance(1, quantity03.AmperesPerNanosecond, AmperesPerNanosecondTolerance); + Assert.Equal(ElectricCurrentGradientUnit.AmperePerNanosecond, quantity03.Unit); + + var quantity04 = ElectricCurrentGradient.From(1, ElectricCurrentGradientUnit.AmperePerSecond); + AssertEx.EqualTolerance(1, quantity04.AmperesPerSecond, AmperesPerSecondTolerance); + Assert.Equal(ElectricCurrentGradientUnit.AmperePerSecond, quantity04.Unit); + + var quantity05 = ElectricCurrentGradient.From(1, ElectricCurrentGradientUnit.MilliamperePerMinute); + AssertEx.EqualTolerance(1, quantity05.MilliamperesPerMinute, MilliamperesPerMinuteTolerance); + Assert.Equal(ElectricCurrentGradientUnit.MilliamperePerMinute, quantity05.Unit); + + var quantity06 = ElectricCurrentGradient.From(1, ElectricCurrentGradientUnit.MilliamperePerSecond); + AssertEx.EqualTolerance(1, quantity06.MilliamperesPerSecond, MilliamperesPerSecondTolerance); + Assert.Equal(ElectricCurrentGradientUnit.MilliamperePerSecond, quantity06.Unit); } @@ -176,8 +203,11 @@ public void As() var amperepersecond = ElectricCurrentGradient.FromAmperesPerSecond(1); AssertEx.EqualTolerance(AmperesPerMicrosecondInOneAmperePerSecond, amperepersecond.As(ElectricCurrentGradientUnit.AmperePerMicrosecond), AmperesPerMicrosecondTolerance); AssertEx.EqualTolerance(AmperesPerMillisecondInOneAmperePerSecond, amperepersecond.As(ElectricCurrentGradientUnit.AmperePerMillisecond), AmperesPerMillisecondTolerance); + AssertEx.EqualTolerance(AmperesPerMinuteInOneAmperePerSecond, amperepersecond.As(ElectricCurrentGradientUnit.AmperePerMinute), AmperesPerMinuteTolerance); AssertEx.EqualTolerance(AmperesPerNanosecondInOneAmperePerSecond, amperepersecond.As(ElectricCurrentGradientUnit.AmperePerNanosecond), AmperesPerNanosecondTolerance); AssertEx.EqualTolerance(AmperesPerSecondInOneAmperePerSecond, amperepersecond.As(ElectricCurrentGradientUnit.AmperePerSecond), AmperesPerSecondTolerance); + AssertEx.EqualTolerance(MilliamperesPerMinuteInOneAmperePerSecond, amperepersecond.As(ElectricCurrentGradientUnit.MilliamperePerMinute), MilliamperesPerMinuteTolerance); + AssertEx.EqualTolerance(MilliamperesPerSecondInOneAmperePerSecond, amperepersecond.As(ElectricCurrentGradientUnit.MilliamperePerSecond), MilliamperesPerSecondTolerance); } [Fact] @@ -214,6 +244,13 @@ public void Parse() Assert.Equal(ElectricCurrentGradientUnit.AmperePerMillisecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = ElectricCurrentGradient.Parse("1 A/min", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.AmperesPerMinute, AmperesPerMinuteTolerance); + Assert.Equal(ElectricCurrentGradientUnit.AmperePerMinute, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = ElectricCurrentGradient.Parse("1 A/ns", CultureInfo.GetCultureInfo("en-US")); @@ -228,6 +265,20 @@ public void Parse() Assert.Equal(ElectricCurrentGradientUnit.AmperePerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = ElectricCurrentGradient.Parse("1 mA/min", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.MilliamperesPerMinute, MilliamperesPerMinuteTolerance); + Assert.Equal(ElectricCurrentGradientUnit.MilliamperePerMinute, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = ElectricCurrentGradient.Parse("1 mA/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.MilliamperesPerSecond, MilliamperesPerSecondTolerance); + Assert.Equal(ElectricCurrentGradientUnit.MilliamperePerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + } [Fact] @@ -245,6 +296,12 @@ public void TryParse() Assert.Equal(ElectricCurrentGradientUnit.AmperePerMillisecond, parsed.Unit); } + { + Assert.True(ElectricCurrentGradient.TryParse("1 A/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.AmperesPerMinute, AmperesPerMinuteTolerance); + Assert.Equal(ElectricCurrentGradientUnit.AmperePerMinute, parsed.Unit); + } + { Assert.True(ElectricCurrentGradient.TryParse("1 A/ns", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.AmperesPerNanosecond, AmperesPerNanosecondTolerance); @@ -257,6 +314,18 @@ public void TryParse() Assert.Equal(ElectricCurrentGradientUnit.AmperePerSecond, parsed.Unit); } + { + Assert.True(ElectricCurrentGradient.TryParse("1 mA/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.MilliamperesPerMinute, MilliamperesPerMinuteTolerance); + Assert.Equal(ElectricCurrentGradientUnit.MilliamperePerMinute, parsed.Unit); + } + + { + Assert.True(ElectricCurrentGradient.TryParse("1 mA/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.MilliamperesPerSecond, MilliamperesPerSecondTolerance); + Assert.Equal(ElectricCurrentGradientUnit.MilliamperePerSecond, parsed.Unit); + } + } [Fact] @@ -274,6 +343,12 @@ public void ParseUnit() Assert.Equal(ElectricCurrentGradientUnit.AmperePerMillisecond, parsedUnit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsedUnit = ElectricCurrentGradient.ParseUnit("A/min", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(ElectricCurrentGradientUnit.AmperePerMinute, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsedUnit = ElectricCurrentGradient.ParseUnit("A/ns", CultureInfo.GetCultureInfo("en-US")); @@ -286,6 +361,18 @@ public void ParseUnit() Assert.Equal(ElectricCurrentGradientUnit.AmperePerSecond, parsedUnit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsedUnit = ElectricCurrentGradient.ParseUnit("mA/min", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(ElectricCurrentGradientUnit.MilliamperePerMinute, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = ElectricCurrentGradient.ParseUnit("mA/s", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(ElectricCurrentGradientUnit.MilliamperePerSecond, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + } [Fact] @@ -301,6 +388,11 @@ public void TryParseUnit() Assert.Equal(ElectricCurrentGradientUnit.AmperePerMillisecond, parsedUnit); } + { + Assert.True(ElectricCurrentGradient.TryParseUnit("A/min", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(ElectricCurrentGradientUnit.AmperePerMinute, parsedUnit); + } + { Assert.True(ElectricCurrentGradient.TryParseUnit("A/ns", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); Assert.Equal(ElectricCurrentGradientUnit.AmperePerNanosecond, parsedUnit); @@ -311,6 +403,16 @@ public void TryParseUnit() Assert.Equal(ElectricCurrentGradientUnit.AmperePerSecond, parsedUnit); } + { + Assert.True(ElectricCurrentGradient.TryParseUnit("mA/min", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(ElectricCurrentGradientUnit.MilliamperePerMinute, parsedUnit); + } + + { + Assert.True(ElectricCurrentGradient.TryParseUnit("mA/s", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(ElectricCurrentGradientUnit.MilliamperePerSecond, parsedUnit); + } + } [Theory] @@ -361,8 +463,11 @@ public void ConversionRoundTrip() ElectricCurrentGradient amperepersecond = ElectricCurrentGradient.FromAmperesPerSecond(1); AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromAmperesPerMicrosecond(amperepersecond.AmperesPerMicrosecond).AmperesPerSecond, AmperesPerMicrosecondTolerance); AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromAmperesPerMillisecond(amperepersecond.AmperesPerMillisecond).AmperesPerSecond, AmperesPerMillisecondTolerance); + AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromAmperesPerMinute(amperepersecond.AmperesPerMinute).AmperesPerSecond, AmperesPerMinuteTolerance); AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromAmperesPerNanosecond(amperepersecond.AmperesPerNanosecond).AmperesPerSecond, AmperesPerNanosecondTolerance); AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromAmperesPerSecond(amperepersecond.AmperesPerSecond).AmperesPerSecond, AmperesPerSecondTolerance); + AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromMilliamperesPerMinute(amperepersecond.MilliamperesPerMinute).AmperesPerSecond, MilliamperesPerMinuteTolerance); + AssertEx.EqualTolerance(1, ElectricCurrentGradient.FromMilliamperesPerSecond(amperepersecond.MilliamperesPerSecond).AmperesPerSecond, MilliamperesPerSecondTolerance); } [Fact] @@ -512,8 +617,11 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() try { Assert.Equal("1 A/μs", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.AmperePerMicrosecond).ToString()); Assert.Equal("1 A/ms", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.AmperePerMillisecond).ToString()); + Assert.Equal("1 A/min", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.AmperePerMinute).ToString()); Assert.Equal("1 A/ns", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.AmperePerNanosecond).ToString()); Assert.Equal("1 A/s", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.AmperePerSecond).ToString()); + Assert.Equal("1 mA/min", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.MilliamperePerMinute).ToString()); + Assert.Equal("1 mA/s", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.MilliamperePerSecond).ToString()); } finally { @@ -529,8 +637,11 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 A/μs", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.AmperePerMicrosecond).ToString(swedishCulture)); Assert.Equal("1 A/ms", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.AmperePerMillisecond).ToString(swedishCulture)); + Assert.Equal("1 A/min", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.AmperePerMinute).ToString(swedishCulture)); Assert.Equal("1 A/ns", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.AmperePerNanosecond).ToString(swedishCulture)); Assert.Equal("1 A/s", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.AmperePerSecond).ToString(swedishCulture)); + Assert.Equal("1 mA/min", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.MilliamperePerMinute).ToString(swedishCulture)); + Assert.Equal("1 mA/s", new ElectricCurrentGradient(1, ElectricCurrentGradientUnit.MilliamperePerSecond).ToString(swedishCulture)); } [Fact] diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs index b7e373e91e..1e4178602b 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/PressureChangeRateTestsBase.g.cs @@ -39,6 +39,8 @@ namespace UnitsNet.Tests public abstract partial class PressureChangeRateTestsBase : QuantityTestsBase { protected abstract double AtmospheresPerSecondInOnePascalPerSecond { get; } + protected abstract double BarsPerMinuteInOnePascalPerSecond { get; } + protected abstract double BarsPerSecondInOnePascalPerSecond { get; } protected abstract double KilopascalsPerMinuteInOnePascalPerSecond { get; } protected abstract double KilopascalsPerSecondInOnePascalPerSecond { get; } protected abstract double KilopoundsForcePerSquareInchPerMinuteInOnePascalPerSecond { get; } @@ -47,6 +49,8 @@ public abstract partial class PressureChangeRateTestsBase : QuantityTestsBase protected abstract double MegapascalsPerSecondInOnePascalPerSecond { get; } protected abstract double MegapoundsForcePerSquareInchPerMinuteInOnePascalPerSecond { get; } protected abstract double MegapoundsForcePerSquareInchPerSecondInOnePascalPerSecond { get; } + protected abstract double MillibarsPerMinuteInOnePascalPerSecond { get; } + protected abstract double MillibarsPerSecondInOnePascalPerSecond { get; } protected abstract double MillimetersOfMercuryPerSecondInOnePascalPerSecond { get; } protected abstract double PascalsPerMinuteInOnePascalPerSecond { get; } protected abstract double PascalsPerSecondInOnePascalPerSecond { get; } @@ -55,6 +59,8 @@ public abstract partial class PressureChangeRateTestsBase : QuantityTestsBase // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double AtmospheresPerSecondTolerance { get { return 1e-5; } } + protected virtual double BarsPerMinuteTolerance { get { return 1e-5; } } + protected virtual double BarsPerSecondTolerance { get { return 1e-5; } } protected virtual double KilopascalsPerMinuteTolerance { get { return 1e-5; } } protected virtual double KilopascalsPerSecondTolerance { get { return 1e-5; } } protected virtual double KilopoundsForcePerSquareInchPerMinuteTolerance { get { return 1e-5; } } @@ -63,6 +69,8 @@ public abstract partial class PressureChangeRateTestsBase : QuantityTestsBase protected virtual double MegapascalsPerSecondTolerance { get { return 1e-5; } } protected virtual double MegapoundsForcePerSquareInchPerMinuteTolerance { get { return 1e-5; } } protected virtual double MegapoundsForcePerSquareInchPerSecondTolerance { get { return 1e-5; } } + protected virtual double MillibarsPerMinuteTolerance { get { return 1e-5; } } + protected virtual double MillibarsPerSecondTolerance { get { return 1e-5; } } protected virtual double MillimetersOfMercuryPerSecondTolerance { get { return 1e-5; } } protected virtual double PascalsPerMinuteTolerance { get { return 1e-5; } } protected virtual double PascalsPerSecondTolerance { get { return 1e-5; } } @@ -75,6 +83,8 @@ public abstract partial class PressureChangeRateTestsBase : QuantityTestsBase return unit switch { PressureChangeRateUnit.AtmospherePerSecond => (AtmospheresPerSecondInOnePascalPerSecond, AtmospheresPerSecondTolerance), + PressureChangeRateUnit.BarPerMinute => (BarsPerMinuteInOnePascalPerSecond, BarsPerMinuteTolerance), + PressureChangeRateUnit.BarPerSecond => (BarsPerSecondInOnePascalPerSecond, BarsPerSecondTolerance), PressureChangeRateUnit.KilopascalPerMinute => (KilopascalsPerMinuteInOnePascalPerSecond, KilopascalsPerMinuteTolerance), PressureChangeRateUnit.KilopascalPerSecond => (KilopascalsPerSecondInOnePascalPerSecond, KilopascalsPerSecondTolerance), PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute => (KilopoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, KilopoundsForcePerSquareInchPerMinuteTolerance), @@ -83,6 +93,8 @@ public abstract partial class PressureChangeRateTestsBase : QuantityTestsBase PressureChangeRateUnit.MegapascalPerSecond => (MegapascalsPerSecondInOnePascalPerSecond, MegapascalsPerSecondTolerance), PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute => (MegapoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, MegapoundsForcePerSquareInchPerMinuteTolerance), PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond => (MegapoundsForcePerSquareInchPerSecondInOnePascalPerSecond, MegapoundsForcePerSquareInchPerSecondTolerance), + PressureChangeRateUnit.MillibarPerMinute => (MillibarsPerMinuteInOnePascalPerSecond, MillibarsPerMinuteTolerance), + PressureChangeRateUnit.MillibarPerSecond => (MillibarsPerSecondInOnePascalPerSecond, MillibarsPerSecondTolerance), PressureChangeRateUnit.MillimeterOfMercuryPerSecond => (MillimetersOfMercuryPerSecondInOnePascalPerSecond, MillimetersOfMercuryPerSecondTolerance), PressureChangeRateUnit.PascalPerMinute => (PascalsPerMinuteInOnePascalPerSecond, PascalsPerMinuteTolerance), PressureChangeRateUnit.PascalPerSecond => (PascalsPerSecondInOnePascalPerSecond, PascalsPerSecondTolerance), @@ -95,6 +107,8 @@ public abstract partial class PressureChangeRateTestsBase : QuantityTestsBase public static IEnumerable UnitTypes = new List { new object[] { PressureChangeRateUnit.AtmospherePerSecond }, + new object[] { PressureChangeRateUnit.BarPerMinute }, + new object[] { PressureChangeRateUnit.BarPerSecond }, new object[] { PressureChangeRateUnit.KilopascalPerMinute }, new object[] { PressureChangeRateUnit.KilopascalPerSecond }, new object[] { PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute }, @@ -103,6 +117,8 @@ public abstract partial class PressureChangeRateTestsBase : QuantityTestsBase new object[] { PressureChangeRateUnit.MegapascalPerSecond }, new object[] { PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute }, new object[] { PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond }, + new object[] { PressureChangeRateUnit.MillibarPerMinute }, + new object[] { PressureChangeRateUnit.MillibarPerSecond }, new object[] { PressureChangeRateUnit.MillimeterOfMercuryPerSecond }, new object[] { PressureChangeRateUnit.PascalPerMinute }, new object[] { PressureChangeRateUnit.PascalPerSecond }, @@ -171,6 +187,8 @@ public void PascalPerSecondToPressureChangeRateUnits() { PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1); AssertEx.EqualTolerance(AtmospheresPerSecondInOnePascalPerSecond, pascalpersecond.AtmospheresPerSecond, AtmospheresPerSecondTolerance); + AssertEx.EqualTolerance(BarsPerMinuteInOnePascalPerSecond, pascalpersecond.BarsPerMinute, BarsPerMinuteTolerance); + AssertEx.EqualTolerance(BarsPerSecondInOnePascalPerSecond, pascalpersecond.BarsPerSecond, BarsPerSecondTolerance); AssertEx.EqualTolerance(KilopascalsPerMinuteInOnePascalPerSecond, pascalpersecond.KilopascalsPerMinute, KilopascalsPerMinuteTolerance); AssertEx.EqualTolerance(KilopascalsPerSecondInOnePascalPerSecond, pascalpersecond.KilopascalsPerSecond, KilopascalsPerSecondTolerance); AssertEx.EqualTolerance(KilopoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, pascalpersecond.KilopoundsForcePerSquareInchPerMinute, KilopoundsForcePerSquareInchPerMinuteTolerance); @@ -179,6 +197,8 @@ public void PascalPerSecondToPressureChangeRateUnits() AssertEx.EqualTolerance(MegapascalsPerSecondInOnePascalPerSecond, pascalpersecond.MegapascalsPerSecond, MegapascalsPerSecondTolerance); AssertEx.EqualTolerance(MegapoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, pascalpersecond.MegapoundsForcePerSquareInchPerMinute, MegapoundsForcePerSquareInchPerMinuteTolerance); AssertEx.EqualTolerance(MegapoundsForcePerSquareInchPerSecondInOnePascalPerSecond, pascalpersecond.MegapoundsForcePerSquareInchPerSecond, MegapoundsForcePerSquareInchPerSecondTolerance); + AssertEx.EqualTolerance(MillibarsPerMinuteInOnePascalPerSecond, pascalpersecond.MillibarsPerMinute, MillibarsPerMinuteTolerance); + AssertEx.EqualTolerance(MillibarsPerSecondInOnePascalPerSecond, pascalpersecond.MillibarsPerSecond, MillibarsPerSecondTolerance); AssertEx.EqualTolerance(MillimetersOfMercuryPerSecondInOnePascalPerSecond, pascalpersecond.MillimetersOfMercuryPerSecond, MillimetersOfMercuryPerSecondTolerance); AssertEx.EqualTolerance(PascalsPerMinuteInOnePascalPerSecond, pascalpersecond.PascalsPerMinute, PascalsPerMinuteTolerance); AssertEx.EqualTolerance(PascalsPerSecondInOnePascalPerSecond, pascalpersecond.PascalsPerSecond, PascalsPerSecondTolerance); @@ -193,57 +213,73 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity00.AtmospheresPerSecond, AtmospheresPerSecondTolerance); Assert.Equal(PressureChangeRateUnit.AtmospherePerSecond, quantity00.Unit); - var quantity01 = PressureChangeRate.From(1, PressureChangeRateUnit.KilopascalPerMinute); - AssertEx.EqualTolerance(1, quantity01.KilopascalsPerMinute, KilopascalsPerMinuteTolerance); - Assert.Equal(PressureChangeRateUnit.KilopascalPerMinute, quantity01.Unit); + var quantity01 = PressureChangeRate.From(1, PressureChangeRateUnit.BarPerMinute); + AssertEx.EqualTolerance(1, quantity01.BarsPerMinute, BarsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.BarPerMinute, quantity01.Unit); - var quantity02 = PressureChangeRate.From(1, PressureChangeRateUnit.KilopascalPerSecond); - AssertEx.EqualTolerance(1, quantity02.KilopascalsPerSecond, KilopascalsPerSecondTolerance); - Assert.Equal(PressureChangeRateUnit.KilopascalPerSecond, quantity02.Unit); + var quantity02 = PressureChangeRate.From(1, PressureChangeRateUnit.BarPerSecond); + AssertEx.EqualTolerance(1, quantity02.BarsPerSecond, BarsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.BarPerSecond, quantity02.Unit); - var quantity03 = PressureChangeRate.From(1, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute); - AssertEx.EqualTolerance(1, quantity03.KilopoundsForcePerSquareInchPerMinute, KilopoundsForcePerSquareInchPerMinuteTolerance); - Assert.Equal(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, quantity03.Unit); + var quantity03 = PressureChangeRate.From(1, PressureChangeRateUnit.KilopascalPerMinute); + AssertEx.EqualTolerance(1, quantity03.KilopascalsPerMinute, KilopascalsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.KilopascalPerMinute, quantity03.Unit); - var quantity04 = PressureChangeRate.From(1, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond); - AssertEx.EqualTolerance(1, quantity04.KilopoundsForcePerSquareInchPerSecond, KilopoundsForcePerSquareInchPerSecondTolerance); - Assert.Equal(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, quantity04.Unit); + var quantity04 = PressureChangeRate.From(1, PressureChangeRateUnit.KilopascalPerSecond); + AssertEx.EqualTolerance(1, quantity04.KilopascalsPerSecond, KilopascalsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.KilopascalPerSecond, quantity04.Unit); - var quantity05 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerMinute); - AssertEx.EqualTolerance(1, quantity05.MegapascalsPerMinute, MegapascalsPerMinuteTolerance); - Assert.Equal(PressureChangeRateUnit.MegapascalPerMinute, quantity05.Unit); + var quantity05 = PressureChangeRate.From(1, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute); + AssertEx.EqualTolerance(1, quantity05.KilopoundsForcePerSquareInchPerMinute, KilopoundsForcePerSquareInchPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, quantity05.Unit); - var quantity06 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerSecond); - AssertEx.EqualTolerance(1, quantity06.MegapascalsPerSecond, MegapascalsPerSecondTolerance); - Assert.Equal(PressureChangeRateUnit.MegapascalPerSecond, quantity06.Unit); + var quantity06 = PressureChangeRate.From(1, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond); + AssertEx.EqualTolerance(1, quantity06.KilopoundsForcePerSquareInchPerSecond, KilopoundsForcePerSquareInchPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond, quantity06.Unit); - var quantity07 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute); - AssertEx.EqualTolerance(1, quantity07.MegapoundsForcePerSquareInchPerMinute, MegapoundsForcePerSquareInchPerMinuteTolerance); - Assert.Equal(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, quantity07.Unit); + var quantity07 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerMinute); + AssertEx.EqualTolerance(1, quantity07.MegapascalsPerMinute, MegapascalsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.MegapascalPerMinute, quantity07.Unit); - var quantity08 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); - AssertEx.EqualTolerance(1, quantity08.MegapoundsForcePerSquareInchPerSecond, MegapoundsForcePerSquareInchPerSecondTolerance); - Assert.Equal(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, quantity08.Unit); + var quantity08 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapascalPerSecond); + AssertEx.EqualTolerance(1, quantity08.MegapascalsPerSecond, MegapascalsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.MegapascalPerSecond, quantity08.Unit); - var quantity09 = PressureChangeRate.From(1, PressureChangeRateUnit.MillimeterOfMercuryPerSecond); - AssertEx.EqualTolerance(1, quantity09.MillimetersOfMercuryPerSecond, MillimetersOfMercuryPerSecondTolerance); - Assert.Equal(PressureChangeRateUnit.MillimeterOfMercuryPerSecond, quantity09.Unit); + var quantity09 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute); + AssertEx.EqualTolerance(1, quantity09.MegapoundsForcePerSquareInchPerMinute, MegapoundsForcePerSquareInchPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, quantity09.Unit); - var quantity10 = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerMinute); - AssertEx.EqualTolerance(1, quantity10.PascalsPerMinute, PascalsPerMinuteTolerance); - Assert.Equal(PressureChangeRateUnit.PascalPerMinute, quantity10.Unit); + var quantity10 = PressureChangeRate.From(1, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); + AssertEx.EqualTolerance(1, quantity10.MegapoundsForcePerSquareInchPerSecond, MegapoundsForcePerSquareInchPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, quantity10.Unit); - var quantity11 = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerSecond); - AssertEx.EqualTolerance(1, quantity11.PascalsPerSecond, PascalsPerSecondTolerance); - Assert.Equal(PressureChangeRateUnit.PascalPerSecond, quantity11.Unit); + var quantity11 = PressureChangeRate.From(1, PressureChangeRateUnit.MillibarPerMinute); + AssertEx.EqualTolerance(1, quantity11.MillibarsPerMinute, MillibarsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.MillibarPerMinute, quantity11.Unit); - var quantity12 = PressureChangeRate.From(1, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute); - AssertEx.EqualTolerance(1, quantity12.PoundsForcePerSquareInchPerMinute, PoundsForcePerSquareInchPerMinuteTolerance); - Assert.Equal(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, quantity12.Unit); + var quantity12 = PressureChangeRate.From(1, PressureChangeRateUnit.MillibarPerSecond); + AssertEx.EqualTolerance(1, quantity12.MillibarsPerSecond, MillibarsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.MillibarPerSecond, quantity12.Unit); - var quantity13 = PressureChangeRate.From(1, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond); - AssertEx.EqualTolerance(1, quantity13.PoundsForcePerSquareInchPerSecond, PoundsForcePerSquareInchPerSecondTolerance); - Assert.Equal(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, quantity13.Unit); + var quantity13 = PressureChangeRate.From(1, PressureChangeRateUnit.MillimeterOfMercuryPerSecond); + AssertEx.EqualTolerance(1, quantity13.MillimetersOfMercuryPerSecond, MillimetersOfMercuryPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.MillimeterOfMercuryPerSecond, quantity13.Unit); + + var quantity14 = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerMinute); + AssertEx.EqualTolerance(1, quantity14.PascalsPerMinute, PascalsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.PascalPerMinute, quantity14.Unit); + + var quantity15 = PressureChangeRate.From(1, PressureChangeRateUnit.PascalPerSecond); + AssertEx.EqualTolerance(1, quantity15.PascalsPerSecond, PascalsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.PascalPerSecond, quantity15.Unit); + + var quantity16 = PressureChangeRate.From(1, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute); + AssertEx.EqualTolerance(1, quantity16.PoundsForcePerSquareInchPerMinute, PoundsForcePerSquareInchPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, quantity16.Unit); + + var quantity17 = PressureChangeRate.From(1, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond); + AssertEx.EqualTolerance(1, quantity17.PoundsForcePerSquareInchPerSecond, PoundsForcePerSquareInchPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, quantity17.Unit); } @@ -265,6 +301,8 @@ public void As() { var pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1); AssertEx.EqualTolerance(AtmospheresPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.AtmospherePerSecond), AtmospheresPerSecondTolerance); + AssertEx.EqualTolerance(BarsPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.BarPerMinute), BarsPerMinuteTolerance); + AssertEx.EqualTolerance(BarsPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.BarPerSecond), BarsPerSecondTolerance); AssertEx.EqualTolerance(KilopascalsPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.KilopascalPerMinute), KilopascalsPerMinuteTolerance); AssertEx.EqualTolerance(KilopascalsPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.KilopascalPerSecond), KilopascalsPerSecondTolerance); AssertEx.EqualTolerance(KilopoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute), KilopoundsForcePerSquareInchPerMinuteTolerance); @@ -273,6 +311,8 @@ public void As() AssertEx.EqualTolerance(MegapascalsPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.MegapascalPerSecond), MegapascalsPerSecondTolerance); AssertEx.EqualTolerance(MegapoundsForcePerSquareInchPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute), MegapoundsForcePerSquareInchPerMinuteTolerance); AssertEx.EqualTolerance(MegapoundsForcePerSquareInchPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond), MegapoundsForcePerSquareInchPerSecondTolerance); + AssertEx.EqualTolerance(MillibarsPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.MillibarPerMinute), MillibarsPerMinuteTolerance); + AssertEx.EqualTolerance(MillibarsPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.MillibarPerSecond), MillibarsPerSecondTolerance); AssertEx.EqualTolerance(MillimetersOfMercuryPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.MillimeterOfMercuryPerSecond), MillimetersOfMercuryPerSecondTolerance); AssertEx.EqualTolerance(PascalsPerMinuteInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.PascalPerMinute), PascalsPerMinuteTolerance); AssertEx.EqualTolerance(PascalsPerSecondInOnePascalPerSecond, pascalpersecond.As(PressureChangeRateUnit.PascalPerSecond), PascalsPerSecondTolerance); @@ -314,6 +354,34 @@ public void Parse() Assert.Equal(PressureChangeRateUnit.AtmospherePerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = PressureChangeRate.Parse("1 bar/min", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.BarsPerMinute, BarsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.BarPerMinute, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = PressureChangeRate.Parse("1 бар/мин", CultureInfo.GetCultureInfo("ru-RU")); + AssertEx.EqualTolerance(1, parsed.BarsPerMinute, BarsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.BarPerMinute, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = PressureChangeRate.Parse("1 bar/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.BarsPerSecond, BarsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.BarPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = PressureChangeRate.Parse("1 бар/с", CultureInfo.GetCultureInfo("ru-RU")); + AssertEx.EqualTolerance(1, parsed.BarsPerSecond, BarsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.BarPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = PressureChangeRate.Parse("1 kPa/min", CultureInfo.GetCultureInfo("en-US")); @@ -482,6 +550,34 @@ public void Parse() Assert.Equal(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, parsed.Unit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsed = PressureChangeRate.Parse("1 mbar/min", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.MillibarsPerMinute, MillibarsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.MillibarPerMinute, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = PressureChangeRate.Parse("1 мбар/мин", CultureInfo.GetCultureInfo("ru-RU")); + AssertEx.EqualTolerance(1, parsed.MillibarsPerMinute, MillibarsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.MillibarPerMinute, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = PressureChangeRate.Parse("1 mbar/s", CultureInfo.GetCultureInfo("en-US")); + AssertEx.EqualTolerance(1, parsed.MillibarsPerSecond, MillibarsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.MillibarPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsed = PressureChangeRate.Parse("1 мбар/с", CultureInfo.GetCultureInfo("ru-RU")); + AssertEx.EqualTolerance(1, parsed.MillibarsPerSecond, MillibarsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.MillibarPerSecond, parsed.Unit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsed = PressureChangeRate.Parse("1 mmHg/s", CultureInfo.GetCultureInfo("en-US")); @@ -597,6 +693,30 @@ public void TryParse() Assert.Equal(PressureChangeRateUnit.AtmospherePerSecond, parsed.Unit); } + { + Assert.True(PressureChangeRate.TryParse("1 bar/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.BarsPerMinute, BarsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.BarPerMinute, parsed.Unit); + } + + { + Assert.True(PressureChangeRate.TryParse("1 бар/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.BarsPerMinute, BarsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.BarPerMinute, parsed.Unit); + } + + { + Assert.True(PressureChangeRate.TryParse("1 bar/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.BarsPerSecond, BarsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.BarPerSecond, parsed.Unit); + } + + { + Assert.True(PressureChangeRate.TryParse("1 бар/с", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.BarsPerSecond, BarsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.BarPerSecond, parsed.Unit); + } + { Assert.True(PressureChangeRate.TryParse("1 kPa/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.KilopascalsPerMinute, KilopascalsPerMinuteTolerance); @@ -741,6 +861,30 @@ public void TryParse() Assert.Equal(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, parsed.Unit); } + { + Assert.True(PressureChangeRate.TryParse("1 mbar/min", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.MillibarsPerMinute, MillibarsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.MillibarPerMinute, parsed.Unit); + } + + { + Assert.True(PressureChangeRate.TryParse("1 мбар/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.MillibarsPerMinute, MillibarsPerMinuteTolerance); + Assert.Equal(PressureChangeRateUnit.MillibarPerMinute, parsed.Unit); + } + + { + Assert.True(PressureChangeRate.TryParse("1 mbar/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.MillibarsPerSecond, MillibarsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.MillibarPerSecond, parsed.Unit); + } + + { + Assert.True(PressureChangeRate.TryParse("1 мбар/с", CultureInfo.GetCultureInfo("ru-RU"), out var parsed)); + AssertEx.EqualTolerance(1, parsed.MillibarsPerSecond, MillibarsPerSecondTolerance); + Assert.Equal(PressureChangeRateUnit.MillibarPerSecond, parsed.Unit); + } + { Assert.True(PressureChangeRate.TryParse("1 mmHg/s", CultureInfo.GetCultureInfo("en-US"), out var parsed)); AssertEx.EqualTolerance(1, parsed.MillimetersOfMercuryPerSecond, MillimetersOfMercuryPerSecondTolerance); @@ -842,6 +986,30 @@ public void ParseUnit() Assert.Equal(PressureChangeRateUnit.AtmospherePerSecond, parsedUnit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsedUnit = PressureChangeRate.ParseUnit("bar/min", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(PressureChangeRateUnit.BarPerMinute, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = PressureChangeRate.ParseUnit("бар/мин", CultureInfo.GetCultureInfo("ru-RU")); + Assert.Equal(PressureChangeRateUnit.BarPerMinute, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = PressureChangeRate.ParseUnit("bar/s", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(PressureChangeRateUnit.BarPerSecond, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = PressureChangeRate.ParseUnit("бар/с", CultureInfo.GetCultureInfo("ru-RU")); + Assert.Equal(PressureChangeRateUnit.BarPerSecond, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsedUnit = PressureChangeRate.ParseUnit("kPa/min", CultureInfo.GetCultureInfo("en-US")); @@ -986,6 +1154,30 @@ public void ParseUnit() Assert.Equal(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, parsedUnit); } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try + { + var parsedUnit = PressureChangeRate.ParseUnit("mbar/min", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(PressureChangeRateUnit.MillibarPerMinute, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = PressureChangeRate.ParseUnit("мбар/мин", CultureInfo.GetCultureInfo("ru-RU")); + Assert.Equal(PressureChangeRateUnit.MillibarPerMinute, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = PressureChangeRate.ParseUnit("mbar/s", CultureInfo.GetCultureInfo("en-US")); + Assert.Equal(PressureChangeRateUnit.MillibarPerSecond, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + + try + { + var parsedUnit = PressureChangeRate.ParseUnit("мбар/с", CultureInfo.GetCultureInfo("ru-RU")); + Assert.Equal(PressureChangeRateUnit.MillibarPerSecond, parsedUnit); + } catch (AmbiguousUnitParseException) { /* Some units have the same abbreviations */ } + try { var parsedUnit = PressureChangeRate.ParseUnit("mmHg/s", CultureInfo.GetCultureInfo("en-US")); @@ -1085,6 +1277,26 @@ public void TryParseUnit() Assert.Equal(PressureChangeRateUnit.AtmospherePerSecond, parsedUnit); } + { + Assert.True(PressureChangeRate.TryParseUnit("bar/min", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(PressureChangeRateUnit.BarPerMinute, parsedUnit); + } + + { + Assert.True(PressureChangeRate.TryParseUnit("бар/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsedUnit)); + Assert.Equal(PressureChangeRateUnit.BarPerMinute, parsedUnit); + } + + { + Assert.True(PressureChangeRate.TryParseUnit("bar/s", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(PressureChangeRateUnit.BarPerSecond, parsedUnit); + } + + { + Assert.True(PressureChangeRate.TryParseUnit("бар/с", CultureInfo.GetCultureInfo("ru-RU"), out var parsedUnit)); + Assert.Equal(PressureChangeRateUnit.BarPerSecond, parsedUnit); + } + { Assert.True(PressureChangeRate.TryParseUnit("kPa/min", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); Assert.Equal(PressureChangeRateUnit.KilopascalPerMinute, parsedUnit); @@ -1205,6 +1417,26 @@ public void TryParseUnit() Assert.Equal(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, parsedUnit); } + { + Assert.True(PressureChangeRate.TryParseUnit("mbar/min", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(PressureChangeRateUnit.MillibarPerMinute, parsedUnit); + } + + { + Assert.True(PressureChangeRate.TryParseUnit("мбар/мин", CultureInfo.GetCultureInfo("ru-RU"), out var parsedUnit)); + Assert.Equal(PressureChangeRateUnit.MillibarPerMinute, parsedUnit); + } + + { + Assert.True(PressureChangeRate.TryParseUnit("mbar/s", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); + Assert.Equal(PressureChangeRateUnit.MillibarPerSecond, parsedUnit); + } + + { + Assert.True(PressureChangeRate.TryParseUnit("мбар/с", CultureInfo.GetCultureInfo("ru-RU"), out var parsedUnit)); + Assert.Equal(PressureChangeRateUnit.MillibarPerSecond, parsedUnit); + } + { Assert.True(PressureChangeRate.TryParseUnit("mmHg/s", CultureInfo.GetCultureInfo("en-US"), out var parsedUnit)); Assert.Equal(PressureChangeRateUnit.MillimeterOfMercuryPerSecond, parsedUnit); @@ -1324,6 +1556,8 @@ public void ConversionRoundTrip() { PressureChangeRate pascalpersecond = PressureChangeRate.FromPascalsPerSecond(1); AssertEx.EqualTolerance(1, PressureChangeRate.FromAtmospheresPerSecond(pascalpersecond.AtmospheresPerSecond).PascalsPerSecond, AtmospheresPerSecondTolerance); + AssertEx.EqualTolerance(1, PressureChangeRate.FromBarsPerMinute(pascalpersecond.BarsPerMinute).PascalsPerSecond, BarsPerMinuteTolerance); + AssertEx.EqualTolerance(1, PressureChangeRate.FromBarsPerSecond(pascalpersecond.BarsPerSecond).PascalsPerSecond, BarsPerSecondTolerance); AssertEx.EqualTolerance(1, PressureChangeRate.FromKilopascalsPerMinute(pascalpersecond.KilopascalsPerMinute).PascalsPerSecond, KilopascalsPerMinuteTolerance); AssertEx.EqualTolerance(1, PressureChangeRate.FromKilopascalsPerSecond(pascalpersecond.KilopascalsPerSecond).PascalsPerSecond, KilopascalsPerSecondTolerance); AssertEx.EqualTolerance(1, PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(pascalpersecond.KilopoundsForcePerSquareInchPerMinute).PascalsPerSecond, KilopoundsForcePerSquareInchPerMinuteTolerance); @@ -1332,6 +1566,8 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, PressureChangeRate.FromMegapascalsPerSecond(pascalpersecond.MegapascalsPerSecond).PascalsPerSecond, MegapascalsPerSecondTolerance); AssertEx.EqualTolerance(1, PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(pascalpersecond.MegapoundsForcePerSquareInchPerMinute).PascalsPerSecond, MegapoundsForcePerSquareInchPerMinuteTolerance); AssertEx.EqualTolerance(1, PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(pascalpersecond.MegapoundsForcePerSquareInchPerSecond).PascalsPerSecond, MegapoundsForcePerSquareInchPerSecondTolerance); + AssertEx.EqualTolerance(1, PressureChangeRate.FromMillibarsPerMinute(pascalpersecond.MillibarsPerMinute).PascalsPerSecond, MillibarsPerMinuteTolerance); + AssertEx.EqualTolerance(1, PressureChangeRate.FromMillibarsPerSecond(pascalpersecond.MillibarsPerSecond).PascalsPerSecond, MillibarsPerSecondTolerance); AssertEx.EqualTolerance(1, PressureChangeRate.FromMillimetersOfMercuryPerSecond(pascalpersecond.MillimetersOfMercuryPerSecond).PascalsPerSecond, MillimetersOfMercuryPerSecondTolerance); AssertEx.EqualTolerance(1, PressureChangeRate.FromPascalsPerMinute(pascalpersecond.PascalsPerMinute).PascalsPerSecond, PascalsPerMinuteTolerance); AssertEx.EqualTolerance(1, PressureChangeRate.FromPascalsPerSecond(pascalpersecond.PascalsPerSecond).PascalsPerSecond, PascalsPerSecondTolerance); @@ -1485,6 +1721,8 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("en-US"); try { Assert.Equal("1 atm/s", new PressureChangeRate(1, PressureChangeRateUnit.AtmospherePerSecond).ToString()); + Assert.Equal("1 bar/min", new PressureChangeRate(1, PressureChangeRateUnit.BarPerMinute).ToString()); + Assert.Equal("1 bar/s", new PressureChangeRate(1, PressureChangeRateUnit.BarPerSecond).ToString()); Assert.Equal("1 kPa/min", new PressureChangeRate(1, PressureChangeRateUnit.KilopascalPerMinute).ToString()); Assert.Equal("1 kPa/s", new PressureChangeRate(1, PressureChangeRateUnit.KilopascalPerSecond).ToString()); Assert.Equal("1 ksi/min", new PressureChangeRate(1, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute).ToString()); @@ -1493,6 +1731,8 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Assert.Equal("1 MPa/s", new PressureChangeRate(1, PressureChangeRateUnit.MegapascalPerSecond).ToString()); Assert.Equal("1 Mpsi/min", new PressureChangeRate(1, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute).ToString()); Assert.Equal("1 Mpsi/s", new PressureChangeRate(1, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond).ToString()); + Assert.Equal("1 mbar/min", new PressureChangeRate(1, PressureChangeRateUnit.MillibarPerMinute).ToString()); + Assert.Equal("1 mbar/s", new PressureChangeRate(1, PressureChangeRateUnit.MillibarPerSecond).ToString()); Assert.Equal("1 mmHg/s", new PressureChangeRate(1, PressureChangeRateUnit.MillimeterOfMercuryPerSecond).ToString()); Assert.Equal("1 Pa/min", new PressureChangeRate(1, PressureChangeRateUnit.PascalPerMinute).ToString()); Assert.Equal("1 Pa/s", new PressureChangeRate(1, PressureChangeRateUnit.PascalPerSecond).ToString()); @@ -1512,6 +1752,8 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture var swedishCulture = CultureInfo.GetCultureInfo("sv-SE"); Assert.Equal("1 atm/s", new PressureChangeRate(1, PressureChangeRateUnit.AtmospherePerSecond).ToString(swedishCulture)); + Assert.Equal("1 bar/min", new PressureChangeRate(1, PressureChangeRateUnit.BarPerMinute).ToString(swedishCulture)); + Assert.Equal("1 bar/s", new PressureChangeRate(1, PressureChangeRateUnit.BarPerSecond).ToString(swedishCulture)); Assert.Equal("1 kPa/min", new PressureChangeRate(1, PressureChangeRateUnit.KilopascalPerMinute).ToString(swedishCulture)); Assert.Equal("1 kPa/s", new PressureChangeRate(1, PressureChangeRateUnit.KilopascalPerSecond).ToString(swedishCulture)); Assert.Equal("1 ksi/min", new PressureChangeRate(1, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute).ToString(swedishCulture)); @@ -1520,6 +1762,8 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture Assert.Equal("1 MPa/s", new PressureChangeRate(1, PressureChangeRateUnit.MegapascalPerSecond).ToString(swedishCulture)); Assert.Equal("1 Mpsi/min", new PressureChangeRate(1, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute).ToString(swedishCulture)); Assert.Equal("1 Mpsi/s", new PressureChangeRate(1, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond).ToString(swedishCulture)); + Assert.Equal("1 mbar/min", new PressureChangeRate(1, PressureChangeRateUnit.MillibarPerMinute).ToString(swedishCulture)); + Assert.Equal("1 mbar/s", new PressureChangeRate(1, PressureChangeRateUnit.MillibarPerSecond).ToString(swedishCulture)); Assert.Equal("1 mmHg/s", new PressureChangeRate(1, PressureChangeRateUnit.MillimeterOfMercuryPerSecond).ToString(swedishCulture)); Assert.Equal("1 Pa/min", new PressureChangeRate(1, PressureChangeRateUnit.PascalPerMinute).ToString(swedishCulture)); Assert.Equal("1 Pa/s", new PressureChangeRate(1, PressureChangeRateUnit.PascalPerSecond).ToString(swedishCulture)); diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs index 194cb7500a..044d4ad6d7 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs @@ -67,8 +67,11 @@ static ElectricCurrentGradient() { new UnitInfo(ElectricCurrentGradientUnit.AmperePerMicrosecond, "AmperesPerMicrosecond", new BaseUnits(time: DurationUnit.Microsecond, current: ElectricCurrentUnit.Ampere), "ElectricCurrentGradient"), new UnitInfo(ElectricCurrentGradientUnit.AmperePerMillisecond, "AmperesPerMillisecond", new BaseUnits(time: DurationUnit.Millisecond, current: ElectricCurrentUnit.Ampere), "ElectricCurrentGradient"), + new UnitInfo(ElectricCurrentGradientUnit.AmperePerMinute, "AmperesPerMinute", new BaseUnits(time: DurationUnit.Minute, current: ElectricCurrentUnit.Ampere), "ElectricCurrentGradient"), new UnitInfo(ElectricCurrentGradientUnit.AmperePerNanosecond, "AmperesPerNanosecond", new BaseUnits(time: DurationUnit.Nanosecond, current: ElectricCurrentUnit.Ampere), "ElectricCurrentGradient"), - new UnitInfo(ElectricCurrentGradientUnit.AmperePerSecond, "AmperesPerSecond", BaseUnits.Undefined, "ElectricCurrentGradient"), + new UnitInfo(ElectricCurrentGradientUnit.AmperePerSecond, "AmperesPerSecond", new BaseUnits(time: DurationUnit.Second, current: ElectricCurrentUnit.Ampere), "ElectricCurrentGradient"), + new UnitInfo(ElectricCurrentGradientUnit.MilliamperePerMinute, "MilliamperesPerMinute", BaseUnits.Undefined, "ElectricCurrentGradient"), + new UnitInfo(ElectricCurrentGradientUnit.MilliamperePerSecond, "MilliamperesPerSecond", BaseUnits.Undefined, "ElectricCurrentGradient"), }, BaseUnit, Zero, BaseDimensions); @@ -182,6 +185,11 @@ public ElectricCurrentGradient(double value, UnitSystem unitSystem) /// public double AmperesPerMillisecond => As(ElectricCurrentGradientUnit.AmperePerMillisecond); + /// + /// Gets a value of this quantity converted into + /// + public double AmperesPerMinute => As(ElectricCurrentGradientUnit.AmperePerMinute); + /// /// Gets a value of this quantity converted into /// @@ -192,6 +200,16 @@ public ElectricCurrentGradient(double value, UnitSystem unitSystem) /// public double AmperesPerSecond => As(ElectricCurrentGradientUnit.AmperePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double MilliamperesPerMinute => As(ElectricCurrentGradientUnit.MilliamperePerMinute); + + /// + /// Gets a value of this quantity converted into + /// + public double MilliamperesPerSecond => As(ElectricCurrentGradientUnit.MilliamperePerSecond); + #endregion #region Static Methods @@ -205,7 +223,10 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) // Register in unit converter: ElectricCurrentGradientUnit -> BaseUnit unitConverter.SetConversionFunction(ElectricCurrentGradientUnit.AmperePerMicrosecond, ElectricCurrentGradientUnit.AmperePerSecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerSecond)); unitConverter.SetConversionFunction(ElectricCurrentGradientUnit.AmperePerMillisecond, ElectricCurrentGradientUnit.AmperePerSecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerSecond)); + unitConverter.SetConversionFunction(ElectricCurrentGradientUnit.AmperePerMinute, ElectricCurrentGradientUnit.AmperePerSecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerSecond)); unitConverter.SetConversionFunction(ElectricCurrentGradientUnit.AmperePerNanosecond, ElectricCurrentGradientUnit.AmperePerSecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerSecond)); + unitConverter.SetConversionFunction(ElectricCurrentGradientUnit.MilliamperePerMinute, ElectricCurrentGradientUnit.AmperePerSecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerSecond)); + unitConverter.SetConversionFunction(ElectricCurrentGradientUnit.MilliamperePerSecond, ElectricCurrentGradientUnit.AmperePerSecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerSecond)); // Register in unit converter: BaseUnit <-> BaseUnit unitConverter.SetConversionFunction(ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerSecond, quantity => quantity); @@ -213,7 +234,10 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) // Register in unit converter: BaseUnit -> ElectricCurrentGradientUnit unitConverter.SetConversionFunction(ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerMicrosecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerMicrosecond)); unitConverter.SetConversionFunction(ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerMillisecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerMillisecond)); + unitConverter.SetConversionFunction(ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerMinute, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerMinute)); unitConverter.SetConversionFunction(ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerNanosecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.AmperePerNanosecond)); + unitConverter.SetConversionFunction(ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.MilliamperePerMinute, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.MilliamperePerMinute)); + unitConverter.SetConversionFunction(ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.MilliamperePerSecond, quantity => quantity.ToUnit(ElectricCurrentGradientUnit.MilliamperePerSecond)); } /// @@ -261,6 +285,16 @@ public static ElectricCurrentGradient FromAmperesPerMillisecond(QuantityValue am return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMillisecond); } + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static ElectricCurrentGradient FromAmperesPerMinute(QuantityValue amperesperminute) + { + double value = (double) amperesperminute; + return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMinute); + } + /// /// Creates a from . /// @@ -281,6 +315,26 @@ public static ElectricCurrentGradient FromAmperesPerSecond(QuantityValue amperes return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerSecond); } + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static ElectricCurrentGradient FromMilliamperesPerMinute(QuantityValue milliamperesperminute) + { + double value = (double) milliamperesperminute; + return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.MilliamperePerMinute); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static ElectricCurrentGradient FromMilliamperesPerSecond(QuantityValue milliamperespersecond) + { + double value = (double) milliamperespersecond; + return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.MilliamperePerSecond); + } + /// /// Dynamically convert from value and unit enum to . /// @@ -776,12 +830,18 @@ private bool TryToUnit(ElectricCurrentGradientUnit unit, [NotNullWhen(true)] out // ElectricCurrentGradientUnit -> BaseUnit (ElectricCurrentGradientUnit.AmperePerMicrosecond, ElectricCurrentGradientUnit.AmperePerSecond) => new ElectricCurrentGradient(_value * 1E6, ElectricCurrentGradientUnit.AmperePerSecond), (ElectricCurrentGradientUnit.AmperePerMillisecond, ElectricCurrentGradientUnit.AmperePerSecond) => new ElectricCurrentGradient(_value * 1E3, ElectricCurrentGradientUnit.AmperePerSecond), + (ElectricCurrentGradientUnit.AmperePerMinute, ElectricCurrentGradientUnit.AmperePerSecond) => new ElectricCurrentGradient(_value / 60, ElectricCurrentGradientUnit.AmperePerSecond), (ElectricCurrentGradientUnit.AmperePerNanosecond, ElectricCurrentGradientUnit.AmperePerSecond) => new ElectricCurrentGradient(_value * 1E9, ElectricCurrentGradientUnit.AmperePerSecond), + (ElectricCurrentGradientUnit.MilliamperePerMinute, ElectricCurrentGradientUnit.AmperePerSecond) => new ElectricCurrentGradient((_value / 60) * 1e-3d, ElectricCurrentGradientUnit.AmperePerSecond), + (ElectricCurrentGradientUnit.MilliamperePerSecond, ElectricCurrentGradientUnit.AmperePerSecond) => new ElectricCurrentGradient((_value) * 1e-3d, ElectricCurrentGradientUnit.AmperePerSecond), // BaseUnit -> ElectricCurrentGradientUnit (ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerMicrosecond) => new ElectricCurrentGradient(_value / 1E6, ElectricCurrentGradientUnit.AmperePerMicrosecond), (ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerMillisecond) => new ElectricCurrentGradient(_value / 1E3, ElectricCurrentGradientUnit.AmperePerMillisecond), + (ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerMinute) => new ElectricCurrentGradient(_value * 60, ElectricCurrentGradientUnit.AmperePerMinute), (ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.AmperePerNanosecond) => new ElectricCurrentGradient(_value / 1E9, ElectricCurrentGradientUnit.AmperePerNanosecond), + (ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.MilliamperePerMinute) => new ElectricCurrentGradient((_value * 60) / 1e-3d, ElectricCurrentGradientUnit.MilliamperePerMinute), + (ElectricCurrentGradientUnit.AmperePerSecond, ElectricCurrentGradientUnit.MilliamperePerSecond) => new ElectricCurrentGradient((_value) / 1e-3d, ElectricCurrentGradientUnit.MilliamperePerSecond), _ => null }; diff --git a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs index a08361c9c8..d42f859ed1 100644 --- a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs @@ -66,6 +66,8 @@ static PressureChangeRate() new UnitInfo[] { new UnitInfo(PressureChangeRateUnit.AtmospherePerSecond, "AtmospheresPerSecond", BaseUnits.Undefined, "PressureChangeRate"), + new UnitInfo(PressureChangeRateUnit.BarPerMinute, "BarsPerMinute", BaseUnits.Undefined, "PressureChangeRate"), + new UnitInfo(PressureChangeRateUnit.BarPerSecond, "BarsPerSecond", BaseUnits.Undefined, "PressureChangeRate"), new UnitInfo(PressureChangeRateUnit.KilopascalPerMinute, "KilopascalsPerMinute", BaseUnits.Undefined, "PressureChangeRate"), new UnitInfo(PressureChangeRateUnit.KilopascalPerSecond, "KilopascalsPerSecond", BaseUnits.Undefined, "PressureChangeRate"), new UnitInfo(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, "KilopoundsForcePerSquareInchPerMinute", BaseUnits.Undefined, "PressureChangeRate"), @@ -74,6 +76,8 @@ static PressureChangeRate() new UnitInfo(PressureChangeRateUnit.MegapascalPerSecond, "MegapascalsPerSecond", BaseUnits.Undefined, "PressureChangeRate"), new UnitInfo(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, "MegapoundsForcePerSquareInchPerMinute", BaseUnits.Undefined, "PressureChangeRate"), new UnitInfo(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, "MegapoundsForcePerSquareInchPerSecond", BaseUnits.Undefined, "PressureChangeRate"), + new UnitInfo(PressureChangeRateUnit.MillibarPerMinute, "MillibarsPerMinute", BaseUnits.Undefined, "PressureChangeRate"), + new UnitInfo(PressureChangeRateUnit.MillibarPerSecond, "MillibarsPerSecond", BaseUnits.Undefined, "PressureChangeRate"), new UnitInfo(PressureChangeRateUnit.MillimeterOfMercuryPerSecond, "MillimetersOfMercuryPerSecond", BaseUnits.Undefined, "PressureChangeRate"), new UnitInfo(PressureChangeRateUnit.PascalPerMinute, "PascalsPerMinute", BaseUnits.Undefined, "PressureChangeRate"), new UnitInfo(PressureChangeRateUnit.PascalPerSecond, "PascalsPerSecond", BaseUnits.Undefined, "PressureChangeRate"), @@ -187,6 +191,16 @@ public PressureChangeRate(double value, UnitSystem unitSystem) /// public double AtmospheresPerSecond => As(PressureChangeRateUnit.AtmospherePerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double BarsPerMinute => As(PressureChangeRateUnit.BarPerMinute); + + /// + /// Gets a value of this quantity converted into + /// + public double BarsPerSecond => As(PressureChangeRateUnit.BarPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -227,6 +241,16 @@ public PressureChangeRate(double value, UnitSystem unitSystem) /// public double MegapoundsForcePerSquareInchPerSecond => As(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); + /// + /// Gets a value of this quantity converted into + /// + public double MillibarsPerMinute => As(PressureChangeRateUnit.MillibarPerMinute); + + /// + /// Gets a value of this quantity converted into + /// + public double MillibarsPerSecond => As(PressureChangeRateUnit.MillibarPerSecond); + /// /// Gets a value of this quantity converted into /// @@ -264,6 +288,8 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) { // Register in unit converter: PressureChangeRateUnit -> BaseUnit unitConverter.SetConversionFunction(PressureChangeRateUnit.AtmospherePerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.BarPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.BarPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopascalPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopascalPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond)); @@ -272,6 +298,8 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapascalPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.MillibarPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.MillibarPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.MillimeterOfMercuryPerSecond, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, PressureChangeRateUnit.PascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerSecond)); @@ -282,6 +310,8 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) // Register in unit converter: BaseUnit -> PressureChangeRateUnit unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.AtmospherePerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.AtmospherePerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.BarPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.BarPerMinute)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.BarPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.BarPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.KilopascalPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.KilopascalPerMinute)); unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.KilopascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.KilopascalPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute)); @@ -290,6 +320,8 @@ internal static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MegapascalPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.MegapascalPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute)); unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MillibarPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.MillibarPerMinute)); + unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MillibarPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.MillibarPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MillimeterOfMercuryPerSecond, quantity => quantity.ToUnit(PressureChangeRateUnit.MillimeterOfMercuryPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.PascalPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.PascalPerMinute)); unitConverter.SetConversionFunction(PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, quantity => quantity.ToUnit(PressureChangeRateUnit.PoundForcePerSquareInchPerMinute)); @@ -331,6 +363,26 @@ public static PressureChangeRate FromAtmospheresPerSecond(QuantityValue atmosphe return new PressureChangeRate(value, PressureChangeRateUnit.AtmospherePerSecond); } + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static PressureChangeRate FromBarsPerMinute(QuantityValue barsperminute) + { + double value = (double) barsperminute; + return new PressureChangeRate(value, PressureChangeRateUnit.BarPerMinute); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static PressureChangeRate FromBarsPerSecond(QuantityValue barspersecond) + { + double value = (double) barspersecond; + return new PressureChangeRate(value, PressureChangeRateUnit.BarPerSecond); + } + /// /// Creates a from . /// @@ -411,6 +463,26 @@ public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(Quant return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); } + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static PressureChangeRate FromMillibarsPerMinute(QuantityValue millibarsperminute) + { + double value = (double) millibarsperminute; + return new PressureChangeRate(value, PressureChangeRateUnit.MillibarPerMinute); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static PressureChangeRate FromMillibarsPerSecond(QuantityValue millibarspersecond) + { + double value = (double) millibarspersecond; + return new PressureChangeRate(value, PressureChangeRateUnit.MillibarPerSecond); + } + /// /// Creates a from . /// @@ -955,6 +1027,8 @@ private bool TryToUnit(PressureChangeRateUnit unit, [NotNullWhen(true)] out Pres { // PressureChangeRateUnit -> BaseUnit (PressureChangeRateUnit.AtmospherePerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate(_value * 1.01325 * 1e5, PressureChangeRateUnit.PascalPerSecond), + (PressureChangeRateUnit.BarPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate(_value * 1e5 / 60, PressureChangeRateUnit.PascalPerSecond), + (PressureChangeRateUnit.BarPerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate(_value * 1e5, PressureChangeRateUnit.PascalPerSecond), (PressureChangeRateUnit.KilopascalPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value / 60) * 1e3d, PressureChangeRateUnit.PascalPerSecond), (PressureChangeRateUnit.KilopascalPerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value) * 1e3d, PressureChangeRateUnit.PascalPerSecond), (PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value * 6.894757293168361e3 / 60) * 1e3d, PressureChangeRateUnit.PascalPerSecond), @@ -963,6 +1037,8 @@ private bool TryToUnit(PressureChangeRateUnit unit, [NotNullWhen(true)] out Pres (PressureChangeRateUnit.MegapascalPerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value) * 1e6d, PressureChangeRateUnit.PascalPerSecond), (PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value * 6.894757293168361e3 / 60) * 1e6d, PressureChangeRateUnit.PascalPerSecond), (PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value * 6.894757293168361e3) * 1e6d, PressureChangeRateUnit.PascalPerSecond), + (PressureChangeRateUnit.MillibarPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value * 1e5 / 60) * 1e-3d, PressureChangeRateUnit.PascalPerSecond), + (PressureChangeRateUnit.MillibarPerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate((_value * 1e5) * 1e-3d, PressureChangeRateUnit.PascalPerSecond), (PressureChangeRateUnit.MillimeterOfMercuryPerSecond, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate(_value * 133.322, PressureChangeRateUnit.PascalPerSecond), (PressureChangeRateUnit.PascalPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate(_value / 60, PressureChangeRateUnit.PascalPerSecond), (PressureChangeRateUnit.PoundForcePerSquareInchPerMinute, PressureChangeRateUnit.PascalPerSecond) => new PressureChangeRate(_value * 6.894757293168361e3 / 60, PressureChangeRateUnit.PascalPerSecond), @@ -970,6 +1046,8 @@ private bool TryToUnit(PressureChangeRateUnit unit, [NotNullWhen(true)] out Pres // BaseUnit -> PressureChangeRateUnit (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.AtmospherePerSecond) => new PressureChangeRate(_value / (1.01325 * 1e5), PressureChangeRateUnit.AtmospherePerSecond), + (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.BarPerMinute) => new PressureChangeRate(_value / 1e5 * 60, PressureChangeRateUnit.BarPerMinute), + (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.BarPerSecond) => new PressureChangeRate(_value / 1e5, PressureChangeRateUnit.BarPerSecond), (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.KilopascalPerMinute) => new PressureChangeRate((_value * 60) / 1e3d, PressureChangeRateUnit.KilopascalPerMinute), (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.KilopascalPerSecond) => new PressureChangeRate((_value) / 1e3d, PressureChangeRateUnit.KilopascalPerSecond), (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute) => new PressureChangeRate((_value / 6.894757293168361e3 * 60) / 1e3d, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute), @@ -978,6 +1056,8 @@ private bool TryToUnit(PressureChangeRateUnit unit, [NotNullWhen(true)] out Pres (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MegapascalPerSecond) => new PressureChangeRate((_value) / 1e6d, PressureChangeRateUnit.MegapascalPerSecond), (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute) => new PressureChangeRate((_value / 6.894757293168361e3 * 60) / 1e6d, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute), (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond) => new PressureChangeRate((_value / 6.894757293168361e3) / 1e6d, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond), + (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MillibarPerMinute) => new PressureChangeRate((_value / 1e5 * 60) / 1e-3d, PressureChangeRateUnit.MillibarPerMinute), + (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MillibarPerSecond) => new PressureChangeRate((_value / 1e5) / 1e-3d, PressureChangeRateUnit.MillibarPerSecond), (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.MillimeterOfMercuryPerSecond) => new PressureChangeRate(_value / 133.322, PressureChangeRateUnit.MillimeterOfMercuryPerSecond), (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.PascalPerMinute) => new PressureChangeRate(_value * 60, PressureChangeRateUnit.PascalPerMinute), (PressureChangeRateUnit.PascalPerSecond, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute) => new PressureChangeRate(_value / 6.894757293168361e3 * 60, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute), diff --git a/UnitsNet/GeneratedCode/Resources/ElectricCurrentGradient.restext b/UnitsNet/GeneratedCode/Resources/ElectricCurrentGradient.restext index 4a4fb09d25..9e4515a9cd 100644 --- a/UnitsNet/GeneratedCode/Resources/ElectricCurrentGradient.restext +++ b/UnitsNet/GeneratedCode/Resources/ElectricCurrentGradient.restext @@ -1,4 +1,7 @@ AmperesPerMicrosecond=A/μs AmperesPerMillisecond=A/ms +AmperesPerMinute=A/min AmperesPerNanosecond=A/ns AmperesPerSecond=A/s +MilliamperesPerMinute=mA/min +MilliamperesPerSecond=mA/s diff --git a/UnitsNet/GeneratedCode/Resources/PressureChangeRate.restext b/UnitsNet/GeneratedCode/Resources/PressureChangeRate.restext index 04f57bca0e..8b27d614dc 100644 --- a/UnitsNet/GeneratedCode/Resources/PressureChangeRate.restext +++ b/UnitsNet/GeneratedCode/Resources/PressureChangeRate.restext @@ -1,4 +1,6 @@ AtmospheresPerSecond=atm/s +BarsPerMinute=bar/min +BarsPerSecond=bar/s KilopascalsPerMinute=kPa/min KilopascalsPerSecond=kPa/s KilopoundsForcePerSquareInchPerMinute=ksi/min,kipf/in²/min @@ -7,6 +9,8 @@ MegapascalsPerMinute=MPa/min MegapascalsPerSecond=MPa/s MegapoundsForcePerSquareInchPerMinute=Mpsi/min,Mlb/in²/min MegapoundsForcePerSquareInchPerSecond=Mpsi/s,Mlb/in²/s +MillibarsPerMinute=mbar/min +MillibarsPerSecond=mbar/s MillimetersOfMercuryPerSecond=mmHg/s PascalsPerMinute=Pa/min PascalsPerSecond=Pa/s diff --git a/UnitsNet/GeneratedCode/Resources/PressureChangeRate.ru-RU.restext b/UnitsNet/GeneratedCode/Resources/PressureChangeRate.ru-RU.restext index 096bd255b2..3de7826088 100644 --- a/UnitsNet/GeneratedCode/Resources/PressureChangeRate.ru-RU.restext +++ b/UnitsNet/GeneratedCode/Resources/PressureChangeRate.ru-RU.restext @@ -1,4 +1,6 @@ AtmospheresPerSecond=атм/с +BarsPerMinute=бар/мин +BarsPerSecond=бар/с KilopascalsPerMinute=кПа/мин KilopascalsPerSecond=кПа/с KilopoundsForcePerSquareInchPerMinute=ksi/мин,kipf/in²/мин @@ -7,6 +9,8 @@ MegapascalsPerMinute=МПа/мин MegapascalsPerSecond=МПа/с MegapoundsForcePerSquareInchPerMinute=Мpsi/мин,Мlb/in²/мин MegapoundsForcePerSquareInchPerSecond=Мpsi/с,Мlb/in²/с +MillibarsPerMinute=мбар/мин +MillibarsPerSecond=мбар/с MillimetersOfMercuryPerSecond=mmHg/с PascalsPerMinute=Па/мин PascalsPerSecond=Па/с diff --git a/UnitsNet/GeneratedCode/Units/ElectricCurrentGradientUnit.g.cs b/UnitsNet/GeneratedCode/Units/ElectricCurrentGradientUnit.g.cs index eb247e6cfc..64607d4ef8 100644 --- a/UnitsNet/GeneratedCode/Units/ElectricCurrentGradientUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/ElectricCurrentGradientUnit.g.cs @@ -27,8 +27,11 @@ public enum ElectricCurrentGradientUnit { AmperePerMicrosecond = 1, AmperePerMillisecond = 2, + AmperePerMinute = 11, AmperePerNanosecond = 3, AmperePerSecond = 4, + MilliamperePerMinute = 6, + MilliamperePerSecond = 14, } #pragma warning restore 1591 diff --git a/UnitsNet/GeneratedCode/Units/PressureChangeRateUnit.g.cs b/UnitsNet/GeneratedCode/Units/PressureChangeRateUnit.g.cs index fed99a6a4a..8593e5b890 100644 --- a/UnitsNet/GeneratedCode/Units/PressureChangeRateUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/PressureChangeRateUnit.g.cs @@ -26,6 +26,8 @@ namespace UnitsNet.Units public enum PressureChangeRateUnit { AtmospherePerSecond = 1, + BarPerMinute = 16, + BarPerSecond = 23, KilopascalPerMinute = 2, KilopascalPerSecond = 3, KilopoundForcePerSquareInchPerMinute = 4, @@ -34,6 +36,8 @@ public enum PressureChangeRateUnit MegapascalPerSecond = 7, MegapoundForcePerSquareInchPerMinute = 8, MegapoundForcePerSquareInchPerSecond = 9, + MillibarPerMinute = 24, + MillibarPerSecond = 20, MillimeterOfMercuryPerSecond = 10, PascalPerMinute = 11, PascalPerSecond = 12, From 7d772b307f528ad9be7f02d8c65d3b1f8a47948f Mon Sep 17 00:00:00 2001 From: v'Karas Date: Wed, 28 Jun 2023 18:52:25 +0200 Subject: [PATCH 2/4] Only added some files with a change in summary spaces from an old CodeGen change? can't find it because it looks like that this line changes has been excluded from commits from atleast (#656) --- UnitsNet/GeneratedCode/Quantities/Molarity.g.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs index 4814b4fdac..0818f01a01 100644 --- a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs @@ -33,7 +33,7 @@ namespace UnitsNet { /// /// - /// Molar concentration, also called molarity, amount concentration or substance concentration, is a measure of the concentration of a solute in a solution, or of any chemical species, in terms of amount of substance in a given volume. + /// Molar concentration, also called molarity, amount concentration or substance concentration, is a measure of the concentration of a solute in a solution, or of any chemical species, in terms of amount of substance in a given volume. /// /// /// https://en.wikipedia.org/wiki/Molar_concentration From cf1b16c602ec71cef212273841bc1e3e9cfc797c Mon Sep 17 00:00:00 2001 From: v'Karas Date: Thu, 29 Jun 2023 16:24:31 +0200 Subject: [PATCH 3/4] operator overloads for ElectricCurrentGradient and time to ElectricCurrent and PressureChangeRate and Time to Pressure --- .../ElectricCurrentGradientTests.cs | 16 ++++++++++++++ .../CustomCode/ElectricCurrentTests.cs | 16 ++++++++++++++ .../CustomCode/PressureChangeRateTests.cs | 20 ++++++++++++++++- UnitsNet.Tests/CustomCode/PressureTests.cs | 14 ++++++++++++ .../Quantities/ElectricCurrent.extra.cs | 14 ++++++++++++ .../ElectricCurrentGradient.extra.cs | 22 +++++++++++++++++++ .../CustomCode/Quantities/Pressure.extra.cs | 14 ++++++++++++ .../Quantities/PressureChangeRate.extra.cs | 22 +++++++++++++++++++ 8 files changed, 137 insertions(+), 1 deletion(-) create mode 100644 UnitsNet/CustomCode/Quantities/ElectricCurrentGradient.extra.cs create mode 100644 UnitsNet/CustomCode/Quantities/PressureChangeRate.extra.cs diff --git a/UnitsNet.Tests/CustomCode/ElectricCurrentGradientTests.cs b/UnitsNet.Tests/CustomCode/ElectricCurrentGradientTests.cs index 17b75ad3ce..f57f3d9190 100644 --- a/UnitsNet.Tests/CustomCode/ElectricCurrentGradientTests.cs +++ b/UnitsNet.Tests/CustomCode/ElectricCurrentGradientTests.cs @@ -23,6 +23,8 @@ using System; +using Xunit; + namespace UnitsNet.Tests.CustomCode { public class ElectricCurrentGradientTests : ElectricCurrentGradientTestsBase @@ -36,5 +38,19 @@ public class ElectricCurrentGradientTests : ElectricCurrentGradientTestsBase protected override double AmperesPerMinuteInOneAmperePerSecond => 60; protected override double MilliamperesPerMinuteInOneAmperePerSecond => 6e4; protected override double MilliamperesPerSecondInOneAmperePerSecond => 1e3; + + [Fact] + public void ElectricCurrentGradientTimesDurationEqualsElectricCurrent() + { + ElectricCurrent electricCurrent = ElectricCurrentGradient.FromAmperesPerSecond(10) * Duration.FromSeconds(2); + Assert.Equal(ElectricCurrent.FromAmperes(20) ,electricCurrent); + } + + [Fact] + public void ElectricCurrentGradientTimesTimeSpanEqualsElectricCurrent() + { + ElectricCurrent electricCurrent = ElectricCurrentGradient.FromAmperesPerSecond(10) * TimeSpan.FromSeconds(2); + Assert.Equal(ElectricCurrent.FromAmperes(20), electricCurrent); + } } } diff --git a/UnitsNet.Tests/CustomCode/ElectricCurrentTests.cs b/UnitsNet.Tests/CustomCode/ElectricCurrentTests.cs index 861d0aeb74..61ae46f9a8 100644 --- a/UnitsNet.Tests/CustomCode/ElectricCurrentTests.cs +++ b/UnitsNet.Tests/CustomCode/ElectricCurrentTests.cs @@ -1,6 +1,8 @@ // Licensed under MIT No Attribution, see LICENSE file at the root. // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. +using System; + using Xunit; namespace UnitsNet.Tests @@ -52,5 +54,19 @@ public void ElectricCurrentMultipliedByDurationEqualsElectricCharge() ElectricCharge ah = ElectricCurrent.FromAmperes(4) * Duration.FromHours(5); Assert.Equal(20, ah.AmpereHours); } + + [Fact] + public void ElectricCurrentDividedByDurationEqualsElectricCurrentGradient() + { + ElectricCurrentGradient electricCurrentGradient = ElectricCurrent.FromAmperes(10) / Duration.FromSeconds(2); + Assert.Equal(ElectricCurrentGradient.FromAmperesPerSecond(5), electricCurrentGradient); + } + + [Fact] + public void ElectricCurrentDividedByTimeSpanEqualsElectricCurrentGradient() + { + ElectricCurrentGradient electricCurrentGradient = ElectricCurrent.FromAmperes(10) / TimeSpan.FromSeconds(2); + Assert.Equal(ElectricCurrentGradient.FromAmperesPerSecond(5), electricCurrentGradient); + } } } diff --git a/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs b/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs index 99c93b7202..b2ea085cef 100644 --- a/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs +++ b/UnitsNet.Tests/CustomCode/PressureChangeRateTests.cs @@ -1,12 +1,16 @@ // Licensed under MIT No Attribution, see LICENSE file at the root. // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. +using System; + +using Xunit; + namespace UnitsNet.Tests { public class PressureChangeRateTests : PressureChangeRateTestsBase { protected override bool SupportsSIUnitSystem => false; - protected override double AtmospheresPerSecondInOnePascalPerSecond => 9.8692*1E-6; + protected override double AtmospheresPerSecondInOnePascalPerSecond => 9.8692 * 1E-6; protected override double KilopascalsPerSecondInOnePascalPerSecond => 1e-3; @@ -41,5 +45,19 @@ public class PressureChangeRateTests : PressureChangeRateTestsBase protected override double MillibarsPerMinuteInOnePascalPerSecond => 0.6; protected override double MillibarsPerSecondInOnePascalPerSecond => 1e-2; + + [Fact] + public void PressureChangeRateTimesDurationEqualsPressure() + { + Pressure pressure = PressureChangeRate.FromPascalsPerSecond(500) * Duration.FromSeconds(2); + Assert.Equal(Pressure.FromPascals(1000), pressure); + } + + [Fact] + public void PressureChangeRateTimesTimeSpanEqualsPressure() + { + Pressure pressure = PressureChangeRate.FromPascalsPerSecond(500) * TimeSpan.FromSeconds(2); + Assert.Equal(Pressure.FromPascals(1000), pressure); + } } } diff --git a/UnitsNet.Tests/CustomCode/PressureTests.cs b/UnitsNet.Tests/CustomCode/PressureTests.cs index 15eb0ad09e..f369b61f9e 100644 --- a/UnitsNet.Tests/CustomCode/PressureTests.cs +++ b/UnitsNet.Tests/CustomCode/PressureTests.cs @@ -248,5 +248,19 @@ public void PressureDividedByReciprocalAreaEqualsForce() Force force = Pressure.FromPascals(200) / ReciprocalArea.FromInverseSquareMeters(5); Assert.Equal(force, Force.FromNewtons(40)); } + + [Fact] + public void PressureDividedByDurationEqualsPressureChangeRate() + { + PressureChangeRate pressureChangeRate = Pressure.FromPascals(500) / Duration.FromSeconds(2); + Assert.Equal(PressureChangeRate.FromPascalsPerSecond(250), pressureChangeRate); + } + + [Fact] + public void PressureDividedByTimeSpanEqualsPressurechangeRate() + { + PressureChangeRate pressureChangeRate = Pressure.FromPascals(50) / TimeSpan.FromSeconds(5); + Assert.Equal(PressureChangeRate.FromPascalsPerSecond(10), pressureChangeRate); + } } } diff --git a/UnitsNet/CustomCode/Quantities/ElectricCurrent.extra.cs b/UnitsNet/CustomCode/Quantities/ElectricCurrent.extra.cs index 944900c4e5..8928254f82 100644 --- a/UnitsNet/CustomCode/Quantities/ElectricCurrent.extra.cs +++ b/UnitsNet/CustomCode/Quantities/ElectricCurrent.extra.cs @@ -1,6 +1,8 @@ // Licensed under MIT No Attribution, see LICENSE file at the root. // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. +using System; + namespace UnitsNet { public partial struct ElectricCurrent @@ -24,5 +26,17 @@ public partial struct ElectricCurrent { return ElectricCharge.FromAmpereHours(current.Amperes * time.Hours); } + + /// Get from divided by . + public static ElectricCurrentGradient operator /(ElectricCurrent current, Duration duration) + { + return ElectricCurrentGradient.FromAmperesPerSecond(current.Amperes / duration.Seconds); + } + + /// Get from divided by . + public static ElectricCurrentGradient operator /(ElectricCurrent current, TimeSpan timeSpan) + { + return ElectricCurrentGradient.FromAmperesPerSecond(current.Amperes / timeSpan.TotalSeconds); + } } } diff --git a/UnitsNet/CustomCode/Quantities/ElectricCurrentGradient.extra.cs b/UnitsNet/CustomCode/Quantities/ElectricCurrentGradient.extra.cs new file mode 100644 index 0000000000..11800f51f6 --- /dev/null +++ b/UnitsNet/CustomCode/Quantities/ElectricCurrentGradient.extra.cs @@ -0,0 +1,22 @@ +// Licensed under MIT No Attribution, see LICENSE file at the root. +// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. + +using System; + +namespace UnitsNet +{ + public partial struct ElectricCurrentGradient + { + /// Get from times . + public static ElectricCurrent operator *(ElectricCurrentGradient currentGradient, Duration duration) + { + return ElectricCurrent.FromAmperes(currentGradient.AmperesPerSecond * duration.Seconds); + } + + /// Get from times . + public static ElectricCurrent operator *(ElectricCurrentGradient currentGradient, TimeSpan timeSpan) + { + return ElectricCurrent.FromAmperes(currentGradient.AmperesPerSecond * timeSpan.TotalSeconds); + } + } +} diff --git a/UnitsNet/CustomCode/Quantities/Pressure.extra.cs b/UnitsNet/CustomCode/Quantities/Pressure.extra.cs index 9328b9541f..259771f8dc 100644 --- a/UnitsNet/CustomCode/Quantities/Pressure.extra.cs +++ b/UnitsNet/CustomCode/Quantities/Pressure.extra.cs @@ -1,6 +1,8 @@ // Licensed under MIT No Attribution, see LICENSE file at the root. // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. +using System; + namespace UnitsNet { public partial struct Pressure @@ -40,5 +42,17 @@ public partial struct Pressure { return new Force(pressure.Pascals / reciprocalArea.InverseSquareMeters, UnitsNet.Units.ForceUnit.Newton); } + + /// Get from divided by + public static PressureChangeRate operator /(Pressure pressure, TimeSpan timeSpan) + { + return new PressureChangeRate(pressure.Pascals / timeSpan.TotalSeconds , UnitsNet.Units.PressureChangeRateUnit.PascalPerSecond); + } + + /// Get from divided by + public static PressureChangeRate operator /(Pressure pressure, Duration duration) + { + return new PressureChangeRate(pressure.Pascals / duration.Seconds, UnitsNet.Units.PressureChangeRateUnit.PascalPerSecond); + } } } diff --git a/UnitsNet/CustomCode/Quantities/PressureChangeRate.extra.cs b/UnitsNet/CustomCode/Quantities/PressureChangeRate.extra.cs new file mode 100644 index 0000000000..1d2359459e --- /dev/null +++ b/UnitsNet/CustomCode/Quantities/PressureChangeRate.extra.cs @@ -0,0 +1,22 @@ +// Licensed under MIT No Attribution, see LICENSE file at the root. +// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. + +using System; + +namespace UnitsNet +{ + public partial struct PressureChangeRate + { + /// Get from times + public static Pressure operator *(PressureChangeRate pressureChangeRate, TimeSpan timeSpan) + { + return new Pressure(pressureChangeRate.PascalsPerSecond * timeSpan.TotalSeconds , UnitsNet.Units.PressureUnit.Pascal); + } + + /// Get from times + public static Pressure operator *(PressureChangeRate pressureChangeRate, Duration duration) + { + return new Pressure(pressureChangeRate.PascalsPerSecond * duration.Seconds, UnitsNet.Units.PressureUnit.Pascal); + } + } +} From 7d511af58a1641b7395ba5d3e79ff829d3f6b1a1 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Tue, 11 Jul 2023 03:21:09 +0200 Subject: [PATCH 4/4] Regen code --- UnitsNet/GeneratedCode/Quantities/Molarity.g.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs index 0818f01a01..4814b4fdac 100644 --- a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs @@ -33,7 +33,7 @@ namespace UnitsNet { /// /// - /// Molar concentration, also called molarity, amount concentration or substance concentration, is a measure of the concentration of a solute in a solution, or of any chemical species, in terms of amount of substance in a given volume. + /// Molar concentration, also called molarity, amount concentration or substance concentration, is a measure of the concentration of a solute in a solution, or of any chemical species, in terms of amount of substance in a given volume. /// /// /// https://en.wikipedia.org/wiki/Molar_concentration