From fd8594b87a569812ac3f1ae2f4560842ab08c1c3 Mon Sep 17 00:00:00 2001 From: tongbong Date: Wed, 16 Mar 2016 10:52:37 +0100 Subject: [PATCH] Add family meters per minute --- UnitsNet.Tests/CustomCode/SpeedTests.cs | 14 + .../GeneratedCode/SpeedTestsBase.g.cs | 42 +++ UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs | 7 + UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs | 259 ++++++++++++++++++ .../GeneratedCode/UnitSystem.Default.g.cs | 35 +++ UnitsNet/Scripts/UnitDefinitions/Speed.json | 13 + 6 files changed, 370 insertions(+) diff --git a/UnitsNet.Tests/CustomCode/SpeedTests.cs b/UnitsNet.Tests/CustomCode/SpeedTests.cs index 4feda43a28..006d245006 100644 --- a/UnitsNet.Tests/CustomCode/SpeedTests.cs +++ b/UnitsNet.Tests/CustomCode/SpeedTests.cs @@ -50,6 +50,20 @@ public class SpeedTests : SpeedTestsBase protected override double MetersPerHourInOneMeterPerSecond => 3600.0; + protected override double NanometersPerMinutesInOneMeterPerSecond => 60000000000; + + protected override double MicrometersPerMinutesInOneMeterPerSecond => 60000000; + + protected override double MillimetersPerMinutesInOneMeterPerSecond => 60000; + + protected override double CentimetersPerMinutesInOneMeterPerSecond => 6000; + + protected override double DecimetersPerMinutesInOneMeterPerSecond => 600; + + protected override double MetersPerMinutesInOneMeterPerSecond => 60; + + protected override double KilometersPerMinutesInOneMeterPerSecond => 0.06; + [Test] public void DurationSpeedTimesEqualsLength() { diff --git a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs index 45cbed78be..43b05384ca 100644 --- a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs @@ -36,31 +36,45 @@ namespace UnitsNet.Tests // ReSharper disable once PartialTypeWithSinglePart public abstract partial class SpeedTestsBase { + protected abstract double CentimetersPerMinutesInOneMeterPerSecond { get; } protected abstract double CentimetersPerSecondInOneMeterPerSecond { get; } + protected abstract double DecimetersPerMinutesInOneMeterPerSecond { get; } protected abstract double DecimetersPerSecondInOneMeterPerSecond { get; } protected abstract double FeetPerSecondInOneMeterPerSecond { get; } protected abstract double KilometersPerHourInOneMeterPerSecond { get; } + protected abstract double KilometersPerMinutesInOneMeterPerSecond { get; } protected abstract double KilometersPerSecondInOneMeterPerSecond { get; } protected abstract double KnotsInOneMeterPerSecond { get; } protected abstract double MetersPerHourInOneMeterPerSecond { get; } + protected abstract double MetersPerMinutesInOneMeterPerSecond { get; } protected abstract double MetersPerSecondInOneMeterPerSecond { get; } + protected abstract double MicrometersPerMinutesInOneMeterPerSecond { get; } protected abstract double MicrometersPerSecondInOneMeterPerSecond { get; } protected abstract double MilesPerHourInOneMeterPerSecond { get; } + protected abstract double MillimetersPerMinutesInOneMeterPerSecond { get; } protected abstract double MillimetersPerSecondInOneMeterPerSecond { get; } + protected abstract double NanometersPerMinutesInOneMeterPerSecond { get; } protected abstract double NanometersPerSecondInOneMeterPerSecond { get; } // ReSharper disable VirtualMemberNeverOverriden.Global + protected virtual double CentimetersPerMinutesTolerance { get { return 1e-5; } } protected virtual double CentimetersPerSecondTolerance { get { return 1e-5; } } + 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 KilometersPerHourTolerance { get { return 1e-5; } } + protected virtual double KilometersPerMinutesTolerance { get { return 1e-5; } } protected virtual double KilometersPerSecondTolerance { get { return 1e-5; } } protected virtual double KnotsTolerance { get { return 1e-5; } } protected virtual double MetersPerHourTolerance { get { return 1e-5; } } + protected virtual double MetersPerMinutesTolerance { get { return 1e-5; } } protected virtual double MetersPerSecondTolerance { get { return 1e-5; } } + protected virtual double MicrometersPerMinutesTolerance { get { return 1e-5; } } protected virtual double MicrometersPerSecondTolerance { get { return 1e-5; } } protected virtual double MilesPerHourTolerance { get { return 1e-5; } } + protected virtual double MillimetersPerMinutesTolerance { get { return 1e-5; } } protected virtual double MillimetersPerSecondTolerance { get { return 1e-5; } } + protected virtual double NanometersPerMinutesTolerance { get { return 1e-5; } } protected virtual double NanometersPerSecondTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global @@ -68,34 +82,48 @@ public abstract partial class SpeedTestsBase public void MeterPerSecondToSpeedUnits() { Speed meterpersecond = Speed.FromMetersPerSecond(1); + Assert.AreEqual(CentimetersPerMinutesInOneMeterPerSecond, meterpersecond.CentimetersPerMinutes, CentimetersPerMinutesTolerance); Assert.AreEqual(CentimetersPerSecondInOneMeterPerSecond, meterpersecond.CentimetersPerSecond, CentimetersPerSecondTolerance); + Assert.AreEqual(DecimetersPerMinutesInOneMeterPerSecond, meterpersecond.DecimetersPerMinutes, DecimetersPerMinutesTolerance); Assert.AreEqual(DecimetersPerSecondInOneMeterPerSecond, meterpersecond.DecimetersPerSecond, DecimetersPerSecondTolerance); Assert.AreEqual(FeetPerSecondInOneMeterPerSecond, meterpersecond.FeetPerSecond, FeetPerSecondTolerance); Assert.AreEqual(KilometersPerHourInOneMeterPerSecond, meterpersecond.KilometersPerHour, KilometersPerHourTolerance); + Assert.AreEqual(KilometersPerMinutesInOneMeterPerSecond, meterpersecond.KilometersPerMinutes, KilometersPerMinutesTolerance); Assert.AreEqual(KilometersPerSecondInOneMeterPerSecond, meterpersecond.KilometersPerSecond, KilometersPerSecondTolerance); Assert.AreEqual(KnotsInOneMeterPerSecond, meterpersecond.Knots, KnotsTolerance); Assert.AreEqual(MetersPerHourInOneMeterPerSecond, meterpersecond.MetersPerHour, MetersPerHourTolerance); + Assert.AreEqual(MetersPerMinutesInOneMeterPerSecond, meterpersecond.MetersPerMinutes, MetersPerMinutesTolerance); Assert.AreEqual(MetersPerSecondInOneMeterPerSecond, meterpersecond.MetersPerSecond, MetersPerSecondTolerance); + Assert.AreEqual(MicrometersPerMinutesInOneMeterPerSecond, meterpersecond.MicrometersPerMinutes, MicrometersPerMinutesTolerance); Assert.AreEqual(MicrometersPerSecondInOneMeterPerSecond, meterpersecond.MicrometersPerSecond, MicrometersPerSecondTolerance); Assert.AreEqual(MilesPerHourInOneMeterPerSecond, meterpersecond.MilesPerHour, MilesPerHourTolerance); + Assert.AreEqual(MillimetersPerMinutesInOneMeterPerSecond, meterpersecond.MillimetersPerMinutes, MillimetersPerMinutesTolerance); Assert.AreEqual(MillimetersPerSecondInOneMeterPerSecond, meterpersecond.MillimetersPerSecond, MillimetersPerSecondTolerance); + Assert.AreEqual(NanometersPerMinutesInOneMeterPerSecond, meterpersecond.NanometersPerMinutes, NanometersPerMinutesTolerance); Assert.AreEqual(NanometersPerSecondInOneMeterPerSecond, meterpersecond.NanometersPerSecond, NanometersPerSecondTolerance); } [Test] public void FromValueAndUnit() { + Assert.AreEqual(1, Speed.From(1, SpeedUnit.CentimeterPerMinute).CentimetersPerMinutes, CentimetersPerMinutesTolerance); Assert.AreEqual(1, Speed.From(1, SpeedUnit.CentimeterPerSecond).CentimetersPerSecond, CentimetersPerSecondTolerance); + 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.KilometerPerHour).KilometersPerHour, KilometersPerHourTolerance); + Assert.AreEqual(1, Speed.From(1, SpeedUnit.KilometerPerMinute).KilometersPerMinutes, KilometersPerMinutesTolerance); Assert.AreEqual(1, Speed.From(1, SpeedUnit.KilometerPerSecond).KilometersPerSecond, KilometersPerSecondTolerance); Assert.AreEqual(1, Speed.From(1, SpeedUnit.Knot).Knots, KnotsTolerance); Assert.AreEqual(1, Speed.From(1, SpeedUnit.MeterPerHour).MetersPerHour, MetersPerHourTolerance); + Assert.AreEqual(1, Speed.From(1, SpeedUnit.MeterPerMinute).MetersPerMinutes, MetersPerMinutesTolerance); Assert.AreEqual(1, Speed.From(1, SpeedUnit.MeterPerSecond).MetersPerSecond, MetersPerSecondTolerance); + Assert.AreEqual(1, Speed.From(1, SpeedUnit.MicrometerPerMinute).MicrometersPerMinutes, MicrometersPerMinutesTolerance); Assert.AreEqual(1, Speed.From(1, SpeedUnit.MicrometerPerSecond).MicrometersPerSecond, MicrometersPerSecondTolerance); Assert.AreEqual(1, Speed.From(1, SpeedUnit.MilePerHour).MilesPerHour, MilesPerHourTolerance); + Assert.AreEqual(1, Speed.From(1, SpeedUnit.MillimeterPerMinute).MillimetersPerMinutes, MillimetersPerMinutesTolerance); 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); } @@ -103,17 +131,24 @@ public void FromValueAndUnit() public void As() { var meterpersecond = Speed.FromMetersPerSecond(1); + Assert.AreEqual(CentimetersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.CentimeterPerMinute), CentimetersPerMinutesTolerance); Assert.AreEqual(CentimetersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.CentimeterPerSecond), CentimetersPerSecondTolerance); + 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(KilometersPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.KilometerPerHour), KilometersPerHourTolerance); + Assert.AreEqual(KilometersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.KilometerPerMinute), KilometersPerMinutesTolerance); Assert.AreEqual(KilometersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.KilometerPerSecond), KilometersPerSecondTolerance); Assert.AreEqual(KnotsInOneMeterPerSecond, meterpersecond.As(SpeedUnit.Knot), KnotsTolerance); Assert.AreEqual(MetersPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MeterPerHour), MetersPerHourTolerance); + Assert.AreEqual(MetersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MeterPerMinute), MetersPerMinutesTolerance); Assert.AreEqual(MetersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MeterPerSecond), MetersPerSecondTolerance); + Assert.AreEqual(MicrometersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MicrometerPerMinute), MicrometersPerMinutesTolerance); Assert.AreEqual(MicrometersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MicrometerPerSecond), MicrometersPerSecondTolerance); Assert.AreEqual(MilesPerHourInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MilePerHour), MilesPerHourTolerance); + Assert.AreEqual(MillimetersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MillimeterPerMinute), MillimetersPerMinutesTolerance); Assert.AreEqual(MillimetersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.MillimeterPerSecond), MillimetersPerSecondTolerance); + Assert.AreEqual(NanometersPerMinutesInOneMeterPerSecond, meterpersecond.As(SpeedUnit.NanometerPerMinute), NanometersPerMinutesTolerance); Assert.AreEqual(NanometersPerSecondInOneMeterPerSecond, meterpersecond.As(SpeedUnit.NanometerPerSecond), NanometersPerSecondTolerance); } @@ -121,17 +156,24 @@ public void As() public void ConversionRoundTrip() { Speed meterpersecond = Speed.FromMetersPerSecond(1); + Assert.AreEqual(1, Speed.FromCentimetersPerMinutes(meterpersecond.CentimetersPerMinutes).MetersPerSecond, CentimetersPerMinutesTolerance); Assert.AreEqual(1, Speed.FromCentimetersPerSecond(meterpersecond.CentimetersPerSecond).MetersPerSecond, CentimetersPerSecondTolerance); + 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.FromKilometersPerHour(meterpersecond.KilometersPerHour).MetersPerSecond, KilometersPerHourTolerance); + Assert.AreEqual(1, Speed.FromKilometersPerMinutes(meterpersecond.KilometersPerMinutes).MetersPerSecond, KilometersPerMinutesTolerance); Assert.AreEqual(1, Speed.FromKilometersPerSecond(meterpersecond.KilometersPerSecond).MetersPerSecond, KilometersPerSecondTolerance); Assert.AreEqual(1, Speed.FromKnots(meterpersecond.Knots).MetersPerSecond, KnotsTolerance); Assert.AreEqual(1, Speed.FromMetersPerHour(meterpersecond.MetersPerHour).MetersPerSecond, MetersPerHourTolerance); + Assert.AreEqual(1, Speed.FromMetersPerMinutes(meterpersecond.MetersPerMinutes).MetersPerSecond, MetersPerMinutesTolerance); Assert.AreEqual(1, Speed.FromMetersPerSecond(meterpersecond.MetersPerSecond).MetersPerSecond, MetersPerSecondTolerance); + Assert.AreEqual(1, Speed.FromMicrometersPerMinutes(meterpersecond.MicrometersPerMinutes).MetersPerSecond, MicrometersPerMinutesTolerance); Assert.AreEqual(1, Speed.FromMicrometersPerSecond(meterpersecond.MicrometersPerSecond).MetersPerSecond, MicrometersPerSecondTolerance); Assert.AreEqual(1, Speed.FromMilesPerHour(meterpersecond.MilesPerHour).MetersPerSecond, MilesPerHourTolerance); + Assert.AreEqual(1, Speed.FromMillimetersPerMinutes(meterpersecond.MillimetersPerMinutes).MetersPerSecond, MillimetersPerMinutesTolerance); 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); } diff --git a/UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs b/UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs index 68f7d3088e..54bc1cf277 100644 --- a/UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs +++ b/UnitsNet/GeneratedCode/Enums/SpeedUnit.g.cs @@ -25,17 +25,24 @@ namespace UnitsNet.Units public enum SpeedUnit { Undefined = 0, + CentimeterPerMinute, CentimeterPerSecond, + DecimeterPerMinute, DecimeterPerSecond, FootPerSecond, KilometerPerHour, + KilometerPerMinute, KilometerPerSecond, Knot, MeterPerHour, + MeterPerMinute, MeterPerSecond, + MicrometerPerMinute, MicrometerPerSecond, MilePerHour, + MillimeterPerMinute, MillimeterPerSecond, + NanometerPerMinute, NanometerPerSecond, } } diff --git a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs index 38dc4523b8..18541fbfb0 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Speed.g.cs @@ -54,6 +54,14 @@ public static SpeedUnit BaseUnit get { return SpeedUnit.MeterPerSecond; } } + /// + /// Get Speed in CentimetersPerMinutes. + /// + public double CentimetersPerMinutes + { + get { return (_metersPerSecond*60) / 1e-2d; } + } + /// /// Get Speed in CentimetersPerSecond. /// @@ -62,6 +70,14 @@ public double CentimetersPerSecond get { return (_metersPerSecond) / 1e-2d; } } + /// + /// Get Speed in DecimetersPerMinutes. + /// + public double DecimetersPerMinutes + { + get { return (_metersPerSecond*60) / 1e-1d; } + } + /// /// Get Speed in DecimetersPerSecond. /// @@ -86,6 +102,14 @@ public double KilometersPerHour get { return _metersPerSecond*3.6; } } + /// + /// Get Speed in KilometersPerMinutes. + /// + public double KilometersPerMinutes + { + get { return (_metersPerSecond*60) / 1e3d; } + } + /// /// Get Speed in KilometersPerSecond. /// @@ -110,6 +134,14 @@ public double MetersPerHour get { return _metersPerSecond*3600; } } + /// + /// Get Speed in MetersPerMinutes. + /// + public double MetersPerMinutes + { + get { return _metersPerSecond*60; } + } + /// /// Get Speed in MetersPerSecond. /// @@ -118,6 +150,14 @@ public double MetersPerSecond get { return _metersPerSecond; } } + /// + /// Get Speed in MicrometersPerMinutes. + /// + public double MicrometersPerMinutes + { + get { return (_metersPerSecond*60) / 1e-6d; } + } + /// /// Get Speed in MicrometersPerSecond. /// @@ -134,6 +174,14 @@ public double MilesPerHour get { return _metersPerSecond/0.44704; } } + /// + /// Get Speed in MillimetersPerMinutes. + /// + public double MillimetersPerMinutes + { + get { return (_metersPerSecond*60) / 1e-3d; } + } + /// /// Get Speed in MillimetersPerSecond. /// @@ -142,6 +190,14 @@ public double MillimetersPerSecond get { return (_metersPerSecond) / 1e-3d; } } + /// + /// Get Speed in NanometersPerMinutes. + /// + public double NanometersPerMinutes + { + get { return (_metersPerSecond*60) / 1e-9d; } + } + /// /// Get Speed in NanometersPerSecond. /// @@ -159,6 +215,14 @@ public static Speed Zero get { return new Speed(); } } + /// + /// Get Speed from CentimetersPerMinutes. + /// + public static Speed FromCentimetersPerMinutes(double centimetersperminutes) + { + return new Speed((centimetersperminutes/60) * 1e-2d); + } + /// /// Get Speed from CentimetersPerSecond. /// @@ -167,6 +231,14 @@ public static Speed FromCentimetersPerSecond(double centimeterspersecond) return new Speed((centimeterspersecond) * 1e-2d); } + /// + /// Get Speed from DecimetersPerMinutes. + /// + public static Speed FromDecimetersPerMinutes(double decimetersperminutes) + { + return new Speed((decimetersperminutes/60) * 1e-1d); + } + /// /// Get Speed from DecimetersPerSecond. /// @@ -191,6 +263,14 @@ public static Speed FromKilometersPerHour(double kilometersperhour) return new Speed(kilometersperhour/3.6); } + /// + /// Get Speed from KilometersPerMinutes. + /// + public static Speed FromKilometersPerMinutes(double kilometersperminutes) + { + return new Speed((kilometersperminutes/60) * 1e3d); + } + /// /// Get Speed from KilometersPerSecond. /// @@ -215,6 +295,14 @@ public static Speed FromMetersPerHour(double metersperhour) return new Speed(metersperhour/3600); } + /// + /// Get Speed from MetersPerMinutes. + /// + public static Speed FromMetersPerMinutes(double metersperminutes) + { + return new Speed(metersperminutes/60); + } + /// /// Get Speed from MetersPerSecond. /// @@ -223,6 +311,14 @@ public static Speed FromMetersPerSecond(double meterspersecond) return new Speed(meterspersecond); } + /// + /// Get Speed from MicrometersPerMinutes. + /// + public static Speed FromMicrometersPerMinutes(double micrometersperminutes) + { + return new Speed((micrometersperminutes/60) * 1e-6d); + } + /// /// Get Speed from MicrometersPerSecond. /// @@ -239,6 +335,14 @@ public static Speed FromMilesPerHour(double milesperhour) return new Speed(milesperhour*0.44704); } + /// + /// Get Speed from MillimetersPerMinutes. + /// + public static Speed FromMillimetersPerMinutes(double millimetersperminutes) + { + return new Speed((millimetersperminutes/60) * 1e-3d); + } + /// /// Get Speed from MillimetersPerSecond. /// @@ -247,6 +351,14 @@ public static Speed FromMillimetersPerSecond(double millimeterspersecond) return new Speed((millimeterspersecond) * 1e-3d); } + /// + /// Get Speed from NanometersPerMinutes. + /// + public static Speed FromNanometersPerMinutes(double nanometersperminutes) + { + return new Speed((nanometersperminutes/60) * 1e-9d); + } + /// /// Get Speed from NanometersPerSecond. /// @@ -256,6 +368,21 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) } + /// + /// Get nullable Speed from nullable CentimetersPerMinutes. + /// + public static Speed? FromCentimetersPerMinutes(double? centimetersperminutes) + { + if (centimetersperminutes.HasValue) + { + return FromCentimetersPerMinutes(centimetersperminutes.Value); + } + else + { + return null; + } + } + /// /// Get nullable Speed from nullable CentimetersPerSecond. /// @@ -271,6 +398,21 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) } } + /// + /// Get nullable Speed from nullable DecimetersPerMinutes. + /// + public static Speed? FromDecimetersPerMinutes(double? decimetersperminutes) + { + if (decimetersperminutes.HasValue) + { + return FromDecimetersPerMinutes(decimetersperminutes.Value); + } + else + { + return null; + } + } + /// /// Get nullable Speed from nullable DecimetersPerSecond. /// @@ -316,6 +458,21 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) } } + /// + /// Get nullable Speed from nullable KilometersPerMinutes. + /// + public static Speed? FromKilometersPerMinutes(double? kilometersperminutes) + { + if (kilometersperminutes.HasValue) + { + return FromKilometersPerMinutes(kilometersperminutes.Value); + } + else + { + return null; + } + } + /// /// Get nullable Speed from nullable KilometersPerSecond. /// @@ -361,6 +518,21 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) } } + /// + /// Get nullable Speed from nullable MetersPerMinutes. + /// + public static Speed? FromMetersPerMinutes(double? metersperminutes) + { + if (metersperminutes.HasValue) + { + return FromMetersPerMinutes(metersperminutes.Value); + } + else + { + return null; + } + } + /// /// Get nullable Speed from nullable MetersPerSecond. /// @@ -376,6 +548,21 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) } } + /// + /// Get nullable Speed from nullable MicrometersPerMinutes. + /// + public static Speed? FromMicrometersPerMinutes(double? micrometersperminutes) + { + if (micrometersperminutes.HasValue) + { + return FromMicrometersPerMinutes(micrometersperminutes.Value); + } + else + { + return null; + } + } + /// /// Get nullable Speed from nullable MicrometersPerSecond. /// @@ -406,6 +593,21 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) } } + /// + /// Get nullable Speed from nullable MillimetersPerMinutes. + /// + public static Speed? FromMillimetersPerMinutes(double? millimetersperminutes) + { + if (millimetersperminutes.HasValue) + { + return FromMillimetersPerMinutes(millimetersperminutes.Value); + } + else + { + return null; + } + } + /// /// Get nullable Speed from nullable MillimetersPerSecond. /// @@ -421,6 +623,21 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) } } + /// + /// Get nullable Speed from nullable NanometersPerMinutes. + /// + public static Speed? FromNanometersPerMinutes(double? nanometersperminutes) + { + if (nanometersperminutes.HasValue) + { + return FromNanometersPerMinutes(nanometersperminutes.Value); + } + else + { + return null; + } + } + /// /// Get nullable Speed from nullable NanometersPerSecond. /// @@ -447,28 +664,42 @@ public static Speed From(double value, SpeedUnit fromUnit) { switch (fromUnit) { + case SpeedUnit.CentimeterPerMinute: + return FromCentimetersPerMinutes(value); case SpeedUnit.CentimeterPerSecond: return FromCentimetersPerSecond(value); + case SpeedUnit.DecimeterPerMinute: + return FromDecimetersPerMinutes(value); case SpeedUnit.DecimeterPerSecond: return FromDecimetersPerSecond(value); case SpeedUnit.FootPerSecond: return FromFeetPerSecond(value); case SpeedUnit.KilometerPerHour: return FromKilometersPerHour(value); + case SpeedUnit.KilometerPerMinute: + return FromKilometersPerMinutes(value); case SpeedUnit.KilometerPerSecond: return FromKilometersPerSecond(value); case SpeedUnit.Knot: return FromKnots(value); case SpeedUnit.MeterPerHour: return FromMetersPerHour(value); + case SpeedUnit.MeterPerMinute: + return FromMetersPerMinutes(value); case SpeedUnit.MeterPerSecond: return FromMetersPerSecond(value); + case SpeedUnit.MicrometerPerMinute: + return FromMicrometersPerMinutes(value); case SpeedUnit.MicrometerPerSecond: return FromMicrometersPerSecond(value); case SpeedUnit.MilePerHour: return FromMilesPerHour(value); + case SpeedUnit.MillimeterPerMinute: + return FromMillimetersPerMinutes(value); case SpeedUnit.MillimeterPerSecond: return FromMillimetersPerSecond(value); + case SpeedUnit.NanometerPerMinute: + return FromNanometersPerMinutes(value); case SpeedUnit.NanometerPerSecond: return FromNanometersPerSecond(value); @@ -491,28 +722,42 @@ public static Speed From(double value, SpeedUnit fromUnit) } switch (fromUnit) { + case SpeedUnit.CentimeterPerMinute: + return FromCentimetersPerMinutes(value.Value); case SpeedUnit.CentimeterPerSecond: return FromCentimetersPerSecond(value.Value); + case SpeedUnit.DecimeterPerMinute: + return FromDecimetersPerMinutes(value.Value); case SpeedUnit.DecimeterPerSecond: return FromDecimetersPerSecond(value.Value); case SpeedUnit.FootPerSecond: return FromFeetPerSecond(value.Value); case SpeedUnit.KilometerPerHour: return FromKilometersPerHour(value.Value); + case SpeedUnit.KilometerPerMinute: + return FromKilometersPerMinutes(value.Value); case SpeedUnit.KilometerPerSecond: return FromKilometersPerSecond(value.Value); case SpeedUnit.Knot: return FromKnots(value.Value); case SpeedUnit.MeterPerHour: return FromMetersPerHour(value.Value); + case SpeedUnit.MeterPerMinute: + return FromMetersPerMinutes(value.Value); case SpeedUnit.MeterPerSecond: return FromMetersPerSecond(value.Value); + case SpeedUnit.MicrometerPerMinute: + return FromMicrometersPerMinutes(value.Value); case SpeedUnit.MicrometerPerSecond: return FromMicrometersPerSecond(value.Value); case SpeedUnit.MilePerHour: return FromMilesPerHour(value.Value); + case SpeedUnit.MillimeterPerMinute: + return FromMillimetersPerMinutes(value.Value); case SpeedUnit.MillimeterPerSecond: return FromMillimetersPerSecond(value.Value); + case SpeedUnit.NanometerPerMinute: + return FromNanometersPerMinutes(value.Value); case SpeedUnit.NanometerPerSecond: return FromNanometersPerSecond(value.Value); @@ -648,28 +893,42 @@ public double As(SpeedUnit unit) { switch (unit) { + case SpeedUnit.CentimeterPerMinute: + return CentimetersPerMinutes; case SpeedUnit.CentimeterPerSecond: return CentimetersPerSecond; + case SpeedUnit.DecimeterPerMinute: + return DecimetersPerMinutes; case SpeedUnit.DecimeterPerSecond: return DecimetersPerSecond; case SpeedUnit.FootPerSecond: return FeetPerSecond; case SpeedUnit.KilometerPerHour: return KilometersPerHour; + case SpeedUnit.KilometerPerMinute: + return KilometersPerMinutes; case SpeedUnit.KilometerPerSecond: return KilometersPerSecond; case SpeedUnit.Knot: return Knots; case SpeedUnit.MeterPerHour: return MetersPerHour; + case SpeedUnit.MeterPerMinute: + return MetersPerMinutes; case SpeedUnit.MeterPerSecond: return MetersPerSecond; + case SpeedUnit.MicrometerPerMinute: + return MicrometersPerMinutes; case SpeedUnit.MicrometerPerSecond: return MicrometersPerSecond; case SpeedUnit.MilePerHour: return MilesPerHour; + case SpeedUnit.MillimeterPerMinute: + return MillimetersPerMinutes; case SpeedUnit.MillimeterPerSecond: return MillimetersPerSecond; + case SpeedUnit.NanometerPerMinute: + return NanometersPerMinutes; case SpeedUnit.NanometerPerSecond: return NanometersPerSecond; diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index c4acbf8d36..2c6cc7c185 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1748,11 +1748,21 @@ private static readonly ReadOnlyCollection DefaultLocalization new UnitLocalization(typeof (SpeedUnit), new[] { + new CulturesForEnumValue((int) SpeedUnit.CentimeterPerMinute, + new[] + { + new AbbreviationsForCulture("en-US", "cm/min"), + }), new CulturesForEnumValue((int) SpeedUnit.CentimeterPerSecond, new[] { new AbbreviationsForCulture("en-US", "cm/s"), }), + new CulturesForEnumValue((int) SpeedUnit.DecimeterPerMinute, + new[] + { + new AbbreviationsForCulture("en-US", "dm/min"), + }), new CulturesForEnumValue((int) SpeedUnit.DecimeterPerSecond, new[] { @@ -1768,6 +1778,11 @@ private static readonly ReadOnlyCollection DefaultLocalization { new AbbreviationsForCulture("en-US", "km/h", "kph"), }), + new CulturesForEnumValue((int) SpeedUnit.KilometerPerMinute, + new[] + { + new AbbreviationsForCulture("en-US", "km/min"), + }), new CulturesForEnumValue((int) SpeedUnit.KilometerPerSecond, new[] { @@ -1783,11 +1798,21 @@ private static readonly ReadOnlyCollection DefaultLocalization { new AbbreviationsForCulture("en-US", "m/h"), }), + new CulturesForEnumValue((int) SpeedUnit.MeterPerMinute, + new[] + { + new AbbreviationsForCulture("en-US", "m/min"), + }), new CulturesForEnumValue((int) SpeedUnit.MeterPerSecond, new[] { new AbbreviationsForCulture("en-US", "m/s"), }), + new CulturesForEnumValue((int) SpeedUnit.MicrometerPerMinute, + new[] + { + new AbbreviationsForCulture("en-US", "μm/min"), + }), new CulturesForEnumValue((int) SpeedUnit.MicrometerPerSecond, new[] { @@ -1798,11 +1823,21 @@ private static readonly ReadOnlyCollection DefaultLocalization { new AbbreviationsForCulture("en-US", "mph"), }), + new CulturesForEnumValue((int) SpeedUnit.MillimeterPerMinute, + new[] + { + new AbbreviationsForCulture("en-US", "mm/min"), + }), new CulturesForEnumValue((int) SpeedUnit.MillimeterPerSecond, new[] { new AbbreviationsForCulture("en-US", "mm/s"), }), + new CulturesForEnumValue((int) SpeedUnit.NanometerPerMinute, + new[] + { + new AbbreviationsForCulture("en-US", "nm/min"), + }), new CulturesForEnumValue((int) SpeedUnit.NanometerPerSecond, new[] { diff --git a/UnitsNet/Scripts/UnitDefinitions/Speed.json b/UnitsNet/Scripts/UnitDefinitions/Speed.json index 66ce2aa4ec..0f18194ecc 100644 --- a/UnitsNet/Scripts/UnitDefinitions/Speed.json +++ b/UnitsNet/Scripts/UnitDefinitions/Speed.json @@ -16,6 +16,19 @@ } ] }, + { + "SingularName": "MeterPerMinute", + "PluralName": "MetersPerMinutes", + "FromUnitToBaseFunc": "x/60", + "FromBaseToUnitFunc": "x*60", + "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Kilo" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "m/min" ] + } + ] + }, { "SingularName": "MeterPerHour", "PluralName": "MetersPerHour",