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); }