public void Call()
{
Expression exp = Expression.Parse("sin(x)");
Functionf f = exp.GetFunctionf(exp.Params, FunctionSet.Default);
Assert.AreEqual(f(0.0f), 0.0);
}
/// <summary>
/// Computes derivate at x0, using order 4 formulea.
/// </summary>
/// <param name="f">The function.</param>
/// <param name="x0">Point where differentiation is needed.</param>
/// <returns>Result.</returns>
/// <param name="h">The delta.</param>
public static float DerivateOrder4([NotNull] Functionf f, float x0, float h)
{
return(((float)8.0 * (f(x0 + h) - f(x0))
- (f(x0 + (float)2 * h)
- f(x0 - (float)2 * h)))
/ ((float)12.0 * h));
}
public void Multicall()
{
Expression exp = Expression.Parse("log(x, 10)");
Functionf f = exp.GetFunctionf(exp.Params, FunctionSet.Default);
Assert.AreEqual(f(1.0f), 0.0f);
}
public void QuadraticTest()
{
Expression exp = Expression.Parse("quadratic", "(3+2)^2*x^2+(7/4)*x+(x/4)");
Expression.FunctionParams p = exp.Params;
Functionf f = exp.GetFunctionf(p, FunctionSet.Default);
Assert.AreEqual(f(1.0f), (25.0f + 7.0f / 4.0f + 0.25f));
}
public void LinearTest()
{
// Prepare; x must be auto bound.
Expression exp = Expression.Parse("linear", "k*x+n");
Expression.FunctionParams p = exp.GetParams(true);
p["k"] = 2.0;
p["n"] = -2.0;
Functionf f = exp.GetFunctionf(p, FunctionSet.Default);
Assert.AreEqual(f(1.0f), 0.0f);
Assert.AreEqual(f(2.0f), 2.0f);
}
public void IdentityTest()
{
// Construct expression.
Expression exp = Expression.Parse("x");
Expression.FunctionParams p = exp.Params;
p.SetBinding("x", exp.Variable(0));
Functionf f = exp.GetFunctionf(p, null);
// Test it.
for (float x = 0.0f; x < 100.0f; x += 1.0f)
{
Assert.AreEqual(f(x), x);
}
}
//#ifdef FunctionDelegateClassName
/// <summary>
/// Samples the specified function.
/// </summary>
/// <param name="function">The function.</param>
/// <param name="count">The count.</param>
/// <returns></returns>
public float[] Sample(
[NotNull] Functionf f,
[MinUInt(2)] uint count)
{
float range = Range;
float dcount = (float)(count - 1);
float[] result = new float[count];
for (int i = 0; i < count; i++)
{
result[i] = f(A + (float)i / dcount * Range);
}
return(result);
}
/// <summary>
/// Creates a derivate function using samples.
/// </summary>
/// <param name="f">The function.</param>
/// <param name="interval">Interval where to compute derivate.</param>
/// <param name="samples">Number of samples.</param>
/// <param name="h">The delta for computation.</param>
/// <param name="order">Order of differentiation.</param>
/// <returns>Function, a polynomial.</returns>
public static Functions.Polynomial Derivate([NotNull] Functionf f,
Intervalf interval, uint samples, uint order, float h)
{
return(null);
}
/// <summary>
/// Creates a derivate function using samples.
/// </summary>
/// <param name="f">The function.</param>
/// <param name="interval">Interval where to compute derivate.</param>
/// <param name="samples">Number of samples.</param>
/// <param name="h">The delta for computation.</param>
/// <returns>Function, a polynomial in compact compiled form.</returns>
public static Functionf Derivate([NotNull] Functionf f, Intervalf interval, uint samples, float h)
{
return(null);
}
/// <summary>
/// A derivate of order n calculation.
/// </summary>
/// <param name="f">The function.</param>
/// <param name="x0">Actual value where the function is to be differentiated.</param>
/// <param name="order">Order of differentiation.</param>
/// <param name="h">Delta for computation.</param>
/// <returns>Result.</returns>
public static float Derivate([NotNull] Functionf f, float x0, uint order, float h)
{
throw new NotImplementedException();
}
//#endfor instanced to 'Double'
//#foreach instanced to 'Float'
#region float
#region Point Differentiation
/// <summary>
/// Computes derivate at x0, using order 2 (not very precise).
/// </summary>
/// <param name="f">The function.</param>
/// <param name="x0">Point where derivate is to be computed.</param>
/// <returns>Derivate (slope, tangents of angle between axis x and tangent).</returns>
/// <param name="h">The delta.</param>
public static float DerivateOrder2([NotNull] Functionf f, float x0, float h)
{
return((f(x0 + h) - f(x0 - h)) / ((float)2.0 * h));
}
public RecursiveSeriesf(float initial, [NotNull] Functionf f)
{
this.initial = initial;
this.f = f;
}
/// <summary>
/// Adds a function to set. It can override one.
/// </summary>
/// <param name="name">The name of function.</param>
/// <param name="f">The floating version of function.</param>
/// <param name="d">The double version of function.</param>
public void Add([NotEmpty] string name, [NotNull] Functionf f, [NotNull] Functiond d)
{
doubleSet[name] = d;
floatSet[name] = f;
}
/// <summary>
/// Quadratic integrator.
/// </summary>
/// <param name="func"></param>
/// <param name="range"></param>
public QuadraticIntegratorf(Functionf func, Intervalf range)
{
this.func = func;
this.range = range;
}