public void SupportTransitiveStatements()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var conceptParent = "parent".CreateConcept();
var conceptIntermediate = "intermediate".CreateConcept();
var conceptChild = "child".CreateConcept();
semanticNetwork.Concepts.Add(conceptParent);
semanticNetwork.Concepts.Add(conceptIntermediate);
semanticNetwork.Concepts.Add(conceptChild);
var statementPI = new TransitiveTestStatement(conceptParent, conceptIntermediate);
var statementIC = new TransitiveTestStatement(conceptIntermediate, conceptChild);
semanticNetwork.Statements.Add(statementPI);
semanticNetwork.Statements.Add(statementIC);
var statementToCheck = new TransitiveTestStatement(conceptParent, conceptChild);
// act
var answer = semanticNetwork.Ask().IsTrueThat(statementToCheck);
// assert
Assert.IsFalse(answer.IsEmpty);
Assert.IsTrue(((BooleanAnswer)answer).Result);
Assert.AreEqual(2, answer.Explanation.Statements.Count);
Assert.IsTrue(answer.Explanation.Statements.Contains(statementPI));
Assert.IsTrue(answer.Explanation.Statements.Contains(statementIC));
}
public void WithModulesDoesNotDependOnSequence()
{
// arrange
var language = Language.Default;
ISemanticNetwork semanticNetwork = new SemanticNetwork(language);
var modules = new IExtensionModule[]
{
new TestModule("4", new string[] { "2", "3" }),
new TestModule("5", new string[] { "1", "4" }),
new TestModule("0"),
new TestModule("2", new string[] { "1" }),
new TestModule("3", new string[] { "1" }),
new TestModule("1", new string[] { "0" }),
};
// act
semanticNetwork = semanticNetwork.WithModules(modules);
var appliedModules = semanticNetwork.Modules.Keys;
var expectedModules = modules.Select(m => m.Name).ToList();
// assert
Assert.AreEqual(expectedModules.Count, appliedModules.Count);
Assert.IsFalse(expectedModules.Except(appliedModules).Any());
}
public void ReturnFoundStatementIfExists()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var statementToCheck = new TestStatement(1);
var statementRight = new TestStatement(1);
var statementWrong = new TestStatement(2);
semanticNetwork.Statements.Add(statementRight);
semanticNetwork.Statements.Add(statementWrong);
// act
var answerToCheck = semanticNetwork.Ask().IsTrueThat(statementToCheck);
var answerRight = semanticNetwork.Ask().IsTrueThat(statementRight);
// assert
Assert.IsFalse(answerToCheck.IsEmpty);
Assert.IsTrue(((BooleanAnswer)answerToCheck).Result);
Assert.AreSame(statementRight, answerToCheck.Explanation.Statements.Single());
Assert.IsFalse(answerRight.IsEmpty);
Assert.IsTrue(((BooleanAnswer)answerRight).Result);
Assert.AreSame(statementRight, answerRight.Explanation.Statements.Single());
}
public void ReturnAllDifferenceManyLevels()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
GetCommonQuestionTest.CreateCompareConceptsTest(semanticNetwork);
// act
var answer = semanticNetwork.Ask().WhatIsTheDifference(
semanticNetwork.Concepts.First(c => c.HasAttribute <IsProcessAttribute>()),
semanticNetwork.Concepts.Last(c => c.HasAttribute <IsProcessAttribute>()));
// assert
Assert.IsFalse(answer.IsEmpty);
var signs = (((ConceptsAnswer)answer).Result).Select(c => c.Name.GetValue(language)).ToList();
Assert.AreEqual(3, signs.Count);
Assert.IsTrue(signs.Contains(GetCommonQuestionTest.SignDifferentValues));
Assert.IsTrue(signs.Contains(GetCommonQuestionTest.SignFirstNotSet));
Assert.IsTrue(signs.Contains(GetCommonQuestionTest.SignSecondNotSet));
Assert.Greater(answer.Explanation.Statements.Count, 0);
}
public void ReturnAllParents()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var childConcept = ConceptCreationHelper.CreateConcept();
semanticNetwork.Concepts.Add(childConcept);
const int parentCount = 4;
for (int i = 1; i <= parentCount; i++)
{
// act
var parentConcept = ConceptCreationHelper.CreateConcept();
semanticNetwork.Concepts.Add(parentConcept);
semanticNetwork.DeclareThat(parentConcept).IsAncestorOf(childConcept);
var answer = semanticNetwork.Ask().WhichAncestorsHas(childConcept);
// assert
Assert.IsFalse(answer.IsEmpty);
var parentConcepts = ((ConceptsAnswer)answer).Result;
Assert.AreEqual(i, parentConcepts.Count);
Assert.IsTrue(parentConcepts.All(semanticNetwork.Concepts.Contains));
Assert.AreEqual(i, answer.Explanation.Statements.Count);
Assert.IsFalse(semanticNetwork.Statements.Except(answer.Explanation.Statements).Any());
}
}
public void WhenNoRelationshipsReturnEmptyAnswer()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var conceptToCheck = ConceptCreationHelper.CreateConcept();
var wholeConcept = ConceptCreationHelper.CreateConcept();
var partConcept = ConceptCreationHelper.CreateConcept();
semanticNetwork.Concepts.Add(conceptToCheck);
semanticNetwork.Concepts.Add(wholeConcept);
semanticNetwork.Concepts.Add(partConcept);
semanticNetwork.DeclareThat(partConcept).IsPartOf(wholeConcept);
// act
var answerToCheck = semanticNetwork.Ask().WhichContainersInclude(conceptToCheck);
var answerWhole = semanticNetwork.Ask().WhichContainersInclude(wholeConcept);
// assert
Assert.IsTrue(answerToCheck.IsEmpty);
Assert.AreEqual(0, answerToCheck.Explanation.Statements.Count);
Assert.IsTrue(answerWhole.IsEmpty);
Assert.AreEqual(0, answerWhole.Explanation.Statements.Count);
}
public void ReturnEmptyAnswerIfNoMathingStatementsFound()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var statementToCheck = new TestStatement(1);
var statementWrong = new TestStatement(2);
// act
var answerNoStatements = semanticNetwork.Ask().IsTrueThat(statementToCheck);
semanticNetwork.Statements.Add(statementWrong);
var answerWrongStatement = semanticNetwork.Ask().IsTrueThat(statementToCheck);
// assert
var answer = (BooleanAnswer)answerNoStatements;
Assert.IsFalse(answer.IsEmpty);
Assert.IsFalse(answer.Result);
Assert.AreEqual(0, answer.Explanation.Statements.Count);
answer = (BooleanAnswer)answerWrongStatement;
Assert.IsFalse(answer.IsEmpty);
Assert.IsFalse(answer.Result);
Assert.AreEqual(0, answer.Explanation.Statements.Count);
}
public void WhenNoRelationshipsReturnEmptyAnswer()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var conceptToCheck = ConceptCreationHelper.CreateConcept();
var parentConcept = ConceptCreationHelper.CreateConcept();
var childConcept = ConceptCreationHelper.CreateConcept();
semanticNetwork.Concepts.Add(conceptToCheck);
semanticNetwork.Concepts.Add(parentConcept);
semanticNetwork.Concepts.Add(childConcept);
semanticNetwork.DeclareThat(childConcept).IsDescendantOf(parentConcept);
// act
var answerToCheck = semanticNetwork.Ask().WhichAncestorsHas(conceptToCheck);
var answerChild = semanticNetwork.Ask().WhichAncestorsHas(parentConcept);
// assert
Assert.IsTrue(answerToCheck.IsEmpty);
Assert.AreEqual(0, answerToCheck.Explanation.Statements.Count);
Assert.IsTrue(answerChild.IsEmpty);
Assert.AreEqual(0, answerChild.Explanation.Statements.Count);
}
static void Main(string[] args)
{
#region Preparation section
Console.WriteLine("This sample demonstrates how to compare concepts.");
Console.WriteLine("It works with usual numbers.");
Console.WriteLine();
ISemanticNetwork semanticNetwork = new SemanticNetwork(Language.Default)
.WithModule <MathematicsModule>();
Console.WriteLine();
#endregion
#region Define concepts
var numbers = new List <IConcept>();
for (int i = 0; i <= 10; i++)
{
string n = i.ToString();
IConcept number = n.CreateConcept().WithAttribute(IsValueAttribute.Value);
numbers.Add(number);
semanticNetwork.Concepts.Add(number);
}
#endregion
#region Define statements
for (int i = 0; i < 5; i++)
{
semanticNetwork.DeclareThat(numbers[i]).IsLessThan(numbers[i + 1]);
}
for (int i = 10; i > 5; i--)
{
semanticNetwork.DeclareThat(numbers[i]).IsGreaterThan(numbers[i - 1]);
}
#endregion
#region Ask questions
// Now we can work with our Semantic Network and ask questions.
writeAnswer(
"Question 1: 0 vs 10?",
semanticNetwork.Ask().HowCompared(numbers[0], numbers[10])); // There are no explicit knowledge about this.
writeAnswer(
"Question 2: 10 vs 0?",
semanticNetwork.Ask().HowCompared(numbers[10], numbers[0])); // vice versa, but with the same result
#endregion
Console.WriteLine();
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
static void Main(string[] args)
{
#region Preparation section
Console.WriteLine("This sample demonstrates work of custom user-defined Question, which just selects random Concept.");
Console.WriteLine();
ISemanticNetwork semanticNetwork = new SemanticNetwork(Language.Default);
Console.WriteLine();
#endregion
#region Define concepts
semanticNetwork.Concepts.Add("Alfa".CreateConcept());
semanticNetwork.Concepts.Add("Bravo".CreateConcept());
semanticNetwork.Concepts.Add("Charlie".CreateConcept());
semanticNetwork.Concepts.Add("Delta".CreateConcept());
semanticNetwork.Concepts.Add("Echo".CreateConcept());
semanticNetwork.Concepts.Add("Foxtrot".CreateConcept());
semanticNetwork.Concepts.Add("Golf".CreateConcept());
semanticNetwork.Concepts.Add("Hotel".CreateConcept());
semanticNetwork.Concepts.Add("India".CreateConcept());
semanticNetwork.Concepts.Add("Juliett".CreateConcept());
semanticNetwork.Concepts.Add("Kilo".CreateConcept());
semanticNetwork.Concepts.Add("Lima".CreateConcept());
semanticNetwork.Concepts.Add("Mike".CreateConcept());
semanticNetwork.Concepts.Add("November".CreateConcept());
semanticNetwork.Concepts.Add("Oscar".CreateConcept());
semanticNetwork.Concepts.Add("Papa".CreateConcept());
semanticNetwork.Concepts.Add("Quebec".CreateConcept());
semanticNetwork.Concepts.Add("Romeo".CreateConcept());
semanticNetwork.Concepts.Add("Sierra".CreateConcept());
semanticNetwork.Concepts.Add("Tango".CreateConcept());
semanticNetwork.Concepts.Add("Uniform".CreateConcept());
semanticNetwork.Concepts.Add("Victor".CreateConcept());
semanticNetwork.Concepts.Add("Whiskey".CreateConcept());
semanticNetwork.Concepts.Add("X-ray".CreateConcept());
semanticNetwork.Concepts.Add("Yankee".CreateConcept());
semanticNetwork.Concepts.Add("Zulu".CreateConcept());
#endregion
#region Ask questions
// Now we can work with our Semantic Network and ask questions.
writeAnswer(
"Question: Give me any random Code word from NATO phonetic alphabet...",
semanticNetwork.Ask().ForRandomConcept()); // There are no explicit knowledge about this
#endregion
Console.WriteLine();
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
public void ImpossibleToInstantiateMoreThanOneSemanticNetworkContextOutOfOneSystemContext()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var systemContext = (SystemContext)semanticNetwork.Context.Parent;
// act & assert
Assert.Throws <InvalidOperationException>(() => systemContext.Instantiate(new TestSemanticNetwork()));
}
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);
}
}
}
}
}
}
private void MainForm_Load(object sender, EventArgs e)
{
DrawPanel.MouseWheel += DrawPanel_MouseWheel;
(DrawPanel as Control).KeyUp += DrawPanel_KeyUp;
(DrawPanel as Control).KeyDown += DrawPanel_KeyDown;
SemanticNetwork = new SemanticNetwork(new List <Node>(), new List <Edge>(), "Семантическая сеть");
converter = new Converter(DrawPanel.Width, DrawPanel.Height, -5, 5, -5, 5);
Test();
DrawPanel.Invalidate();
}
public void ContextDisposingRemovesStatementsAddedByIt()
{
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
// this context adds to semantic network new test statement, attached to this context
new TestQuestionCreateContextKnowledge().Ask(semanticNetwork.Context);
// as context has been disposed after previous line, ensure, that added test stametement(s) was (were) also deleted
Assert.IsFalse(semanticNetwork.Statements.Enumerate <TestStatement>().Any());
}
public static Node CheckNode(int U, int V, SemanticNetwork sn)
{
foreach (Node node in sn.Nodes)
{
if (node.Contains(new Point(U, V)))
{
node.NodeConfig.Selected = true;
return(node);
}
}
return(null);
}
public static Edge CheckEdge(Point p, SemanticNetwork semanticNetwork)
{
foreach (Edge edge in semanticNetwork.Edges)
{
if (edge.Contains(p))
{
edge.EdgeConfig.Selected = true;
return(edge);
}
}
return(null);
}
public static void DrawSemanticNetwork(Graphics g, SemanticNetwork semanticNetwork)
{
foreach (Edge edge in semanticNetwork.Edges)
{
DrawEdge(g, edge);
}
foreach (Node node in semanticNetwork.Nodes)
{
DrawNode(g, node);
}
}
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);
}
}
}
// POST api/<controller>
public SemanticNetwork Post([FromBody] SemanticNetwork semNetwork)
{
if (semNetwork != null)
{
_context.SemanticNetworks.Add(semNetwork);
_context.SaveChanges();
return(semNetwork);
}
else
{
throw new Exception("Пустое имя сем. сети.");
}
}
public void ImpossibleToRegisterModuleWithUnregisteredDependencies()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var module = new TestModule("Test", new[] { "Dependency" });
// act && assert
var error = Assert.Throws <ModuleException>(() => module.AttachTo(semanticNetwork));
Assert.AreEqual(module.Name, error.ModuleName);
}
public static void Editing(Point p, SemanticNetwork semanticNetwork)
{
if (CheckEdge(p, semanticNetwork) != null)
{
CheckEdge(p, semanticNetwork).EdgeConfig.Edit = true;
}
else
{
foreach (var edge in semanticNetwork.Edges)
{
edge.EdgeConfig.Edit = false;
}
}
}
public static void Select(int U, int V, SemanticNetwork semanticNetwork)
{
if (CheckNode(U, V, semanticNetwork) != null)
{
CheckNode(U, V, semanticNetwork).NodeConfig.Selected = true;
}
else if (CheckEdge(U, V, semanticNetwork) != null)
{
CheckEdge(U, V, semanticNetwork).EdgeConfig.Selected = true;
}
else
{
semanticNetwork.Deselect();
}
}
public void ContextDisposalWorksOnlyOnce()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var questionContext = semanticNetwork.Context.CreateQuestionContext(new TestQuestionCreateContextKnowledge());
var childQuestionContext = semanticNetwork.Context.CreateQuestionContext(new TestQuestionCreateNestedContext(false));
// act
questionContext.Dispose();
questionContext.Children.Add(childQuestionContext);
// assert
Assert.DoesNotThrow(() => questionContext.Dispose());
}
public void AttachToSemanticNetworkOnce()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var module = new TestModule("Test");
semanticNetwork.Modules[module.Name] = module;
// act
module.AttachTo(semanticNetwork);
// assert
Assert.IsFalse(module.IsSemanticNetworkAttached);
}
// PUT api/<controller>/5
public SemanticNetwork Put(int id, [FromBody] SemanticNetwork newSemNetwork)
{
var semNetwork = _context.SemanticNetworks.Find(id);
if (semNetwork == null)
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
}
semNetwork.Name = newSemNetwork.Name;
semNetwork.Vertices = newSemNetwork.Vertices;
semNetwork.Arcs = newSemNetwork.Arcs;
_context.SaveChanges();
return(semNetwork);
}
public void EnsureThatImpossibleToDisposeContextWhichHasNotDisposedChildContexts()
{
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
Assert.DoesNotThrow(() =>
{
// test context is created without children and can be successfully disposed
new TestQuestionCreateNestedContext(false).Ask(semanticNetwork.Context);
});
Assert.Throws <InvalidOperationException>(() =>
{
// test context is created with unfinished children and fails to dispose
new TestQuestionCreateNestedContext(true).Ask(semanticNetwork.Context);
});
}
public void OnlySystemContextIsSystem()
{
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var semanticNetworkContext = (SemanticNetworkContext)semanticNetwork.Context;
Assert.IsFalse(semanticNetworkContext.IsSystem);
var systemContext = (SystemContext)semanticNetworkContext.Parent;
Assert.IsTrue(systemContext.IsSystem);
var questionContext = semanticNetworkContext.CreateQuestionContext(new TestQuestionCreateContextKnowledge());
Assert.IsFalse(questionContext.IsSystem);
}
public void AccessQuestionContextQuestion()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var question = new TestQuestionCreateContextKnowledge();
// act
var questionContext = semanticNetwork.Context.CreateQuestionContext(question);
// assert
var contextQuestion = questionContext.Question;
var typedContextQuestion = ((IQuestionProcessingContext <TestQuestionCreateContextKnowledge>)questionContext).Question;
Assert.AreSame(question, contextQuestion);
Assert.AreSame(question, typedContextQuestion);
}
public void TestBuildingIsStatement()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var ancestor = ConceptCreationHelper.CreateConcept();
var descendant = ConceptCreationHelper.CreateConcept();
// act
var statementByConstuctor = new IsStatement(null, ancestor, descendant);
var statementByBuilderFromAncestor = semanticNetwork.DeclareThat(ancestor).IsAncestorOf(descendant);
var statementByBuilderFromDescendant = semanticNetwork.DeclareThat(descendant).IsDescendantOf(ancestor);
// assert
Assert.AreEqual(statementByConstuctor, statementByBuilderFromAncestor);
Assert.AreEqual(statementByConstuctor, statementByBuilderFromDescendant);
}
public void TestBuildingGroupStatement()
{
// arrange
var language = Language.Default;
var semanticNetwork = new SemanticNetwork(language);
var area = ConceptCreationHelper.CreateConcept();
var concept = ConceptCreationHelper.CreateConcept();
// act
var statementByConstuctor = new GroupStatement(null, area, concept);
var statementByBuilderFromArea = semanticNetwork.DeclareThat(area).IsSubjectAreaOf(concept);
var statementByBuilderFromConcept = semanticNetwork.DeclareThat(concept).BelongsToSubjectArea(area);
// assert
Assert.AreEqual(statementByConstuctor, statementByBuilderFromArea);
Assert.AreEqual(statementByConstuctor, statementByBuilderFromConcept);
}
