示例#1
0
        public override bool Equals(Object clause)
        {
            CongruentArcs cts = clause as CongruentArcs;

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

            return(this.ca1.Equals(cts.ca1) || this.ca2.Equals(cts.ca2) ||
                   this.ca2.Equals(cts.ca1) || this.ca1.Equals(cts.ca2));
        }
        //               A
        //              /)
        //             /  )
        //            /    )
        // center:   O      )
        //            \    )
        //             \  )
        //              \)
        //               C
        //
        //               D
        //              /)
        //             /  )
        //            /    )
        // center:   Q      )
        //            \    )
        //             \  )
        //              \)
        //               F
        //
        // Congruent(Arc(A, C), Arc(D, F)) -> Congruent(Segment(AC), Segment(DF))
        //
        private static List<EdgeAggregator> InstantiateConversePartOfTheorem(CongruentArcs cas)
        {
            List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();

            //
            // Acquire the chords for this specific pair of arcs (endpoints of arc and segment are the same).
            //
            Segment chord1 = Segment.GetFigureSegment(cas.ca1.endpoint1, cas.ca1.endpoint2);
            Segment chord2 = Segment.GetFigureSegment(cas.ca2.endpoint1, cas.ca2.endpoint2);

            if (chord1 == null || chord2 == null) return newGrounded;

            // Construct the congruence
            GeometricCongruentSegments gcss = new GeometricCongruentSegments(chord1, chord2);

            // For hypergraph
            List<GroundedClause> antecedent = new List<GroundedClause>();
            antecedent.Add(chord1);
            antecedent.Add(chord2);
            antecedent.Add(cas);

            newGrounded.Add(new EdgeAggregator(antecedent, gcss, forwardAnnotation));

            return newGrounded;
        }
        //               A
        //              /)
        //             /  )
        //            /    )
        // center:   O      )
        //            \    )
        //             \  )
        //              \)
        //               C
        //
        //               D
        //              /)
        //             /  )
        //            /    )
        // center:   Q      )
        //            \    )
        //             \  )
        //              \)
        //               F
        //
        // Congruent(Arc(A, C), Arc(D, F)) -> Congruent(Angle(AOC), Angle(DQF))
        //
        private static List<EdgeAggregator> InstantiateConversePartOfTheorem(CongruentArcs cas)
        {
            List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();

            //
            // Get the radii (and determine if the exist in the figure)
            //
            Segment radius11;
            Segment radius12;
            cas.ca1.GetRadii(out radius11, out radius12);

            if (radius11 == null || radius12 == null) return newGrounded;

            Segment radius21;
            Segment radius22;
            cas.ca2.GetRadii(out radius21, out radius22);

            if (radius21 == null || radius22 == null) return newGrounded;

            //
            // Acquire the central angles from the respoitory
            //
            Angle central1 = Angle.AcquireFigureAngle(new Angle(radius11, radius12));
            Angle central2 = Angle.AcquireFigureAngle(new Angle(radius21, radius22));

            if (central1 == null || central2 == null) return newGrounded;

            GeometricCongruentAngles gcas = new GeometricCongruentAngles(central1, central2);

            // For hypergraph
            List<GroundedClause> antecedent = new List<GroundedClause>();
            antecedent.Add(central1);
            antecedent.Add(central2);
            antecedent.Add(cas);

            newGrounded.Add(new EdgeAggregator(antecedent, gcas, converseAnnotation));

            return newGrounded;
        }