ArcSecH.cs

using System;
using System.Numerics;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Script.Operators.Arithmetics;
 
namespace Waher.Script.Functions.Analytic
{
    public class ArcSecH : FunctionOneScalarVariable, IDifferentiable
    {
        public ArcSecH(ScriptNode Argument, int Start, int Length, Expression Expression)
            : base(Argument, Start, Length, Expression)
        {
        }
 
        public override string FunctionName => nameof(ArcSecH);
 
        public override string[] Aliases
        {
            get { return new string[] { "asech" }; }
        }
 
        public ScriptNode Differentiate(string VariableName, Variables Variables)
        {
            if (VariableName == this.DefaultVariableName)
            {
                int Start = this.Start;
                int Len = this.Length;
                Expression Exp = this.Expression;
 
                return this.DifferentiationChainRule(VariableName, Variables, this.Argument,
                    new Invert(
                        new Negate(
                            new Multiply(
                                this.Argument,
                                new Sqrt(
                                    new Subtract(
                                        new ConstantElement(DoubleNumber.OneElement, Start, Len, Exp),
                                        new Square(this.Argument, Start, Len, Exp),
                                        Start, Len, Exp),
                                    Start, Len, Exp),
                                Start, Len, Exp),
                            Start, Len, Exp),
                        Start, Len, Exp));
            }
            else
                return new ConstantElement(DoubleNumber.ZeroElement, this.Start, this.Length, this.Expression);
        }
 
        public override IElement EvaluateScalar(double Argument, Variables Variables)
        {
            double d = 1 / Argument;
            return new DoubleNumber(Math.Log(d + Math.Sqrt(d * d - 1)));
        }
 
        public override IElement EvaluateScalar(Complex Argument, Variables Variables)
        {
            Complex d = Complex.Reciprocal(Argument);
            return new ComplexNumber(Complex.Log(d + Complex.Sqrt(d * d - Complex.One)));
        }
    }
}