public void CopyToManagedArrayCopiesElements()
{
using (NativeArray2D <int> src = CreateArray(2, 3))
{
NativeArray2D <int> srcAlias = src;
srcAlias[0, 0] = 100;
srcAlias[0, 1] = 200;
srcAlias[0, 2] = 300;
srcAlias[1, 0] = 400;
srcAlias[1, 1] = 500;
srcAlias[1, 2] = 600;
int[,] dest = new int[2, 3];
src.CopyTo(dest);
Assert.That(dest[0, 0], Is.EqualTo(src[0, 0]));
Assert.That(dest[0, 1], Is.EqualTo(src[0, 1]));
Assert.That(dest[0, 2], Is.EqualTo(src[0, 2]));
Assert.That(dest[1, 0], Is.EqualTo(src[1, 0]));
Assert.That(dest[1, 1], Is.EqualTo(src[1, 1]));
Assert.That(dest[1, 2], Is.EqualTo(src[1, 2]));
}
}
public NativeArray2DDebugView(NativeArray2D <T> array)
{
m_array = array;
}
public bool Equals(NativeArray2D <T> other)
{
return(m_data == other.m_data);
}
public ColorData(Color[] data, int dataLengthX, float threshold, bool useInterpolation)
{
this.data = new NativeArray2D <Color>(data, dataLengthX, data.Length / dataLengthX, Allocator.Persistent);
this.threshold = threshold;
this.useInterpolation = useInterpolation;
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
//Writeable.
NativeArray <PathFinding> pathfindingArray = chunk.GetNativeArray(pathFindingComponentHandle);
BufferAccessor <PathNode> pathNodeBufferAccessor = chunk.GetBufferAccessor(pathNodeBufferHandle);
//Read Only.
NativeArray <CurrentTarget> currentTargetArray = chunk.GetNativeArray(currentTargetComponentHandle);
NativeArray <Translation> translationArray = chunk.GetNativeArray(translationComponentHandle);
NativeArray <Entity> entities = chunk.GetNativeArray(entityType);
//Create a copy of the grid for this thread and chunk.
NativeArray2D <MapNode> gridCopy = new NativeArray2D <MapNode>(gridRef.Length0, gridRef.Length1, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
UnsafeUtility.MemCpy(gridCopy.GetUnsafePtr(), gridRef.GetUnsafePtrReadOnly(), gridRef.Length * sizeof(MapNode));
for (int indexInChunk = 0; indexInChunk < chunk.Count; ++indexInChunk)
{
//Writable.
PathFinding pathfinding = pathfindingArray[indexInChunk];
DynamicBuffer <PathNode> path = pathNodeBufferAccessor[indexInChunk];
//Read Only.
Entity entity = entities[indexInChunk];
CurrentTarget currentTarget = currentTargetArray[indexInChunk];
Translation translation = translationArray[indexInChunk];
bool hasPath = chunk.Has(hasPathComponentHandle);
if (!pathfinding.requestedPath)
{
//We only want to remove our has path component if we didn't request a new one, to avoid re-adding later in the job if we find a new path.
if (pathfinding.completedPath)
{
pathfinding.completedPath = false;
ecb.RemoveComponent <HasPathTag>(chunkIndex, entity);
pathfindingArray[indexInChunk] = pathfinding;
}
continue;
}
path.Clear();
pathfinding.currentIndexOnPath = 0;
pathfinding.completedPath = false;
pathfinding.requestedPath = false;
//Calculate the closest nodes to us and our target position.
//Don't search for path if we're already at our target node.
pathfinding.currentNode = FindNearestNode(translation.Value, gridCopy);
pathfinding.targetNode = FindNearestNode(currentTarget.targetData.targetPos, gridCopy);
if (pathfinding.targetNode.Equals(pathfinding.currentNode))
{
pathfindingArray[indexInChunk] = pathfinding;
continue;
}
CalculateGridH(gridCopy, ref pathfinding);
bool pathfound = SearchForPath(pathfinding.currentNode, pathfinding.targetNode, gridCopy);
if (pathfound)
{
ConstructPath(gridCopy, ref pathfinding, ref path);
if (!hasPath)
{
ecb.AddComponent <HasPathTag>(chunkIndex, entity);
}
}
else if (hasPath)
{
ecb.RemoveComponent <HasPathTag>(chunkIndex, entity);
}
pathfindingArray[indexInChunk] = pathfinding;
}
gridCopy.Dispose();
}
public void IsCreatedReturnsTrueForDefaultStruct()
{
NativeArray2D <int> array = default(NativeArray2D <int>);
Assert.That(array.IsCreated, Is.False);
}
private IEnumerator TrainingProcess()
{
var neuralNetworkConfig = new NetworkDescription()
{
Layers = new List <LayerParamaters>()
{
new LayerParamaters()
{
LayerType = ELayerType.Input,
NeuronCount = InputAttributeCount,
NeuronType = ENeruonType.Input
},
new LayerParamaters()
{
LayerType = ELayerType.Hidden,
NeuronCount = 64,
NeuronType = ENeruonType.Sigmoid
},
new LayerParamaters()
{
LayerType = ELayerType.Hidden,
NeuronCount = 16,
NeuronType = ENeruonType.Sigmoid
},
new LayerParamaters()
{
LayerType = ELayerType.Output,
NeuronCount = 1,
NeuronType = ENeruonType.Sigmoid
},
}
};
var neuralNetwork = new NeuralNetwork(neuralNetworkConfig);
neuralNetwork.InitNetworkWithRandomValues(-0.05f, 0.05f);
var networkEvaluator = new NetworkEvaluator(neuralNetwork);
var tempResult = new NativeArray2D <float>(1, 1);
//Test inital accuracy
TestInitialAccuracy(networkEvaluator, tempResult.Slice());
//Learn over a number of iterations
for (int epoch = 0; epoch < Epochs; epoch++)
{
//For each epoch, perform training
for (int tc = 0; tc < _dataset.TrainingSetSize; tc++)
{
_dataset.GetTrainingCase(tc, out var trainingInput, out var trainingResult);
//Evolve network
var jobHandle = networkEvaluator.GradientDescentBackpropigate(trainingInput, trainingResult, 1, out _);
jobHandle.Complete();
}
float totalError = 0.0f;
int totalCorrect = 0;
for (int i = 0; i < _dataset.TestingSetSize; i++)
{
_dataset.GetTestCase(i, out var trainingInput, out var trainingResult);
networkEvaluator.Evaluate(trainingInput, tempResult.Slice(), 1).Complete();
var error = Math.Abs(tempResult[0, 0] - trainingResult[0, 0]);
bool wasCorrect = error < 0.5f;
totalCorrect += wasCorrect ? 1 : 0;
totalError += error;
}
float averageError = totalError / (float)_dataset.TestingSetSize;
float accuracy = (float)totalCorrect / (float)_dataset.TestingSetSize;
//Forward test
Debug.Log($"Epoch {epoch}: Accuracy:{accuracy:P2} Average Error:{averageError:F4}");
yield return(null);
}
tempResult.BackingStore.Dispose();
}
public BoolData(NativeArray2D <bool> data)
{
this.data = data;
}
public BoolData(bool[,] data)
{
this.data = new NativeArray2D <bool>(data, Allocator.Persistent);
}
