C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/Mathematics/VectorN.cs

//-----------------------------------------------------------------------------
// VectorN.cs
// (A. Schiffler, 2009)
//-----------------------------------------------------------------------------

namespace NewGamePhysics.Mathematics
{
    using System;

    public class VectorN
    {
        int n;

        double [] x;

        public VectorN(int n)
        {
            if (n < 0)
            {
                throw new ArgumentOutOfRangeException("n","Size must be greater than zero.");
            }

            this.n = n;
            this.x = new double[n];
        }

        public VectorN(VectorN a)
        {
            this.n = a.n;
            this.x = new double[n];
            for (int i = 0; i < this.n; i++)
            {
                this.x[i] = a.x[i];
            }
        }

        public int N
        {
            get
            {
                return this.n;
            }
        }

        public double this[int i]
        {
            get
            {
                if (i < 0 || i >= this.n)
                {
                    throw new IndexOutOfRangeException("Index out of range.");
                }

                return this.x[i]; 
            }

            set
            {
                if (i < 0 || i >= this.n)
                {
                    throw new IndexOutOfRangeException("Index out of range.");
                }

                this.x[i] = value;
            }
        }

        public VectorN Copy()
        {            
            VectorN r = new VectorN(this.n);
            for (int i = 0; i < this.n; i++)
            {
                r.x[i] = this.x[i];
            }

            return r;
        }

        public double Abs()
        {
            double r = 0;
            for (int i = 0; i < this.n; i++)
            {
                double v = this.x[i];
                r += v * v;
            }

            r = Math.Sqrt(r);
            return r;
        }

        public static VectorN operator +(VectorN a, VectorN b)
        {
            if (a.n != b.n)
            {
                throw new ArgumentException("Vectors must be of same size");
            }

            VectorN r = new VectorN(a.n);
            for (int i = 0; i < a.n; i++)
            {
                r.x[i] = a.x[i] + b.x[i];
            }

            return r;
        }

        public static VectorN operator -(VectorN a, VectorN b)
        {
            if (a.n != b.n)
            {
                throw new ArgumentException("Vectors must be of same size");
            }

            VectorN r = new VectorN(a.n);
            for (int i = 0; i < a.n; i++)
            {
                r.x[i] = a.x[i] - b.x[i];
            }

            return r;
        }

        public static VectorN operator *(double c, VectorN a)
        {
            VectorN r = new VectorN(a.n);
            for (int i = 0; i < a.n; i++)
            {
                r.x[i] = c * a.x[i];
            }

            return r;
        }

        public static VectorN operator *(VectorN a, double c)
        {
            return c * a;
        }

        public static VectorN operator /(double c, VectorN a)
        {
            for (int i = 0; i < a.n; i++)
            {
                if (a[i] == 0.0)
                {
                    throw new ArgumentOutOfRangeException("a", "All components must be non-zero");
                }
            }

            VectorN r = new VectorN(a.n);
            for (int i = 0; i < a.n; i++)
            {
                r.x[i] = c / a.x[i];
            }

            return r;
        }

        public static VectorN operator /(VectorN a, double c)
        {
            if (c == 0.0)
            {
                throw new ArgumentOutOfRangeException("c", "Must be non-zero");
            }

            double d = 1.0 / c;
            return d * a;
        }
    }
}

---