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>
/// Updates itself
/// </summary>
public virtual void Update()
{
try
{
object o = tree.Result;
checkValue(o);
ret = o;
}
catch (Exception ex)
{
ex.ShowError(10);
object o = associated.Additional;
object ot = null;
if (o == null)
{
ot = name;
}
else if (o is object[])
{
List <object> l = new List <object>();
l.AddRange(o as object[]);
l.Add(name);
ot = l.ToArray();
}
else
{
ot = new object[] { o, name };
}
AssociatedAddition aa =
new AssociatedAddition(associated.AssociatedObject, ot);
AssociatedException.Throw(aa, ex);
}
}
/// <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);
}
private void CreateProxyInternal()
{
try
{
List <IMeasurement> outNew = new List <IMeasurement>();
update = UpdateFormulas;
proxy = null;
proxy = this.CreateProxy();
//int k = 0;
dictF = new Dictionary <char, FormulaMeasurement>();
AssociatedAddition aa = new AssociatedAddition(this, null);
foreach (char c in variables.Keys)
{
object[] o = variables[c] as object[];
ObjectFormulaTree tree = o[1] as ObjectFormulaTree;
FormulaMeasurement fm = FormulaMeasurement.Create(tree, 0, c + "", aa);
dictF[c] = fm;
outNew.Add(fm);
}
List <IMeasurement> lm = new List <IMeasurement>();
foreach (IMeasurement mm in dictF.Values)
{
lm.Add(mm);
}
FormulaMeasurement.Set(lm, proxy);
update = UpdateProxy;
output = outNew;
}
catch (Exception ex)
{
ex.ShowError(10);
}
}
public FormulaMeasurement(ObjectFormulaTree tree, string name,
AssociatedAddition associated)
{
this.tree = tree;
this.name = name;
this.associated = associated;
par = GetDefaultValue;
}
/// <summary>
/// Throws exception
/// </summary>
/// <param name="addition">Associated addition</param>
/// <param name="exception">Internal exception</param>
public static void Throw(AssociatedAddition addition,
Exception exception)
{
if ((exception is DiagramException) | (exception is AssociatedException))
{
throw exception;
}
throw new AssociatedException(addition, exception);
}
/// <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);
}
public static AssociatedAddition Create(AssociatedAddition associated)
{
object o = associated.Additional;
object[] ot = null;
if (o is object[])
{
object[] oa = o as object[];
int k = (int)oa[1] + 1;
ot = new object[] { oa[0], k };
}
else
{
ot = new object[] { o, 0 };
}
return(new AssociatedAddition(associated.AssociatedObject, ot));
}
/// <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);
}
}
public FormulaMeasurementDerivationDistribution(ObjectFormulaTree tree,
FormulaMeasurement derivation,
string name, AssociatedAddition associated)
: base(tree, derivation, name, associated)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="tree">Tree</param>
/// <param name="name">Measure name</param>
/// <param name="associated">Associated addition</param>
protected FormulaMeasurementDerivation(ObjectFormulaTree tree,
string name, AssociatedAddition associated)
: base(tree, name, associated)
{
}
public FormulaMeasurementDerivation(ObjectFormulaTree tree,
FormulaMeasurement derivation, string name, AssociatedAddition associated)
: base(tree, name, associated)
{
this.derivation = derivation;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="associated">Associated addition</param>
/// <param name="exception">Internal exception</param>
protected AssociatedException(AssociatedAddition associated,
Exception exception)
{
this.associated = associated;
this.exception = exception;
}
public Variable(string symbol, AssociatedAddition addition)
{
this.symbol = symbol;
par = GetValue;
this.addition = addition;
}
internal void Iterate(bool next)
{
AssociatedAddition aa = FormulaMeasurementDerivation.Create(addition);
temp = temp.Iterate(next, aa);
}
/// <summary>
/// Throws exception
/// </summary>
/// <param name="addition">Associated addition</param>
/// <param name="message">Exception message</param>
public static void Throw(AssociatedAddition addition, string message)
{
Exception ex = new Exception(message);
Throw(addition, ex);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="tree">Tree</param>
/// <param name="name">Name</param>
/// <param name="addition">Addition</param>
public FormulaMeasurementDistribution(ObjectFormulaTree tree,
string name, AssociatedAddition addition)
: base(tree, name, addition)
{
}
