diff --git a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs index 0fb21b18b4..a43e25b135 100644 --- a/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs +++ b/UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs @@ -38,9 +38,18 @@ 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 => 0.15915494; + + protected override double DegreesPerSecondInOneRadianPerSecond => 57.29577951308; + + protected override double MillidegreesPerSecondInOneRadianPerSecond => 57295.77951308; + + protected override double MicrodegreesPerSecondInOneRadianPerSecond => 57295779.51308232; + + protected override double NanodegreesPerSecondInOneRadianPerSecond => 57295779513.08232087; - protected override double RevolutionsPerSecondInOneRadianPerSecond => 1/(2*Math.PI); [Test] public void DurationTimesRotationalSpeedEqualsAngle() diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs index 552412d898..434eea090b 100644 --- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs @@ -38,8 +38,12 @@ 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; } @@ -48,8 +52,12 @@ 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 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; } } @@ -62,8 +70,12 @@ 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(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); @@ -75,8 +87,12 @@ 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); @@ -89,8 +105,12 @@ 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(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); @@ -103,8 +123,12 @@ 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.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 bef3c12843..11b589ae94 100644 --- a/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs +++ b/UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs @@ -27,8 +27,12 @@ public enum RotationalSpeedUnit Undefined = 0, 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 3e054a5cb1..738eec1c20 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs @@ -70,6 +70,22 @@ public double DeciradiansPerSecond get { return (_radiansPerSecond) / 1e-1d; } } + /// + /// Get RotationalSpeed in DegreesPerSecond. + /// + 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. /// @@ -78,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. /// @@ -86,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. /// @@ -143,6 +175,22 @@ 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 MicrodegreesPerSecond. + /// + public static RotationalSpeed FromMicrodegreesPerSecond(double microdegreespersecond) + { + return new RotationalSpeed(((Math.PI/180)*microdegreespersecond) * 1e-6d); + } + /// /// Get RotationalSpeed from MicroradiansPerSecond. /// @@ -151,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. /// @@ -159,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. /// @@ -206,10 +270,18 @@ 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.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: @@ -355,10 +427,18 @@ public double As(RotationalSpeedUnit unit) return CentiradiansPerSecond; case RotationalSpeedUnit.DeciradianPerSecond: 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 93920aace2..8e35a5d5a9 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1478,18 +1478,42 @@ 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", "°/s", "deg/s"), + new AbbreviationsForCulture("ru-RU", "°/с"), + }), + new CulturesForEnumValue((int) RotationalSpeedUnit.MicrodegreePerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "μ°/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", "m°/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", "n°/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 7d4a572e1c..d44d69d9c7 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,23 @@ } ] }, + { + "SingularName": "DegreePerSecond", + "PluralName": "DegreesPerSecond", + "FromUnitToBaseFunc": "(Math.PI/180)*x", + "FromBaseToUnitFunc": "(180/Math.PI)*x", + "Prefixes": [ "Nano", "Micro", "Milli" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "°/s", "deg/s" ] + }, + { + "Culture": "ru-RU", + "Abbreviations": [ "°/с" ] + } + ] + }, { "SingularName": "RevolutionPerSecond", "PluralName": "RevolutionsPerSecond",