From 0f39a47e9f771ec6aaabf1c6a4052bc17394405a Mon Sep 17 00:00:00 2001 From: N-tiz Date: Tue, 27 Apr 2021 11:36:14 +0200 Subject: [PATCH] =?UTF-8?q?Adding=20new=20ratio=20unit:=20Strain=20(=CE=B5?= =?UTF-8?q?)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Common/UnitDefinitions/Ratio.json | 18 ++++++ .../NumberToRatioExtensionsTest.g.cs | 8 +++ .../NumberToRatioExtensions.g.cs | 8 +++ UnitsNet.Tests/CustomCode/RatioTests.cs | 4 ++ .../GeneratedCode/IQuantityTests.g.cs | 2 +- .../TestsBase/RatioTestsBase.g.cs | 60 ++++++++++++++----- .../GeneratedCode/Quantities/Ratio.g.cs | 34 +++++++++++ .../GeneratedCode/UnitAbbreviationsCache.g.cs | 4 ++ .../GeneratedCode/Units/RatioUnit.g.cs | 2 + UnitsNet/GeneratedCode/Quantities/Ratio.g.cs | 34 +++++++++++ .../GeneratedCode/UnitAbbreviationsCache.g.cs | 4 ++ UnitsNet/GeneratedCode/UnitConverter.g.cs | 4 ++ UnitsNet/GeneratedCode/Units/RatioUnit.g.cs | 2 + 13 files changed, 168 insertions(+), 16 deletions(-) diff --git a/Common/UnitDefinitions/Ratio.json b/Common/UnitDefinitions/Ratio.json index 3254d3e8f8..8a37d0b32a 100644 --- a/Common/UnitDefinitions/Ratio.json +++ b/Common/UnitDefinitions/Ratio.json @@ -74,6 +74,24 @@ "Abbreviations": [ "ppt" ] } ] + }, + { + "SingularName": "Strain", + "PluralName": "Strains", + "FromUnitToBaseFunc": "x", + "FromBaseToUnitFunc": "x", + "Prefixes": [ "Micro" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "ε" ] + }, + { + "Culture": "fr-FR", + "Abbreviations": [ "def" ] + } + ] } + ] } diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs index 46075ada6c..b696692c37 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs @@ -28,6 +28,10 @@ public class NumberToRatioExtensionsTests public void NumberToDecimalFractionsTest() => Assert.Equal(Ratio.FromDecimalFractions(2), 2.DecimalFractions()); + [Fact] + public void NumberToMicrostrainsTest() => + Assert.Equal(Ratio.FromMicrostrains(2), 2.Microstrains()); + [Fact] public void NumberToPartsPerBillionTest() => Assert.Equal(Ratio.FromPartsPerBillion(2), 2.PartsPerBillion()); @@ -48,5 +52,9 @@ public void NumberToPartsPerTrillionTest() => public void NumberToPercentTest() => Assert.Equal(Ratio.FromPercent(2), 2.Percent()); + [Fact] + public void NumberToStrainsTest() => + Assert.Equal(Ratio.FromStrains(2), 2.Strains()); + } } diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs index c1467d6d2d..b19fda91f4 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs @@ -32,6 +32,10 @@ public static class NumberToRatioExtensions public static Ratio DecimalFractions(this T value) => Ratio.FromDecimalFractions(Convert.ToDouble(value)); + /// + public static Ratio Microstrains(this T value) => + Ratio.FromMicrostrains(Convert.ToDouble(value)); + /// public static Ratio PartsPerBillion(this T value) => Ratio.FromPartsPerBillion(Convert.ToDouble(value)); @@ -52,5 +56,9 @@ public static Ratio PartsPerTrillion(this T value) => public static Ratio Percent(this T value) => Ratio.FromPercent(Convert.ToDouble(value)); + /// + public static Ratio Strains(this T value) => + Ratio.FromStrains(Convert.ToDouble(value)); + } } diff --git a/UnitsNet.Tests/CustomCode/RatioTests.cs b/UnitsNet.Tests/CustomCode/RatioTests.cs index d48694a80c..27b17dcac5 100644 --- a/UnitsNet.Tests/CustomCode/RatioTests.cs +++ b/UnitsNet.Tests/CustomCode/RatioTests.cs @@ -17,5 +17,9 @@ public class RatioTests : RatioTestsBase protected override double PartsPerTrillionInOneDecimalFraction => 1e12; protected override double PercentInOneDecimalFraction => 100; + + protected override double MicrostrainsInOneDecimalFraction => 1e6; + + protected override double StrainsInOneDecimalFraction => 1; } } diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs index 8d721c0ad7..73a4216325 100644 --- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs +++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs @@ -109,7 +109,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity) Assertion(3, PowerRatioUnit.DecibelWatt, Quantity.From(3, PowerRatioUnit.DecibelWatt)); Assertion(3, PressureUnit.Torr, Quantity.From(3, PressureUnit.Torr)); Assertion(3, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, Quantity.From(3, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond)); - Assertion(3, RatioUnit.Percent, Quantity.From(3, RatioUnit.Percent)); + Assertion(3, RatioUnit.Strain, Quantity.From(3, RatioUnit.Strain)); Assertion(3, RatioChangeRateUnit.PercentPerSecond, Quantity.From(3, RatioChangeRateUnit.PercentPerSecond)); Assertion(3, ReactiveEnergyUnit.VoltampereReactiveHour, Quantity.From(3, ReactiveEnergyUnit.VoltampereReactiveHour)); Assertion(3, ReactivePowerUnit.VoltampereReactive, Quantity.From(3, ReactivePowerUnit.VoltampereReactive)); diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RatioTestsBase.g.cs index e8442f994f..11e654c675 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/RatioTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RatioTestsBase.g.cs @@ -38,19 +38,23 @@ namespace UnitsNet.Tests public abstract partial class RatioTestsBase : QuantityTestsBase { protected abstract double DecimalFractionsInOneDecimalFraction { get; } + protected abstract double MicrostrainsInOneDecimalFraction { get; } protected abstract double PartsPerBillionInOneDecimalFraction { get; } protected abstract double PartsPerMillionInOneDecimalFraction { get; } protected abstract double PartsPerThousandInOneDecimalFraction { get; } protected abstract double PartsPerTrillionInOneDecimalFraction { get; } protected abstract double PercentInOneDecimalFraction { get; } + protected abstract double StrainsInOneDecimalFraction { get; } // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double DecimalFractionsTolerance { get { return 1e-5; } } + protected virtual double MicrostrainsTolerance { get { return 1e-5; } } protected virtual double PartsPerBillionTolerance { get { return 1e-5; } } protected virtual double PartsPerMillionTolerance { get { return 1e-5; } } protected virtual double PartsPerThousandTolerance { get { return 1e-5; } } protected virtual double PartsPerTrillionTolerance { get { return 1e-5; } } protected virtual double PercentTolerance { get { return 1e-5; } } + protected virtual double StrainsTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global [Fact] @@ -126,11 +130,13 @@ public void DecimalFractionToRatioUnits() { Ratio decimalfraction = Ratio.FromDecimalFractions(1); AssertEx.EqualTolerance(DecimalFractionsInOneDecimalFraction, decimalfraction.DecimalFractions, DecimalFractionsTolerance); + AssertEx.EqualTolerance(MicrostrainsInOneDecimalFraction, decimalfraction.Microstrains, MicrostrainsTolerance); AssertEx.EqualTolerance(PartsPerBillionInOneDecimalFraction, decimalfraction.PartsPerBillion, PartsPerBillionTolerance); AssertEx.EqualTolerance(PartsPerMillionInOneDecimalFraction, decimalfraction.PartsPerMillion, PartsPerMillionTolerance); AssertEx.EqualTolerance(PartsPerThousandInOneDecimalFraction, decimalfraction.PartsPerThousand, PartsPerThousandTolerance); AssertEx.EqualTolerance(PartsPerTrillionInOneDecimalFraction, decimalfraction.PartsPerTrillion, PartsPerTrillionTolerance); AssertEx.EqualTolerance(PercentInOneDecimalFraction, decimalfraction.Percent, PercentTolerance); + AssertEx.EqualTolerance(StrainsInOneDecimalFraction, decimalfraction.Strains, StrainsTolerance); } [Fact] @@ -140,25 +146,33 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() AssertEx.EqualTolerance(1, quantity00.DecimalFractions, DecimalFractionsTolerance); Assert.Equal(RatioUnit.DecimalFraction, quantity00.Unit); - var quantity01 = Ratio.From(1, RatioUnit.PartPerBillion); - AssertEx.EqualTolerance(1, quantity01.PartsPerBillion, PartsPerBillionTolerance); - Assert.Equal(RatioUnit.PartPerBillion, quantity01.Unit); + var quantity01 = Ratio.From(1, RatioUnit.Microstrain); + AssertEx.EqualTolerance(1, quantity01.Microstrains, MicrostrainsTolerance); + Assert.Equal(RatioUnit.Microstrain, quantity01.Unit); - var quantity02 = Ratio.From(1, RatioUnit.PartPerMillion); - AssertEx.EqualTolerance(1, quantity02.PartsPerMillion, PartsPerMillionTolerance); - Assert.Equal(RatioUnit.PartPerMillion, quantity02.Unit); + var quantity02 = Ratio.From(1, RatioUnit.PartPerBillion); + AssertEx.EqualTolerance(1, quantity02.PartsPerBillion, PartsPerBillionTolerance); + Assert.Equal(RatioUnit.PartPerBillion, quantity02.Unit); - var quantity03 = Ratio.From(1, RatioUnit.PartPerThousand); - AssertEx.EqualTolerance(1, quantity03.PartsPerThousand, PartsPerThousandTolerance); - Assert.Equal(RatioUnit.PartPerThousand, quantity03.Unit); + var quantity03 = Ratio.From(1, RatioUnit.PartPerMillion); + AssertEx.EqualTolerance(1, quantity03.PartsPerMillion, PartsPerMillionTolerance); + Assert.Equal(RatioUnit.PartPerMillion, quantity03.Unit); - var quantity04 = Ratio.From(1, RatioUnit.PartPerTrillion); - AssertEx.EqualTolerance(1, quantity04.PartsPerTrillion, PartsPerTrillionTolerance); - Assert.Equal(RatioUnit.PartPerTrillion, quantity04.Unit); + var quantity04 = Ratio.From(1, RatioUnit.PartPerThousand); + AssertEx.EqualTolerance(1, quantity04.PartsPerThousand, PartsPerThousandTolerance); + Assert.Equal(RatioUnit.PartPerThousand, quantity04.Unit); - var quantity05 = Ratio.From(1, RatioUnit.Percent); - AssertEx.EqualTolerance(1, quantity05.Percent, PercentTolerance); - Assert.Equal(RatioUnit.Percent, quantity05.Unit); + var quantity05 = Ratio.From(1, RatioUnit.PartPerTrillion); + AssertEx.EqualTolerance(1, quantity05.PartsPerTrillion, PartsPerTrillionTolerance); + Assert.Equal(RatioUnit.PartPerTrillion, quantity05.Unit); + + var quantity06 = Ratio.From(1, RatioUnit.Percent); + AssertEx.EqualTolerance(1, quantity06.Percent, PercentTolerance); + Assert.Equal(RatioUnit.Percent, quantity06.Unit); + + var quantity07 = Ratio.From(1, RatioUnit.Strain); + AssertEx.EqualTolerance(1, quantity07.Strains, StrainsTolerance); + Assert.Equal(RatioUnit.Strain, quantity07.Unit); } @@ -180,11 +194,13 @@ public void As() { var decimalfraction = Ratio.FromDecimalFractions(1); AssertEx.EqualTolerance(DecimalFractionsInOneDecimalFraction, decimalfraction.As(RatioUnit.DecimalFraction), DecimalFractionsTolerance); + AssertEx.EqualTolerance(MicrostrainsInOneDecimalFraction, decimalfraction.As(RatioUnit.Microstrain), MicrostrainsTolerance); AssertEx.EqualTolerance(PartsPerBillionInOneDecimalFraction, decimalfraction.As(RatioUnit.PartPerBillion), PartsPerBillionTolerance); AssertEx.EqualTolerance(PartsPerMillionInOneDecimalFraction, decimalfraction.As(RatioUnit.PartPerMillion), PartsPerMillionTolerance); AssertEx.EqualTolerance(PartsPerThousandInOneDecimalFraction, decimalfraction.As(RatioUnit.PartPerThousand), PartsPerThousandTolerance); AssertEx.EqualTolerance(PartsPerTrillionInOneDecimalFraction, decimalfraction.As(RatioUnit.PartPerTrillion), PartsPerTrillionTolerance); AssertEx.EqualTolerance(PercentInOneDecimalFraction, decimalfraction.As(RatioUnit.Percent), PercentTolerance); + AssertEx.EqualTolerance(StrainsInOneDecimalFraction, decimalfraction.As(RatioUnit.Strain), StrainsTolerance); } [Fact] @@ -213,6 +229,10 @@ public void ToUnit() AssertEx.EqualTolerance(DecimalFractionsInOneDecimalFraction, (double)decimalfractionQuantity.Value, DecimalFractionsTolerance); Assert.Equal(RatioUnit.DecimalFraction, decimalfractionQuantity.Unit); + var microstrainQuantity = decimalfraction.ToUnit(RatioUnit.Microstrain); + AssertEx.EqualTolerance(MicrostrainsInOneDecimalFraction, (double)microstrainQuantity.Value, MicrostrainsTolerance); + Assert.Equal(RatioUnit.Microstrain, microstrainQuantity.Unit); + var partperbillionQuantity = decimalfraction.ToUnit(RatioUnit.PartPerBillion); AssertEx.EqualTolerance(PartsPerBillionInOneDecimalFraction, (double)partperbillionQuantity.Value, PartsPerBillionTolerance); Assert.Equal(RatioUnit.PartPerBillion, partperbillionQuantity.Unit); @@ -232,6 +252,10 @@ public void ToUnit() var percentQuantity = decimalfraction.ToUnit(RatioUnit.Percent); AssertEx.EqualTolerance(PercentInOneDecimalFraction, (double)percentQuantity.Value, PercentTolerance); Assert.Equal(RatioUnit.Percent, percentQuantity.Unit); + + var strainQuantity = decimalfraction.ToUnit(RatioUnit.Strain); + AssertEx.EqualTolerance(StrainsInOneDecimalFraction, (double)strainQuantity.Value, StrainsTolerance); + Assert.Equal(RatioUnit.Strain, strainQuantity.Unit); } [Fact] @@ -246,11 +270,13 @@ public void ConversionRoundTrip() { Ratio decimalfraction = Ratio.FromDecimalFractions(1); AssertEx.EqualTolerance(1, Ratio.FromDecimalFractions(decimalfraction.DecimalFractions).DecimalFractions, DecimalFractionsTolerance); + AssertEx.EqualTolerance(1, Ratio.FromMicrostrains(decimalfraction.Microstrains).DecimalFractions, MicrostrainsTolerance); AssertEx.EqualTolerance(1, Ratio.FromPartsPerBillion(decimalfraction.PartsPerBillion).DecimalFractions, PartsPerBillionTolerance); AssertEx.EqualTolerance(1, Ratio.FromPartsPerMillion(decimalfraction.PartsPerMillion).DecimalFractions, PartsPerMillionTolerance); AssertEx.EqualTolerance(1, Ratio.FromPartsPerThousand(decimalfraction.PartsPerThousand).DecimalFractions, PartsPerThousandTolerance); AssertEx.EqualTolerance(1, Ratio.FromPartsPerTrillion(decimalfraction.PartsPerTrillion).DecimalFractions, PartsPerTrillionTolerance); AssertEx.EqualTolerance(1, Ratio.FromPercent(decimalfraction.Percent).DecimalFractions, PercentTolerance); + AssertEx.EqualTolerance(1, Ratio.FromStrains(decimalfraction.Strains).DecimalFractions, StrainsTolerance); } [Fact] @@ -408,11 +434,13 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo("en-US"); try { Assert.Equal("1", new Ratio(1, RatioUnit.DecimalFraction).ToString()); + Assert.Equal("1 µε", new Ratio(1, RatioUnit.Microstrain).ToString()); Assert.Equal("1 ppb", new Ratio(1, RatioUnit.PartPerBillion).ToString()); Assert.Equal("1 ppm", new Ratio(1, RatioUnit.PartPerMillion).ToString()); Assert.Equal("1 ‰", new Ratio(1, RatioUnit.PartPerThousand).ToString()); Assert.Equal("1 ppt", new Ratio(1, RatioUnit.PartPerTrillion).ToString()); Assert.Equal("1 %", new Ratio(1, RatioUnit.Percent).ToString()); + Assert.Equal("1 ε", new Ratio(1, RatioUnit.Strain).ToString()); } finally { @@ -427,11 +455,13 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture var swedishCulture = CultureInfo.GetCultureInfo("sv-SE"); Assert.Equal("1", new Ratio(1, RatioUnit.DecimalFraction).ToString(swedishCulture)); + Assert.Equal("1 µε", new Ratio(1, RatioUnit.Microstrain).ToString(swedishCulture)); Assert.Equal("1 ppb", new Ratio(1, RatioUnit.PartPerBillion).ToString(swedishCulture)); Assert.Equal("1 ppm", new Ratio(1, RatioUnit.PartPerMillion).ToString(swedishCulture)); Assert.Equal("1 ‰", new Ratio(1, RatioUnit.PartPerThousand).ToString(swedishCulture)); Assert.Equal("1 ppt", new Ratio(1, RatioUnit.PartPerTrillion).ToString(swedishCulture)); Assert.Equal("1 %", new Ratio(1, RatioUnit.Percent).ToString(swedishCulture)); + Assert.Equal("1 ε", new Ratio(1, RatioUnit.Strain).ToString(swedishCulture)); } [Fact] diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.g.cs index 5579f00abe..7d6eca876b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.g.cs @@ -160,6 +160,11 @@ private Ratio(double value, RatioUnit unit) /// public double DecimalFractions => As(RatioUnit.DecimalFraction); + /// + /// Get Ratio in Microstrains. + /// + public double Microstrains => As(RatioUnit.Microstrain); + /// /// Get Ratio in PartsPerBillion. /// @@ -185,6 +190,11 @@ private Ratio(double value, RatioUnit unit) /// public double Percent => As(RatioUnit.Percent); + /// + /// Get Ratio in Strains. + /// + public double Strains => As(RatioUnit.Strain); + #endregion #region Static Methods @@ -226,6 +236,16 @@ public static Ratio FromDecimalFractions(double decimalfractions) return new Ratio(value, RatioUnit.DecimalFraction); } /// + /// Get Ratio from Microstrains. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Ratio FromMicrostrains(double microstrains) + { + double value = (double) microstrains; + return new Ratio(value, RatioUnit.Microstrain); + } + /// /// Get Ratio from PartsPerBillion. /// /// If value is NaN or Infinity. @@ -275,6 +295,16 @@ public static Ratio FromPercent(double percent) double value = (double) percent; return new Ratio(value, RatioUnit.Percent); } + /// + /// Get Ratio from Strains. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Ratio FromStrains(double strains) + { + double value = (double) strains; + return new Ratio(value, RatioUnit.Strain); + } /// /// Dynamically convert from value and unit enum to . @@ -567,11 +597,13 @@ private double AsBaseUnit() switch(Unit) { case RatioUnit.DecimalFraction: return _value; + case RatioUnit.Microstrain: return (_value) * 1e-6d; case RatioUnit.PartPerBillion: return _value/1e9; case RatioUnit.PartPerMillion: return _value/1e6; case RatioUnit.PartPerThousand: return _value/1e3; case RatioUnit.PartPerTrillion: return _value/1e12; case RatioUnit.Percent: return _value/1e2; + case RatioUnit.Strain: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -587,11 +619,13 @@ private double AsBaseNumericType(RatioUnit unit) switch(unit) { case RatioUnit.DecimalFraction: return baseUnitValue; + case RatioUnit.Microstrain: return (baseUnitValue) / 1e-6d; case RatioUnit.PartPerBillion: return baseUnitValue*1e9; case RatioUnit.PartPerMillion: return baseUnitValue*1e6; case RatioUnit.PartPerThousand: return baseUnitValue*1e3; case RatioUnit.PartPerTrillion: return baseUnitValue*1e12; case RatioUnit.Percent: return baseUnitValue*1e2; + case RatioUnit.Strain: return baseUnitValue; default: throw new NotImplementedException($"Can not convert {Unit} to {unit}."); } diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs index 454c8dd8f5..a032a201d5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -1183,11 +1183,15 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, new string[]{"psi/s", "lb/in²/s"}), ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, new string[]{"psi/с", "lb/in²/с"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.DecimalFraction, new string[]{""}), + ("en-US", typeof(RatioUnit), (int)RatioUnit.Microstrain, new string[]{"µε"}), + ("fr-FR", typeof(RatioUnit), (int)RatioUnit.Microstrain, new string[]{"µdef"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.PartPerBillion, new string[]{"ppb"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.PartPerMillion, new string[]{"ppm"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.PartPerThousand, new string[]{"‰"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.PartPerTrillion, new string[]{"ppt"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.Percent, new string[]{"%"}), + ("en-US", typeof(RatioUnit), (int)RatioUnit.Strain, new string[]{"ε"}), + ("fr-FR", typeof(RatioUnit), (int)RatioUnit.Strain, new string[]{"def"}), ("en-US", typeof(RatioChangeRateUnit), (int)RatioChangeRateUnit.DecimalFractionPerSecond, new string[]{"/s"}), ("en-US", typeof(RatioChangeRateUnit), (int)RatioChangeRateUnit.PercentPerSecond, new string[]{"%/s"}), ("en-US", typeof(ReactiveEnergyUnit), (int)ReactiveEnergyUnit.KilovoltampereReactiveHour, new string[]{"kvarh"}), diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/RatioUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/RatioUnit.g.cs index 8979dfc368..57cdc37bb8 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/RatioUnit.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/RatioUnit.g.cs @@ -27,11 +27,13 @@ public enum RatioUnit { Undefined = 0, DecimalFraction, + Microstrain, PartPerBillion, PartPerMillion, PartPerThousand, PartPerTrillion, Percent, + Strain, } #pragma warning restore 1591 diff --git a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs index 5c72a590a9..138b413cdd 100644 --- a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs @@ -53,11 +53,13 @@ static Ratio() Info = new QuantityInfo("Ratio", new UnitInfo[] { new UnitInfo(RatioUnit.DecimalFraction, BaseUnits.Undefined), + new UnitInfo(RatioUnit.Microstrain, BaseUnits.Undefined), new UnitInfo(RatioUnit.PartPerBillion, BaseUnits.Undefined), new UnitInfo(RatioUnit.PartPerMillion, BaseUnits.Undefined), new UnitInfo(RatioUnit.PartPerThousand, BaseUnits.Undefined), new UnitInfo(RatioUnit.PartPerTrillion, BaseUnits.Undefined), new UnitInfo(RatioUnit.Percent, BaseUnits.Undefined), + new UnitInfo(RatioUnit.Strain, BaseUnits.Undefined), }, BaseUnit, Zero, BaseDimensions, QuantityType.Ratio); } @@ -178,6 +180,11 @@ public Ratio(double value, UnitSystem unitSystem) /// public double DecimalFractions => As(RatioUnit.DecimalFraction); + /// + /// Get Ratio in Microstrains. + /// + public double Microstrains => As(RatioUnit.Microstrain); + /// /// Get Ratio in PartsPerBillion. /// @@ -203,6 +210,11 @@ public Ratio(double value, UnitSystem unitSystem) /// public double Percent => As(RatioUnit.Percent); + /// + /// Get Ratio in Strains. + /// + public double Strains => As(RatioUnit.Strain); + #endregion #region Static Methods @@ -242,6 +254,15 @@ public static Ratio FromDecimalFractions(QuantityValue decimalfractions) return new Ratio(value, RatioUnit.DecimalFraction); } /// + /// Get Ratio from Microstrains. + /// + /// If value is NaN or Infinity. + public static Ratio FromMicrostrains(QuantityValue microstrains) + { + double value = (double) microstrains; + return new Ratio(value, RatioUnit.Microstrain); + } + /// /// Get Ratio from PartsPerBillion. /// /// If value is NaN or Infinity. @@ -286,6 +307,15 @@ public static Ratio FromPercent(QuantityValue percent) double value = (double) percent; return new Ratio(value, RatioUnit.Percent); } + /// + /// Get Ratio from Strains. + /// + /// If value is NaN or Infinity. + public static Ratio FromStrains(QuantityValue strains) + { + double value = (double) strains; + return new Ratio(value, RatioUnit.Strain); + } /// /// Dynamically convert from value and unit enum to . @@ -716,11 +746,13 @@ private double GetValueInBaseUnit() switch(Unit) { case RatioUnit.DecimalFraction: return _value; + case RatioUnit.Microstrain: return (_value) * 1e-6d; case RatioUnit.PartPerBillion: return _value/1e9; case RatioUnit.PartPerMillion: return _value/1e6; case RatioUnit.PartPerThousand: return _value/1e3; case RatioUnit.PartPerTrillion: return _value/1e12; case RatioUnit.Percent: return _value/1e2; + case RatioUnit.Strain: return _value; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -747,11 +779,13 @@ private double GetValueAs(RatioUnit unit) switch(unit) { case RatioUnit.DecimalFraction: return baseUnitValue; + case RatioUnit.Microstrain: return (baseUnitValue) / 1e-6d; case RatioUnit.PartPerBillion: return baseUnitValue*1e9; case RatioUnit.PartPerMillion: return baseUnitValue*1e6; case RatioUnit.PartPerThousand: return baseUnitValue*1e3; case RatioUnit.PartPerTrillion: return baseUnitValue*1e12; case RatioUnit.Percent: return baseUnitValue*1e2; + case RatioUnit.Strain: return baseUnitValue; default: throw new NotImplementedException($"Can not convert {Unit} to {unit}."); } diff --git a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs index 5eb54aa602..7e68425e8f 100644 --- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -1183,11 +1183,15 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, new string[]{"psi/s", "lb/in²/s"}), ("ru-RU", typeof(PressureChangeRateUnit), (int)PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, new string[]{"psi/с", "lb/in²/с"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.DecimalFraction, new string[]{""}), + ("en-US", typeof(RatioUnit), (int)RatioUnit.Microstrain, new string[]{"µε"}), + ("fr-FR", typeof(RatioUnit), (int)RatioUnit.Microstrain, new string[]{"µdef"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.PartPerBillion, new string[]{"ppb"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.PartPerMillion, new string[]{"ppm"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.PartPerThousand, new string[]{"‰"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.PartPerTrillion, new string[]{"ppt"}), ("en-US", typeof(RatioUnit), (int)RatioUnit.Percent, new string[]{"%"}), + ("en-US", typeof(RatioUnit), (int)RatioUnit.Strain, new string[]{"ε"}), + ("fr-FR", typeof(RatioUnit), (int)RatioUnit.Strain, new string[]{"def"}), ("en-US", typeof(RatioChangeRateUnit), (int)RatioChangeRateUnit.DecimalFractionPerSecond, new string[]{"/s"}), ("en-US", typeof(RatioChangeRateUnit), (int)RatioChangeRateUnit.PercentPerSecond, new string[]{"%/s"}), ("en-US", typeof(ReactiveEnergyUnit), (int)ReactiveEnergyUnit.KilovoltampereReactiveHour, new string[]{"kvarh"}), diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs index 9c44830680..ea8af92258 100644 --- a/UnitsNet/GeneratedCode/UnitConverter.g.cs +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -1756,6 +1756,8 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(PressureChangeRate.BaseUnit, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, q => q.ToUnit(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond)); unitConverter.SetConversionFunction(PressureChangeRateUnit.PoundForcePerSquareInchPerSecond, PressureChangeRate.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Ratio.BaseUnit, Ratio.BaseUnit, q => q); + unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.Microstrain, q => q.ToUnit(RatioUnit.Microstrain)); + unitConverter.SetConversionFunction(RatioUnit.Microstrain, Ratio.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerBillion, q => q.ToUnit(RatioUnit.PartPerBillion)); unitConverter.SetConversionFunction(RatioUnit.PartPerBillion, Ratio.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.PartPerMillion, q => q.ToUnit(RatioUnit.PartPerMillion)); @@ -1766,6 +1768,8 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(RatioUnit.PartPerTrillion, Ratio.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.Percent, q => q.ToUnit(RatioUnit.Percent)); unitConverter.SetConversionFunction(RatioUnit.Percent, Ratio.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(Ratio.BaseUnit, RatioUnit.Strain, q => q.ToUnit(RatioUnit.Strain)); + unitConverter.SetConversionFunction(RatioUnit.Strain, Ratio.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(RatioChangeRate.BaseUnit, RatioChangeRate.BaseUnit, q => q); unitConverter.SetConversionFunction(RatioChangeRate.BaseUnit, RatioChangeRateUnit.PercentPerSecond, q => q.ToUnit(RatioChangeRateUnit.PercentPerSecond)); unitConverter.SetConversionFunction(RatioChangeRateUnit.PercentPerSecond, RatioChangeRate.BaseUnit, q => q.ToBaseUnit()); diff --git a/UnitsNet/GeneratedCode/Units/RatioUnit.g.cs b/UnitsNet/GeneratedCode/Units/RatioUnit.g.cs index 8979dfc368..57cdc37bb8 100644 --- a/UnitsNet/GeneratedCode/Units/RatioUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/RatioUnit.g.cs @@ -27,11 +27,13 @@ public enum RatioUnit { Undefined = 0, DecimalFraction, + Microstrain, PartPerBillion, PartPerMillion, PartPerThousand, PartPerTrillion, Percent, + Strain, } #pragma warning restore 1591