public void DoubleReversionDoNothing() { foreach (var sign in SequenceSigns.All) { Assert.AreSame(sign, SequenceSigns.Revert(SequenceSigns.Revert(sign))); } }
protected override Boolean SetCombinationWithDescendants(IConcept valueRow, IConcept valueColumn, IConcept sign) { Boolean combinationsUpdated = SetCombination(valueRow, valueColumn, sign); combinationsUpdated |= SetCombination(valueColumn, valueRow, SequenceSigns.Revert(sign)); foreach (var consequentSign in sign.Consequently()) { combinationsUpdated |= SetCombination(valueRow, valueColumn, consequentSign); } return(combinationsUpdated); }
public void CheckAllValidCombinations(IConcept signAI, IConcept signIB, IConcept resultSign) { // arrange var language = Language.Default; var semanticNetwork = new SemanticNetwork(language); IConcept processA, processB, processI; semanticNetwork.Concepts.Add(processA = createProcess("Process A")); semanticNetwork.Concepts.Add(processB = createProcess("Process B")); semanticNetwork.Concepts.Add(processI = createProcess("Process I")); var statementAI = new ProcessesStatement(null, processA, processI, signAI); var statementIA = new ProcessesStatement(null, processI, processA, SequenceSigns.Revert(signAI)); var statementIB = new ProcessesStatement(null, processI, processB, signIB); var statementBI = new ProcessesStatement(null, processB, processI, SequenceSigns.Revert(signIB)); foreach (var statementCombination in new[] { new Tuple <IStatement, IStatement>(statementAI, statementIB), new Tuple <IStatement, IStatement>(statementAI, statementBI), new Tuple <IStatement, IStatement>(statementIA, statementIB), new Tuple <IStatement, IStatement>(statementIA, statementBI), }) { try { semanticNetwork.Statements.Add(statementCombination.Item1); semanticNetwork.Statements.Add(statementCombination.Item2); // act var answer = semanticNetwork.Ask().WhatIsMutualSequenceOfProcesses(processA, processB); // assert Assert.IsFalse(answer.IsEmpty); var processesAnswer = (StatementsAnswer <ProcessesStatement>)answer; Assert.Greater(processesAnswer.Result.Count, 0); Assert.IsTrue(processesAnswer.Result.All(s => s.ProcessA == processA)); Assert.IsTrue(processesAnswer.Result.All(s => s.ProcessB == processB)); Assert.IsTrue(processesAnswer.Result.Any(s => s.SequenceSign == resultSign)); Assert.IsTrue(answer.Explanation.Statements.Contains(statementCombination.Item1)); Assert.IsTrue(answer.Explanation.Statements.Contains(statementCombination.Item2)); } finally { semanticNetwork.Statements.Remove(statementCombination.Item1); semanticNetwork.Statements.Remove(statementCombination.Item2); } } }
public void OnlySequenceSignsSuit() { foreach (var concept in SystemConcepts.GetAll()) { if (!SequenceSigns.All.Contains(concept)) { Assert.Throws <InvalidOperationException>(() => { concept.Contradicts(SequenceSigns.SimultaneousWith); }); Assert.Throws <InvalidOperationException>(() => { SequenceSigns.SimultaneousWith.Contradicts(concept); }); Assert.Throws <InvalidOperationException>(() => { SequenceSigns.Revert(concept); }); Assert.Throws <InvalidOperationException>(() => { SequenceSigns.TryToCombineMutualSequences(concept, SequenceSigns.SimultaneousWith); }); Assert.Throws <InvalidOperationException>(() => { SequenceSigns.TryToCombineMutualSequences(SequenceSigns.SimultaneousWith, concept); }); } } }
private IAnswer ProcessChildAnswers(IQuestionProcessingContext <ProcessesQuestion> context, ICollection <ChildAnswer> childAnswers) { foreach (var answer in childAnswers) { var childStatements = (answer.Answer as StatementsAnswer <ProcessesStatement>)?.Result ?? Array.Empty <ProcessesStatement>(); var resultStatements = new List <ProcessesStatement>(); var transitiveStatements = answer.TransitiveStatements.OfType <ProcessesStatement>().ToList(); var firstChild = childStatements.First(); var firstTransitive = transitiveStatements.First(); var intermediateValue = new[] { firstChild.ProcessA, firstChild.ProcessB }.Intersect(new[] { firstTransitive.ProcessA, firstTransitive.ProcessB }).Single(); for (int i = 0; i < transitiveStatements.Count; i++) { if ((firstChild.ProcessA == intermediateValue) == (transitiveStatements[i].ProcessA == intermediateValue)) { transitiveStatements[i] = transitiveStatements[i].SwapOperands(); } } foreach (var childStatement in childStatements) { foreach (var transitiveStatement in transitiveStatements) { var sign = SequenceSigns.TryToCombineMutualSequences(transitiveStatement.SequenceSign, childStatement.SequenceSign); if (sign != null) { resultStatements.Add(new ProcessesStatement(null, ProcessA, ProcessB, sign)); } } } if (resultStatements.Count > 0) { var resultTransitiveStatements = new List <IStatement>(answer.TransitiveStatements); resultTransitiveStatements.AddRange(answer.Answer.Explanation.Statements); return(createAnswer(resultStatements, context, resultTransitiveStatements)); } } return(Answer.CreateUnknown()); }
public void CheckAllInvalidCombinations() { // arrange var language = Language.Default; var semanticNetwork = new SemanticNetwork(language); IConcept processA, processB, processI; semanticNetwork.Concepts.Add(processA = createProcess("Process A")); semanticNetwork.Concepts.Add(processB = createProcess("Process B")); semanticNetwork.Concepts.Add(processI = createProcess("Process I")); var validCombinations = getAllValidCombinations().Select(array => new Tuple <IConcept, IConcept, IConcept>((IConcept)array[0], (IConcept)array[1], (IConcept)array[2])).ToList(); foreach (var signAI in SequenceSigns.All) { foreach (var signIB in SequenceSigns.All) { if (!validCombinations.Any(c => c.Item1 == signAI && c.Item2 == signIB)) { var statementAI = new ProcessesStatement(null, processA, processI, signAI); var statementIA = new ProcessesStatement(null, processI, processA, SequenceSigns.Revert(signAI)); var statementIB = new ProcessesStatement(null, processI, processB, signIB); var statementBI = new ProcessesStatement(null, processB, processI, SequenceSigns.Revert(signIB)); foreach (var statementCombination in new[] { new Tuple <IStatement, IStatement>(statementAI, statementIB), new Tuple <IStatement, IStatement>(statementAI, statementBI), new Tuple <IStatement, IStatement>(statementIA, statementIB), new Tuple <IStatement, IStatement>(statementIA, statementBI), }) { try { semanticNetwork.Statements.Add(statementCombination.Item1); semanticNetwork.Statements.Add(statementCombination.Item2); // act var answer = semanticNetwork.Ask().WhatIsMutualSequenceOfProcesses(processA, processB); // assert Assert.IsTrue(answer.IsEmpty); Assert.AreEqual(0, answer.Explanation.Statements.Count); } finally { semanticNetwork.Statements.Remove(statementCombination.Item1); semanticNetwork.Statements.Remove(statementCombination.Item2); } } } } } }
protected override Boolean TryToUpdateCombinations(IConcept valueRow, IConcept signRow, IConcept signColumn, IConcept valueColumn) { var resultSign = SequenceSigns.TryToCombineMutualSequences(signRow, signColumn); return(resultSign != null && SetCombinationWithDescendants(valueRow, valueColumn, resultSign)); }
public ProcessesStatement SwapOperands() { return(new ProcessesStatement(null, processA: ProcessB, processB: ProcessA, sequenceSign: SequenceSigns.Revert(SequenceSign))); }