public static void Test()
{
// Initialize the math solving engine.
MathSolver.Init();
EvalData evalData = ConstructEvalData();
// Object deriving from ExComp representing a algebraic variable.
AlgebraComp x = new AlgebraComp("x");
ExComp complexExpression = ConstructEx("3x^2 - 3", evalData);
ExComp combined = AddOp.StaticCombine(x, complexExpression);
// Square the expression.
ExComp squared = PowOp.RaiseToPower(complexExpression, new ExNumber(2.0), ref evalData, false);
// String containing the evaluated result.
string result = squared.ToAlgTerm().FinalToDispStr();
ExComp left = ConstructEx(¨ln(x - 2) ¨, evalData);
ExComp right = ConstructEx(¨3¨, evalData);
// The object containing the functionality used to solve algebraic equations.
AlgebraSolver agSolver = new AlgebraSolver();
// Any additional information regarding the result will be stored in the evalData object.
ExComp solveResult = agSolver.SolveEq(left, right, new AlgebraVar(¨x¨), evalData);
}
private static ExComp AttemptPartialFractions(ExComp num, ExComp den, AlgebraComp dVar, ref IntegrationInfo pIntInfo, ref EvalData pEvalData)
{
if (!(den is AlgebraTerm))
return null;
AlgebraTerm numTerm = num.ToAlgTerm();
AlgebraTerm denTerm = den.ToAlgTerm();
PolynomialExt numPoly = new PolynomialExt();
PolynomialExt denPoly = new PolynomialExt();
if (!numPoly.Init(numTerm) || !denPoly.Init(denTerm))
return null;
if (denPoly.GetMaxPow() < 2)
return null;
if (numPoly.GetMaxPow() > denPoly.GetMaxPow())
{
// First do a synthetic division.
ExComp synthDivResult = DivOp.AttemptPolyDiv(numPoly.Clone(), denPoly.Clone(), ref pEvalData);
if (synthDivResult == null)
return null;
ExComp intEval = Integral.TakeAntiDeriv(synthDivResult, dVar, ref pEvalData);
return intEval;
}
ExComp atmpt = PartialFracs.Split(numTerm, denTerm, numPoly, dVar, ref pEvalData);
if (atmpt == null)
return null;
ExComp antiDerivEval = Integral.TakeAntiDeriv(atmpt, dVar, ref pEvalData);
return antiDerivEval;
}
private static ExComp TryU(ExComp[] group, ExComp uatmpt, AlgebraComp dVar, ref IntegrationInfo pIntInfo, ref EvalData pEvalData)
{
string groupStr = GroupHelper.ToAlgTerm(GroupHelper.CloneGroup(group)).FinalToDispStr();
string thisStr = "\\int(" + groupStr + ")" + dVar.ToDispString();
string atmptStr = uatmpt.ToAlgTerm().FinalToDispStr();
pEvalData.GetWorkMgr().FromFormatted(WorkMgr.STM + "\\int (" + groupStr + ") \\d" + dVar.ToDispString() + WorkMgr.EDM,
"Use u-substitution.");
AlgebraTerm term = GroupHelper.ToAlgNoRedunTerm(group);
AlgebraComp subInVar;
if (term.Contains(new AlgebraComp("u")))
{
if (term.Contains(new AlgebraComp("w")))
subInVar = new AlgebraComp("v");
else
subInVar = new AlgebraComp("w");
}
else
subInVar = new AlgebraComp("u");
bool success = false;
term = term.Substitute(uatmpt, subInVar, ref success);
if (!success)
return null;
List<ExComp[]> updatedGroups = term.GetGroupsNoOps();
// The group count started as one and should not have been altered by substitutions.
if (updatedGroups.Count != 1)
return null;
Derivative derivative = Derivative.ConstructDeriv(uatmpt, dVar, null);
pEvalData.GetWorkMgr().FromFormatted(WorkMgr.STM + thisStr + WorkMgr.EDM,
"Substitute " + WorkMgr.STM + subInVar.ToDispString() + "=" + uatmpt.ToAlgTerm().FinalToDispStr() + WorkMgr.EDM);
pEvalData.GetWorkMgr().FromFormatted("",
"Find " + WorkMgr.STM + "d" + subInVar.ToDispString() + WorkMgr.EDM);
WorkStep last = pEvalData.GetWorkMgr().GetLast();
last.GoDown(ref pEvalData);
ExComp evaluated = derivative.Evaluate(false, ref pEvalData);
last.GoUp(ref pEvalData);
if (evaluated is Derivative)
return null;
last.SetWorkHtml(WorkMgr.STM + "\\frac{d}{d" + dVar.ToDispString() + "}[" + atmptStr + "]=" + WorkMgr.ToDisp(evaluated) + WorkMgr.EDM);
group = updatedGroups[0];
List<ExComp[]> groups = evaluated.ToAlgTerm().GetGroupsNoOps();
ExComp constEx = null;
if (groups.Count == 1)
{
ExComp[] singularGp = groups[0];
ExComp[] varTo, constTo;
GroupHelper.GetConstVarTo(singularGp, out varTo, out constTo, dVar);
constEx = constTo.Length == 0 ? ExNumber.GetOne() : (ExComp)AlgebraTerm.FromFraction(ExNumber.GetOne(), GroupHelper.ToAlgTerm(constTo));
if (varTo.Length == 0)
{
if (GroupHelper.GroupContains(group, dVar))
return null;
pEvalData.GetWorkMgr().GetWorkSteps().Add(new WorkStep(WorkMgr.STM + thisStr +
WorkMgr.EDM, "Make the substitution " + WorkMgr.STM + subInVar.ToDispString() + "=" +
atmptStr + WorkMgr.EDM + " and " + WorkMgr.STM + "d" + subInVar.ToDispString() + "=" +
evaluated.ToAlgTerm().FinalToDispStr() + WorkMgr.EDM, true));
pEvalData.GetWorkMgr().FromFormatted(WorkMgr.STM + constEx.ToAlgTerm().FinalToDispStr() + "\\int (" + GroupHelper.ToAlgTerm(group.ToArray()).FinalToDispStr() + ") d" + subInVar.ToDispString() + WorkMgr.EDM);
ExComp innerAntiDeriv = TakeAntiDerivativeGp(group, subInVar, ref pIntInfo, ref pEvalData, "", "");
if (innerAntiDeriv == null)
return null;
pEvalData.GetWorkMgr().FromSides(MulOp.StaticWeakCombine(constEx, innerAntiDeriv), null, "Substitute back in " + WorkMgr.STM + subInVar.ToDispString() + "=" +
atmptStr + WorkMgr.EDM);
// Sub back in the appropriate values.
innerAntiDeriv = innerAntiDeriv.ToAlgTerm().Substitute(subInVar, uatmpt);
ExComp retEx = MulOp.StaticCombine(innerAntiDeriv, constEx);
pEvalData.GetWorkMgr().FromSides(retEx, null);
return retEx;
}
evaluated = GroupHelper.ToAlgTerm(varTo).RemoveRedundancies(false);
}
else
{
ExComp[] groupGcf = evaluated.ToAlgTerm().GetGroupGCF();
ExComp[] varTo, constTo;
GroupHelper.GetConstVarTo(groupGcf, out varTo, out constTo, dVar);
AlgebraTerm constToAg = GroupHelper.ToAlgTerm(constTo);
evaluated = DivOp.StaticCombine(evaluated, constToAg.CloneEx());
constEx = AlgebraTerm.FromFraction(ExNumber.GetOne(), constToAg);
}
for (int j = 0; j < group.Length; ++j)
{
if (group[j].IsEqualTo(evaluated))
{
List<ExComp> groupList = ArrayFunc.ToList(group);
ArrayFunc.RemoveIndex(groupList, j);
pEvalData.GetWorkMgr().GetWorkSteps().Add(new WorkStep(WorkMgr.STM + thisStr +
WorkMgr.EDM, "Make the substitution " + WorkMgr.STM + subInVar.ToDispString() + "=" +
atmptStr + WorkMgr.EDM + " and " + WorkMgr.STM + "d" + subInVar.ToDispString() + "=" +
evaluated.ToAlgTerm().FinalToDispStr() + WorkMgr.EDM, false));
bool mulInCost = constEx != null && !ExNumber.GetOne().IsEqualTo(constEx);
string mulInCostStr = (mulInCost ? constEx.ToAlgTerm().FinalToDispStr() : "");
group = groupList.ToArray();
if (GroupHelper.GroupContains(group, dVar))
return null;
pEvalData.GetWorkMgr().FromFormatted(WorkMgr.STM + mulInCostStr +
"\\int (" + GroupHelper.ToAlgTerm(group).FinalToDispStr() + ") d" + subInVar.ToDispString() + WorkMgr.EDM);
ExComp innerAntiDeriv = TakeAntiDerivativeGp(group, subInVar, ref pIntInfo, ref pEvalData, "", "");
if (innerAntiDeriv == null)
return null;
pEvalData.GetWorkMgr().FromFormatted(WorkMgr.STM + mulInCostStr + "(" + innerAntiDeriv.ToAlgTerm().FinalToDispStr() + ")" + WorkMgr.EDM, "Substitute back in " + WorkMgr.STM + subInVar.ToDispString() + "=" +
uatmpt.ToAlgTerm().FinalToDispStr() + WorkMgr.EDM);
// Sub back in the appropriate values.
innerAntiDeriv = innerAntiDeriv.ToAlgTerm().Substitute(subInVar, uatmpt);
ExComp retEx;
if (mulInCost)
retEx = MulOp.StaticCombine(constEx, innerAntiDeriv);
else
retEx = innerAntiDeriv;
pEvalData.GetWorkMgr().FromSides(retEx, null);
return retEx;
}
else if (group[j] is PowerFunction && evaluated is PowerFunction && (group[j] as PowerFunction).GetPower().IsEqualTo((evaluated as PowerFunction).GetPower()))
{
PowerFunction groupPf = group[j] as PowerFunction;
PowerFunction evaluatedPf = evaluated as PowerFunction;
List<ExComp[]> baseGps = groupPf.GetBase().ToAlgTerm().GetGroupsNoOps();
if (baseGps.Count == 1)
{
// Search the base for like terms.
for (int k = 0; k < baseGps[0].Length; ++k)
{
if (baseGps[0][k].IsEqualTo(evaluatedPf.GetBase()))
{
List<ExComp> baseGpsList = ArrayFunc.ToList(baseGps[0]);
ArrayFunc.RemoveIndex(baseGpsList, k);
group[j] = new PowerFunction(GroupHelper.ToAlgTerm(baseGpsList.ToArray()), evaluatedPf.GetPower());
pEvalData.GetWorkMgr().GetWorkSteps().Add(new WorkStep(WorkMgr.STM + thisStr +
WorkMgr.EDM, "Make the substitution " + WorkMgr.STM + subInVar.ToDispString() + "=" +
atmptStr + WorkMgr.EDM + " and " + WorkMgr.STM + "d" + subInVar.ToDispString() + "=" +
evaluated.ToAlgTerm().FinalToDispStr() + WorkMgr.EDM, false));
bool mulInCost = constEx != null && !ExNumber.GetOne().IsEqualTo(constEx);
string mulInCostStr = (mulInCost ? constEx.ToAlgTerm().FinalToDispStr() : "");
pEvalData.GetWorkMgr().FromFormatted(WorkMgr.STM + mulInCostStr +
"\\int (" + GroupHelper.ToAlgTerm(group).FinalToDispStr() + ") d" + subInVar.ToDispString() + WorkMgr.EDM);
ExComp innerAntiDeriv = TakeAntiDerivativeGp(@group, subInVar, ref pIntInfo, ref pEvalData, "", "");
if (innerAntiDeriv == null)
return null;
pEvalData.GetWorkMgr().FromFormatted(WorkMgr.STM + mulInCostStr + "(" + innerAntiDeriv.ToAlgTerm().FinalToDispStr() + ")" + WorkMgr.EDM, "Substitute back in " + WorkMgr.STM + subInVar.ToDispString() + "=" +
uatmpt.ToAlgTerm().FinalToDispStr() + WorkMgr.EDM);
// Sub back in the appropriate values.
innerAntiDeriv = innerAntiDeriv.ToAlgTerm().Substitute(subInVar, uatmpt);
ExComp retEx;
if (mulInCost)
retEx = MulOp.StaticCombine(constEx, innerAntiDeriv);
else
retEx = innerAntiDeriv;
pEvalData.GetWorkMgr().FromSides(retEx, null);
return retEx;
}
}
}
}
}
return null;
}
