source: branches/2925_AutoDiffForDynamicalModels/HeuristicLab.Problems.DynamicalSystemsModelling/3.3/Vector.cs @ 16600

using System;
using System.Diagnostics;

namespace HeuristicLab.Problems.DynamicalSystemsModelling {
  public class Vector {
    public readonly static Vector Zero = new Vector(new double[0]);

    public static Vector operator +(Vector a, Vector b) {
      if (a == Zero) return b;
      if (b == Zero) return a;
      Trace.Assert(a.arr.Length == b.arr.Length);
      var res = new double[a.arr.Length];
      for (int i = 0; i < res.Length; i++)
        res[i] = a.arr[i] + b.arr[i];
      return new Vector(res);
    }

    // public static Vector AddTo(Vector a, Vector b) {
    //   if (b == Zero) return a;
    //   if (a == Zero) {
    //     var vArr = new double[b.Length];
    //     b.CopyTo(vArr);
    //     return new Vector(vArr);
    //   } else {
    //     Trace.Assert(a.arr.Length == b.arr.Length);
    //     for (int i = 0; i < a.arr.Length; i++)
    //       a.arr[i] += b.arr[i];
    //     return a;
    //   }
    // }


    public static Vector Subtract(Vector a, Vector b) {
      if (b == Zero) return a;
      if (a == Zero) {
        var vArr = new double[b.Length];
        a = new Vector(vArr);
      }
      Trace.Assert(a.arr.Length == b.arr.Length);
      var res = new double[a.arr.Length];
      for (int i = 0; i < a.arr.Length; i++)
        res[i] = a.arr[i] - b.arr[i];
      return new Vector(res);
    }

    public static Vector operator -(Vector a, Vector b) {
      return Subtract(a, b);
    }
    public static Vector operator -(Vector v) {
      return v.Scale(-1.0);
    }

    public static Vector operator *(double s, Vector v) {
      return v.Scale(s);
    }

    public Vector Scale(double s) {
      if (this == Zero) return Zero;

      var res = new double[arr.Length];
      for (int i = 0; i < arr.Length; i++) {
        res[i] = arr[i] * s;
      }
      return new Vector(res);

    }

    public static Vector operator *(Vector v, double s) {
      return s * v;
    }

    public static Vector operator *(Vector u, Vector v) {
      if (v == Zero) return Zero;
      if (u == Zero) return Zero;
      var res = new double[v.arr.Length];
      for (int i = 0; i < res.Length; i++)
        res[i] = u.arr[i] * v.arr[i];
      return new Vector(res);
    }

    public static Vector operator /(double s, Vector v) {
      if (s == 0.0) return Zero;
      if (v == Zero) throw new ArgumentException("Division by zero vector");
      var res = new double[v.arr.Length];
      for (int i = 0; i < res.Length; i++)
        res[i] = s / v.arr[i];
      return new Vector(res);
    }

    public static Vector operator /(Vector v, double s) {
      return v.Scale(1.0 / s);
    }

    public static Vector Sin(Vector s) {
      var res = new double[s.arr.Length];
      for (int i = 0; i < res.Length; i++) res[i] = Math.Sin(s.arr[i]);
      return new Vector(res);
    }
    public static Vector Cos(Vector s) {
      var res = new double[s.arr.Length];
      for (int i = 0; i < res.Length; i++) res[i] = Math.Cos(s.arr[i]);
      return new Vector(res);
    }

    public double this[int idx] {
      get {
        if (this == Vector.Zero) return 0.0;
        else return arr[idx];
      }
      set {
        if (this == Vector.Zero) throw new InvalidOperationException();
        else arr[idx] = value;
      }
    }

    public int Length {
      get {
        if (this == Vector.Zero) throw new InvalidOperationException();
        else return arr.Length;
      }
    }

    private readonly double[] arr; // backing array;

    /// <summary>
    /// 
    /// </summary>
    /// <param name="v">Is not cloned!</param>
    public Vector(double[] v) {
      this.arr = v;
    }

    public void CopyTo(double[] target) {
      Trace.Assert(arr.Length <= target.Length);
      Array.Copy(arr, target, arr.Length);
    }

    /// <summary>
    /// Creates a new vector
    /// </summary>
    /// <param name="a"> is cloned</param>
    /// <returns></returns>
    public static Vector CreateNew(double[] a) {
      var arr = new double[a.Length];
      Array.Copy(a, arr, arr.Length);
      return new Vector(arr);
    }

    /// <summary>
    /// Creates a new vector
    /// </summary>
    /// <param name="v"> is cloned</param>
    /// <returns></returns>
    public static Vector CreateNew(Vector v) {
      if (v == Zero) return Zero;
      var arr = new double[v.arr.Length];
      Array.Copy(v.arr, arr, arr.Length);
      return new Vector(arr);
    }
  }
}