public SegmentRatio GetOtherRatio(SegmentRatio that)
{
// Check for the obvious shared ratio
if (lhs.StructurallyEquals(that)) return this.rhs;
if (rhs.StructurallyEquals(that)) return this.lhs;
return GetOtherImpliedRatio(that);
}
//
// Compare the numeric proportion between the relations
//
public bool ProportionallyEquals(SegmentRatio that)
{
if (this.proportion.Key == -1 && this.proportion.Value == -1)
{
return(Utilities.CompareValues(this.dictatedProportion, that.dictatedProportion));
}
return(this.proportion.Key == that.proportion.Key && this.proportion.Value == that.proportion.Value);
}
public override bool Equals(Object obj)
{
SegmentRatio p = obj as SegmentRatio;
if (p == null)
{
return(false);
}
return(smallerSegment.Equals(p.smallerSegment) && largerSegment.Equals(p.largerSegment) && base.Equals(obj));
}
public override bool StructurallyEquals(Object obj)
{
SegmentRatio p = obj as SegmentRatio;
if (p == null)
{
return(false);
}
return(smallerSegment.StructurallyEquals(p.smallerSegment) && largerSegment.StructurallyEquals(p.largerSegment));
}
//
// Create the three resultant angles from each triangle to create the congruency of angles
//
private static List <GenericInstantiator.EdgeAggregator> GenerateSegmentRatio(SimilarTriangles simTris,
List <Point> orderedTriOnePts,
List <Point> orderedTriTwoPts)
{
segmentAnnotation.active = EngineUIBridge.JustificationSwitch.SIMILARITY;
//
// Cycle through the points creating the angles: ABC - DEF ; BCA - EFD ; CAB - FDE
//
List <SegmentRatio> ratios = new List <SegmentRatio>();
for (int i = 0; i < orderedTriOnePts.Count; i++)
{
Segment cs1 = new Segment(orderedTriOnePts[0], orderedTriOnePts[1]);
Segment cs2 = new Segment(orderedTriTwoPts[0], orderedTriTwoPts[1]);
SegmentRatio ratio = new SegmentRatio(cs1, cs2);
ratios.Add(ratio);
// rotate the lists
Point tmp = orderedTriOnePts.ElementAt(0);
orderedTriOnePts.RemoveAt(0);
orderedTriOnePts.Add(tmp);
tmp = orderedTriTwoPts.ElementAt(0);
orderedTriTwoPts.RemoveAt(0);
orderedTriTwoPts.Add(tmp);
}
//
// Take the ratios and create ratio equations.
//
List <GroundedClause> ratioEqs = new List <GroundedClause>();
for (int i = 0; i < ratios.Count; i++)
{
ratioEqs.Add(new GeometricSegmentRatioEquation(ratios[i], ratios[(i + 1) % ratios.Count]));
}
//
// Construct the new deduced edges: proportional segments.
//
List <GenericInstantiator.EdgeAggregator> newGrounded = new List <GenericInstantiator.EdgeAggregator>();
List <GroundedClause> antecedent = Utilities.MakeList <GroundedClause>(simTris);
foreach (GroundedClause eq in ratioEqs)
{
newGrounded.Add(new GenericInstantiator.EdgeAggregator(antecedent, eq, segmentAnnotation));
}
return(newGrounded);
}
//
// if x / y = z / w and we are checking for x / z OR y / w
//
private bool HasImpliedRatio(SegmentRatio thatRatio)
{
if (thatRatio.HasSegment(lhs.largerSegment) && thatRatio.HasSegment(rhs.largerSegment))
{
return(true);
}
if (thatRatio.HasSegment(lhs.smallerSegment) && thatRatio.HasSegment(rhs.smallerSegment))
{
return(true);
}
return(false);
}
public bool IsDistinctFrom(SegmentRatio thatProp)
{
if (this.smallerSegment.StructurallyEquals(thatProp.smallerSegment))
{
return(false);
}
if (this.largerSegment.StructurallyEquals(thatProp.largerSegment))
{
return(false);
}
return(true);
}
public SegmentRatio GetOtherRatio(SegmentRatio that)
{
// Check for the obvious shared ratio
if (lhs.StructurallyEquals(that))
{
return(this.rhs);
}
if (rhs.StructurallyEquals(that))
{
return(this.lhs);
}
return(GetOtherImpliedRatio(that));
}
private SegmentRatio GetOtherImpliedRatio(SegmentRatio thatRatio)
{
if (thatRatio.HasSegment(lhs.largerSegment) && thatRatio.HasSegment(rhs.largerSegment))
{
return(new SegmentRatio(lhs.smallerSegment, rhs.smallerSegment));
}
if (thatRatio.HasSegment(lhs.smallerSegment) && thatRatio.HasSegment(rhs.smallerSegment))
{
return(new SegmentRatio(lhs.largerSegment, rhs.largerSegment));
}
return(null);
}
//public KeyValuePair<int, int> proportion { get; protected set; }
//public double dictatedProportion { get; protected set; }
public SegmentRatioEquation(SegmentRatio ell, SegmentRatio r) : base()
{
if (!ell.ProportionallyEquals(r))
{
throw new ArgumentException("Ratios of segments are not proportionally equal: " + ell + " " + r);
}
lhs = ell;
rhs = r;
segments = new List <Segment>();
segments.Add(lhs.smallerSegment);
segments.Add(lhs.largerSegment);
segments.Add(rhs.smallerSegment);
segments.Add(rhs.largerSegment);
}
//public KeyValuePair<int, int> proportion { get; protected set; }
//public double dictatedProportion { get; protected set; }
public SegmentRatioEquation(SegmentRatio ell, SegmentRatio r)
: base()
{
if (!ell.ProportionallyEquals(r))
{
throw new ArgumentException("Ratios of segments are not proportionally equal: " + ell + " " + r);
}
lhs = ell;
rhs = r;
segments = new List<Segment>();
segments.Add(lhs.smallerSegment);
segments.Add(lhs.largerSegment);
segments.Add(rhs.smallerSegment);
segments.Add(rhs.largerSegment);
}
public static List <GenericInstantiator.EdgeAggregator> InstantiateEquation(GroundedClause clause)
{
List <GenericInstantiator.EdgeAggregator> newGrounded = new List <GenericInstantiator.EdgeAggregator>();
if (!(clause is SegmentEquation))
{
return(newGrounded);
}
Equation original = clause as Equation;
Equation copyEq = (Equation)original.DeepCopy();
FlatEquation flattened = new FlatEquation(copyEq.lhs.CollectTerms(), copyEq.rhs.CollectTerms());
if (flattened.lhsExps.Count != 1 || flattened.rhsExps.Count != 1)
{
return(newGrounded);
}
KeyValuePair <int, int> ratio = Utilities.RationalRatio(flattened.lhsExps[0].multiplier, flattened.rhsExps[0].multiplier);
if (ratio.Key != -1)
{
if (ratio.Key <= 2 && ratio.Value <= 2)
{
SegmentRatio prop = new SegmentRatio((Segment)flattened.lhsExps[0].DeepCopy(),
(Segment)flattened.rhsExps[0].DeepCopy());
prop.MakeProportionValueKnown();
List <GroundedClause> antecedent = Utilities.MakeList <GroundedClause>(original);
newGrounded.Add(new GenericInstantiator.EdgeAggregator(antecedent, prop, atomAnnotation));
}
}
return(newGrounded);
}
//
// Compare the numeric proportion between the relations
//
public bool ProportionallyEquals(SegmentRatio that)
{
if (this.proportion.Key == -1 && this.proportion.Value == -1)
{
return Utilities.CompareValues(this.dictatedProportion, that.dictatedProportion);
}
return this.proportion.Key == that.proportion.Key && this.proportion.Value == that.proportion.Value;
}
public bool IsDistinctFrom(SegmentRatio thatProp)
{
if (this.smallerSegment.StructurallyEquals(thatProp.smallerSegment)) return false;
if (this.largerSegment.StructurallyEquals(thatProp.largerSegment)) return false;
return true;
}
public static List<GenericInstantiator.EdgeAggregator> InstantiateEquation(GroundedClause clause)
{
List<GenericInstantiator.EdgeAggregator> newGrounded = new List<GenericInstantiator.EdgeAggregator>();
if (!(clause is SegmentEquation)) return newGrounded;
Equation original = clause as Equation;
Equation copyEq = (Equation)original.DeepCopy();
FlatEquation flattened = new FlatEquation(copyEq.lhs.CollectTerms(), copyEq.rhs.CollectTerms());
if (flattened.lhsExps.Count != 1 || flattened.rhsExps.Count != 1) return newGrounded;
KeyValuePair<int, int> ratio = Utilities.RationalRatio(flattened.lhsExps[0].multiplier, flattened.rhsExps[0].multiplier);
if (ratio.Key != -1)
{
if (ratio.Key <= 2 && ratio.Value <= 2)
{
SegmentRatio prop = new SegmentRatio((Segment)flattened.lhsExps[0].DeepCopy(),
(Segment)flattened.rhsExps[0].DeepCopy());
prop.MakeProportionValueKnown();
List<GroundedClause> antecedent = Utilities.MakeList<GroundedClause>(original);
newGrounded.Add(new GenericInstantiator.EdgeAggregator(antecedent, prop, atomAnnotation));
}
}
return newGrounded;
}
public GeometricSegmentRatioEquation(SegmentRatio r1, SegmentRatio r2)
: base(r1, r2)
{
}
//
// Create the three resultant angles from each triangle to create the congruency of angles
//
private static List<GenericInstantiator.EdgeAggregator> GenerateSegmentRatio(SimilarTriangles simTris,
List<Point> orderedTriOnePts,
List<Point> orderedTriTwoPts)
{
segmentAnnotation.active = EngineUIBridge.JustificationSwitch.SIMILARITY;
//
// Cycle through the points creating the angles: ABC - DEF ; BCA - EFD ; CAB - FDE
//
List<SegmentRatio> ratios = new List<SegmentRatio>();
for (int i = 0; i < orderedTriOnePts.Count; i++)
{
Segment cs1 = new Segment(orderedTriOnePts[0], orderedTriOnePts[1]);
Segment cs2 = new Segment(orderedTriTwoPts[0], orderedTriTwoPts[1]);
SegmentRatio ratio = new SegmentRatio(cs1, cs2);
ratios.Add(ratio);
// rotate the lists
Point tmp = orderedTriOnePts.ElementAt(0);
orderedTriOnePts.RemoveAt(0);
orderedTriOnePts.Add(tmp);
tmp = orderedTriTwoPts.ElementAt(0);
orderedTriTwoPts.RemoveAt(0);
orderedTriTwoPts.Add(tmp);
}
//
// Take the ratios and create ratio equations.
//
List<GroundedClause> ratioEqs = new List<GroundedClause>();
for (int i = 0; i < ratios.Count; i++)
{
ratioEqs.Add(new GeometricSegmentRatioEquation(ratios[i], ratios[(i + 1) % ratios.Count]));
}
//
// Construct the new deduced edges: proportional segments.
//
List<GenericInstantiator.EdgeAggregator> newGrounded = new List<GenericInstantiator.EdgeAggregator>();
List<GroundedClause> antecedent = Utilities.MakeList<GroundedClause>(simTris);
foreach (GroundedClause eq in ratioEqs)
{
newGrounded.Add(new GenericInstantiator.EdgeAggregator(antecedent, eq, segmentAnnotation));
}
return newGrounded;
}
//
//
//
private static List<EdgeAggregator> IfCongruencesApplyToTrianglesGenerate(Triangle ct1, Triangle ct2, CongruentSegments css1, CongruentSegments css2)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
//
// The congruent relationships need to link the given triangles
//
if (!css1.LinksTriangles(ct1, ct2)) return newGrounded;
if (!css2.LinksTriangles(ct1, ct2)) return newGrounded;
Segment seg1Tri1 = ct1.GetSegment(css1);
Segment seg2Tri1 = ct1.GetSegment(css2);
Segment seg1Tri2 = ct2.GetSegment(css1);
Segment seg2Tri2 = ct2.GetSegment(css2);
// Avoid redundant segments, if it arises
if (seg1Tri1.StructurallyEquals(seg2Tri1)) return newGrounded;
if (seg1Tri2.StructurallyEquals(seg2Tri2)) return newGrounded;
//
// Proportional Segments (we generate only as needed to avoid bloat in the hypergraph (assuming they are used by both triangles)
// We avoid generating proportions if they are truly congruences.
//
List<GroundedClause> propAntecedent = new List<GroundedClause>();
propAntecedent.Add(css1);
propAntecedent.Add(css2);
SegmentRatio ratio1 = new SegmentRatio(seg1Tri1, seg1Tri2);
SegmentRatio ratio2 = new SegmentRatio(seg2Tri1, seg2Tri2);
GeometricSegmentRatioEquation newEq = new GeometricSegmentRatioEquation(ratio1, ratio2);
newGrounded.Add(new EdgeAggregator(propAntecedent, newEq, annotation));
////
//// Only generate if ratios are not 1.
////
//GeometricSegmentRatio newProp = null;
//if (!Utilities.CompareValues(seg1Tri1.Length, seg1Tri2.Length))
//{
// newProp = new GeometricSegmentRatio(seg1Tri1, seg1Tri2);
// newGrounded.Add(new EdgeAggregator(propAntecedent, newProp, annotation));
//}
//if (!Utilities.CompareValues(seg1Tri1.Length, seg2Tri2.Length))
//{
// newProp = new GeometricSegmentRatio(seg1Tri1, seg2Tri2);
// newGrounded.Add(new EdgeAggregator(propAntecedent, newProp, annotation));
//}
//if (!Utilities.CompareValues(seg2Tri1.Length, seg1Tri2.Length))
//{
// newProp = new GeometricSegmentRatio(seg2Tri1, seg1Tri2);
// newGrounded.Add(new EdgeAggregator(propAntecedent, newProp, annotation));
//}
//if (!Utilities.CompareValues(seg2Tri1.Length, seg2Tri2.Length))
//{
// newProp = new GeometricSegmentRatio(seg2Tri1, seg2Tri2);
// newGrounded.Add(new EdgeAggregator(propAntecedent, newProp, annotation));
//}
return newGrounded;
}
private static List<EdgeAggregator> CheckAndGenerateProportionality(Triangle tri, Intersection inter1,
Intersection inter2, Parallel parallel)
{
List<EdgeAggregator> newGrounded = new List<EdgeAggregator>();
// The two intersections should not be at the same vertex
if (inter1.intersect.Equals(inter2.intersect)) return newGrounded;
//
// Do these intersections share a segment? That is, do they share the transversal?
//
Segment transversal = inter1.AcquireTransversal(inter2);
if (transversal == null) return newGrounded;
//
// Is the transversal a side of the triangle? It should not be.
//
if (tri.LiesOn(transversal)) return newGrounded;
//
// Determine if one parallel segment is a side of the triangle (which must occur)
//
Segment coinciding = tri.DoesParallelCoincideWith(parallel);
if (coinciding == null) return newGrounded;
// The transversal and common segment must be distinct
if (coinciding.IsCollinearWith(transversal)) return newGrounded;
//
// Determine if the simplified transversal is within the parallel relationship.
//
Segment parallelTransversal = parallel.OtherSegment(coinciding);
Segment simpleParallelTransversal = new Segment(inter1.intersect, inter2.intersect);
if (!parallelTransversal.IsCollinearWith(simpleParallelTransversal)) return newGrounded;
// A
// /\
// / \
// / \
// off1 /------\ off2
// / \
// B /__________\ C
//
// Both intersections should create a T-shape.
//
Point off1 = inter1.CreatesTShape();
Point off2 = inter2.CreatesTShape();
if (off1 == null || off2 == null) return newGrounded;
// Get the intersection segments which should coincide with the triangle sides
KeyValuePair<Segment, Segment> otherSides = tri.OtherSides(coinciding);
// The intersections may be outside this triangle
if (otherSides.Key == null || otherSides.Value == null) return newGrounded;
Segment side1 = inter1.OtherSegment(transversal);
Segment side2 = inter2.OtherSegment(transversal);
// Get the actual sides of the triangle
Segment triangleSide1 = null;
Segment triangleSide2 = null;
if (side1.IsCollinearWith(otherSides.Key) && side2.IsCollinearWith(otherSides.Value))
{
triangleSide1 = otherSides.Key;
triangleSide2 = otherSides.Value;
}
else if (side1.IsCollinearWith(otherSides.Value) && side2.IsCollinearWith(otherSides.Key))
{
triangleSide1 = otherSides.Value;
triangleSide2 = otherSides.Key;
}
else return newGrounded;
// Verify the opposing parts of the T are on the opposite sides of the triangle
if (!triangleSide1.PointLiesOnAndExactlyBetweenEndpoints(off2)) return newGrounded;
if (!triangleSide2.PointLiesOnAndExactlyBetweenEndpoints(off1)) return newGrounded;
//
// Construct the new proprtional relationship and resultant equation
//
Point sharedVertex = triangleSide1.SharedVertex(triangleSide2);
SegmentRatio newProp1 = new SegmentRatio(new Segment(sharedVertex, off2), triangleSide1);
SegmentRatio newProp2 = new SegmentRatio(new Segment(sharedVertex, off1), triangleSide2);
GeometricSegmentRatioEquation newEq = new GeometricSegmentRatioEquation(newProp1, newProp2);
// Construct hyperedge
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(tri);
antecedent.Add(inter1);
antecedent.Add(inter2);
antecedent.Add(parallel);
newGrounded.Add(new EdgeAggregator(antecedent, newEq, annotation));
return newGrounded;
}
public GeometricSegmentRatioEquation(SegmentRatio r1, SegmentRatio r2) : base(r1, r2)
{
}
public static List<GenericInstantiator.EdgeAggregator> CreateProportionEquation(SegmentRatio ratio1, SegmentRatio ratio2)
{
List<GenericInstantiator.EdgeAggregator> newGrounded = new List<GenericInstantiator.EdgeAggregator>();
// Double-Check that the ratios are, in-fact, known.
if (!ratio1.ProportionValueKnown() || !ratio2.ProportionValueKnown()) return newGrounded;
//
// Create the antecedent clauses
//
List<GroundedClause> antecedent = new List<GroundedClause>();
antecedent.Add(ratio1);
antecedent.Add(ratio2);
// Create the consequent proportionality equation.
GeometricSegmentRatioEquation gsreq = new GeometricSegmentRatioEquation(ratio1, ratio2);
newGrounded.Add(new GenericInstantiator.EdgeAggregator(antecedent, gsreq, propAnnotation));
return newGrounded;
}
public AlgebraicSegmentRatioEquation(SegmentRatio r1, SegmentRatio r2)
: base(r1, r2)
{
}
public static List <GenericInstantiator.EdgeAggregator> CreateProportionEquation(SegmentRatio ratio1, SegmentRatio ratio2)
{
List <GenericInstantiator.EdgeAggregator> newGrounded = new List <GenericInstantiator.EdgeAggregator>();
// Double-Check that the ratios are, in-fact, known.
if (!ratio1.ProportionValueKnown() || !ratio2.ProportionValueKnown())
{
return(newGrounded);
}
//
// Create the antecedent clauses
//
List <GroundedClause> antecedent = new List <GroundedClause>();
antecedent.Add(ratio1);
antecedent.Add(ratio2);
// Create the consequent proportionality equation.
GeometricSegmentRatioEquation gsreq = new GeometricSegmentRatioEquation(ratio1, ratio2);
newGrounded.Add(new GenericInstantiator.EdgeAggregator(antecedent, gsreq, propAnnotation));
return(newGrounded);
}
public AlgebraicSegmentRatioEquation(SegmentRatio r1, SegmentRatio r2) : base(r1, r2)
{
}
private SegmentRatio GetOtherImpliedRatio(SegmentRatio thatRatio)
{
if (thatRatio.HasSegment(lhs.largerSegment) && thatRatio.HasSegment(rhs.largerSegment))
{
return new SegmentRatio(lhs.smallerSegment, rhs.smallerSegment);
}
if (thatRatio.HasSegment(lhs.smallerSegment) && thatRatio.HasSegment(rhs.smallerSegment))
{
return new SegmentRatio(lhs.largerSegment, rhs.largerSegment);
}
return null;
}
// Of the propportional pair, return the segment that applies to this triangle
public Segment GetSegment(SegmentRatio prop)
{
if (HasSegment(prop.smallerSegment)) return prop.smallerSegment;
if (HasSegment(prop.largerSegment)) return prop.largerSegment;
return null;
}
//
// if x / y = z / w and we are checking for x / z OR y / w
//
private bool HasImpliedRatio(SegmentRatio thatRatio)
{
if (thatRatio.HasSegment(lhs.largerSegment) && thatRatio.HasSegment(rhs.largerSegment)) return true;
if (thatRatio.HasSegment(lhs.smallerSegment) && thatRatio.HasSegment(rhs.smallerSegment)) return true;
return false;
}
