Skip to content

Add degree per second unit #144

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 4 commits into from
Mar 1, 2016
Merged

Add degree per second unit #144

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
d65d5bc
Add degree per second unit
Feb 29, 2016
2c9757d
Add more units based on degree per second unit
Feb 29, 2016
27a01f7
Fix abbreviation
Mar 1, 2016
e6ba20a
Use hardcoded values instead of formulas
Mar 1, 2016
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
13 changes: 11 additions & 2 deletions UnitsNet.Tests/CustomCode/RotationalSpeedTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;

Copy link
Owner

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I prefer tests having pre-calculated values here, as it's too easy to fall in the trap of just using the reverse conversion expression from the implementation. I recommend you use an external conversion calculator as a sanity check.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Should be fixed in commit e6ba20a.
You are right, I found myself wondering why I was repeating the formula...
Thanks for the tip.

protected override double MicrodegreesPerSecondInOneRadianPerSecond => 57295779.51308232;

protected override double NanodegreesPerSecondInOneRadianPerSecond => 57295779513.08232087;

protected override double RevolutionsPerSecondInOneRadianPerSecond => 1/(2*Math.PI);

[Test]
public void DurationTimesRotationalSpeedEqualsAngle()
Expand Down
24 changes: 24 additions & 0 deletions UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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; }
Expand All @@ -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; } }
Expand All @@ -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);
Expand All @@ -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);
Expand All @@ -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);
Expand All @@ -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);
Expand Down
4 changes: 4 additions & 0 deletions UnitsNet/GeneratedCode/Enums/RotationalSpeedUnit.g.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,8 +27,12 @@ public enum RotationalSpeedUnit
Undefined = 0,
CentiradianPerSecond,
DeciradianPerSecond,
DegreePerSecond,
MicrodegreePerSecond,
MicroradianPerSecond,
MillidegreePerSecond,
MilliradianPerSecond,
NanodegreePerSecond,
NanoradianPerSecond,
RadianPerSecond,
RevolutionPerMinute,
Expand Down
80 changes: 80 additions & 0 deletions UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -70,6 +70,22 @@ public double DeciradiansPerSecond
get { return (_radiansPerSecond) / 1e-1d; }
}

/// <summary>
/// Get RotationalSpeed in DegreesPerSecond.
/// </summary>
public double DegreesPerSecond
{
get { return (180/Math.PI)*_radiansPerSecond; }
}

/// <summary>
/// Get RotationalSpeed in MicrodegreesPerSecond.
/// </summary>
public double MicrodegreesPerSecond
{
get { return ((180/Math.PI)*_radiansPerSecond) / 1e-6d; }
}

/// <summary>
/// Get RotationalSpeed in MicroradiansPerSecond.
/// </summary>
Expand All @@ -78,6 +94,14 @@ public double MicroradiansPerSecond
get { return (_radiansPerSecond) / 1e-6d; }
}

/// <summary>
/// Get RotationalSpeed in MillidegreesPerSecond.
/// </summary>
public double MillidegreesPerSecond
{
get { return ((180/Math.PI)*_radiansPerSecond) / 1e-3d; }
}

/// <summary>
/// Get RotationalSpeed in MilliradiansPerSecond.
/// </summary>
Expand All @@ -86,6 +110,14 @@ public double MilliradiansPerSecond
get { return (_radiansPerSecond) / 1e-3d; }
}

/// <summary>
/// Get RotationalSpeed in NanodegreesPerSecond.
/// </summary>
public double NanodegreesPerSecond
{
get { return ((180/Math.PI)*_radiansPerSecond) / 1e-9d; }
}

/// <summary>
/// Get RotationalSpeed in NanoradiansPerSecond.
/// </summary>
Expand Down Expand Up @@ -143,6 +175,22 @@ public static RotationalSpeed FromDeciradiansPerSecond(double deciradiansperseco
return new RotationalSpeed((deciradianspersecond) * 1e-1d);
}

/// <summary>
/// Get RotationalSpeed from DegreesPerSecond.
/// </summary>
public static RotationalSpeed FromDegreesPerSecond(double degreespersecond)
{
return new RotationalSpeed((Math.PI/180)*degreespersecond);
}

/// <summary>
/// Get RotationalSpeed from MicrodegreesPerSecond.
/// </summary>
public static RotationalSpeed FromMicrodegreesPerSecond(double microdegreespersecond)
{
return new RotationalSpeed(((Math.PI/180)*microdegreespersecond) * 1e-6d);
}

/// <summary>
/// Get RotationalSpeed from MicroradiansPerSecond.
/// </summary>
Expand All @@ -151,6 +199,14 @@ public static RotationalSpeed FromMicroradiansPerSecond(double microradiansperse
return new RotationalSpeed((microradianspersecond) * 1e-6d);
}

/// <summary>
/// Get RotationalSpeed from MillidegreesPerSecond.
/// </summary>
public static RotationalSpeed FromMillidegreesPerSecond(double millidegreespersecond)
{
return new RotationalSpeed(((Math.PI/180)*millidegreespersecond) * 1e-3d);
}

/// <summary>
/// Get RotationalSpeed from MilliradiansPerSecond.
/// </summary>
Expand All @@ -159,6 +215,14 @@ public static RotationalSpeed FromMilliradiansPerSecond(double milliradiansperse
return new RotationalSpeed((milliradianspersecond) * 1e-3d);
}

/// <summary>
/// Get RotationalSpeed from NanodegreesPerSecond.
/// </summary>
public static RotationalSpeed FromNanodegreesPerSecond(double nanodegreespersecond)
{
return new RotationalSpeed(((Math.PI/180)*nanodegreespersecond) * 1e-9d);
}

/// <summary>
/// Get RotationalSpeed from NanoradiansPerSecond.
/// </summary>
Expand Down Expand Up @@ -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:
Expand Down Expand Up @@ -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:
Expand Down
24 changes: 24 additions & 0 deletions UnitsNet/GeneratedCode/UnitSystem.Default.g.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1478,18 +1478,42 @@ private static readonly ReadOnlyCollection<UnitLocalization> 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[]
{
Expand Down
Loading