// 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 );
		}
	}
}