internal static ObjectFormulaTree signed(ObjectFormulaTree tree, bool sign)
{
if (sign)
{
return(tree);
}
ElementaryFunctionOperation eo = new ElementaryFunctionOperation('-');
List <ObjectFormulaTree> l = new List <ObjectFormulaTree>();
l.Add(tree);
return(new ObjectFormulaTree(eo, l));
}
static StaticExtensionFormulaEditor()
{
"orderby".AddAdditionalFormula();
"where".AddAdditionalFormula();
"average".AddAdditionalFormula();
"IndexOf".AddAdditionalFormula();
MathSymbolFactory.Sizes = new int[] { 15, 11, 9, 6 };
loadFormulaResources();
ObjectFormulaTree.Creator =
new FormulaArrayObjectCreator(ElementaryFunctionsCreator.Object);
ElementaryFunctionOperation.InitDeri();
ElementaryIntegerOperation.Prepare();
ParallelCount = 0;
}
/// <summary>
/// Integral of tree
/// </summary>
/// <param name="tree">The tree</param>
/// <returns>The integral</returns>
public static double Integral(ObjectFormulaTree tree)
{
IObjectOperation op = tree.Operation;
if (op is IDistribution)
{
IDistribution df = op as IDistribution;
return(df.Integral);
}
if (op is ElementaryBinaryOperation)
{
ElementaryBinaryOperation ebo = op as ElementaryBinaryOperation;
char c = ebo.Symbol;
if (c == '+')
{
return(getSum(tree));
}
if (c == '-')
{
return(getDiff(tree));
}
if (c == '*')
{
return(getMult(tree));
}
}
if (op is ElementaryFunctionOperation)
{
ElementaryFunctionOperation efo = op as ElementaryFunctionOperation;
char c = efo.Symbol;
double a = Integral(tree[0]);
if (c == '?')
{
return(a);
}
if (c == '-')
{
return(-a);
}
}
return(0);
}
/// <summary>
/// Calculates derivation
/// </summary>
/// <param name="tree">The function for derivation calculation</param>
/// <param name="variableName">Name of variable</param>
/// <returns>The derivation</returns>
public ObjectFormulaTree Derivation(ObjectFormulaTree tree, string variableName)
{
if (arity == 1)
{
return(ElementaryFunctionOperation.SquareRootDerivation(tree, variableName));
}
IObjectOperation mainOp = ElementaryFunctionsCreator.Object.GetPowerOperation(a, a);
List <ObjectFormulaTree> mainList = new List <ObjectFormulaTree>();
mainList.Add(tree[0]);
IObjectOperation secondOp = ElementaryFraction.Object;
List <ObjectFormulaTree> secondList = new List <ObjectFormulaTree>();
IObjectOperation secondFistOperation = new ElementaryRealConstant(1);
ObjectFormulaTree secondFirstTree = new ObjectFormulaTree(secondFistOperation, new List <ObjectFormulaTree>());
secondList.Add(secondFirstTree);
secondList.Add(tree[1]);
ObjectFormulaTree secondTree = new ObjectFormulaTree(secondOp, secondList);
mainList.Add(secondTree);
return((new ObjectFormulaTree(mainOp, mainList)).Derivation(variableName));
}
/// <summary>
/// Checks whether tree contains distributions
/// </summary>
/// <param name="tree">The tree</param>
/// <returns>True if contains and false otherwise</returns>
static bool CheckDelta(ObjectFormulaTree tree)
{
int count = 0;
if (tree == null)
{
return(false);
}
if (tree.Operation is IDistribution)
{
return(true);
}
bool b = false;
for (int i = 0; i < tree.Count; i++)
{
ObjectFormulaTree t = tree[i];
if (t == null)
{
continue;
}
b |= CheckDelta(t);
if (t.Operation is IDistribution)
{
++count;
}
}
IObjectOperation op = tree.Operation;
if (b)
{
if (op.InputTypes.Length == 2)
{
if (op is ElementaryBinaryOperation)
{
ElementaryBinaryOperation bop = op as ElementaryBinaryOperation;
char s = bop.Symbol;
if (s != '+' & s != '-' & s != '*')
{
throwError();
}
if (count > 1 & s == '*')
{
throwError();
}
}
else if (op is ElementaryFunctionOperation)
{
ElementaryFunctionOperation eop = op as ElementaryFunctionOperation;
char c = eop.Symbol;
if (c != '!' & c != '-')
{
throwError();
}
}
else
{
throwError();
}
}
}
return(b | count > 0);
}
private static ObjectFormulaTree sumSumInverse(PolySum ps)
{
Dictionary <ObjectFormulaTree, bool> d = new Dictionary <ObjectFormulaTree, bool>(ps.summands);
ObjectFormulaTree first = null;
ObjectFormulaTree second = null;
bool bf = true;
foreach (ObjectFormulaTree t in d.Keys)
{
if (ElementaryFormulaSimplification.IsConst(t))
{
first = t;
}
}
if (first == null)
{
if (d.Count > 0)
{
foreach (ObjectFormulaTree t in d.Keys)
{
first = t;
bf = d[t];
break;
}
}
}
if (first == null)
{
ElementaryRealConstant er = new ElementaryRealConstant(0);
return(new ObjectFormulaTree(er, new List <ObjectFormulaTree>()));
}
d.Remove(first);
first = sumSumInverse(first);
if (!bf)
{
ElementaryFunctionOperation ef = new ElementaryFunctionOperation('-');
List <ObjectFormulaTree> l = new List <ObjectFormulaTree>();
l.Add(first);
first = new ObjectFormulaTree(ef, l);
}
if (d.Count == 0)
{
return(first);
}
ObjectFormulaTree sec = null;
foreach (ObjectFormulaTree t in d.Keys)
{
sec = t;
}
bool kb = d[sec];
PolySum pp = new PolySum(true);
Dictionary <ObjectFormulaTree, bool> dd = pp.summands;
foreach (ObjectFormulaTree t in d.Keys)
{
if (PolyMult.IsZero(t))
{
continue;
}
bool bl = d[t];
if (!kb)
{
bl = !bl;
}
dd[t] = bl;
}
second = sumSumInverse(pp);
List <ObjectFormulaTree> lr = new List <ObjectFormulaTree>();
lr.Add(first);
lr.Add(second);
char c = kb ? '+' : '-';
if (PolyMult.IsZero(second))
{
return(first);
}
Double type = 0;
ElementaryBinaryOperation eop = new ElementaryBinaryOperation(c, new object[] { type, type });
return(new ObjectFormulaTree(eop, lr));
}
private static ObjectFormulaTree delConst(PolySum ps, ref bool simple)
{
Dictionary <ObjectFormulaTree, bool> dd = ps.summands;
List <ObjectFormulaTree> del = new List <ObjectFormulaTree>();
Dictionary <ObjectFormulaTree, bool> d = new Dictionary <ObjectFormulaTree, bool>();
foreach (ObjectFormulaTree ttt in dd.Keys)
{
ObjectFormulaTree ts = ElementaryFormulaSimplification.Object.Simplify(ttt);
if (!PolyMult.IsZero(ts))
{
d[ts] = dd[ttt];
}
}
PolySum p = new PolySum(true);
Dictionary <ObjectFormulaTree, bool> forms = p.summands;
double a = 0;
int i = 0;
foreach (ObjectFormulaTree t in d.Keys)
{
bool b = d[t];
ObjectFormulaTree tr = delConst(t, ref simple);
if (PolyMult.IsZero(tr))
{
simple = false;
continue;
}
if (ElementaryFormulaSimplification.IsConst(tr))
{
double x = (double)tr.Result;
a += b ? x : -x;
++i;
if (i > 1)
{
simple = false;
}
}
else
{
forms[tr] = d[t];
}
}
if (a != 0)
{
ElementaryRealConstant ec = new ElementaryRealConstant(a);
forms[new ObjectFormulaTree(ec, new List <ObjectFormulaTree>())] = true;
}
if (forms.Count == 1)
{
foreach (ObjectFormulaTree f in forms.Keys)
{
bool b = forms[f];
if (b)
{
return(f);
}
ElementaryFunctionOperation op = new ElementaryFunctionOperation('-');
List <ObjectFormulaTree> lop = new List <ObjectFormulaTree>();
lop.Add(f);
return(new ObjectFormulaTree(op, lop));
}
}
return(new ObjectFormulaTree(p, new List <ObjectFormulaTree>()));
}
/// <summary>
/// Calculates derivation
/// </summary>
/// <param name="tree">The function for derivation calculation</param>
/// <param name="variableName">Name of variable</param>
/// <returns>The derivation</returns>
public ObjectFormulaTree Derivation(ObjectFormulaTree tree, string variableName)
{
Double a = 0;
ObjectFormulaTree[] fc = new ObjectFormulaTree[2];
ObjectFormulaTree[] fd = new ObjectFormulaTree[2];
bool[] b = new bool[] { false, false };
for (int i = 0; i < 2; i++)
{
fc[i] = tree[i];//.Clone() as ObjectFormulaTree;
fd[i] = fc[i].Derivation(variableName);
bool bb = ZeroPerformer.IsZero(fd[i]);
b[i] = bb;
if (!bb)
{
// glo = true;
}
}
if (b[1])
{
double rs = (double)fc[1].Result;
if (rs == 1)
{
return(fd[0]);
}
}
List <ObjectFormulaTree> mainList = new List <ObjectFormulaTree>();
IObjectOperation mainOperation = new ElementaryBinaryOperation('+', new object[] { a, a });
List <ObjectFormulaTree> firstList = new List <ObjectFormulaTree>();
IObjectOperation firstOperation = new ElementaryBinaryOperation('*', new object[] { a, a });
List <ObjectFormulaTree> secondList = new List <ObjectFormulaTree>();
IObjectOperation secondOperation = new ElementaryBinaryOperation('*', new object[] { a, a });
List <ObjectFormulaTree> firstFirstList = new List <ObjectFormulaTree>();
firstFirstList.Add(fc[1]);
IObjectOperation firstFirstOperation = new ElementaryBinaryOperation('*', new object[] { a, a });
IObjectOperation firstFirstSecondOperation = new ElementaryPowerOperation(valType, powType);
List <ObjectFormulaTree> firstFirstSecondList = new List <ObjectFormulaTree>();
firstFirstSecondList.Add(fc[0]);
List <ObjectFormulaTree> firstFirstSecondSecondList = new List <ObjectFormulaTree>();
IObjectOperation firstFirstSecondSecondOperation = new ElementaryBinaryOperation('-', new object[] { a, a });
ObjectFormulaTree fcd = fd[1];
firstFirstSecondSecondList.Add(fc[1]);
IObjectOperation firstFirstSecondSecondSecondOperation = new ElementaryRealConstant(1);
ObjectFormulaTree firstFirstSecondSecondSecondTree =
new ObjectFormulaTree(firstFirstSecondSecondSecondOperation, new List <ObjectFormulaTree>());
firstFirstSecondSecondList.Add(firstFirstSecondSecondSecondTree);
ObjectFormulaTree firstFirstSecondSecondTree = null;
bool unityDeg = false;
if (ZeroPerformer.IsZero(fd[1]))
{
double f2d = (double)tree[1].Result - 1;
if (f2d == 1)
{
unityDeg = true;
}
ElementaryRealConstant erc = new ElementaryRealConstant(f2d);
firstFirstSecondSecondTree = new ObjectFormulaTree(erc, new List <ObjectFormulaTree>());
}
else
{
firstFirstSecondSecondTree =
new ObjectFormulaTree(firstFirstSecondSecondOperation, firstFirstSecondSecondList);
}
firstFirstSecondList.Add(firstFirstSecondSecondTree);
ObjectFormulaTree firstFirstSecondTree = null;
if (unityDeg)
{
firstFirstSecondTree = fc[0];
}
else
{
firstFirstSecondTree =
new ObjectFormulaTree(firstFirstSecondOperation, firstFirstSecondList);
}
firstFirstList.Add(firstFirstSecondTree);
ObjectFormulaTree firstFirstTree = new ObjectFormulaTree(firstFirstOperation, firstFirstList);
firstList.Add(firstFirstTree);
firstList.Add(fd[0]);
ObjectFormulaTree firstTree = new ObjectFormulaTree(firstOperation, firstList);
mainList.Add(firstTree);
// Second part
IObjectOperation secondFirstOperation = new ElementaryBinaryOperation('*', new object[] { a, a });
List <ObjectFormulaTree> secondFirstList = new List <ObjectFormulaTree>();
IObjectOperation secondFirstFirstOperation = new ElementaryFunctionOperation('l');
List <ObjectFormulaTree> secondFirstFirstList = new List <ObjectFormulaTree>();
secondFirstFirstList.Add(fc[0]);//.Clone() as ObjectFormulaTree);
ObjectFormulaTree secondFirstFirstTree =
new ObjectFormulaTree(secondFirstFirstOperation, secondFirstFirstList);
secondFirstList.Add(secondFirstFirstTree);
secondFirstList.Add(tree);//.Clone() as ObjectFormulaTree);
ObjectFormulaTree secondFirstTree = new ObjectFormulaTree(secondFirstOperation, secondFirstList);
secondList.Add(secondFirstTree);
secondList.Add(fd[1]);
ObjectFormulaTree secondTree = new ObjectFormulaTree(secondOperation, secondList);
mainList.Add(secondTree);
if (b[0] & b[1])
{
return(ElementaryRealConstant.RealZero);
}
for (int i = 0; i < 2; i++)
{
if (b[i])
{
return(mainList[1 - i]);
}
}
return(new ObjectFormulaTree(mainOperation, mainList));
}
