public SWIGTYPE_p_float FloatArray(int n, float val)
{
var arr = new FloatArray(n);
for(int i = 0; i < n; i++)
arr.setitem(i, val);
return arr.cast();
}
public void CreateBuffers(int width_, int height_)
{
width = width_;
height = height_;
cpuBuffer = new FloatArray(width * height * 8);
// Initial test data for rendering
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
double coord = Math.Sin(x / 5.0) * 0.01;
//coord = sin(y/);
int index = (y * width + x) * 8;
// Position
cpuBuffer[index] = x / ((float)(width - 1));
cpuBuffer[index + 1] = (float)coord;
cpuBuffer[index + 2] = y / ((float)(height - 1));
// Normal
cpuBuffer[index + 3] = 1;
cpuBuffer[index + 4] = 0;
cpuBuffer[index + 5] = 0;
// TexCoords
cpuBuffer[index + 6] = y / ((float)(height - 1));
cpuBuffer[index + 7] = -x / ((float)(width - 1));
}
}
// Generate and fill index array for rendering
//indices = new IntArray(width * 3 * 2 + 2 + height * width * 3 * 2); // FIXME: what is this?
indices = new IntArray(3 * 2 * (width - 1) * (height - 1));
for (int y = 0; y < height - 1; y++)
{
for (int x = 0; x < width - 1; x++)
{
// *3 indices/triangle, *2 triangles/quad
int baseIndex = (x + y * (width - 1)) * 3 * 2;
indices[baseIndex] = x + y * width;
indices[baseIndex + 1] = x + 1 + y * width;
indices[baseIndex + 2] = x + width + y * width;
indices[baseIndex + 3] = indices[baseIndex + 1];
indices[baseIndex + 4] = indices[baseIndex] + (width + 1);
indices[baseIndex + 5] = indices[baseIndex + 2];
}
}
}
public void EdnaScorer()
{
var eval = new EdnaEvaluator(EdnaFeatures(), "ACGTACGT", ChannelArray().cast(), ModelParams());
var recursor = new SparseSseEdnaRecursor((int) Move.ALL_MOVES, new BandingOptions(0, 10));
var scorer = new SparseSseEdnaMutationScorer(eval, recursor);
scorer.ScoreMutation(MutationType.INSERTION, 3, 'A');
var counter = new EdnaCounts();
var intFeature = new IntFeature(10);
var resultArray = new FloatArray(5);
counter.DoCount(intFeature, eval, scorer, 3,4, resultArray.cast());
}
public ObjParser(String path)
{
FloatArray floatArray = new FloatArray();
TrianglesInput input = new TrianglesInput();
TrianglesP triP = new TrianglesP();
Source source = new Source();
source.mFloatArray = floatArray;
Triangles triangles = new Triangles();
triangles.mTriangleInputs.Add(input);
triangles.mTrianglesP = triP;
Vertices vertices = new Vertices();
Mesh mesh = new Mesh();
mesh.mSources.Add(source);
mesh.mTriangles.Add(triangles);
mesh.mVertices = vertices;
Geometry geometry = new Geometry();
geometry.mMeshes.Add(mesh);
mGeometryLibrary.mGeometries.Add(geometry);
}
public FloatArray Error(FloatArray targetOutputVector, FloatArray values)
{
return values - targetOutputVector;
}
public static FloatArray Relu(FloatArray x)
{
return(((x >= 0) * x) + .001f);
}
public static FloatArray Tanh(FloatArray x)
{
return(x.Tanh());
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(FloatArray obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
public FloatArray Derivate(FloatArray sum, FloatArray act)
{
return(1 - act * act);
}
public void AddAll(FloatArray array)
{
AddAll(array, 0, array.size);
}
public FloatArray Error(FloatArray target, FloatArray output)
{
return(output - target);
}
public FloatArray computePolygon(float[] points, int offset, int count, bool sorted)
{
int end = offset + count;
if (!sorted)
{
if (sortedPoints == null || sortedPoints.Length < count)
{
sortedPoints = new float[count];
}
Array.Copy(points, offset, sortedPoints, 0, count);
points = sortedPoints;
offset = 0;
sort(points, count);
}
FloatArray hull = this.hull;
hull.clear();
// Lower hull.
for (int i = offset; i < end; i += 2)
{
float x = points[i];
float y = points[i + 1];
while (hull.size >= 4 && ccw(x, y) <= 0)
{
hull.size -= 2;
}
hull.Add(x);
hull.Add(y);
}
List <float> l1 = new List <float>();
List <float> l2 = new List <float>();
float[] xx = new float[hull.size];
float[] yy = new float[hull.size];
l1 = hull.toArray().ToList();
l2 = hull.toArray().ToList();
for (int i = 0; i < l1.Count; i++)
{
if (i % 2 == 0)
{
xx[i / 2] = l1.ElementAt(i);
}
else
{
yy[(i - 1) / 2] = l1.ElementAt(i);
}
}
abajo = Punto.getArreglo(xx, yy);
FloatArray hullAUX = new FloatArray();
// Upper hull.
for (int i = end - 4, t = hull.size + 2; i >= offset; i -= 2)
{
float x = points[i];
float y = points[i + 1];
while (hull.size >= t && ccw(x, y) <= 0)
{
hull.size -= 2;
}
hull.Add(x);
hull.Add(y);
}
for (int i = end - 4, t = hullAUX.size + 2; i >= offset; i -= 2)
{
float x = points[i];
float y = points[i + 1];
while (hullAUX.size >= t && ccw(x, y) <= 0)
{
hullAUX.size -= 2;
}
hullAUX.Add(x);
hullAUX.Add(y);
}
l1 = hullAUX.toArray().ToList();
l2 = hullAUX.toArray().ToList();
for (int i = 0; i < l1.Count; i++)
{
if (i % 2 == 0)
{
xx[i / 2] = l1.ElementAt(i);
}
else
{
yy[(i - 1) / 2] = l1.ElementAt(i);
}
}
arriba = Punto.getArreglo(xx, yy);
Array.Sort(arriba, ConvexHull.compararPorAbsisa());
return(hull);
}
/** @see #computePolygon(float[], int, int, bool) */
public FloatArray computePolygon(FloatArray points, bool sorted)
{
return(computePolygon(points.items, 0, points.size, sorted));
}
/** Computes a hull the same as {@link #computePolygon(float[], int, int, bool)} but returns indices of the specified points. */
public IntArray computeIndices(float[] points, int offset, int count, bool sorted, bool yDown)
{
int end = offset + count;
if (!sorted)
{
if (sortedPoints == null || sortedPoints.Length < count)
{
sortedPoints = new float[count];
}
Array.Copy(points, offset, sortedPoints, 0, count);
points = sortedPoints;
offset = 0;
sortWithIndices(points, count, yDown);
}
IntArray indices = this.indices;
indices.clear();
FloatArray hull = this.hull;
hull.clear();
// Lower hull.
for (int i = offset, index = i / 2; i < end; i += 2, index++)
{
float x = points[i];
float y = points[i + 1];
while (hull.size >= 4 && ccw(x, y) <= 0)
{
hull.size -= 2;
indices.size--;
}
hull.Add(x);
hull.Add(y);
indices.Add(index);
}
// Upper hull.
for (int i = end - 4, index = i / 2, t = hull.size + 2; i >= offset; i -= 2, index--)
{
float x = points[i];
float y = points[i + 1];
while (hull.size >= t && ccw(x, y) <= 0)
{
hull.size -= 2;
indices.size--;
}
hull.Add(x);
hull.Add(y);
indices.Add(index);
}
// Convert sorted to unsorted indices.
if (!sorted)
{
short[] originalIndicesArray = originalIndices.items;
int[] indicesArray = indices.items;
for (int i = 0, n = indices.size; i < n; i++)
{
indicesArray[i] = originalIndicesArray[indicesArray[i]];
}
}
return(indices);
}
/** @see #computeIndices(float[], int, int, bool, bool) */
public IntArray computeIndices(FloatArray points, bool sorted, bool yDown)
{
return(computeIndices(points.items, 0, points.size, sorted, yDown));
}
public void Visit(FloatArray array) => CompareArrays(array);
private static void serializeIjkGrid(DataObjectRepository repo)
{
AbstractIjkGridRepresentation ijkGrid = repo.createPartialIjkGridRepresentation("", "partial IJK Grid");
f2i.energisticsStandardsApi.common.PropertyKind propertyKind = repo.createPartialPropertyKind("", "Partial prop kind");
// creating the continuous Property with computing min max
ContinuousProperty propertyCompute = repo.createContinuousProperty(
ijkGrid, "9d0a717f-2cd3-4d43-9cbf-3484105ed384", "slab prop compute min max",
1,
resqml20__IndexableElements.resqml20__IndexableElements__cells,
resqml20__ResqmlUom.resqml20__ResqmlUom__m,
propertyKind);
propertyCompute.pushBackFloatHdf5Array3dOfValues(2, 3, 4);
ulong valueCountInFastestDim = 2;
ulong valueCountInMiddleDim = 3;
ulong valueCountInSlowestDim = 1;
ulong offsetInFastestDim = 0;
ulong offsetInMiddleDim = 0;
ulong offsetInSlowestDim = 0;
FloatArray kLayerValues = new FloatArray(6);
kLayerValues.setitem(0, -123.0f);
kLayerValues.setitem(1, .01f);
kLayerValues.setitem(2, .02f);
kLayerValues.setitem(3, .03f);
kLayerValues.setitem(4, .04f);
kLayerValues.setitem(5, .05f);
propertyCompute.setValuesOfFloatHdf5Array3dOfValues(kLayerValues.cast(), valueCountInFastestDim, valueCountInMiddleDim, valueCountInSlowestDim,
offsetInFastestDim, offsetInMiddleDim, offsetInSlowestDim);
kLayerValues.setitem(0, .10f);
kLayerValues.setitem(1, .11f);
kLayerValues.setitem(2, .12f);
kLayerValues.setitem(3, .13f);
kLayerValues.setitem(4, .14f);
kLayerValues.setitem(5, .15f);
++offsetInSlowestDim;
propertyCompute.setValuesOfFloatHdf5Array3dOfValues(kLayerValues.cast(), valueCountInFastestDim, valueCountInMiddleDim, valueCountInSlowestDim,
offsetInFastestDim, offsetInMiddleDim, offsetInSlowestDim);
kLayerValues.setitem(0, .20f);
kLayerValues.setitem(1, .21f);
kLayerValues.setitem(2, .22f);
kLayerValues.setitem(3, float.NaN);
kLayerValues.setitem(4, .24f);
kLayerValues.setitem(5, .25f);
++offsetInSlowestDim;
propertyCompute.setValuesOfFloatHdf5Array3dOfValues(kLayerValues.cast(), valueCountInFastestDim, valueCountInMiddleDim, valueCountInSlowestDim,
offsetInFastestDim, offsetInMiddleDim, offsetInSlowestDim);
kLayerValues.setitem(0, .30f);
kLayerValues.setitem(1, .31f);
kLayerValues.setitem(2, .32f);
kLayerValues.setitem(3, .33f);
kLayerValues.setitem(4, .34f);
kLayerValues.setitem(5, .35f);
++offsetInSlowestDim;
propertyCompute.setValuesOfFloatHdf5Array3dOfValues(kLayerValues.cast(), valueCountInFastestDim, valueCountInMiddleDim, valueCountInSlowestDim,
offsetInFastestDim, offsetInMiddleDim, offsetInSlowestDim);
GC.KeepAlive(kLayerValues);
// creating the discrete Property with computing min max
DiscreteProperty discretePropertyCompute = repo.createDiscreteProperty(
ijkGrid, "50935c31-93ec-4084-8891-6e9f130c49c3", "testing discrete prop",
1,
resqml20__IndexableElements.resqml20__IndexableElements__cells,
resqml20__ResqmlPropertyKind.resqml20__ResqmlPropertyKind__index);
discretePropertyCompute.pushBackLongHdf5Array3dOfValues(2, 3, 4, 9999);
offsetInSlowestDim = 0;
LongArray kLayerlongValues = new LongArray(6);
kLayerlongValues.setitem(0, -10);
kLayerlongValues.setitem(1, 1);
kLayerlongValues.setitem(2, 2);
kLayerlongValues.setitem(3, 3);
kLayerlongValues.setitem(4, 4);
kLayerlongValues.setitem(5, 5);
discretePropertyCompute.setValuesOfLongHdf5Array3dOfValues(kLayerlongValues.cast(), valueCountInFastestDim, valueCountInMiddleDim, valueCountInSlowestDim,
offsetInFastestDim, offsetInMiddleDim, offsetInSlowestDim);
kLayerlongValues.setitem(0, 10);
kLayerlongValues.setitem(1, 11);
kLayerlongValues.setitem(2, 12);
kLayerlongValues.setitem(3, 13);
kLayerlongValues.setitem(4, 14);
kLayerlongValues.setitem(5, 15);
++offsetInSlowestDim;
discretePropertyCompute.setValuesOfLongHdf5Array3dOfValues(kLayerlongValues.cast(), valueCountInFastestDim, valueCountInMiddleDim, valueCountInSlowestDim,
offsetInFastestDim, offsetInMiddleDim, offsetInSlowestDim);
kLayerlongValues.setitem(0, 20);
kLayerlongValues.setitem(1, 21);
kLayerlongValues.setitem(2, 22);
kLayerlongValues.setitem(3, 9999);
kLayerlongValues.setitem(4, 24);
kLayerlongValues.setitem(5, 25);
++offsetInSlowestDim;
discretePropertyCompute.setValuesOfLongHdf5Array3dOfValues(kLayerlongValues.cast(), valueCountInFastestDim, valueCountInMiddleDim, valueCountInSlowestDim,
offsetInFastestDim, offsetInMiddleDim, offsetInSlowestDim);
kLayerlongValues.setitem(0, 30);
kLayerlongValues.setitem(1, 31);
kLayerlongValues.setitem(2, 32);
kLayerlongValues.setitem(3, 33);
kLayerlongValues.setitem(4, 34);
kLayerlongValues.setitem(5, 35);
++offsetInSlowestDim;
discretePropertyCompute.setValuesOfLongHdf5Array3dOfValues(kLayerlongValues.cast(), valueCountInFastestDim, valueCountInMiddleDim, valueCountInSlowestDim,
offsetInFastestDim, offsetInMiddleDim, offsetInSlowestDim);
GC.KeepAlive(kLayerlongValues);
}
public void UpdateBias(IMultipleLayer target, FloatArray dB)
{
var update = dB * target.CachedLearningRate;
var momentum = target.BiasVector * target.CachedMomentum;
target.BiasVector += (update + momentum);
}
BPTT(int[] inputs, int[] targets, FloatArray hprev)
{
var loss = 0f;
var xs = new Array <FloatArray>(inputs.Length);
var ht = new Array <FloatArray>(inputs.Length);
var ps = new Array <FloatArray>(inputs.Length);
var tg = new Array <FloatArray>(inputs.Length);
ht[-1] = hprev;
var dWxt = new FloatArray2D(Wxt.W, Wxt.H);
var dWtt = new FloatArray2D(Wtt.W, Wtt.H);
var dWhy = new FloatArray2D(Why.W, Why.H);
var dhnext = new FloatArray(hidden_size);
var dbt = new FloatArray(bt.Length);
var dby = new FloatArray(by.Length);
for (var t = 0; t < inputs.Length; t++)
{
xs[t] = new FloatArray(input_size);
xs[t][inputs[t]] = 1;
tg[t] = new FloatArray(output_size);
tg[t][targets[t]] = 1;
(ps[t], ht[t]) = FeedForward(xs[t], ht[t - 1]);
loss += -(tg[t] * ps[t].Log()).Sum();
}
for (var t = inputs.Length - 1; t >= 0; t--)
{
// output probabilities
var dy = ps[t].Clone();
// derive our first gradient
dy[targets[t]] -= 1;
// backpropagate to
var dt = (Why * dy).SumColumn() + dhnext;
// Compute gradient of T (Derivate of Tanh)
var dtraw = (1 - ht[t] * ht[t]) * dt;
dWtt += ht[t - 1].T * dtraw; // Temporal
dWxt += xs[t].T * dtraw; // Input
dbt += dtraw;
// Acc to next Time
dhnext = (dtraw * Wtt).SumColumn();
// Compute Derivates
dWhy += ht[t].T * dy;
dby += dy;
}
// Normalize
dWxt = NumMath.Normalize(-5, 5, dWxt);
dWtt = NumMath.Normalize(-5, 5, dWtt);
dWhy = NumMath.Normalize(-5, 5, dWhy);
dbt = NumMath.Normalize(-5, 5, dbt);
dby = NumMath.Normalize(-5, 5, dby);
return(loss, dWxt, dWtt, dWhy, dbt, dby, ht[inputs.Length - 1]);
public void CalculateParams(IMultipleLayer target)
{
gW = NumMath.Array(target.Size, target.ConectionsSize);
bW = NumMath.Array(target.Size);
}
public FloatArray FeedForward(FloatArray cl, FloatArray cr, FloatArray deep)
{
var p = ActivationFunctions.Tanh(((cl.T * wpl).SumLine() + (cr.T * wpr).SumLine() + (deep.T * wDeep).SumLine() + b));
return(p);
}
public void UpdateBias(IMultipleLayer target, FloatArray dB)
{
bW = ((v * bW) + (m * (dB * dB)));
target.BiasVector -= ((target.LearningRate / (bW + e).Sqrt()) * dB);
}
public (FloatArray errorL, FloatArray errorR, FloatArray errorDeep, FloatArray2D dwpl, FloatArray2D dwpr, FloatArray2D dwdeep, FloatArray db) BackWard(FloatArray p, FloatArray pl, FloatArray pr, FloatArray pprev, FloatArray ep)
{
var dep = ActivationFunctions.Dtanh(p) * ep;
var bkp_pl = (dep * wpl).SumColumn();
var bkp_pr = (dep * wpr).SumColumn();
var bkp_deep = (dep * wDeep).SumColumn();
var dwpl = (pl.T * dep);
var dwpr = (pr.T * dep);
var dwdeep = (pprev.T * dep);
return(bkp_pl, bkp_pr, bkp_deep, dwpl, dwpr, dwdeep, dep);
}
/** @see #FloatArray(float[]) */
static public FloatArray with(FloatArray array)
{
return(new FloatArray(array));
}
public void UpdateParams(FloatArray2D dwpl, FloatArray2D dwpr, FloatArray2D dwdeep, FloatArray db)
{
//mwpl += dwpl * dwpl;
//mwpr += dwpr * dwpr;
//mb += db * db;
//wpl -= (learningRate / (mwpl + 1e-8f).Sqrt()) * dwpl;
//wpr -= (learningRate / (mwpr + 1e-8f).Sqrt()) * dwpr;
//b -= (learningRate / (mb + 1e-8f).Sqrt()) * db;
wpl -= learningRate * dwpl;
wpr -= learningRate * dwpr;
wDeep -= learningRate * dwdeep;
b -= learningRate * db;
}
public FloatArray Activate(FloatArray sum)
{
return(sum.Tanh());
}
public void ParseGeometryLibrary_GeometryMeshSource_FloatArray(XmlNode FloatArrayNode, Source CurrentSource)
{
Console.WriteLine("Entered FloatArrayNode");
FloatArray CurrentFloatArray = new FloatArray();
for (int i = 0; i < FloatArrayNode.Attributes.Count; i++)
{
switch(FloatArrayNode.Attributes[i].Name)
{
case "count":
CurrentFloatArray.mCount = uint.Parse(FloatArrayNode.Attributes[i].Value);
break;
case "id":
CurrentFloatArray.mFloatArrayId = FloatArrayNode.Attributes[i].Value.ToString();
break;
}
}
if (CurrentFloatArray.mCount != 0)
{
String floats = FloatArrayNode.InnerText;
String delimter = " ";
String[] floatValues = floats.Split(delimter.ToCharArray());
for (int i = 0; i < floatValues.Length; i++)
{
CurrentFloatArray.mFloats.Add(Convert.ToSingle(floatValues[i], System.Globalization.CultureInfo.InvariantCulture));
}
}
CurrentSource.mFloatArray = CurrentFloatArray;
}
public static FloatArray Dsigmoid(FloatArray y)
{
return(y * (1 - y));
}
public void CrearPista(Vector3 a)
{
var r = new System.Random();
int m = 500;
Punto[] puntos = new Punto[m];
Punto Centro = new Punto(a.x, a.z);
for (int i = 0; i < m; i++)
{
//COORDENADAS POLARES argumentos en radianes
puntos[i] = new Punto(125 * UnityEngine.Random.value, UnityEngine.Random.value * 2 * Mathf.PI, 1);
puntos[i].x += Centro.x;
puntos[i].y += Centro.y;
}
List <Punto> l = new List <Punto>();
for (int i = 0; i < puntos.Length; i++)
{
l.Add(puntos[i]);
}
l.Add(puntos[0]);
puntos = l.ToArray();
ConvexHull ch = new ConvexHull();
List <float> ll = new List <float>();
for (int i = 0; i < puntos.Length; i++)
{
ll.Add(puntos[i].x);
ll.Add(puntos[i].y);
}
FloatArray fa = new FloatArray(ll.ToArray());
FloatArray contorno = ch.computePolygon(fa, false);
float[] xx;
float[] yy;
float[] xs, ys;
desglosarFloatArrayEnVectoresNormales(contorno, out xx, out yy);
Punto[] convexo = Punto.CrearArregloDesdeArreglos(xx, yy);
////////////////////////////////////// AGREGAR DIFICULTAD
float ancho = UnityEngine.Random.Range(5f, 9f);
Punto[] convexo2 = new Punto[convexo.Length * 2];
deformar(ref convexo);
separarPuntos(ref convexo);
xx = Punto.getAbscisas(convexo);
yy = Punto.getOrdenadas(convexo);
CubicSpline.FitParametric(xx, yy, n, out xs, out ys, 1, -1, 1, -1);
/////////////////////////////////////////////////////////////////////////
/*
* en xs y en ys estan las posiciones x,y de cada punto de la pista
*/
LS.Add(Instantiate(this.suelo, new Vector3(0, -1, 0), Quaternion.Euler(Vector3.zero), this.transform));
float[] angulosEnGrados = new float[n];
for (int i = 0; i < xs.Length - 1; i++)
{
angulosEnGrados[i] = 180 * Mathf.Atan2(ys[i + 1] - ys[i], -xs[i + 1] + xs[i]) / Mathf.PI;
}
IList <Punto> listaRoja = new List <Punto>();
IList <Punto> listaCheckpoint = new List <Punto>();
Punto[] puntosInteriores;
int offset = r.Next();
Vector3 pos, pos2 = new Vector3();
Quaternion rot;
for (int i = 0; i < xs.Length - 1; i++)
{
pos = new Vector3(xs[i], 0, ys[i]);
rot = Quaternion.Euler(0, angulosEnGrados[i], 0);
pared.transform.position = pos;
pared.transform.rotation = rot;
LPA.Add(Instantiate(pared, pos, rot, this.transform));
if (i % 10 == 0)
{
pared.transform.Translate(ancho / 2 * -Vector3.back, Space.Self);
pos2 = pared.transform.position;
pared.transform.Translate(ancho / 2 * -Vector3.back, Space.Self);
listaRoja.Add(new Punto(pared.transform.position));
}
else
{
pared.transform.Translate((ancho + Mathf.Sin(i / 10)) * -Vector3.back, Space.Self);
listaRoja.Add(new Punto(pared.transform.position));
}
if (i % 5 == 0)
{
pared.transform.Translate(ancho / 2 * Vector3.back, Space.Self);
checkpoint.transform.rotation = Quaternion.Euler(0, angulosEnGrados[i], 0);
checkpoint.transform.position = pared.transform.position;
checkpoint.transform.localScale = new Vector3(0.1f, checkpoint.transform.localScale.y, ancho);
LCH.Add(Instantiate(checkpoint, pared.transform.position, Quaternion.Euler(0, angulosEnGrados[i], 0), this.transform));
}
if (UnityEngine.Random.value > 0.97f)
{
obstaculo.transform.position = pos;
obstaculo.transform.rotation = rot;
obstaculo.transform.Translate(UnityEngine.Random.Range(1, ancho - 1) * Vector3.forward, Space.Self);
LO.Add(Instantiate(obstaculo, this.transform));
}
posIni[i / 10] = pos2;
EvolutionManager.ini = posIni[i / 10];
}
puntosInteriores = listaRoja.ToArray();
puntosInteriores[puntosInteriores.Length - 1] = puntosInteriores[0];
arreglarAngulos(ref puntosInteriores);
Punto[] PC = listaCheckpoint.ToArray();
float[] xx2;
float[] yy2;
float[] xs2, ys2;
float[] angulosEnGrados2 = new float[n2];
float[] angulosEnGrados3 = new float[n / 10];
xx2 = Punto.getAbscisas(puntosInteriores);
yy2 = Punto.getOrdenadas(puntosInteriores);
CubicSpline.FitParametric(xx2, yy2, n2, out xs2, out ys2, 1, -1, 1, -1);
for (int i = 0; i < xs2.Length - 1; i++)
{
angulosEnGrados2[i] = 180 * Mathf.Atan2(ys2[i + 1] - ys2[i], -xs2[i + 1] + xs2[i]) / Mathf.PI;
}
for (int i = 0; i < xs2.Length - 1; i++)
{
paredRoja.transform.rotation = Quaternion.Euler(0, angulosEnGrados2[i], 0);
paredRoja.transform.position = new Vector3(xs2[i], 0, ys2[i]);
LPR.Add(Instantiate(paredRoja, new Vector3(xs2[i], 0, ys2[i]), Quaternion.Euler(0, angulosEnGrados2[i], 0), this.transform));
}
//Cuando lee esta variable, los autos van a estar creados para una pista vieja
////////////////////////////////////7
}
public static FloatArray Dtanh(FloatArray y)
{
return(1 - y * y);
}
public void Visit(FloatArray array) => CreateBuffers(array);
public float Loss(FloatArray targets, FloatArray prediction)
{
return((float)Math.Sqrt(1f / targets.Length * (prediction - targets).Pow(2).Sum()));
}
public void UpdateBias(IMultipleLayer target, FloatArray dB)
{
mB += dB * dB;
target.BiasVector -= ((target.LearningRate / (mB + 1e-8f).Sqrt()) * dB);
}
public static PrimitiveData DecodeMorphedPrimitivesUnweighted(Matrix4 bindMatrix, Morph morph)
{
if (!(morph.BaseMeshUrl.GetElement(morph.Root) is Geometry baseMesh))
{
WriteLine("Morph base mesh '" + morph.BaseMeshUrl.TargetID + "' does not point to a valid geometry entry.");
return(null);
}
DecodePrimitives(baseMesh, bindMatrix, null,
out VertexShaderDesc baseInfo, out List <VertexPrimitive> baseLines, out List <VertexPolygon> baseFaces);
var targets = morph.TargetsElement;
InputUnshared morphTargets = null, morphWeights = null;
foreach (InputUnshared input in targets.InputElements)
{
switch (input.CommonSemanticType)
{
case ESemantic.MORPH_TARGET: morphTargets = input; break;
case ESemantic.MORPH_WEIGHT: morphWeights = input; break;
}
}
Source targetSource = morphTargets?.Source?.GetElement <Source>(morphTargets.Root);
Source weightSource = morphWeights?.Source?.GetElement <Source>(morphWeights.Root);
NameArray nameArray = targetSource?.GetArrayElement <NameArray>();
FloatArray weightArray = weightSource?.GetArrayElement <FloatArray>();
string[] geomIds = nameArray?.StringContent?.Values;
float[] weights = weightArray?.StringContent?.Values;
if (geomIds == null || weights == null)
{
WriteLine("Morph set for '" + morph.BaseMeshUrl.TargetID + "' does not have valid target and weight inputs.");
return(null);
}
int count = geomIds.Length;
if (geomIds.Length != weights.Length)
{
WriteLine("Morph set for '" + morph.BaseMeshUrl.TargetID + "' does not have a target count that matches weight count.");
count = Math.Min(geomIds.Length, weights.Length);
}
Geometry geom;
List <VertexPrimitive>[] morphLines = new List <VertexPrimitive> [count];
List <VertexPolygon>[] morphFaces = new List <VertexPolygon> [count];
for (int i = 0; i < count; ++i)
{
geom = targets.Root.GetIDEntry <Geometry>(geomIds[i]);
DecodePrimitives(geom, bindMatrix, null,
out VertexShaderDesc info, out List <VertexPrimitive> lines, out List <VertexPolygon> faces);
morphLines[i] = lines;
morphFaces[i] = faces;
}
//TODO: create data using weights and morphLines or morphFaces array
return(CreateData(baseInfo, baseLines, baseFaces));
}
public (FloatArray errorL, FloatArray errorR, FloatArray errorC, FloatArray2D dws, FloatArray2D dwhp, FloatArray2D dwhc, FloatArray2D dwpl, FloatArray2D dwpr, FloatArray2D dwc, FloatArray dbh, FloatArray dbc, FloatArray dbp) ComputeErrorNBackWard(FloatArray s, FloatArray p, FloatArray c, FloatArray h, FloatArray pl, FloatArray pr, FloatArray cx, FloatArray targetScore)
{
var ce = s - targetScore;
var des = ActivationFunctions.Dsigmoid(s) * ce;
var bkpS = (des * wS).SumColumn();
var deh = ActivationFunctions.Dtanh(h) * bkpS;
var bkpHp = (deh * wHP).SumColumn();
var bkpHc = (deh * wHC).SumColumn();
var dep = ActivationFunctions.Dtanh(p) * bkpHp;
var bkpPl = (dep * wpl).SumColumn();
var bkpPr = (dep * wpr).SumColumn();
var dec = ActivationFunctions.Dtanh(c) * bkpHc;
var bkpC = (dec * wC).SumColumn();
var dws = (h.T * des);
var dwhp = (p.T * deh);
var dwhc = (c.T * deh);
var dwpl = (pl.T * dep);
var dwpr = (pr.T * dep);
var dwc = (cx.T * dec);
return(bkpPl, bkpPr, bkpC, dws, dwhp, dwhc, dwpl, dwpr, dwc, deh, dec, dep);
}
