public static void Set(ManagedIntList dst, int value)
{
for (var i = 0; i < dst.Length(); i++)
{
dst[i] = value;
}
}
// Copy 2D[index_list][y]
public static void Copy2DX(ManagedArray dst, ManagedArray src, ManagedIntList index_list, int minx)
{
for (int y = 0; y < dst.y; y++)
{
var dstoffset = y * dst.x;
var srcoffset = y * src.x;
var xx = index_list[minx];
MemCopy(dst, dstoffset, src, srcoffset + xx, dst.x);
}
}
public int Test(ManagedArray output, ManagedIntList classification, int category = 1)
{
var errors = 0;
for (var i = 0; i < classification.Length(); i++)
{
var correct = (int)output[i] != category ? 0 : category;
errors += correct != classification[i] ? 1 : 0;
}
return(errors);
}
public ManagedIntList Classify(ManagedArray input, double threshold = 0)
{
var classification = new ManagedIntList(Rows(input));
var predictions = Predict(input);
for (var i = 0; i < predictions.Length(); i++)
{
classification[i] = predictions[i] > threshold ? Category : 0;
}
ManagedOps.Free(predictions);
return(classification);
}
// Fisher–Yates shuffle algorithm
public static void Shuffle(ManagedIntList index_list)
{
System.Random random = new System.Random(System.Guid.NewGuid().GetHashCode());
int n = index_list.Length();
for (int i = n - 1; i > 1; i--)
{
int rnd = random.Next(i + 1);
var value = index_list[rnd];
index_list[rnd] = index_list[i];
index_list[i] = value;
}
}
// Copy 3D[x][y][index_list]
public static void Copy3DZ(ManagedArray dst, ManagedArray src, ManagedIntList index_list, int minz)
{
if (minz < src.z)
{
for (int z = 0; z < dst.z; z++)
{
var zz = index_list[minz + z];
for (int y = 0; y < dst.y; y++)
{
var dstoffset = (z * dst.y + y) * dst.x;
var srcoffset = (zz * src.y + y) * src.x;
MemCopy(dst, dstoffset, src, srcoffset, dst.x);
}
}
}
}
public static void Points(Pixbuf pixbuf, ManagedArray x, ManagedIntList c, Color[] colors, int f1 = 0, int f2 = 0)
{
f1 = f1 >= 0 && f1 < Cols(x) ? f1 : 0;
f2 = f2 >= 0 && f2 < Cols(x) ? f2 : 0;
if (pixbuf != null)
{
for (var i = 0; i < Rows(x); i++)
{
if (Math.Abs(deltax) > 0 && Math.Abs(deltay) > 0)
{
var xp = (int)((x[f1, i] - minx) / deltax);
var yp = (int)((x[f2, i] - miny) / deltay);
Common.Circle(pixbuf, xp, yp, 2, colors[c[i] % colors.Length], true);
}
}
}
}
// Copy 3D[minx + x][miny + y][index_list[minz + z]]
public static void Copy3D(ManagedArray dst, ManagedArray src, int minx, int miny, int minz, ManagedIntList index_list)
{
if (minx >= 0 & minx < src.x & miny >= 0 & miny < src.y & minz >= 0 & minz < src.z)
{
for (var z = 0; z < dst.z; z++)
{
var zz = index_list[minz + z];
var offsets = zz * src.y + miny;
var offsetd = z * dst.y;
for (var y = 0; y < dst.y; y++)
{
var dstoffset = (offsetd + y) * dst.x;
var srcoffset = (offsets + y) * src.x + minx;
MemCopy(dst, dstoffset, src, srcoffset, dst.x);
}
}
}
}
// Copy 2D[index_list[minx + x]][miny + y]
public static void Copy2D(ManagedArray dst, ManagedArray src, int minx, int miny, ManagedIntList index_list)
{
if (miny >= 0 & miny < src.y)
{
for (var y = 0; y < dst.y; y++)
{
var sx = (miny + y) * src.x;
var dx = y * dst.x;
for (var x = 0; x < dst.x; x++)
{
var xx = index_list[minx + x];
var srcoffset = sx + xx;
var dstoffset = dx + x;
dst[dstoffset] = src[srcoffset];
}
}
}
}
