/// <summary>
/// Accepts operation
/// </summary>
/// <param name="detector">Operation detector</param>
/// <param name="type">Operation type</param>
/// <returns>Operation</returns>
public static IObjectOperation Accept(OneVariableFunctionDetector detector, object type)
{
if (type is IOneVariableFunction)
{
try
{
IOneVariableFunction g = type as IOneVariableFunction;
return(new OneVariableReturn(OneVariableFuntionCompostion.Compose(g, detector.f)));
}
catch (Exception)
{
}
}
if (detector.f == null)
{
return(null);
}
if (type == null)
{
return(new OneVariableReturn(detector.f));
}
object t = detector.f.VariableType;
if (!type.Equals(t))
{
return(null);
}
return(detector.f);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="symbol">Symbol of variable</param>
/// <param name="measure">Measure</param>
/// <param name="detector">Detector of variables</param>
internal VariableMeasurement(string symbol, IMeasurement measure, IVariableDetector detector)
{
this.symbol = symbol;
this.measurement = measure;
this.detector = detector;
object par = measure.Type;
if (par is IOneVariableFunction)
{
func = par as IOneVariableFunction;
operationDetector = new OneVariableFunctionDetector(detector);
funcwrapper = new OneVariableFunctionDetector(func);
}
else if (par is Table2D)
{
table2D = par as Table2D;
}
else if (par is Table3D)
{
table3D = par as Table3D;
}
/*!!! else if (par is FuncReturn)
* {
* funcReturn = par as FuncReturn;
* //operationDetector = new FormulaEditor.Func.FuncDetector(detector, )
* }*/
else
{
acceptor = this;
}
tree = new ObjectFormulaTree(this, new List <ObjectFormulaTree>());
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="f">The f</param>
/// <param name="g">The g</param>
private OneVariableFuntionCompostion(IOneVariableFunction f, IOneVariableFunction g)
{
if (!f.ReturnType.Equals(g.VariableType))
{
throw new Exception();
}
this.f = f;
this.g = g;
fo = f;
go = g;
}
/// Initializes internal parameters to start the iterative process.
/// Assigns default derivative if necessary.
public override void InitializeIterations()
{
if (_df == null)
{
_df = new FunctionDerivative(_f);
}
if (double.IsNaN(_result))
{
_result = 0;
}
int n = 0;
Random random = new Random();
while (DhbMath.Equal(_df.Value(_result), 0))
{
if (++n > MaximumIterations)
{
break;
}
_result += random.NextDouble();
}
}
IObjectOperation IOperationAcceptor.Accept(object type)
{
/**!!!! if (funcReturn != null)
* {
* IOperationDetector d = new FormulaEditor.Func.FuncDetector(funcReturn, measurement.Parameter());
* }
*/
if (func != null)
{
func = measurement.Parameter() as IOneVariableFunction;
funcwrapper = new OneVariableFunctionDetector(func);
return(OneVariableFunctionDetector.Accept(funcwrapper, type));
}
if (table2D != null)
{
return(table2D);
}
if (table3D != null)
{
return(table3D);
}
return(this);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="f">The detected function</param>
public OneVariableFunctionDetector(IOneVariableFunction f)
{
this.f = f;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="f">The function to return</param>
internal OneVariableReturn(IOneVariableFunction f)
{
this.f = f;
}
/// @param func DhbInterfaces.OneVariableFunction
/// @param x1 location at which the function yields a negative value
/// @param x2 location at which the function yields a positive value
public BisectionZeroFinder(IOneVariableFunction func, double x1, double x2)
: this(func)
{
this.NegativeX = x1;
this.PositiveX = x2;
}
/// Constructor method.
/// @param func the function for which the derivative is computed.
/// @param precision the relative step used to compute the derivative.
public FunctionDerivative(IOneVariableFunction func, double precision)
{
_f = func;
_relativePrecision = precision;
}
/// @return OptimizingPoint an minimizing point strategy.
public override OptimizingPoint CreatePoint(double x, IOneVariableFunction f)
{
return(new MinimizingPoint(x, f));
}
/// Constructor method.
/// @param func the function for which the derivative is computed.
public FunctionDerivative(IOneVariableFunction func) : this(func, 0.000001)
{
}
/// Initializes internal parameters to start the iterative process.
/// Assigns default derivative if necessary.
public override void InitializeIterations()
{
if (_df == null)
_df = new FunctionDerivative(Function);
if (double.IsNaN(_result))
_result = 0;
int n = 0;
var random = new Random();
while (DhbMath.Equal(_df.Value(_result), 0))
{
if (++n > MaximumIterations)
break;
_result += random.NextDouble();
}
}
/// Constructor method.
/// @param func the function for which the zero will be found.
/// @param start the initial value for the search.
public NewtonZeroFinder(IOneVariableFunction func, double start) : base(func)
{
StartingValue = start;
}
/// Constructor method.
/// @param func the function for which the zero will be found.
/// @param start the initial value for the search.
public NewtonZeroFinder(IOneVariableFunction func, double start)
: base(func)
{
StartingValue = start;
}
/// Constructor method.
/// @param func the function for which the zero will be found.
/// @param dFunc derivative of func.
/// @param start the initial value for the search.
public NewtonZeroFinder(IOneVariableFunction func,
IOneVariableFunction dFunc, double start)
: this(func, start)
{
this.Derivative = dFunc;
}
/// @return DhbOptimizing.OptimizingPoint /// @param x double /// @param f IOneVariableFunction public abstract OptimizingPoint CreatePoint(double x, IOneVariableFunction f);
/// Constructor method
/// @param x double position at which the goal function is evaluated.
/// @param f IOneVariableFunction function to optimize.
public OptimizingPoint(double x, IOneVariableFunction f)
{
_position = x;
_value = f.Value(x);
}
/// <summary>
/// Composition g * f;
/// </summary>
/// <param name="f">The f</param>
/// <param name="g">The g</param>
/// <returns>The composition</returns>
static public IOneVariableFunction Compose(IOneVariableFunction f, IOneVariableFunction g)
{
return(new OneVariableFuntionCompostion(f, g));
}
protected FunctionalIterator(IOneVariableFunction func)
{
this.Function = func;
}
/// Constructor method.
/// @param func the function for which the zero will be found.
/// @param dFunc derivative of func.
/// @param start the initial value for the search.
public NewtonZeroFinder(IOneVariableFunction func,
IOneVariableFunction dFunc, double start) : this(func, start)
{
this.Derivative = dFunc;
}
/// Constructor method
/// @param func IOneVariableFunction
/// @param pointCreator OptimizingPointFactory a factory to create
/// strategy points
public OneVariableFunctionOptimizer(IOneVariableFunction func,
OptimizingPointFactory pointCreator)
: base(func)
{
_pointFactory = pointCreator;
}
public BisectionZeroFinder(IOneVariableFunction func)
: base(func)
{
}
/// @return double contribution to chi^2 sum against
/// a theoretical function
/// @param f DhbInterfaces.OneVariableFunction
public double Chi2Contribution(IOneVariableFunction f)
{
double residue = _yValue - f.Value(_xValue);
return residue * residue * _weight;
}
/// @param func DhbInterfaces.OneVariableFunction
public BisectionZeroFinder(IOneVariableFunction func) : base(func)
{
}
/// Constructor method.
/// @param func the function for which the derivative is computed.
/// @param precision the relative step used to compute the derivative.
public FunctionDerivative(IOneVariableFunction func, double precision)
{
_f = func;
_relativePrecision = precision;
}
/// Constructor method.
/// @param x double
/// @param f DhbInterfaces.IOneVariableFunction
public MinimizingPoint(double x, IOneVariableFunction f) : base(x, f)
{
}
/// Generic constructor.
/// @param func OneVariableFunction
/// @param start double
public FunctionalIterator(IOneVariableFunction func)
{
this.Function = func;
}
/// Constructor method.
/// @param func the function for which the derivative is computed.
public FunctionDerivative(IOneVariableFunction func)
: this(func, 0.000001)
{
}
/// @param func DhbInterfaces.OneVariableFunction
/// @param x1 location at which the function yields a negative value
/// @param x2 location at which the function yields a positive value
public BisectionZeroFinder(IOneVariableFunction func, double x1, double x2)
: this(func)
{
this.NegativeX = x1;
this.PositiveX = x2;
}
/// @return double contribution to chi^2 sum against
/// a theoretical function
/// @param f DhbInterfaces.OneVariableFunction
public double Chi2Contribution(IOneVariableFunction f)
{
double residue = _yValue - f.Value(_xValue);
return(residue * residue * _weight);
}