private static void _aligned_strided_to_contig_size2_srcstride0(VoidPtr dst, npy_intp dst_stride, VoidPtr src, npy_intp src_stride, npy_intp N, npy_intp src_itemsize, NpyAuxData transferdata)
{
_strided_to_strided(dst, dst_stride, src, src_stride, N, src_itemsize, transferdata);
}
private static npy_intp SetIDX(VoidPtr v, npy_intp index, npy_intp d)
{
npy_intp[] vv = v.datap as npy_intp[];
return(vv[v.data_offset + index] = d);
}
public override int GetTypeSize(VoidPtr v)
{
return(sizeof(sbyte));
}
internal static int NpyArray_SortFunc(object o1, npy_intp length, NpyArray NOTUSED, NPY_SORTKIND kind)
{
VoidPtr arr = o1 as VoidPtr;
return(NpyArray_SortFuncTypeNum(arr, (int)(arr.data_offset >> GetDivSize(GetTypeSize(arr.type_num))), (int)length));
}
internal static void swapvalue(VoidPtr dest, npy_intp data_offset, int DivSize)
{
npy_intp item_offset = data_offset >> DivSize;
switch (dest.type_num)
{
case NPY_TYPES.NPY_BOOL:
{
return;
}
case NPY_TYPES.NPY_BYTE:
{
return;
}
case NPY_TYPES.NPY_UBYTE:
{
return;
}
case NPY_TYPES.NPY_INT16:
{
Int16[] bdata = dest.datap as Int16[];
Int16 value = bdata[item_offset];
var uvalue = (UInt16)value;
UInt16 swapped = (UInt16)
((0x00FF) & (uvalue >> 8)
| (0xFF00) & (uvalue << 8));
bdata[item_offset] = (Int16)swapped;
return;
}
case NPY_TYPES.NPY_UINT16:
{
UInt16[] bdata = dest.datap as UInt16[];
UInt16 value = bdata[item_offset];
var uvalue = (UInt16)value;
UInt16 swapped = (UInt16)
((0x00FF) & (uvalue >> 8)
| (0xFF00) & (uvalue << 8));
bdata[item_offset] = (UInt16)swapped;
return;
}
case NPY_TYPES.NPY_INT32:
{
Int32[] bdata = dest.datap as Int32[];
Int32 value = bdata[item_offset];
var uvalue = (UInt32)value;
UInt32 swapped =
((0x000000FF) & (uvalue >> 24)
| (0x0000FF00) & (uvalue >> 8)
| (0x00FF0000) & (uvalue << 8)
| (0xFF000000) & (uvalue << 24));
bdata[item_offset] = (Int32)swapped;
break;
}
case NPY_TYPES.NPY_UINT32:
{
UInt32[] bdata = dest.datap as UInt32[];
UInt32 value = bdata[item_offset];
var uvalue = (UInt32)value;
UInt32 swapped =
((0x000000FF) & (uvalue >> 24)
| (0x0000FF00) & (uvalue >> 8)
| (0x00FF0000) & (uvalue << 8)
| (0xFF000000) & (uvalue << 24));
bdata[item_offset] = (UInt32)swapped;
break;
}
case NPY_TYPES.NPY_INT64:
{
Int64[] bdata = dest.datap as Int64[];
Int64 value = bdata[item_offset];
var uvalue = (UInt64)value;
UInt64 swapped =
((0x00000000000000FF) & (uvalue >> 56)
| (0x000000000000FF00) & (uvalue >> 40)
| (0x0000000000FF0000) & (uvalue >> 24)
| (0x00000000FF000000) & (uvalue >> 8)
| (0x000000FF00000000) & (uvalue << 8)
| (0x0000FF0000000000) & (uvalue << 24)
| (0x00FF000000000000) & (uvalue << 40)
| (0xFF00000000000000) & (uvalue << 56));
bdata[item_offset] = (Int64)swapped;
break;
}
case NPY_TYPES.NPY_UINT64:
{
UInt64[] bdata = dest.datap as UInt64[];
UInt64 value = bdata[item_offset];
var uvalue = (UInt64)value;
UInt64 swapped =
((0x00000000000000FF) & (uvalue >> 56)
| (0x000000000000FF00) & (uvalue >> 40)
| (0x0000000000FF0000) & (uvalue >> 24)
| (0x00000000FF000000) & (uvalue >> 8)
| (0x000000FF00000000) & (uvalue << 8)
| (0x0000FF0000000000) & (uvalue << 24)
| (0x00FF000000000000) & (uvalue << 40)
| (0xFF00000000000000) & (uvalue << 56));
bdata[item_offset] = (UInt64)swapped;
break;
}
// these data types can't be swapped
case NPY_TYPES.NPY_DECIMAL:
case NPY_TYPES.NPY_COMPLEX:
case NPY_TYPES.NPY_BIGINT:
case NPY_TYPES.NPY_OBJECT:
return;
}
}
internal static void NpyArray_Item_XDECREF(VoidPtr data, NpyArray_Descr descr)
{
// todo: not sure I need to do anything. Am I going to ref count the buffers?
}
internal static int NpyArray_FillFunc(VoidPtr dest, npy_intp length, NpyArray arr)
{
return(NpyArray_FillWithScalarFunc(dest, length, arr.data, arr));
}
private static long GetTypeSize(VoidPtr vp)
{
return(GetTypeSize(vp.type_num));
}
internal static void memmove(VoidPtr dest, VoidPtr src, long len)
{
memmove(dest, 0, src, 0, len);
}
internal static object GetIndex(VoidPtr obj, npy_intp index)
{
if (index < 0)
{
dynamic dyndatap = obj.datap;
index = dyndatap.Length - Math.Abs(index);
}
switch (obj.type_num)
{
case NPY_TYPES.NPY_BOOL:
var dbool = obj.datap as bool[];
return(dbool[index]);
case NPY_TYPES.NPY_BYTE:
var dsbyte = obj.datap as sbyte[];
return(dsbyte[index]);
case NPY_TYPES.NPY_UBYTE:
var dbyte = obj.datap as byte[];
return(dbyte[index]);
case NPY_TYPES.NPY_UINT16:
var duint16 = obj.datap as UInt16[];
return(duint16[index]);
case NPY_TYPES.NPY_INT16:
var dint16 = obj.datap as Int16[];
return(dint16[index]);
case NPY_TYPES.NPY_UINT32:
var duint32 = obj.datap as UInt32[];
return(duint32[index]);
case NPY_TYPES.NPY_INT32:
var dint32 = obj.datap as Int32[];
return(dint32[index]);
case NPY_TYPES.NPY_INT64:
var dint64 = obj.datap as Int64[];
return(dint64[index]);
case NPY_TYPES.NPY_UINT64:
var duint64 = obj.datap as UInt64[];
return(duint64[index]);
case NPY_TYPES.NPY_FLOAT:
var float1 = obj.datap as float[];
return(float1[index]);
case NPY_TYPES.NPY_DOUBLE:
var double1 = obj.datap as double[];
return(double1[index]);
case NPY_TYPES.NPY_DECIMAL:
var decimal1 = obj.datap as decimal[];
return(decimal1[index]);
default:
throw new Exception("Unsupported data type");
}
}
internal static int SetIndex(VoidPtr obj, npy_intp index, object invalue)
{
if (index < 0)
{
dynamic dyndatap = obj.datap;
index = dyndatap.Length - Math.Abs(index);
}
var value = invalue; // CoerceValue(invalue, obj.type_num);
try
{
switch (obj.type_num)
{
case NPY_TYPES.NPY_BOOL:
var dbool = obj.datap as bool[];
dbool[index] = Convert.ToBoolean(value);
break;
case NPY_TYPES.NPY_BYTE:
var dsbyte = obj.datap as sbyte[];
dsbyte[index] = Convert.ToSByte(value);
break;
case NPY_TYPES.NPY_UBYTE:
var dbyte = obj.datap as byte[];
dbyte[index] = Convert.ToByte(value);
break;
case NPY_TYPES.NPY_UINT16:
var duint16 = obj.datap as UInt16[];
duint16[index] = Convert.ToUInt16(value);
break;
case NPY_TYPES.NPY_INT16:
var dint16 = obj.datap as Int16[];
dint16[index] = Convert.ToInt16(value);
break;
case NPY_TYPES.NPY_UINT32:
var duint32 = obj.datap as UInt32[];
duint32[index] = Convert.ToUInt32(value);
break;
case NPY_TYPES.NPY_INT32:
var dint32 = obj.datap as Int32[];
dint32[index] = Convert.ToInt32(value);
break;
case NPY_TYPES.NPY_INT64:
var dint64 = obj.datap as Int64[];
dint64[index] = Convert.ToInt64(value);
break;
case NPY_TYPES.NPY_UINT64:
var duint64 = obj.datap as UInt64[];
duint64[index] = Convert.ToUInt64(value);
break;
case NPY_TYPES.NPY_FLOAT:
var float1 = obj.datap as float[];
float1[index] = Convert.ToSingle(value);
break;
case NPY_TYPES.NPY_DOUBLE:
var double1 = obj.datap as double[];
double1[index] = Convert.ToDouble(value);
break;
case NPY_TYPES.NPY_DECIMAL:
var decimal1 = obj.datap as decimal[];
decimal1[index] = Convert.ToDecimal(value);
break;
default:
throw new Exception("Unsupported data type");
}
}
catch (System.OverflowException oe)
{
NpyErr_SetString(npyexc_type.NpyExc_OverflowError, oe.Message);
}
catch (Exception ex)
{
NpyErr_SetString(npyexc_type.NpyExc_ValueError, ex.Message);
}
return(1);
}
internal static NpyArray NpyArray_IterSubscriptBoolArray(NpyArrayIterObject self, NpyArray index)
{
NpyArray result;
npy_intp bool_size, i;
npy_intp [] result_size = new npy_intp[1] {
0
};
npy_intp stride;
VoidPtr dptr;
VoidPtr optr;
int elsize;
NpyArray_CopySwapFunc copyswap;
bool swap;
if (index.nd != 1)
{
NpyErr_SetString(npyexc_type.NpyExc_ValueError,
"boolean index array should have 1 dimension");
return(null);
}
bool_size = index.dimensions[0];
if (bool_size > self.size)
{
NpyErr_SetString(npyexc_type.NpyExc_ValueError,
"too many boolean indices");
return(null);
}
/* Get the size of the result by counting the Trues in the index. */
stride = index.strides[0];
dptr = new VoidPtr(index);
Debug.Assert(index.descr.elsize == 1);
i = bool_size;
result_size[0] = 0;
bool[] data = dptr.datap as bool[];
npy_intp dptr_index = 0;
while (i-- > 0)
{
if (data[dptr_index])
{
++result_size[0];
}
dptr_index += stride;
}
/* Build the result. */
Npy_INCREF(self.ao.descr);
result = NpyArray_Alloc(self.ao.descr, 1, result_size, false, Npy_INTERFACE(self.ao));
if (result == null)
{
return(null);
}
/* Copy in the data. */
copyswap = result.descr.f.copyswap;
swap = (NpyArray_ISNOTSWAPPED(self.ao) != NpyArray_ISNOTSWAPPED(result));
elsize = result.descr.elsize;
optr = new VoidPtr(result);
dptr = new VoidPtr(index);
NpyArray_ITER_RESET(self);
i = bool_size;
data = dptr.datap as bool[];
dptr_index = 0;
while (i-- > 0)
{
if (data[dptr_index])
{
copyswap(optr, self.dataptr, swap, result);
optr.data_offset += elsize;
}
dptr_index += stride;
NpyArray_ITER_NEXT(self);
}
Debug.Assert(optr.datap == result.data.datap && optr.data_offset == (result_size[0] * elsize));
NpyArray_ITER_RESET(self);
return(result);
}
internal static NpyArray NpyArray_IterSubscriptIntpArray(NpyArrayIterObject self, NpyArray index)
{
NpyArray result;
NpyArray_CopySwapFunc copyswap;
NpyArrayIterObject index_iter;
npy_intp i, num;
VoidPtr optr;
int elsize;
bool swap;
/* Build the result in the same shape as the index. */
Npy_INCREF(self.ao.descr);
result = NpyArray_Alloc(self.ao.descr,
index.nd, index.dimensions,
false, Npy_INTERFACE(self.ao));
if (result == null)
{
return(null);
}
/* Copy in the data. */
index_iter = NpyArray_IterNew(index);
if (index_iter == null)
{
Npy_DECREF(result);
return(null);
}
copyswap = result.descr.f.copyswap;
i = index_iter.size;
swap = (NpyArray_ISNOTSWAPPED(self.ao) != NpyArray_ISNOTSWAPPED(result));
optr = new VoidPtr(result);
elsize = result.descr.elsize;
NpyArray_ITER_RESET(self);
npy_intp[] dataptr = index_iter.dataptr.datap as npy_intp[];
while (i-- > 0)
{
num = dataptr[index_iter.dataptr.data_offset / sizeof(npy_intp)];
if (num < 0)
{
num += self.size;
}
if (num < 0 || num >= self.size)
{
string msg = string.Format("index {0} out of bounds 0<=index<{1}", num, self.size);
NpyErr_SetString(npyexc_type.NpyExc_IndexError, msg);
Npy_DECREF(index_iter);
Npy_DECREF(result);
NpyArray_ITER_RESET(self);
return(null);
}
NpyArray_ITER_GOTO1D(self, num);
copyswap(optr, self.dataptr, swap, result);
optr.data_offset += elsize;
NpyArray_ITER_NEXT(index_iter);
}
Npy_DECREF(index_iter);
NpyArray_ITER_RESET(self);
return(result);
}
private static bool NPY_RAW_ITER_TWO_NEXT(ref int idim, int ndim, npy_intp[] coord, npy_intp[] shape, VoidPtr dataA, npy_intp[] stridesA, VoidPtr dataB, npy_intp[] stridesB)
{
for (idim = 1; idim < ndim; ++idim)
{
if (++coord[idim] == shape[idim])
{
coord[idim] = 0;
dataA.data_offset -= (shape[idim] - 1) * stridesA[idim];
dataB.data_offset -= (shape[idim] - 1) * stridesB[idim];
}
else
{
dataA.data_offset += stridesA[idim];
dataB.data_offset += stridesB[idim];
break;
}
}
return(idim < ndim);
}
private static void _dec_src_ref_nop(VoidPtr dst, long dst_stride, VoidPtr src, long src_stride, long N, long src_itemsize, NpyAuxData transferdata)
{
throw new NotImplementedException();
}
internal static void memcpy(VoidPtr dest, VoidPtr src, long len)
{
MemCopy.MemCpy(dest, 0, src, 0, len);
}
/*
* Prepares shape and strides for a simple raw array iteration.
* This sorts the strides into FORTRAN order, reverses any negative
* strides, then coalesces axes where possible. The results are
* filled in the output parameters.
*
* This is intended for simple, lightweight iteration over arrays
* where no buffering of any kind is needed, and the array may
* not be stored as a PyArrayObject.
*
* The arrays shape, out_shape, strides, and out_strides must all
* point to different data.
*
* Returns 0 on success, -1 on failure.
*/
internal static int PyArray_PrepareOneRawArrayIter(int ndim, npy_intp[] shape,
VoidPtr data, npy_intp[] strides,
ref int out_ndim, npy_intp[] out_shape,
ref VoidPtr out_data, npy_intp[] out_strides)
{
npy_stride_sort_item [] strideperm = new npy_stride_sort_item[npy_defs.NPY_MAXDIMS];
int i, j;
/* Special case 0 and 1 dimensions */
if (ndim == 0)
{
out_ndim = 1;
out_data = data;
out_shape[0] = 1;
out_strides[0] = 0;
return(0);
}
else if (ndim == 1)
{
npy_intp stride_entry = strides[0], shape_entry = shape[0];
out_ndim = 1;
out_shape[0] = shape[0];
/* Always make a positive stride */
if (stride_entry >= 0)
{
out_data = data;
out_strides[0] = stride_entry;
}
else
{
out_data = data + stride_entry * (shape_entry - 1);
out_strides[0] = -stride_entry;
}
return(0);
}
/* Sort the axes based on the destination strides */
PyArray_CreateSortedStridePerm(ndim, strides, strideperm);
for (i = 0; i < ndim; ++i)
{
npy_intp iperm = strideperm[ndim - i - 1].perm;
out_shape[i] = shape[iperm];
out_strides[i] = strides[iperm];
}
/* Reverse any negative strides */
for (i = 0; i < ndim; ++i)
{
npy_intp stride_entry = out_strides[i], shape_entry = out_shape[i];
if (stride_entry < 0)
{
data += stride_entry * (shape_entry - 1);
out_strides[i] = -stride_entry;
}
/* Detect 0-size arrays here */
if (shape_entry == 0)
{
out_ndim = 1;
out_data = data;
out_shape[0] = 0;
out_strides[0] = 0;
return(0);
}
}
/* Coalesce any dimensions where possible */
i = 0;
for (j = 1; j < ndim; ++j)
{
if (out_shape[i] == 1)
{
/* Drop axis i */
out_shape[i] = out_shape[j];
out_strides[i] = out_strides[j];
}
else if (out_shape[j] == 1)
{
/* Drop axis j */
}
else if (out_strides[i] * out_shape[i] == out_strides[j])
{
/* Coalesce axes i and j */
out_shape[i] *= out_shape[j];
}
else
{
/* Can't coalesce, go to next i */
++i;
out_shape[i] = out_shape[j];
out_strides[i] = out_strides[j];
}
}
ndim = i + 1;
#if false
/* DEBUG */
{
printf("raw iter ndim %d\n", ndim);
printf("shape: ");
for (i = 0; i < ndim; ++i)
{
printf("%d ", (int)out_shape[i]);
}
printf("\n");
printf("strides: ");
for (i = 0; i < ndim; ++i)
{
printf("%d ", (int)out_strides[i]);
}
printf("\n");
}
#endif
out_data = data;
out_ndim = ndim;
return(0);
}
internal static void memset(VoidPtr dest, byte setvalue, long len)
{
MemSet.memset(dest, 0, setvalue, len);
}
/*
* Resize (reallocate data). Only works if nothing else is referencing this
* array and it is contiguous. If refcheck is 0, then the reference count is
* not checked and assumed to be 1. You still must own this data and have no
* weak-references and no base object.
*/
internal static int NpyArray_Resize(NpyArray self, NpyArray_Dims newshape, bool refcheck, NPY_ORDER fortran)
{
npy_intp oldsize, newsize;
int new_nd = newshape.len, k, elsize;
int refcnt;
npy_intp [] new_dimensions = newshape.ptr;
npy_intp [] new_strides = new npy_intp[npy_defs.NPY_MAXDIMS];
size_t sd;
npy_intp[] dimptr;
npy_intp[] strptr;
npy_intp largest;
if (!NpyArray_ISONESEGMENT(self))
{
NpyErr_SetString(npyexc_type.NpyExc_ValueError, "resize only works on single-segment arrays");
return(-1);
}
if (self.descr.elsize == 0)
{
NpyErr_SetString(npyexc_type.NpyExc_ValueError, "Bad data-type size.");
return(-1);
}
newsize = 1;
largest = npy_defs.NPY_MAX_INTP / self.descr.elsize;
for (k = 0; k < new_nd; k++)
{
if (new_dimensions[k] == 0)
{
break;
}
if (new_dimensions[k] < 0)
{
NpyErr_SetString(npyexc_type.NpyExc_ValueError, "negative dimensions not allowed");
return(-1);
}
newsize *= new_dimensions[k];
if (newsize <= 0 || newsize > largest)
{
NpyErr_MEMORY();
return(-1);
}
}
oldsize = NpyArray_SIZE(self);
if (oldsize != newsize)
{
if (!((self.flags & NPYARRAYFLAGS.NPY_OWNDATA) != 0))
{
NpyErr_SetString(npyexc_type.NpyExc_ValueError, "cannot resize this array: it does not own its data");
return(-1);
}
/* TODO: This isn't right for usage from C. I think we
* need to revisit the refcounts so we don't have counts
* of 0. */
if (refcheck)
{
refcnt = (int)self.nob_refcnt;
}
else
{
refcnt = 0;
}
if ((refcnt > 0) ||
(self.base_arr != null) || (null != self.base_obj))
{
NpyErr_SetString(npyexc_type.NpyExc_ValueError, "cannot resize an array references or is referenced\nby another array in this way. Use the resize function");
return(-1);
}
if (newsize == 0)
{
sd = (size_t)self.descr.elsize;
}
else
{
sd = (size_t)(newsize * self.descr.elsize);
}
/* Reallocate space if needed */
VoidPtr new_data = NpyDataMem_RENEW(self.data, sd);
if (new_data == null)
{
NpyErr_MEMORY();
return(-1);
}
self.data = new_data;
}
if ((newsize > oldsize) && NpyArray_ISWRITEABLE(self))
{
/* Fill new memory with zeros */
elsize = self.descr.elsize;
memclr(self.data + oldsize * elsize, (newsize - oldsize));
}
if (self.nd != new_nd)
{
/* Different number of dimensions. */
self.nd = new_nd;
/* Need new dimensions and strides arrays */
dimptr = NpyDimMem_NEW(new_nd);
strptr = NpyDimMem_NEW(new_nd);
if (dimptr == null || strptr == null)
{
NpyErr_MEMORY();
return(-1);
}
copydims(dimptr, self.dimensions, self.nd);
copydims(strptr, self.strides, self.nd);
self.dimensions = dimptr;
self.strides = strptr;
}
/* make new_strides variable */
sd = (size_t)self.descr.elsize;
NPYARRAYFLAGS flags = 0;
sd = (size_t)npy_array_fill_strides(new_strides, new_dimensions, new_nd, sd, self.flags, ref flags); self.flags = flags;
Array.Copy(new_dimensions, self.dimensions, new_nd);
Array.Copy(new_strides, self.strides, new_nd);
return(0);
}
internal static VoidPtr NpyDataMem_NEW(NPY_TYPES type_num, ulong size, bool AdjustForBytes = true)
{
VoidPtr vp = new VoidPtr();
switch (type_num)
{
case NPY_TYPES.NPY_BOOL:
vp.datap = new bool[size / (AdjustForBytes ? sizeof(bool) : (ulong)1)];
break;
case NPY_TYPES.NPY_BYTE:
vp.datap = new sbyte[size / (AdjustForBytes ? sizeof(sbyte) : (ulong)1)];
break;
case NPY_TYPES.NPY_UBYTE:
vp.datap = new byte[size / (AdjustForBytes ? sizeof(byte) : (ulong)1)];
break;
case NPY_TYPES.NPY_SHORT:
vp.datap = new Int16[size / (AdjustForBytes ? sizeof(Int16) : (ulong)1)];
break;
case NPY_TYPES.NPY_USHORT:
vp.datap = new UInt16[size / (AdjustForBytes ? sizeof(UInt16) : (ulong)1)];
break;
case NPY_TYPES.NPY_INT32:
vp.datap = new Int32[size / (AdjustForBytes ? sizeof(Int32) : (ulong)1)];
break;
case NPY_TYPES.NPY_UINT32:
vp.datap = new UInt32[size / (AdjustForBytes ? sizeof(UInt32) : (ulong)1)];
break;
case NPY_TYPES.NPY_LONG:
vp.datap = new Int64[size / (AdjustForBytes ? sizeof(Int64) : (ulong)1)];
break;
case NPY_TYPES.NPY_ULONG:
vp.datap = new UInt64[size / (AdjustForBytes ? sizeof(UInt64) : (ulong)1)];
break;
case NPY_TYPES.NPY_FLOAT:
vp.datap = new float[size / (AdjustForBytes ? sizeof(float) : (ulong)1)];
break;
case NPY_TYPES.NPY_DOUBLE:
vp.datap = new double[size / (AdjustForBytes ? sizeof(double) : (ulong)1)];
break;
case NPY_TYPES.NPY_DECIMAL:
vp.datap = new decimal[size / (AdjustForBytes ? sizeof(decimal) : (ulong)1)];
break;
case NPY_TYPES.NPY_LONGLONG:
case NPY_TYPES.NPY_ULONGLONG:
vp.datap = new UInt64[size / (AdjustForBytes ? sizeof(UInt64) : (ulong)1)];
break;
// not sure about these yet. Not really supported
case NPY_TYPES.NPY_DATETIME:
case NPY_TYPES.NPY_TIMEDELTA:
vp.datap = new UInt64[size / (AdjustForBytes ? sizeof(UInt64) : (ulong)1)];
break;
// not sure about these yet. Not really supported
case NPY_TYPES.NPY_LONGDOUBLE:
case NPY_TYPES.NPY_CFLOAT:
case NPY_TYPES.NPY_CDOUBLE:
case NPY_TYPES.NPY_CLONGDOUBLE:
vp.datap = new UInt64[size / (AdjustForBytes ? sizeof(UInt64) : (ulong)1)];
break;
default:
throw new Exception(string.Format("NpyDataMem_NEW: Unexpected type_num {0}", type_num));
}
vp.type_num = type_num;
return(vp);
}
internal static int NpyArray_FillWithScalarFunc(VoidPtr dest, npy_intp length, VoidPtr scalar, NpyArray arr)
{
npy_intp dest_offset = dest.data_offset >> arr.ItemDiv;
npy_intp scalar_offset = scalar.data_offset >> arr.ItemDiv;
return(DefaultArrayHandlers.GetArrayHandler(dest.type_num).ArrayFill(dest, scalar, (int)length, (int)dest_offset, (int)scalar_offset));
}
internal static void NpyDataMem_FREE(VoidPtr b)
{
return;
}
private static int NpyArray_SortFuncTypeNum(VoidPtr data, int offset, int length)
{
DefaultArrayHandlers.GetArrayHandler(data.type_num).SortArray(data, offset, length);
return(0);
}
private static bool NpyArray_WriteBinaryStream(Stream fs, VoidPtr vp, npy_intp dataLen)
{
npy_intp dataOffset = vp.data_offset;
dataLen = dataOffset + dataLen;
using (var binaryWriter = new BinaryWriter(fs))
{
switch (vp.type_num)
{
default:
return(false);
case NPY_TYPES.NPY_BOOL:
{
bool[] bdata = vp.datap as bool[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
binaryWriter.Write(bdata[i]);
}
break;
}
case NPY_TYPES.NPY_BYTE:
{
sbyte[] bdata = vp.datap as sbyte[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
binaryWriter.Write(bdata[i]);
}
break;
}
case NPY_TYPES.NPY_UBYTE:
{
byte[] bdata = vp.datap as byte[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
binaryWriter.Write(bdata[i]);
}
break;
}
case NPY_TYPES.NPY_INT16:
{
Int16[] bdata = vp.datap as Int16[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
binaryWriter.Write(bdata[i]);
}
break;
}
case NPY_TYPES.NPY_UINT16:
{
UInt16[] bdata = vp.datap as UInt16[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
binaryWriter.Write(bdata[i]);
}
break;
}
case NPY_TYPES.NPY_INT32:
{
Int32[] bdata = vp.datap as Int32[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
binaryWriter.Write(bdata[i]);
}
break;
}
case NPY_TYPES.NPY_UINT32:
{
UInt32[] bdata = vp.datap as UInt32[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
binaryWriter.Write(bdata[i]);
}
break;
}
case NPY_TYPES.NPY_INT64:
{
Int64[] bdata = vp.datap as Int64[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
binaryWriter.Write(bdata[i]);
}
break;
}
case NPY_TYPES.NPY_UINT64:
{
UInt64[] bdata = vp.datap as UInt64[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
binaryWriter.Write(bdata[i]);
}
break;
}
case NPY_TYPES.NPY_FLOAT:
{
float[] bdata = vp.datap as float[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
binaryWriter.Write(bdata[i]);
}
break;
}
case NPY_TYPES.NPY_DOUBLE:
{
double[] bdata = vp.datap as double[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
binaryWriter.Write(bdata[i]);
}
break;
}
case NPY_TYPES.NPY_DECIMAL:
{
decimal[] bdata = vp.datap as decimal[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
binaryWriter.Write(bdata[i]);
}
break;
}
case NPY_TYPES.NPY_COMPLEX:
{
//var bdata = vp.datap as System.Numerics.Complex[];
//for (npy_intp i = dataOffset; i < dataLen; i++)
//{
// binaryWriter.Write(bdata[i]);
//}
break;
}
}
}
return(true);
}
internal static npy_intp NpyArray_ArgMaxFunc(VoidPtr ip, npy_intp startIndex, npy_intp endIndex)
{
return(DefaultArrayHandlers.GetArrayHandler(ip.type_num).ArgMax(ip.datap, startIndex, endIndex));
}
private static bool NpyArray_WriteTextStream(Stream fs, VoidPtr vp, npy_intp dataLen, string sep, string format)
{
npy_intp dataOffset = vp.data_offset;
dataLen = dataOffset + dataLen;
using (var textwriter = new StreamWriter(fs))
{
StringBuilder sb = new StringBuilder();
switch (vp.type_num)
{
default:
return(false);
case NPY_TYPES.NPY_BOOL:
{
if (string.IsNullOrEmpty(format))
{
format = "{0}";
}
bool[] bdata = vp.datap as bool[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
sb.AppendFormat(format, bdata[i]);
sb.Append(sep);
}
break;
}
case NPY_TYPES.NPY_BYTE:
{
if (string.IsNullOrEmpty(format))
{
format = "{0}";
}
sbyte[] bdata = vp.datap as sbyte[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
sb.AppendFormat(format, bdata[i]);
sb.Append(sep);
}
break;
}
case NPY_TYPES.NPY_UBYTE:
{
if (string.IsNullOrEmpty(format))
{
format = "{0}";
}
byte[] bdata = vp.datap as byte[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
sb.AppendFormat(format, bdata[i]);
sb.Append(sep);
}
break;
}
case NPY_TYPES.NPY_INT16:
{
if (string.IsNullOrEmpty(format))
{
format = "{0}";
}
Int16[] bdata = vp.datap as Int16[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
sb.AppendFormat(format, bdata[i]);
sb.Append(sep); textwriter.Write(bdata[i]);
}
break;
}
case NPY_TYPES.NPY_UINT16:
{
if (string.IsNullOrEmpty(format))
{
format = "{0}";
}
UInt16[] bdata = vp.datap as UInt16[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
sb.AppendFormat(format, bdata[i]);
sb.Append(sep);
}
break;
}
case NPY_TYPES.NPY_INT32:
{
if (string.IsNullOrEmpty(format))
{
format = "{0}";
}
Int32[] bdata = vp.datap as Int32[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
sb.AppendFormat(format, bdata[i]);
sb.Append(sep);
}
break;
}
case NPY_TYPES.NPY_UINT32:
{
if (string.IsNullOrEmpty(format))
{
format = "{0}";
}
UInt32[] bdata = vp.datap as UInt32[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
sb.AppendFormat(format, bdata[i]);
sb.Append(sep);
}
break;
}
case NPY_TYPES.NPY_INT64:
{
if (string.IsNullOrEmpty(format))
{
format = "{0}";
}
Int64[] bdata = vp.datap as Int64[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
sb.AppendFormat(format, bdata[i]);
sb.Append(sep);
}
break;
}
case NPY_TYPES.NPY_UINT64:
{
if (string.IsNullOrEmpty(format))
{
format = "{0}";
}
UInt64[] bdata = vp.datap as UInt64[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
sb.AppendFormat(format, bdata[i]);
sb.Append(sep);
}
break;
}
case NPY_TYPES.NPY_FLOAT:
{
if (string.IsNullOrEmpty(format))
{
format = "{0:0.0#######}";
}
float[] bdata = vp.datap as float[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
sb.AppendFormat(format, bdata[i]);
sb.Append(sep);
}
break;
}
case NPY_TYPES.NPY_DOUBLE:
{
if (string.IsNullOrEmpty(format))
{
format = "{0:0.0###############}";
}
double[] bdata = vp.datap as double[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
sb.AppendFormat(format, bdata[i]);
sb.Append(sep);
}
break;
}
case NPY_TYPES.NPY_DECIMAL:
{
if (string.IsNullOrEmpty(format))
{
format = "{0:0.0###############}";
}
decimal[] bdata = vp.datap as decimal[];
for (npy_intp i = dataOffset; i < dataLen; i++)
{
sb.AppendFormat(format, bdata[i]);
sb.Append(sep);
}
break;
}
}
// remove the last seperator and write to the file
sb.Remove(sb.Length - sep.Length, sep.Length);
textwriter.Write(sb.ToString());
}
return(true);
}
private static T SetItem(VoidPtr v, npy_intp index, T d)
{
T[] vv = v.datap as T[];
return(vv[v.data_offset + index] = d);
}
/*
* The same as PyArray_PrepareOneRawArrayIter, but for three
* operands instead of one. Any broadcasting of the three operands
* should have already been done before calling this function,
* as the ndim and shape is only specified once for all operands.
*
* Only the strides of the first operand are used to reorder
* the dimensions, no attempt to consider all the strides together
* is made, as is done in the NpyIter object.
*
* You can use this together with NPY_RAW_ITER_START and
* NPY_RAW_ITER_THREE_NEXT to handle the looping boilerplate of everything
* but the innermost loop (which is for idim == 0).
*
* Returns 0 on success, -1 on failure.
*/
internal static int PyArray_PrepareThreeRawArrayIter(int ndim, npy_intp[] shape,
VoidPtr dataA, npy_intp[] stridesA,
VoidPtr dataB, npy_intp[] stridesB,
VoidPtr dataC, npy_intp[] stridesC,
ref int out_ndim, npy_intp[] out_shape,
ref VoidPtr out_dataA, npy_intp[] out_stridesA,
ref VoidPtr out_dataB, npy_intp[] out_stridesB,
ref VoidPtr out_dataC, npy_intp[] out_stridesC)
{
npy_stride_sort_item [] strideperm = new npy_stride_sort_item[npy_defs.NPY_MAXDIMS];
int i, j;
/* Special case 0 and 1 dimensions */
if (ndim == 0)
{
out_ndim = 1;
out_dataA = dataA;
out_dataB = dataB;
out_dataC = dataC;
out_shape[0] = 1;
out_stridesA[0] = 0;
out_stridesB[0] = 0;
out_stridesC[0] = 0;
return(0);
}
else if (ndim == 1)
{
npy_intp stride_entryA = stridesA[0];
npy_intp stride_entryB = stridesB[0];
npy_intp stride_entryC = stridesC[0];
npy_intp shape_entry = shape[0];
out_ndim = 1;
out_shape[0] = shape[0];
/* Always make a positive stride for the first operand */
if (stride_entryA >= 0)
{
out_dataA = dataA;
out_dataB = dataB;
out_dataC = dataC;
out_stridesA[0] = stride_entryA;
out_stridesB[0] = stride_entryB;
out_stridesC[0] = stride_entryC;
}
else
{
out_dataA = dataA + stride_entryA * (shape_entry - 1);
out_dataB = dataB + stride_entryB * (shape_entry - 1);
out_dataC = dataC + stride_entryC * (shape_entry - 1);
out_stridesA[0] = -stride_entryA;
out_stridesB[0] = -stride_entryB;
out_stridesC[0] = -stride_entryC;
}
return(0);
}
/* Sort the axes based on the destination strides */
PyArray_CreateSortedStridePerm(ndim, stridesA, strideperm);
for (i = 0; i < ndim; ++i)
{
npy_intp iperm = strideperm[ndim - i - 1].perm;
out_shape[i] = shape[iperm];
out_stridesA[i] = stridesA[iperm];
out_stridesB[i] = stridesB[iperm];
out_stridesC[i] = stridesC[iperm];
}
/* Reverse any negative strides of operand A */
for (i = 0; i < ndim; ++i)
{
npy_intp stride_entryA = out_stridesA[i];
npy_intp stride_entryB = out_stridesB[i];
npy_intp stride_entryC = out_stridesC[i];
npy_intp shape_entry = out_shape[i];
if (stride_entryA < 0)
{
dataA += stride_entryA * (shape_entry - 1);
dataB += stride_entryB * (shape_entry - 1);
dataC += stride_entryC * (shape_entry - 1);
out_stridesA[i] = -stride_entryA;
out_stridesB[i] = -stride_entryB;
out_stridesC[i] = -stride_entryC;
}
/* Detect 0-size arrays here */
if (shape_entry == 0)
{
out_ndim = 1;
out_dataA = dataA;
out_dataB = dataB;
out_dataC = dataC;
out_shape[0] = 0;
out_stridesA[0] = 0;
out_stridesB[0] = 0;
out_stridesC[0] = 0;
return(0);
}
}
/* Coalesce any dimensions where possible */
i = 0;
for (j = 1; j < ndim; ++j)
{
if (out_shape[i] == 1)
{
/* Drop axis i */
out_shape[i] = out_shape[j];
out_stridesA[i] = out_stridesA[j];
out_stridesB[i] = out_stridesB[j];
out_stridesC[i] = out_stridesC[j];
}
else if (out_shape[j] == 1)
{
/* Drop axis j */
}
else if (out_stridesA[i] * out_shape[i] == out_stridesA[j] &&
out_stridesB[i] * out_shape[i] == out_stridesB[j] &&
out_stridesC[i] * out_shape[i] == out_stridesC[j])
{
/* Coalesce axes i and j */
out_shape[i] *= out_shape[j];
}
else
{
/* Can't coalesce, go to next i */
++i;
out_shape[i] = out_shape[j];
out_stridesA[i] = out_stridesA[j];
out_stridesB[i] = out_stridesB[j];
out_stridesC[i] = out_stridesC[j];
}
}
ndim = i + 1;
out_dataA = dataA;
out_dataB = dataB;
out_dataC = dataC;
out_ndim = ndim;
return(0);
}
public override int GetTypeSize(VoidPtr v)
{
return(sizeof(UInt16));
}
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;
for (j = 0; j < dims[1]; j++)
{
/* optr[i,j] = iptr[j,i] */
memcpy(optr, iptr, eltsize);
optr.data_offset += eltsize;
iptr.data_offset += stride2;
}
}
Npy_DECREF(tmp);
return(ret);
}
