UnlimitedAngle.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 System.Globalization;
 
namespace Jypeli
{
    public struct UnlimitedAngle
    {
        public static readonly UnlimitedAngle Zero = new UnlimitedAngle( 0 );
 
        public static readonly UnlimitedAngle RightAngle = new UnlimitedAngle( 0.5 * Math.PI );
 
        public static readonly UnlimitedAngle StraightAngle = new UnlimitedAngle( Math.PI );
 
        public static readonly UnlimitedAngle FullAngle = new UnlimitedAngle( 2 * Math.PI );
 
        public static readonly UnlimitedAngle Infinity = new UnlimitedAngle( double.PositiveInfinity );
 
        private double radian;
 
        public double Degrees
        {
            get
            {
                return RadianToDegree( radian );
            }
            set
            {
                radian = DegreeToRadian( value );
            }
        }
 
        public double Radians
        {
            get { return radian; }
            set
            {
                radian = (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 UnlimitedAngle( double radians )
        {
            this.radian = (float)radians;
        }
 
        #region Operators
 
        public static UnlimitedAngle operator +( UnlimitedAngle a, UnlimitedAngle b )
        {
            return FromRadians( a.Radians + b.Radians );
        }
 
        public static UnlimitedAngle operator -( UnlimitedAngle a, UnlimitedAngle b )
        {
            return FromRadians( a.Radians - b.Radians );
        }
 
        public static UnlimitedAngle operator -( UnlimitedAngle a )
        {
            return FromRadians( -a.Radians );
        }
 
        public static UnlimitedAngle operator *( double a, UnlimitedAngle b )
        {
            return FromRadians( a * b.Radians );
        }
 
        public static UnlimitedAngle operator *( UnlimitedAngle a, double b )
        {
            return FromRadians( a.Radians * b );
        }
 
        public static UnlimitedAngle operator /( UnlimitedAngle a, double b )
        {
            return FromRadians( a.Radians / b );
        }
 
        public static bool operator ==( UnlimitedAngle a, UnlimitedAngle b )
        {
            return a.Radians == b.Radians;
        }
 
        public static bool operator !=( UnlimitedAngle a, UnlimitedAngle b )
        {
            return a.Radians != b.Radians;
        }
 
        public static bool operator <( UnlimitedAngle a, UnlimitedAngle b )
        {
            return a.Radians < b.Radians;
        }
 
        public static bool operator <=( UnlimitedAngle a, UnlimitedAngle b )
        {
            return a.Radians <= b.Radians;
        }
 
        public static bool operator >( UnlimitedAngle a, UnlimitedAngle b )
        {
            return a.Radians > b.Radians;
        }
 
        public static bool operator >=( UnlimitedAngle a, UnlimitedAngle b )
        {
            return a.Radians >= b.Radians;
        }
 
        public static explicit operator Angle( UnlimitedAngle angle )
        {
            return angle.Limit();
        }
 
        public static UnlimitedAngle Sum( UnlimitedAngle a, Angle b )
        {
            return UnlimitedAngle.FromRadians( a.Radians + b.Radians );
        }
 
        public static UnlimitedAngle Sum( Angle a, UnlimitedAngle b )
        {
            return UnlimitedAngle.FromRadians( a.Radians + b.Radians );
        }
 
        #endregion
 
        public Angle Limit()
        {
            return Angle.FromRadians( this.radian );
        }
 
        public static UnlimitedAngle FromRadians( double radian )
        {
            return new UnlimitedAngle( radian );
        }
 
        public static UnlimitedAngle FromDegrees( double degree )
        {
            return new UnlimitedAngle( DegreeToRadian( degree ) );
        }
 
        public static double DegreeToRadian( double degree )
        {
            return (float)( degree * ( System.Math.PI / 180 ) );
        }
 
        public static double RadianToDegree( double radian )
        {
            return radian * ( 180 / Math.PI );
        }
 
        public override int GetHashCode()
        {
            return Convert.ToInt32( Degrees );
        }
 
        public override bool Equals( object obj )
        {
            if ( obj is UnlimitedAngle )
            {
                return Double.Equals( this.Radians, ( (UnlimitedAngle)obj ).Radians );
            }
 
            else 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 UnlimitedAngle Parse( string angleStr, IFormatProvider formatProvider )
        {
            return new UnlimitedAngle( double.Parse( angleStr, formatProvider ) );
        }
 
        public static UnlimitedAngle Parse( string angleStr )
        {
            return new UnlimitedAngle( double.Parse( angleStr, NumberFormatInfo.InvariantInfo ) );
        }
 
        public double GetPositiveRadians()
        {
            return Radians > 0 ? Radians : Math.PI * 2 + Radians;
        }
 
        public double GetPositiveDegrees()
        {
            double deg = Degrees;
            while ( deg < 0 ) deg += 360;
            return deg;
        }
 
        public Vector GetVector()
        {
            return Vector.FromAngle( Limit() );
        }
 
        #region Arcusfunktiot
 
        public static UnlimitedAngle ArcSin( double d )
        {
            return new UnlimitedAngle( Math.Asin( d ) );
        }
 
        public static UnlimitedAngle ArcCos( double d )
        {
            return new UnlimitedAngle( Math.Acos( d ) );
        }
 
        public static UnlimitedAngle ArcTan( double d )
        {
            return new UnlimitedAngle( Math.Atan( d ) );
        }
 
        #endregion
    }
}