public static IEquationSolutions Solve(Equation equation, string variable)
{
EquationClassifier.Classify(equation, variable);
var sols = Solve(variable, equation.Left, equation.Classification);
var newSols = new EquationSolutions();
RecursiveSolve(variable, sols, newSols);
return(newSols);
}
public IEquationSolutions Solve(IExpression expression, string variable, IClassificationResult classification)
{
var res = new EquationSolutions();
if (expression is FlatAddExpression fa)
{
IExpression a = null;
IExpression b = null;
IExpression c = null;
List <IExpression> ca = new List <IExpression>();
for (int i = 0; i < fa.Expressions.Count; i++)
{
var kv = fa.Expressions.ElementAt(i);
var deg = kv.Value[0].DimensionKey.Value;
var key = kv.Value[0].DimensionKey.Key;
var expr = kv.Value[0];
if (deg.ToNumber() == 2 && key == variable)
{
if (expr is VariableExpression)
{
a = new ComplexExpression(expr.Count);
}
else if (expr is IFunctionExpression)
{
a = new ComplexExpression(expr.Count);
}
else
{
var tmp = (FlatExpression)expr.Clone();
tmp.Remove(variable, 2);
a = tmp;
}
}
else if (deg.ToNumber() == 1 && key == variable)
{
if (expr is VariableExpression)
{
b = new ComplexExpression(expr.Count);
}
else if (expr is IFunctionExpression)
{
b = new ComplexExpression(expr.Count);
}
else
{
var tmp = (FlatExpression)expr.Clone();
tmp.Remove(variable, 2);
b = tmp;
}
}
else
{
ca.Add(kv.Value[0]);
}
}
if (ca.Count > 1)
{
c = new FlatAddExpression();
var ct = (FlatAddExpression)c;
foreach (var ci in ca)
{
ct.Add(ci);
}
}
else if (ca.Count == 1)
{
c = ca[0];
}
if (a != null && c != null)
{
var delta = this.Delta(a, b, c);
var ds = new BinaryExpression(delta, Enums.Operators.OperatorTypes.Power, new NumberExpression(new Fraction(1, 2)));
var dsqrt = ds.Execute();
var r1 = X1X2(b, dsqrt, a, true);
var r2 = X1X2(b, dsqrt, a, false);
res.Solutions.Add(variable, new Tuple <IExpression, List <IExpression> >(classification.SearchResult[variable].Item1, new List <IExpression>()
{
r1.Execute()
}));
res.Solutions[variable].Item2.Add(r2.Execute());
}
}
return(res);
}
public IEquationSolutions Solve(IExpression expression, string variable, IClassificationResult classification)
{
var res = new EquationSolutions();
List <IExpression> al = new List <IExpression>();
List <IExpression> bl = new List <IExpression>();
List <IExpression> cl = new List <IExpression>();
if (expression is FlatAddExpression fa)
{
foreach (var kv in fa.Expressions)
{
var expr = kv.Value[0];
if (expr is IFunctionExpression)
{
if (expr is CosExpression)
{
al.Add(expr);
}
else if (expr is SinExpression)
{
al.Add(expr);
}
else if (expr is TanExpression)
{
al.Add(expr);
}
else if (expr is CotExpression)
{
al.Add(expr);
}
else
{
bl.Add(expr);
}
}
else if (expr is FlatExpression fe)
{
if (fe.Expressions.Any(e => e.Key == variable))
{
bl.Add(expr);
}
else
{
cl.Add(expr);
}
}
else if (expr.DimensionKey.Key == variable)
{
bl.Add(expr);
}
else
{
cl.Add(expr);
}
}
if (bl.Count > 0)
{
//General way of solving
}
if (al.Count > 1)
{
//General way of solving ?
}
if (al.Count == 1)
{
var expr = (IFunctionExpression)al[0];
if (expr.InverseFunction != 0)
{
var arg = new FlatAddExpression();
foreach (var e in cl)
{
arg.Add(new UnaryExpression(Enums.Operators.OperatorTypes.Sign, e).Execute());
}
arg.Execute();
var sol = Functions.Get(expr.InverseFunction.ToString(), arg).Execute();
var solFor = expr.Argument.DimensionKey.Key;
res.Solutions.Add(solFor, new Tuple <IExpression, List <IExpression> >(expr.Argument, new List <IExpression>()
{
sol
}));
}
else
{
//No inverse function => Numeric solution ?
}
}
}
return(res);
}
public IEquationSolutions Solve(IExpression expression, string variable, IClassificationResult classification)
{
var res = new EquationSolutions();
IExpression a = null;
IExpression b = null;
List <IExpression> ba = new List <IExpression>();
if (expression is FlatAddExpression fa)
{
foreach (var expr in fa.Expressions)
{
if (expr.Value[0] is FlatExpression fe)
{
if (fe.Expressions.Any(e => e.Key == variable))
{
if (expr.Value[0] is VariableExpression)
{
a = new ComplexExpression(expr.Value[0].Count);
}
else
{
var tmp = (FlatExpression)expr.Value[0].Clone();
tmp.Remove(variable, 1);
a = tmp;
}
}
}
else if (expr.Key == variable)
{
if (expr.Value[0] is VariableExpression)
{
a = new ComplexExpression(expr.Value[0].Count);
}
else
{
var tmp = (FlatExpression)expr.Value[0].Clone();
tmp.Remove(variable, 1);
a = tmp;
}
}
else
{
ba.Add(expr.Value[0]);
}
}
if (ba.Count > 1)
{
b = new FlatAddExpression();
var ct = (FlatAddExpression)b;
foreach (var ci in ba)
{
ct.Add(ci);
}
}
else if (ba.Count == 1)
{
b = ba[0];
}
var sol = new BinaryExpression(new UnaryExpression(Enums.Operators.OperatorTypes.Sign, b), Enums.Operators.OperatorTypes.Divide, a).Execute();
res.Solutions.Add(variable, new Tuple <IExpression, List <IExpression> >(classification.SearchResult[variable].Item1, new List <IExpression>()
{
sol
}));
}
return(res);
}
