private IAnswer ProcessChildAnswers(IQuestionProcessingContext <ComparisonQuestion> context, ICollection <ChildAnswer> childAnswers)
{
foreach (var answer in childAnswers)
{
var childStatement = (answer.Answer as StatementAnswer)?.Result as ComparisonStatement;
if (childStatement != null)
{
var transitiveStatement = (ComparisonStatement)answer.TransitiveStatements.Single();
var intermediateValue = new[] { childStatement.LeftValue, childStatement.RightValue }.Intersect(new[] { transitiveStatement.LeftValue, transitiveStatement.RightValue }).Single();
if ((childStatement.LeftValue == intermediateValue) == (transitiveStatement.LeftValue == intermediateValue))
{
transitiveStatement = transitiveStatement.SwapOperands();
}
var resultSign = ComparisonSigns.CompareThreeValues(childStatement.ComparisonSign, transitiveStatement.ComparisonSign);
if (resultSign != null)
{
var transitiveStatements = new List <IStatement>(answer.TransitiveStatements);
transitiveStatements.AddRange(answer.Answer.Explanation.Statements);
return(createAnswer(
new ComparisonStatement(null, LeftValue, RightValue, resultSign),
context,
transitiveStatements));
}
}
}
return(Answer.CreateUnknown());
}
public void DoubleReversionDoNothing()
{
foreach (var sign in ComparisonSigns.All)
{
Assert.AreSame(sign, ComparisonSigns.Revert(ComparisonSigns.Revert(sign)));
}
}
protected override Boolean SetCombinationWithDescendants(IConcept valueRow, IConcept valueColumn, IConcept sign)
{
Boolean combinationsUpdated = SetCombination(valueRow, valueColumn, sign);
if (sign.CanBeReverted())
{
combinationsUpdated |= SetCombination(valueColumn, valueRow, ComparisonSigns.Revert(sign));
}
return(combinationsUpdated);
}
public void CheckConditionsWithLeAndGe()
{
// arrange
var language = Language.Default;
var semanticNetwork = new TestSemanticNetwork(language);
var comparisons = new[]
{
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number1or2, semanticNetwork.Number0, ComparisonSigns.IsGreaterThan),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number1or2, semanticNetwork.Number1, ComparisonSigns.IsGreaterThanOrEqualTo),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number1or2, semanticNetwork.Number2, ComparisonSigns.IsLessThanOrEqualTo),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number1or2, semanticNetwork.Number3, ComparisonSigns.IsLessThan),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number1or2, semanticNetwork.Number4, ComparisonSigns.IsLessThan),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number1or2, semanticNetwork.Number2or3, ComparisonSigns.IsLessThanOrEqualTo),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number1or2, semanticNetwork.Number3or4, ComparisonSigns.IsLessThan),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number2or3, semanticNetwork.Number0, ComparisonSigns.IsGreaterThan),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number2or3, semanticNetwork.Number1, ComparisonSigns.IsGreaterThan),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number2or3, semanticNetwork.Number2, ComparisonSigns.IsGreaterThanOrEqualTo),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number2or3, semanticNetwork.Number3, ComparisonSigns.IsLessThanOrEqualTo),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number2or3, semanticNetwork.Number4, ComparisonSigns.IsLessThan),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number2or3, semanticNetwork.Number1or2, ComparisonSigns.IsGreaterThanOrEqualTo),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number2or3, semanticNetwork.Number3or4, ComparisonSigns.IsLessThanOrEqualTo),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number3or4, semanticNetwork.Number0, ComparisonSigns.IsGreaterThan),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number3or4, semanticNetwork.Number1, ComparisonSigns.IsGreaterThan),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number3or4, semanticNetwork.Number2, ComparisonSigns.IsGreaterThan),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number3or4, semanticNetwork.Number3, ComparisonSigns.IsGreaterThanOrEqualTo),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number3or4, semanticNetwork.Number4, ComparisonSigns.IsLessThanOrEqualTo),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number3or4, semanticNetwork.Number1or2, ComparisonSigns.IsGreaterThan),
new Tuple <IConcept, IConcept, IConcept>(semanticNetwork.Number3or4, semanticNetwork.Number2or3, ComparisonSigns.IsGreaterThanOrEqualTo),
};
foreach (var comparison in comparisons)
{
// act
var answer1 = semanticNetwork.SemanticNetwork.Ask().HowCompared(comparison.Item1, comparison.Item2);
var statement1 = (ComparisonStatement)((StatementAnswer)answer1).Result;
var answer2 = semanticNetwork.SemanticNetwork.Ask().HowCompared(comparison.Item2, comparison.Item1);
var statement2 = (ComparisonStatement)((StatementAnswer)answer2).Result;
// assert
Assert.AreSame(comparison.Item1, statement1.LeftValue);
Assert.AreSame(comparison.Item2, statement1.RightValue);
Assert.AreSame(comparison.Item3, statement1.ComparisonSign);
Assert.AreSame(comparison.Item2, statement2.LeftValue);
Assert.AreSame(comparison.Item1, statement2.RightValue);
Assert.AreSame(ComparisonSigns.Revert(comparison.Item3), statement2.ComparisonSign);
}
}
public void OnlyComparisonSignsSuit()
{
foreach (var concept in SystemConcepts.GetAll())
{
if (!ComparisonSigns.All.Contains(concept))
{
Assert.Throws <InvalidOperationException>(() => { concept.Contradicts(ComparisonSigns.IsEqualTo); });
Assert.Throws <InvalidOperationException>(() => { ComparisonSigns.IsEqualTo.Contradicts(concept); });
Assert.Throws <InvalidOperationException>(() => { ComparisonSigns.Revert(concept); });
Assert.Throws <InvalidOperationException>(() => { concept.CanBeReverted(); });
Assert.Throws <InvalidOperationException>(() => { ComparisonSigns.CompareThreeValues(concept, ComparisonSigns.IsEqualTo); });
Assert.Throws <InvalidOperationException>(() => { ComparisonSigns.CompareThreeValues(ComparisonSigns.IsEqualTo, concept); });
}
}
}
public ComparisonStatement SwapOperands()
{
return(new ComparisonStatement(null, leftValue: RightValue, rightValue: LeftValue, comparisonSign: ComparisonSigns.Revert(ComparisonSign)));
}
protected float GetDirection(float compared1 = float.NaN, float compared2 = float.NaN, bool reverse = false, ComparisonSigns comparisonSign = ComparisonSigns.Equals)
{
float mod = reverse ? -1f : 1f;
if (float.IsNaN(compared1))
{
compared1 = transform.eulerAngles.y;
}
if (float.IsNaN(compared2))
{
compared2 = 0;
}
switch (comparisonSign)
{
case ComparisonSigns.More: return(compared1 > compared2 ? 1 * mod : -1 * mod);
case ComparisonSigns.MoreAndEquals: return(compared1 >= compared2 ? 1 * mod : -1 * mod);
default: return(compared1 == compared2 ? 1 * mod : -1 * mod);
}
}
protected void LookAt(float target, float compared = float.NaN, bool reverse = false, ComparisonSigns comparisonSign = ComparisonSigns.MoreAndEquals)
{
(Vector2 answer1, Vector2 answer2) = reverse ? (Vector2.zero, Vector2.up * 180f) : (Vector2.up * 180f, Vector2.zero);
if (float.IsNaN(compared))
{
compared = transform.position.x;
}
switch (comparisonSign)
{
case ComparisonSigns.Equals: transform.eulerAngles = compared == target ? answer1 : answer2; break;
case ComparisonSigns.More: transform.eulerAngles = compared > target ? answer1 : answer2; break;
default: transform.eulerAngles = compared >= target ? answer1 : answer2; break;
}
}
protected override Boolean TryToUpdateCombinations(IConcept valueRow, IConcept signRow, IConcept signColumn, IConcept valueColumn)
{
var resultSign = ComparisonSigns.CompareThreeValues(signRow, signColumn);
return(resultSign != null && SetCombinationWithDescendants(valueRow, valueColumn, resultSign));
}
