From 12d644b84bef56ea11124ff8385b0a15aeb790cf Mon Sep 17 00:00:00 2001 From: Jan Paolo Go Date: Fri, 12 May 2017 15:44:09 -0500 Subject: [PATCH 1/2] Fix UnitParser.ParseUnit for multiple-worded units https://github.com/anjdreas/UnitsNet/issues/253 1. Changed regex to accept multiple worded non-numeric units 2. Used string.Replace to remove all known separators. This way, we don't need to include it in our regex. Also the separator "," is already defined in NumberFormatInfo numFormat 3. Removed code block for group since it will not go into this anymore. 4. Added Unit test for Parsing Mass "Short Tons" and "Long Tons" --- UnitsNet.Tests/CustomCode/ParseTests.cs | 13 ++++++++++++- UnitsNet/CustomCode/UnitParser.cs | 19 ++++++------------- 2 files changed, 18 insertions(+), 14 deletions(-) diff --git a/UnitsNet.Tests/CustomCode/ParseTests.cs b/UnitsNet.Tests/CustomCode/ParseTests.cs index 227e2d4c67..de99e1502c 100644 --- a/UnitsNet.Tests/CustomCode/ParseTests.cs +++ b/UnitsNet.Tests/CustomCode/ParseTests.cs @@ -42,7 +42,7 @@ public class ParseTests [TestCase("500,005 m", Result = 500005)] [TestCase(null, ExpectedExceptionName = "System.ArgumentNullException")] [TestCase("1", ExpectedExceptionName = "System.ArgumentException")] - [TestCase("km", ExpectedExceptionName = "UnitsNet.UnitsNetException")] + [TestCase("km", ExpectedExceptionName = "System.ArgumentException")] [TestCase("1 kg", ExpectedExceptionName = "UnitsNet.UnitsNetException")] public double ParseLengthToMetersUsEnglish(string s) { @@ -116,5 +116,16 @@ public bool TryParseLengthUnitUsEnglish(string s) Length result; return Length.TryParse(s, usEnglish, out result); } + + [TestCase("333 short tn", Result = 333)] + public double ParseMassShortTon(string s) + { + return Mass.Parse(s).ShortTons; + } + [TestCase("333 long tn", Result = 333)] + public double ParseMassLongTon(string s) + { + return Mass.Parse(s).LongTons; + } } } \ No newline at end of file diff --git a/UnitsNet/CustomCode/UnitParser.cs b/UnitsNet/CustomCode/UnitParser.cs index d751149e51..79521a9759 100644 --- a/UnitsNet/CustomCode/UnitParser.cs +++ b/UnitsNet/CustomCode/UnitParser.cs @@ -54,13 +54,14 @@ internal static TUnit ParseUnit([NotNull] string str, const string exponentialRegex = @"(?:[eE][-+]?\d+)?)"; - string regexString = string.Format(@"(?:\s*(?[-+]?{0}{1}{2}{3})?{4}{5}", + string regexString = string.Format(@"(?:\s*(?[-+]?{0}{1}{2}{3})?", numRegex, // capture base (integral) Quantity value exponentialRegex, // capture exponential (if any), end of Quantity capturing @"\s?", // ignore whitespace (allows both "1kg", "1 kg") - @"(?[^\s\d,]+)", // capture Unit (non-whitespace) input - @"(and)?,?", // allow "and" & "," separators between quantities - @"(?[a-z]*)?"); // capture invalid input + @"(?[^\d]+)"); // capture Unit (non-numeric) + + //remove separators + str = str.Replace("and", ""); List quantities = ParseWithRegex(regexString, str, parseUnit, formatProvider); if (quantities.Count == 0) @@ -89,15 +90,7 @@ private static List ParseWithRegex(string regexString, string str, string valueString = groups["value"].Value; string unitString = groups["unit"].Value; - if (groups["invalid"].Value != "") - { - var newEx = new UnitsNetException("Invalid string detected: " + groups["invalid"].Value); - newEx.Data["input"] = str; - newEx.Data["matched value"] = valueString; - newEx.Data["matched unit"] = unitString; - newEx.Data["formatprovider"] = formatProvider?.ToString(); - throw newEx; - } + if ((valueString == "") && (unitString == "")) continue; try From 937550ab35e0da77321878b7d6616a76fd2d683b Mon Sep 17 00:00:00 2001 From: Jan Paolo Go Date: Fri, 12 May 2017 16:23:52 -0500 Subject: [PATCH 2/2] Added Speed Units Added: in/s yd/s yd/min --- UnitsNet.Tests/CustomCode/SpeedTests.cs | 6 + .../GeneratedCode/SpeedTestsBase.g.cs | 18 +++ UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs | 3 + .../Number/NumberToSpeedExtensions.g.cs | 102 ++++++++++++++++ UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs | 111 ++++++++++++++++++ .../GeneratedCode/UnitSystem.Default.g.cs | 15 +++ UnitsNet/UnitDefinitions/Speed.json | 36 ++++++ 7 files changed, 291 insertions(+) diff --git a/UnitsNet.Tests/CustomCode/SpeedTests.cs b/UnitsNet.Tests/CustomCode/SpeedTests.cs index 5013470d66..b8379c95aa 100644 --- a/UnitsNet.Tests/CustomCode/SpeedTests.cs +++ b/UnitsNet.Tests/CustomCode/SpeedTests.cs @@ -68,6 +68,12 @@ public class SpeedTests : SpeedTestsBase protected override double MillimetersPerHourInOneMeterPerSecond => 3600000; + protected override double InchesPerSecondInOneMeterPerSecond => 39.3700787; + + protected override double YardsPerMinuteInOneMeterPerSecond => 65.6167979; + + protected override double YardsPerSecondInOneMeterPerSecond => 1.09361330; + [Test] public void DurationSpeedTimesEqualsLength() { diff --git a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs index b22e076cf8..07b8d51648 100644 --- a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs @@ -59,6 +59,7 @@ public abstract partial class SpeedTestsBase protected abstract double DecimetersPerMinutesInOneMeterPerSecond { get; } protected abstract double DecimetersPerSecondInOneMeterPerSecond { get; } protected abstract double FeetPerSecondInOneMeterPerSecond { get; } + protected abstract double InchesPerSecondInOneMeterPerSecond { get; } protected abstract double KilometersPerHourInOneMeterPerSecond { get; } protected abstract double KilometersPerMinutesInOneMeterPerSecond { get; } protected abstract double KilometersPerSecondInOneMeterPerSecond { get; } @@ -74,6 +75,8 @@ public abstract partial class SpeedTestsBase protected abstract double MillimetersPerSecondInOneMeterPerSecond { get; } protected abstract double NanometersPerMinutesInOneMeterPerSecond { get; } protected abstract double NanometersPerSecondInOneMeterPerSecond { get; } + protected abstract double YardsPerMinuteInOneMeterPerSecond { get; } + protected abstract double YardsPerSecondInOneMeterPerSecond { get; } // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double CentimetersPerHourTolerance { get { return 1e-5; } } @@ -82,6 +85,7 @@ public abstract partial class SpeedTestsBase protected virtual double DecimetersPerMinutesTolerance { get { return 1e-5; } } protected virtual double DecimetersPerSecondTolerance { get { return 1e-5; } } protected virtual double FeetPerSecondTolerance { get { return 1e-5; } } + protected virtual double InchesPerSecondTolerance { get { return 1e-5; } } protected virtual double KilometersPerHourTolerance { get { return 1e-5; } } protected virtual double KilometersPerMinutesTolerance { get { return 1e-5; } } protected virtual double KilometersPerSecondTolerance { get { return 1e-5; } } @@ -97,6 +101,8 @@ public abstract partial class SpeedTestsBase protected virtual double MillimetersPerSecondTolerance { get { return 1e-5; } } protected virtual double NanometersPerMinutesTolerance { get { return 1e-5; } } protected virtual double NanometersPerSecondTolerance { get { return 1e-5; } } + protected virtual double YardsPerMinuteTolerance { get { return 1e-5; } } + protected virtual double YardsPerSecondTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global [Test] @@ -109,6 +115,7 @@ public void MeterPerSecondToSpeedUnits() Assert.AreEqual(DecimetersPerMinutesInOneMeterPerSecond, meterpersecond.DecimetersPerMinutes, DecimetersPerMinutesTolerance); Assert.AreEqual(DecimetersPerSecondInOneMeterPerSecond, meterpersecond.DecimetersPerSecond, DecimetersPerSecondTolerance); Assert.AreEqual(FeetPerSecondInOneMeterPerSecond, meterpersecond.FeetPerSecond, FeetPerSecondTolerance); + Assert.AreEqual(InchesPerSecondInOneMeterPerSecond, meterpersecond.InchesPerSecond, InchesPerSecondTolerance); Assert.AreEqual(KilometersPerHourInOneMeterPerSecond, meterpersecond.KilometersPerHour, KilometersPerHourTolerance); Assert.AreEqual(KilometersPerMinutesInOneMeterPerSecond, meterpersecond.KilometersPerMinutes, KilometersPerMinutesTolerance); Assert.AreEqual(KilometersPerSecondInOneMeterPerSecond, meterpersecond.KilometersPerSecond, KilometersPerSecondTolerance); @@ -124,6 +131,8 @@ public void MeterPerSecondToSpeedUnits() Assert.AreEqual(MillimetersPerSecondInOneMeterPerSecond, meterpersecond.MillimetersPerSecond, MillimetersPerSecondTolerance); Assert.AreEqual(NanometersPerMinutesInOneMeterPerSecond, meterpersecond.NanometersPerMinutes, NanometersPerMinutesTolerance); Assert.AreEqual(NanometersPerSecondInOneMeterPerSecond, meterpersecond.NanometersPerSecond, NanometersPerSecondTolerance); + Assert.AreEqual(YardsPerMinuteInOneMeterPerSecond, meterpersecond.YardsPerMinute, YardsPerMinuteTolerance); + Assert.AreEqual(YardsPerSecondInOneMeterPerSecond, meterpersecond.YardsPerSecond, YardsPerSecondTolerance); } [Test] @@ -135,6 +144,7 @@ public void FromValueAndUnit() Assert.AreEqual(1, Speed.From(1, SpeedUnit.DecimeterPerMinute).DecimetersPerMinutes, DecimetersPerMinutesTolerance); Assert.AreEqual(1, Speed.From(1, SpeedUnit.DecimeterPerSecond).DecimetersPerSecond, DecimetersPerSecondTolerance); Assert.AreEqual(1, Speed.From(1, SpeedUnit.FootPerSecond).FeetPerSecond, FeetPerSecondTolerance); + Assert.AreEqual(1, Speed.From(1, SpeedUnit.InchPerSecond).InchesPerSecond, InchesPerSecondTolerance); Assert.AreEqual(1, Speed.From(1, SpeedUnit.KilometerPerHour).KilometersPerHour, KilometersPerHourTolerance); Assert.AreEqual(1, Speed.From(1, SpeedUnit.KilometerPerMinute).KilometersPerMinutes, KilometersPerMinutesTolerance); Assert.AreEqual(1, Speed.From(1, SpeedUnit.KilometerPerSecond).KilometersPerSecond, KilometersPerSecondTolerance); @@ -150,6 +160,8 @@ public void FromValueAndUnit() Assert.AreEqual(1, Speed.From(1, SpeedUnit.MillimeterPerSecond).MillimetersPerSecond, MillimetersPerSecondTolerance); Assert.AreEqual(1, Speed.From(1, SpeedUnit.NanometerPerMinute).NanometersPerMinutes, NanometersPerMinutesTolerance); Assert.AreEqual(1, Speed.From(1, SpeedUnit.NanometerPerSecond).NanometersPerSecond, NanometersPerSecondTolerance); + Assert.AreEqual(1, Speed.From(1, SpeedUnit.YardPerMinute).YardsPerMinute, YardsPerMinuteTolerance); + Assert.AreEqual(1, Speed.From(1, SpeedUnit.YardPerSecond).YardsPerSecond, YardsPerSecondTolerance); } [Test] @@ -162,6 +174,7 @@ public void As() Assert.AreEqual(DecimetersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.DecimeterPerMinute), DecimetersPerMinutesTolerance); Assert.AreEqual(DecimetersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.DecimeterPerSecond), DecimetersPerSecondTolerance); Assert.AreEqual(FeetPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.FootPerSecond), FeetPerSecondTolerance); + Assert.AreEqual(InchesPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.InchPerSecond), InchesPerSecondTolerance); Assert.AreEqual(KilometersPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.KilometerPerHour), KilometersPerHourTolerance); Assert.AreEqual(KilometersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.KilometerPerMinute), KilometersPerMinutesTolerance); Assert.AreEqual(KilometersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.KilometerPerSecond), KilometersPerSecondTolerance); @@ -177,6 +190,8 @@ public void As() Assert.AreEqual(MillimetersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MillimeterPerSecond), MillimetersPerSecondTolerance); Assert.AreEqual(NanometersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.NanometerPerMinute), NanometersPerMinutesTolerance); Assert.AreEqual(NanometersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.NanometerPerSecond), NanometersPerSecondTolerance); + Assert.AreEqual(YardsPerMinuteInOneMeterPerSecond, meterpersecond.As(SpeedUnit.YardPerMinute), YardsPerMinuteTolerance); + Assert.AreEqual(YardsPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.YardPerSecond), YardsPerSecondTolerance); } [Test] @@ -189,6 +204,7 @@ public void ConversionRoundTrip() Assert.AreEqual(1, Speed.FromDecimetersPerMinutes(meterpersecond.DecimetersPerMinutes).MetersPerSecond, DecimetersPerMinutesTolerance); Assert.AreEqual(1, Speed.FromDecimetersPerSecond(meterpersecond.DecimetersPerSecond).MetersPerSecond, DecimetersPerSecondTolerance); Assert.AreEqual(1, Speed.FromFeetPerSecond(meterpersecond.FeetPerSecond).MetersPerSecond, FeetPerSecondTolerance); + Assert.AreEqual(1, Speed.FromInchesPerSecond(meterpersecond.InchesPerSecond).MetersPerSecond, InchesPerSecondTolerance); Assert.AreEqual(1, Speed.FromKilometersPerHour(meterpersecond.KilometersPerHour).MetersPerSecond, KilometersPerHourTolerance); Assert.AreEqual(1, Speed.FromKilometersPerMinutes(meterpersecond.KilometersPerMinutes).MetersPerSecond, KilometersPerMinutesTolerance); Assert.AreEqual(1, Speed.FromKilometersPerSecond(meterpersecond.KilometersPerSecond).MetersPerSecond, KilometersPerSecondTolerance); @@ -204,6 +220,8 @@ public void ConversionRoundTrip() Assert.AreEqual(1, Speed.FromMillimetersPerSecond(meterpersecond.MillimetersPerSecond).MetersPerSecond, MillimetersPerSecondTolerance); Assert.AreEqual(1, Speed.FromNanometersPerMinutes(meterpersecond.NanometersPerMinutes).MetersPerSecond, NanometersPerMinutesTolerance); Assert.AreEqual(1, Speed.FromNanometersPerSecond(meterpersecond.NanometersPerSecond).MetersPerSecond, NanometersPerSecondTolerance); + Assert.AreEqual(1, Speed.FromYardsPerMinute(meterpersecond.YardsPerMinute).MetersPerSecond, YardsPerMinuteTolerance); + Assert.AreEqual(1, Speed.FromYardsPerSecond(meterpersecond.YardsPerSecond).MetersPerSecond, YardsPerSecondTolerance); } [Test] diff --git a/UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs b/UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs index 17ba7659dc..853a75f292 100644 --- a/UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs +++ b/UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs @@ -48,6 +48,7 @@ public enum SpeedUnit DecimeterPerMinute, DecimeterPerSecond, FootPerSecond, + InchPerSecond, KilometerPerHour, KilometerPerMinute, KilometerPerSecond, @@ -63,5 +64,7 @@ public enum SpeedUnit MillimeterPerSecond, NanometerPerMinute, NanometerPerSecond, + YardPerMinute, + YardPerSecond, } } diff --git a/UnitsNet/GeneratedCode/Extensions/Number/NumberToSpeedExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/Number/NumberToSpeedExtensions.g.cs index b9f1dff3e5..6d8c936e51 100644 --- a/UnitsNet/GeneratedCode/Extensions/Number/NumberToSpeedExtensions.g.cs +++ b/UnitsNet/GeneratedCode/Extensions/Number/NumberToSpeedExtensions.g.cs @@ -248,6 +248,40 @@ public static class NumberToSpeedExtensions #endregion + #region InchPerSecond + + /// + public static Speed InchesPerSecond(this int value) => Speed.FromInchesPerSecond(value); + + /// + public static Speed? InchesPerSecond(this int? value) => Speed.FromInchesPerSecond(value); + + /// + public static Speed InchesPerSecond(this long value) => Speed.FromInchesPerSecond(value); + + /// + public static Speed? InchesPerSecond(this long? value) => Speed.FromInchesPerSecond(value); + + /// + public static Speed InchesPerSecond(this double value) => Speed.FromInchesPerSecond(value); + + /// + public static Speed? InchesPerSecond(this double? value) => Speed.FromInchesPerSecond(value); + + /// + public static Speed InchesPerSecond(this float value) => Speed.FromInchesPerSecond(value); + + /// + public static Speed? InchesPerSecond(this float? value) => Speed.FromInchesPerSecond(value); + + /// + public static Speed InchesPerSecond(this decimal value) => Speed.FromInchesPerSecond(Convert.ToDouble(value)); + + /// + public static Speed? InchesPerSecond(this decimal? value) => Speed.FromInchesPerSecond(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region KilometerPerHour /// @@ -758,6 +792,74 @@ public static class NumberToSpeedExtensions #endregion + #region YardPerMinute + + /// + public static Speed YardsPerMinute(this int value) => Speed.FromYardsPerMinute(value); + + /// + public static Speed? YardsPerMinute(this int? value) => Speed.FromYardsPerMinute(value); + + /// + public static Speed YardsPerMinute(this long value) => Speed.FromYardsPerMinute(value); + + /// + public static Speed? YardsPerMinute(this long? value) => Speed.FromYardsPerMinute(value); + + /// + public static Speed YardsPerMinute(this double value) => Speed.FromYardsPerMinute(value); + + /// + public static Speed? YardsPerMinute(this double? value) => Speed.FromYardsPerMinute(value); + + /// + public static Speed YardsPerMinute(this float value) => Speed.FromYardsPerMinute(value); + + /// + public static Speed? YardsPerMinute(this float? value) => Speed.FromYardsPerMinute(value); + + /// + public static Speed YardsPerMinute(this decimal value) => Speed.FromYardsPerMinute(Convert.ToDouble(value)); + + /// + public static Speed? YardsPerMinute(this decimal? value) => Speed.FromYardsPerMinute(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region YardPerSecond + + /// + public static Speed YardsPerSecond(this int value) => Speed.FromYardsPerSecond(value); + + /// + public static Speed? YardsPerSecond(this int? value) => Speed.FromYardsPerSecond(value); + + /// + public static Speed YardsPerSecond(this long value) => Speed.FromYardsPerSecond(value); + + /// + public static Speed? YardsPerSecond(this long? value) => Speed.FromYardsPerSecond(value); + + /// + public static Speed YardsPerSecond(this double value) => Speed.FromYardsPerSecond(value); + + /// + public static Speed? YardsPerSecond(this double? value) => Speed.FromYardsPerSecond(value); + + /// + public static Speed YardsPerSecond(this float value) => Speed.FromYardsPerSecond(value); + + /// + public static Speed? YardsPerSecond(this float? value) => Speed.FromYardsPerSecond(value); + + /// + public static Speed YardsPerSecond(this decimal value) => Speed.FromYardsPerSecond(Convert.ToDouble(value)); + + /// + public static Speed? YardsPerSecond(this decimal? value) => Speed.FromYardsPerSecond(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + } } #endif diff --git a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs index 35f1c9c714..ee5e7edc09 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs @@ -158,6 +158,14 @@ public double FeetPerSecond get { return _metersPerSecond/0.3048; } } + /// + /// Get Speed in InchesPerSecond. + /// + public double InchesPerSecond + { + get { return _metersPerSecond/2.54e-2; } + } + /// /// Get Speed in KilometersPerHour. /// @@ -278,6 +286,22 @@ public double NanometersPerSecond get { return (_metersPerSecond) / 1e-9d; } } + /// + /// Get Speed in YardsPerMinute. + /// + public double YardsPerMinute + { + get { return _metersPerSecond/0.9144*60; } + } + + /// + /// Get Speed in YardsPerSecond. + /// + public double YardsPerSecond + { + get { return _metersPerSecond/0.9144; } + } + #endregion #region Static @@ -335,6 +359,14 @@ public static Speed FromFeetPerSecond(double feetpersecond) return new Speed(feetpersecond*0.3048); } + /// + /// Get Speed from InchesPerSecond. + /// + public static Speed FromInchesPerSecond(double inchespersecond) + { + return new Speed(inchespersecond*2.54e-2); + } + /// /// Get Speed from KilometersPerHour. /// @@ -455,6 +487,22 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) return new Speed((nanometerspersecond) * 1e-9d); } + /// + /// Get Speed from YardsPerMinute. + /// + public static Speed FromYardsPerMinute(double yardsperminute) + { + return new Speed(yardsperminute*0.9144/60); + } + + /// + /// Get Speed from YardsPerSecond. + /// + public static Speed FromYardsPerSecond(double yardspersecond) + { + return new Speed(yardspersecond*0.9144); + } + #if !WINDOWS_UWP /// /// Get nullable Speed from nullable CentimetersPerHour. @@ -546,6 +594,21 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) } } + /// + /// Get nullable Speed from nullable InchesPerSecond. + /// + public static Speed? FromInchesPerSecond(double? inchespersecond) + { + if (inchespersecond.HasValue) + { + return FromInchesPerSecond(inchespersecond.Value); + } + else + { + return null; + } + } + /// /// Get nullable Speed from nullable KilometersPerHour. /// @@ -771,6 +834,36 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) } } + /// + /// Get nullable Speed from nullable YardsPerMinute. + /// + public static Speed? FromYardsPerMinute(double? yardsperminute) + { + if (yardsperminute.HasValue) + { + return FromYardsPerMinute(yardsperminute.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Speed from nullable YardsPerSecond. + /// + public static Speed? FromYardsPerSecond(double? yardspersecond) + { + if (yardspersecond.HasValue) + { + return FromYardsPerSecond(yardspersecond.Value); + } + else + { + return null; + } + } + #endif /// @@ -795,6 +888,8 @@ public static Speed From(double val, SpeedUnit fromUnit) return FromDecimetersPerSecond(val); case SpeedUnit.FootPerSecond: return FromFeetPerSecond(val); + case SpeedUnit.InchPerSecond: + return FromInchesPerSecond(val); case SpeedUnit.KilometerPerHour: return FromKilometersPerHour(val); case SpeedUnit.KilometerPerMinute: @@ -825,6 +920,10 @@ public static Speed From(double val, SpeedUnit fromUnit) return FromNanometersPerMinutes(val); case SpeedUnit.NanometerPerSecond: return FromNanometersPerSecond(val); + case SpeedUnit.YardPerMinute: + return FromYardsPerMinute(val); + case SpeedUnit.YardPerSecond: + return FromYardsPerSecond(val); default: throw new NotImplementedException("fromUnit: " + fromUnit); @@ -858,6 +957,8 @@ public static Speed From(double val, SpeedUnit fromUnit) return FromDecimetersPerSecond(value.Value); case SpeedUnit.FootPerSecond: return FromFeetPerSecond(value.Value); + case SpeedUnit.InchPerSecond: + return FromInchesPerSecond(value.Value); case SpeedUnit.KilometerPerHour: return FromKilometersPerHour(value.Value); case SpeedUnit.KilometerPerMinute: @@ -888,6 +989,10 @@ public static Speed From(double val, SpeedUnit fromUnit) return FromNanometersPerMinutes(value.Value); case SpeedUnit.NanometerPerSecond: return FromNanometersPerSecond(value.Value); + case SpeedUnit.YardPerMinute: + return FromYardsPerMinute(value.Value); + case SpeedUnit.YardPerSecond: + return FromYardsPerSecond(value.Value); default: throw new NotImplementedException("fromUnit: " + fromUnit); @@ -1054,6 +1159,8 @@ public double As(SpeedUnit unit) return DecimetersPerSecond; case SpeedUnit.FootPerSecond: return FeetPerSecond; + case SpeedUnit.InchPerSecond: + return InchesPerSecond; case SpeedUnit.KilometerPerHour: return KilometersPerHour; case SpeedUnit.KilometerPerMinute: @@ -1084,6 +1191,10 @@ public double As(SpeedUnit unit) return NanometersPerMinutes; case SpeedUnit.NanometerPerSecond: return NanometersPerSecond; + case SpeedUnit.YardPerMinute: + return YardsPerMinute; + case SpeedUnit.YardPerSecond: + return YardsPerSecond; default: throw new NotImplementedException("unit: " + unit); diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index dd5e87852f..17566bf178 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -2273,6 +2273,11 @@ private static readonly ReadOnlyCollection DefaultLocalization { new AbbreviationsForCulture("en-US", "ft/s"), }), + new CulturesForEnumValue((int) SpeedUnit.InchPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "in/s"), + }), new CulturesForEnumValue((int) SpeedUnit.KilometerPerHour, new[] { @@ -2348,6 +2353,16 @@ private static readonly ReadOnlyCollection DefaultLocalization { new AbbreviationsForCulture("en-US", "nm/s"), }), + new CulturesForEnumValue((int) SpeedUnit.YardPerMinute, + new[] + { + new AbbreviationsForCulture("en-US", "yd/min"), + }), + new CulturesForEnumValue((int) SpeedUnit.YardPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "yd/s"), + }), }), new UnitLocalization(typeof (TemperatureUnit), new[] diff --git a/UnitsNet/UnitDefinitions/Speed.json b/UnitsNet/UnitDefinitions/Speed.json index d0ce8a01f7..f3da15da1d 100644 --- a/UnitsNet/UnitDefinitions/Speed.json +++ b/UnitsNet/UnitDefinitions/Speed.json @@ -77,6 +77,42 @@ "Abbreviations": [ "mph" ] } ] + }, + { + "SingularName": "InchPerSecond", + "PluralName": "InchesPerSecond", + "FromUnitToBaseFunc": "x*2.54e-2", + "FromBaseToUnitFunc": "x/2.54e-2", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "in/s" ] + } + ] + }, + { + "SingularName": "YardPerSecond", + "PluralName": "YardsPerSecond", + "FromUnitToBaseFunc": "x*0.9144", + "FromBaseToUnitFunc": "x/0.9144", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "yd/s" ] + } + ] + }, + { + "SingularName": "YardPerMinute", + "PluralName": "YardsPerMinute", + "FromUnitToBaseFunc": "x*0.9144/60", + "FromBaseToUnitFunc": "x/0.9144*60", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "yd/min" ] + } + ] } ] } \ No newline at end of file