private void buttonCalc_Click(object sender, EventArgs e)
{
// try
// {
MathFormula f = new MathFormula(panel.Performer.Formula, UndrawableConverter.Object);
// MathFormula f = MathFormula.FromString(panel.Performer.Formula.Sizes, fs);
f = f.FullTransform(null);
/*FormulaTree tree = new FormulaTree(f);
* FormulaTree der = tree.Deriv(textBoxDerivType.Text);
* der.SimplifyAll();
* derivFormula = der.GetFormula(0, FormulaEditorPanel.sizes);*/
ObjectFormulaTree tree = ObjectFormulaTree.CreateTree(f, ElementaryFunctionsCreator.Object);
ObjectFormulaTree der = tree.Derivation(textBoxDerivType.Text);
//der = ElementaryFormulaSimplification.Object.Simplify(der);//der.SimplifyAll();
MathFormula form = FormulaCreator.CreateFormula(der, (byte)0, MathSymbolFactory.Sizes);
form.Simplify();
derivFormula = new MathFormulaDrawable(form, DrawableConverter.Object);
derivFormula.Position = pointDeriv;
derivFormula.CalculateFullRelativeRectangle();
derivFormula.CalculatePositions();
paintDeriv();
Refresh();
/* }
* catch (System.Exception ex)
* {
* WindowsExtensions.ControlExtensions.ShowMessageBoxModal(this, ex.Message);
* }*/
}
private void init()
{
arg.Clear();
for (int i = 0; i < 3; i++)
{
MathFormula f = MathFormula.FromString(MathSymbolFactory.Sizes, formulaStrings[i]);
formulas[i] = f;
f = f.FullTransform(null);
ObjectFormulaTree t = ObjectFormulaTree.CreateTree(f);
trees[i] = t;
arg.Add(t);
}
}
void Set(Dictionary <string, string> variables)
{
MathFormula f = MathFormula.FromString(MathSymbolFactory.Sizes, formula);
measures.Clear();
Dictionary <char, object> table = new Dictionary <char, object>();
foreach (string key in variables.Keys)
{
IMeasurement m = this.FindMeasurement(variables[key], false);
measures[key[0]] = m;
table[key[0]] = m.Type;
}
IFormulaObjectCreator creator = VariableDetector.GetCreator(table);
f = f.FullTransform(null);
tree = ObjectFormulaTree.CreateTree(f, creator);
arg = new ElementaryObjectArgument();
arg.Add(tree);
this.variables = variables;
}
public virtual void CreateSystem(string formula)
{
double[] no = new double[nom.Length];
double[] dn = new double[denom.Length];
try
{
Array.Copy(nom, no, nom.Length);
Array.Copy(denom, dn, dn.Length);
MathFormula f = AcceptFormula(formula);
MathFormula form = f.FullTransform("");
ObjectFormulaTree tree = ObjectFormulaTree.CreateTree(form, creator);
IObjectOperation op = tree.Operation;
if (!(op is ElementaryFraction))
{
throw new Exception("Operation should be fraction");
}
double[][] p = new double[2][];
for (int i = 0; i < 2; i++)
{
ObjectFormulaTree t = tree[i];
p[i] = CreatePolynom(tree[i]);
}
Set(p[0], p[1]);
if (!IsStable & ShouldStable)
{
throw new Exception("System is not stable");
}
this.formula = formula;
Solver = DifferentialEquationsPerformer.Default[solver];
}
catch (Exception e)
{
e.ShowError(10);
nom = new double[no.Length];
denom = new double[dn.Length];
Array.Copy(no, nom, nom.Length);
Array.Copy(dn, denom, dn.Length);
this.Throw(e);
}
}
/// <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>
private void acceptFormulas()
{
output.Clear();
acc.Clear();
foreach (char c in vars.Keys)
{
Variable v;
output.Add(Variable.GetMeasure(c, this, out v));
acc[c + ""] = v;
}
foreach (char c in parameters.Keys)
{
IMeasurement m = parameters[c] as IMeasurement;
VariableMeasurement v = c.Create(m, this);
acc[c + ""] = v;
}
foreach (char c in aliases.Keys)
{
AliasNameVariable v = new AliasNameVariable(c, this);
acc[c + ""] = v;
object[] o = aliases[c] as object[];
}
IAlias al = this;
IList <string> l = al.AliasNames;
foreach (string n in l)
{
if (n.Length == 1)
{
}
}
IFormulaObjectCreator creator = VariableDetector.GetCreator(this);
variables.Clear();
foreach (char c in vars.Keys)
{
variables[c] = new object[4];
}
IList <string> an = AliasNames;
List <ObjectFormulaTree> tt = new List <ObjectFormulaTree>();
string proh = "\u03B4";
foreach (char c in parameters.Keys)
{
IMeasurement m = parameters[c];
if (m.Type is IOneVariableFunction)
{
proh += c;
}
}
foreach (char c in vars.Keys)
{
object t = null;
object[] os = vars[c] as object[];
if (an.Contains(c + ""))
{
t = GetType(c + "");
}
else
{
t = os[2];
}
if (t is IOneVariableFunction)
{
proh += c;
}
}
foreach (char c in vars.Keys)
{
object[] os = vars[c] as object[];
object t = null;
if (an.Contains(c + ""))
{
t = GetType(c + "");
}
else
{
t = os[2];
}
object[] ol = variables[c] as object[];
string f = os[1] as string;
MathFormula form = MathFormula.FromString(MathSymbolFactory.Sizes, f);
ObjectFormulaTree tree = ObjectFormulaTree.CreateTree(form.FullTransform(proh), creator);
if (!t.Equals(tree.ReturnType))
{
throw new Exception("Illegal return type");
}
ol[1] = tree;
tt.Add(tree);
}
trees = tt.ToArray();
}