public CasExpr Substitute(CasExpr expr, CasVar forV, CasExpr inExpr)
{
CasExpr expr1 = inExpr.Poly1.Substitute(expr, forV);
CasExpr expr2 = inExpr.Poly2.Substitute(expr, forV);
return(Div(expr1, expr2));
}
public CasVar NewVar()
{
var v = new CasVar("Var" + NumVars);
NumVars++;
return(v);
}
public CasExpr VarExpr(CasVar v)
{
var t = new CasTerm(1);
t.Variables[v] = 1;
var p = new CasPolynomial();
p.Terms.Add(t);
return(new CasExpr(p, CasPolynomial.ConstantPoly(1)));
}
public bool ContainsVar(CasVar v)
{
foreach (var t in Terms)
{
if (t.Variables.ContainsKey(v))
{
return(true);
}
}
return(false);
}
public CasExpr Substitute(CasExpr expr, CasVar forV)
{
if (!Variables.ContainsKey(forV))
{
return(this.ToExpr());
}
var exprPow = expr.RaisedToPower(Variables[forV]);
var newTerm = CopyWithCoefficient(Coefficient);
newTerm.Variables.Remove(forV);
return(CasSystem.Instance.Mul(newTerm.ToExpr(), exprPow));
}
public void ReplaceVariable(CasVar variable, CasExpr expr)
{
foreach (var entry in CacheEntries)
{
entry.Expr = CAS.Substitute(expr, variable, entry.Expr);
}
if (ObjectsToKeepUpdated != null)
{
foreach (var obj in ObjectsToKeepUpdated.Values)
{
obj.HeightExpr = CAS.Substitute(expr, variable, obj.HeightExpr);
obj.WidthExpr = CAS.Substitute(expr, variable, obj.WidthExpr);
obj.XExpr = CAS.Substitute(expr, variable, obj.XExpr);
obj.YExpr = CAS.Substitute(expr, variable, obj.YExpr);
}
}
}
public CasExpr Substitute(CasExpr expr, CasVar forV)
{
if (!ContainsVar(forV))
{
return(new CasExpr(this, CasPolynomial.ConstantPoly(1)));
}
List <CasExpr> exprs = new List <CasExpr>();
foreach (var t in Terms)
{
exprs.Add(t.Substitute(expr, forV));
}
var sum = CasExpr.ConstantExpr(0);
foreach (var e in exprs)
{
sum = CasSystem.Instance.Add(sum, e);
}
return(sum);
}
// Result is null if solver fails
public CasExpr MakeZero(CasExpr expr, CasVar v)
{
List <CasTerm> zeroTerms = new List <CasTerm>();
List <CasTerm> oneTerms = new List <CasTerm>();
foreach (var t in expr.Poly1.Terms)
{
if (!t.Variables.ContainsKey(v))
{
zeroTerms.Add(t);
}
else if (t.Variables[v] == 1)
{
oneTerms.Add(t);
}
else
{
return(null);
}
}
if (oneTerms.Count == 0)
{
return(null);
}
CasPolynomial poly1 = new CasPolynomial();
CasPolynomial poly2 = new CasPolynomial();
foreach (var t in zeroTerms)
{
poly1.Terms.Add(t.CopyWithCoefficient(-1 * t.Coefficient));
}
foreach (var t in oneTerms)
{
poly2.Terms.Add(t.CopyWithCoefficient(t.Coefficient));
}
foreach (var t in poly2.Terms)
{
t.Variables.Remove(v);
}
return(new CasExpr(poly1, poly2));
}
public void EqualizeExpressions(CasExpr expr1, CasExpr expr2, CasExpr invariant, Dictionary <int, SlideObject> slideObjects)
{
var diffExpr = CAS.Sub(expr1, expr2);
var vars = new List <CasVar>(CAS.UsedVariables(diffExpr));
CasVar bestVar = null;
CasExpr bestSolution = null;
float minChange = 0;
Dictionary <CasVar, float> values = GetVariableValues();
float initialVal = CAS.Eval(invariant, values);
foreach (var v in vars)
{
var solution = CAS.MakeZero(diffExpr, v);
if (solution != null)
{
float change = Math.Abs(CAS.Eval(CAS.Substitute(solution, v, invariant), values) - initialVal);
if (bestVar == null || change < minChange)
{
bestVar = v;
minChange = change;
bestSolution = solution;
}
}
}
if (bestSolution != null)
{
ObjectsToKeepUpdated = slideObjects;
ReplaceVariable(bestVar, bestSolution);
ObjectsToKeepUpdated = null;
}
// FindExprsForSlideObjs(slideObjects);
SlideScanner.Instance.ApplyDimsToShapes(slideObjects, values);
CacheEntries = new HashSet <SnapCacheEntry>();
CachedXs = RebuildCache(CachedXs, values);
CachedYs = RebuildCache(CachedYs, values);
CachedLengths = RebuildCache(CachedLengths, values);
}
public VariableCacheEntry(CasVar variable, float value)
{
Variable = variable;
Value = value;
}
// Result is null if solver fails
public Tuple <CasExpr, CasVar> Solve(CasExpr expr, CasVar forV)
{
if (expr.Poly1.ContainsVar(forV) && expr.Poly2.ContainsVar(forV))
{
return(null);
}
if (!expr.Poly1.ContainsVar(forV) && !expr.Poly2.ContainsVar(forV))
{
return(null);
}
if (expr.Poly1.ContainsVar(forV) && !expr.Poly2.ContainsVar(forV))
{
List <CasTerm> zeroTerms = new List <CasTerm>();
List <CasTerm> oneTerms = new List <CasTerm>();
foreach (var t in expr.Poly1.Terms)
{
if (!t.Variables.ContainsKey(forV))
{
zeroTerms.Add(t);
}
else if (t.Variables[forV] == 1)
{
oneTerms.Add(t);
}
else
{
return(null);
}
}
if (oneTerms.Count == 0)
{
return(null);
}
CasPolynomial polyZeros = new CasPolynomial();
CasPolynomial polyOnes = new CasPolynomial();
foreach (var t in zeroTerms)
{
polyZeros.Terms.Add(t.CopyWithCoefficient(-1 * t.Coefficient));
}
foreach (var t in oneTerms)
{
polyOnes.Terms.Add(t.CopyWithCoefficient(t.Coefficient));
t.Variables.Remove(forV);
}
var newVar = NewVar();
var newTerm = new CasTerm(1);
newTerm.Variables[newVar] = 1;
polyZeros.Terms.Add(newTerm);
var resExpr = new CasExpr(CasPolynomial.PolyProd(polyZeros, expr.Poly2), polyOnes);
return(new Tuple <CasExpr, CasVar>(resExpr, newVar));
}
else
{
List <CasTerm> zeroTerms = new List <CasTerm>();
List <CasTerm> oneTerms = new List <CasTerm>();
foreach (var t in expr.Poly2.Terms)
{
if (!t.Variables.ContainsKey(forV))
{
zeroTerms.Add(t);
}
else if (t.Variables[forV] == 1)
{
oneTerms.Add(t);
}
else
{
return(null);
}
}
if (oneTerms.Count == 0)
{
return(null);
}
CasPolynomial polyZeros = new CasPolynomial();
CasPolynomial polyOnes = new CasPolynomial();
var newVar = NewVar();
foreach (var t in zeroTerms)
{
polyZeros.Terms.Add(t.CopyWithCoefficient(-1 * t.Coefficient));
t.Variables[newVar] = 1;
}
foreach (var t in oneTerms)
{
polyOnes.Terms.Add(t.CopyWithCoefficient(t.Coefficient));
t.Variables.Remove(forV);
t.Variables[newVar] = 1;
}
var resExpr = new CasExpr(CasPolynomial.PolySum(polyZeros, expr.Poly2), polyOnes);
return(new Tuple <CasExpr, CasVar>(resExpr, newVar));
}
}
