protected override void Start()
{
edgesCount = nodesCount - 1;
var nodes = new GPUNode[nodesCount];
for (int i = 0; i < nodesCount; i++)
{
var n = nodes[i];
var p = new Vector3(Random.value - 0.5f, i * edgeLength, Random.value - 0.5f);
n.position = n.prev = p;
n.decay = 1f;
nodes[i] = n;
}
var edges = new GPUEdge[edgesCount];
for (int i = 0; i < edgesCount; i++)
{
var e = edges[i];
e.a = i;
e.b = i + 1;
e.length = edgeLength;
edges[i] = e;
}
simulator = new GPUVerletSimulator(nodes, edges);
base.Start();
}
private void SanityCheckCumulativeFrequencies()
{
GPUDecisionLearnerContext context = Context.ContextBuffer.Read()[0];
GPUAttributeDataPoint[] attributePoints = _sortedDataPointsPerAxis.Read();
float[] cumulativeFrequenciesPerAxisArray = _cumulativeFrequenciesPerAxis.Read();
for (int openNodeIndex = 0; openNodeIndex < context.NumOpenNodes; ++openNodeIndex)
{
int nodeId = Context.OpenNodeIds[openNodeIndex];
if (nodeId == -1)
{
continue;
}
GPUNode node = Context.Nodes[nodeId];
for (int axisId = 0; axisId < Context.NumAttributeAxes; ++axisId)
{
double[] cumulativeFrequencies = new double[GPUConstants.MaxClasses];
for (int i = 0; i < node.RangeLength; ++i)
{
int index = node.RangeStart + i;
GPUAttributeDataPoint attributePoint = attributePoints[axisId * Context.DataPoints.Count + index];
cumulativeFrequencies[attributePoint.Class] += attributePoint.Weight;
for (int classId = 0; classId < GPUConstants.MaxClasses; ++classId)
{
double cumulativeFrequency = cumulativeFrequenciesPerAxisArray[
axisId * Context.DataPoints.Count * GPUConstants.MaxClasses +
index * GPUConstants.MaxClasses +
classId];
Assert.AreEqual(cumulativeFrequencies[classId], cumulativeFrequency, 1.0);
}
}
}
}
}
private void SanityCheckSplit(CudaArray <GPUSplit> bestSplits)
{
GPUSplit[] bestSplitsArray = bestSplits.Read();
GPUDecisionLearnerContext context = Context.ContextBuffer.Read()[0];
int[] dataPointIds = Context.DataPointIds.Read();
for (int openNodeIndex = 0; openNodeIndex < context.NumOpenNodes; ++openNodeIndex)
{
int nodeId = Context.OpenNodeIds[openNodeIndex];
if (nodeId == -1)
{
continue;
}
GPUSplit bestSplit = bestSplitsArray[openNodeIndex];
if (bestSplit.SplitType != GPUConstants.SplitType_Categorical)
{
continue;
}
GPUNode parentNode = Context.Nodes[nodeId];
GPUNode leftNode = Context.Nodes[parentNode.LeftChild];
GPUNode rightNode = Context.Nodes[parentNode.RightChild];
Assert.AreEqual(parentNode.RangeStart, leftNode.RangeStart);
Assert.AreEqual(leftNode.RangeStart + leftNode.RangeLength, rightNode.RangeStart);
Assert.AreEqual(parentNode.RangeLength, leftNode.RangeLength + rightNode.RangeLength);
for (int i = 0; i < parentNode.RangeLength; ++i)
{
int index = parentNode.RangeStart + i;
IDataPoint dataPoint = Context.DataPoints[dataPointIds[index]];
bool goRight = (dataPoint.Categories[bestSplit.Axis] & bestSplit.SplitCategories) != 0;
if (goRight)
{
Assert.IsTrue(rightNode.RangeStart <= index && index <= rightNode.RangeStart + rightNode.RangeLength);
}
else
{
Assert.IsTrue(leftNode.RangeStart <= index && index <= leftNode.RangeStart + leftNode.RangeLength);
}
}
}
}
protected void Start()
{
var nodes = new GPUNode[tentaclesCount * divisionsCount];
var edges = new List <GPUEdge>();
for (int y = 0; y < tentaclesCount; y++)
{
var yoff = y * divisionsCount;
for (int x = 0; x < divisionsCount - 1; x++)
{
var idx = yoff + x;
var e = new GPUEdge(idx, idx + 1, edgeLength);
edges.Add(e);
}
}
simulator = new GPUVerletSimulator(nodes, edges.ToArray());
tipMesh = BuildTipMesh(1f);
tentacleMesh = BuildTentacleMesh(divisionsCount, radialSegments);
uint[] args = new uint[5] {
0, 0, 0, 0, 0
};
args[0] = tipMesh.GetIndexCount(0);
args[1] = (uint)tentaclesCount;
tipArgsBuffer = new ComputeBuffer(1, sizeof(uint) * args.Length, ComputeBufferType.IndirectArguments);
tipArgsBuffer.SetData(args);
args[0] = tentacleMesh.GetIndexCount(0);
args[1] = (uint)tentaclesCount;
tentacleArgsBuffer = new ComputeBuffer(1, sizeof(uint) * args.Length, ComputeBufferType.IndirectArguments);
tentacleArgsBuffer.SetData(args);
Init();
}
protected override void Start()
{
nodesCount = rows * columns;
var nodes = new GPUNode[nodesCount];
var hCols = columns * 0.5f;
for (int y = 0; y < rows; y++)
{
bool stable = (y == 0);
var yoff = y * columns;
for (int x = 0; x < columns; x++)
{
var idx = yoff + x;
var n = nodes[idx];
n.position = n.prev =
(Vector3.forward * y * edgeLength) +
(Vector3.right * (x - hCols) * edgeLength);
n.decay = 1f;
n.stable = (uint)(stable ? 1 : 0);
nodes[idx] = n;
}
}
var edges = new List <GPUEdge>();
for (int y = 0; y < rows; y++)
{
var yoff = y * columns;
if (y != rows - 1)
{
for (int x = 0; x < columns; x++)
{
var idx = yoff + x;
if (x != columns - 1)
{
var right = idx + 1;
edges.Add(new GPUEdge(idx, right, edgeLength));
}
var down = idx + columns;
edges.Add(new GPUEdge(idx, down, edgeLength));
}
}
else
{
for (int x = 0; x < columns - 1; x++)
{
var idx = yoff + x;
var right = idx + 1;
edges.Add(new GPUEdge(idx, right, edgeLength));
}
}
}
edgesCount = edges.Count;
simulator = new GPUVerletSimulator(nodes, edges.ToArray());
base.Start();
}
