/* * Annotated scaffolding * */ public static void FromPointsToLineSegment(LineSegmentSymbol lss) { var ls = lss.Shape as LineSegment; Debug.Assert(ls != null); var pt1Symbol = new PointSymbol(ls.Pt1); var pt2Symbol = new PointSymbol(ls.Pt2); string strategy; TraceStep ts00 = new TraceStep(null, pt1Symbol, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(pt1Symbol)); TraceStep ts01 = new TraceStep(null, pt2Symbol, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(pt2Symbol)); TraceStep ts02 = null; if (ls.Pt1.Concrete && ls.Pt2.Concrete) { ts02 = new TraceStep(null, lss, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(lss)); } strategy = "Plot a Line Segment passing through two points."; lss._innerLoop.Add(ts00); lss._innerLoop.Add(ts01); if (ts02 != null) { lss._innerLoop.Add(ts02); } lss.GenerateATrace(strategy); /* string stepMetaRule = "Consider draw a line segment passing through the two points."; string stepAppliedRule = String.Format("Draw the line segment passing through two points {0} and {1}", pt1Symbol, pt2Symbol); var traceStep = new TraceStep(null, lss, stepMetaRule, stepAppliedRule); lss._innerLoop.Add(traceStep);*/ }
/* * Annotated scaffolding * */ public static void FromPointsToLineSegment(LineSegmentSymbol lss) { var ls = lss.Shape as LineSegment; Debug.Assert(ls != null); var pt1Symbol = new PointSymbol(ls.Pt1); var pt2Symbol = new PointSymbol(ls.Pt2); string strategy; TraceStep ts00 = new TraceStep(null, pt1Symbol, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(pt1Symbol)); TraceStep ts01 = new TraceStep(null, pt2Symbol, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(pt2Symbol)); TraceStep ts02 = null; if (ls.Pt1.Concrete && ls.Pt2.Concrete) { ts02 = new TraceStep(null, lss, null, PlottingRule.PlottingStrategy, PlottingRule.Plot(lss)); } strategy = "Plot a Line Segment passing through two points."; lss._innerLoop.Add(ts00); lss._innerLoop.Add(ts01); if (ts02 != null) { lss._innerLoop.Add(ts02); } lss.GenerateATrace(strategy); /* string stepMetaRule = "Consider draw a line segment passing through the two points."; * string stepAppliedRule = String.Format("Draw the line segment passing through two points {0} and {1}", * pt1Symbol, pt2Symbol); * * var traceStep = new TraceStep(null, lss, stepMetaRule, stepAppliedRule); * lss._innerLoop.Add(traceStep);*/ }
//forward solving private static object InferDistance(this LineSegmentSymbol inputLineSymbol, string label) { var lineSeg = inputLineSymbol.Shape as LineSegment; Debug.Assert(lineSeg != null); if (label != null && lineSeg.Distance != null) { var goal = new EqGoal(new Var(label), lineSeg.Distance); TraceInstructionalDesign.FromLineSegmentToDistance(inputLineSymbol); goal.Traces.AddRange(inputLineSymbol.Traces); return(goal); } if (label != null && inputLineSymbol.CachedSymbols.Count != 0) { var goalList = new List <object>(); foreach (var lss in inputLineSymbol.CachedSymbols) { var cachedLss = lss as LineSegmentSymbol; Debug.Assert(cachedLss != null); var cachedLs = cachedLss.Shape as LineSegment; Debug.Assert(cachedLs != null); var goal = new EqGoal(new Var(label), cachedLs.Distance); //goal.Traces.AddRange(cachedLss.Traces); TraceInstructionalDesign.FromLineSegmentToDistance(cachedLss); goal.Traces.AddRange(cachedLss.Traces); goalList.Add(goal); } return(goalList); } return(null); }
public void Test_Unify() { var x = new Var("x"); var pt1 = new Point(x, 2.0); var pt2 = new Point(3.0, 5.0); var ls = new LineSegment(pt1, pt2); var lss = new LineSegmentSymbol(ls); var d = new Var("d"); var eqGoal = new EqGoal(d, 5); object obj; bool result = lss.UnifyProperty(eqGoal, 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.Lhs.ToString().Equals("x")); Assert.True(gGoal1.Rhs.ToString().Equals("7")); Assert.True(gGoal1.Traces.Count == 3); var gGoal2 = lst[1] as EqGoal; Assert.NotNull(gGoal2); Assert.True(gGoal2.Lhs.ToString().Equals("x")); Assert.True(gGoal2.Rhs.ToString().Equals("-1")); // Assert.True(gGoal2.Traces.Count == 1); }
public static LineSegmentSymbol GenerateLineSegment(Point pt1, Point pt2) { if (pt1.Equals(pt2)) return null; Debug.Assert(pt1.Concrete); Debug.Assert(pt2.Concrete); var ls = new LineSegment(pt1, pt2); var lss = new LineSegmentSymbol(ls); if(pt1.Traces.Count != 0) lss.Traces.AddRange(pt1.Traces); if(pt2.Traces.Count != 0) lss.Traces.AddRange(pt2.Traces); TraceInstructionalDesign.FromPointsToLineSegment(lss); return lss; }
public void Problem01() { /* const string input1 = "A(2,0)"; * const string input2 = "B(5,4)";*/ var pt1 = new Point(2, 0); var ps1 = new PointSymbol(pt1); var pt2 = new Point(5, 4); var ps2 = new PointSymbol(pt2); var d = new Var("d"); var eqGoal = new EqGoal(d, 5); var ls = new LineSegment(pt1, pt2); var lss = new LineSegmentSymbol(ls); TraceInstructionalDesign.FromPointsToLineSegment(lss); TraceInstructionalDesign.FromLineSegmentToDistance(lss); }
/* * Automatic scaffolding * * Distance function (x-x0)^2+(y-y0)^2 = d^2 * * Forward chaining to derive d. * Backward chaining to derive other four parameters. */ private static Tuple<object, object> DistanceSubstitution(LineSegmentSymbol lss) { var ls = lss.Shape as LineSegment; var lst = new List<TraceStep>(); string step1metaRule = "The Distance Function between two points it: d^2=(x0-x1)^2+(y0-y1)^2"; string step1AppliedRule = String.Format( "Substitute two points into the distance function d^2=({0}-{1})^2+({2}-{3})^2", ls.Pt1.XCoordinate.ToString(), ls.Pt2.XCoordinate.ToString(), ls.Pt1.YCoordinate.ToString(), ls.Pt2.YCoordinate.ToString()); var pt1X = new Var("x0"); var pt1Y = new Var("y0"); var pt2X = new Var("x1"); var pt2Y = new Var("y1"); var term1_1 = new Term(Expression.Subtract, new List<object>() { pt1X, pt2X }); var term11_1 = new Term(Expression.Power, new List<object>() { term1_1, 2.0 }); var term2_1 = new Term(Expression.Subtract, new List<object>() { pt1Y, pt2Y }); var term22_1 = new Term(Expression.Power, new List<object>() { term2_1, 2.0 }); var rhs_1 = new Term(Expression.Add, new List<object>() { term11_1, term22_1 }); 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); var old_eq = new Equation(lhs, rhs_1); var trace = new TraceStep(old_eq, eq, GeometryScaffold.KC_Distance, step1metaRule, step1AppliedRule); lst.Add(trace); string strategy = "Substitute two points coordinates into the distance function."; var newTuple = new Tuple<object, object>(strategy, lst); return newTuple; }
public static LineSegmentSymbol GenerateLineSegment(Point pt1, Point pt2) { if (pt1.Equals(pt2)) { return(null); } Debug.Assert(pt1.Concrete); Debug.Assert(pt2.Concrete); var ls = new LineSegment(pt1, pt2); var lss = new LineSegmentSymbol(ls); if (pt1.Traces.Count != 0) { lss.Traces.AddRange(pt1.Traces); } if (pt2.Traces.Count != 0) { lss.Traces.AddRange(pt2.Traces); } TraceInstructionalDesign.FromPointsToLineSegment(lss); return(lss); }
public static object Unify(this LineSegmentSymbol lss, object constraint) { var label = constraint as string; var eqGoal = constraint as EqGoal; //forward solving if (label != null) { switch (label) { case LineSegmentAcronym.Distance1: case LineSegmentAcronym.Distance2: return(lss.InferDistance(label)); } } //backward solving if (eqGoal != null) { var rhs = eqGoal.Rhs; double dNum; bool isDouble = LogicSharp.IsDouble(rhs, out dNum); if (!isDouble) { return(null); } var lhs = eqGoal.Lhs.ToString(); switch (lhs) { case LineSegmentAcronym.Distance1: case LineSegmentAcronym.Distance2: return(lss.InferDistance(dNum)); } } return(null); }
private LineSegmentSymbol MockSegment() { var pt1 = new Point("A", 2, 0); var pt2 = new Point("B", 5, 4); var seg = new LineSegment("AB", pt1, pt2); var segSymbol = new LineSegmentSymbol(seg); return segSymbol; }
public void Test_Unify() { var x = new Var("x"); var pt1 = new Point(x, 2.0); var pt2 = new Point(3.0, 5.0); var ls = new LineSegment(pt1, pt2); var lss = new LineSegmentSymbol(ls); var d = new Var("d"); var eqGoal = new EqGoal(d, 5); object obj; bool result = lss.UnifyProperty(eqGoal, 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.Lhs.ToString().Equals("x")); Assert.True(gGoal1.Rhs.ToString().Equals("7")); Assert.True(gGoal1.Traces.Count == 3); var gGoal2 = lst[1] as EqGoal; Assert.NotNull(gGoal2); Assert.True(gGoal2.Lhs.ToString().Equals("x")); Assert.True(gGoal2.Rhs.ToString().Equals("-1")); // Assert.True(gGoal2.Traces.Count == 1); }
//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); }
private static bool Reify(this LineSegmentSymbol lineSegSymbol, PointSymbol ps1, PointSymbol ps2) { //if (!lineSeg.RelationStatus) return false; lineSegSymbol.CachedSymbols.Clear(); //re-compute purpose var shape1Lst = new List <PointSymbol>(); var shape2Lst = new List <PointSymbol>(); #region Caching Point 1 if (ps1.Shape.Concrete) { shape1Lst.Add(ps1); } else { foreach (var shapeSymbol in ps1.CachedSymbols.ToList()) { var ptTemp = shapeSymbol as PointSymbol; Debug.Assert(ptTemp != null); if (ptTemp.Shape.Concrete) { shape1Lst.Add(ptTemp); } } } #endregion #region Caching Point 2 if (ps2.Shape.Concrete) { shape2Lst.Add(ps2); } else { foreach (var shapeSymbol in ps2.CachedSymbols.ToList()) { var ptTemp = shapeSymbol as PointSymbol; Debug.Assert(ptTemp != null); if (ptTemp.Shape.Concrete) { shape2Lst.Add(ptTemp); } } } #endregion #region Generate caching linesegment if (shape1Lst.Count == 0 || shape2Lst.Count == 0) { return(false); } foreach (var gPt1 in shape1Lst) { foreach (var gPt2 in shape2Lst) { Debug.Assert(gPt1 != null); Debug.Assert(gPt2 != null); var gPoint1 = gPt1.Shape as Point; var gPoint2 = gPt2.Shape as Point; Debug.Assert(gPoint1 != null); Debug.Assert(gPoint2 != null); Debug.Assert(gPoint1.Concrete); Debug.Assert(gPoint2.Concrete); var lineTemp = LineSegmentGenerationRule.GenerateLineSegment(gPoint1, gPoint2); if (lineTemp != null) { lineSegSymbol.CachedSymbols.Add(lineTemp); } } } #endregion return(true); }
/* * Automatic scaffolding * * Distance function (x-x0)^2+(y-y0)^2 = d^2 * * Forward chaining to derive d. * Backward chaining to derive other four parameters. */ private static Tuple <object, object> DistanceSubstitution(LineSegmentSymbol lss) { var ls = lss.Shape as LineSegment; var lst = new List <TraceStep>(); string step1metaRule = "The Distance Function between two points it: d^2=(x0-x1)^2+(y0-y1)^2"; string step1AppliedRule = String.Format( "Substitute two points into the distance function d^2=({0}-{1})^2+({2}-{3})^2", ls.Pt1.XCoordinate.ToString(), ls.Pt2.XCoordinate.ToString(), ls.Pt1.YCoordinate.ToString(), ls.Pt2.YCoordinate.ToString()); var pt1X = new Var("x0"); var pt1Y = new Var("y0"); var pt2X = new Var("x1"); var pt2Y = new Var("y1"); var term1_1 = new Term(Expression.Subtract, new List <object>() { pt1X, pt2X }); var term11_1 = new Term(Expression.Power, new List <object>() { term1_1, 2.0 }); var term2_1 = new Term(Expression.Subtract, new List <object>() { pt1Y, pt2Y }); var term22_1 = new Term(Expression.Power, new List <object>() { term2_1, 2.0 }); var rhs_1 = new Term(Expression.Add, new List <object>() { term11_1, term22_1 }); 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); var old_eq = new Equation(lhs, rhs_1); var trace = new TraceStep(old_eq, eq, GeometryScaffold.KC_Distance, step1metaRule, step1AppliedRule); lst.Add(trace); string strategy = "Substitute two points coordinates into the distance function."; var newTuple = new Tuple <object, object>(strategy, lst); return(newTuple); }
//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; }
//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 static Expr ToExpr(this LineSegmentSymbol lss) { Debug.Assert(lss.Shape.Label != null); return(Text.Convert(lss.ToString())); }
//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 static LineSegmentSymbol Unify(PointSymbol pt1, PointSymbol pt2) { //point identify check if (pt1.Equals(pt2)) { return(null); } var point1 = pt1.Shape as Point; var point2 = pt2.Shape as Point; Debug.Assert(point1 != null); Debug.Assert(point2 != null); //lazy evaluation //Constraint solving on Graph var lineSeg = new LineSegment(null); //Ghost Line Segment lineSeg.Pt1 = point1; lineSeg.Pt2 = point2; var lss = new LineSegmentSymbol(lineSeg); //Line build process if (pt1.Shape.Concrete) { if (pt2.Shape.Concrete) { return(LineSegmentGenerationRule.GenerateLineSegment(point1, point2)); } if (pt2.CachedSymbols.Count != 0) { foreach (ShapeSymbol ss in pt2.CachedSymbols) { var ps = ss as PointSymbol; Debug.Assert(ps != null); Debug.Assert(ps.Shape.Concrete); var cachePoint = ps.Shape as Point; Debug.Assert(cachePoint != null); var gLss = LineSegmentGenerationRule.GenerateLineSegment(point1, cachePoint); gLss.Traces.AddRange(ps.Traces); lss.CachedSymbols.Add(gLss); } } return(lss); } Debug.Assert(!pt1.Shape.Concrete); if (pt2.Shape.Concrete) { if (pt1.CachedSymbols.Count != 0) { foreach (ShapeSymbol ss in pt1.CachedSymbols) { var ps = ss as PointSymbol; Debug.Assert(ps != null); Debug.Assert(ps.Shape.Concrete); var cachePoint = ps.Shape as Point; Debug.Assert(cachePoint != null); var gLss = LineSegmentGenerationRule.GenerateLineSegment(cachePoint, point2); gLss.Traces.AddRange(ps.Traces); lss.CachedSymbols.Add(gLss); } } return(lss); } Debug.Assert(!pt2.Shape.Concrete); foreach (ShapeSymbol ss1 in pt1.CachedSymbols) { foreach (ShapeSymbol ss2 in pt2.CachedSymbols) { var ps1 = ss1 as PointSymbol; Debug.Assert(ps1 != null); Debug.Assert(ps1.Shape.Concrete); var cachePoint1 = ps1.Shape as Point; Debug.Assert(cachePoint1 != null); var ps2 = ss2 as PointSymbol; Debug.Assert(ps2 != null); Debug.Assert(ps2.Shape.Concrete); var cachePoint2 = ps2.Shape as Point; Debug.Assert(cachePoint2 != null); var gLss = LineSegmentGenerationRule.GenerateLineSegment(cachePoint1, cachePoint2); gLss.Traces.AddRange(ps1.Traces); gLss.Traces.AddRange(ps2.Traces); lss.CachedSymbols.Add(gLss); } } return(lss); }
//backward solving private static object InferDistance(this LineSegmentSymbol inputLineSymbol, double value) { return(TraceInstructionalDesign.FromLineSegmentToDistance(inputLineSymbol, value)); }