Angle.cs

Siirry tämän tiedoston dokumentaatioon.

#region MIT License
/*
 * Copyright (c) 2009 University of Jyväskylä, Department of Mathematical
 * Information Technology.
 * 
 * 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.
 */
#endregion

/*
 * Authors: Tero Jäntti, Tomi Karppinen, Janne Nikkanen.
 */

using System;
using AdvanceMath;
using System.Globalization;

namespace Jypeli
{
    public struct Angle
    {
        public static readonly Angle Zero = new Angle( 0 );

        public static readonly Angle RightAngle = new Angle( 0.5 * Math.PI );

        public static readonly Angle StraightAngle = new Angle( Math.PI );

        public static readonly Angle FullAngle = new Angle( 2 * Math.PI );


        private double radian;

        public double Degrees
        {
            get
            {
                return RadianToDegree( radian );
            }
            set
            {
                radian = DegreeToRadian( value );
            }
        }

        public double Radians
        {
            get { return radian; }
            set
            {
                radian = AdvanceMath.MathHelper.ClampAngle( (float)value );
            }
        }

        public Direction MainDirection
        {
            get
            {
                if ( radian >= -Math.PI / 4 && radian <= Math.PI / 4 ) return Direction.Right;
                if ( radian > Math.PI / 4 && radian < 3 * Math.PI / 4 ) return Direction.Up;
                if ( radian < -Math.PI / 4 && radian > -3 * Math.PI / 4 ) return Direction.Down;
                return Direction.Left;
            }
        }

        public double Sin
        {
            get { return Math.Sin( this.Radians ); }
        }

        public double Cos
        {
            get { return Math.Cos( this.Radians ); }
        }

        public double Tan
        {
            get { return Math.Tan( this.Radians ); }
        }


        private Angle( double radians )
        {
            this.radian = AdvanceMath.MathHelper.ClampAngle( (float)radians );
        }

        #region Operators

        public static Angle operator +( Angle a, Angle b )
        {
            return FromRadians( a.Radians + b.Radians );
        }

        public static Angle operator -( Angle a, Angle b )
        {
            return FromRadians( a.Radians - b.Radians );
        }

        public static Angle operator -( Angle a )
        {
            return FromRadians( -a.Radians );
        }

        public static Angle operator *( double a, Angle b )
        {
            return FromRadians( a * b.Radians );
        }

        public static Angle operator *( Angle a, double b )
        {
            return FromRadians( a.Radians * b );
        }

        public static Angle operator /( Angle a, double b )
        {
            return FromRadians( a.Radians / b );
        }

        public static bool operator ==( Angle a, Angle b )
        {
            return a.Radians == b.Radians;
        }

        public static bool operator !=( Angle a, Angle b )
        {
            return a.Radians != b.Radians;
        }

        public static bool operator <( Angle a, Angle b )
        {
            return a.Radians < b.Radians;
        }

        public static bool operator <=( Angle a, Angle b )
        {
            return a.Radians <= b.Radians;
        }

        public static bool operator >( Angle a, Angle b )
        {
            return a.Radians > b.Radians;
        }

        public static bool operator >=( Angle a, Angle b )
        {
            return a.Radians >= b.Radians;
        }

        public static explicit operator UnlimitedAngle( Angle angle )
        {
            return angle.Unlimit();
        }

        public static Angle Sum(UnlimitedAngle a, Angle b)
        {
            return Angle.FromRadians( a.Radians + b.Radians );
        }

        public static Angle Sum( Angle a, UnlimitedAngle b )
        {
            return Angle.FromRadians( a.Radians + b.Radians );
        }

        #endregion

        public UnlimitedAngle Unlimit()
        {
            return UnlimitedAngle.FromRadians( this.radian );
        }

        public static Angle FromRadians( double radian )
        {
            return new Angle( radian );
        }

        public static Angle FromDegrees( double degree )
        {
            return new Angle( DegreeToRadian( degree ) );
        }

        public static double DegreeToRadian( double degree )
        {
            return AdvanceMath.MathHelper.ClampAngle( (float)(degree * ( System.Math.PI / 180 )) );
        }

        public static double RadianToDegree( double radian )
        {
            double a = AdvanceMath.MathHelper.ClampAngle( (float)radian );
            return a * ( 180 / System.Math.PI );
        }

        public static Angle Complement( Angle a )
        {
            return FromRadians( 0.5 * Math.PI - a.Radians );
        }

        public static Angle Supplement( Angle a )
        {
            return FromRadians( Math.PI - a.Radians );
        }

        public static Angle Explement( Angle a )
        {
            return FromRadians( 2 * Math.PI - a.Radians );
        }

        public override int GetHashCode()
        {
            return Convert.ToInt32( Degrees );
        }

        public override bool Equals( object obj )
        {
            if ( obj is Angle )
            {
                return Double.Equals( this.Radians, ( (Angle)obj ).Radians );
            }

            return false;
        }

        public override string ToString()
        {
            return radian.ToString( System.Globalization.NumberFormatInfo.InvariantInfo );
        }

        public string ToString( IFormatProvider formatProvider )
        {
            return radian.ToString( formatProvider );
        }

        public static Angle Parse( string angleStr, IFormatProvider formatProvider )
        {
            return new Angle( double.Parse( angleStr, formatProvider ) );
        }

        public static Angle Parse( string angleStr )
        {
            return new Angle( double.Parse( angleStr, NumberFormatInfo.InvariantInfo ) );
        }

        public double GetPositiveRadians()
        {
            return Radians >= 0 ? Radians : Math.PI * 2 + Radians;
        }

        public double GetPositiveDegrees()
        {
            return Degrees >= 0 ? Degrees : 360 + Degrees;
        }

        public Vector GetVector()
        {
            return Vector.FromAngle( this );
        }

        #region Arcusfunktiot

        public static Angle ArcSin( double d )
        {
            return new Angle( Math.Asin( d ) );
        }

        public static Angle ArcCos( double d )
        {
            return new Angle( Math.Acos( d ) );
        }

        public static Angle ArcTan( double d )
        {
            return new Angle( Math.Atan( d ) );
        }

        #endregion
    }
}