public override bool Equals(Object obj)
{
SegmentEquation eq = obj as SegmentEquation;
if (eq == null)
{
return(false);
}
return(base.Equals(obj));
}
private static bool HandleSimpleSegmentEquation(KnownMeasurementsAggregator known, SegmentEquation theEq)
{
if (theEq.GetAtomicity() != Equation.BOTH_ATOMIC) return false;
Segment unknownSegment = null;
double segmentValue = -1;
if (theEq.lhs is NumericValue)
{
unknownSegment = theEq.rhs as Segment;
segmentValue = (theEq.lhs as NumericValue).DoubleValue;
}
else if (theEq.rhs is NumericValue)
{
unknownSegment = theEq.lhs as Segment;
segmentValue = (theEq.rhs as NumericValue).DoubleValue;
}
else return false;
//
// (7) Add to the list of knowns
//
return known.AddSegmentLength(unknownSegment, segmentValue);
}
//
// (1) Make a copy
// (2) Collect the equation terms.
// (3) Are all but one known?
// (4) Substitute
// (5) Simplify
// (6) Acquire the unknown and its value.
// (7) Add to the list of knowns.
//
private static bool HandleSegmentEquation(KnownMeasurementsAggregator known, List<GroundedClause> clauses, SegmentEquation theEq)
{
if (theEq.GetAtomicity() == Equation.BOTH_ATOMIC) return HandleSimpleSegmentEquation(known, theEq);
// CTA: Verify this calls the correct Equation deep copy mechanism.
// (1) Make a copy
SegmentEquation copy = (SegmentEquation)theEq.DeepCopy();
// (2) Collect the equation terms.
List<GroundedClause> left = copy.lhs.CollectTerms();
double[] leftVal = new double[left.Count];
List<GroundedClause> right = copy.rhs.CollectTerms();
double[] rightVal = new double[right.Count];
// (3) Are all but one term known?
int unknownCount = 0;
for (int ell = 0; ell < left.Count; ell++)
{
if (left[ell] is NumericValue) leftVal[ell] = (left[ell] as NumericValue).DoubleValue;
else
{
leftVal[ell] = known.GetSegmentLength(left[ell] as Segment);
if (leftVal[ell] <= 0) unknownCount++;
}
}
for (int r = 0; r < right.Count; r++)
{
if (right[r] is NumericValue) rightVal[r] = (right[r] as NumericValue).DoubleValue;
else
{
rightVal[r] = known.GetSegmentLength(right[r] as Segment);
if (rightVal[r] <= 0) unknownCount++;
}
}
// We can't solve for more or less than one unknown.
if (unknownCount != 1) return false;
//
// (4) Substitute
//
for (int ell = 0; ell < left.Count; ell++)
{
if (leftVal[ell] > 0) copy.Substitute(left[ell], new NumericValue(leftVal[ell]));
}
for (int r = 0; r < right.Count; r++)
{
if (rightVal[r] > 0) copy.Substitute(right[r], new NumericValue(rightVal[r]));
}
//
// (5) Simplify
//
SegmentEquation simplified = (SegmentEquation)GenericInstantiator.Simplification.Simplify(copy);
return HandleSimpleSegmentEquation(known, simplified);
}
