Fun with Physics: Implementing a Physics based layout manager

using System;

namespace Bornander.UI.Physics
{
    /// <summary>
    /// A representation of a 2D vector.
    /// </summary>
    public class Vector
    {
        public static readonly Vector Empty = new Vector();

        public Vector()
        {
            X = 0.0f;
            Y = 0.0f;
        }

        public Vector(float x, float y)
        {
            this.X = x;
            this.Y = y;
        }

        public Vector(Vector vector)
        {
            this.X = vector.X;
            this.Y = vector.Y;
        }

        public void Normalize()
        {
            float length = Length;
            if (length > 0.0f)
            {
                X /= length;
                Y /= length;
            }
            else
            {
                X = 0.0f;
                Y = 0.0f;
            }
        }

        #region Public properties

        public float Length
        {
            get { return (float)Math.Sqrt(X * X + Y * Y); }
        }

        public float X
        {
            get;
            set;
        }

        public float Y
        {
            get;
            set;
        }

        #endregion

        #region Public static methods/operators

        public static Vector Normalize(Vector vector)
        {
            float length = vector.Length;
            if (length > 0.0f)
                return new Vector(vector.X / length, vector.Y / length);
            else
                return Vector.Empty;
        }

        public static Vector operator +(Vector lhs, Vector rhs)
        {
            return new Vector(lhs.X + rhs.X, lhs.Y + rhs.Y);
        }

        public static Vector operator -(Vector lhs, Vector rhs)
        {
            return new Vector(lhs.X - rhs.X, lhs.Y - rhs.Y);
        }

        public static Vector operator *(Vector lhs, float rhs)
        {
            return new Vector(lhs.X * rhs, lhs.Y * rhs);
        }

        public static float Dot(Vector lhs, Vector rhs)
        {
            return lhs.X * rhs.X + lhs.Y * rhs.Y;
        }

        public static float DistanceBetween(Vector lhs, Vector rhs)
        {
            return (lhs - rhs).Length;
        }

        public static explicit operator Vector(System.Drawing.Point point)
        {
            return new Vector(point.X, point.Y);
        }

        public static explicit operator System.Drawing.Point(Vector vector)
        {
            return new System.Drawing.Point((int)vector.X, (int)vector.Y);
        }

        #endregion
    }
}