780 lines
30 KiB
C#
780 lines
30 KiB
C#
// Copyright (c) Xenko contributors (https://xenko.com) and Silicon Studio Corp. (https://www.siliconstudio.co.jp)
|
|
// Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
|
|
//
|
|
// -----------------------------------------------------------------------------
|
|
// Original code from SlimMath project. http://code.google.com/p/slimmath/
|
|
// Greetings to SlimDX Group. Original code published with the following license:
|
|
// -----------------------------------------------------------------------------
|
|
/*
|
|
* Copyright (c) 2007-2011 SlimDX Group
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
using System;
|
|
using System.Globalization;
|
|
using System.Runtime.Serialization;
|
|
|
|
namespace math
|
|
{
|
|
/// <summary>
|
|
/// Represents a unit independant angle using a single-precision floating-point
|
|
/// internal representation.
|
|
/// </summary>
|
|
[DataStyle(DataStyle.Compact)]
|
|
[DataContract]
|
|
public struct AngleSingle : IComparable, IComparable<AngleSingle>, IEquatable<AngleSingle>, IFormattable
|
|
{
|
|
/// <summary>
|
|
/// A value that specifies the size of a single degree.
|
|
/// </summary>
|
|
public const float Degree = 0.002777777777777778f;
|
|
|
|
/// <summary>
|
|
/// A value that specifies the size of a single minute.
|
|
/// </summary>
|
|
public const float Minute = 0.000046296296296296f;
|
|
|
|
/// <summary>
|
|
/// A value that specifies the size of a single second.
|
|
/// </summary>
|
|
public const float Second = 0.000000771604938272f;
|
|
|
|
/// <summary>
|
|
/// A value that specifies the size of a single radian.
|
|
/// </summary>
|
|
public const float Radian = 0.159154943091895336f;
|
|
|
|
/// <summary>
|
|
/// A value that specifies the size of a single milliradian.
|
|
/// </summary>
|
|
public const float Milliradian = 0.0001591549431f;
|
|
|
|
/// <summary>
|
|
/// A value that specifies the size of a single gradian.
|
|
/// </summary>
|
|
public const float Gradian = 0.0025f;
|
|
|
|
/// <summary>
|
|
/// The internal representation of the angle.
|
|
/// </summary>
|
|
private float radians;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="AngleSingle"/> struct with the
|
|
/// given unit dependant angle and unit type.
|
|
/// </summary>
|
|
/// <param name="angle">A unit dependant measure of the angle.</param>
|
|
/// <param name="type">The type of unit the angle argument is.</param>
|
|
public AngleSingle(float angle, AngleType type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case AngleType.Revolution:
|
|
radians = MathUtil.RevolutionsToRadians(angle);
|
|
break;
|
|
|
|
case AngleType.Degree:
|
|
radians = MathUtil.DegreesToRadians(angle);
|
|
break;
|
|
|
|
case AngleType.Radian:
|
|
radians = angle;
|
|
break;
|
|
|
|
case AngleType.Gradian:
|
|
radians = MathUtil.GradiansToRadians(angle);
|
|
break;
|
|
|
|
default:
|
|
radians = 0.0f;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="AngleSingle"/> struct using the
|
|
/// arc length formula (θ = s/r).
|
|
/// </summary>
|
|
/// <param name="arcLength">The measure of the arc.</param>
|
|
/// <param name="radius">The radius of the circle.</param>
|
|
public AngleSingle(float arcLength, float radius)
|
|
{
|
|
radians = arcLength / radius;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wraps this math.AngleSingle to be in the range [π, -π].
|
|
/// </summary>
|
|
public void Wrap()
|
|
{
|
|
float newangle = (float)Math.IEEERemainder(radians, MathUtil.TwoPi);
|
|
|
|
if (newangle <= -MathUtil.Pi)
|
|
newangle += MathUtil.TwoPi;
|
|
else if (newangle > MathUtil.Pi)
|
|
newangle -= MathUtil.TwoPi;
|
|
|
|
radians = newangle;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wraps this math.AngleSingle to be in the range [0, 2π).
|
|
/// </summary>
|
|
public void WrapPositive()
|
|
{
|
|
float newangle = radians % MathUtil.TwoPi;
|
|
|
|
if (newangle < 0.0)
|
|
newangle += MathUtil.TwoPi;
|
|
|
|
radians = newangle;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the total number of revolutions this math.AngleSingle represents.
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public float Revolutions
|
|
{
|
|
get { return MathUtil.RadiansToRevolutions(radians); }
|
|
set { radians = MathUtil.RevolutionsToRadians(value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the total number of degrees this math.AngleSingle represents.
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public float Degrees
|
|
{
|
|
get { return MathUtil.RadiansToDegrees(radians); }
|
|
set { radians = MathUtil.DegreesToRadians(value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the minutes component of the degrees this math.AngleSingle represents.
|
|
/// When setting the minutes, if the value is in the range (-60, 60) the whole degrees are
|
|
/// not changed; otherwise, the whole degrees may be changed. Fractional values may set
|
|
/// the seconds component.
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public float Minutes
|
|
{
|
|
get
|
|
{
|
|
float degrees = MathUtil.RadiansToDegrees(radians);
|
|
|
|
if (degrees < 0)
|
|
{
|
|
float degreesfloor = (float)Math.Ceiling(degrees);
|
|
return (degrees - degreesfloor) * 60.0f;
|
|
}
|
|
else
|
|
{
|
|
float degreesfloor = (float)Math.Floor(degrees);
|
|
return (degrees - degreesfloor) * 60.0f;
|
|
}
|
|
}
|
|
set
|
|
{
|
|
float degrees = MathUtil.RadiansToDegrees(radians);
|
|
float degreesfloor = (float)Math.Floor(degrees);
|
|
|
|
degreesfloor += value / 60.0f;
|
|
radians = MathUtil.DegreesToRadians(degreesfloor);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the seconds of the degrees this math.AngleSingle represents.
|
|
/// When setting te seconds, if the value is in the range (-60, 60) the whole minutes
|
|
/// or whole degrees are not changed; otherwise, the whole minutes or whole degrees
|
|
/// may be changed.
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public float Seconds
|
|
{
|
|
get
|
|
{
|
|
float degrees = MathUtil.RadiansToDegrees(radians);
|
|
|
|
if (degrees < 0)
|
|
{
|
|
float degreesfloor = (float)Math.Ceiling(degrees);
|
|
|
|
float minutes = (degrees - degreesfloor) * 60.0f;
|
|
float minutesfloor = (float)Math.Ceiling(minutes);
|
|
|
|
return (minutes - minutesfloor) * 60.0f;
|
|
}
|
|
else
|
|
{
|
|
float degreesfloor = (float)Math.Floor(degrees);
|
|
|
|
float minutes = (degrees - degreesfloor) * 60.0f;
|
|
float minutesfloor = (float)Math.Floor(minutes);
|
|
|
|
return (minutes - minutesfloor) * 60.0f;
|
|
}
|
|
}
|
|
set
|
|
{
|
|
float degrees = MathUtil.RadiansToDegrees(radians);
|
|
float degreesfloor = (float)Math.Floor(degrees);
|
|
|
|
float minutes = (degrees - degreesfloor) * 60.0f;
|
|
float minutesfloor = (float)Math.Floor(minutes);
|
|
|
|
minutesfloor += value / 60.0f;
|
|
degreesfloor += minutesfloor / 60.0f;
|
|
radians = MathUtil.DegreesToRadians(degreesfloor);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the total number of radians this math.AngleSingle represents.
|
|
/// </summary>
|
|
public float Radians
|
|
{
|
|
get { return radians; }
|
|
set { radians = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the total number of milliradians this math.AngleSingle represents.
|
|
/// One milliradian is equal to 1/(2000π).
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public float Milliradians
|
|
{
|
|
get { return radians / (Milliradian * MathUtil.TwoPi); }
|
|
set { radians = value * (Milliradian * MathUtil.TwoPi); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the total number of gradians this math.AngleSingle represents.
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public float Gradians
|
|
{
|
|
get { return MathUtil.RadiansToGradians(radians); }
|
|
set { radians = MathUtil.GradiansToRadians(value); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a System.Boolean that determines whether this math.Angle
|
|
/// is a right angle (i.e. 90° or π/2).
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public bool IsRight
|
|
{
|
|
get { return radians == MathUtil.PiOverTwo; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a System.Boolean that determines whether this math.Angle
|
|
/// is a straight angle (i.e. 180° or π).
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public bool IsStraight
|
|
{
|
|
get { return radians == MathUtil.Pi; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a System.Boolean that determines whether this math.Angle
|
|
/// is a full rotation angle (i.e. 360° or 2π).
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public bool IsFullRotation
|
|
{
|
|
get { return radians == MathUtil.TwoPi; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a System.Boolean that determines whether this math.Angle
|
|
/// is an oblique angle (i.e. is not 90° or a multiple of 90°).
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public bool IsOblique
|
|
{
|
|
get { return WrapPositive(this).radians != MathUtil.PiOverTwo; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a System.Boolean that determines whether this math.Angle
|
|
/// is an acute angle (i.e. less than 90° but greater than 0°).
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public bool IsAcute
|
|
{
|
|
get { return radians > 0.0 && radians < MathUtil.PiOverTwo; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a System.Boolean that determines whether this math.Angle
|
|
/// is an obtuse angle (i.e. greater than 90° but less than 180°).
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public bool IsObtuse
|
|
{
|
|
get { return radians > MathUtil.PiOverTwo && radians < MathUtil.Pi; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a System.Boolean that determines whether this math.Angle
|
|
/// is a reflex angle (i.e. greater than 180° but less than 360°).
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public bool IsReflex
|
|
{
|
|
get { return radians > MathUtil.Pi && radians < MathUtil.TwoPi; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a math.AngleSingle instance that complements this angle (i.e. the two angles add to 90°).
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public AngleSingle Complement
|
|
{
|
|
get { return new AngleSingle(MathUtil.PiOverTwo - radians, AngleType.Radian); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a math.AngleSingle instance that supplements this angle (i.e. the two angles add to 180°).
|
|
/// </summary>
|
|
[DataMemberIgnore]
|
|
public AngleSingle Supplement
|
|
{
|
|
get { return new AngleSingle(MathUtil.Pi - radians, AngleType.Radian); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wraps the math.AngleSingle given in the value argument to be in the range [π, -π].
|
|
/// </summary>
|
|
/// <param name="value">A math.AngleSingle to wrap.</param>
|
|
/// <returns>The math.AngleSingle that is wrapped.</returns>
|
|
public static AngleSingle Wrap(AngleSingle value)
|
|
{
|
|
value.Wrap();
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wraps the math.AngleSingle given in the value argument to be in the range [0, 2π).
|
|
/// </summary>
|
|
/// <param name="value">A math.AngleSingle to wrap.</param>
|
|
/// <returns>The math.AngleSingle that is wrapped.</returns>
|
|
public static AngleSingle WrapPositive(AngleSingle value)
|
|
{
|
|
value.WrapPositive();
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compares two math.AngleSingle instances and returns the smaller angle.
|
|
/// </summary>
|
|
/// <param name="left">The first math.AngleSingle instance to compare.</param>
|
|
/// <param name="right">The second math.AngleSingle instance to compare.</param>
|
|
/// <returns>The smaller of the two given math.AngleSingle instances.</returns>
|
|
public static AngleSingle Min(AngleSingle left, AngleSingle right)
|
|
{
|
|
if (left.radians < right.radians)
|
|
return left;
|
|
|
|
return right;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compares two math.AngleSingle instances and returns the greater angle.
|
|
/// </summary>
|
|
/// <param name="left">The first math.AngleSingle instance to compare.</param>
|
|
/// <param name="right">The second math.AngleSingle instance to compare.</param>
|
|
/// <returns>The greater of the two given math.AngleSingle instances.</returns>
|
|
public static AngleSingle Max(AngleSingle left, AngleSingle right)
|
|
{
|
|
if (left.radians > right.radians)
|
|
return left;
|
|
|
|
return right;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds two math.AngleSingle objects and returns the result.
|
|
/// </summary>
|
|
/// <param name="left">The first object to add.</param>
|
|
/// <param name="right">The second object to add.</param>
|
|
/// <returns>The value of the two objects added together.</returns>
|
|
public static AngleSingle Add(AngleSingle left, AngleSingle right)
|
|
{
|
|
return new AngleSingle(left.radians + right.radians, AngleType.Radian);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Subtracts two math.AngleSingle objects and returns the result.
|
|
/// </summary>
|
|
/// <param name="left">The first object to subtract.</param>
|
|
/// <param name="right">The second object to subtract.</param>
|
|
/// <returns>The value of the two objects subtracted.</returns>
|
|
public static AngleSingle Subtract(AngleSingle left, AngleSingle right)
|
|
{
|
|
return new AngleSingle(left.radians - right.radians, AngleType.Radian);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiplies two math.AngleSingle objects and returns the result.
|
|
/// </summary>
|
|
/// <param name="left">The first object to multiply.</param>
|
|
/// <param name="right">The second object to multiply.</param>
|
|
/// <returns>The value of the two objects multiplied together.</returns>
|
|
public static AngleSingle Multiply(AngleSingle left, AngleSingle right)
|
|
{
|
|
return new AngleSingle(left.radians * right.radians, AngleType.Radian);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Divides two math.AngleSingle objects and returns the result.
|
|
/// </summary>
|
|
/// <param name="left">The numerator object.</param>
|
|
/// <param name="right">The denominator object.</param>
|
|
/// <returns>The value of the two objects divided.</returns>
|
|
public static AngleSingle Divide(AngleSingle left, AngleSingle right)
|
|
{
|
|
return new AngleSingle(left.radians / right.radians, AngleType.Radian);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a new math.AngleSingle instance that represents the zero angle (i.e. 0°).
|
|
/// </summary>
|
|
public static AngleSingle ZeroAngle
|
|
{
|
|
get { return new AngleSingle(0.0f, AngleType.Radian); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a new math.AngleSingle instance that represents the right angle (i.e. 90° or π/2).
|
|
/// </summary>
|
|
public static AngleSingle RightAngle
|
|
{
|
|
get { return new AngleSingle(MathUtil.PiOverTwo, AngleType.Radian); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a new math.AngleSingle instance that represents the straight angle (i.e. 180° or π).
|
|
/// </summary>
|
|
public static AngleSingle StraightAngle
|
|
{
|
|
get { return new AngleSingle(MathUtil.Pi, AngleType.Radian); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a new math.AngleSingle instance that represents the full rotation angle (i.e. 360° or 2π).
|
|
/// </summary>
|
|
public static AngleSingle FullRotationAngle
|
|
{
|
|
get { return new AngleSingle(MathUtil.TwoPi, AngleType.Radian); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a System.Boolean that indicates whether the values of two math.Angle
|
|
/// objects are equal.
|
|
/// </summary>
|
|
/// <param name="left">The first object to compare.</param>
|
|
/// <param name="right">The second object to compare.</param>
|
|
/// <returns>True if the left and right parameters have the same value; otherwise, false.</returns>
|
|
public static bool operator ==(AngleSingle left, AngleSingle right)
|
|
{
|
|
return left.radians == right.radians;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a System.Boolean that indicates whether the values of two math.Angle
|
|
/// objects are not equal.
|
|
/// </summary>
|
|
/// <param name="left">The first object to compare.</param>
|
|
/// <param name="right">The second object to compare.</param>
|
|
/// <returns>True if the left and right parameters do not have the same value; otherwise, false.</returns>
|
|
public static bool operator !=(AngleSingle left, AngleSingle right)
|
|
{
|
|
return left.radians != right.radians;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a System.Boolean that indicates whether a math.Angle
|
|
/// object is less than another math.AngleSingle object.
|
|
/// </summary>
|
|
/// <param name="left">The first object to compare.</param>
|
|
/// <param name="right">The second object to compare.</param>
|
|
/// <returns>True if left is less than right; otherwise, false.</returns>
|
|
public static bool operator <(AngleSingle left, AngleSingle right)
|
|
{
|
|
return left.radians < right.radians;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a System.Boolean that indicates whether a math.Angle
|
|
/// object is greater than another math.AngleSingle object.
|
|
/// </summary>
|
|
/// <param name="left">The first object to compare.</param>
|
|
/// <param name="right">The second object to compare.</param>
|
|
/// <returns>True if left is greater than right; otherwise, false.</returns>
|
|
public static bool operator >(AngleSingle left, AngleSingle right)
|
|
{
|
|
return left.radians > right.radians;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a System.Boolean that indicates whether a math.Angle
|
|
/// object is less than or equal to another math.AngleSingle object.
|
|
/// </summary>
|
|
/// <param name="left">The first object to compare.</param>
|
|
/// <param name="right">The second object to compare.</param>
|
|
/// <returns>True if left is less than or equal to right; otherwise, false.</returns>
|
|
public static bool operator <=(AngleSingle left, AngleSingle right)
|
|
{
|
|
return left.radians <= right.radians;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a System.Boolean that indicates whether a math.Angle
|
|
/// object is greater than or equal to another math.AngleSingle object.
|
|
/// </summary>
|
|
/// <param name="left">The first object to compare.</param>
|
|
/// <param name="right">The second object to compare.</param>
|
|
/// <returns>True if left is greater than or equal to right; otherwise, false.</returns>
|
|
public static bool operator >=(AngleSingle left, AngleSingle right)
|
|
{
|
|
return left.radians >= right.radians;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the value of the math.AngleSingle operand. (The sign of
|
|
/// the operand is unchanged.)
|
|
/// </summary>
|
|
/// <param name="value">A math.AngleSingle object.</param>
|
|
/// <returns>The value of the value parameter.</returns>
|
|
public static AngleSingle operator +(AngleSingle value)
|
|
{
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the the negated value of the math.AngleSingle operand.
|
|
/// </summary>
|
|
/// <param name="value">A math.AngleSingle object.</param>
|
|
/// <returns>The negated value of the value parameter.</returns>
|
|
public static AngleSingle operator -(AngleSingle value)
|
|
{
|
|
return new AngleSingle(-value.radians, AngleType.Radian);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds two math.AngleSingle objects and returns the result.
|
|
/// </summary>
|
|
/// <param name="left">The first object to add.</param>
|
|
/// <param name="right">The second object to add.</param>
|
|
/// <returns>The value of the two objects added together.</returns>
|
|
public static AngleSingle operator +(AngleSingle left, AngleSingle right)
|
|
{
|
|
return new AngleSingle(left.radians + right.radians, AngleType.Radian);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Subtracts two math.AngleSingle objects and returns the result.
|
|
/// </summary>
|
|
/// <param name="left">The first object to subtract</param>
|
|
/// <param name="right">The second object to subtract.</param>
|
|
/// <returns>The value of the two objects subtracted.</returns>
|
|
public static AngleSingle operator -(AngleSingle left, AngleSingle right)
|
|
{
|
|
return new AngleSingle(left.radians - right.radians, AngleType.Radian);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Multiplies two math.AngleSingle objects and returns the result.
|
|
/// </summary>
|
|
/// <param name="left">The first object to multiply.</param>
|
|
/// <param name="right">The second object to multiply.</param>
|
|
/// <returns>The value of the two objects multiplied together.</returns>
|
|
public static AngleSingle operator *(AngleSingle left, AngleSingle right)
|
|
{
|
|
return new AngleSingle(left.radians * right.radians, AngleType.Radian);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Divides two math.AngleSingle objects and returns the result.
|
|
/// </summary>
|
|
/// <param name="left">The numerator object.</param>
|
|
/// <param name="right">The denominator object.</param>
|
|
/// <returns>The value of the two objects divided.</returns>
|
|
public static AngleSingle operator /(AngleSingle left, AngleSingle right)
|
|
{
|
|
return new AngleSingle(left.radians / right.radians, AngleType.Radian);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compares this instance to a specified object and returns an integer that
|
|
/// indicates whether the value of this instance is less than, equal to, or greater
|
|
/// than the value of the specified object.
|
|
/// </summary>
|
|
/// <param name="other">The object to compare.</param>
|
|
/// <returns>
|
|
/// A signed integer that indicates the relationship of the current instance
|
|
/// to the obj parameter. If the value is less than zero, the current instance
|
|
/// is less than the other. If the value is zero, the current instance is equal
|
|
/// to the other. If the value is greater than zero, the current instance is
|
|
/// greater than the other.
|
|
/// </returns>
|
|
public int CompareTo(object other)
|
|
{
|
|
if (other == null)
|
|
return 1;
|
|
|
|
if (!(other is AngleSingle))
|
|
throw new ArgumentException("Argument must be of type Angle.", "other");
|
|
|
|
float radians = ((AngleSingle)other).radians;
|
|
|
|
if (this.radians > radians)
|
|
return 1;
|
|
|
|
if (this.radians < radians)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compares this instance to a second math.AngleSingle and returns
|
|
/// an integer that indicates whether the value of this instance is less than,
|
|
/// equal to, or greater than the value of the specified object.
|
|
/// </summary>
|
|
/// <param name="other">The object to compare.</param>
|
|
/// <returns>
|
|
/// A signed integer that indicates the relationship of the current instance
|
|
/// to the obj parameter. If the value is less than zero, the current instance
|
|
/// is less than the other. If the value is zero, the current instance is equal
|
|
/// to the other. If the value is greater than zero, the current instance is
|
|
/// greater than the other.
|
|
/// </returns>
|
|
public int CompareTo(AngleSingle other)
|
|
{
|
|
if (this.radians > other.radians)
|
|
return 1;
|
|
|
|
if (this.radians < other.radians)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a value that indicates whether the current instance and a specified
|
|
/// math.AngleSingle object have the same value.
|
|
/// </summary>
|
|
/// <param name="other">The object to compare.</param>
|
|
/// <returns>
|
|
/// Returns true if this math.AngleSingle object and another have the same value;
|
|
/// otherwise, false.
|
|
/// </returns>
|
|
public bool Equals(AngleSingle other)
|
|
{
|
|
return this == other;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a <see cref="string"/> that represents this instance.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// A <see cref="string"/> that represents this instance.
|
|
/// </returns>
|
|
public override string ToString()
|
|
{
|
|
return string.Format(CultureInfo.CurrentCulture, MathUtil.RadiansToDegrees(radians).ToString("0.##°"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a <see cref="string"/> that represents this instance.
|
|
/// </summary>
|
|
/// <param name="format">The format.</param>
|
|
/// <returns>
|
|
/// A <see cref="string"/> that represents this instance.
|
|
/// </returns>
|
|
public string ToString(string format)
|
|
{
|
|
if (format == null)
|
|
return ToString();
|
|
|
|
return string.Format(CultureInfo.CurrentCulture, $"{MathUtil.RadiansToDegrees(radians).ToString(format, CultureInfo.CurrentCulture)}°" );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a <see cref="string"/> that represents this instance.
|
|
/// </summary>
|
|
/// <param name="formatProvider">The format provider.</param>
|
|
/// <returns>
|
|
/// A <see cref="string"/> that represents this instance.
|
|
/// </returns>
|
|
public string ToString(IFormatProvider formatProvider)
|
|
{
|
|
return string.Format(formatProvider, MathUtil.RadiansToDegrees(radians).ToString("0.##°"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a <see cref="string"/> that represents this instance.
|
|
/// </summary>
|
|
/// <param name="format">The format.</param>
|
|
/// <param name="formatProvider">The format provider.</param>
|
|
/// <returns>
|
|
/// A <see cref="string"/> that represents this instance.
|
|
/// </returns>
|
|
public string ToString(string format, IFormatProvider formatProvider)
|
|
{
|
|
if (format == null)
|
|
return ToString(formatProvider);
|
|
|
|
return string.Format(formatProvider, "{0}°", MathUtil.RadiansToDegrees(radians).ToString(format, CultureInfo.CurrentCulture));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a hash code for this math.AngleSingle instance.
|
|
/// </summary>
|
|
/// <returns>A 32-bit signed integer hash code.</returns>
|
|
public override int GetHashCode()
|
|
{
|
|
return (int)(BitConverter.DoubleToInt64Bits(radians) % int.MaxValue);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a value that indicates whether the current instance and a specified
|
|
/// object have the same value.
|
|
/// </summary>
|
|
/// <param name="obj">The object to compare.</param>
|
|
/// <returns>
|
|
/// Returns true if the obj parameter is a math.AngleSingle object or a type
|
|
/// capable of implicit conversion to a math.AngleSingle value, and
|
|
/// its value is equal to the value of the current math.Angle
|
|
/// object; otherwise, false.
|
|
/// </returns>
|
|
public override bool Equals(object obj)
|
|
{
|
|
return (obj is AngleSingle) && (this == (AngleSingle)obj);
|
|
}
|
|
}
|
|
}
|