public void Multiply_Number_FlatAdd()
{
//Arrange
var expected = new FlatAddExpression();
expected.Add(new VariableExpression("u", 2));
expected.Add(new NumberExpression(3));
expected.Count = new Complex(12, 0);
expected.Execute();
var c = new NumberExpression(3);
var n = new FlatAddExpression();
n.Add(new VariableExpression("u", 2));
n.Add(new NumberExpression(3));
n.Count = new Complex(4, 0);
var expr = new BinaryExpression(c, OperatorTypes.Multiply, n);
//Act
var actual = expr.Execute();
//Assert
Assert.AreEqual(expected.Count.Re.ToNumber(), actual.Count.Re.ToNumber());
Assert.AreEqual(expected.Count.Im.ToNumber(), actual.Count.Im.ToNumber());
}
private static void RecursiveSolve(string variable, IEquationSolutions sols, IEquationSolutions newSols)
{
var keys = sols.Solutions.Keys.ToList();
foreach (var k in keys)
{
if (k != variable)
{
var s = sols.Solutions[k];
foreach (var e in s.Item2)
{
var tmpEq = new FlatAddExpression();
tmpEq.Add(s.Item1);
tmpEq.Add(new UnaryExpression(Enums.Operators.OperatorTypes.Sign, e));
var emp = tmpEq.Execute();
var c = EquationClassifier.Classify(emp, variable);
var tmp = Solve(variable, tmpEq, c);
foreach (var ns in tmp.Solutions)
{
RecursiveSolve(variable, tmp, newSols);
}
}
}
else
{
var s = sols.Solutions[k];
if (!newSols.Solutions.ContainsKey(variable))
{
newSols.Solutions.Add(variable, new Tuple <IExpression, List <IExpression> >(s.Item1, new List <IExpression>()));
}
newSols.Solutions[variable].Item2.AddRange(s.Item2);
}
}
}
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);
}
