diff --git a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs index 9d0e934f83..3fd2d844d5 100644 --- a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs +++ b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs @@ -25,22 +25,45 @@ 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 RevolutionsPerMinuteInOneRevolutionPerSecond + protected override double DeciradiansPerSecondInOneRadianPerSecond { - get { return 1.0*60; } + get { return 1E1; } } - protected override double RevolutionsPerSecondInOneRevolutionPerSecond + protected override double CentiradiansPerSecondInOneRadianPerSecond { - get { return 1; } + get { return 1E2; } + } + + protected override double MilliradiansPerSecondInOneRadianPerSecond + { + get { return 1E3; } + } + + protected override double MicroradiansPerSecondInOneRadianPerSecond + { + get { return 1E6; } + } + + protected override double NanoradiansPerSecondInOneRadianPerSecond + { + get { return 1E9; } + } + + protected override double RevolutionsPerMinuteInOneRadianPerSecond + { + get { return (60*1) / (2 * Math.PI); } + } + + protected override double RevolutionsPerSecondInOneRadianPerSecond + { + 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 c19e55c6aa..4cb6aa1448 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -36,28 +36,48 @@ namespace UnitsNet.Tests // ReSharper disable once PartialTypeWithSinglePart public abstract partial class RotationalSpeedTestsBase { - 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; } } + 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; } } // ReSharper restore VirtualMemberNeverOverriden.Global [Test] - public void RevolutionPerSecondToRotationalSpeedUnits() + public void RadianPerSecondToRotationalSpeedUnits() { - RotationalSpeed revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1); - 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] 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); @@ -66,84 +86,94 @@ public void FromValueAndUnit() [Test] public void As() { - var revolutionpersecond = RotationalSpeed.FromRevolutionsPerSecond(1); - 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.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); @@ -157,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.Tests/UnitSystemTests.cs b/UnitsNet.Tests/UnitSystemTests.cs index e776e5f969..4e7eb45842 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()); 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..a676beacda 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs @@ -40,18 +40,58 @@ 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; } + } + + /// + /// Get RotationalSpeed in CentiradiansPerSecond. + /// + public double CentiradiansPerSecond + { + get { return (_radiansPerSecond) / 1e-2d; } + } + + /// + /// Get RotationalSpeed in DeciradiansPerSecond. + /// + public double DeciradiansPerSecond + { + get { return (_radiansPerSecond) / 1e-1d; } + } + + /// + /// Get RotationalSpeed in MicroradiansPerSecond. + /// + public double MicroradiansPerSecond + { + get { return (_radiansPerSecond) / 1e-6d; } + } + + /// + /// Get RotationalSpeed in MilliradiansPerSecond. + /// + public double MilliradiansPerSecond + { + get { return (_radiansPerSecond) / 1e-3d; } + } + + /// + /// Get RotationalSpeed in NanoradiansPerSecond. + /// + public double NanoradiansPerSecond + { + get { return (_radiansPerSecond) / 1e-9d; } } /// @@ -59,7 +99,7 @@ public static RotationalSpeedUnit BaseUnit /// public double RadiansPerSecond { - get { return _revolutionsPerSecond*6.2831853072; } + get { return _radiansPerSecond; } } /// @@ -67,7 +107,7 @@ public double RadiansPerSecond /// public double RevolutionsPerMinute { - get { return _revolutionsPerSecond*60; } + get { return (_radiansPerSecond/6.2831853072)*60; } } /// @@ -75,7 +115,7 @@ public double RevolutionsPerMinute /// public double RevolutionsPerSecond { - get { return _revolutionsPerSecond; } + get { return _radiansPerSecond/6.2831853072; } } #endregion @@ -87,12 +127,52 @@ public static RotationalSpeed Zero get { return new RotationalSpeed(); } } + /// + /// Get RotationalSpeed from CentiradiansPerSecond. + /// + public static RotationalSpeed FromCentiradiansPerSecond(double centiradianspersecond) + { + return new RotationalSpeed((centiradianspersecond) * 1e-2d); + } + + /// + /// Get RotationalSpeed from DeciradiansPerSecond. + /// + public static RotationalSpeed FromDeciradiansPerSecond(double deciradianspersecond) + { + return new RotationalSpeed((deciradianspersecond) * 1e-1d); + } + + /// + /// Get RotationalSpeed from MicroradiansPerSecond. + /// + public static RotationalSpeed FromMicroradiansPerSecond(double microradianspersecond) + { + return new RotationalSpeed((microradianspersecond) * 1e-6d); + } + + /// + /// Get RotationalSpeed from MilliradiansPerSecond. + /// + public static RotationalSpeed FromMilliradiansPerSecond(double milliradianspersecond) + { + return new RotationalSpeed((milliradianspersecond) * 1e-3d); + } + + /// + /// Get RotationalSpeed from NanoradiansPerSecond. + /// + public static RotationalSpeed FromNanoradiansPerSecond(double nanoradianspersecond) + { + return new RotationalSpeed((nanoradianspersecond) * 1e-9d); + } + /// /// Get RotationalSpeed from RadiansPerSecond. /// public static RotationalSpeed FromRadiansPerSecond(double radianspersecond) { - return new RotationalSpeed(radianspersecond/6.2831853072); + return new RotationalSpeed(radianspersecond); } /// @@ -100,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); } /// @@ -108,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); } @@ -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: @@ -152,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 @@ -198,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) @@ -240,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 @@ -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: @@ -399,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/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 84de974690..69e2574513 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1352,10 +1352,41 @@ private static readonly ReadOnlyCollection DefaultLocalization new UnitLocalization(typeof (RotationalSpeedUnit), new[] { + new CulturesForEnumValue((int) RotationalSpeedUnit.CentiradianPerSecond, + 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 060d65c34c..7d4a572e1c 100644 --- a/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json +++ b/UnitsNet/Scripts/UnitDefinitions/RotationalSpeed.json @@ -1,51 +1,56 @@ { - "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": "RadianPerSecond", - "PluralName": "RadiansPerSecond", - "FromUnitToBaseFunc": "x/6.2831853072", - "FromBaseToUnitFunc": "x*6.2831853072", - "Localization": [ - { - "Culture": "en-US", - "Abbreviations": ["rad/s"] - } - ] + { + "Culture": "ru-RU", + "Abbreviations": [ "рад/с" ] + } + ] + }, + { + "SingularName": "RevolutionPerSecond", + "PluralName": "RevolutionsPerSecond", + "FromUnitToBaseFunc": "x*6.2831853072", + "FromBaseToUnitFunc": "x/6.2831853072", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "r/s" ] + }, + { + "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" ] }, - { - "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": [ "об/мин" ] } - ] + ] + } + ] } \ No newline at end of file