From d65d5bca09f8ab052f311fe0e89555462a7ca20f Mon Sep 17 00:00:00 2001 From: tongbong Date: Mon, 29 Feb 2016 14:13:51 +0100 Subject: [PATCH 1/4] Add degree per second unit --- .../CustomCode/RotationalSpeedTests.cs | 2 ++ .../RotationalSpeedTestsBase.g.cs | 6 +++++ .../Enums/RotationalSpeedUnit.g.cs | 1 + .../UnitClasses/RotationalSpeed.g.cs | 20 ++++++++++++++++ .../GeneratedCode/UnitSystem.Default.g.cs | 6 +++++ .../UnitDefinitions/RotationalSpeed.json | 24 +++++++++++++++---- 6 files changed, 55 insertions(+), 4 deletions(-) diff --git a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs index 0fb21b18b4..76050c6c66 100644 --- a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs +++ b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs @@ -42,6 +42,8 @@ public class RotationalSpeedTests : RotationalSpeedTestsBase protected override double RevolutionsPerSecondInOneRadianPerSecond => 1/(2*Math.PI); + protected override double DegreesPerSecondInOneRadianPerSecond => (180 / Math.PI) * 1; + [Test] public void DurationTimesRotationalSpeedEqualsAngle() { diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index 552412d898..6058cab611 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -38,6 +38,7 @@ public abstract partial class RotationalSpeedTestsBase { protected abstract double CentiradiansPerSecondInOneRadianPerSecond { get; } protected abstract double DeciradiansPerSecondInOneRadianPerSecond { get; } + protected abstract double DegreesPerSecondInOneRadianPerSecond { get; } protected abstract double MicroradiansPerSecondInOneRadianPerSecond { get; } protected abstract double MilliradiansPerSecondInOneRadianPerSecond { get; } protected abstract double NanoradiansPerSecondInOneRadianPerSecond { get; } @@ -48,6 +49,7 @@ public abstract partial class RotationalSpeedTestsBase // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double CentiradiansPerSecondTolerance { get { return 1e-5; } } protected virtual double DeciradiansPerSecondTolerance { get { return 1e-5; } } + protected virtual double DegreesPerSecondTolerance { get { return 1e-5; } } protected virtual double MicroradiansPerSecondTolerance { get { return 1e-5; } } protected virtual double MilliradiansPerSecondTolerance { get { return 1e-5; } } protected virtual double NanoradiansPerSecondTolerance { get { return 1e-5; } } @@ -62,6 +64,7 @@ public void RadianPerSecondToRotationalSpeedUnits() RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); Assert.AreEqual(CentiradiansPerSecondInOneRadianPerSecond, radianpersecond.CentiradiansPerSecond, CentiradiansPerSecondTolerance); Assert.AreEqual(DeciradiansPerSecondInOneRadianPerSecond, radianpersecond.DeciradiansPerSecond, DeciradiansPerSecondTolerance); + Assert.AreEqual(DegreesPerSecondInOneRadianPerSecond, radianpersecond.DegreesPerSecond, DegreesPerSecondTolerance); Assert.AreEqual(MicroradiansPerSecondInOneRadianPerSecond, radianpersecond.MicroradiansPerSecond, MicroradiansPerSecondTolerance); Assert.AreEqual(MilliradiansPerSecondInOneRadianPerSecond, radianpersecond.MilliradiansPerSecond, MilliradiansPerSecondTolerance); Assert.AreEqual(NanoradiansPerSecondInOneRadianPerSecond, radianpersecond.NanoradiansPerSecond, NanoradiansPerSecondTolerance); @@ -75,6 +78,7 @@ public void FromValueAndUnit() { Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.CentiradianPerSecond).CentiradiansPerSecond, CentiradiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.DeciradianPerSecond).DeciradiansPerSecond, DeciradiansPerSecondTolerance); + Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.DegreePerSecond).DegreesPerSecond, DegreesPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.MicroradianPerSecond).MicroradiansPerSecond, MicroradiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.MilliradianPerSecond).MilliradiansPerSecond, MilliradiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.NanoradianPerSecond).NanoradiansPerSecond, NanoradiansPerSecondTolerance); @@ -89,6 +93,7 @@ public void As() var radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); Assert.AreEqual(CentiradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.CentiradianPerSecond), CentiradiansPerSecondTolerance); Assert.AreEqual(DeciradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.DeciradianPerSecond), DeciradiansPerSecondTolerance); + Assert.AreEqual(DegreesPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.DegreePerSecond), DegreesPerSecondTolerance); Assert.AreEqual(MicroradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.MicroradianPerSecond), MicroradiansPerSecondTolerance); Assert.AreEqual(MilliradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.MilliradianPerSecond), MilliradiansPerSecondTolerance); Assert.AreEqual(NanoradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.NanoradianPerSecond), NanoradiansPerSecondTolerance); @@ -103,6 +108,7 @@ public void ConversionRoundTrip() RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); Assert.AreEqual(1, RotationalSpeed.FromCentiradiansPerSecond(radianpersecond.CentiradiansPerSecond).RadiansPerSecond, CentiradiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.FromDeciradiansPerSecond(radianpersecond.DeciradiansPerSecond).RadiansPerSecond, DeciradiansPerSecondTolerance); + Assert.AreEqual(1, RotationalSpeed.FromDegreesPerSecond(radianpersecond.DegreesPerSecond).RadiansPerSecond, DegreesPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.FromMicroradiansPerSecond(radianpersecond.MicroradiansPerSecond).RadiansPerSecond, MicroradiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.FromMilliradiansPerSecond(radianpersecond.MilliradiansPerSecond).RadiansPerSecond, MilliradiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.FromNanoradiansPerSecond(radianpersecond.NanoradiansPerSecond).RadiansPerSecond, NanoradiansPerSecondTolerance); diff --git a/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs b/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs index bef3c12843..e03d3f07fc 100644 --- a/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs +++ b/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs @@ -27,6 +27,7 @@ public enum RotationalSpeedUnit Undefined = 0, CentiradianPerSecond, DeciradianPerSecond, + DegreePerSecond, MicroradianPerSecond, MilliradianPerSecond, NanoradianPerSecond, diff --git a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs index 3e054a5cb1..9eddf0534f 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs @@ -70,6 +70,14 @@ public double DeciradiansPerSecond get { return (_radiansPerSecond) / 1e-1d; } } + /// + /// Get RotationalSpeed in DegreesPerSecond. + /// + public double DegreesPerSecond + { + get { return (180/Math.PI)*_radiansPerSecond; } + } + /// /// Get RotationalSpeed in MicroradiansPerSecond. /// @@ -143,6 +151,14 @@ public static RotationalSpeed FromDeciradiansPerSecond(double deciradiansperseco return new RotationalSpeed((deciradianspersecond) * 1e-1d); } + /// + /// Get RotationalSpeed from DegreesPerSecond. + /// + public static RotationalSpeed FromDegreesPerSecond(double degreespersecond) + { + return new RotationalSpeed((Math.PI/180)*degreespersecond); + } + /// /// Get RotationalSpeed from MicroradiansPerSecond. /// @@ -206,6 +222,8 @@ public static RotationalSpeed From(double value, RotationalSpeedUnit fromUnit) return FromCentiradiansPerSecond(value); case RotationalSpeedUnit.DeciradianPerSecond: return FromDeciradiansPerSecond(value); + case RotationalSpeedUnit.DegreePerSecond: + return FromDegreesPerSecond(value); case RotationalSpeedUnit.MicroradianPerSecond: return FromMicroradiansPerSecond(value); case RotationalSpeedUnit.MilliradianPerSecond: @@ -355,6 +373,8 @@ public double As(RotationalSpeedUnit unit) return CentiradiansPerSecond; case RotationalSpeedUnit.DeciradianPerSecond: return DeciradiansPerSecond; + case RotationalSpeedUnit.DegreePerSecond: + return DegreesPerSecond; case RotationalSpeedUnit.MicroradianPerSecond: return MicroradiansPerSecond; case RotationalSpeedUnit.MilliradianPerSecond: diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 93920aace2..3d3a3befc0 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1478,6 +1478,12 @@ private static readonly ReadOnlyCollection DefaultLocalization new AbbreviationsForCulture("en-US", "drad/s"), new AbbreviationsForCulture("ru-RU", "dрад/с"), }), + new CulturesForEnumValue((int) RotationalSpeedUnit.DegreePerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "r/s"), + new AbbreviationsForCulture("ru-RU", "°/с"), + }), new CulturesForEnumValue((int) RotationalSpeedUnit.MicroradianPerSecond, new[] { diff --git a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json index 7d4a572e1c..0ba928bdfe 100644 --- a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json +++ b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json @@ -1,8 +1,8 @@ { - "Name": "RotationalSpeed", - "BaseUnit": "RadianPerSecond", - "XmlDoc": "Rotational speed (sometimes called speed of revolution) is the number of complete rotations, revolutions, cycles, or turns per time unit. Rotational speed is a cyclic frequency, measured in radians per second or in hertz in the SI System by scientists, or in revolutions per minute (rpm or min-1) or revolutions per second in everyday life. The symbol for rotational speed is ω (the Greek lowercase letter \"omega\").", - "Units": [ + "Name": "RotationalSpeed", + "BaseUnit": "RadianPerSecond", + "XmlDoc": "Rotational speed (sometimes called speed of revolution) is the number of complete rotations, revolutions, cycles, or turns per time unit. Rotational speed is a cyclic frequency, measured in radians per second or in hertz in the SI System by scientists, or in revolutions per minute (rpm or min-1) or revolutions per second in everyday life. The symbol for rotational speed is ω (the Greek lowercase letter \"omega\").", + "Units": [ { "SingularName": "RadianPerSecond", "PluralName": "RadiansPerSecond", @@ -20,6 +20,22 @@ } ] }, + { + "SingularName": "DegreePerSecond", + "PluralName": "DegreesPerSecond", + "FromUnitToBaseFunc": "(Math.PI/180)*x", + "FromBaseToUnitFunc": "(180/Math.PI)*x", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "r/s" ] + }, + { + "Culture": "ru-RU", + "Abbreviations": [ "°/с" ] + } + ] + }, { "SingularName": "RevolutionPerSecond", "PluralName": "RevolutionsPerSecond", From 2c9757d208b7112997df5eb056d0867ebed2a0a6 Mon Sep 17 00:00:00 2001 From: tongbong Date: Mon, 29 Feb 2016 17:46:08 +0100 Subject: [PATCH 2/4] Add more units based on degree per second unit --- .../CustomCode/RotationalSpeedTests.cs | 7 +++ .../RotationalSpeedTestsBase.g.cs | 18 ++++++ .../Enums/RotationalSpeedUnit.g.cs | 3 + .../UnitClasses/RotationalSpeed.g.cs | 60 +++++++++++++++++++ .../GeneratedCode/UnitSystem.Default.g.cs | 18 ++++++ .../UnitDefinitions/RotationalSpeed.json | 33 +++++----- 6 files changed, 123 insertions(+), 16 deletions(-) diff --git a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs index 76050c6c66..0bf59900a5 100644 --- a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs +++ b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs @@ -44,6 +44,13 @@ public class RotationalSpeedTests : RotationalSpeedTestsBase protected override double DegreesPerSecondInOneRadianPerSecond => (180 / Math.PI) * 1; + protected override double MillidegreesPerSecondInOneRadianPerSecond => ((180 / Math.PI) * 1)* 1E3; + + protected override double MicrodegreesPerSecondInOneRadianPerSecond => ((180 / Math.PI) * 1) * 1E6; + + protected override double NanodegreesPerSecondInOneRadianPerSecond => ((180 / Math.PI) * 1) * 1E9; + + [Test] public void DurationTimesRotationalSpeedEqualsAngle() { diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index 6058cab611..434eea090b 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -39,8 +39,11 @@ public abstract partial class RotationalSpeedTestsBase protected abstract double CentiradiansPerSecondInOneRadianPerSecond { get; } protected abstract double DeciradiansPerSecondInOneRadianPerSecond { get; } protected abstract double DegreesPerSecondInOneRadianPerSecond { get; } + protected abstract double MicrodegreesPerSecondInOneRadianPerSecond { get; } protected abstract double MicroradiansPerSecondInOneRadianPerSecond { get; } + protected abstract double MillidegreesPerSecondInOneRadianPerSecond { get; } protected abstract double MilliradiansPerSecondInOneRadianPerSecond { get; } + protected abstract double NanodegreesPerSecondInOneRadianPerSecond { get; } protected abstract double NanoradiansPerSecondInOneRadianPerSecond { get; } protected abstract double RadiansPerSecondInOneRadianPerSecond { get; } protected abstract double RevolutionsPerMinuteInOneRadianPerSecond { get; } @@ -50,8 +53,11 @@ public abstract partial class RotationalSpeedTestsBase protected virtual double CentiradiansPerSecondTolerance { get { return 1e-5; } } protected virtual double DeciradiansPerSecondTolerance { get { return 1e-5; } } protected virtual double DegreesPerSecondTolerance { get { return 1e-5; } } + protected virtual double MicrodegreesPerSecondTolerance { get { return 1e-5; } } protected virtual double MicroradiansPerSecondTolerance { get { return 1e-5; } } + protected virtual double MillidegreesPerSecondTolerance { get { return 1e-5; } } protected virtual double MilliradiansPerSecondTolerance { get { return 1e-5; } } + protected virtual double NanodegreesPerSecondTolerance { get { return 1e-5; } } protected virtual double NanoradiansPerSecondTolerance { get { return 1e-5; } } protected virtual double RadiansPerSecondTolerance { get { return 1e-5; } } protected virtual double RevolutionsPerMinuteTolerance { get { return 1e-5; } } @@ -65,8 +71,11 @@ public void RadianPerSecondToRotationalSpeedUnits() Assert.AreEqual(CentiradiansPerSecondInOneRadianPerSecond, radianpersecond.CentiradiansPerSecond, CentiradiansPerSecondTolerance); Assert.AreEqual(DeciradiansPerSecondInOneRadianPerSecond, radianpersecond.DeciradiansPerSecond, DeciradiansPerSecondTolerance); Assert.AreEqual(DegreesPerSecondInOneRadianPerSecond, radianpersecond.DegreesPerSecond, DegreesPerSecondTolerance); + Assert.AreEqual(MicrodegreesPerSecondInOneRadianPerSecond, radianpersecond.MicrodegreesPerSecond, MicrodegreesPerSecondTolerance); Assert.AreEqual(MicroradiansPerSecondInOneRadianPerSecond, radianpersecond.MicroradiansPerSecond, MicroradiansPerSecondTolerance); + Assert.AreEqual(MillidegreesPerSecondInOneRadianPerSecond, radianpersecond.MillidegreesPerSecond, MillidegreesPerSecondTolerance); Assert.AreEqual(MilliradiansPerSecondInOneRadianPerSecond, radianpersecond.MilliradiansPerSecond, MilliradiansPerSecondTolerance); + Assert.AreEqual(NanodegreesPerSecondInOneRadianPerSecond, radianpersecond.NanodegreesPerSecond, NanodegreesPerSecondTolerance); Assert.AreEqual(NanoradiansPerSecondInOneRadianPerSecond, radianpersecond.NanoradiansPerSecond, NanoradiansPerSecondTolerance); Assert.AreEqual(RadiansPerSecondInOneRadianPerSecond, radianpersecond.RadiansPerSecond, RadiansPerSecondTolerance); Assert.AreEqual(RevolutionsPerMinuteInOneRadianPerSecond, radianpersecond.RevolutionsPerMinute, RevolutionsPerMinuteTolerance); @@ -79,8 +88,11 @@ public void FromValueAndUnit() Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.CentiradianPerSecond).CentiradiansPerSecond, CentiradiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.DeciradianPerSecond).DeciradiansPerSecond, DeciradiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.DegreePerSecond).DegreesPerSecond, DegreesPerSecondTolerance); + Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.MicrodegreePerSecond).MicrodegreesPerSecond, MicrodegreesPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.MicroradianPerSecond).MicroradiansPerSecond, MicroradiansPerSecondTolerance); + Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.MillidegreePerSecond).MillidegreesPerSecond, MillidegreesPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.MilliradianPerSecond).MilliradiansPerSecond, MilliradiansPerSecondTolerance); + Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.NanodegreePerSecond).NanodegreesPerSecond, NanodegreesPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.NanoradianPerSecond).NanoradiansPerSecond, NanoradiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.RadianPerSecond).RadiansPerSecond, RadiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerMinute).RevolutionsPerMinute, RevolutionsPerMinuteTolerance); @@ -94,8 +106,11 @@ public void As() Assert.AreEqual(CentiradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.CentiradianPerSecond), CentiradiansPerSecondTolerance); Assert.AreEqual(DeciradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.DeciradianPerSecond), DeciradiansPerSecondTolerance); Assert.AreEqual(DegreesPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.DegreePerSecond), DegreesPerSecondTolerance); + Assert.AreEqual(MicrodegreesPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.MicrodegreePerSecond), MicrodegreesPerSecondTolerance); Assert.AreEqual(MicroradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.MicroradianPerSecond), MicroradiansPerSecondTolerance); + Assert.AreEqual(MillidegreesPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.MillidegreePerSecond), MillidegreesPerSecondTolerance); Assert.AreEqual(MilliradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.MilliradianPerSecond), MilliradiansPerSecondTolerance); + Assert.AreEqual(NanodegreesPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.NanodegreePerSecond), NanodegreesPerSecondTolerance); Assert.AreEqual(NanoradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.NanoradianPerSecond), NanoradiansPerSecondTolerance); Assert.AreEqual(RadiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.RadianPerSecond), RadiansPerSecondTolerance); Assert.AreEqual(RevolutionsPerMinuteInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.RevolutionPerMinute), RevolutionsPerMinuteTolerance); @@ -109,8 +124,11 @@ public void ConversionRoundTrip() Assert.AreEqual(1, RotationalSpeed.FromCentiradiansPerSecond(radianpersecond.CentiradiansPerSecond).RadiansPerSecond, CentiradiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.FromDeciradiansPerSecond(radianpersecond.DeciradiansPerSecond).RadiansPerSecond, DeciradiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.FromDegreesPerSecond(radianpersecond.DegreesPerSecond).RadiansPerSecond, DegreesPerSecondTolerance); + Assert.AreEqual(1, RotationalSpeed.FromMicrodegreesPerSecond(radianpersecond.MicrodegreesPerSecond).RadiansPerSecond, MicrodegreesPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.FromMicroradiansPerSecond(radianpersecond.MicroradiansPerSecond).RadiansPerSecond, MicroradiansPerSecondTolerance); + Assert.AreEqual(1, RotationalSpeed.FromMillidegreesPerSecond(radianpersecond.MillidegreesPerSecond).RadiansPerSecond, MillidegreesPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.FromMilliradiansPerSecond(radianpersecond.MilliradiansPerSecond).RadiansPerSecond, MilliradiansPerSecondTolerance); + Assert.AreEqual(1, RotationalSpeed.FromNanodegreesPerSecond(radianpersecond.NanodegreesPerSecond).RadiansPerSecond, NanodegreesPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.FromNanoradiansPerSecond(radianpersecond.NanoradiansPerSecond).RadiansPerSecond, NanoradiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.FromRadiansPerSecond(radianpersecond.RadiansPerSecond).RadiansPerSecond, RadiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.FromRevolutionsPerMinute(radianpersecond.RevolutionsPerMinute).RadiansPerSecond, RevolutionsPerMinuteTolerance); diff --git a/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs b/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs index e03d3f07fc..11b589ae94 100644 --- a/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs +++ b/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs @@ -28,8 +28,11 @@ public enum RotationalSpeedUnit CentiradianPerSecond, DeciradianPerSecond, DegreePerSecond, + MicrodegreePerSecond, MicroradianPerSecond, + MillidegreePerSecond, MilliradianPerSecond, + NanodegreePerSecond, NanoradianPerSecond, RadianPerSecond, RevolutionPerMinute, diff --git a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs index 9eddf0534f..738eec1c20 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs @@ -78,6 +78,14 @@ public double DegreesPerSecond get { return (180/Math.PI)*_radiansPerSecond; } } + /// + /// Get RotationalSpeed in MicrodegreesPerSecond. + /// + public double MicrodegreesPerSecond + { + get { return ((180/Math.PI)*_radiansPerSecond) / 1e-6d; } + } + /// /// Get RotationalSpeed in MicroradiansPerSecond. /// @@ -86,6 +94,14 @@ public double MicroradiansPerSecond get { return (_radiansPerSecond) / 1e-6d; } } + /// + /// Get RotationalSpeed in MillidegreesPerSecond. + /// + public double MillidegreesPerSecond + { + get { return ((180/Math.PI)*_radiansPerSecond) / 1e-3d; } + } + /// /// Get RotationalSpeed in MilliradiansPerSecond. /// @@ -94,6 +110,14 @@ public double MilliradiansPerSecond get { return (_radiansPerSecond) / 1e-3d; } } + /// + /// Get RotationalSpeed in NanodegreesPerSecond. + /// + public double NanodegreesPerSecond + { + get { return ((180/Math.PI)*_radiansPerSecond) / 1e-9d; } + } + /// /// Get RotationalSpeed in NanoradiansPerSecond. /// @@ -159,6 +183,14 @@ public static RotationalSpeed FromDegreesPerSecond(double degreespersecond) return new RotationalSpeed((Math.PI/180)*degreespersecond); } + /// + /// Get RotationalSpeed from MicrodegreesPerSecond. + /// + public static RotationalSpeed FromMicrodegreesPerSecond(double microdegreespersecond) + { + return new RotationalSpeed(((Math.PI/180)*microdegreespersecond) * 1e-6d); + } + /// /// Get RotationalSpeed from MicroradiansPerSecond. /// @@ -167,6 +199,14 @@ public static RotationalSpeed FromMicroradiansPerSecond(double microradiansperse return new RotationalSpeed((microradianspersecond) * 1e-6d); } + /// + /// Get RotationalSpeed from MillidegreesPerSecond. + /// + public static RotationalSpeed FromMillidegreesPerSecond(double millidegreespersecond) + { + return new RotationalSpeed(((Math.PI/180)*millidegreespersecond) * 1e-3d); + } + /// /// Get RotationalSpeed from MilliradiansPerSecond. /// @@ -175,6 +215,14 @@ public static RotationalSpeed FromMilliradiansPerSecond(double milliradiansperse return new RotationalSpeed((milliradianspersecond) * 1e-3d); } + /// + /// Get RotationalSpeed from NanodegreesPerSecond. + /// + public static RotationalSpeed FromNanodegreesPerSecond(double nanodegreespersecond) + { + return new RotationalSpeed(((Math.PI/180)*nanodegreespersecond) * 1e-9d); + } + /// /// Get RotationalSpeed from NanoradiansPerSecond. /// @@ -224,10 +272,16 @@ public static RotationalSpeed From(double value, RotationalSpeedUnit fromUnit) return FromDeciradiansPerSecond(value); case RotationalSpeedUnit.DegreePerSecond: return FromDegreesPerSecond(value); + case RotationalSpeedUnit.MicrodegreePerSecond: + return FromMicrodegreesPerSecond(value); case RotationalSpeedUnit.MicroradianPerSecond: return FromMicroradiansPerSecond(value); + case RotationalSpeedUnit.MillidegreePerSecond: + return FromMillidegreesPerSecond(value); case RotationalSpeedUnit.MilliradianPerSecond: return FromMilliradiansPerSecond(value); + case RotationalSpeedUnit.NanodegreePerSecond: + return FromNanodegreesPerSecond(value); case RotationalSpeedUnit.NanoradianPerSecond: return FromNanoradiansPerSecond(value); case RotationalSpeedUnit.RadianPerSecond: @@ -375,10 +429,16 @@ public double As(RotationalSpeedUnit unit) return DeciradiansPerSecond; case RotationalSpeedUnit.DegreePerSecond: return DegreesPerSecond; + case RotationalSpeedUnit.MicrodegreePerSecond: + return MicrodegreesPerSecond; case RotationalSpeedUnit.MicroradianPerSecond: return MicroradiansPerSecond; + case RotationalSpeedUnit.MillidegreePerSecond: + return MillidegreesPerSecond; case RotationalSpeedUnit.MilliradianPerSecond: return MilliradiansPerSecond; + case RotationalSpeedUnit.NanodegreePerSecond: + return NanodegreesPerSecond; case RotationalSpeedUnit.NanoradianPerSecond: return NanoradiansPerSecond; case RotationalSpeedUnit.RadianPerSecond: diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 3d3a3befc0..76284c4a07 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1484,18 +1484,36 @@ private static readonly ReadOnlyCollection DefaultLocalization new AbbreviationsForCulture("en-US", "r/s"), new AbbreviationsForCulture("ru-RU", "°/с"), }), + new CulturesForEnumValue((int) RotationalSpeedUnit.MicrodegreePerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "μr/s"), + new AbbreviationsForCulture("ru-RU", "μ°/с"), + }), new CulturesForEnumValue((int) RotationalSpeedUnit.MicroradianPerSecond, new[] { new AbbreviationsForCulture("en-US", "μrad/s"), new AbbreviationsForCulture("ru-RU", "μрад/с"), }), + new CulturesForEnumValue((int) RotationalSpeedUnit.MillidegreePerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "mr/s"), + new AbbreviationsForCulture("ru-RU", "m°/с"), + }), new CulturesForEnumValue((int) RotationalSpeedUnit.MilliradianPerSecond, new[] { new AbbreviationsForCulture("en-US", "mrad/s"), new AbbreviationsForCulture("ru-RU", "mрад/с"), }), + new CulturesForEnumValue((int) RotationalSpeedUnit.NanodegreePerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "nr/s"), + new AbbreviationsForCulture("ru-RU", "n°/с"), + }), new CulturesForEnumValue((int) RotationalSpeedUnit.NanoradianPerSecond, new[] { diff --git a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json index 0ba928bdfe..51724caf93 100644 --- a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json +++ b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json @@ -20,22 +20,23 @@ } ] }, - { - "SingularName": "DegreePerSecond", - "PluralName": "DegreesPerSecond", - "FromUnitToBaseFunc": "(Math.PI/180)*x", - "FromBaseToUnitFunc": "(180/Math.PI)*x", - "Localization": [ - { - "Culture": "en-US", - "Abbreviations": [ "r/s" ] - }, - { - "Culture": "ru-RU", - "Abbreviations": [ "°/с" ] - } - ] - }, + { + "SingularName": "DegreePerSecond", + "PluralName": "DegreesPerSecond", + "FromUnitToBaseFunc": "(Math.PI/180)*x", + "FromBaseToUnitFunc": "(180/Math.PI)*x", + "Prefixes": [ "Nano", "Micro", "Milli" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "r/s" ] + }, + { + "Culture": "ru-RU", + "Abbreviations": [ "°/с" ] + } + ] + }, { "SingularName": "RevolutionPerSecond", "PluralName": "RevolutionsPerSecond", From 27a01f74ccab8b3e24d7a9fe1d57235fd08aa7ac Mon Sep 17 00:00:00 2001 From: tongbong Date: Tue, 1 Mar 2016 08:22:26 +0100 Subject: [PATCH 3/4] Fix abbreviation --- UnitsNet/GeneratedCode/UnitSystem.Default.g.cs | 8 ++++---- UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 76284c4a07..8e35a5d5a9 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1481,13 +1481,13 @@ private static readonly ReadOnlyCollection DefaultLocalization new CulturesForEnumValue((int) RotationalSpeedUnit.DegreePerSecond, new[] { - new AbbreviationsForCulture("en-US", "r/s"), + new AbbreviationsForCulture("en-US", "°/s", "deg/s"), new AbbreviationsForCulture("ru-RU", "°/с"), }), new CulturesForEnumValue((int) RotationalSpeedUnit.MicrodegreePerSecond, new[] { - new AbbreviationsForCulture("en-US", "μr/s"), + new AbbreviationsForCulture("en-US", "μ°/s"), new AbbreviationsForCulture("ru-RU", "μ°/с"), }), new CulturesForEnumValue((int) RotationalSpeedUnit.MicroradianPerSecond, @@ -1499,7 +1499,7 @@ private static readonly ReadOnlyCollection DefaultLocalization new CulturesForEnumValue((int) RotationalSpeedUnit.MillidegreePerSecond, new[] { - new AbbreviationsForCulture("en-US", "mr/s"), + new AbbreviationsForCulture("en-US", "m°/s"), new AbbreviationsForCulture("ru-RU", "m°/с"), }), new CulturesForEnumValue((int) RotationalSpeedUnit.MilliradianPerSecond, @@ -1511,7 +1511,7 @@ private static readonly ReadOnlyCollection DefaultLocalization new CulturesForEnumValue((int) RotationalSpeedUnit.NanodegreePerSecond, new[] { - new AbbreviationsForCulture("en-US", "nr/s"), + new AbbreviationsForCulture("en-US", "n°/s"), new AbbreviationsForCulture("ru-RU", "n°/с"), }), new CulturesForEnumValue((int) RotationalSpeedUnit.NanoradianPerSecond, diff --git a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json index 51724caf93..d44d69d9c7 100644 --- a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json +++ b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json @@ -29,7 +29,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "r/s" ] + "Abbreviations": [ "°/s", "deg/s" ] }, { "Culture": "ru-RU", From e6ba20a52b8475d37ed07a2c5785b998e9359b70 Mon Sep 17 00:00:00 2001 From: tongbong Date: Tue, 1 Mar 2016 08:34:30 +0100 Subject: [PATCH 4/4] Use hardcoded values instead of formulas --- UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs index 0bf59900a5..a43e25b135 100644 --- a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs +++ b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs @@ -38,17 +38,17 @@ public class RotationalSpeedTests : RotationalSpeedTestsBase protected override double NanoradiansPerSecondInOneRadianPerSecond => 1E9; - protected override double RevolutionsPerMinuteInOneRadianPerSecond => 60*1/(2*Math.PI); + protected override double RevolutionsPerMinuteInOneRadianPerSecond => 9.54929659; - protected override double RevolutionsPerSecondInOneRadianPerSecond => 1/(2*Math.PI); + protected override double RevolutionsPerSecondInOneRadianPerSecond => 0.15915494; - protected override double DegreesPerSecondInOneRadianPerSecond => (180 / Math.PI) * 1; + protected override double DegreesPerSecondInOneRadianPerSecond => 57.29577951308; - protected override double MillidegreesPerSecondInOneRadianPerSecond => ((180 / Math.PI) * 1)* 1E3; + protected override double MillidegreesPerSecondInOneRadianPerSecond => 57295.77951308; - protected override double MicrodegreesPerSecondInOneRadianPerSecond => ((180 / Math.PI) * 1) * 1E6; + protected override double MicrodegreesPerSecondInOneRadianPerSecond => 57295779.51308232; - protected override double NanodegreesPerSecondInOneRadianPerSecond => ((180 / Math.PI) * 1) * 1E9; + protected override double NanodegreesPerSecondInOneRadianPerSecond => 57295779513.08232087; [Test]