public void Equation_EqGoal_Satisfy()
{
//2=2
var eq = new Equation(2, 2);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.False(result);
//3=4
eq = new Equation(3, 4);
result = eq.IsEqGoal(out obj);
Assert.False(result);
//3=5-2
var term = new Term(Expression.Add, new List<object>() { 5, -2 });
eq = new Equation(3, term);
result = eq.IsEqGoal(out obj);
Assert.False(result);
//x = x
//TODO
var variable = new Var('x');
eq = new Equation(variable, variable);
/* result = eq.IsEqGoal(out obj);
Assert.True(result);*/
//x = 2x-x
//TODO
term = new Term(Expression.Multiply, new List<object>() { 2, variable });
var term0 = new Term(Expression.Multiply, new List<object>() { -1, variable });
var term1 = new Term(Expression.Add, new List<object>() { term, term0 });
eq = new Equation(variable, term1);
/* result = eq.IsEqGoal(out obj);
Assert.True(result);*/
}
public void Goal_Gen_10()
{
//(3-y)/2-4 = 5
var y = new Var('y');
var yInverse = new Term(Expression.Multiply, new List <object>()
{
-1, y
});
var term1 = new Term(Expression.Add, new List <object>()
{
3, yInverse
});
var term2 = new Term(Expression.Add, new List <object>()
{
2, -4
});
var term11 = new Term(Expression.Divide, new List <object>()
{
term1, term2
});
var eq = new Equation(term11, 5);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var gGoal = obj as EqGoal;
Assert.NotNull(gGoal);
Assert.True(gGoal.Rhs.Equals(13));
}
public void Equation_EqGoal_Satisfy()
{
//2=2
var eq = new Equation(2, 2);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.False(result);
//3=4
eq = new Equation(3, 4);
result = eq.IsEqGoal(out obj);
Assert.False(result);
//3=5-2
var term = new Term(Expression.Add, new List <object>()
{
5, -2
});
eq = new Equation(3, term);
result = eq.IsEqGoal(out obj);
Assert.False(result);
//x = x
//TODO
var variable = new Var('x');
eq = new Equation(variable, variable);
/* result = eq.IsEqGoal(out obj);
* Assert.True(result);*/
//x = 2x-x
//TODO
term = new Term(Expression.Multiply, new List <object>()
{
2, variable
});
var term0 = new Term(Expression.Multiply, new List <object>()
{
-1, variable
});
var term1 = new Term(Expression.Add, new List <object>()
{
term, term0
});
eq = new Equation(variable, term1);
/* result = eq.IsEqGoal(out obj);
* Assert.True(result);*/
}
public void Goal_Gen_8()
{
double value = 5.0d;
var v = new Var("v");
var term1_1 = new Term(Expression.Multiply, new List <object>()
{
-1, 5.0
});
var term1 = new Term(Expression.Add, new List <object>()
{
2.0, term1_1
});
var term11 = new Term(Expression.Power, new List <object>()
{
term1, 2.0
});
var term2_2 = new Term(Expression.Multiply, new List <object>()
{
-1, v
});
var term2 = new Term(Expression.Add, new List <object>()
{
4, term2_2
});
var term22 = new Term(Expression.Power, new List <object>()
{
term2, 2.0
});
var rhs = new Term(Expression.Add, new List <object>()
{
term11, term22
});
var lhs = new Term(Expression.Power, new List <object>()
{
value, 2.0
});
var eq = new Equation(lhs, rhs);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var lst = obj as List <object>;
Assert.NotNull(lst);
Assert.True(lst.Count == 2);
}
public void Test_Algebra_OneVariable_Linear_Goal_Gen_1()
{
//x = 2+3
var x = new Var('x');
var term = new Term(Expression.Add, new List<object>() { 2, 3 });
var eq = new Equation(x, term);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var eqGoal = obj as EqGoal;
Assert.NotNull(eqGoal);
Assert.True(eqGoal.Traces.Count == 1);
Assert.True(eqGoal.Lhs.Equals(x));
Assert.True(eqGoal.Rhs.Equals(5));
Assert.True(result);
}
public void Goal_Gen_9()
{
double value = 5.0d;
var v = new Var("v");
var term1_1 = new Term(Expression.Multiply, new List <object>()
{
-1, 5.0
});
var term1 = new Term(Expression.Subtract, new List <object>()
{
2.0, 5.0
});
var term11 = new Term(Expression.Power, new List <object>()
{
term1, 2.0
});
var term2_2 = new Term(Expression.Multiply, new List <object>()
{
-1, v
});
var term2 = new Term(Expression.Subtract, new List <object>()
{
4, v
});
var term22 = new Term(Expression.Power, new List <object>()
{
term2, 2.0
});
var rhs = new Term(Expression.Add, new List <object>()
{
term11, term22
});
var lhs = new Term(Expression.Power, new List <object>()
{
value, 2.0
});
var eq = new Equation(lhs, rhs);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.False(result);
//do not use substract when dealing with variable. use add instead.
}
public void Goal_Gen_5()
{
//1*x=0
var x = new Var("x");
var term = new Term(Expression.Multiply, new List <object>()
{
1, x
});
var eq = new Equation(term, 0);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var eqGoal = obj as EqGoal;
Assert.NotNull(eqGoal);
Assert.True(eqGoal.Rhs.Equals(0));
}
public void Goal_Gen_3()
{
//x=(-1)*0
var x = new Var('x');
var term = new Term(Expression.Multiply, new List <object>()
{
-1, 0
});
var eq = new Equation(x, term);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var goal = obj as EqGoal;
Assert.NotNull(goal);
Assert.True(goal.Rhs.Equals(0));
}
public void Goal_Gen_7()
{
//a^2 = 25
// 25 = (a-3.0)^2+(6.0-3.0)^2
object pt1XCoord = new Var("a");
object pt1YCoord = 6.0;
object pt2XCoord = -3.0;
object pt2YCoord = -3.0;
var term1 = new Term(Expression.Add, new List <object>()
{
pt1XCoord, pt2XCoord
});
var term11 = new Term(Expression.Power, new List <object>()
{
term1, 2.0
});
var term2 = new Term(Expression.Add, new List <object>()
{
pt1YCoord, pt2YCoord
});
var term22 = new Term(Expression.Power, new List <object>()
{
term2, 2.0
});
var rhs = new Term(Expression.Add, new List <object>()
{
term11, term22
});
var eq = new Equation(rhs, 25);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var lst = obj as List <object>;
Assert.NotNull(lst);
Assert.True(lst.Count == 2);
var gGoal1 = lst[0] as EqGoal;
Assert.NotNull(gGoal1);
Assert.True(gGoal1.Traces.Count == 1);
}
public void Test_Algebra_OneVariable_Linear_Goal_Gen_1()
{
//x = 2+3
var x = new Var('x');
var term = new Term(Expression.Add, new List <object>()
{
2, 3
});
var eq = new Equation(x, term);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var eqGoal = obj as EqGoal;
Assert.NotNull(eqGoal);
Assert.True(eqGoal.Traces.Count == 1);
Assert.True(eqGoal.Lhs.Equals(x));
Assert.True(eqGoal.Rhs.Equals(5));
Assert.True(result);
}
public void Goal_Gen_12()
{
//-1*v = 2
var v = new Var('v');
var term = new Term(Expression.Multiply, new List <object>()
{
-1, v
});
var eq = new Equation(term, 2);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var gGoal = obj as EqGoal;
Assert.NotNull(gGoal);
Assert.True(gGoal.Rhs.Equals(-2));
Assert.True(gGoal.Traces.Count == 1);
}
public void Goal_Gen_8()
{
double value = 5.0d;
var v = new Var("v");
var term1_1 = new Term(Expression.Multiply, new List<object>() { -1, 5.0 });
var term1 = new Term(Expression.Add, new List<object>() { 2.0, term1_1 });
var term11 = new Term(Expression.Power, new List<object>() { term1, 2.0 });
var term2_2 = new Term(Expression.Multiply, new List<object>() { -1, v });
var term2 = new Term(Expression.Add, new List<object>() { 4, term2_2 });
var term22 = new Term(Expression.Power, new List<object>() { term2, 2.0 });
var rhs = new Term(Expression.Add, new List<object>() { term11, term22 });
var lhs = new Term(Expression.Power, new List<object>() { value, 2.0 });
var eq = new Equation(lhs, rhs);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var lst = obj as List<object>;
Assert.NotNull(lst);
Assert.True(lst.Count == 2);
}
public void Goal_Gen_6()
{
// d^2 = (1.0-4.0)^2+(2.0-6.0)^2
// d>0
object pt1XCoord = 1.0;
object pt1YCoord = 2.0;
object pt2XCoord = 4.0;
object pt2YCoord = 6.0;
var variable = new Var('d');
var lhs = new Term(Expression.Power, new List<object>() { variable, 2.0 });
var term1 = new Term(Expression.Subtract, new List<object>() { pt1XCoord, pt2XCoord });
var term11 = new Term(Expression.Power, new List<object>() { term1, 2.0 });
var term2 = new Term(Expression.Subtract, new List<object>() { pt1YCoord, pt2YCoord });
var term22 = new Term(Expression.Power, new List<object>() { term2, 2.0 });
var rhs = new Term(Expression.Add, new List<object>() { term11, term22 });
//var obj = rhs.Eval();
//Assert.True(obj.Equals(25));
var eq = new Equation(lhs, rhs);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var lst = obj as List<object>;
Assert.NotNull(lst);
Assert.True(lst.Count == 2);
//Trace Verify
var gGoal = lst[0] as EqGoal;
Assert.NotNull(gGoal);
Assert.True(gGoal.Traces.Count == 1);
var steps = gGoal.Traces[0].Item2 as List<TraceStep>;
Assert.NotNull(steps);
Assert.True(steps.Count == 7);
var lastStep = steps[6];
Assert.NotNull(lastStep);
}
public void Goal_Gen_12()
{
//-1*v = 2
var v = new Var('v');
var term = new Term(Expression.Multiply, new List<object>() { -1, v });
var eq = new Equation(term, 2);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var gGoal = obj as EqGoal;
Assert.NotNull(gGoal);
Assert.True(gGoal.Rhs.Equals(-2));
Assert.True(gGoal.Traces.Count == 1);
}
public void Goal_Gen_6()
{
// d^2 = (1.0-4.0)^2+(2.0-6.0)^2
// d>0
object pt1XCoord = 1.0;
object pt1YCoord = 2.0;
object pt2XCoord = 4.0;
object pt2YCoord = 6.0;
var variable = new Var('d');
var lhs = new Term(Expression.Power, new List <object>()
{
variable, 2.0
});
var term1 = new Term(Expression.Subtract, new List <object>()
{
pt1XCoord, pt2XCoord
});
var term11 = new Term(Expression.Power, new List <object>()
{
term1, 2.0
});
var term2 = new Term(Expression.Subtract, new List <object>()
{
pt1YCoord, pt2YCoord
});
var term22 = new Term(Expression.Power, new List <object>()
{
term2, 2.0
});
var rhs = new Term(Expression.Add, new List <object>()
{
term11, term22
});
//var obj = rhs.Eval();
//Assert.True(obj.Equals(25));
var eq = new Equation(lhs, rhs);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var lst = obj as List <object>;
Assert.NotNull(lst);
Assert.True(lst.Count == 2);
//Trace Verify
var gGoal = lst[0] as EqGoal;
Assert.NotNull(gGoal);
Assert.True(gGoal.Traces.Count == 1);
var steps = gGoal.Traces[0].Item2 as List <TraceStep>;
Assert.NotNull(steps);
Assert.True(steps.Count == 7);
var lastStep = steps[6];
Assert.NotNull(lastStep);
}
public static void FromPointsToMidPoint(PointSymbol ps1, PointSymbol ps2, PointSymbol midPoint)
{
//1. plot the ps1, ps2 and the line
//2. generate x coordinate
//3. generate y coordinate
//4. generate point (x,y)
string strategy;
var ts00 = new TraceStep(null, ps1, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(ps1));
var ts01 = new TraceStep(null, ps2, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(ps2));
var ls = LineBinaryRelation.Unify(ps1, ps2) as LineSymbol;
var ts02 = new TraceStep(null, ls, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(ls));
strategy = "Plot the given two points and the connected line.";
midPoint._innerLoop.Add(ts00);
midPoint._innerLoop.Add(ts01);
midPoint._innerLoop.Add(ts02);
midPoint.GenerateATrace(strategy);
////////////////////////////////////////////////
var xCoord = new Var("x");
var pt1 = ps1.Shape as Point;
Debug.Assert(pt1 != null);
var pt2 = ps2.Shape as Point;
Debug.Assert(pt2 != null);
var term1 = new Term(Expression.Add, new List<object>(){pt1.XCoordinate, pt2.XCoordinate});
var term2 = new Term(Expression.Divide, new List<object>(){term1, 2});
var eq = new Equation(xCoord, term2);
/////////////////////////////////////////////////
object obj;
bool result = eq.IsEqGoal(out obj);
EqGoal goal1 = null;
if (result)
{
goal1 = obj as EqGoal;
Debug.Assert(goal1!=null);
Debug.Assert(goal1.Traces.Count == 1);
var currentTrace = goal1.Traces.ToList()[0];
strategy = "Generate x coordinate of midpoint.";
var newTrace = new Tuple<object, object>(strategy, currentTrace.Item2);
midPoint.Traces.Add(newTrace);
}
//////////////////////////////////////////////////
var yCoord = new Var("y");
term1 = new Term(Expression.Add, new List<object>() { pt1.YCoordinate, pt2.YCoordinate });
term2 = new Term(Expression.Divide, new List<object>() { term1, 2 });
var eq1 = new Equation(yCoord, term2);
result = eq1.IsEqGoal(out obj);
EqGoal goal2 = null;
if (result)
{
goal2 = obj as EqGoal;
Debug.Assert(goal2 != null);
Debug.Assert(goal2.Traces.Count == 1);
var currentTrace1 = goal2.Traces.ToList()[0];
strategy = "Generate y coordinate of midpoint.";
var newTrace = new Tuple<object, object>(strategy, currentTrace1.Item2);
midPoint.Traces.Add(newTrace);
}
//////////////////////////////////////////////////////
var ps = new Point(xCoord, yCoord);
var psym = new PointSymbol(ps);
var mid = midPoint.Shape as Point;
Debug.Assert(mid != null);
var ps_inter1 = new Point(mid.XCoordinate, yCoord);
var psym_inter1 = new PointSymbol(ps_inter1);
var metaRule = "Consider substitute generate x coordinate into the point form.";
var appliedRule = SubstitutionRule.ApplySubstitute(goal1, psym);
var ts1 = new TraceStep(psym, psym_inter1, null, metaRule, appliedRule);
metaRule = "Consider substitute generate y coordinate into the point form.";
appliedRule = SubstitutionRule.ApplySubstitute(goal2, psym_inter1);
var ts2 = new TraceStep(psym_inter1, midPoint, null, metaRule, appliedRule);
strategy = "Generate point (x,y) by subsitute generated x and y.";
midPoint._innerLoop.Add(ts1);
midPoint._innerLoop.Add(ts2);
midPoint.GenerateATrace(strategy);
}
public void Goal_Gen_5()
{
//1*x=0
var x = new Var("x");
var term = new Term(Expression.Multiply, new List<object>() { 1, x });
var eq = new Equation(term, 0);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var eqGoal = obj as EqGoal;
Assert.NotNull(eqGoal);
Assert.True(eqGoal.Rhs.Equals(0));
}
public static void LineSlopeIntercepToGraph(LineSymbol ls)
{
string strategy = strategy_graphing;
//Plotting shapes
//1. plotting Y-Intercept
//2. plotting X-Intercept
//3. plotting the line
//////////////////////////////////////////////////////////////
// Step 1:
var pt = new Point(0, ls.SymIntercept);
var ptSym = new PointSymbol(pt);
var ts0 = new TraceStep(null, ptSym, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(ptSym));
ls._innerLoop.Add(ts0);
//////////////////////////////////////////////////////////////
// Step 2:
var line = ls.Shape as Line;
Debug.Assert(line != null);
Equation eq;
if (line.B == null)
{
}
else
{
var x = new Var("x");
//step 2.1
var term = new Term(Expression.Multiply, new List<object>() { line.Slope, x });
var term1 = new Term(Expression.Add, new List<object>() { term, line.Intercept });
eq = new Equation(term1, 0);
object obj;
EqGoal gGoal = null;
bool result = eq.IsEqGoal(out obj);
if (result)
{
gGoal = obj as EqGoal;
}
if (gGoal != null)
{
double dX;
LogicSharp.IsDouble(gGoal.Rhs, out dX);
var pt1 = new Point(dX, 0);
var ptSym1 = new PointSymbol(pt1);
var ts1 = new TraceStep(null, ptSym1, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(ptSym1));
ls._innerLoop.Add(ts1);
}
}
/////////////////////////////////////////////////////////////////
const string step1MetaRule = "Given the line slope-intercept form y=mx+b, plot the line by passing points (0,b) and (-b/m,0).";
string step1AppliedRule = String.Format("Plotting the line passing through (0,{0}) and ({1},0) ", ls.SymIntercept, ls.SymC);
//var ts = new TraceStep(null, ls.SlopeInterceptForm, step1MetaRule, step1AppliedRule);
string kc = GeometryScaffold.KC_LineGraphing;
var ts = new TraceStep(null, ls, kc, step1MetaRule, step1AppliedRule);
ls._innerLoop.Add(ts);
//////////////////////////////////////////////////////////////////
ls.GenerateATrace(strategy);
}
public void Goal_Gen_10()
{
//(3-y)/2-4 = 5
var y = new Var('y');
var yInverse = new Term(Expression.Multiply, new List<object>() { -1, y });
var term1 = new Term(Expression.Add, new List<object>() { 3, yInverse });
var term2 = new Term(Expression.Add, new List<object>() { 2, -4 });
var term11 = new Term(Expression.Divide, new List<object>() { term1, term2 });
var eq = new Equation(term11, 5);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var gGoal = obj as EqGoal;
Assert.NotNull(gGoal);
Assert.True(gGoal.Rhs.Equals(13));
}
//backward solving
public static object FromLineToSlope(LineSymbol ls, double value)
{
var line = ls.Shape as Line;
Debug.Assert(line != null);
var pt1 = line.Rel1 as Point;
var pt2 = line.Rel2 as Point;
if (pt1 == null || pt2 == null) return null;
//(pt2.Y-pt1.Y)/(pt2.X-pt1.X) = slope
var yInverse = new Term(Expression.Multiply, new List<object>() { -1, pt1.YCoordinate });
var term1 = new Term(Expression.Add, new List<object>() { pt2.YCoordinate, yInverse });
var xInverse = new Term(Expression.Multiply, new List<object>() { -1, pt1.XCoordinate });
var term2 = new Term(Expression.Add, new List<object>() { pt2.XCoordinate, xInverse });
var term11 = new Term(Expression.Divide, new List<object>() { term1, term2 });
var eq = new Equation(term11, value);
object obj1;
bool result = eq.IsEqGoal(out obj1);
if (!result) return null;
var eqGoal = obj1 as EqGoal;
if (eqGoal == null) return null;
var newTraces = new List<Tuple<object, object>>();
newTraces.Add(SlopeSubstitution(pt1, pt2, value));
Debug.Assert(eqGoal.Traces.Count == 1);
var trace = eqGoal.Traces[0];
var subStrategy = "Derive unknown variable by manipulating the current algebraic expression.";
var newTrace = new Tuple<object, object>(subStrategy, trace.Item2);
newTraces.Add(newTrace);
//newTraces.AddRange(eqGoal.Traces);
eqGoal.Traces = newTraces;
return new List<object>() { eqGoal };
}
public void Goal_Gen_7()
{
//a^2 = 25
// 25 = (a-3.0)^2+(6.0-3.0)^2
object pt1XCoord = new Var("a");
object pt1YCoord = 6.0;
object pt2XCoord = -3.0;
object pt2YCoord = -3.0;
var term1 = new Term(Expression.Add, new List<object>() { pt1XCoord, pt2XCoord });
var term11 = new Term(Expression.Power, new List<object>() { term1, 2.0 });
var term2 = new Term(Expression.Add, new List<object>() { pt1YCoord, pt2YCoord });
var term22 = new Term(Expression.Power, new List<object>() { term2, 2.0 });
var rhs = new Term(Expression.Add, new List<object>() { term11, term22 });
var eq = new Equation(rhs, 25);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var lst = obj as List<object>;
Assert.NotNull(lst);
Assert.True(lst.Count == 2);
var gGoal1 = lst[0] as EqGoal;
Assert.NotNull(gGoal1);
Assert.True(gGoal1.Traces.Count == 1);
}
public static void FromPointSlopeToLine(PointSymbol ps, EqGoal goal, LineSymbol ls)
{
string strategy = "Substitute point and slope property into line form.";
// 1. Substitute slope property into the line slope-intercept form.
// 2. Calculate the line intercept by substituting the point into line pattern.
//////////////////////////////////////////////////////////////////////
string strategy1 = "Substitute slope property into the line slope-intercept form.";
var m = new Var("m");
var k = new Var("k");
var x = new Var("x");
var y = new Var("y");
var term = new Term(Expression.Multiply, new List<object>() {m, x});
var term1 = new Term(Expression.Add, new List<object>() {term, k});
var eqPattern = new Equation(y, term1);
var term2 = new Term(Expression.Multiply, new List<object>() {goal.Rhs,x});
var term3 = new Term(Expression.Add, new List<object>() {term2, k});
var eqInternal1 = new Equation(y, term3);
var appliedRule1 = SubstitutionRule.ApplySubstitute(eqPattern, goal);
var ts0 = new TraceStep(eqPattern, eqInternal1, SubstitutionRule.SubstituteKC(), strategy1, appliedRule1);
ls._innerLoop.Add(ts0);
//////////////////////////////////////////////////////////////////////
var point = ps.Shape as Point;
Debug.Assert(point != null);
string strategy2 = "Calculate the line intercept by substituting the point into line pattern.";
var term4 = new Term(Expression.Multiply, new List<object>() { goal.Rhs, point.XCoordinate});
var term5 = new Term(Expression.Add, new List<object>() {term4, k});
var eqinternal2 = new Equation(point.YCoordinate, term5);
object obj;
bool result = eqinternal2.IsEqGoal(out obj);
var eqGoal = obj as EqGoal;
Debug.Assert(eqGoal != null);
var gTuple = eqGoal.Traces[0];
var gLst = gTuple.Item2 as List<TraceStep>;
Debug.Assert(gLst != null);
ls._innerLoop.AddRange(gLst);
var appliedRule2 = SubstitutionRule.ApplySubstitute(eqInternal1, ps);
var ts = new TraceStep(eqInternal1, ls, SubstitutionRule.SubstituteKC(), strategy2, appliedRule2);
ls._innerLoop.Add(ts);
ls.GenerateATrace(strategy);
}
public void Goal_Gen_9()
{
double value = 5.0d;
var v = new Var("v");
var term1_1 = new Term(Expression.Multiply, new List<object>() { -1, 5.0 });
var term1 = new Term(Expression.Subtract, new List<object>() { 2.0, 5.0 });
var term11 = new Term(Expression.Power, new List<object>() { term1, 2.0 });
var term2_2 = new Term(Expression.Multiply, new List<object>() { -1, v });
var term2 = new Term(Expression.Subtract, new List<object>() { 4, v });
var term22 = new Term(Expression.Power, new List<object>() { term2, 2.0 });
var rhs = new Term(Expression.Add, new List<object>() { term11, term22 });
var lhs = new Term(Expression.Power, new List<object>() { value, 2.0 });
var eq = new Equation(lhs, rhs);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.False(result);
//do not use substract when dealing with variable. use add instead.
}
//forward chaining
public static void FromLineSegmentToDistance(LineSegmentSymbol lss)
{
//1. Substitute two points coordinates into the distance function.
//2. Manipulate the expression to derive the goal.
////////////////////////////////////////////////////////
//1.
lss.Traces.Add(DistanceSubstitution(lss));
////////////////////////////////////////////////////////
//2.
var ls = lss.Shape as LineSegment;
var variable = new Var('d');
var lhs = new Term(Expression.Power, new List<object>() { variable, 2.0 });
var term1 = new Term(Expression.Subtract, new List<object>() {ls.Pt1.XCoordinate, ls.Pt2.XCoordinate});
var term11 = new Term(Expression.Power, new List<object>() {term1, 2.0});
var term2 = new Term(Expression.Subtract, new List<object>() {ls.Pt1.YCoordinate, ls.Pt2.YCoordinate});
var term22 = new Term(Expression.Power, new List<object>() {term2, 2.0});
var rhs = new Term(Expression.Add, new List<object>() {term11, term22});
var eq = new Equation(lhs, rhs);
object obj1;
bool result = eq.IsEqGoal(out obj1);
EqGoal eqGoal = null;
Debug.Assert(result);
var lst1 = obj1 as List<object>;
foreach (var temp in lst1)
{
var tempGoal = temp as EqGoal;
if (tempGoal == null) continue;
double dNum;
bool tempResult = LogicSharp.IsDouble(tempGoal.Rhs, out dNum);
if (tempResult && dNum > 0)
{
eqGoal = tempGoal;
break;
}
}
Debug.Assert(eqGoal != null);
lss.Traces.AddRange(eqGoal.Traces);
}
public void Goal_Gen_3()
{
//x=(-1)*0
var x = new Var('x');
var term = new Term(Expression.Multiply, new List<object>() { -1, 0 });
var eq = new Equation(x, term);
object obj;
bool result = eq.IsEqGoal(out obj);
Assert.True(result);
var goal = obj as EqGoal;
Assert.NotNull(goal);
Assert.True(goal.Rhs.Equals(0));
}
//backward chaining
public static object FromLineSegmentToDistance(LineSegmentSymbol lss, double value)
{
//0. Plotting existing knowledge
//1. Substitute two points coordinates into the distance function.
//2. Manipulate the expression to derive the goal.
////////////////////////////////////////////////////////
var ls = lss.Shape as LineSegment;
Debug.Assert(ls != null);
FromPointsToLineSegment(lss);
var term1_1 = new Term(Expression.Multiply, new List<object>() {-1, ls.Pt2.XCoordinate});
var term1 = new Term(Expression.Add, new List<object>() { ls.Pt1.XCoordinate, term1_1 });
var term11 = new Term(Expression.Power, new List<object>() { term1, 2.0 });
var term2_2 = new Term(Expression.Multiply, new List<object>() {-1, ls.Pt2.YCoordinate});
var term2 = new Term(Expression.Add, new List<object>() { ls.Pt1.YCoordinate, term2_2});
var term22 = new Term(Expression.Power, new List<object>() { term2, 2.0 });
var rhs = new Term(Expression.Add, new List<object>() { term11, term22 });
var lhs = new Term(Expression.Power, new List<object>() {value, 2.0});
var eq = new Equation(lhs, rhs);
object obj1;
bool result = eq.IsEqGoal(out obj1);
if (result)
{
var lst = obj1 as List<object>;
if (lst != null)
{
foreach (object tempObj in lst)
{
var gGoal = tempObj as EqGoal;
if (gGoal != null)
{
var newTraces = new List<Tuple<object, object>>();
newTraces.AddRange(lss.Traces);
newTraces.Add(DistanceSubstitution(lss));
newTraces.AddRange(gGoal.Traces);
gGoal.Traces = newTraces;
}
}
}
return obj1;
}
return null;
}
