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

using System;
using System.Diagnostics;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
  public class Dual<V> : IAlgebraicType<Dual<V>>
    where V : IComparableAlgebraicType<V> {
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private V v;
    public V Value => v;

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private V dv;
    public V Derivative => dv;

    public Dual(V v, V dv) { this.v = v; this.dv = dv; }

    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public Dual<V> Zero => new Dual<V>(Value.Zero, Derivative.Zero);
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public Dual<V> One => new Dual<V>(Value.One, Derivative.Zero);

    public Dual<V> Assign(Dual<V> a) { v.Assign(a.v); dv.Assign(a.dv); return this; }
    public Dual<V> Scale(double s) { v.Scale(s); dv.Scale(s); return this; }
    public Dual<V> Add(Dual<V> a) { v.Add(a.v); dv.Add(a.dv); return this; }
    public Dual<V> Sub(Dual<V> a) { v.Sub(a.v); dv.Sub(a.dv); return this; }
    public Dual<V> AssignNeg(Dual<V> a) { v.AssignNeg(a.v); dv.AssignNeg(a.dv); return this; }
    public Dual<V> AssignInv(Dual<V> a) { v.AssignInv(a.v); dv.AssignNeg(a.dv).Mul(v).Mul(v); return this; } // (1/f(x))' = - f(x)' / f(x)^2

    // (a(x) * b(x))' = b(x)*a(x)' + b(x)'*a(x);
    public Dual<V> Mul(Dual<V> a) {
      var t1 = a.dv.Clone().Mul(v);
      var t2 = dv.Clone().Mul(a.v);
      dv.Assign(t1).Add(t2);

      v.Mul(a.v);
      return this;
    }
    public Dual<V> Div(Dual<V> a) { Mul(a.Inv()); return this; }

    public Dual<V> AssignExp(Dual<V> a) { v.AssignExp(a.v); dv.Assign(a.dv).Mul(v); return this; } // exp(f(x)) = exp(f(x))*f(x)'
    public Dual<V> AssignLog(Dual<V> a) { v.AssignLog(a.v); dv.Assign(a.dv).Div(a.v); return this; }     // log(x)' = 1/f(x) * f(x)' 

    public Dual<V> AssignIntPower(Dual<V> a, int p) { v.AssignIntPower(a.v, p); dv.Assign(a.dv).Scale(p).Mul(a.v.Clone().IntPower(p - 1)); return this; }
    public Dual<V> AssignIntRoot(Dual<V> a, int r) { v.AssignIntRoot(a.v, r); dv.Assign(a.dv).Scale(1.0 / r).Mul(a.v.IntRoot(r - 1)); return this; }

    public Dual<V> AssignSin(Dual<V> a) { v.AssignSin(a.v); dv.Assign(a.dv).Mul(a.v.Clone().Cos()); return this; }
    public Dual<V> AssignCos(Dual<V> a) { v.AssignCos(a.v); dv.AssignNeg(a.dv).Mul(a.v.Clone().Sin()); return this; }
    public Dual<V> AssignTanh(Dual<V> a) { v.AssignTanh(a.v); dv.Assign(a.dv.Mul(v.Clone().IntPower(2).Neg().Add(Value.One))); return this; }

    public Dual<V> AssignAbs(Dual<V> a) { v.AssignAbs(a.v); dv.Assign(a.dv).Mul(a.v.Clone().Sgn()); return this; }       // abs(f(x))' = f(x)*f'(x) / |f(x)|      
    public Dual<V> AssignSgn(Dual<V> a) { v.AssignSgn(a.v); dv.Assign(a.dv.Zero); return this; }

    public Dual<V> Clone() { return new Dual<V>(v.Clone(), dv.Clone()); }

    public Dual<V> AssignMin(Dual<V> other) {
      if(v.CompareTo(other.v) > 0) {
        v.Assign(other.v);
        dv.Assign(other.dv);
      }
      return this;
    }

    public Dual<V> AssignMax(Dual<V> other) {
      if (v.CompareTo(other.v) <= 0) {
        v.Assign(other.v);
        dv.Assign(other.dv);
      }
      return this;
    }
  }
}