DerivativeFunction

FunctionF<1>FunctionWithCachingFunction
[IoId("00000000-E7EF-4CA4-BA45-593FB17B0A3A")] public sealed class DerivativeFunction : FunctionF<Function>
The derivative of a function.

Constructors

DerivativeFunction

#
public DerivativeFunction()

DerivativeFunction

#
public DerivativeFunction(Function f)
Parameters:
f (Function)

DerivativeFunction

#
public DerivativeFunction(IReader reader)
Parameters:
reader (IReader)

Properties

Derivative

public sealed override Function Derivative { get; }
Gets a function which is the derivative of this function. The returned function may be either analytic or approximate.
inherited fromFunctionWithCaching
Overrides: Function.Derivative

F

public T1 F { get; }
First operand.
inherited fromFunctionF<T1>

Integral

public sealed override Function Integral { get; }
Gets a function which is the indefinite integral of this function. The returned function may be analytic or approximate. Note that numeric approximation of indefinite integrals is a slow and not particularly high quality process.
inherited fromFunctionWithCaching
Overrides: Function.Integral

Nomen

public sealed override Nomen Nomen { get; }
Gets a description of this function.
inherited fromFunctionWithCaching
Overrides: Function.Nomen

Notation

public override string Notation { get; }
Gets the notation for this function. Notation is aimed at humans and does not need to return a parseable string.
inherited fromFunctionWithCaching
Overrides: Function.Notation

Ui

#
public override FunctionUi Ui { get; }
Overrides: Function.Ui

Methods

Asymptotes

public virtual Line[] Asymptotes()
Returns an array of *all* the non-vertical asymptotes for this function. This property may return both null and empty arrays, implying no asymptotes. Due to the nature of non-vertical asymptotes, there can only be a finite amount of them.
inherited fromFunction

AutoCoDomain

protected void AutoCoDomain(double x0, double x1, out double y0, out double y1, int samples = 100)
Compute the automatic codomain for a given domain.
inherited fromFunction
Parameters:
x0 (double)Domain start.
x1 (double)Domain end.
y0 (out double)Lowest value in codomain.
y1 (out double)Highest value in codomain.
samples (int = 100)Samples.

DomainEstimate

public override void DomainEstimate(out double x0, out double x1, out double y0, out double y1)
inherited fromFunctionF<T1>
Parameters:
x0 (out double)
x1 (out double)
y0 (out double)
y1 (out double)
Overrides: Function.DomainEstimate

EmitDerivative

protected virtual Function EmitDerivative()
Override this method to provide an analytic derivative.
inherited fromFunctionWithCaching

EmitIntegral

#
protected override Function EmitIntegral()
Overrides: FunctionWithCaching.EmitIntegral

Holes

#
public override Interval[] Holes(double x0, double x1)
Every value comes from the derivative, not from F, so the derivative is what gets asked. Differentiating tends to add features rather than keep them where they were - a kink in F is a jump in Fʹ - and the derivative function is the one that knows where they ended up.
Parameters:
x0 (double)
x1 (double)
Overrides: FunctionF<T1>.Holes

Integrate

#
public override double Integrate(double x0, double x1)
Parameters:
x0 (double)
x1 (double)
Overrides: Function.Integrate

Poles

#
public override Pole[] Poles(double x0, double x1)
Every value comes from the derivative, not from F, so the derivative is what gets asked. Differentiating tends to add features rather than keep them where they were - a kink in F is a jump in Fʹ - and the derivative function is the one that knows where they ended up.
Parameters:
x0 (double)
x1 (double)
Overrides: FunctionF<T1>.Poles

Store

public override void Store(IWriter writer)
inherited fromFunctionF<T1>
Parameters:
writer (IWriter)
Overrides: FunctionWithCaching.Store

Y

#
public override double Y(double x)
Parameters:
x (double)
Overrides: Function.Y

YYYY

public double[] YYYY(double[] x)
Evaluate a large amount of values. Functions may choose to use multiple threads to perform this calculation. This method should not throw, instead every failed evaluation will be represented by a NaN value.
inherited fromFunction
Parameters:
x (double[])Value to evaluate.
Returns: Evaluation results. Array will contain double.NaN entries for failed evaluations.