From d82d7466dd117818935f01b49c657876873425a2 Mon Sep 17 00:00:00 2001 From: tongbong Date: Thu, 21 Jan 2016 12:31:11 +0100 Subject: [PATCH 1/4] Add prefixes RadianPerSecond Tests do not pass --- .../CustomCode/RotationalSpeedTests.cs | 30 +++++- .../RotationalSpeedTestsBase.g.cs | 30 ++++++ .../Enums/RotationalSpeedUnit.g.cs | 5 + .../UnitClasses/RotationalSpeed.g.cs | 100 ++++++++++++++++++ .../GeneratedCode/UnitSystem.Default.g.cs | 25 +++++ .../UnitDefinitions/RotationalSpeed.json | 25 ++--- 6 files changed, 199 insertions(+), 16 deletions(-) diff --git a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs index 9d0e934f83..2392eee8e7 100644 --- a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs +++ b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs @@ -25,12 +25,34 @@ namespace UnitsNet.Tests.CustomCode { public class RotationalSpeedTests : RotationalSpeedTestsBase { + protected override double RadiansPerSecondInOneRevolutionPerSecond { - get - { - return 2 * Math.PI; - } + get { return 2 * Math.PI; } + } + protected override double DeciradiansPerSecondInOneRevolutionPerSecond + { + get { return 2 * Math.PI * 1E1; } + } + + protected override double CentiradiansPerSecondInOneRevolutionPerSecond + { + get { return 2 * Math.PI * 1E2; } + } + + protected override double MilliradiansPerSecondInOneRevolutionPerSecond + { + get { return 2 * Math.PI * 1E3; } + } + + protected override double MicroradiansPerSecondInOneRevolutionPerSecond + { + get { return 2 * Math.PI * 1E6; } + } + + protected override double NanoradiansPerSecondInOneRevolutionPerSecond + { + get { return 2 * Math.PI * 1E9; } } protected override double RevolutionsPerMinuteInOneRevolutionPerSecond diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index c19e55c6aa..222af96ff4 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -36,11 +36,21 @@ namespace UnitsNet.Tests // ReSharper disable once PartialTypeWithSinglePart public abstract partial class RotationalSpeedTestsBase { + protected abstract double CentiradiansPerSecondInOneRevolutionPerSecond { get; } + protected abstract double DeciradiansPerSecondInOneRevolutionPerSecond { get; } + protected abstract double MicroradiansPerSecondInOneRevolutionPerSecond { get; } + protected abstract double MilliradiansPerSecondInOneRevolutionPerSecond { get; } + protected abstract double NanoradiansPerSecondInOneRevolutionPerSecond { get; } protected abstract double RadiansPerSecondInOneRevolutionPerSecond { get; } protected abstract double RevolutionsPerMinuteInOneRevolutionPerSecond { get; } protected abstract double RevolutionsPerSecondInOneRevolutionPerSecond { get; } // ReSharper disable VirtualMemberNeverOverriden.Global + protected virtual double CentiradiansPerSecondTolerance { get { return 1e-5; } } + protected virtual double DeciradiansPerSecondTolerance { 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; } } protected virtual double RadiansPerSecondTolerance { get { return 1e-5; } } protected virtual double RevolutionsPerMinuteTolerance { get { return 1e-5; } } protected virtual double RevolutionsPerSecondTolerance { get { return 1e-5; } } @@ -50,6 +60,11 @@ public abstract partial class RotationalSpeedTestsBase public void RevolutionPerSecondToRotationalSpeedUnits() { RotationalSpeed revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1); + Assert.AreEqual(CentiradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.CentiradiansPerSecond, CentiradiansPerSecondTolerance); + Assert.AreEqual(DeciradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.DeciradiansPerSecond, DeciradiansPerSecondTolerance); + Assert.AreEqual(MicroradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.MicroradiansPerSecond, MicroradiansPerSecondTolerance); + Assert.AreEqual(MilliradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.MilliradiansPerSecond, MilliradiansPerSecondTolerance); + Assert.AreEqual(NanoradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.NanoradiansPerSecond, NanoradiansPerSecondTolerance); Assert.AreEqual(RadiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.RadiansPerSecond, RadiansPerSecondTolerance); Assert.AreEqual(RevolutionsPerMinuteInOneRevolutionPerSecond, revolutionpersecond.RevolutionsPerMinute, RevolutionsPerMinuteTolerance); Assert.AreEqual(RevolutionsPerSecondInOneRevolutionPerSecond, revolutionpersecond.RevolutionsPerSecond, RevolutionsPerSecondTolerance); @@ -58,6 +73,11 @@ public void RevolutionPerSecondToRotationalSpeedUnits() [Test] 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.MicroradianPerSecond).MicroradiansPerSecond, MicroradiansPerSecondTolerance); + Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.MilliradianPerSecond).MilliradiansPerSecond, MilliradiansPerSecondTolerance); + 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); Assert.AreEqual(1, RotationalSpeed.From(1, RotationalSpeedUnit.RevolutionPerSecond).RevolutionsPerSecond, RevolutionsPerSecondTolerance); @@ -67,6 +87,11 @@ public void FromValueAndUnit() public void As() { var revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1); + Assert.AreEqual(CentiradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.CentiradianPerSecond), CentiradiansPerSecondTolerance); + Assert.AreEqual(DeciradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.DeciradianPerSecond), DeciradiansPerSecondTolerance); + Assert.AreEqual(MicroradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.MicroradianPerSecond), MicroradiansPerSecondTolerance); + Assert.AreEqual(MilliradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.MilliradianPerSecond), MilliradiansPerSecondTolerance); + Assert.AreEqual(NanoradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.NanoradianPerSecond), NanoradiansPerSecondTolerance); Assert.AreEqual(RadiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.RadianPerSecond), RadiansPerSecondTolerance); Assert.AreEqual(RevolutionsPerMinuteInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.RevolutionPerMinute), RevolutionsPerMinuteTolerance); Assert.AreEqual(RevolutionsPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.RevolutionPerSecond), RevolutionsPerSecondTolerance); @@ -76,6 +101,11 @@ public void As() public void ConversionRoundTrip() { RotationalSpeed revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1); + Assert.AreEqual(1, RotationalSpeed.FromCentiradiansPerSecond(revolutionpersecond.CentiradiansPerSecond).RevolutionsPerSecond, CentiradiansPerSecondTolerance); + Assert.AreEqual(1, RotationalSpeed.FromDeciradiansPerSecond(revolutionpersecond.DeciradiansPerSecond).RevolutionsPerSecond, DeciradiansPerSecondTolerance); + Assert.AreEqual(1, RotationalSpeed.FromMicroradiansPerSecond(revolutionpersecond.MicroradiansPerSecond).RevolutionsPerSecond, MicroradiansPerSecondTolerance); + Assert.AreEqual(1, RotationalSpeed.FromMilliradiansPerSecond(revolutionpersecond.MilliradiansPerSecond).RevolutionsPerSecond, MilliradiansPerSecondTolerance); + Assert.AreEqual(1, RotationalSpeed.FromNanoradiansPerSecond(revolutionpersecond.NanoradiansPerSecond).RevolutionsPerSecond, NanoradiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.FromRadiansPerSecond(revolutionpersecond.RadiansPerSecond).RevolutionsPerSecond, RadiansPerSecondTolerance); Assert.AreEqual(1, RotationalSpeed.FromRevolutionsPerMinute(revolutionpersecond.RevolutionsPerMinute).RevolutionsPerSecond, RevolutionsPerMinuteTolerance); Assert.AreEqual(1, RotationalSpeed.FromRevolutionsPerSecond(revolutionpersecond.RevolutionsPerSecond).RevolutionsPerSecond, RevolutionsPerSecondTolerance); diff --git a/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs b/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs index 7f17328fd8..269ad35b9f 100644 --- a/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs +++ b/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs @@ -25,6 +25,11 @@ namespace UnitsNet.Units public enum RotationalSpeedUnit { Undefined = 0, + CentiradianPerSecond, + DeciradianPerSecond, + MicroradianPerSecond, + MilliradianPerSecond, + NanoradianPerSecond, RadianPerSecond, RevolutionPerMinute, RevolutionPerSecond, diff --git a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs index 1685378504..39628aba33 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs @@ -54,6 +54,46 @@ public static RotationalSpeedUnit BaseUnit get { return RotationalSpeedUnit.RevolutionPerSecond; } } + /// + /// Get RotationalSpeed in CentiradiansPerSecond. + /// + public double CentiradiansPerSecond + { + get { return (_revolutionsPerSecond*6.2831853072) / 1e-2d; } + } + + /// + /// Get RotationalSpeed in DeciradiansPerSecond. + /// + public double DeciradiansPerSecond + { + get { return (_revolutionsPerSecond*6.2831853072) / 1e-1d; } + } + + /// + /// Get RotationalSpeed in MicroradiansPerSecond. + /// + public double MicroradiansPerSecond + { + get { return (_revolutionsPerSecond*6.2831853072) / 1e-6d; } + } + + /// + /// Get RotationalSpeed in MilliradiansPerSecond. + /// + public double MilliradiansPerSecond + { + get { return (_revolutionsPerSecond*6.2831853072) / 1e-3d; } + } + + /// + /// Get RotationalSpeed in NanoradiansPerSecond. + /// + public double NanoradiansPerSecond + { + get { return (_revolutionsPerSecond*6.2831853072) / 1e-9d; } + } + /// /// Get RotationalSpeed in RadiansPerSecond. /// @@ -87,6 +127,46 @@ public static RotationalSpeed Zero get { return new RotationalSpeed(); } } + /// + /// Get RotationalSpeed from CentiradiansPerSecond. + /// + public static RotationalSpeed FromCentiradiansPerSecond(double centiradianspersecond) + { + return new RotationalSpeed((centiradianspersecond/6.2831853072) * 1e-2d); + } + + /// + /// Get RotationalSpeed from DeciradiansPerSecond. + /// + public static RotationalSpeed FromDeciradiansPerSecond(double deciradianspersecond) + { + return new RotationalSpeed((deciradianspersecond/6.2831853072) * 1e-1d); + } + + /// + /// Get RotationalSpeed from MicroradiansPerSecond. + /// + public static RotationalSpeed FromMicroradiansPerSecond(double microradianspersecond) + { + return new RotationalSpeed((microradianspersecond/6.2831853072) * 1e-6d); + } + + /// + /// Get RotationalSpeed from MilliradiansPerSecond. + /// + public static RotationalSpeed FromMilliradiansPerSecond(double milliradianspersecond) + { + return new RotationalSpeed((milliradianspersecond/6.2831853072) * 1e-3d); + } + + /// + /// Get RotationalSpeed from NanoradiansPerSecond. + /// + public static RotationalSpeed FromNanoradiansPerSecond(double nanoradianspersecond) + { + return new RotationalSpeed((nanoradianspersecond/6.2831853072) * 1e-9d); + } + /// /// Get RotationalSpeed from RadiansPerSecond. /// @@ -122,6 +202,16 @@ public static RotationalSpeed From(double value, RotationalSpeedUnit fromUnit) { switch (fromUnit) { + case RotationalSpeedUnit.CentiradianPerSecond: + return FromCentiradiansPerSecond(value); + case RotationalSpeedUnit.DeciradianPerSecond: + return FromDeciradiansPerSecond(value); + case RotationalSpeedUnit.MicroradianPerSecond: + return FromMicroradiansPerSecond(value); + case RotationalSpeedUnit.MilliradianPerSecond: + return FromMilliradiansPerSecond(value); + case RotationalSpeedUnit.NanoradianPerSecond: + return FromNanoradiansPerSecond(value); case RotationalSpeedUnit.RadianPerSecond: return FromRadiansPerSecond(value); case RotationalSpeedUnit.RevolutionPerMinute: @@ -261,6 +351,16 @@ public double As(RotationalSpeedUnit unit) { switch (unit) { + case RotationalSpeedUnit.CentiradianPerSecond: + return CentiradiansPerSecond; + case RotationalSpeedUnit.DeciradianPerSecond: + return DeciradiansPerSecond; + case RotationalSpeedUnit.MicroradianPerSecond: + return MicroradiansPerSecond; + case RotationalSpeedUnit.MilliradianPerSecond: + return MilliradiansPerSecond; + case RotationalSpeedUnit.NanoradianPerSecond: + return NanoradiansPerSecond; case RotationalSpeedUnit.RadianPerSecond: return RadiansPerSecond; case RotationalSpeedUnit.RevolutionPerMinute: diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 84de974690..9678cea033 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1352,6 +1352,31 @@ private static readonly ReadOnlyCollection DefaultLocalization new UnitLocalization(typeof (RotationalSpeedUnit), new[] { + new CulturesForEnumValue((int) RotationalSpeedUnit.CentiradianPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "crad/s"), + }), + new CulturesForEnumValue((int) RotationalSpeedUnit.DeciradianPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "drad/s"), + }), + new CulturesForEnumValue((int) RotationalSpeedUnit.MicroradianPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "μrad/s"), + }), + new CulturesForEnumValue((int) RotationalSpeedUnit.MilliradianPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "mrad/s"), + }), + new CulturesForEnumValue((int) RotationalSpeedUnit.NanoradianPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "nrad/s"), + }), new CulturesForEnumValue((int) RotationalSpeedUnit.RadianPerSecond, new[] { diff --git a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json index 060d65c34c..baebb8536d 100644 --- a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json +++ b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json @@ -19,18 +19,19 @@ } ] }, - { - "SingularName": "RadianPerSecond", - "PluralName": "RadiansPerSecond", - "FromUnitToBaseFunc": "x/6.2831853072", - "FromBaseToUnitFunc": "x*6.2831853072", - "Localization": [ - { - "Culture": "en-US", - "Abbreviations": ["rad/s"] - } - ] - }, + { + "SingularName": "RadianPerSecond", + "PluralName": "RadiansPerSecond", + "FromUnitToBaseFunc": "x/6.2831853072", + "FromBaseToUnitFunc": "x*6.2831853072", + "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "rad/s" ] + } + ] + }, { "SingularName": "RevolutionPerMinute", "PluralName": "RevolutionsPerMinute", From ea9cb18089038e6be8f84cf04d1010cb857c7cee Mon Sep 17 00:00:00 2001 From: tongbong Date: Thu, 21 Jan 2016 14:15:27 +0100 Subject: [PATCH 2/4] More units for rotational speed Change base unit to radian per second because of loss of precision (tests were red). Add prefixes for radian per second. --- .../CustomCode/RotationalSpeedTests.cs | 33 ++-- .../RotationalSpeedTestsBase.g.cs | 144 +++++++++--------- .../UnitClasses/RotationalSpeed.g.cs | 74 ++++----- .../UnitDefinitions/RotationalSpeed.json | 94 ++++++------ 4 files changed, 173 insertions(+), 172 deletions(-) diff --git a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs index 2392eee8e7..3fd2d844d5 100644 --- a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs +++ b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs @@ -26,43 +26,44 @@ namespace UnitsNet.Tests.CustomCode public class RotationalSpeedTests : RotationalSpeedTestsBase { - protected override double RadiansPerSecondInOneRevolutionPerSecond + protected override double RadiansPerSecondInOneRadianPerSecond { - get { return 2 * Math.PI; } + get { return 1; } } - protected override double DeciradiansPerSecondInOneRevolutionPerSecond + + protected override double DeciradiansPerSecondInOneRadianPerSecond { - get { return 2 * Math.PI * 1E1; } + get { return 1E1; } } - protected override double CentiradiansPerSecondInOneRevolutionPerSecond + protected override double CentiradiansPerSecondInOneRadianPerSecond { - get { return 2 * Math.PI * 1E2; } + get { return 1E2; } } - protected override double MilliradiansPerSecondInOneRevolutionPerSecond + protected override double MilliradiansPerSecondInOneRadianPerSecond { - get { return 2 * Math.PI * 1E3; } + get { return 1E3; } } - protected override double MicroradiansPerSecondInOneRevolutionPerSecond + protected override double MicroradiansPerSecondInOneRadianPerSecond { - get { return 2 * Math.PI * 1E6; } + get { return 1E6; } } - protected override double NanoradiansPerSecondInOneRevolutionPerSecond + protected override double NanoradiansPerSecondInOneRadianPerSecond { - get { return 2 * Math.PI * 1E9; } + get { return 1E9; } } - protected override double RevolutionsPerMinuteInOneRevolutionPerSecond + protected override double RevolutionsPerMinuteInOneRadianPerSecond { - get { return 1.0*60; } + get { return (60*1) / (2 * Math.PI); } } - protected override double RevolutionsPerSecondInOneRevolutionPerSecond + protected override double RevolutionsPerSecondInOneRadianPerSecond { - get { return 1; } + get { return 1/(2*Math.PI); } } } } \ No newline at end of file diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index 222af96ff4..4cb6aa1448 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -36,14 +36,14 @@ namespace UnitsNet.Tests // ReSharper disable once PartialTypeWithSinglePart public abstract partial class RotationalSpeedTestsBase { - protected abstract double CentiradiansPerSecondInOneRevolutionPerSecond { get; } - protected abstract double DeciradiansPerSecondInOneRevolutionPerSecond { get; } - protected abstract double MicroradiansPerSecondInOneRevolutionPerSecond { get; } - protected abstract double MilliradiansPerSecondInOneRevolutionPerSecond { get; } - protected abstract double NanoradiansPerSecondInOneRevolutionPerSecond { get; } - protected abstract double RadiansPerSecondInOneRevolutionPerSecond { get; } - protected abstract double RevolutionsPerMinuteInOneRevolutionPerSecond { get; } - protected abstract double RevolutionsPerSecondInOneRevolutionPerSecond { get; } + protected abstract double CentiradiansPerSecondInOneRadianPerSecond { get; } + protected abstract double DeciradiansPerSecondInOneRadianPerSecond { get; } + protected abstract double MicroradiansPerSecondInOneRadianPerSecond { get; } + protected abstract double MilliradiansPerSecondInOneRadianPerSecond { get; } + protected abstract double NanoradiansPerSecondInOneRadianPerSecond { get; } + protected abstract double RadiansPerSecondInOneRadianPerSecond { get; } + protected abstract double RevolutionsPerMinuteInOneRadianPerSecond { get; } + protected abstract double RevolutionsPerSecondInOneRadianPerSecond { get; } // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double CentiradiansPerSecondTolerance { get { return 1e-5; } } @@ -57,17 +57,17 @@ public abstract partial class RotationalSpeedTestsBase // ReSharper restore VirtualMemberNeverOverriden.Global [Test] - public void RevolutionPerSecondToRotationalSpeedUnits() + public void RadianPerSecondToRotationalSpeedUnits() { - RotationalSpeed revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1); - Assert.AreEqual(CentiradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.CentiradiansPerSecond, CentiradiansPerSecondTolerance); - Assert.AreEqual(DeciradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.DeciradiansPerSecond, DeciradiansPerSecondTolerance); - Assert.AreEqual(MicroradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.MicroradiansPerSecond, MicroradiansPerSecondTolerance); - Assert.AreEqual(MilliradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.MilliradiansPerSecond, MilliradiansPerSecondTolerance); - Assert.AreEqual(NanoradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.NanoradiansPerSecond, NanoradiansPerSecondTolerance); - Assert.AreEqual(RadiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.RadiansPerSecond, RadiansPerSecondTolerance); - Assert.AreEqual(RevolutionsPerMinuteInOneRevolutionPerSecond, revolutionpersecond.RevolutionsPerMinute, RevolutionsPerMinuteTolerance); - Assert.AreEqual(RevolutionsPerSecondInOneRevolutionPerSecond, revolutionpersecond.RevolutionsPerSecond, RevolutionsPerSecondTolerance); + RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); + Assert.AreEqual(CentiradiansPerSecondInOneRadianPerSecond, radianpersecond.CentiradiansPerSecond, CentiradiansPerSecondTolerance); + Assert.AreEqual(DeciradiansPerSecondInOneRadianPerSecond, radianpersecond.DeciradiansPerSecond, DeciradiansPerSecondTolerance); + Assert.AreEqual(MicroradiansPerSecondInOneRadianPerSecond, radianpersecond.MicroradiansPerSecond, MicroradiansPerSecondTolerance); + Assert.AreEqual(MilliradiansPerSecondInOneRadianPerSecond, radianpersecond.MilliradiansPerSecond, MilliradiansPerSecondTolerance); + Assert.AreEqual(NanoradiansPerSecondInOneRadianPerSecond, radianpersecond.NanoradiansPerSecond, NanoradiansPerSecondTolerance); + Assert.AreEqual(RadiansPerSecondInOneRadianPerSecond, radianpersecond.RadiansPerSecond, RadiansPerSecondTolerance); + Assert.AreEqual(RevolutionsPerMinuteInOneRadianPerSecond, radianpersecond.RevolutionsPerMinute, RevolutionsPerMinuteTolerance); + Assert.AreEqual(RevolutionsPerSecondInOneRadianPerSecond, radianpersecond.RevolutionsPerSecond, RevolutionsPerSecondTolerance); } [Test] @@ -86,94 +86,94 @@ public void FromValueAndUnit() [Test] public void As() { - var revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1); - Assert.AreEqual(CentiradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.CentiradianPerSecond), CentiradiansPerSecondTolerance); - Assert.AreEqual(DeciradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.DeciradianPerSecond), DeciradiansPerSecondTolerance); - Assert.AreEqual(MicroradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.MicroradianPerSecond), MicroradiansPerSecondTolerance); - Assert.AreEqual(MilliradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.MilliradianPerSecond), MilliradiansPerSecondTolerance); - Assert.AreEqual(NanoradiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.NanoradianPerSecond), NanoradiansPerSecondTolerance); - Assert.AreEqual(RadiansPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.RadianPerSecond), RadiansPerSecondTolerance); - Assert.AreEqual(RevolutionsPerMinuteInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.RevolutionPerMinute), RevolutionsPerMinuteTolerance); - Assert.AreEqual(RevolutionsPerSecondInOneRevolutionPerSecond, revolutionpersecond.As(RotationalSpeedUnit.RevolutionPerSecond), RevolutionsPerSecondTolerance); + var radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); + Assert.AreEqual(CentiradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.CentiradianPerSecond), CentiradiansPerSecondTolerance); + Assert.AreEqual(DeciradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.DeciradianPerSecond), DeciradiansPerSecondTolerance); + Assert.AreEqual(MicroradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.MicroradianPerSecond), MicroradiansPerSecondTolerance); + Assert.AreEqual(MilliradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.MilliradianPerSecond), MilliradiansPerSecondTolerance); + Assert.AreEqual(NanoradiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.NanoradianPerSecond), NanoradiansPerSecondTolerance); + Assert.AreEqual(RadiansPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.RadianPerSecond), RadiansPerSecondTolerance); + Assert.AreEqual(RevolutionsPerMinuteInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.RevolutionPerMinute), RevolutionsPerMinuteTolerance); + Assert.AreEqual(RevolutionsPerSecondInOneRadianPerSecond, radianpersecond.As(RotationalSpeedUnit.RevolutionPerSecond), RevolutionsPerSecondTolerance); } [Test] public void ConversionRoundTrip() { - RotationalSpeed revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1); - Assert.AreEqual(1, RotationalSpeed.FromCentiradiansPerSecond(revolutionpersecond.CentiradiansPerSecond).RevolutionsPerSecond, CentiradiansPerSecondTolerance); - Assert.AreEqual(1, RotationalSpeed.FromDeciradiansPerSecond(revolutionpersecond.DeciradiansPerSecond).RevolutionsPerSecond, DeciradiansPerSecondTolerance); - Assert.AreEqual(1, RotationalSpeed.FromMicroradiansPerSecond(revolutionpersecond.MicroradiansPerSecond).RevolutionsPerSecond, MicroradiansPerSecondTolerance); - Assert.AreEqual(1, RotationalSpeed.FromMilliradiansPerSecond(revolutionpersecond.MilliradiansPerSecond).RevolutionsPerSecond, MilliradiansPerSecondTolerance); - Assert.AreEqual(1, RotationalSpeed.FromNanoradiansPerSecond(revolutionpersecond.NanoradiansPerSecond).RevolutionsPerSecond, NanoradiansPerSecondTolerance); - Assert.AreEqual(1, RotationalSpeed.FromRadiansPerSecond(revolutionpersecond.RadiansPerSecond).RevolutionsPerSecond, RadiansPerSecondTolerance); - Assert.AreEqual(1, RotationalSpeed.FromRevolutionsPerMinute(revolutionpersecond.RevolutionsPerMinute).RevolutionsPerSecond, RevolutionsPerMinuteTolerance); - Assert.AreEqual(1, RotationalSpeed.FromRevolutionsPerSecond(revolutionpersecond.RevolutionsPerSecond).RevolutionsPerSecond, RevolutionsPerSecondTolerance); + 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.FromMicroradiansPerSecond(radianpersecond.MicroradiansPerSecond).RadiansPerSecond, MicroradiansPerSecondTolerance); + Assert.AreEqual(1, RotationalSpeed.FromMilliradiansPerSecond(radianpersecond.MilliradiansPerSecond).RadiansPerSecond, MilliradiansPerSecondTolerance); + 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); + Assert.AreEqual(1, RotationalSpeed.FromRevolutionsPerSecond(radianpersecond.RevolutionsPerSecond).RadiansPerSecond, RevolutionsPerSecondTolerance); } [Test] public void ArithmeticOperators() { - RotationalSpeed v = RotationalSpeed.FromRevolutionsPerSecond(1); - Assert.AreEqual(-1, -v.RevolutionsPerSecond, RevolutionsPerSecondTolerance); - Assert.AreEqual(2, (RotationalSpeed.FromRevolutionsPerSecond(3)-v).RevolutionsPerSecond, RevolutionsPerSecondTolerance); - Assert.AreEqual(2, (v + v).RevolutionsPerSecond, RevolutionsPerSecondTolerance); - Assert.AreEqual(10, (v*10).RevolutionsPerSecond, RevolutionsPerSecondTolerance); - Assert.AreEqual(10, (10*v).RevolutionsPerSecond, RevolutionsPerSecondTolerance); - Assert.AreEqual(2, (RotationalSpeed.FromRevolutionsPerSecond(10)/5).RevolutionsPerSecond, RevolutionsPerSecondTolerance); - Assert.AreEqual(2, RotationalSpeed.FromRevolutionsPerSecond(10)/RotationalSpeed.FromRevolutionsPerSecond(5), RevolutionsPerSecondTolerance); + RotationalSpeed v = RotationalSpeed.FromRadiansPerSecond(1); + Assert.AreEqual(-1, -v.RadiansPerSecond, RadiansPerSecondTolerance); + Assert.AreEqual(2, (RotationalSpeed.FromRadiansPerSecond(3)-v).RadiansPerSecond, RadiansPerSecondTolerance); + Assert.AreEqual(2, (v + v).RadiansPerSecond, RadiansPerSecondTolerance); + Assert.AreEqual(10, (v*10).RadiansPerSecond, RadiansPerSecondTolerance); + Assert.AreEqual(10, (10*v).RadiansPerSecond, RadiansPerSecondTolerance); + Assert.AreEqual(2, (RotationalSpeed.FromRadiansPerSecond(10)/5).RadiansPerSecond, RadiansPerSecondTolerance); + Assert.AreEqual(2, RotationalSpeed.FromRadiansPerSecond(10)/RotationalSpeed.FromRadiansPerSecond(5), RadiansPerSecondTolerance); } [Test] public void ComparisonOperators() { - RotationalSpeed oneRevolutionPerSecond = RotationalSpeed.FromRevolutionsPerSecond(1); - RotationalSpeed twoRevolutionsPerSecond = RotationalSpeed.FromRevolutionsPerSecond(2); - - Assert.True(oneRevolutionPerSecond < twoRevolutionsPerSecond); - Assert.True(oneRevolutionPerSecond <= twoRevolutionsPerSecond); - Assert.True(twoRevolutionsPerSecond > oneRevolutionPerSecond); - Assert.True(twoRevolutionsPerSecond >= oneRevolutionPerSecond); - - Assert.False(oneRevolutionPerSecond > twoRevolutionsPerSecond); - Assert.False(oneRevolutionPerSecond >= twoRevolutionsPerSecond); - Assert.False(twoRevolutionsPerSecond < oneRevolutionPerSecond); - Assert.False(twoRevolutionsPerSecond <= oneRevolutionPerSecond); + RotationalSpeed oneRadianPerSecond = RotationalSpeed.FromRadiansPerSecond(1); + RotationalSpeed twoRadiansPerSecond = RotationalSpeed.FromRadiansPerSecond(2); + + Assert.True(oneRadianPerSecond < twoRadiansPerSecond); + Assert.True(oneRadianPerSecond <= twoRadiansPerSecond); + Assert.True(twoRadiansPerSecond > oneRadianPerSecond); + Assert.True(twoRadiansPerSecond >= oneRadianPerSecond); + + Assert.False(oneRadianPerSecond > twoRadiansPerSecond); + Assert.False(oneRadianPerSecond >= twoRadiansPerSecond); + Assert.False(twoRadiansPerSecond < oneRadianPerSecond); + Assert.False(twoRadiansPerSecond <= oneRadianPerSecond); } [Test] public void CompareToIsImplemented() { - RotationalSpeed revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1); - Assert.AreEqual(0, revolutionpersecond.CompareTo(revolutionpersecond)); - Assert.Greater(revolutionpersecond.CompareTo(RotationalSpeed.Zero), 0); - Assert.Less(RotationalSpeed.Zero.CompareTo(revolutionpersecond), 0); + RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); + Assert.AreEqual(0, radianpersecond.CompareTo(radianpersecond)); + Assert.Greater(radianpersecond.CompareTo(RotationalSpeed.Zero), 0); + Assert.Less(RotationalSpeed.Zero.CompareTo(radianpersecond), 0); } [Test] [ExpectedException(typeof(ArgumentException))] public void CompareToThrowsOnTypeMismatch() { - RotationalSpeed revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1); + RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); // ReSharper disable once ReturnValueOfPureMethodIsNotUsed - revolutionpersecond.CompareTo(new object()); + radianpersecond.CompareTo(new object()); } [Test] [ExpectedException(typeof(ArgumentNullException))] public void CompareToThrowsOnNull() { - RotationalSpeed revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1); + RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); // ReSharper disable once ReturnValueOfPureMethodIsNotUsed - revolutionpersecond.CompareTo(null); + radianpersecond.CompareTo(null); } [Test] public void EqualityOperators() { - RotationalSpeed a = RotationalSpeed.FromRevolutionsPerSecond(1); - RotationalSpeed b = RotationalSpeed.FromRevolutionsPerSecond(2); + RotationalSpeed a = RotationalSpeed.FromRadiansPerSecond(1); + RotationalSpeed b = RotationalSpeed.FromRadiansPerSecond(2); // ReSharper disable EqualExpressionComparison Assert.True(a == a); @@ -187,23 +187,23 @@ public void EqualityOperators() [Test] public void EqualsIsImplemented() { - RotationalSpeed v = RotationalSpeed.FromRevolutionsPerSecond(1); - Assert.IsTrue(v.Equals(RotationalSpeed.FromRevolutionsPerSecond(1))); + RotationalSpeed v = RotationalSpeed.FromRadiansPerSecond(1); + Assert.IsTrue(v.Equals(RotationalSpeed.FromRadiansPerSecond(1))); Assert.IsFalse(v.Equals(RotationalSpeed.Zero)); } [Test] public void EqualsReturnsFalseOnTypeMismatch() { - RotationalSpeed revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1); - Assert.IsFalse(revolutionpersecond.Equals(new object())); + RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); + Assert.IsFalse(radianpersecond.Equals(new object())); } [Test] public void EqualsReturnsFalseOnNull() { - RotationalSpeed revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1); - Assert.IsFalse(revolutionpersecond.Equals(null)); + RotationalSpeed radianpersecond = RotationalSpeed.FromRadiansPerSecond(1); + Assert.IsFalse(radianpersecond.Equals(null)); } } } diff --git a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs index 39628aba33..a676beacda 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs @@ -40,18 +40,18 @@ public partial struct RotationalSpeed : IComparable, IComparable /// Base unit of RotationalSpeed. /// - private readonly double _revolutionsPerSecond; + private readonly double _radiansPerSecond; - public RotationalSpeed(double revolutionspersecond) : this() + public RotationalSpeed(double radianspersecond) : this() { - _revolutionsPerSecond = revolutionspersecond; + _radiansPerSecond = radianspersecond; } #region Properties public static RotationalSpeedUnit BaseUnit { - get { return RotationalSpeedUnit.RevolutionPerSecond; } + get { return RotationalSpeedUnit.RadianPerSecond; } } /// @@ -59,7 +59,7 @@ public static RotationalSpeedUnit BaseUnit /// public double CentiradiansPerSecond { - get { return (_revolutionsPerSecond*6.2831853072) / 1e-2d; } + get { return (_radiansPerSecond) / 1e-2d; } } /// @@ -67,7 +67,7 @@ public double CentiradiansPerSecond /// public double DeciradiansPerSecond { - get { return (_revolutionsPerSecond*6.2831853072) / 1e-1d; } + get { return (_radiansPerSecond) / 1e-1d; } } /// @@ -75,7 +75,7 @@ public double DeciradiansPerSecond /// public double MicroradiansPerSecond { - get { return (_revolutionsPerSecond*6.2831853072) / 1e-6d; } + get { return (_radiansPerSecond) / 1e-6d; } } /// @@ -83,7 +83,7 @@ public double MicroradiansPerSecond /// public double MilliradiansPerSecond { - get { return (_revolutionsPerSecond*6.2831853072) / 1e-3d; } + get { return (_radiansPerSecond) / 1e-3d; } } /// @@ -91,7 +91,7 @@ public double MilliradiansPerSecond /// public double NanoradiansPerSecond { - get { return (_revolutionsPerSecond*6.2831853072) / 1e-9d; } + get { return (_radiansPerSecond) / 1e-9d; } } /// @@ -99,7 +99,7 @@ public double NanoradiansPerSecond /// public double RadiansPerSecond { - get { return _revolutionsPerSecond*6.2831853072; } + get { return _radiansPerSecond; } } /// @@ -107,7 +107,7 @@ public double RadiansPerSecond /// public double RevolutionsPerMinute { - get { return _revolutionsPerSecond*60; } + get { return (_radiansPerSecond/6.2831853072)*60; } } /// @@ -115,7 +115,7 @@ public double RevolutionsPerMinute /// public double RevolutionsPerSecond { - get { return _revolutionsPerSecond; } + get { return _radiansPerSecond/6.2831853072; } } #endregion @@ -132,7 +132,7 @@ public static RotationalSpeed Zero /// public static RotationalSpeed FromCentiradiansPerSecond(double centiradianspersecond) { - return new RotationalSpeed((centiradianspersecond/6.2831853072) * 1e-2d); + return new RotationalSpeed((centiradianspersecond) * 1e-2d); } /// @@ -140,7 +140,7 @@ public static RotationalSpeed FromCentiradiansPerSecond(double centiradiansperse /// public static RotationalSpeed FromDeciradiansPerSecond(double deciradianspersecond) { - return new RotationalSpeed((deciradianspersecond/6.2831853072) * 1e-1d); + return new RotationalSpeed((deciradianspersecond) * 1e-1d); } /// @@ -148,7 +148,7 @@ public static RotationalSpeed FromDeciradiansPerSecond(double deciradiansperseco /// public static RotationalSpeed FromMicroradiansPerSecond(double microradianspersecond) { - return new RotationalSpeed((microradianspersecond/6.2831853072) * 1e-6d); + return new RotationalSpeed((microradianspersecond) * 1e-6d); } /// @@ -156,7 +156,7 @@ public static RotationalSpeed FromMicroradiansPerSecond(double microradiansperse /// public static RotationalSpeed FromMilliradiansPerSecond(double milliradianspersecond) { - return new RotationalSpeed((milliradianspersecond/6.2831853072) * 1e-3d); + return new RotationalSpeed((milliradianspersecond) * 1e-3d); } /// @@ -164,7 +164,7 @@ public static RotationalSpeed FromMilliradiansPerSecond(double milliradiansperse /// public static RotationalSpeed FromNanoradiansPerSecond(double nanoradianspersecond) { - return new RotationalSpeed((nanoradianspersecond/6.2831853072) * 1e-9d); + return new RotationalSpeed((nanoradianspersecond) * 1e-9d); } /// @@ -172,7 +172,7 @@ public static RotationalSpeed FromNanoradiansPerSecond(double nanoradiansperseco /// public static RotationalSpeed FromRadiansPerSecond(double radianspersecond) { - return new RotationalSpeed(radianspersecond/6.2831853072); + return new RotationalSpeed(radianspersecond); } /// @@ -180,7 +180,7 @@ public static RotationalSpeed FromRadiansPerSecond(double radianspersecond) /// public static RotationalSpeed FromRevolutionsPerMinute(double revolutionsperminute) { - return new RotationalSpeed(revolutionsperminute/60); + return new RotationalSpeed((revolutionsperminute*6.2831853072)/60); } /// @@ -188,7 +188,7 @@ public static RotationalSpeed FromRevolutionsPerMinute(double revolutionsperminu /// public static RotationalSpeed FromRevolutionsPerSecond(double revolutionspersecond) { - return new RotationalSpeed(revolutionspersecond); + return new RotationalSpeed(revolutionspersecond*6.2831853072); } @@ -242,37 +242,37 @@ public static string GetAbbreviation(RotationalSpeedUnit unit, CultureInfo cultu public static RotationalSpeed operator -(RotationalSpeed right) { - return new RotationalSpeed(-right._revolutionsPerSecond); + return new RotationalSpeed(-right._radiansPerSecond); } public static RotationalSpeed operator +(RotationalSpeed left, RotationalSpeed right) { - return new RotationalSpeed(left._revolutionsPerSecond + right._revolutionsPerSecond); + return new RotationalSpeed(left._radiansPerSecond + right._radiansPerSecond); } public static RotationalSpeed operator -(RotationalSpeed left, RotationalSpeed right) { - return new RotationalSpeed(left._revolutionsPerSecond - right._revolutionsPerSecond); + return new RotationalSpeed(left._radiansPerSecond - right._radiansPerSecond); } public static RotationalSpeed operator *(double left, RotationalSpeed right) { - return new RotationalSpeed(left*right._revolutionsPerSecond); + return new RotationalSpeed(left*right._radiansPerSecond); } public static RotationalSpeed operator *(RotationalSpeed left, double right) { - return new RotationalSpeed(left._revolutionsPerSecond*(double)right); + return new RotationalSpeed(left._radiansPerSecond*(double)right); } public static RotationalSpeed operator /(RotationalSpeed left, double right) { - return new RotationalSpeed(left._revolutionsPerSecond/(double)right); + return new RotationalSpeed(left._radiansPerSecond/(double)right); } public static double operator /(RotationalSpeed left, RotationalSpeed right) { - return Convert.ToDouble(left._revolutionsPerSecond/right._revolutionsPerSecond); + return Convert.ToDouble(left._radiansPerSecond/right._radiansPerSecond); } #endregion @@ -288,39 +288,39 @@ public int CompareTo(object obj) public int CompareTo(RotationalSpeed other) { - return _revolutionsPerSecond.CompareTo(other._revolutionsPerSecond); + return _radiansPerSecond.CompareTo(other._radiansPerSecond); } public static bool operator <=(RotationalSpeed left, RotationalSpeed right) { - return left._revolutionsPerSecond <= right._revolutionsPerSecond; + return left._radiansPerSecond <= right._radiansPerSecond; } public static bool operator >=(RotationalSpeed left, RotationalSpeed right) { - return left._revolutionsPerSecond >= right._revolutionsPerSecond; + return left._radiansPerSecond >= right._radiansPerSecond; } public static bool operator <(RotationalSpeed left, RotationalSpeed right) { - return left._revolutionsPerSecond < right._revolutionsPerSecond; + return left._radiansPerSecond < right._radiansPerSecond; } public static bool operator >(RotationalSpeed left, RotationalSpeed right) { - return left._revolutionsPerSecond > right._revolutionsPerSecond; + return left._radiansPerSecond > right._radiansPerSecond; } public static bool operator ==(RotationalSpeed left, RotationalSpeed right) { // ReSharper disable once CompareOfFloatsByEqualityOperator - return left._revolutionsPerSecond == right._revolutionsPerSecond; + return left._radiansPerSecond == right._radiansPerSecond; } public static bool operator !=(RotationalSpeed left, RotationalSpeed right) { // ReSharper disable once CompareOfFloatsByEqualityOperator - return left._revolutionsPerSecond != right._revolutionsPerSecond; + return left._radiansPerSecond != right._radiansPerSecond; } public override bool Equals(object obj) @@ -330,12 +330,12 @@ public override bool Equals(object obj) return false; } - return _revolutionsPerSecond.Equals(((RotationalSpeed) obj)._revolutionsPerSecond); + return _radiansPerSecond.Equals(((RotationalSpeed) obj)._radiansPerSecond); } public override int GetHashCode() { - return _revolutionsPerSecond.GetHashCode(); + return _radiansPerSecond.GetHashCode(); } #endregion @@ -499,7 +499,7 @@ public static RotationalSpeedUnit ParseUnit(string str, IFormatProvider formatPr /// String representation. public override string ToString() { - return ToString(RotationalSpeedUnit.RevolutionPerSecond); + return ToString(RotationalSpeedUnit.RadianPerSecond); } /// diff --git a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json index baebb8536d..b87b03e5e2 100644 --- a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json +++ b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json @@ -1,52 +1,52 @@ { - "Name": "RotationalSpeed", - "BaseUnit": "RevolutionPerSecond", - "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", + "FromUnitToBaseFunc": "x", + "FromBaseToUnitFunc": "x", + "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci" ], + "Localization": [ { - "SingularName": "RevolutionPerSecond", - "PluralName": "RevolutionsPerSecond", - "FromUnitToBaseFunc": "x", - "FromBaseToUnitFunc": "x", - "Localization": [ - { - "Culture": "en-US", - "Abbreviations": ["r/s"] - }, - { - "Culture": "ru-RU", - "Abbreviations": ["об/с"] - } - ] + "Culture": "en-US", + "Abbreviations": [ "rad/s" ] + } + ] + }, + { + "SingularName": "RevolutionPerSecond", + "PluralName": "RevolutionsPerSecond", + "FromUnitToBaseFunc": "x*6.2831853072", + "FromBaseToUnitFunc": "x/6.2831853072", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "r/s" ] }, - { - "SingularName": "RadianPerSecond", - "PluralName": "RadiansPerSecond", - "FromUnitToBaseFunc": "x/6.2831853072", - "FromBaseToUnitFunc": "x*6.2831853072", - "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci" ], - "Localization": [ - { - "Culture": "en-US", - "Abbreviations": [ "rad/s" ] - } - ] - }, - { - "SingularName": "RevolutionPerMinute", - "PluralName": "RevolutionsPerMinute", - "FromUnitToBaseFunc": "x/60", - "FromBaseToUnitFunc": "x*60", - "Localization": [ - { - "Culture": "en-US", - "Abbreviations": ["rpm","r/min"] - }, - { - "Culture": "ru-RU", - "Abbreviations": ["об/мин"] - } - ] + { + "Culture": "ru-RU", + "Abbreviations": [ "об/с" ] + } + ] + }, + { + "SingularName": "RevolutionPerMinute", + "PluralName": "RevolutionsPerMinute", + "FromUnitToBaseFunc": "(x*6.2831853072)/60", + "FromBaseToUnitFunc": "(x/6.2831853072)*60", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "rpm", "r/min" ] + }, + { + "Culture": "ru-RU", + "Abbreviations": [ "об/мин" ] } - ] + ] + } + ] } \ No newline at end of file From a96180e5c3d143f9f39a8bef31ef8babf8fc9c8f Mon Sep 17 00:00:00 2001 From: tongbong Date: Thu, 21 Jan 2016 16:01:39 +0100 Subject: [PATCH 3/4] Update test to take into account default uni for rotational speed --- UnitsNet.Tests/UnitSystemTests.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/UnitsNet.Tests/UnitSystemTests.cs b/UnitsNet.Tests/UnitSystemTests.cs index e776e5f969..8a4a31c00f 100644 --- a/UnitsNet.Tests/UnitSystemTests.cs +++ b/UnitsNet.Tests/UnitSystemTests.cs @@ -161,7 +161,7 @@ public void AllUnitsImplementToStringForInvariantCulture() Assert.AreEqual("1 m", Length.FromMeters(1).ToString()); Assert.AreEqual("1 kg", Mass.FromKilograms(1).ToString()); Assert.AreEqual("1 Pa", Pressure.FromPascals(1).ToString()); - Assert.AreEqual("1 r/s", RotationalSpeed.FromRevolutionsPerSecond(1).ToString()); + Assert.AreEqual("1 rad/s", RotationalSpeed.FromRadiansPerSecond(1).ToString()); Assert.AreEqual("1 K", Temperature.FromKelvins(1).ToString()); Assert.AreEqual("1 N·m", Torque.FromNewtonMeters(1).ToString()); Assert.AreEqual("1 m³", Volume.FromCubicMeters(1).ToString()); @@ -184,7 +184,7 @@ public void AllUnitsImplementToStringForNorwegian() Assert.AreEqual("1 m", Length.FromMeters(1).ToString()); Assert.AreEqual("1 kg", Mass.FromKilograms(1).ToString()); Assert.AreEqual("1 Pa", Pressure.FromPascals(1).ToString()); - Assert.AreEqual("1 r/s", RotationalSpeed.FromRevolutionsPerSecond(1).ToString()); + Assert.AreEqual("1 rad/s", RotationalSpeed.FromRadiansPerSecond(1).ToString()); Assert.AreEqual("1 K", Temperature.FromKelvins(1).ToString()); Assert.AreEqual("1 N·m", Torque.FromNewtonMeters(1).ToString()); Assert.AreEqual("1 m³", Volume.FromCubicMeters(1).ToString()); @@ -203,7 +203,7 @@ public void AllUnitsImplementToStringForRussian() Assert.AreEqual("1 м", Length.FromMeters(1).ToString()); Assert.AreEqual("1 кг", Mass.FromKilograms(1).ToString()); Assert.AreEqual("1 Па", Pressure.FromPascals(1).ToString()); - Assert.AreEqual("1 об/с", RotationalSpeed.FromRevolutionsPerSecond(1).ToString()); + Assert.AreEqual("1 об/с", RotationalSpeed.FromRadiansPerSecond(1).ToString()); Assert.AreEqual("1 K", Temperature.FromKelvins(1).ToString()); Assert.AreEqual("1 Н·м", Torque.FromNewtonMeters(1).ToString()); Assert.AreEqual("1 м³", Volume.FromCubicMeters(1).ToString()); From c14ff6d86dc405aea227113c3f2c1c92a81547da Mon Sep 17 00:00:00 2001 From: tongbong Date: Thu, 21 Jan 2016 16:06:16 +0100 Subject: [PATCH 4/4] Translation for russian --- UnitsNet.Tests/UnitSystemTests.cs | 2 +- UnitsNet/GeneratedCode/UnitSystem.Default.g.cs | 6 ++++++ UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json | 4 ++++ 3 files changed, 11 insertions(+), 1 deletion(-) diff --git a/UnitsNet.Tests/UnitSystemTests.cs b/UnitsNet.Tests/UnitSystemTests.cs index 8a4a31c00f..4e7eb45842 100644 --- a/UnitsNet.Tests/UnitSystemTests.cs +++ b/UnitsNet.Tests/UnitSystemTests.cs @@ -203,7 +203,7 @@ public void AllUnitsImplementToStringForRussian() Assert.AreEqual("1 м", Length.FromMeters(1).ToString()); Assert.AreEqual("1 кг", Mass.FromKilograms(1).ToString()); Assert.AreEqual("1 Па", Pressure.FromPascals(1).ToString()); - Assert.AreEqual("1 об/с", RotationalSpeed.FromRadiansPerSecond(1).ToString()); + Assert.AreEqual("1 рад/с", RotationalSpeed.FromRadiansPerSecond(1).ToString()); Assert.AreEqual("1 K", Temperature.FromKelvins(1).ToString()); Assert.AreEqual("1 Н·м", Torque.FromNewtonMeters(1).ToString()); Assert.AreEqual("1 м³", Volume.FromCubicMeters(1).ToString()); diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 9678cea033..69e2574513 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1356,31 +1356,37 @@ private static readonly ReadOnlyCollection DefaultLocalization new[] { new AbbreviationsForCulture("en-US", "crad/s"), + new AbbreviationsForCulture("ru-RU", "cрад/с"), }), new CulturesForEnumValue((int) RotationalSpeedUnit.DeciradianPerSecond, new[] { new AbbreviationsForCulture("en-US", "drad/s"), + new AbbreviationsForCulture("ru-RU", "dрад/с"), }), new CulturesForEnumValue((int) RotationalSpeedUnit.MicroradianPerSecond, new[] { new AbbreviationsForCulture("en-US", "μrad/s"), + new AbbreviationsForCulture("ru-RU", "μрад/с"), }), new CulturesForEnumValue((int) RotationalSpeedUnit.MilliradianPerSecond, new[] { new AbbreviationsForCulture("en-US", "mrad/s"), + new AbbreviationsForCulture("ru-RU", "mрад/с"), }), new CulturesForEnumValue((int) RotationalSpeedUnit.NanoradianPerSecond, new[] { new AbbreviationsForCulture("en-US", "nrad/s"), + new AbbreviationsForCulture("ru-RU", "nрад/с"), }), new CulturesForEnumValue((int) RotationalSpeedUnit.RadianPerSecond, new[] { new AbbreviationsForCulture("en-US", "rad/s"), + new AbbreviationsForCulture("ru-RU", "рад/с"), }), new CulturesForEnumValue((int) RotationalSpeedUnit.RevolutionPerMinute, new[] diff --git a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json index b87b03e5e2..7d4a572e1c 100644 --- a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json +++ b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json @@ -13,6 +13,10 @@ { "Culture": "en-US", "Abbreviations": [ "rad/s" ] + }, + { + "Culture": "ru-RU", + "Abbreviations": [ "рад/с" ] } ] },