public static List<GraphModel> GetChartData()
{
DataTable dt = new DataTable();
using (SqlConnection con = new SqlConnection("Data Source=.;Initial Catalog=ShoppingDB;User ID=sa;Password=pass123!@#"))
{
con.Open();
SqlCommand cmd = new SqlCommand("select Name,total=value from CountryDetails order by total desc", con);
SqlDataAdapter da = new SqlDataAdapter(cmd);
da.Fill(dt);
con.Close();
}
List<countrydetails> dataList = new List<countrydetails>();
List<GraphModel> gmL = new List<GraphModel>();
foreach (DataRow dtrow in dt.Rows)
{
GraphModel gm = new GraphModel();
gm.label = dtrow[0].ToString();
gm.value= Convert.ToInt32(dtrow[1]);
gmL.Add(gm);
}
return gmL;
}
public void Init()
{
_graph = new GraphModel();
_user1 = _graph.CreateNode("user");
var user2 = _graph.CreateNode("user");
var tweet = _graph.CreateNode("tweet");
_graph.CreateEdge(_user1, tweet, "tweeted");
_graph.CreateEdge(user2, tweet, "retweeted");
_graph.CreateEdge(_user1, user2, "followed");
_graph.CreateEdge(_user1, _user1, "followed");
}
// todo クラス化
private IGraphModel MakeTrendChartModel(IProject project, ISprintToGraphModel sprintToGraphModel)
{
var sx = project.Sprints;
// todo グラフデータに変換
// xは日付
// yはValue
var gx =
(from s in sx
let g = sprintToGraphModel.Make(s)
select g).ToArray();
// マージする
var merged =
new GraphModel
{
Pv = gx.Select(x => x.Pv).Foldl(Enumerable.Empty<IGraphPoint>(), (a, x) => sprintToGraphModel.Merge(a, x)).ToArray(),
Ev = gx.Select(x => x.Ev).Foldl(Enumerable.Empty<IGraphPoint>(), (a, x) => sprintToGraphModel.Merge(a, x)).ToArray(),
Ac = gx.Select(x => x.Ac).Foldl(Enumerable.Empty<IGraphPoint>(), (a, x) => sprintToGraphModel.Merge(a, x)).ToArray(),
};
// 抜けてる日付をorする
var allDays = merged.Pv.Concat(merged.Ev).Concat(merged.Ac).Select(x => x.Day).Distinct();
var filledBlank =
new GraphModel
{
Pv = sprintToGraphModel.ToFillBlank(merged.Pv, allDays).ToArray(),
Ev = sprintToGraphModel.ToFillBlank(merged.Ev, allDays).ToArray(),
Ac = sprintToGraphModel.ToFillBlank(merged.Ac, allDays).ToArray(),
};
// 値を積み上げる
var stacked =
new GraphModel
{
Pv = sprintToGraphModel.ToStacked(filledBlank.Pv).ToArray(),
Ev = sprintToGraphModel.ToStacked(filledBlank.Ev).ToArray(),
Ac = sprintToGraphModel.ToStacked(filledBlank.Ac).ToArray(),
};
return stacked;
}
public static MacroRefNodeModel CreateMacroRefNode(this IGraphNodeCreationData data, GraphModel macroGraphModel)
{
return(data.GraphModel.CreateMacroRefNode(macroGraphModel, data.Position, data.SpawnFlags, data.Guid));
}
public BaseAlgorithm(GraphModel graphModel)
{
this.graphModel = graphModel;
}
public Benchmarks()
{
_g = g
.ConfigureEnvironment(env => env.UseModel(GraphModel.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())));
}
public GremlinQueryTest(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
{
_g = g
.ConfigureEnvironment(_ => _
.UseModel(GraphModel.FromBaseTypes <Vertex, Edge>()));
}
public DepthFirstSearchDirectedAlgorithm(GraphModel model)
{
_model = model;
}
/// <summary>
/// Classifies text into either positive or negative sentiment
/// The data files can be downloaded from https://archive.ics.uci.edu/ml/datasets/Sentiment+Labelled+Sentences
/// </summary>
/// <param name="dataFilesPath">Path to extracted data files</param>
public static void SentimentClassification(string dataFilesPath)
{
var files = new[] { "amazon_cells_labelled.txt", "imdb_labelled.txt", "yelp_labelled.txt" };
var LINE_SEPARATOR = "\n".ToCharArray();
var SEPARATOR = "\t".ToCharArray();
var stringTable = new StringTableBuilder();
var sentimentData = files.SelectMany(f =>
File.ReadAllText(dataFilesPath + f).Split(LINE_SEPARATOR).
Where(l => !string.IsNullOrWhiteSpace(l)).Select(l => l.Split(SEPARATOR)).
Select(s => Tuple.Create(Tokenise(s[0]), s[1][0] == '1' ? "positive" : "negative")).
Where(d => d.Item1.Any())).Shuffle(0).ToList();
var splitSentimentData = sentimentData.Split();
// build training and test classification bag
var trainingClassificationBag =
BuildIndexedClassifications(splitSentimentData.Training, stringTable);
var testClassificationBag =
BuildIndexedClassifications(splitSentimentData.Test, stringTable);
// train a bernoulli naive bayes classifier
var bernoulli = trainingClassificationBag.TrainBernoulliNaiveBayes();
Console.WriteLine("Bernoulli accuracy: {0:P}",
testClassificationBag.Classify(bernoulli.CreateClassifier()).Average(r => r.Score));
// train a multinomial naive bayes classifier
var multinomial = trainingClassificationBag.TrainMultinomialNaiveBayes();
Console.WriteLine("Multinomial accuracy: {0:P}",
testClassificationBag.Classify(multinomial.CreateClassifier()).Average(r => r.Score));
// convert the index lists to vectors and normalise along the way
var sentimentDataTable = BuildIndexedClassifications(sentimentData, stringTable).
ConvertToTable().Normalise(NormalisationType.Standard);
var vectoriser = sentimentDataTable.GetVectoriser();
var sentimentDataSet = sentimentDataTable.Split(0);
var dataTableAnalysis = sentimentDataTable.GetAnalysis();
using (var lap = BrightWireProvider.CreateLinearAlgebra())
{
var graph = new GraphFactory(lap);
var trainingData = graph.CreateDataSource(sentimentDataSet.Training, vectoriser);
var testData = graph.CreateDataSource(sentimentDataSet.Test, vectoriser);
var indexListEncoder = (IIndexListEncoder)trainingData;
// use a one hot encoding error metric, rmsprop gradient descent and xavier weight initialisation
var errorMetric = graph.ErrorMetric.OneHotEncoding;
var propertySet = graph.CurrentPropertySet.Use(graph.GradientDescent.RmsProp).
Use(graph.WeightInitialisation.Xavier);
var engine = graph.CreateTrainingEngine(trainingData, 0.3f);
engine.LearningContext.ScheduleLearningRate(5, 0.1f);
engine.LearningContext.ScheduleLearningRate(11, 1f);
engine.LearningContext.ScheduleLearningRate(15, 0.3f);
// train a neural network classifier
var neuralNetworkWire = graph.Connect(engine).AddFeedForward(512, "layer1")
//.AddBatchNormalisation()
.Add(graph.ReluActivation()).AddDropOut(0.5f).
AddFeedForward(trainingData.OutputSize, "layer2").Add(graph.ReluActivation()).
AddBackpropagation(errorMetric, "first-network");
// train the network
Console.WriteLine("Training neural network classifier...");
const int TRAINING_ITERATIONS = 10;
GraphModel bestNetwork = null;
engine.Train(TRAINING_ITERATIONS, testData, errorMetric, network => bestNetwork = network);
if (bestNetwork != null)
{
engine.LoadParametersFrom(bestNetwork.Graph);
}
var firstClassifier = graph.CreateEngine(engine.Graph);
// stop the backpropagation to the first neural network
engine.LearningContext.EnableNodeUpdates(neuralNetworkWire.Find("layer1"), false);
engine.LearningContext.EnableNodeUpdates(neuralNetworkWire.Find("layer2"), false);
// create the bernoulli classifier wire
var bernoulliClassifier = bernoulli.CreateClassifier();
var bernoulliWire = graph.Connect(engine).AddClassifier(bernoulliClassifier,
sentimentDataSet.Training, dataTableAnalysis);
// create the multinomial classifier wire
var multinomialClassifier = multinomial.CreateClassifier();
var multinomialWire = graph.Connect(engine).AddClassifier(multinomialClassifier,
sentimentDataSet.Training, dataTableAnalysis);
// join the bernoulli, multinomial and neural network classification outputs
var firstNetwork = neuralNetworkWire.Find("first-network");
var joined = graph.Join(multinomialWire,
graph.Join(bernoulliWire, graph.Connect(trainingData.OutputSize, firstNetwork)));
// train an additional classifier on the output of the previous three classifiers
joined.AddFeedForward(outputSize: 64).Add(graph.ReluActivation()).
AddDropOut(dropOutPercentage: 0.5f).AddFeedForward(trainingData.OutputSize).
Add(graph.ReluActivation()).AddBackpropagation(errorMetric);
// train the network again
Console.WriteLine("Training stacked neural network classifier...");
GraphModel bestStackedNetwork = null;
engine.Train(10, testData, errorMetric, network => bestStackedNetwork = network);
if (bestStackedNetwork != null)
{
engine.LoadParametersFrom(bestStackedNetwork.Graph);
}
Console.WriteLine("Enter some text to test the classifiers...");
while (true)
{
Console.Write(">");
var line = Console.ReadLine();
if (string.IsNullOrWhiteSpace(line))
{
break;
}
var tokens = Tokenise(line);
var indexList = new List <uint>();
foreach (var token in tokens)
{
if (stringTable.TryGetIndex(token, out uint stringIndex))
{
indexList.Add(stringIndex);
}
}
if (indexList.Any())
{
var queryTokens = indexList.GroupBy(d => d).
Select(g => Tuple.Create(g.Key, (float)g.Count())).ToList();
var vector = new float[trainingData.InputSize];
foreach (var token in queryTokens)
{
vector[token.Item1] = token.Item2;
}
var indexList2 = IndexList.Create(indexList.ToArray());
var encodedInput = indexListEncoder.Encode(indexList2);
Console.WriteLine("Bernoulli classification: " +
bernoulliClassifier.Classify(indexList2).First().Label);
Console.WriteLine("Multinomial classification: " +
multinomialClassifier.Classify(indexList2).First().Label);
var result = firstClassifier.Execute(encodedInput);
var classification = vectoriser.GetOutputLabel(1,
(result.Output[0].Data[0] > result.Output[0].Data[1]) ? 0 : 1);
Console.WriteLine("Neural network classification: " + classification);
var stackedResult = engine.Execute(encodedInput);
var stackedClassification = vectoriser.GetOutputLabel(1,
(stackedResult.Output[0].Data[0] > stackedResult.Output[0].Data[1]) ? 0 : 1);
Console.WriteLine("Stack classification: " + stackedClassification);
}
else
{
Console.WriteLine("Sorry, none of those words have been seen before.");
}
Console.WriteLine();
}
}
Console.WriteLine();
}
private GraphModel GraphSetup()
{
GraphDB db = new GraphDB();
var graph = new GraphModel();
//get all the nodes
foreach (var node in db.Nodes)
{
var dataVertex = new DataVertex() { ID = node.Id, Text = node.label };
graph.AddVertex(dataVertex);
nodeList.Add(node.Id,node.label);
}
var vlist = graph.Vertices.ToList();
//add all the edges
foreach (var node in vlist)
{
Dictionary<int,int> edges = new Dictionary<int, int>();
foreach (var edge in db.Edges.Where(x => x.FromNode == node.ID))
{
var dataEdge = new DataEdge(node, vlist[vlist.FindIndex(x => x.ID == edge.ToNode)]);
graph.AddEdge(dataEdge);
edges.Add(edge.ToNode,1);
}
vertices.Add(node.ID,edges);
}
return graph;
}
public static InstantiateNodeModel FindInstantiateNodeModel(this GraphModel graph)
{
return(graph.NodeModels.OfType <IStackModel>().SelectMany(node => node.NodeModels.OfType <InstantiateNodeModel>()).First());
}
public GremlinQueryLanguageTest()
{
this._model = GraphModel.FromAssembly(Assembly.GetExecutingAssembly(), typeof(Vertex), typeof(Edge), GraphElementNamingStrategy.Simple);
}
public Gantt()
{
InitializeComponent();
// create the diagram's data model
var model = new GraphModel <Activity, int>();
int row = 1;
model.NodesSource = new ObservableCollection <Activity>()
{
// don't use Key==0
new Activity()
{
Key = 1, Row = row++, Text = "Start", FromKeys = P(), Length = 0, Start = 0, Critical = true, Category = "Start"
},
new Activity()
{
Key = 2, Row = row++, Text = "a", FromKeys = P(1), Length = 4, Start = 0, Critical = true
},
new Activity()
{
Key = 3, Row = row++, Text = "b", FromKeys = P(1), Length = 5.33, Start = 0
},
new Activity()
{
Key = 4, Row = row++, Text = "c", FromKeys = P(2), Length = 5.17, Start = 4, Critical = true
},
new Activity()
{
Key = 5, Row = row++, Text = "d", FromKeys = P(2), Length = 6.33, Start = 4
},
new Activity()
{
Key = 6, Row = row++, Text = "e", FromKeys = P(3, 4), Length = 5.17, Start = 9.17, Critical = true
},
new Activity()
{
Key = 7, Row = row++, Text = "f", FromKeys = P(5), Length = 4.5, Start = 10.33
},
new Activity()
{
Key = 8, Row = row++, Text = "g", FromKeys = P(6), Length = 5.17, Start = 14.34, Critical = true
},
new Activity()
{
Key = 9, Row = row++, Text = "Finish", FromKeys = P(7, 8), Length = 0, Start = 19.51, Critical = true, Category = "Finish"
},
// add Dates along the top
new Activity()
{
Key = 9999, Row = 0, Text = "23Jul", Start = 0, Category = "Week"
},
new Activity()
{
Key = 9999, Row = 0, Text = "30Jul", Start = 5, Category = "Week"
},
new Activity()
{
Key = 9999, Row = 0, Text = "6Aug", Start = 10, Category = "Week"
},
new Activity()
{
Key = 9999, Row = 0, Text = "13Aug", Start = 15, Category = "Week"
},
};
myDiagram.Model = model;
// initialize the converter to know about the Diagram, to support zooming
var conv = Diagram.FindResource <LengthConverter>(this, "myLengthConverter");
if (conv != null)
{
conv.Diagram = myDiagram;
}
// initialize the Diagram.GridPattern based on the spacing
myDiagram.GridPattern.CellSize = new Size(conv.Space * Gantt.XUnit, Gantt.YUnit);
}
public void Test_MoveElementsActionForNodes([Values] TestingMode mode)
{
var node0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero);
var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero);
var node2 = GraphModel.CreateNode <Type0FakeNodeModel>("Node2", Vector2.zero);
var node3 = GraphModel.CreateNode <Type0FakeNodeModel>("Node3", Vector2.zero);
var newPosition0 = new Vector2(50, -75);
var newPosition1 = new Vector2(60, 25);
var newPosition2 = new Vector2(-30, 15);
var deltaAll = new Vector2(100, 100);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(4));
Assert.That(GetNode(0).Position, Is.EqualTo(Vector2.zero));
Assert.That(GetNode(1).Position, Is.EqualTo(Vector2.zero));
Assert.That(GetNode(2).Position, Is.EqualTo(Vector2.zero));
Assert.That(GetNode(3).Position, Is.EqualTo(Vector2.zero));
return(new MoveElementsAction(newPosition0, new[] { node0 }, null));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(4));
Assert.That(GetNode(0).Position, Is.EqualTo(newPosition0));
Assert.That(GetNode(1).Position, Is.EqualTo(Vector2.zero));
Assert.That(GetNode(2).Position, Is.EqualTo(Vector2.zero));
Assert.That(GetNode(3).Position, Is.EqualTo(Vector2.zero));
});
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(4));
Assert.That(GetNode(0).Position, Is.EqualTo(newPosition0));
Assert.That(GetNode(1).Position, Is.EqualTo(Vector2.zero));
Assert.That(GetNode(2).Position, Is.EqualTo(Vector2.zero));
Assert.That(GetNode(3).Position, Is.EqualTo(Vector2.zero));
return(new MoveElementsAction(newPosition1, new[] { node1 }, null));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(4));
Assert.That(GetNode(0).Position, Is.EqualTo(newPosition0));
Assert.That(GetNode(1).Position, Is.EqualTo(newPosition1));
Assert.That(GetNode(2).Position, Is.EqualTo(Vector2.zero));
Assert.That(GetNode(3).Position, Is.EqualTo(Vector2.zero));
});
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(4));
Assert.That(GetNode(0).Position, Is.EqualTo(newPosition0));
Assert.That(GetNode(1).Position, Is.EqualTo(newPosition1));
Assert.That(GetNode(2).Position, Is.EqualTo(Vector2.zero));
Assert.That(GetNode(3).Position, Is.EqualTo(Vector2.zero));
return(new MoveElementsAction(newPosition2, new[] { node2 }, null));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(4));
Assert.That(GetNode(0).Position, Is.EqualTo(newPosition0));
Assert.That(GetNode(1).Position, Is.EqualTo(newPosition1));
Assert.That(GetNode(2).Position, Is.EqualTo(newPosition2));
Assert.That(GetNode(3).Position, Is.EqualTo(Vector2.zero));
});
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(4));
Assert.That(GetNode(0).Position, Is.EqualTo(newPosition0));
Assert.That(GetNode(1).Position, Is.EqualTo(newPosition1));
Assert.That(GetNode(2).Position, Is.EqualTo(newPosition2));
Assert.That(GetNode(3).Position, Is.EqualTo(Vector2.zero));
return(new MoveElementsAction(deltaAll, new[] { node0, node1, node2, node3 }, null));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(4));
Assert.That(GetNode(0).Position, Is.EqualTo(newPosition0 + deltaAll));
Assert.That(GetNode(1).Position, Is.EqualTo(newPosition1 + deltaAll));
Assert.That(GetNode(2).Position, Is.EqualTo(newPosition2 + deltaAll));
Assert.That(GetNode(3).Position, Is.EqualTo(deltaAll));
});
}
public JsonSupportTest()
{
_g = g
.UseModel(GraphModel.FromBaseTypes <Vertex, Edge>());
}
/// <summary>
/// Uses a recurrent LSTM neural network to predict stock price movements
/// Data can be downloaded from https://raw.githubusercontent.com/plotly/datasets/master/stockdata.csv
/// </summary>
static void StockData(string dataFilePath)
{
// load and normalise the data
var dataSet = new StreamReader(dataFilePath).ParseCSV(',', true);
var normalised = dataSet.Normalise(NormalisationType.FeatureScale);
var rows = normalised.GetNumericRows(dataSet.Columns.Where(c => c.Name != "Date").Select(c => c.Index));
// build the data table with a window of input data and the prediction as the following value
var builder = BrightWireProvider.CreateDataTableBuilder();
builder.AddColumn(ColumnType.Matrix, "Past");
builder.AddColumn(ColumnType.Vector, "Future");
const int LAST_X_DAYS = 14;
for (var i = 0; i < rows.Count - LAST_X_DAYS - 1; i++)
{
var inputVector = new List <FloatVector>();
for (var j = 0; j < LAST_X_DAYS; j++)
{
inputVector.Add(FloatVector.Create(rows[i + j]));
}
var input = FloatMatrix.Create(inputVector.ToArray());
var target = FloatVector.Create(rows[i + LAST_X_DAYS + 1]);
builder.Add(input, target);
}
var data = builder.Build().Split(trainingPercentage: 0.2);
using (var lap = BrightWireProvider.CreateLinearAlgebra()) {
var graph = new GraphFactory(lap);
var errorMetric = graph.ErrorMetric.Quadratic;
// create the property set
graph.CurrentPropertySet
.Use(graph.GradientDescent.Adam)
.Use(graph.WeightInitialisation.Xavier);
// create the engine
var trainingData = graph.CreateDataSource(data.Training);
var testData = trainingData.CloneWith(data.Test);
var engine = graph.CreateTrainingEngine(trainingData, learningRate: 0.03f, batchSize: 128);
// build the network
const int HIDDEN_LAYER_SIZE = 256;
graph.Connect(engine)
.AddLstm(HIDDEN_LAYER_SIZE)
.AddFeedForward(engine.DataSource.OutputSize)
.Add(graph.TanhActivation())
.AddBackpropagationThroughTime(errorMetric);
// train the network and restore the best result
GraphModel bestNetwork = null;
engine.Train(50, testData, errorMetric, model => bestNetwork = model);
if (bestNetwork != null)
{
// execute each row of the test data on an execution engine
var executionEngine = graph.CreateEngine(bestNetwork.Graph);
var results = executionEngine.Execute(testData).OrderSequentialOutput();
var expectedOutput = data.Test.GetColumn <FloatVector>(1);
var score = results.Select((r, i) => errorMetric.Compute(r.Last(), expectedOutput[i])).Average();
Console.WriteLine(score);
}
}
}
public IEnumerator AlignNodesHierarchiesCommandWorks([Values] TestingMode mode)
{
var constantA = GraphModel.CreateConstantNode(typeof(int).GenerateTypeHandle(), "constantA", Vector2.zero);
var binary0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.one * 200);
var binary1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node2", Vector2.one * 500);
GraphModel.CreateEdge(binary0.Input0, constantA.OutputPort);
GraphModel.CreateEdge(binary1.Input0, binary0.Output0);
MarkGraphViewStateDirty();
yield return(null);
void RefreshModelReferences()
{
constantA = GraphModel.NodeModels[0] as IConstantNodeModel;
binary0 = GraphModel.NodeModels[1] as Type0FakeNodeModel;
binary1 = GraphModel.NodeModels[2] as Type0FakeNodeModel;
Assert.IsNotNull(constantA);
Assert.IsNotNull(binary0);
Assert.IsNotNull(binary1);
}
yield return(TestPrereqCommandPostreq(mode,
() =>
{
RefreshModelReferences();
Assert.That(binary0.Input0, Is.ConnectedTo(constantA.OutputPort));
Assert.That(binary1.Input0, Is.ConnectedTo(binary0.Output0));
var port0UI = binary0.Output0.GetUI <Port>(GraphView);
Assert.IsNotNull(port0UI);
var port1UI = binary1.Input0.GetUI <Port>(GraphView);
Assert.IsNotNull(port1UI);
Assert.AreNotEqual(GetPortY(port0UI), GetPortY(port1UI));
var port2UI = constantA.OutputPort.GetUI <Port>(GraphView);
Assert.IsNotNull(port2UI);
var port3UI = binary0.Input0.GetUI <Port>(GraphView);
Assert.IsNotNull(port3UI);
Assert.AreNotEqual(GetPortY(port2UI), GetPortY(port3UI));
},
frame =>
{
switch (frame)
{
case 0:
CommandDispatcher.Dispatch(new AlignNodesCommand(GraphView, true, binary1));
return TestPhase.WaitForNextFrame;
default:
return TestPhase.Done;
}
},
() =>
{
RefreshModelReferences();
var port0UI = binary0.Output0.GetUI <Port>(GraphView);
Assert.IsNotNull(port0UI);
var port1UI = binary1.Input0.GetUI <Port>(GraphView);
Assert.IsNotNull(port1UI);
Assert.AreEqual(GetPortY(port0UI), GetPortY(port1UI));
var port2UI = constantA.OutputPort.GetUI <Port>(GraphView);
Assert.IsNotNull(port2UI);
var port3UI = binary0.Input0.GetUI <Port>(GraphView);
Assert.IsNotNull(port3UI);
Assert.AreEqual(GetPortY(port2UI), GetPortY(port3UI));
}));
}
public void NestedIteration_DifferentGroups_DifferentEntitiesAccess([Values] CodeGenMode mode)
{
SetupTestGraph(mode, graph =>
{
var translationType = typeof(Translation).GenerateTypeHandle(Stencil);
var scaleType = typeof(Scale).GenerateTypeHandle(Stencil);
// query1 - Position
var query1 = GraphModel.CreateComponentQuery("g1");
query1.AddComponent(Stencil, translationType, ComponentDefinitionFlags.None);
var query1Instance = GraphModel.CreateVariableNode(query1, Vector2.zero);
// query2 - Scale
var query2 = GraphModel.CreateComponentQuery("g2");
query2.AddComponent(Stencil, scaleType, ComponentDefinitionFlags.None);
var query2Instance = GraphModel.CreateVariableNode(query2, Vector2.zero);
// update query 1
var update = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(update.InstancePort, query1Instance.OutputPort);
// nested update query 2
var forAllStack = GraphModel.CreateLoopStack <ForAllEntitiesStackModel>(Vector2.zero);
var forAllNode = forAllStack.CreateLoopNode(update, 0) as ForAllEntitiesNodeModel;
Assert.That(forAllNode, Is.Not.Null);
GraphModel.CreateEdge(forAllNode.InputPort, query2Instance.OutputPort);
GraphModel.CreateEdge(forAllStack.InputPort, forAllNode.OutputPort);
// entity from query 1
var entity1 = graph.CreateVariableNode(
update.FunctionParameterModels.Single(
p => p.DataType == typeof(Entity).GenerateTypeHandle(graph.Stencil)),
Vector2.zero);
// entity from query 2
var entity2 = graph.CreateVariableNode(
forAllStack.FunctionParameterModels.Single(
p => p.DataType == typeof(Entity).GenerateTypeHandle(graph.Stencil)),
Vector2.zero);
// set a new Translation to entities of query1
var setTranslation = forAllStack.CreateStackedNode <SetComponentNodeModel>("set translation");
setTranslation.ComponentType = typeof(Translation).GenerateTypeHandle(graph.Stencil);
setTranslation.DefineNode();
((FloatConstantModel)setTranslation.InputConstantsById["z"]).value = 10f;
graph.CreateEdge(setTranslation.EntityPort, entity1.OutputPort);
// set a new Scale to entities of query2
var setScale = forAllStack.CreateStackedNode <SetComponentNodeModel>("set scale");
setScale.ComponentType = typeof(Scale).GenerateTypeHandle(graph.Stencil);
setScale.DefineNode();
((FloatConstantModel)setScale.InputConstantsById["Value"]).value = 30f;
graph.CreateEdge(setScale.EntityPort, entity2.OutputPort);
},
(manager, index, entity) =>
{
if (index % 2 == 0)
{
manager.AddComponentData(entity, new Translation());
}
else
{
manager.AddComponentData(entity, new Scale());
}
},
(manager, index, entity) =>
{
if (manager.HasComponent <Translation>(entity))
{
Assert.That(manager.GetComponentData <Translation>(entity).Value.z, Is.EqualTo(10f));
}
if (manager.HasComponent <Scale>(entity))
{
Assert.That(manager.GetComponentData <Scale>(entity).Value, Is.EqualTo(30f));
}
}
);
}
public GraphsonSupportTest(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
{
_g = g
.ConfigureEnvironment(env => env.UseModel(GraphModel.FromBaseTypes <Vertex, Edge>(lookup => lookup
.IncludeAssembliesOfBaseTypes())));
}
public BreadthFirstSearchAlgorithm(GraphModel model)
{
_model = model;
_path = new Dictionary <int, int>();
}
public void Test_EditPropertyGroupNodeAction_AddRemove([Values] TestingMode mode)
{
IConstantNodeModel constant = GraphModel.CreateConstantNode("toto", typeof(Vector3).GenerateTypeHandle(Stencil), Vector2.zero);
GetPropertyGroupNodeModel property = GraphModel.CreateGetPropertyGroupNode(Vector2.zero);
GraphModel.CreateEdge(property.InstancePort, constant.OutputPort);
Type type = typeof(GameObject);
MemberInfo memberInfo = type.GetMembers()[0];
var newMember = new TypeMember
{
Path = new List <string> {
memberInfo.Name
},
Type = memberInfo.GetUnderlyingType().GenerateTypeHandle(Stencil)
};
TestPrereqActionPostreq(mode,
() =>
{
property = (GetPropertyGroupNodeModel)GraphModel.NodesByGuid[property.Guid];
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(property.GetPortsForMembers().Count(), Is.EqualTo(0));
Assert.That(property.OutputsByDisplayOrder.Count(), Is.EqualTo(0));
return(new EditPropertyGroupNodeAction(
EditPropertyGroupNodeAction.EditType.Add,
property,
newMember));
},
() =>
{
property = (GetPropertyGroupNodeModel)GraphModel.NodesByGuid[property.Guid];
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(property.GetPortsForMembers().Count(), Is.EqualTo(1));
Assert.That(property.OutputsByDisplayOrder.Count(), Is.EqualTo(1));
});
TestPrereqActionPostreq(mode,
() =>
{
property = (GetPropertyGroupNodeModel)GraphModel.NodesByGuid[property.Guid];
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(property.GetPortsForMembers().Count(), Is.EqualTo(1));
Assert.That(property.OutputsByDisplayOrder.Count(), Is.EqualTo(1));
return(new EditPropertyGroupNodeAction(
EditPropertyGroupNodeAction.EditType.Remove,
property,
newMember));
},
() =>
{
property = (GetPropertyGroupNodeModel)GraphModel.NodesByGuid[property.Guid];
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(property.GetPortsForMembers().Count(), Is.EqualTo(0));
Assert.That(property.OutputsByDisplayOrder.Count(), Is.EqualTo(0));
});
}
public void Test_BypassNodeAction([Values] TestingMode mode)
{
var constantA = GraphModel.CreateConstantNode("constantA", typeof(float).GenerateTypeHandle(Stencil), Vector2.zero);
var binary0 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
var binary1 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
GraphModel.CreateEdge(binary0.InputPortA, constantA.OutputPort);
GraphModel.CreateEdge(binary1.InputPortA, binary0.OutputPort);
var constantB = GraphModel.CreateConstantNode("constantB", typeof(float).GenerateTypeHandle(Stencil), Vector2.zero);
var binary2 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
var binary3 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
GraphModel.CreateEdge(binary2.InputPortA, constantB.OutputPort);
GraphModel.CreateEdge(binary3.InputPortA, binary2.OutputPort);
var constantC = GraphModel.CreateConstantNode("constantC", typeof(float).GenerateTypeHandle(Stencil), Vector2.zero);
var binary4 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
var binary5 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
GraphModel.CreateEdge(binary4.InputPortA, constantC.OutputPort);
GraphModel.CreateEdge(binary5.InputPortA, binary4.OutputPort);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(9));
Assert.That(GetEdgeCount(), Is.EqualTo(6));
Assert.That(binary0.InputPortA, Is.ConnectedTo(constantA.OutputPort));
Assert.That(binary1.InputPortA, Is.ConnectedTo(binary0.OutputPort));
Assert.That(binary2.InputPortA, Is.ConnectedTo(constantB.OutputPort));
Assert.That(binary3.InputPortA, Is.ConnectedTo(binary2.OutputPort));
Assert.That(binary4.InputPortA, Is.ConnectedTo(constantC.OutputPort));
Assert.That(binary5.InputPortA, Is.ConnectedTo(binary4.OutputPort));
return(new BypassNodeAction(binary0));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(9));
Assert.That(GetEdgeCount(), Is.EqualTo(5));
Assert.That(binary1.InputPortA, Is.ConnectedTo(constantA.OutputPort));
Assert.That(binary2.InputPortA, Is.ConnectedTo(constantB.OutputPort));
Assert.That(binary3.InputPortA, Is.ConnectedTo(binary2.OutputPort));
Assert.That(binary4.InputPortA, Is.ConnectedTo(constantC.OutputPort));
Assert.That(binary5.InputPortA, Is.ConnectedTo(binary4.OutputPort));
});
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(9));
Assert.That(GetEdgeCount(), Is.EqualTo(5));
Assert.That(binary1.InputPortA, Is.ConnectedTo(constantA.OutputPort));
Assert.That(binary2.InputPortA, Is.ConnectedTo(constantB.OutputPort));
Assert.That(binary3.InputPortA, Is.ConnectedTo(binary2.OutputPort));
Assert.That(binary4.InputPortA, Is.ConnectedTo(constantC.OutputPort));
Assert.That(binary5.InputPortA, Is.ConnectedTo(binary4.OutputPort));
return(new BypassNodeAction(binary2, binary4));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(9));
Assert.That(GetEdgeCount(), Is.EqualTo(3));
Assert.That(binary1.InputPortA, Is.ConnectedTo(constantA.OutputPort));
Assert.That(binary3.InputPortA, Is.ConnectedTo(constantB.OutputPort));
Assert.That(binary5.InputPortA, Is.ConnectedTo(constantC.OutputPort));
});
}
public MyProblemFitness(GraphModel gm)
{
graphModel = gm;
}
/// <summary>
/// Builds a graph according provided informations.
/// </summary>
/// <param name="graphInfo">Informations about the Graph. Format 'AB9'</param>
public void BuildGraph(string graphInfo)
{
graph = GraphBusiness.BuildGraph(graphInfo);
}
void TestExtractMacro(IEnumerable <IGraphElementModel> toExtract, IO inputs, IO outputs)
{
MacroRefNodeModel macroRef = GraphModel.ExtractNodesAsMacro(m_MacroGraphModel, Vector2.zero, toExtract);
Assert.That(macroRef.Macro, Is.EqualTo(m_MacroGraphModel));
inputs.Check(m_MacroGraphModel, macroRef.InputVariablePorts.ToList(), ModifierFlags.ReadOnly);
outputs.Check(m_MacroGraphModel, macroRef.OutputVariablePorts.ToList(), ModifierFlags.WriteOnly);
CompilationResult compilationResult = GraphModel.Compile(AssemblyType.None, GraphModel.CreateTranslator(), CompilationOptions.Default);
Assert.That(
compilationResult.status,
Is.EqualTo(CompilationStatus.Succeeded));
Debug.Log(compilationResult.sourceCode[0]);
}
public void Test_MoveMultipleStackedNodesAction_ToDifferentStack([Values] TestingMode mode)
{
var stack0 = GraphModel.CreateStack(string.Empty, Vector2.zero);
var nodeA = stack0.CreateStackedNode <Type0FakeNodeModel>("A");
var nodeB = stack0.CreateStackedNode <Type0FakeNodeModel>("B");
var nodeC = stack0.CreateStackedNode <Type0FakeNodeModel>("C");
var stack1 = GraphModel.CreateStack(string.Empty, Vector2.zero);
var nodeD = stack1.CreateStackedNode <Type0FakeNodeModel>("D");
var nodeE = stack1.CreateStackedNode <Type0FakeNodeModel>("E");
var nodeF = stack1.CreateStackedNode <Type0FakeNodeModel>("F");
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(stack0.NodeModels.Count(), Is.EqualTo(3));
Assert.That(nodeA, Has.IndexInStack(0, stack0));
Assert.That(nodeB, Has.IndexInStack(1, stack0));
Assert.That(nodeC, Has.IndexInStack(2, stack0));
Assert.That(stack1.NodeModels.Count(), Is.EqualTo(3));
Assert.That(nodeD, Has.IndexInStack(0, stack1));
Assert.That(nodeE, Has.IndexInStack(1, stack1));
Assert.That(nodeF, Has.IndexInStack(2, stack1));
return(new MoveStackedNodesAction(new [] { nodeA, nodeC }, stack1, 1));
},
() =>
{
Assert.That(stack0.NodeModels.Count(), Is.EqualTo(1));
Assert.That(nodeB, Has.IndexInStack(0, stack0));
Assert.That(stack1.NodeModels.Count(), Is.EqualTo(5));
Assert.That(nodeD, Has.IndexInStack(0, stack1));
Assert.That(nodeA, Has.IndexInStack(1, stack1));
Assert.That(nodeC, Has.IndexInStack(2, stack1));
Assert.That(nodeE, Has.IndexInStack(3, stack1));
Assert.That(nodeF, Has.IndexInStack(4, stack1));
});
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(stack0.NodeModels.Count(), Is.EqualTo(1));
Assert.That(nodeB, Has.IndexInStack(0, stack0));
Assert.That(stack1.NodeModels.Count(), Is.EqualTo(5));
Assert.That(nodeD, Has.IndexInStack(0, stack1));
Assert.That(nodeA, Has.IndexInStack(1, stack1));
Assert.That(nodeC, Has.IndexInStack(2, stack1));
Assert.That(nodeE, Has.IndexInStack(3, stack1));
Assert.That(nodeF, Has.IndexInStack(4, stack1));
return(new MoveStackedNodesAction(new [] { nodeF, nodeD }, stack0, 0));
},
() =>
{
Assert.That(stack0.NodeModels.Count(), Is.EqualTo(3));
Assert.That(nodeF, Has.IndexInStack(0, stack0));
Assert.That(nodeD, Has.IndexInStack(1, stack0));
Assert.That(nodeB, Has.IndexInStack(2, stack0));
Assert.That(stack1.NodeModels.Count(), Is.EqualTo(3));
Assert.That(nodeA, Has.IndexInStack(0, stack1));
Assert.That(nodeC, Has.IndexInStack(1, stack1));
Assert.That(nodeE, Has.IndexInStack(2, stack1));
});
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(stack0.NodeModels.Count(), Is.EqualTo(3));
Assert.That(nodeF, Has.IndexInStack(0, stack0));
Assert.That(nodeD, Has.IndexInStack(1, stack0));
Assert.That(nodeB, Has.IndexInStack(2, stack0));
Assert.That(stack1.NodeModels.Count(), Is.EqualTo(3));
Assert.That(nodeA, Has.IndexInStack(0, stack1));
Assert.That(nodeC, Has.IndexInStack(1, stack1));
Assert.That(nodeE, Has.IndexInStack(2, stack1));
return(new MoveStackedNodesAction(new [] { nodeF, nodeC }, stack1, 2));
},
() =>
{
Assert.That(stack0.NodeModels.Count(), Is.EqualTo(2));
Assert.That(nodeD, Has.IndexInStack(0, stack0));
Assert.That(nodeB, Has.IndexInStack(1, stack0));
Assert.That(stack1.NodeModels.Count(), Is.EqualTo(4));
Assert.That(nodeA, Has.IndexInStack(0, stack1));
Assert.That(nodeE, Has.IndexInStack(1, stack1));
Assert.That(nodeF, Has.IndexInStack(2, stack1));
Assert.That(nodeC, Has.IndexInStack(3, stack1));
});
}
public void Test_BypassNodeAction_Throw()
{
var constantA = GraphModel.CreateConstantNode("constantA", typeof(float).GenerateTypeHandle(Stencil), Vector2.zero);
Assert.Throws <InvalidOperationException>(() => m_Store.Dispatch(new BypassNodeAction(constantA)));
}
public void Test_EmbeddedConstantIsUsedWhenDisconnected([Values] TestingMode mode)
{
const float outerValue = 42f;
const float innerValue = 347f;
// make sure that we really test values that are not default
Assume.That(outerValue, Is.Not.EqualTo(default(float)));
Assume.That(innerValue, Is.Not.EqualTo(default(float)));
var stencil = GraphModel.Stencil;
FunctionModel a = GraphModel.CreateFunction("A", Vector2.zero);
// Debug.Log(...)
MethodInfo logMethod = typeof(Debug).GetMethod(nameof(Debug.Log), new[] { typeof(object) });
Assume.That(logMethod, Is.Not.Null);
FunctionCallNodeModel log = a.CreateStackedNode <FunctionCallNodeModel>("Log", 0, SpawnFlags.Default, n => n.MethodInfo = logMethod);
var logParameterPort = log.GetParameterPorts().Single();
// Math.Abs(...)
MethodInfo absMethod = typeof(Mathf).GetMethod(nameof(Mathf.Abs), new[] { typeof(float) });
Assume.That(absMethod, Is.Not.Null);
FunctionCallNodeModel abs = GraphModel.CreateNode <FunctionCallNodeModel>("Abs", Vector2.zero, SpawnFlags.Default, n => n.MethodInfo = absMethod);
var absParameterPort = abs.GetParameterPorts().Single();
((FloatConstantModel)abs.InputConstantsById[absParameterPort.UniqueId]).value = innerValue;
GraphModel.CreateEdge(logParameterPort, abs.OutputPort);
// float
IConstantNodeModel outerFloat = GraphModel.CreateConstantNode("float42", typeof(float).GenerateTypeHandle(stencil), Vector2.zero);
Assume.That(outerFloat, Is.Not.Null);
((FloatConstantModel)outerFloat).value = outerValue;
string innerFloatString = SyntaxFactory.LiteralExpression(
SyntaxKind.NumericLiteralExpression,
SyntaxFactory.Literal(innerValue)).ToFullString();
string outerFloatString = SyntaxFactory.LiteralExpression(
SyntaxKind.NumericLiteralExpression,
SyntaxFactory.Literal(outerValue)).ToFullString();
TestPrereqActionPostreq(mode,
() =>
{
// outer float disconnected, check that we use the inner value
SyntaxNode astRoot = CompileCurrentGraphModel();
LiteralExpressionSyntax literalInsideLogAbs = GetLiteralInsideLogAbs(astRoot);
Assert.That(literalInsideLogAbs.ToFullString(), Is.EqualTo(innerFloatString));
return(new CreateEdgeAction(absParameterPort, outerFloat.OutputPort));
},
() =>
{
// outer float connected, check that we use the outer value
SyntaxNode astRoot = CompileCurrentGraphModel();
LiteralExpressionSyntax literalInsideLogAbs = GetLiteralInsideLogAbs(astRoot);
Assert.That(literalInsideLogAbs.ToFullString(), Is.EqualTo(outerFloatString));
});
}
public static MacroRefNodeModel CreateMacroRefNode(this IGraphModel graphModel, GraphModel macroGraphModel,
Vector2 position, SpawnFlags spawnFlags = SpawnFlags.Default, GUID?guid = null)
{
return(graphModel.CreateNode <MacroRefNodeModel>(graphModel.AssetModel.Name, position, spawnFlags, n => n.GraphAssetModel = (GraphAssetModel)macroGraphModel.AssetModel, guid));
}
public IEnumerator HighlightIsAppliedToVariables()
{
var actions = RunTestFor <VariableNodeModel, TokenNode>(TypeHandle.Int,
(m, p) => (VariableNodeModel)GraphModel.CreateVariableNode(m, p));
while (actions.MoveNext())
{
yield return(null);
}
}
public GraphViewModel()
{
var graph = new GraphModel();
Host = graph.Picture;
}
/// <summary>
/// Process data to create the lines
/// </summary>
/// <param name="graphData"></param>
private void ProcessData(GraphModel graphData)
{
if (graphData?.result == null || graphData.result.Length <= 0)
{
return;
}
var dateTimeList = graphData.result.Select(item => item.getDateTime()).ToList();
var temperatureList = graphData.result.Select(item => item.getTemperature()).Where(item => item.HasValue)
.ToList();
if (temperatureList != null && temperatureList.Count > 0)
{
var line = CreateLine("Temperature", temperatureList, dateTimeList);
_model.Series.Add(line);
}
var humidityList = graphData.result.Select(item => item.getHumidity()).Where(item => item.HasValue)
.ToList();
if (humidityList != null && humidityList.Count > 0)
{
var line = CreateLine("Humidity", humidityList, dateTimeList);
_model.Series.Add(line);
}
var setPointList = graphData.result.Select(item => item.getSetPoint()).Where(item => item.HasValue)
.ToList();
if (setPointList != null && setPointList.Count > 0)
{
var line = CreateLine("SetPoint", setPointList, dateTimeList);
_model.Series.Add(line);
}
var barometerList = graphData.result.Select(item => item.getBarometer()).Where(item => item.HasValue)
.ToList();
if (barometerList != null && barometerList.Count > 0)
{
var line = CreateLine("Barometer", barometerList, dateTimeList);
_model.Series.Add(line);
}
var percentageList = graphData.result.Select(item => item.getValue()).Where(item => item.HasValue).ToList();
if (percentageList != null && percentageList.Count > 0)
{
var line = CreateLine("Percentage", percentageList, dateTimeList);
_model.Series.Add(line);
}
var secondValueList = graphData.result.Select(item => item.getSecondValue()).Where(item => item.HasValue)
.ToList();
if (secondValueList != null && secondValueList.Count > 0)
{
var line = CreateLine("Second Percentage", secondValueList, dateTimeList);
_model.Series.Add(line);
}
var PercentageMinList = graphData.result.Select(item => item.getValueMin()).Where(item => item.HasValue).ToList();
if (PercentageMinList != null && PercentageMinList.Count > 0)
{
var line = CreateLine("Min Percentage", PercentageMinList, dateTimeList);
_model.Series.Add(line);
}
var PercentageMaxList = graphData.result.Select(item => item.getValueMax()).Where(item => item.HasValue).ToList();
if (PercentageMaxList != null && PercentageMaxList.Count > 0)
{
var line = CreateLine("Max Percentage", PercentageMaxList, dateTimeList);
_model.Series.Add(line);
}
var PercentageAvgList = graphData.result.Select(item => item.getValueAvg()).Where(item => item.HasValue).ToList();
if (PercentageAvgList != null && PercentageAvgList.Count > 0)
{
var line = CreateLine("Avg Percentage", PercentageAvgList, dateTimeList);
_model.Series.Add(line);
}
var powerDeliveryList = graphData.result.Select(item => item.getPowerDelivery())
.Where(item => item.HasValue).ToList();
if (powerDeliveryList != null && powerDeliveryList.Count > 0)
{
var line = CreateLine("Power Delivery", powerDeliveryList, dateTimeList);
_model.Series.Add(line);
}
var powerUsageList = graphData.result.Select(item => item.getPowerUsage()).Where(item => item.HasValue)
.ToList();
if (powerUsageList != null && powerUsageList.Count > 0)
{
var line = CreateLine("Power Usage", powerUsageList, dateTimeList);
_model.Series.Add(line);
}
var counterList = graphData.result.Select(item => item.getCounter()).Where(item => item.HasValue).ToList();
if (counterList != null && counterList.Count > 0)
{
var line = CreateLine("Counter", counterList, dateTimeList);
_model.Series.Add(line);
}
var speedList = graphData.result.Select(item => item.getSpeed()).Where(item => item.HasValue).ToList();
if (speedList != null && speedList.Count > 0)
{
var line = CreateLine("Speed", speedList, dateTimeList);
_model.Series.Add(line);
}
var directionList = graphData.result.Select(item => item.getDirection()).Where(item => item.HasValue)
.ToList();
if (directionList != null && directionList.Count > 0)
{
var line = CreateLine("Direction", directionList, dateTimeList);
_model.Series.Add(line);
}
var sunPowerList = graphData.result.Select(item => item.getSunPower()).Where(item => item.HasValue)
.ToList();
if (sunPowerList != null && sunPowerList.Count > 0)
{
var line = CreateLine("SunPower", sunPowerList, dateTimeList);
_model.Series.Add(line);
}
var usageList = graphData.result.Select(item => item.getUsage()).Where(item => item.HasValue).ToList();
if (usageList != null && usageList.Count > 0)
{
var line = CreateLine("Usage", usageList, dateTimeList);
_model.Series.Add(line);
}
var rainList = graphData.result.Select(item => item.getRain()).Where(item => item.HasValue).ToList();
if (rainList != null && rainList.Count > 0)
{
var line = CreateLine("Rain", rainList, dateTimeList);
_model.Series.Add(line);
}
var co2List = graphData.result.Select(item => item.getCo2()).Where(item => item.HasValue).ToList();
if (co2List != null && co2List.Count > 0)
{
var line = CreateLine("Co2", co2List, dateTimeList);
_model.Series.Add(line);
}
var co2MinList = graphData.result.Select(item => item.getCo2Min()).Where(item => item.HasValue).ToList();
if (co2MinList != null && co2MinList.Count > 0)
{
var line = CreateLine("Min Co2", co2MinList, dateTimeList);
_model.Series.Add(line);
}
var co2MaxList = graphData.result.Select(item => item.getCo2Max()).Where(item => item.HasValue).ToList();
if (co2MaxList != null && co2MaxList.Count > 0)
{
var line = CreateLine("Max Co2", co2MaxList, dateTimeList);
_model.Series.Add(line);
}
var luxList = graphData.result.Select(item => item.getLux()).Where(item => item.HasValue).ToList();
if (luxList != null && luxList.Count > 0)
{
var line = CreateLine("Lux", luxList, dateTimeList);
_model.Series.Add(line);
}
var luxMinList = graphData.result.Select(item => item.getLuxMin()).Where(item => item.HasValue).ToList();
if (luxMinList != null && luxMinList.Count > 0)
{
var line = CreateLine("Min Lux", luxMinList, dateTimeList);
_model.Series.Add(line);
}
var luxMaxList = graphData.result.Select(item => item.getLuxMax()).Where(item => item.HasValue).ToList();
if (luxMaxList != null && luxMaxList.Count > 0)
{
var line = CreateLine("Max Lux", luxMaxList, dateTimeList);
_model.Series.Add(line);
}
var luxAvgList = graphData.result.Select(item => item.getLuxAvg()).Where(item => item.HasValue).ToList();
if (luxAvgList != null && luxAvgList.Count > 0)
{
var line = CreateLine("Avg Lux", luxAvgList, dateTimeList);
_model.Series.Add(line);
}
MapTemperatureLines(graphData, dateTimeList);
}
public void Test_UpdateRankAction([Values] TestingMode mode)
{
TypeHandle intType = typeof(int).GenerateTypeHandle(Stencil);
TypeHandle intArrayType = intType.MakeVsArrayType(Stencil);
VariableDeclarationModel declaration = GraphModel.CreateGraphVariableDeclaration("decl0", typeof(int).GenerateTypeHandle(Stencil), true);
GraphModel.CreateVariableNode(declaration, Vector2.zero);
GraphModel.CreateVariableNode(declaration, Vector2.zero);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
Assert.That(declaration.DataType.IsVsArrayType(Stencil), Is.False);
Assert.That(((ConstantNodeModel)declaration.InitializationModel).Type, Is.EqualTo(typeof(int)));
foreach (var variableNodeModel in GraphModel.NodeModels.OfType <VariableNodeModel>())
{
Assert.That(variableNodeModel.OutputPort.DataType, Is.EqualTo(intType));
}
return(new UpdateTypeRankAction(declaration, true));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
Assert.That(declaration.DataType.IsVsArrayType(Stencil), Is.True);
Assert.That(((ConstantNodeModel)declaration.InitializationModel), Is.Null, "Array type have no initialization values");
foreach (var variableNodeModel in GraphModel.NodeModels.OfType <VariableNodeModel>())
{
Assert.That(variableNodeModel.OutputPort.DataType, Is.EqualTo(intArrayType));
}
});
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
Assert.That(declaration.DataType.IsVsArrayType(Stencil), Is.True);
Assert.That(((ConstantNodeModel)declaration.InitializationModel), Is.Null, "Array type have no initialization values");
foreach (var variableNodeModel in GraphModel.NodeModels.OfType <VariableNodeModel>())
{
Assert.That(variableNodeModel.OutputPort.DataType, Is.EqualTo(intArrayType));
}
return(new UpdateTypeRankAction(declaration, false));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
Assert.That(declaration.DataType.IsVsArrayType(Stencil), Is.False);
Assert.That(((ConstantNodeModel)declaration.InitializationModel), Is.Not.Null);
foreach (var variableNodeModel in GraphModel.NodeModels.OfType <VariableNodeModel>())
{
Assert.That(variableNodeModel.OutputPort.DataType, Is.EqualTo(intType));
}
});
}
public void OnEventTest([Values] CodeGenMode mode)
{
SetupTestGraphMultipleFrames(mode, g =>
{
ComponentQueryDeclarationModel query = GraphModel.CreateComponentQuery("g1");
TypeHandle positionType = typeof(Translation).GenerateTypeHandle(Stencil);
query.AddComponent(Stencil, positionType, ComponentDefinitionFlags.None);
IVariableModel queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero);
TypeHandle eventTypeHandle = typeof(UnitTestEvent).GenerateTypeHandle(Stencil);
OnEventNodeModel onUpdateModel = GraphModel.CreateNode <OnEventNodeModel>("update", Vector2.zero, SpawnFlags.Default, n => n.EventTypeHandle = eventTypeHandle);
GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort);
SetPropertyGroupNodeModel set = onUpdateModel.CreateStackedNode <SetPropertyGroupNodeModel>("set", 0);
var member = new TypeMember(TypeHandle.Float, new List <string> {
nameof(Translation.Value), nameof(Translation.Value.x)
});
set.AddMember(member);
IVariableModel posComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero);
GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort);
((FloatConstantModel)set.InputConstantsById[member.GetId()]).value = 2f;
},
// Add translation to even entities
EachEntity((manager, i, e) =>
{
if (e.Index % 2 == 0)
{
manager.AddComponent(e, typeof(Translation));
}
}),
// Send event on these
EachEntity(del: (manager, i, e) =>
{
if (e.Index % 2 == 0)
{
Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(0f));
}
else
{
Assert.IsFalse(manager.HasComponent <Translation>(e));
}
// Add event on all entities
manager.AddBuffer <UnitTestEvent>(e).Add(new UnitTestEvent());
}),
// Event handler should set t.x to 2
EachEntity((manager, i, e) =>
{
if (e.Index % 2 == 0)
{
Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(2f));
}
}),
// Reset translation
EachEntity((manager, i, e) =>
{
if (e.Index % 2 == 0)
{
var t = manager.GetComponentData <Translation>(e);
t.Value.x = 0;
manager.SetComponentData(e, t);
}
}),
// As we send events manually, the event system is not running and won't cleanup events.
// Event handler should set t.x to 2 again
EachEntity((manager, i, e) =>
{
if (e.Index % 2 == 0)
{
Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(2f));
}
})
);
}