/// <summary>
/// Cria um grafo de testes.
/// </summary>
/// <param name="syncSource">
/// Uma fonte de valores.
/// </param>
/// <returns>O grafo de testes.</returns>
private LabeledEdgeListGraph <OperationVertex, OperationEdge> CreateTestGraph_SingleNode(
SynchGen syncSource)
{
var result = new LabeledEdgeListGraph <OperationVertex, OperationEdge>(
true);
result.AddVertex(new OperationVertex(() => syncSource.Current));
return(result);
}
/// <summary>
/// Cria um grafo de testes que, quando devidamente estruturado com a pesquisa
/// de profundidade, pode ser utlizado na resolução da equação às diferenças da
/// forma y[n+3]= n - y[n] - 2y[n+1] - 3y[n+3]
/// </summary>
/// <param name="syncSource">Uma fonte de valores.</param>
/// <returns>O grafo de testes.</returns>
/// <remarks>
/// Note-se que o grafo deverá ser dirigido dos nós de saída para os nós de entrada.
/// </remarks>
private LabeledEdgeListGraph <OperationVertex, OperationEdge> CreateTestGraph_DiffEquation(
SynchGen syncSource)
{
var result = new LabeledEdgeListGraph <OperationVertex, OperationEdge>(
true);
var sourceVertex = new OperationVertex(
() => syncSource.Current);
var prodSumVertex = new OperationVertex(
4,
1,
(i, o) =>
{
o[0] = i[0] - i[1] - 2 * i[2] - 3 * i[3];
});
// Poderia ser realizado com apenas um vértice e vários canais de saída
// sem a necessidade de uma linha de atraso.
var delayVertex = new OperationVertex(
1,
4,
(i, o) =>
{
o[0] = o[1];
o[1] = o[2];
o[2] = o[3];
o[3] = i[0];
});
delayVertex.Results[1] = 1;
delayVertex.Results[2] = 2;
delayVertex.Results[3] = 3;
result.AddEdge(
delayVertex,
prodSumVertex,
new OperationEdge(0, 0));
result.AddEdge(
prodSumVertex,
sourceVertex,
new OperationEdge(0, 0));
result.AddEdge(
prodSumVertex,
delayVertex,
new OperationEdge(1, 1));
result.AddEdge(
prodSumVertex,
delayVertex,
new OperationEdge(2, 2));
result.AddEdge(
prodSumVertex,
delayVertex,
new OperationEdge(3, 3));
return(result);
}
/// <summary>
/// Cria um grafo de testes.
/// </summary>
/// <param name="syncSource">Uma fonte de valores.</param>
/// <returns>O grafo de testes.</returns>
private LabeledEdgeListGraph <OperationVertex, OperationEdge> CreateTestGraph_SimpleCycle(
SynchGen syncSource)
{
var result = new LabeledEdgeListGraph <OperationVertex, OperationEdge>(true);
var sourceVertex = new OperationVertex(
1,
1,
(arg, res) => res[0] = arg[0] + syncSource.Current);
Array.Clear(sourceVertex.Arguments, 0, sourceVertex.Arguments.Length);
Array.Clear(sourceVertex.Results, 0, sourceVertex.Results.Length);
result.AddVertex(sourceVertex);
result.AddEdge(
sourceVertex,
sourceVertex,
new OperationEdge(0, 0));
return(result);
}
/// <summary>
/// Cria um grafo de teste que define uma espécie de rede neural muito simples.
/// </summary>
/// <returns>O grafo de teste.</returns>
private LabeledEdgeListGraph <NeuSource, double> CreateTestGraph_SimpleNeuralNework()
{
var result = new LabeledEdgeListGraph <NeuSource, double>(true);
var h1 = new NeuTest("h1");
var h2 = new NeuTest("h2");
var g1 = new NeuTest(d => d > 1.5 ? 1.0 : 0.0, "g1");
var g2 = new NeuTest(d => d > -1.5 ? 1.0 : 0.0, "g2");
var vertices = new NeuSource[6];
for (var i = 0; i < 6; ++i)
{
var vertex = new NeuSource(string.Format("input{0}", i));
result.AddVertex(vertex);
vertices[i] = vertex;
}
result.AddVertex(g1);
result.AddVertex(g2);
var j = 0;
for (; j < 3; ++j)
{
result.AddEdge(h1, vertices[j], 1.0);
}
for (; j < 6; ++j)
{
result.AddEdge(h2, vertices[j], 1.0);
}
result.AddEdge(g1, h1, 1.0);
result.AddEdge(g1, h2, 1.0);
result.AddEdge(g2, h1, -1.0);
result.AddEdge(g2, h2, -1.0);
return(result);
}
/// <summary>
/// Cria um grafo de testes um pouco mais complexo.
/// </summary>
/// <param name="syncSource">Uma fonte de valores.</param>
/// <returns>O grafo de testes.</returns>
private LabeledEdgeListGraph <OperationVertex, OperationEdge> CreateTestGraph_Complex(
SynchGen syncSource)
{
var result = new LabeledEdgeListGraph <OperationVertex, OperationEdge>(
true);
var delayLine = new int[] { 1, 2, 3 };
var sourceVertex = new OperationVertex(
() => syncSource.Current);
var prodSumVertex = new OperationVertex(
4,
1,
(i, o) =>
{
o[0] = i[0] - i[1] - 2 * i[2] - 3 * i[3];
});
// Poderia ser realizado com apenas um vértice e vários canais de saída
// sem a necessidade de uma linha de atraso.
var delay1Vertex = new OperationVertex(
1,
1,
(i, o) =>
{
o[0] = delayLine[0];
delayLine[0] = i[0];
});
var delay2Vertex = new OperationVertex(
1,
1,
(i, o) =>
{
o[0] = delayLine[1];
delayLine[1] = i[0];
});
var delay3Vertex = new OperationVertex(
1,
1,
(i, o) =>
{
o[0] = delayLine[2];
delayLine[2] = i[0];
});
// O grafo tem de ser realizado da saída para a entrada
result.AddEdge(
sourceVertex,
prodSumVertex,
new OperationEdge(0, 0));
result.AddEdge(
prodSumVertex,
delay1Vertex,
new OperationEdge(0, 0));
result.AddEdge(
delay1Vertex,
delay2Vertex,
new OperationEdge(0, 0));
result.AddEdge(
delay1Vertex,
prodSumVertex,
new OperationEdge(0, 1));
result.AddEdge(
delay2Vertex,
delay3Vertex,
new OperationEdge(0, 0));
result.AddEdge(
delay2Vertex,
prodSumVertex,
new OperationEdge(0, 2));
result.AddEdge(
delay3Vertex,
prodSumVertex,
new OperationEdge(0, 3));
return(result);
}
