LogOperator.cs

namespace SymSharp;

/// <summary>
/// Represents the natural logarithm (ln) of an inner expression.
/// </summary>
public class LogOperator : IUnaryOperator
{
    /// <summary>
    /// The inner expression to take the logarithm of.
    /// </summary>
    private readonly IMathExpression inner;

    /// <summary>
    /// Gets the inner expression.
    /// </summary>
    public IMathExpression Inner => inner;

    /// <summary>
    /// Constructs a natural logarithm operator wrapping the specified inner expression.
    /// </summary>
    /// <param name="inner">The inner expression.</param>
    public LogOperator(IMathExpression inner)
    {
        this.inner = inner;
    }

    /// <summary>
    /// Returns a textual representation of the logarithm.
    /// </summary>
    public override string ToString()
    {
        return $"ln({Inner})";
    }

    /// <summary>
    /// Simplifies the logarithm, evaluating ln(constant) when possible.
    /// </summary>
    public IMathExpression Simplified()
    {
        IMathExpression simplifiedInner = Inner.Simplified();

        ///// I doubt we need this
        // // Case: ln(constant) → evaluate directly
        // if (simplifiedInner is Scalar s)
        // {
        //     return new Scalar(Math.Log(s.ToDouble()));
        // }

        // Default: keep symbolic
        return new LogOperator(simplifiedInner);
    }

    /// <summary>
    /// Computes the derivative of ln(f(x)): f'(x) / f(x).
    /// </summary>
    /// <param name="varname">The variable name to differentiate with respect to.</param>
    public IMathExpression Derivative(string varname)
    {
        // d/dx ln(f(x)) = f'(x) / f(x)
        return new DivideOperator(Inner.Derivative(varname), Inner).Simplified();
    }
}