internal void SetTree(ObjectFormulaTree tree,
bool next,
AssociatedAddition addition,
IList <IMeasurement> list)
{
string dn = "D" + symbol;
this.tree = tree;
IDistribution d = DeltaFunction.GetDistribution(tree);
if (next)
{
if (d != null)
{
temp = new FormulaMeasurementDerivationDistribution(tree, null, symbol, addition);
}
else
{
temp = new FormulaMeasurementDerivation(tree, null, symbol, addition);
}
derivation = temp;
list.Add(derivation);
return;
}
if (d != null)
{
derivation = new FormulaMeasurementDistribution(tree, symbol, addition);
}
else
{
derivation = new FormulaMeasurement(tree, symbol, addition);
}
list.Add(derivation);
return;
}
/// <summary>
/// Iterates calculation of derivation
/// </summary>
/// <param name="next">The "next" msign</param>
/// <param name="addition">Associated addition</param>
/// <returns>Next derivation iteration</returns>
public FormulaMeasurementDerivation Iterate(bool next, AssociatedAddition addition)
{
string dn = "D" + name;
ObjectFormulaTree t = tree.Derivation("d/dt");
IDistribution d = DeltaFunction.GetDistribution(t);
AssociatedAddition aa = FormulaMeasurementDerivation.Create(associated);
if (next)
{
FormulaMeasurementDerivation der = null;
if (d != null)
{
der = new FormulaMeasurementDerivationDistribution(t, dn, aa);
}
else
{
der = new FormulaMeasurementDerivation(t, dn, aa);
}
derivation = der;
return(der);
}
if (d != null)
{
derivation = new FormulaMeasurementDistribution(t, dn, aa);
}
else
{
derivation = new FormulaMeasurement(t, dn, aa);
}
return(null);
}
/// <summary>
/// Creates measure
/// </summary>
/// <param name="tree">Tree</param>
/// <param name="n">Number of tree</param>
/// <param name="name">Name</param>
/// <param name="associated">Associated addition</param>
/// <returns>Measurement</returns>
public static FormulaMeasurement Create(ObjectFormulaTree tree, int n,
string name, AssociatedAddition associated)
{
object ret = null;
try
{
ret = tree.Result;
}
catch (Exception ex)
{
ex.ShowError(-1);
}
FormulaMeasurement fm;
if (n == 0)
{
IDistribution d = DeltaFunction.GetDistribution(tree);
if (d != null)
{
return(new FormulaMeasurementDistribution(tree, name, associated));
}
fm = new FormulaMeasurement(tree, name, associated);
fm.ret = ret;
return(fm);
}
string dn = "D" + name;
ObjectFormulaTree t = tree.Derivation("d/dt");
if (t == null)
{
throw new Exception("VariableMeasure.Derivation");
}
AssociatedAddition aa = FormulaMeasurementDerivation.Create(associated);
FormulaMeasurement der = Create(t, n - 1, dn, aa);
fm = new FormulaMeasurementDerivation(tree, der, name, aa);
try
{
fm.ret = t.Result;
}
catch (Exception exc)
{
exc.ShowError(10);
}
return(fm);
}
private static ObjectFormulaTree[] GetTreesLocal(FormulaMeasurement[] meas, List <ObjectFormulaTree> list,
List <FormulaMeasurement> globalList)
{
foreach (FormulaMeasurement m in meas)
{
if (!list.Contains(m.tree))
{
list.Add(m.tree);
}
}
List <FormulaMeasurement> l = new List <FormulaMeasurement>();
foreach (FormulaMeasurement mea in meas)
{
if (mea is IDerivation)
{
IDerivation d = mea as IDerivation;
if (d is FormulaMeasurement)
{
FormulaMeasurement fm = d.Derivation as FormulaMeasurement;
if (!globalList.Contains(fm))
{
globalList.Add(fm);
if (!list.Contains(fm.tree))
{
if (!l.Contains(fm))
{
l.Add(fm);
if (!list.Contains(fm.tree))
{
list.Add(fm.tree);
}
}
}
}
}
}
}
if (l.Count > 0)
{
GetTreesLocal(l.ToArray(), list, globalList);
}
return(list.ToArray());
}
/// <summary>
/// Accepts formulas
/// </summary>
private void acceptFormulas()
{
try
{
AssociatedAddition aa = new AssociatedAddition(this, null);
int n = Dimension;
measurements = new FormulaMeasurement[n];
result = new object[n, 2];
for (int i = 0; i < n; i++)
{
MathFormula formula = MathFormula.FromString(MathSymbolFactory.Sizes, formulaString[i]);
MathFormula f = formula.FullTransform(null);
ObjectFormulaTree t = ObjectFormulaTree.CreateTree(f, ElementaryFunctionsCreator.Object);
measurements[i] = FormulaMeasurement.Create(t, deriOrder, Formula_ + (i + 1), aa);
}
}
catch (Exception e)
{
e.ShowError(10);
this.Throw(e);
}
}
/// <summary>
/// Accepts formulas
/// </summary>
public void AcceptFormulas()
{
try
{
int n = Dimension;
measurements = new FormulaMeasurement[n];
formula = new MathFormula[n];
result = new object[n, 2];
parameters.Clear();
arguments.Clear();
par = null;
for (int i = 0; i < n; i++)
{
MathFormula form = MathFormula.FromString(MathSymbolFactory.Sizes, formulaString[i]);
formula[i] = form;
}
allVariables = ElementaryObjectDetector.GetVariables(formula);
}
catch (Exception e)
{
e.ShowError(10);
this.Throw(e);
}
}
public FormulaMeasurementDerivation(ObjectFormulaTree tree,
FormulaMeasurement derivation, string name, AssociatedAddition associated)
: base(tree, name, associated)
{
this.derivation = derivation;
}
public FormulaMeasurementDerivationDistribution(ObjectFormulaTree tree,
FormulaMeasurement derivation,
string name, AssociatedAddition associated)
: base(tree, derivation, name, associated)
{
}
