Invert.cs

using System;
using System.Collections.Generic;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
 
namespace Waher.Script.Operators.Arithmetics
{
    public class Invert : UnaryOperator, IDifferentiable
    {
        public Invert(ScriptNode Operand, int Start, int Length, Expression Expression)
            : base(Operand, Start, Length, Expression)
        {
        }
 
        public override IElement Evaluate(IElement Operand, Variables Variables)
        {
            if (Operand is IRingElement E)
            {
                E = E.Invert();
                if (E is null)
                    throw new ScriptRuntimeException("Operand not invertible.", this);
                else
                    return E;
            }
            else if (Operand.IsScalar)
                throw new ScriptRuntimeException("Operand not invertible.", this);
            else
            {
                LinkedList<IElement> Elements = new LinkedList<IElement>();
 
                foreach (IElement E2 in Operand.ChildElements)
                    Elements.AddLast(this.Evaluate(E2, Variables));
 
                return Operand.Encapsulate(Elements, this);
            }
        }
 
        public ScriptNode Differentiate(string VariableName, Variables Variables)
        {
            int Start = this.Start;
            int Len = this.Length;
            Expression Expression = this.Expression;
 
            return this.DifferentiationChainRule(VariableName, Variables, this.op,
                new Negate(
                    new Invert(
                        new Square(this.op, Start, Len, Expression),
                        Start, Len, Expression),
                    Start, Len, Expression));
        }
 
        public override PatternMatchResult PatternMatch(IElement CheckAgainst, Dictionary<string, IElement> AlreadyFound)
        {
            if (!(CheckAgainst is EuclidianDomainElement E))
                return PatternMatchResult.NoMatch;
 
            IElement Inv = E.AssociatedEuclidianDomain.Divide(E.One, E);
            if (Inv is null)
                return PatternMatchResult.NoMatch;
 
            return this.op.PatternMatch(Inv, AlreadyFound);
        }
 
    }
}