internal static int NpyArray_CompareFunc(VoidPtr o1, VoidPtr o2, int elSize, NpyArray npa)
{
dynamic d1 = o1.datap;
dynamic d2 = o2.datap;
return(DefaultArrayHandlers.GetArrayHandler(o1.type_num).CompareTo(d1[o1.data_offset / elSize], d2[o2.data_offset / elSize]));
}
internal static int NpyArray_FillWithScalarFunc(VoidPtr dest, npy_intp length, VoidPtr scalar, NpyArray arr)
{
npy_intp dest_offset = dest.data_offset / arr.ItemSize;
npy_intp scalar_offset = scalar.data_offset / arr.ItemSize;
return(DefaultArrayHandlers.GetArrayHandler(dest.type_num).ArrayFill(dest, scalar, (int)length, (int)dest_offset, (int)scalar_offset));
}
public static NumericOperations GetOperations(UFuncOperation operationType, NumericOperation operation, NpyArray srcArray, NpyArray destArray, NpyArray operandArray)
{
NumericOperations operations = new NumericOperations();
operations.operationType = operationType;
operations.operation = operation;
if (srcArray != null)
{
operations.srcHelper = GetNumericOperationsHelper(srcArray);
operations._ConvertOperand = DefaultArrayHandlers.GetArrayHandler(srcArray.ItemType).MathOpConvertOperand;
}
if (destArray != null)
{
operations.destHelper = GetNumericOperationsHelper(destArray);
operations.destItemType = destArray.ItemType;
operations.destTypeIsFloat = numpyinternal.NpyTypeNum_ISFLOAT(destArray.ItemType);
}
if (operandArray != null)
{
operations.operHelper = GetNumericOperationsHelper(operandArray);
operations.IsSrcAndOperandSameType = srcArray.ItemType == operandArray.ItemType;
}
return(operations);
}
public static NumericOperations GetOperations(NumericOperation operation, NpyArray srcArray, NpyArray destArray, NpyArray operandArray)
{
NumericOperations operations = new NumericOperations();
operations.operation = operation;
if (srcArray != null)
{
operations.srcGetItem = srcArray.descr.f.getitem;
operations.srcSetItem = srcArray.descr.f.setitem;
operations.ConvertOperand = DefaultArrayHandlers.GetArrayHandler(srcArray.ItemType).MathOpConvertOperand;
}
if (destArray != null)
{
operations.destGetItem = destArray.descr.f.getitem;
operations.destSetItem = destArray.descr.f.setitem;
}
if (operandArray != null)
{
operations.operandGetItem = operandArray.descr.f.getitem;
operations.operandSetItem = operandArray.descr.f.setitem;
}
return(operations);
}
internal static ulong VoidPointer_BytesLength(VoidPtr vp)
{
var ArrayHandler = DefaultArrayHandlers.GetArrayHandler(vp.type_num);
var Length = ArrayHandler.GetLength(vp) * ArrayHandler.ItemSize;
return((ulong)(Length - vp.data_offset));
}
internal static int VoidPointer_Length(VoidPtr vp)
{
var ArrayHandler = DefaultArrayHandlers.GetArrayHandler(vp.type_num);
var Length = ArrayHandler.GetLength(vp);
return(Length);
}
public NpyArray_Descr(NPY_TYPES type_num)
{
f = numpyinternal.GetArrFuncs(type_num);
byteorder = numpyinternal.NPY_NATIVE;
this.type_num = type_num;
this.elsize = DefaultArrayHandlers.GetArrayHandler(type_num).ItemSize;
this.f.nonzero = DefaultArrayHandlers.GetArrayHandler(type_num).NonZero;
}
internal static object NpyArray_GetItemFunc(npy_intp index, NpyArray npa)
{
if (npa.ItemType == npa.data.type_num)
{
return(DefaultArrayHandlers.GetArrayHandler(npa.ItemType).GetItem(npa.data, index));
}
else
{
return(DefaultArrayHandlers.GetArrayHandler(npa.ItemType).GetItemDifferentType(npa.data, index, npa.ItemType, npa.ItemSize));
}
}
internal static int NpyArray_SetItemFunc(npy_intp index, object value, NpyArray npa)
{
if (npa.ItemType == npa.data.type_num)
{
return(DefaultArrayHandlers.GetArrayHandler(npa.ItemType).SetItem(npa.data, index, value));
}
else
{
return(DefaultArrayHandlers.GetArrayHandler(npa.ItemType).SetItemDifferentType(npa.data, index, value));
}
}
internal static VoidPtr NpyDataMem_NEW(NPY_TYPES type_num, ulong size, bool AdjustForBytes = true)
{
var ArrayHandler = DefaultArrayHandlers.GetArrayHandler(type_num);
size = size / (AdjustForBytes ? (ulong)ArrayHandler.ItemSize : (ulong)1);
VoidPtr vp = new VoidPtr();
vp.datap = ArrayHandler.AllocateNewArray((int)size);
vp.type_num = type_num;
return(vp);
}
internal static object GetIndex(VoidPtr obj, npy_intp index)
{
if (index < 0)
{
dynamic dyndatap = obj.datap;
index = dyndatap.Length - Math.Abs(index);
}
object ret = DefaultArrayHandlers.GetArrayHandler(obj.type_num).GetIndex(obj, index);
return(ret);
}
internal static bool NpyArray_RegisterDataType(NpyArray_Descr descr)
{
NpyArray_Descr descr2;
NPY_TYPES typenum;
int i;
NpyArray_ArrFuncs f;
/* See if this type is already registered */
for (i = 0; i < npy_userdescrs.Count(); i++)
{
descr2 = npy_userdescrs[i];
if (descr2 == descr)
{
return(true);
}
}
typenum = NPY_TYPES.NPY_USERDEF + npy_userdescrs.Count();
descr.type_num = typenum;
if (descr.elsize == 0)
{
NpyErr_SetString(npyexc_type.NpyExc_ValueError, "cannot register a flexible data-type");
return(false);
}
f = descr.f;
if (f.nonzero == null)
{
f.nonzero = DefaultArrayHandlers.GetArrayHandler(typenum).NonZero;
}
if (f.getitem == null || f.setitem == null)
{
NpyErr_SetString(npyexc_type.NpyExc_ValueError, "a required array function is missing.");
return(false);
}
npy_userdescrs.Add(descr);
return(true);
}
internal static int SetIndex(VoidPtr data, npy_intp index, object invalue)
{
if (index < 0)
{
dynamic dyndatap = data.datap;
index = dyndatap.Length - Math.Abs(index);
}
try
{
DefaultArrayHandlers.GetArrayHandler(data.type_num).SetIndex(data, index, invalue);
}
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);
}
private static int NpyArray_SortFuncTypeNum(VoidPtr data, int offset, int length)
{
DefaultArrayHandlers.GetArrayHandler(data.type_num).SortArray(data, offset, length);
return(0);
}
private static int GetTypeSize(NPY_TYPES type_num)
{
int ItemSize = 0;
switch (type_num)
{
case NPY_TYPES.NPY_BOOL:
{
ItemSize = sizeof(bool);
break;
}
case NPY_TYPES.NPY_BYTE:
{
ItemSize = sizeof(sbyte);
break;
}
case NPY_TYPES.NPY_UBYTE:
{
ItemSize = sizeof(byte);
break;
}
case NPY_TYPES.NPY_INT16:
{
ItemSize = sizeof(Int16);
break;
}
case NPY_TYPES.NPY_UINT16:
{
ItemSize = sizeof(UInt16);
break;
}
case NPY_TYPES.NPY_INT32:
{
ItemSize = sizeof(Int32);
break;
}
case NPY_TYPES.NPY_UINT32:
{
ItemSize = sizeof(UInt32);
break;
}
case NPY_TYPES.NPY_INT64:
{
ItemSize = sizeof(Int64);
break;
}
case NPY_TYPES.NPY_UINT64:
{
ItemSize = sizeof(UInt64);
break;
}
case NPY_TYPES.NPY_FLOAT:
{
ItemSize = sizeof(float);
break;
}
case NPY_TYPES.NPY_DOUBLE:
case NPY_TYPES.NPY_COMPLEXREAL:
case NPY_TYPES.NPY_COMPLEXIMAG:
{
ItemSize = sizeof(double);
break;
}
case NPY_TYPES.NPY_DECIMAL:
{
ItemSize = sizeof(decimal);
break;
}
case NPY_TYPES.NPY_COMPLEX:
{
if (__ComplexSize < 0)
{
__ComplexSize = DefaultArrayHandlers.GetArrayHandler(NPY_TYPES.NPY_COMPLEX).ItemSize;
}
ItemSize = __ComplexSize;
break;
}
case NPY_TYPES.NPY_BIGINT:
{
if (__BigIntSize < 0)
{
__BigIntSize = DefaultArrayHandlers.GetArrayHandler(NPY_TYPES.NPY_BIGINT).ItemSize;
}
ItemSize = __BigIntSize;
break;
}
case NPY_TYPES.NPY_OBJECT:
{
if (__ObjectSize < 0)
{
__ObjectSize = DefaultArrayHandlers.GetArrayHandler(NPY_TYPES.NPY_OBJECT).ItemSize;
}
ItemSize = __ObjectSize;
break;
}
case NPY_TYPES.NPY_STRING:
{
if (__StringSize < 0)
{
__StringSize = DefaultArrayHandlers.GetArrayHandler(NPY_TYPES.NPY_STRING).ItemSize;
}
ItemSize = __StringSize;
break;
}
}
return(ItemSize);
}
internal static void SetArrayHandler(NPY_TYPES ItemType, IArrayHandlers Handlers)
{
DefaultArrayHandlers.SetArrayHandler(ItemType, Handlers);
}
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));
}
internal static IArrayHandlers GetArrayHandler(NPY_TYPES ItemType)
{
return(DefaultArrayHandlers.GetArrayHandler(ItemType));
}
static numpyinternal()
{
DefaultArrayHandlers.Initialize();
}