static NpyArray _npyarray_correlate(NpyArray ap1, NpyArray ap2, NPY_TYPES typenum, NPY_CONVOLE_MODE mode, ref int inverted)
{
npy_intp n1 = NpyArray_DIM(ap1, 0);
npy_intp n2 = NpyArray_DIM(ap2, 0);
if (n1 < n2)
{
var temp = ap1;
ap1 = ap2;
ap2 = temp;
temp = null;
var t = n1;
n1 = n2;
n2 = t;
inverted = 1;
}
else
{
inverted = 0;
}
npy_intp n_left, n_right;
npy_intp[] length = new npy_intp[] { n1 };
npy_intp n = n2;
switch (mode)
{
case NPY_CONVOLE_MODE.NPY_CONVOLVE_VALID:
length[0] = length[0] - n + 1;
n_left = n_right = 0;
break;
case NPY_CONVOLE_MODE.NPY_CONVOLVE_SAME:
n_left = (npy_intp)(n / 2);
n_right = n - n_left - 1;
break;
case NPY_CONVOLE_MODE.NPY_CONVOLVE_FULL:
n_right = n - 1;
n_left = n - 1;
length[0] = length[0] + n - 1;
break;
default:
NpyErr_SetString(npyexc_type.NpyExc_ValueError, "mode must be 0, 1, or 2");
return(null);
}
/*
* Need to choose an output array that can hold a sum
* -- use priority to determine which subtype.
*/
NpyArray ret = new_array_for_sum(ap1, ap2, 1, length, typenum);
if (ret == null)
{
return(null);
}
npy_intp is1 = NpyArray_STRIDE(ap1, 0);
npy_intp is2 = NpyArray_STRIDE(ap2, 0);
VoidPtr op = new VoidPtr(ret);
npy_intp os = NpyArray_ITEMSIZE(ret);
VoidPtr ip1 = new VoidPtr(ap1);
VoidPtr ip2 = new VoidPtr(ap2);
ip2.data_offset += n_left * is2;
n -= n_left;
var helper = MemCopy.GetMemcopyHelper(ip1);
helper.correlate(ip1, ip2, op, is1, is2, os, n, n1, n2, n_left, n_right);
if (NpyErr_Occurred())
{
goto clean_ret;
}
return(ret);
clean_ret:
Npy_DECREF(ret);
return(null);
}
internal static NpyArray NpyArray_MatrixProduct(NpyArray ap1, NpyArray ap2, NPY_TYPES typenum)
{
NpyArray ret = null;
NpyArrayIterObject it1, it2;
npy_intp i, j, l, is1, is2, os;
npy_intp [] dimensions = new npy_intp[npy_defs.NPY_MAXDIMS];
int nd, axis, matchDim;
VoidPtr op;
if (ap2.nd > 1)
{
matchDim = ap2.nd - 2;
}
else
{
matchDim = 0;
}
l = ap1.dimensions[ap1.nd - 1];
if (ap2.dimensions[matchDim] != l)
{
NpyErr_SetString(npyexc_type.NpyExc_ValueError, "objects are not aligned");
return(null);
}
nd = ap1.nd + ap2.nd - 2;
if (nd > npy_defs.NPY_MAXDIMS)
{
NpyErr_SetString(npyexc_type.NpyExc_ValueError, "dot: too many dimensions in result");
return(null);
}
j = 0;
for (i = 0; i < ap1.nd - 1; i++)
{
dimensions[j++] = ap1.dimensions[i];
}
for (i = 0; i < ap2.nd - 2; i++)
{
dimensions[j++] = ap2.dimensions[i];
}
if (ap2.nd > 1)
{
dimensions[j++] = ap2.dimensions[ap2.nd - 1];
}
is1 = ap1.strides[ap1.nd - 1];
is2 = ap2.strides[matchDim];
/* Choose which subtype to return */
ret = new_array_for_sum(ap1, ap2, nd, dimensions, typenum);
if (ret == null)
{
return(null);
}
/* Ensure that multiarray.dot(<Nx0>,<0xM>) . zeros((N,M)) */
if (NpyArray_SIZE(ap1) == 0 && NpyArray_SIZE(ap2) == 0)
{
memset(NpyArray_DATA(ret), 0, (int)NpyArray_NBYTES(ret));
}
else
{
/* Ensure that multiarray.dot([],[]) . 0 */
memset(NpyArray_DATA(ret), 0, (int)NpyArray_ITEMSIZE(ret));
}
op = new VoidPtr(ret);
os = NpyArray_ITEMSIZE(ret);
axis = ap1.nd - 1;
it1 = NpyArray_IterAllButAxis(ap1, ref axis);
it2 = NpyArray_IterAllButAxis(ap2, ref matchDim);
var helper = MemCopy.GetMemcopyHelper(it1.dataptr);
helper.MatrixProduct(it1, it2, op, is1, is2, os, l);
Npy_DECREF(it1);
Npy_DECREF(it2);
if (NpyErr_Occurred())
{
goto fail;
}
return(ret);
fail:
Npy_XDECREF(ret);
return(null);
}
internal static NpyArray NpyArray_InnerProduct(NpyArray ap1, NpyArray ap2, NPY_TYPES typenum)
{
npy_intp [] dimensions = new npy_intp[npy_defs.NPY_MAXDIMS];
npy_intp l = ap1.dimensions[ap1.nd - 1];
if (ap2.dimensions[ap2.nd - 1] != l)
{
NpyErr_SetString(npyexc_type.NpyExc_ValueError, "matrices are not aligned");
return(null);
}
int nd = ap1.nd + ap2.nd - 2;
int j = 0;
for (int i = 0; i < ap1.nd - 1; i++)
{
dimensions[j++] = ap1.dimensions[i];
}
for (int i = 0; i < ap2.nd - 1; i++)
{
dimensions[j++] = ap2.dimensions[i];
}
/*
* Need to choose an output array that can hold a sum
* -- use priority to determine which subtype.
*/
NpyArray ret = new_array_for_sum(ap1, ap2, nd, dimensions, typenum);
if (ret == null)
{
return(null);
}
npy_intp is1 = ap1.strides[ap1.nd - 1];
npy_intp is2 = ap2.strides[ap2.nd - 1];
VoidPtr op = new VoidPtr(ret);
npy_intp os = ret.descr.elsize;
int axis = ap1.nd - 1;
NpyArrayIterObject it1 = NpyArray_IterAllButAxis(ap1, ref axis);
axis = ap2.nd - 1;
NpyArrayIterObject it2 = NpyArray_IterAllButAxis(ap2, ref axis);
var helper = MemCopy.GetMemcopyHelper(it1.dataptr);
helper.InnerProduct(it1, it2, op, is1, is2, os, l);
Npy_DECREF(it1);
Npy_DECREF(it2);
if (NpyErr_Occurred())
{
goto fail;
}
return(ret);
fail:
Npy_DECREF(ret);
return(null);
}
internal static NpyArray NpyArray_CopyAndTranspose(NpyArray arr)
{
NpyArray ret, tmp;
int nd, eltsize;
npy_intp stride2;
npy_intp[] dims = new npy_intp[2];
npy_intp i, j;
VoidPtr iptr; VoidPtr optr;
/* make sure it is well-behaved */
tmp = NpyArray_ContiguousFromArray(arr, NpyArray_TYPE(arr));
if (tmp == null)
{
return(null);
}
arr = tmp;
nd = NpyArray_NDIM(arr);
if (nd == 1)
{
/* we will give in to old behavior */
Npy_DECREF(tmp);
return(arr);
}
else if (nd != 2)
{
Npy_DECREF(tmp);
NpyErr_SetString(npyexc_type.NpyExc_ValueError, "only 2-d arrays are allowed");
return(null);
}
/* Now construct output array */
dims[0] = NpyArray_DIM(arr, 1);
dims[1] = NpyArray_DIM(arr, 0);
eltsize = NpyArray_ITEMSIZE(arr);
Npy_INCREF(arr.descr);
ret = NpyArray_Alloc(arr.descr, 2, dims, false, null);
if (ret == null)
{
Npy_DECREF(tmp);
return(null);
}
/* do 2-d loop */
optr = new VoidPtr(ret);
stride2 = eltsize * dims[0];
for (i = 0; i < dims[0]; i++)
{
iptr = new VoidPtr(arr);
iptr.data_offset += i * eltsize;
var helper = MemCopy.GetMemcopyHelper(optr);
helper.memmove_init(optr, iptr);
for (j = 0; j < dims[1]; j++)
{
/* optr[i,j] = iptr[j,i] */
helper.memcpy(optr.data_offset, iptr.data_offset, eltsize);
optr.data_offset += eltsize;
iptr.data_offset += stride2;
}
}
Npy_DECREF(tmp);
return(ret);
}
internal static NpyArrayMapIterObject NpyArray_MapIterNew(NpyIndex [] indexes, int n)
{
NpyArrayMapIterObject mit;
int i, j;
/* Allocates the Python object wrapper around the map iterator. */
mit = new NpyArrayMapIterObject();
NpyObject_Init(mit, NpyArrayMapIter_Type);
if (mit == null)
{
return(null);
}
for (i = 0; i < npy_defs.NPY_MAXDIMS; i++)
{
mit.iters[i] = null;
}
mit.index = 0;
mit.ait = null;
mit.subspace = null;
mit.numiter = 0;
mit.consec = 1;
mit.n_indexes = 0;
mit.nob_interface = null;
/* Expand the boolean arrays in indexes. */
mit.n_indexes = NpyArray_IndexExpandBool(indexes, n, mit.indexes);
if (mit.n_indexes < 0)
{
Npy_DECREF(mit);
return(null);
}
/* Make iterators from any intp arrays and intp in the index. */
j = 0;
for (i = 0; i < mit.n_indexes; i++)
{
NpyIndex index = mit.indexes[i];
if (index.type == NpyIndexType.NPY_INDEX_INTP_ARRAY)
{
mit.iters[j] = NpyArray_IterNew(index.intp_array);
if (mit.iters[j] == null)
{
mit.numiter = j - 1;
Npy_DECREF(mit);
return(null);
}
j++;
}
else if (index.type == NpyIndexType.NPY_INDEX_INTP)
{
NpyArray_Descr indtype;
NpyArray indarray;
/* Make a 0-d array for the index. */
indtype = NpyArray_DescrFromType(NPY_TYPES.NPY_INTP);
indarray = NpyArray_Alloc(indtype, 0, null, false, null);
if (indarray == null)
{
mit.numiter = j - 1;
Npy_DECREF(mit);
return(null);
}
byte[] src = BitConverter.GetBytes(index.intp);
var srcvp = new VoidPtr(src);
var helper = MemCopy.GetMemcopyHelper(indarray.data);
helper.memmove_init(indarray.data, srcvp);
helper.memcpy(indarray.data.data_offset, srcvp.data_offset, sizeof(npy_intp));
mit.iters[j] = NpyArray_IterNew(indarray);
Npy_DECREF(indarray);
if (mit.iters[j] == null)
{
mit.numiter = j - 1;
Npy_DECREF(mit);
return(null);
}
j++;
}
}
mit.numiter = j;
/* Broadcast the index iterators. */
if (NpyArray_Broadcast(mit) < 0)
{
Npy_DECREF(mit);
return(null);
}
return(mit);
}
internal static void memclr(VoidPtr dest, npy_intp len)
{
var helper = MemCopy.GetMemcopyHelper(dest);
helper.memclr(dest, dest.data_offset, len);
}