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

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
  /// <summary>
  /// A sparse vector of algebraic types. Elements are accessed via a key of type K
  /// </summary>
  /// <typeparam name="K">Key type</typeparam>
  /// <typeparam name="T">Element type</typeparam>
  [DebuggerDisplay("SparseVector: {ToString()}")]
  public sealed class AlgebraicSparseVector<K, T> : IAlgebraicType<AlgebraicSparseVector<K, T>> where T : IAlgebraicType<T> {
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private Dictionary<K, T> elems;
    public IReadOnlyDictionary<K, T> Elements => elems;


    public AlgebraicSparseVector(AlgebraicSparseVector<K, T> original) {
      elems = original.elems.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Clone());
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="keys"></param>
    /// <param name="values">values are cloned</param>
    public AlgebraicSparseVector(K[] keys, T[] values) {
      if (keys.Length != values.Length) throw new ArgumentException("lengths of keys and values doesn't match in SparseVector");
      elems = new Dictionary<K, T>(keys.Length);
      for (int i = 0; i < keys.Length; ++i) {
        elems.Add(keys[i], values[i].Clone());
      }
    }

    public AlgebraicSparseVector() {
      this.elems = new Dictionary<K, T>();
    }

    // keep only elements from a
    private void AssignFromSource(AlgebraicSparseVector<K, T> a, Func<T, T, T> mapAssign) {
      // remove elems from this which don't occur in a
      List<K> keysToRemove = new List<K>();
      foreach (var kvp in elems) {
        if (!a.elems.ContainsKey(kvp.Key)) keysToRemove.Add(kvp.Key);
      }
      foreach (var o in keysToRemove) elems.Remove(o); // -> zero

      foreach (var kvp in a.elems) {
        if (elems.TryGetValue(kvp.Key, out T value))
          mapAssign(kvp.Value, value);
        else
          elems.Add(kvp.Key, mapAssign(kvp.Value, kvp.Value.Zero));
      }
    }

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public AlgebraicSparseVector<K, T> Zero => new AlgebraicSparseVector<K, T>();
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public AlgebraicSparseVector<K, T> One => throw new NotSupportedException();

    public AlgebraicSparseVector<K, T> Scale(T s) { foreach (var kvp in elems) { kvp.Value.Mul(s); } return this; }
    public AlgebraicSparseVector<K, T> Scale(double s) { foreach (var kvp in elems) { kvp.Value.Scale(s); } return this; }

    public AlgebraicSparseVector<K, T> Assign(AlgebraicSparseVector<K, T> a) { elems.Clear(); AssignFromSource(a, (src, dest) => dest.Assign(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignInv(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignInv(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignNeg(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignNeg(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignLog(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignLog(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignExp(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignExp(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignIntPower(AlgebraicSparseVector<K, T> a, int p) { AssignFromSource(a, (src, dest) => dest.AssignIntPower(src, p)); return this; }
    public AlgebraicSparseVector<K, T> AssignIntRoot(AlgebraicSparseVector<K, T> a, int r) { AssignFromSource(a, (src, dest) => dest.AssignIntRoot(src, r)); return this; }
    public AlgebraicSparseVector<K, T> AssignSin(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignSin(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignCos(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignCos(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignTanh(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignTanh(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignAbs(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignAbs(src)); return this; }
    public AlgebraicSparseVector<K, T> AssignSgn(AlgebraicSparseVector<K, T> a) { AssignFromSource(a, (src, dest) => dest.AssignSgn(src)); return this; }
    public AlgebraicSparseVector<K, T> Add(AlgebraicSparseVector<K, T> a) {
      foreach (var kvp in a.elems) {
        if (elems.TryGetValue(kvp.Key, out T value))
          value.Add(kvp.Value);
        else
          elems.Add(kvp.Key, kvp.Value.Clone()); // 0 + a
      }
      return this;
    }

    public AlgebraicSparseVector<K, T> Sub(AlgebraicSparseVector<K, T> a) {
      foreach (var kvp in a.elems) {
        if (elems.TryGetValue(kvp.Key, out T value))
          value.Sub(kvp.Value);
        else
          elems.Add(kvp.Key, kvp.Value.Zero.Sub(kvp.Value)); // 0 - a
      }
      return this;
    }

    public AlgebraicSparseVector<K, T> Mul(AlgebraicSparseVector<K, T> a) {
      var keys = elems.Keys.ToArray();
      foreach (var k in keys) if (!a.elems.ContainsKey(k)) elems.Remove(k); // 0 * a => 0
      foreach (var kvp in a.elems) {
        if (elems.TryGetValue(kvp.Key, out T value))
          value.Mul(kvp.Value); // this * a
      }
      return this;
    }

    public AlgebraicSparseVector<K, T> Div(AlgebraicSparseVector<K, T> a) {
      return Mul(a.Clone().Inv());
    }

    public AlgebraicSparseVector<K, T> Clone() {
      return new AlgebraicSparseVector<K, T>(this);
    }

    public override string ToString() {
      return "[" + string.Join(" ", elems.Select(kvp => kvp.Key + ": " + kvp.Value)) + "]";
    }
  }
}