/// <summary>
/// Calculates derivation
/// </summary>
/// <param name="tree">The function for derivation calculation</param>
/// <param name="variableName">Derivation string</param>
/// <returns>The derivation</returns>
public ObjectFormulaTree Derivation(ObjectFormulaTree tree, string variableName)
{
Double a = 0;
bool[] b = new bool[] { false, false };
ObjectFormulaTree[] fc = new ObjectFormulaTree[2];
ObjectFormulaTree[] fd = new ObjectFormulaTree[2];
for (int i = 0; i < 2; i++)
{
fc[i] = tree[1 - i];
fd[i] = fc[i].Derivation(variableName);
b[i] = ZeroPerformer.IsZero(fd[i]);
}
if (b[0] & b[1])
{
return(ElementaryRealConstant.RealZero);
}
IObjectOperation nom = new ElementaryBinaryOperation('-', new object[] { a, a });
List <ObjectFormulaTree> nomList = new List <ObjectFormulaTree>();
for (int i = 0; i < 2; i++)
{
List <ObjectFormulaTree> l = new List <ObjectFormulaTree>();
l.Add(fd[1 - i]); //.Clone() as ObjectFormulaTree);
l.Add(fc[i]); //.Clone() as ObjectFormulaTree);
IObjectOperation o = new ElementaryBinaryOperation('*', new object[] { a, a });
nomList.Add(new ObjectFormulaTree(o, l));
}
List <ObjectFormulaTree> list = new List <ObjectFormulaTree>();
if (b[0] | b[1])
{
for (int i = 0; i < 2; i++)
{
if (b[i])
{
List <ObjectFormulaTree> lt = new List <ObjectFormulaTree>();
lt.Add(nomList[i]);
list.Add(new ObjectFormulaTree(new ElementaryFunctionOperation('-'), lt));
}
}
}
else
{
list.Add(new ObjectFormulaTree(nom, nomList));
}
IObjectOperation square = ElementaryFunctionsCreator.Object.GetPowerOperation(a, a);
List <ObjectFormulaTree> squareList = new List <ObjectFormulaTree>();
squareList.Add(fc[0]);
squareList.Add(new ObjectFormulaTree(new ElementaryRealConstant(2), new List <ObjectFormulaTree>()));
list.Add(new ObjectFormulaTree(square, squareList));
if (list.Count != 2)
{
// list = list;
}
return(new ObjectFormulaTree(new ElementaryFraction(), list));
}
/// <summary>
/// Calculates derivation of i - th function
/// </summary>
/// <param name="tree">Object tree</param>
/// <param name="i">Function number</param>
/// <param name="variableName">Name of variable</param>
/// <returns>The derivation</returns>
static private ObjectFormulaTree Derivation(ObjectFormulaTree tree, int i, string variableName)
{
Double a = 0;
ObjectFormulaTree f1 = tree[0].Derivation(variableName);
if (ZeroPerformer.IsZero(f1))
{
return(ElementaryRealConstant.RealZero);
}
ObjectFormulaTree fd = functionDerivations[i];
ObjectFormulaTree f0 = InsertVariable(fd, tree[0]);
IObjectOperation operation = new ElementaryBinaryOperation('*', new object[] { a, a });
List <ObjectFormulaTree> children = new List <ObjectFormulaTree>();
children.Add(f0);
children.Add(f1);
return(new ObjectFormulaTree(operation, children));
}
/// <summary>
/// Calculates derivation
/// </summary>
/// <param name="tree">The function for derivation calculation</param>
/// <param name="variableName">Name of variable</param>
/// <returns>The derivation</returns>
ObjectFormulaTree IDerivationOperation.Derivation(ObjectFormulaTree tree, string variableName)
{
bool[] b = new bool[] { false, false };
if ((symbol == '+') | (symbol == '-')) // "+" or "-" operation
{
IObjectOperation op = new ElementaryBinaryOperation(symbol,
new object[] { tree[0].ReturnType, tree[1].ReturnType });
List <ObjectFormulaTree> l = new List <ObjectFormulaTree>();
for (int i = 0; i < tree.Count; i++)
{
ObjectFormulaTree t = tree[i].Derivation(variableName);
b[i] = ZeroPerformer.IsZero(t);
l.Add(t);
}
if (b[0])
{
if (b[1])
{
return(ElementaryRealConstant.RealZero);
}
if (symbol == '+')
{
return(l[1]);
}
List <ObjectFormulaTree> ll = new List <ObjectFormulaTree>();
ll.Add(l[1]);
return(new ObjectFormulaTree(new ElementaryFunctionOperation('-'), ll));
}
if (b[1])
{
return(l[0]);
}
return(new ObjectFormulaTree(op, l));
}
ObjectFormulaTree[] der = new ObjectFormulaTree[2];
for (int i = 0; i < 2; i++)
{
der[i] = tree[i].Derivation(variableName);
b[i] = ZeroPerformer.IsZero(der[i]);
}
if (symbol == '*') // "*" - operation
{
List <ObjectFormulaTree> list = new List <ObjectFormulaTree>();
for (int i = 0; i < 2; i++)
{
List <ObjectFormulaTree> l = new List <ObjectFormulaTree>();
l.Add(tree[i]);
l.Add(der[1 - i]);
ElementaryBinaryOperation o = new ElementaryBinaryOperation('*',
new object[] { l[0].ReturnType, l[1].ReturnType });
list.Add(new ObjectFormulaTree(o, l));
}
if (b[0] & b[1])
{
return(ElementaryRealConstant.RealZero);
}
for (int i = 0; i < b.Length; i++)
{
if (b[i])
{
return(list[i]);
}
}
ElementaryBinaryOperation op = new ElementaryBinaryOperation('+',
new object[] { list[0].ReturnType, list[1].ReturnType });
return(new ObjectFormulaTree(op, list));
}
return(null);
}
/// <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));
}