Example #1
0
        private static object InferIntercept(this LineSymbol inputLineSymbol, string label)
        {
            var line = inputLineSymbol.Shape as Line;

            Debug.Assert(line != null);
            if (line.Intercept != null)
            {
                var goal = new EqGoal(new Var(label), line.Intercept);
                goal.Traces.AddRange(inputLineSymbol.Traces);
                TraceInstructionalDesign.FromLineToIntercept(inputLineSymbol, goal);
                return(goal);
            }

            if (inputLineSymbol.CachedSymbols.Count != 0)
            {
                var goalList = new List <object>();
                foreach (var lss in inputLineSymbol.CachedSymbols)
                {
                    var cachedLss = lss as LineSymbol;
                    Debug.Assert(cachedLss != null);
                    var cachedLs = cachedLss.Shape as Line;
                    Debug.Assert(cachedLs != null);
                    var goal = new EqGoal(new Var(label), cachedLs.Intercept);
                    goal.Traces.AddRange(cachedLss.Traces);
                    TraceInstructionalDesign.FromLineToIntercept(cachedLss, goal);
                    goalList.Add(goal);
                }
                return(goalList);
            }

            return(null);
        }
        //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);
        }
Example #3
0
        //forward solving
        private static EqGoal InferSlope(this LineSymbol inputLineSymbol, string label)
        {
            var line = inputLineSymbol.Shape as Line;

            Debug.Assert(line != null);
            var goal = new EqGoal(new Var(label), line.Slope);

            goal.Traces.AddRange(inputLineSymbol.Traces);
            TraceInstructionalDesign.FromLineToSlope(inputLineSymbol, goal);
            return(goal);
        }
Example #4
0
        /// <summary>
        /// TODO
        /// </summary>
        /// <param name="inputLineSymbol"></param>
        /// <param name="label"></param>
        /// <returns></returns>
        private static LineSymbol InferGeneralForm(this LineSymbol inputLineSymbol, string label)
        {
            var line = inputLineSymbol.Shape as Line;

            Debug.Assert(line != null);
            var ls = new LineSymbol(line);

            ls.OutputType = LineType.GeneralForm;
            ls.Traces.AddRange(inputLineSymbol.Traces);
            TraceInstructionalDesign.FromOneFormToAnother(inputLineSymbol, ls);
            return(ls);
        }
        private static bool ConstraintCheck(GoalNode goalNode1, GoalNode goalNode2,
                                            object constraint, out object output)
        {
            Debug.Assert(constraint != null);
            var st    = constraint as ShapeType?;
            var goal1 = goalNode1.Goal as EqGoal;
            var goal2 = goalNode2.Goal as EqGoal;

            Debug.Assert(goal1 != null);
            Debug.Assert(goal2 != null);
            output = null;
            if (st != null)
            {
                switch (st.Value)
                {
                case ShapeType.Line:
                    output = LineBinaryRelation.Unify(goal1, goal2);
                    break;
                }
                return(output != null);
            }
            var label = constraint as string;

            if (label != null)
            {
                //TODO
                if (LineAcronym.EqualGeneralFormLabels(label))
                {
                    output = LineBinaryRelation.Unify(goal1, goal2);
                    var ls = output as LineSymbol;
                    if (ls != null)
                    {
                        ls.OutputType = LineType.GeneralForm;
                        TraceInstructionalDesign.FromLineSlopeIntercetpToLineGeneralForm(ls);
                        return(true);
                    }
                    return(false);
                }
                if (LineAcronym.EqualSlopeInterceptFormLabels(label))
                {
                    output = LineBinaryRelation.Unify(goal1, goal2);
                    var ls = output as LineSymbol;
                    if (ls != null)
                    {
                        ls.OutputType = LineType.SlopeIntercept;
                        return(true);
                    }
                    return(false);
                }
            }
            return(false);
        }
        public void Problem16()
        {
            var pt1 = new Point(-1, 2);
            var ps1 = new PointSymbol(pt1);

            var pt2 = new Point(5, 8);
            var ps2 = new PointSymbol(pt2);

            var pt3      = new Point(2, 4);
            var midPoint = new PointSymbol(pt3);

            TraceInstructionalDesign.FromPointsToMidPoint(ps1, ps2, midPoint);
        }
Example #7
0
        /// <summary>
        /// ax+by+c=0 =========> y = -(a/b)x-(c/b)
        /// </summary>
        /// <param name="inputLineSymbol"></param>
        /// <param name="label"></param>
        /// <returns></returns>
        private static LineSymbol InferSlopeInterceptForm(this LineSymbol inputLineSymbol)
        {
            //TODO
            var line = inputLineSymbol.Shape as Line;

            Debug.Assert(line != null);
            var ls = new LineSymbol(line);

            ls.OutputType = LineType.SlopeIntercept;
            ls.Traces.AddRange(inputLineSymbol.Traces);
            TraceInstructionalDesign.FromOneFormToAnother(inputLineSymbol, ls);
            return(ls);
        }
        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);
        }
Example #9
0
        /// <summary>
        /// construct a line through a point and a goal,
        /// e.g A(1,2) ^ S = 2=> Conjunctive Norm Form
        /// </summary>
        /// <param name="pt1"></param>
        /// <param name="goal"></param>
        /// <returns></returns>
        public static LineSymbol Unify(PointSymbol pt, EqGoal goal)
        {
            var variable1 = goal.Lhs as Var;

            Debug.Assert(variable1 != null);

            if (LineAcronym.EqualSlopeLabels(variable1.ToString()))
            {
                double dValue;
                bool   result = LogicSharp.IsDouble(goal.Rhs, out dValue);
                if (result)
                {
                    if (!pt.Shape.Concrete)
                    {
                        return(null);
                    }
                    var line = LineGenerationRule.GenerateLine((Point)pt.Shape, dValue, null);
                    if (pt.Traces.Count != 0)
                    {
                        line.Traces.AddRange(pt.Traces);
                    }
                    if (goal.Traces.Count != 0)
                    {
                        line.Traces.AddRange(goal.Traces);
                    }

                    TraceInstructionalDesign.FromPointSlopeToLine(pt, goal, line);

                    line.OutputType = LineType.SlopeIntercept;
                    return(line);
                }
                else
                {
                    var line = new Line(null); //ghost line
                    var ls   = new LineSymbol(line);
                    ls.OutputType = LineType.SlopeIntercept;
                    return(ls);
                }
            }
            return(null);
        }
Example #10
0
        public static object Unify(PointSymbol pt1, PointSymbol pt2, EqGoal goal = null)
        {
            //point identify check
            if (pt1.Equals(pt2))
            {
                return(null);
            }

            //Mid-point build process
            if (pt1.Shape.Concrete && pt2.Shape.Concrete)
            {
                var point1 = pt1.Shape as Point;
                var point2 = pt2.Shape as Point;
                Debug.Assert(point1 != null);
                Debug.Assert(point2 != null);
                var midPoint = PointGenerationRule.GenerateMidPoint(point1, point2);
                TraceInstructionalDesign.FromPointsToMidPoint(pt1, pt2, midPoint);
                return(midPoint);
            }
            return(null);
        }
Example #11
0
        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);
        }
Example #12
0
 //backward solving
 private static object InferSlope(this LineSymbol inputLineSymbol, double value)
 {
     return(TraceInstructionalDesign.FromLineToSlope(inputLineSymbol, value));
 }
Example #13
0
        /// <summary>
        /// construct a line through two points
        /// </summary>
        /// <param name="pt1"></param>
        /// <param name="pt2"></param>
        /// <returns></returns>
        public static object Unify(PointSymbol pt1, PointSymbol pt2, EqGoal goal = null)
        {
            //point identify check
            if (pt1.Equals(pt2))
            {
                return(null);
            }

            //Line build process
            if (pt1.Shape.Concrete && pt2.Shape.Concrete)
            {
                var point1 = pt1.Shape as Point;
                var point2 = pt2.Shape as Point;

                Debug.Assert(point1 != null);
                Debug.Assert(point2 != null);

                var winPt1 = new System.Windows.Point((double)point1.XCoordinate, (double)point1.YCoordinate);
                var winPt2 = new System.Windows.Point((double)point2.XCoordinate, (double)point2.YCoordinate);

                var lineSymbol = LineGenerationRule.GenerateLine(point1, point2);

                if (lineSymbol == null)
                {
                    return(null);
                }

                var line = lineSymbol.Shape as Line;
                Debug.Assert(line != null);

                line.Rel1 = winPt1;
                line.Rel2 = winPt2;

                TraceInstructionalDesign.FromPointPointToLine(pt1, pt2, lineSymbol);
                return(lineSymbol);
            }
            else
            {
                //lazy evaluation
                //Constraint solving on Graph
                var line = new Line(null); //ghost line
                line.Rel1 = pt1.Shape;
                line.Rel2 = pt2.Shape;
                var ls = new LineSymbol(line);

                #region Reification Purpose

                if (pt1.Shape.Concrete && !pt2.Shape.Concrete)
                {
                    var point1 = pt1.Shape as Point;
                    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 gline = LineGenerationRule.GenerateLine(point1, cachePoint);
                            gline.Traces.AddRange(ps.Traces);
                            TraceInstructionalDesign.FromPointPointToLine(pt1, pt2, gline);
                            ls.CachedSymbols.Add(gline);
                        }
                    }
                }

                if (!pt1.Shape.Concrete && pt2.Shape.Concrete)
                {
                    var point2 = pt2.Shape as Point;
                    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 gline = LineGenerationRule.GenerateLine(cachePoint, point2);
                            gline.Traces.AddRange(ps.Traces);
                            TraceInstructionalDesign.FromPointPointToLine(pt1, pt2, gline);
                            ls.CachedSymbols.Add(gline);
                        }
                    }
                }

                if (!pt1.Shape.Concrete && !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 gline = LineGenerationRule.GenerateLine(cachePoint1, cachePoint2);
                            gline.Traces.AddRange(ps1.Traces);
                            gline.Traces.AddRange(ps2.Traces);
                            TraceInstructionalDesign.FromPointPointToLine(pt1, pt2, gline);
                            ls.CachedSymbols.Add(gline);
                        }
                    }
                }

                #endregion

                if (goal != null)
                {
                    return(ls.Unify(goal));
                }

                return(ls);
            }
        }
Example #14
0
        /// <summary>
        /// construct a line through two goals
        /// e.g  m=2, k=3 => conjunctive norm form
        /// </summary>
        /// <param name="goal1"></param>
        /// <param name="goal2"></param>
        /// <returns></returns>
        public static LineSymbol Unify(EqGoal goal1, EqGoal goal2)
        {
            var variable1 = goal1.Lhs as Var;
            var variable2 = goal2.Lhs as Var;

            Debug.Assert(variable1 != null);
            Debug.Assert(variable2 != null);

            var dict = new Dictionary <string, object>();

            string slopeKey     = "slope";
            string interceptKey = "intercept";

            if (LineAcronym.EqualSlopeLabels(variable1.ToString()))
            //if (variable1.ToString().Equals(LineAcronym.Slope1))
            {
                dict.Add(slopeKey, goal1.Rhs);
            }
            if (LineAcronym.EqualInterceptLabels(variable1.ToString()))
            //if (variable1.ToString().Equals(LineAcronym.Intercept1))
            {
                dict.Add(interceptKey, goal1.Rhs);
            }
            if (LineAcronym.EqualSlopeLabels(variable2.ToString()))
            //if (variable2.ToString().Equals(LineAcronym.Slope1))
            {
                if (dict.ContainsKey(slopeKey))
                {
                    return(null);
                }
                dict.Add(slopeKey, goal2.Rhs);
            }
            if (LineAcronym.EqualInterceptLabels(variable2.ToString()))
            //if (variable2.ToString().Equals(LineAcronym.Intercept1))
            {
                if (dict.ContainsKey(interceptKey))
                {
                    return(null);
                }
                dict.Add(interceptKey, goal2.Rhs);
            }

            if (dict.Count == 2 &&
                dict[slopeKey] != null &&
                dict[interceptKey] != null)
            {
                if (LogicSharp.IsNumeric(dict[slopeKey]) &&
                    LogicSharp.IsNumeric(dict[interceptKey]))
                {
                    double dSlope, dIntercept;
                    LogicSharp.IsDouble(dict[slopeKey], out dSlope);
                    LogicSharp.IsDouble(dict[interceptKey], out dIntercept);
                    var line = LineGenerationRule.GenerateLine(dSlope, dIntercept);
                    var ls   = new LineSymbol(line)
                    {
                        OutputType = LineType.SlopeIntercept
                    };

                    TraceInstructionalDesign.FromSlopeInterceptToLineSlopeIntercept(goal1, goal2, ls);
                    return(ls);
                }
                else
                {
                    //lazy evaluation
                    //Constraint solving on Graph
                    var line = new Line(null); //ghost line
                    var ls   = new LineSymbol(line);
                    ls.OutputType = LineType.SlopeIntercept;
                    return(ls);
                }
            }
            return(null);
        }
 //backward solving
 private static object InferDistance(this LineSegmentSymbol inputLineSymbol, double value)
 {
     return(TraceInstructionalDesign.FromLineSegmentToDistance(inputLineSymbol, value));
 }
Example #16
0
        public static bool IsLineEquation(this Equation eq, out LineSymbol ls, bool allowEval = true)
        {
            Debug.Assert(eq != null);
            Debug.Assert(eq.Rhs != null);
            ls = null;

            Line line;

            /* bool matched = SatisfySpecialForm(eq, out line);
             * if (matched)
             * {
             *   ls = new LineSymbol(line);
             *   line.Label = eq.EqLabel;
             *   if (eq.Traces.Count == 1)
             *   {
             *       var strategy = "Generate a line by manipulating algebraic equation.";
             *       var newTrace = new Tuple<object, object>(strategy, eq.Traces[0].Item2);
             *       ls.Traces.Add(newTrace);
             *       //ls.ImportTrace(eq);
             *   }
             *   TraceInstructionalDesign.LineSlopeIntercepToGraph(ls);
             *   return true;
             * }
             *
             * matched = SatisfyLineSlopeInterceptForm(eq, out line);
             * if (matched)
             * {
             *   ls = new LineSymbol(line);
             *   line.Label = eq.EqLabel;
             *   if (eq.Traces.Count == 1)
             *   {
             *       var strategy = "Generate a line by manipulating algebraic equation.";
             *       var newTrace = new Tuple<object, object>(strategy, eq.Traces[0].Item2);
             *       ls.Traces.Add(newTrace);
             *       //ls.ImportTrace(eq);
             *   }
             *   TraceInstructionalDesign.LineSlopeIntercepToGraph(ls);
             *   return true;
             * }*/

/*            if (!allowEval)
 *          {
 *              matched = SatisfyLineGeneralForm(eq, out line);
 *              if (matched)
 *              {
 *                  ls = new LineSymbol(line);
 *                  line.Label = eq.EqLabel;
 *                  return true;
 *              }
 *              matched = SatisfyLineSlopeInterceptForm(eq, out line);
 *              if (matched)
 *              {
 *                  ls = new LineSymbol(line);
 *                  line.Label = eq.EqLabel;
 *                  return true;
 *              }
 *              return false;
 *          }*/

            object obj;
            bool?  result = eq.Eval(out obj, true, true); // without transitive equational rule.

            if (result != null)
            {
                return(false);
            }

            if (eq.CachedEntities.Count != 1)
            {
                return(false);
            }

            var outputEq = eq.CachedEntities.ToList()[0] as Equation;

            if (outputEq == null)
            {
                return(false);
            }

            bool matched = SatisfySpecialForm(outputEq, out line);

            if (matched)
            {
                ls         = new LineSymbol(line);
                line.Label = eq.EqLabel;

                if (outputEq.Traces.Count == 1)
                {
                    var strategy = "Generate a line by manipulating algebraic equation.";
                    var newTrace = new Tuple <object, object>(strategy, outputEq.Traces[0].Item2);
                    ls.Traces.Add(newTrace);
                    //ls.ImportTrace(eq);
                }
                TraceInstructionalDesign.LineSlopeIntercepToGraph(ls);
                return(true);
            }

            //Equation Semantic Unification
            //general     form of line equation ax+by+c=0
            //point-slope form of line equation y = mx + b

            matched = SatisfyLineGeneralForm(outputEq, out line);
            if (matched)
            {
                ls         = new LineSymbol(line);
                line.Label = eq.EqLabel;
                if (outputEq.Traces.Count == 1)
                {
                    var strategy = "Generate a line by manipulating algebraic equation.";
                    var newTrace = new Tuple <object, object>(strategy, outputEq.Traces[0].Item2);
                    ls.Traces.Add(newTrace);
                    //ls.ImportTrace(eq);
                }

                //Instruction Design
                TraceInstructionalDesign.FromLineGeneralFormToSlopeIntercept(ls);
                TraceInstructionalDesign.LineSlopeIntercepToGraph(ls);

                /*  List<Tuple<object, object>> trace = eq.CloneTrace();
                 * ls.Traces.AddRange(trace);
                 * List<Tuple<object, object>> lst = ls.Traces.Intersect(trace).ToList();
                 * if (lst.Count == 0) ls.Traces.AddRange(trace);*/
                return(true);
            }


            matched = SatisfyLineSlopeInterceptForm(outputEq, out line);
            if (matched)
            {
                ls         = new LineSymbol(line);
                line.Label = eq.EqLabel;
                if (outputEq.Traces.Count == 1)
                {
                    var strategy = "Generate a line by manipulating algebraic equation.";
                    var newTrace = new Tuple <object, object>(strategy, outputEq.Traces[0].Item2);
                    ls.Traces.Add(newTrace);
                    //ls.ImportTrace(eq);
                }
                TraceInstructionalDesign.LineSlopeIntercepToGraph(ls);

                /* List<Tuple<object,object>> trace = eq.CloneTrace();
                 * ls = new LineSymbol(line);
                 * line.Label = eq.EqLabel;
                 * ls.Traces.AddRange(trace);
                 * List<Tuple<object, object>> lst = ls.Traces.Intersect(trace).ToList();
                 * if (lst.Count == 0) ls.Traces.AddRange(trace);*/
                return(true);
            }
            eq.ClearTrace();
            //eq.CachedEntities.Clear();

            return(false);
        }