public override bool Equals(Object obj)
{
Complementary supp = obj as Complementary;
if (supp == null)
{
return(false);
}
return(base.Equals(supp));
}
//
// Complementary(Angle(A, B, C), Angle(D, E, F)) -> Angle(A, B, C) + Angle(D, E, F) = 90
//
public static List<EdgeAggregator> InstantiateFromComplementary(Complementary comp)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(comp);
GeometricAngleEquation angEq = new GeometricAngleEquation(new Addition(comp.angle1, comp.angle2), new NumericValue(90));
newGrounded.Add(new EdgeAggregator(antecedent, angEq, annotation));
return newGrounded;
}
//
// We know at this point that we have a right triangle
//
private static List<EdgeAggregator> InstantiateRightTriangle(Triangle tri, GroundedClause original)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
KeyValuePair<Angle, Angle> acuteAngles = tri.GetAcuteAngles();
Complementary newComp = new Complementary(acuteAngles.Key, acuteAngles.Value);
// Hypergraph
List<GroundedClause> antecedent = Utilities.MakeList<GroundedClause>(original);
newGrounded.Add(new EdgeAggregator(antecedent, newComp, annotation));
return newGrounded;
}
private static List<EdgeAggregator> CheckAndGeneratePerpendicularImplyCongruentAdjacent(Perpendicular perp, Angle angle1, Angle angle2)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
if (!Utilities.CompareValues(angle1.measure + angle2.measure, 90)) return newGrounded;
// The perpendicular intersection must occur at the same vertex of both angles (we only need check one).
if (!(angle1.GetVertex().Equals(perp.intersect) && angle2.GetVertex().Equals(perp.intersect))) return newGrounded;
// Are the angles adjacent?
Segment sharedRay = angle1.IsAdjacentTo(angle2);
if (sharedRay == null) return newGrounded;
// Do the non-shared rays for both angles align with the segments defined by the perpendicular intersection?
if (!perp.DefinesBothRays(angle1.OtherRayEquates(sharedRay), angle2.OtherRayEquates(sharedRay))) return newGrounded;
//
// Now we have perpendicular -> complementary angles scenario
//
Complementary cas = new Complementary(angle1, angle2);
// Construct hyperedge
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(perp);
antecedent.Add(angle1);
antecedent.Add(angle2);
newGrounded.Add(new EdgeAggregator(antecedent, cas, annotation));
return newGrounded;
}
private static List<EdgeAggregator> IndirectRelations(CongruentAngles cas, AnglePairRelation relation1, AnglePairRelation relation2)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
// Do we have the same type of relation?
if (relation1.GetType() != relation2.GetType()) return newGrounded;
//
// Determine the shared values amongst the relations
//
Angle shared1 = relation1.AngleShared(cas);
if (shared1 == null) return newGrounded;
Angle shared2 = cas.OtherAngle(shared1);
if (!relation2.HasAngle(shared2)) return newGrounded;
Angle otherAngle1 = relation1.OtherAngle(shared1);
Angle otherAngle2 = relation2.OtherAngle(shared2);
// Avoid generating a reflexive relationship
if (otherAngle1.Equates(otherAngle2)) return newGrounded;
//
// Congruent(Angle(1), Angle(3))
//
// The other two angles from the relation pairs are then congruent
GeometricCongruentAngles gcas = new GeometricCongruentAngles(otherAngle1, otherAngle2);
// Avoid direct cyclic congruent angle generation
if (cas.StructurallyEquals(gcas)) return newGrounded;
// Construct hyperedge
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(cas);
antecedent.Add(relation1);
antecedent.Add(relation2);
//
// AnglePairRelation(Angle(1), Angle(4)),
// AnglePairRelation(Angle(2), Angle(3)),
//
if (relation1 is Complementary && relation2 is Complementary)
{
Complementary comp1 = new Complementary(shared1, otherAngle2);
Complementary comp2 = new Complementary(shared2, otherAngle1);
newGrounded.Add(new EdgeAggregator(antecedent, comp1, compAnnotation));
newGrounded.Add(new EdgeAggregator(antecedent, comp2, compAnnotation));
}
else if (relation1 is Supplementary && relation2 is Supplementary)
{
Supplementary supp1 = new Supplementary(shared1, otherAngle2);
Supplementary supp2 = new Supplementary(shared2, otherAngle1);
newGrounded.Add(new EdgeAggregator(antecedent, supp1, suppAnnotation));
newGrounded.Add(new EdgeAggregator(antecedent, supp2, suppAnnotation));
}
else
{
throw new ArgumentException("RelationsOfCongruent:: Expected a supplementary or complementary angle, not " + relation1.GetType());
}
newGrounded.Add(new EdgeAggregator(antecedent, gcas, relation1 is Complementary ? compAnnotation : suppAnnotation));
return newGrounded;
}
//
// RightAngle(A, B, C), Angle(A, B, X) + Angle(X, B, C) = 90 -> Complementary(Angle(A, B, X), Angle(X, B, C))
//
public static List<EdgeAggregator> InstantiateToComplementary(AngleEquation eq, RightAngle ra, GroundedClause original)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
//
// Acquire the two angles from the equation
//
KeyValuePair<int, int> cards = eq.GetCardinalities();
List<GroundedClause> terms = cards.Key == 2 ? eq.lhs.CollectTerms() : eq.rhs.CollectTerms();
List<GroundedClause> singleton = cards.Key == 1 ? eq.lhs.CollectTerms() : eq.rhs.CollectTerms();
Angle angle1 = terms[0] as Angle;
Angle angle2 = terms[1] as Angle;
// Create the resultant angle to compare to the input right angle
Segment shared = angle1.IsAdjacentTo(angle2);
if (!ra.HasSegment(angle1.OtherRayEquates(shared)) || !ra.HasSegment(angle2.OtherRayEquates(shared))) return newGrounded;
// Success, we have correspondence
Complementary comp = new Complementary(angle1, angle2);
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(original);
newGrounded.Add(new EdgeAggregator(antecedent, comp, annotation));
return newGrounded;
}
