Point2D.cs

Siirry tämän tiedoston dokumentaatioon.

#region MIT License
/*
 * Copyright (c) 2005-2008 Jonathan Mark Porter. http://physics2d.googlepages.com/
 * 
 * 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
 
 
 
#if UseDouble
using Scalar = System.Double;
#else
using Scalar = System.Single;
#endif
using System;
using System.Runtime.InteropServices;
using System.Xml.Serialization;
 
using AdvanceMath.Design ;
namespace AdvanceMath
{
 
    [StructLayout(LayoutKind.Sequential, Size = Point2D.Size)]
    [AdvBrowsableOrder("X,Y")]
#if !CompactFramework && !WindowsCE && !PocketPC && !XBOX360 && !SILVERLIGHT && !WINDOWS_PHONE && !NETFX_CORE
    [Serializable]
    [System.ComponentModel.TypeConverter(typeof(AdvTypeConverter<Point2D>))]
#endif
    public struct Point2D : IEquatable<Point2D>
    {
        #region const fields
        public const int Count = 2;
        public const int Size = sizeof(int) * Count;
        #endregion
        #region readonly fields
        public static readonly Point2D Zero = new Point2D();
        private static readonly string FormatString = MatrixHelper.CreateVectorFormatString(Count);
        private readonly static string FormatableString = MatrixHelper.CreateVectorFormatableString(Count);
        #endregion
        #region static methods
        public static Point2D Add(Point2D left, Point2D right)
        {
            Point2D result;
            result.X = left.X + right.X;
            result.Y = left.Y + right.Y;
            return result;
        }
        public static void Add(ref Point2D left, ref  Point2D right, out Point2D result)
        {
            result.X = left.X + right.X;
            result.Y = left.Y + right.Y;
        }
        public static Point2D Subtract(Point2D left, Point2D right)
        {
            Point2D result;
            result.X = left.X - right.X;
            result.Y = left.Y - right.Y;
            return result;
        }
        public static void Subtract(ref Point2D left, ref  Point2D right, out Point2D result)
        {
            result.X = left.X - right.X;
            result.Y = left.Y - right.Y;
        }
        public static Point2D Multiply(Point2D source, int scalar)
        {
            Point2D result;
            result.X = source.X * scalar;
            result.Y = source.Y * scalar;
            return result;
        }
        public static void Multiply(ref Point2D source, ref  int scalar, out Point2D result)
        {
            result.X = source.X * scalar;
            result.Y = source.Y * scalar;
        }
 
        public static Point2D Multiply(int scalar, Point2D source)
        {
            Point2D result;
            result.X = scalar * source.X;
            result.Y = scalar * source.Y;
            return result;
        }
        public static void Multiply(ref int scalar, ref  Point2D source, out Point2D result)
        {
            result.X = scalar * source.X;
            result.Y = scalar * source.Y;
        }
 
        public static Point2D Negate(Point2D source)
        {
            Point2D result;
            result.X = -source.X;
            result.Y = -source.Y;
            return result;
        }
        public static void Negate(ref Point2D source)
        {
            Negate(ref source, out source);
        }
        public static void Negate(ref Point2D source, out Point2D result)
        {
            result.X = -source.X;
            result.Y = -source.Y;
        }
 
        public static Point2D Max(Point2D value1, Point2D value2)
        {
            Point2D result;
            Max(ref value1, ref value2, out result);
            return result;
        }
        public static void Max(ref Point2D value1, ref Point2D value2, out Point2D result)
        {
            result.X = (value1.X < value2.X) ? (value2.X) : (value1.X);
            result.Y = (value1.Y < value2.Y) ? (value2.Y) : (value1.Y);
        }
 
        public static Point2D Min(Point2D value1, Point2D value2)
        {
            Point2D result;
            Min(ref value1, ref value2, out result);
            return result;
        }
        public static void Min(ref Point2D value1, ref Point2D value2, out Point2D result)
        {
            result.X = (value1.X > value2.X) ? (value2.X) : (value1.X);
            result.Y = (value1.Y > value2.Y) ? (value2.Y) : (value1.Y);
        }
 
        #endregion
        #region fields
        [AdvBrowsable]
        [XmlAttribute]
#if !WINDOWS_STOREAPP
        [System.ComponentModel.Description("The Magnitude on the X-Axis")]
#endif
        public int X;
        [AdvBrowsable]
        [XmlAttribute]
#if !WINDOWS_STOREAPP
        [System.ComponentModel.Description("The Magnitude on the Y-Axis")]
#endif
        public int Y;
        #endregion
        #region constructors
        [InstanceConstructor("X,Y")]
        public Point2D(int X, int Y)
        {
            this.X = X;
            this.Y = Y;
        }
        #endregion
        #region operators
        public static Point2D operator +(Point2D left, Point2D right)
        {
            Point2D result;
            result.X = left.X + right.X;
            result.Y = left.Y + right.Y;
            return result;
        }
        public static Point2D operator -(Point2D left, Point2D right)
        {
            Point2D result;
            result.X = left.X - right.X;
            result.Y = left.Y - right.Y;
            return result;
        }
        public static Point2D operator *(Point2D source, int scalar)
        {
            Point2D result;
            result.X = source.X * scalar;
            result.Y = source.Y * scalar;
            return result;
        }
        public static Point2D operator *(int scalar, Point2D source)
        {
            Point2D result;
            result.X = scalar * source.X;
            result.Y = scalar * source.Y;
            return result;
        }
        public static Point2D operator -(Point2D source)
        {
            Point2D result;
            result.X = -source.X;
            result.Y = -source.Y;
            return result;
        }
 
        public static bool operator ==(Point2D left, Point2D right)
        {
            return left.X == right.X && left.Y == right.Y;
        }
        public static bool operator !=(Point2D left, Point2D right)
        {
            return !(left.X == right.X && left.Y == right.Y);
        }
 
 
 
 
        #endregion
        #region overrides
        private string ToStringInternal(string FormatString)
        {
            return string.Format(FormatString, X, Y);
        }
        public string ToString(string format)
        {
            return ToStringInternal(string.Format(FormatableString, format));
        }
        public override string ToString()
        {
            return ToStringInternal(FormatString);
        }
 
#if !CompactFramework && !WindowsCE && !PocketPC && !XBOX360 && !SILVERLIGHT 
        public static bool TryParse(string s, out Point2D result)
        {
            if (s == null)
            {
                result = Zero;
                return false;
            }
            string[] vals = ParseHelper.SplitStringVector(s);
            if (vals.Length != Count)
            {
                result = Zero;
                return false;
            }
            if (int.TryParse(vals[0], out result.X) &&
                int.TryParse(vals[1], out result.Y))
            {
                return true;
            }
            else
            {
                result = Zero;
                return false;
            }
        }
#endif
        [ParseMethod]
        public static Point2D Parse(string s)
        {
            if (s == null)
            {
                throw new ArgumentNullException("s");
            }
            string[] vals = ParseHelper.SplitStringVector(s);
            if (vals.Length != Count)
            {
                ThrowHelper.ThrowVectorFormatException(s, Count, FormatString);
            }
            Point2D value;
            value.X = int.Parse(vals[0]);
            value.Y = int.Parse(vals[1]);
            return value;
        }
        public override int GetHashCode()
        {
            return X.GetHashCode() ^ Y.GetHashCode();
        }
        public override bool Equals(object obj)
        {
            return (obj is Point2D) && Equals((Point2D)obj);
        }
        public bool Equals(Point2D other)
        {
            return Equals(ref this, ref other);
        }
        public static bool Equals(Point2D left, Point2D right)
        {
            return
                left.X == right.X &&
                left.Y == right.Y;
        }
        public static bool Equals(ref Point2D left, ref Point2D right)
        {
            return
                left.X == right.X &&
                left.Y == right.Y;
        }
        #endregion
    }
}