private static void _aligned_strided_to_contig_size4(VoidPtr dst, long dst_stride, VoidPtr src, long src_stride, long N, long src_itemsize, NpyAuxData transferdata)
{
_strided_to_strided(dst, dst_stride, src, src_stride, N, src_itemsize, transferdata);
}
private static int get_decsrcref_transfer_function(bool aligned, int elsize, NpyArray_Descr src_dtype, PyArray_StridedUnaryOp out_stransfer, NpyAuxData out_transferdata, bool out_needs_api)
{
throw new NotImplementedException();
}
private static int get_nbo_cast_numeric_transfer_function(bool aligned, long src_stride, long dst_stride, NPY_TYPES src_type_num, NPY_TYPES dst_type_num, PyArray_StridedUnaryOp out_stransfer, NpyAuxData out_transferdata)
{
throw new NotImplementedException();
}
private static void _dec_src_ref_nop(VoidPtr dst, npy_intp dst_stride, VoidPtr src, npy_intp src_stride, npy_intp N, npy_intp src_itemsize, NpyAuxData transferdata)
{
throw new NotImplementedException();
}
private static int PyArray_GetDTypeTransferFunction(bool aligned,
npy_intp src_stride, npy_intp dst_stride,
NpyArray_Descr src_dtype, NpyArray_Descr dst_dtype,
bool move_references,
ref PyArray_StridedUnaryOp out_stransfer,
ref NpyAuxData out_transferdata,
ref bool out_needs_api)
{
npy_intp src_itemsize, dst_itemsize;
NPY_TYPES src_type_num, dst_type_num;
#if NPY_DT_DBG_TRACING
string traceMsg = string.Format("Calculating dtype transfer from {0} to {1}", src_dtype.type_num, dst_dtype.type_num);
Console.WriteLine(traceMsg);
#endif
/*
* If one of the dtypes is NULL, we give back either a src decref
* function or a dst setzero function
*/
if (dst_dtype == null)
{
if (move_references)
{
return(get_decsrcref_transfer_function(aligned,
src_dtype.elsize,
src_dtype,
out_stransfer, out_transferdata,
out_needs_api));
}
else
{
out_stransfer = _dec_src_ref_nop;
out_transferdata = null;
return(npy_defs.NPY_SUCCEED);
}
}
else if (src_dtype == null)
{
return(get_setdstzero_transfer_function(aligned,
dst_dtype.elsize,
dst_dtype,
out_stransfer, out_transferdata,
out_needs_api));
}
src_itemsize = src_dtype.elsize;
dst_itemsize = dst_dtype.elsize;
src_type_num = src_dtype.type_num;
dst_type_num = dst_dtype.type_num;
/* Common special case - number -> number NBO cast */
if (NpyTypeNum_ISNUMBER(src_type_num) &&
NpyTypeNum_ISNUMBER(dst_type_num) &&
NpyArray_ISNBO(src_dtype.byteorder) &&
NpyArray_ISNBO(dst_dtype.byteorder))
{
if (NpyArray_EquivTypenums(src_type_num, dst_type_num))
{
out_stransfer = PyArray_GetStridedCopyFn(aligned,
src_stride, dst_stride,
src_itemsize);
out_transferdata = null;
return((out_stransfer == null) ? npy_defs.NPY_FAIL : npy_defs.NPY_SUCCEED);
}
else
{
return(get_nbo_cast_numeric_transfer_function(aligned,
src_stride, dst_stride,
src_type_num, dst_type_num,
out_stransfer, out_transferdata));
}
}
/*
* If there are no references and the data types are equivalent,
* return a simple copy
*/
if (NpyArray_EquivTypes(src_dtype, dst_dtype) &&
(!NpyDataType_HASFIELDS(dst_dtype) ||
is_dtype_struct_simple_unaligned_layout(dst_dtype)))
{
/*
* We can't pass through the aligned flag because it's not
* appropriate. Consider a size-8 string, it will say it's
* aligned because strings only need alignment 1, but the
* copy function wants to know if it's alignment 8.
*
* TODO: Change align from a flag to a "best power of 2 alignment"
* which holds the strongest alignment value for all
* the data which will be used.
*/
out_stransfer = PyArray_GetStridedCopyFn(false,
src_stride, dst_stride,
src_dtype.elsize);
out_transferdata = null;
return(npy_defs.NPY_SUCCEED);
}
throw new NotImplementedException();
return(npy_defs.NPY_SUCCEED);
}
/*
* Assigns the array from 'src' to 'dst'. The strides must already have
* been broadcast.
*
* Returns 0 on success, -1 on failure.
*/
private static int raw_array_assign_array(int ndim, npy_intp[] shape,
NpyArray_Descr dst_dtype, VoidPtr dst_data, npy_intp[] dst_strides,
NpyArray_Descr src_dtype, VoidPtr src_data, npy_intp[] src_strides)
{
int idim = 0;
npy_intp [] shape_it = new npy_intp[npy_defs.NPY_MAXDIMS];
npy_intp [] dst_strides_it = new npy_intp[npy_defs.NPY_MAXDIMS];
npy_intp [] src_strides_it = new npy_intp[npy_defs.NPY_MAXDIMS];
npy_intp [] coord = new npy_intp[npy_defs.NPY_MAXDIMS];
PyArray_StridedUnaryOp stransfer = null;
NpyAuxData transferdata = null;
bool aligned, needs_api = false;
npy_intp src_itemsize = src_dtype.elsize;
/* Check alignment */
aligned = raw_array_is_aligned(ndim,
dst_data, dst_strides, dst_dtype.alignment) &&
raw_array_is_aligned(ndim,
src_data, src_strides, src_dtype.alignment);
/* Use raw iteration with no heap allocation */
if (PyArray_PrepareTwoRawArrayIter(
ndim, shape,
dst_data, dst_strides,
src_data, src_strides,
ref ndim, shape_it,
ref dst_data, dst_strides_it,
ref src_data, src_strides_it) < 0)
{
return(-1);
}
/*
* Overlap check for the 1D case. Higher dimensional arrays and
* opposite strides cause a temporary copy before getting here.
*/
if (ndim == 1 && arrays_overlap(src_data, dst_data))
{
src_data += (shape_it[0] - 1) * src_strides_it[0];
dst_data += (shape_it[0] - 1) * dst_strides_it[0];
src_strides_it[0] = -src_strides_it[0];
dst_strides_it[0] = -dst_strides_it[0];
}
/* Get the function to do the casting */
if (PyArray_GetDTypeTransferFunction(aligned,
src_strides_it[0], dst_strides_it[0],
src_dtype, dst_dtype,
false,
ref stransfer, ref transferdata,
ref needs_api) != npy_defs.NPY_SUCCEED)
{
return(-1);
}
if (!needs_api)
{
// NPY_BEGIN_THREADS;
}
NPY_RAW_ITER_START(idim, ndim, coord, shape_it);
do
{
/* Process the innermost dimension */
stransfer(dst_data, dst_strides_it[0], src_data, src_strides_it[0],
shape_it[0], src_itemsize, transferdata);
} while (NPY_RAW_ITER_TWO_NEXT(ref idim, ndim, coord, shape_it,
dst_data, dst_strides_it,
src_data, src_strides_it));
//NPY_END_THREADS;
NPY_AUXDATA_FREE(transferdata);
return((needs_api && NpyErr_Occurred()) ? -1 : 0);
}
