source: branches/2994-AutoDiffForIntervals/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/VectorOfAlgebraic.cs @ 17869

using System;
using System.Diagnostics;
using System.Linq;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
  // A vector where each element is an algebraic
  // Operations on the vector are broadcast to each element
  [DebuggerDisplay("VectorOfAlgebraic(len={Length}): {string}")]
  public class VectorOfAlgebraic<T> : IAlgebraicType<VectorOfAlgebraic<T>> where T : IAlgebraicType<T>, new() {
    private T[] arr;
    public T this[int idx] { get { return arr[idx]; } set { arr[idx] = value; } }
    public int Length => arr.Length;

    public VectorOfAlgebraic(int length) { arr = new T[length]; }

    public VectorOfAlgebraic() { }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="arr">array is not copied</param>
    public VectorOfAlgebraic(T[] arr) { this.arr = arr; }

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public VectorOfAlgebraic<T> Zero {
      get {
        var zero = new T[this.Length];
        for (int i = 0; i < zero.Length; i++) {
          zero[i] = new T(); // assumed to be initialized to zero
        }
        return new VectorOfAlgebraic<T>(zero);
      }
    }
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public VectorOfAlgebraic<T> One {
      get {
        var one = new T[this.Length];
        for (int i = 0; i < one.Length; i++) {
          one[i] = new T().One;
        }
        return new VectorOfAlgebraic<T>(one);
      }
    }

    public VectorOfAlgebraic<T> Assign(VectorOfAlgebraic<T> a) { for (int i = 0; i < arr.Length; ++i) { arr[i].Assign(a.arr[i]); } return this; }
    public VectorOfAlgebraic<T> Add(VectorOfAlgebraic<T> a) { for (int i = 0; i < arr.Length; ++i) { arr[i].Add(a.arr[i]); } return this; }
    public VectorOfAlgebraic<T> Sub(VectorOfAlgebraic<T> a) { for (int i = 0; i < arr.Length; ++i) { arr[i].Sub(a.arr[i]); } return this; }
    public VectorOfAlgebraic<T> Mul(VectorOfAlgebraic<T> a) { for (int i = 0; i < arr.Length; ++i) { arr[i].Mul(a.arr[i]); } return this; }
    public VectorOfAlgebraic<T> Div(VectorOfAlgebraic<T> a) { for (int i = 0; i < arr.Length; ++i) { arr[i].Div(a.arr[i]); } return this; }
    public VectorOfAlgebraic<T> AssignNeg(VectorOfAlgebraic<T> a) { for (int i = 0; i < arr.Length; ++i) { arr[i].AssignNeg(a.arr[i]); } return this; }
    public VectorOfAlgebraic<T> AssignInv(VectorOfAlgebraic<T> a) { for (int i = 0; i < arr.Length; ++i) { arr[i].AssignInv(a.arr[i]); } return this; }
    public VectorOfAlgebraic<T> Scale(double s) { for (int i = 0; i < arr.Length; ++i) { arr[i].Scale(s); } return this; }
    public VectorOfAlgebraic<T> AssignLog(VectorOfAlgebraic<T> a) { for (int i = 0; i < arr.Length; ++i) { arr[i].AssignLog(a.arr[i]); } return this; }
    public VectorOfAlgebraic<T> AssignSin(VectorOfAlgebraic<T> a) { for (int i = 0; i < arr.Length; ++i) { arr[i].AssignSin(a.arr[i]); } return this; }
    public VectorOfAlgebraic<T> AssignExp(VectorOfAlgebraic<T> a) { for (int i = 0; i < arr.Length; ++i) { arr[i].AssignExp(a.arr[i]); } return this; }
    public VectorOfAlgebraic<T> AssignCos(VectorOfAlgebraic<T> a) { for (int i = 0; i < arr.Length; ++i) { arr[i].AssignCos(a.arr[i]); } return this; }
    public VectorOfAlgebraic<T> AssignTanh(VectorOfAlgebraic<T> a) { for (int i = 0; i < arr.Length; ++i) { arr[i].AssignTanh(a.arr[i]); } return this; }
    public VectorOfAlgebraic<T> AssignIntPower(VectorOfAlgebraic<T> a, int p) { for (int i = 0; i < arr.Length; ++i) { arr[i].AssignIntPower(a.arr[i], p); } return this; }
    public VectorOfAlgebraic<T> AssignIntRoot(VectorOfAlgebraic<T> a, int r) { for (int i = 0; i < arr.Length; ++i) { arr[i].AssignIntRoot(a.arr[i], r); } return this; }
    public VectorOfAlgebraic<T> AssignAbs(VectorOfAlgebraic<T> a) { for (int i = 0; i < arr.Length; ++i) { arr[i].AssignAbs(a.arr[i]); } return this; }
    public VectorOfAlgebraic<T> AssignSgn(VectorOfAlgebraic<T> a) { for (int i = 0; i < arr.Length; ++i) { arr[i].AssignSgn(a.arr[i]); } return this; }

    public VectorOfAlgebraic<T> Clone() {
      var v = Zero; // create new zero vector
      v.Assign(this); // copy each element
      return v;
    }

    public VectorOfAlgebraic<T> AssignConstant(T constantValue) {
      for (int i = 0; i < arr.Length; ++i) {
        arr[i].Assign(constantValue);
      }
      return this;
    }

    public void CopyTo(T[] dest, int idx, int length) {
      throw new NotImplementedException(); // TODO: check if we need to copy all elements
      // Array.Copy(arr, 0, dest, idx, length); 
    }

    public void CopyFrom(T[] data, int rowIndex) {
      throw new NotImplementedException(); // TODO: check if we need to copy all elements
      // Array.Copy(data, rowIndex, arr, 0, Math.Min(arr.Length, data.Length - rowIndex));
    }
    public void CopyRowTo(T[,] dest, int row) {
      throw new NotImplementedException(); // TODO: check if we need to copy all elements
      // for (int j = 0; j < arr.Length; ++j) dest[row, j] = arr[j];
    }

    internal void CopyColumnTo(T[,] dest, int column, int row, int len) {
      throw new NotImplementedException(); // TODO: check if we need to copy all elements
      // for (int j = 0; j < len; ++j) dest[row + j, column] = arr[j];
    }

    public override string ToString() {
      return "{" + string.Join(", ", arr.Take(Math.Max(5, arr.Length))) + (arr.Length > 5 ? "..." : string.Empty) + "}";
    }
  }
}