internal static NpyArray NpyArray_GenericUnaryFunction(NpyArray inputArray, NpyUFuncObject op, NpyArray retArray)
{
NpyArray[] mps = new NpyArray[npy_defs.NPY_MAXARGS];
NpyArray result;
Debug.Assert(Validate(op));
Debug.Assert(Validate(inputArray));
Debug.Assert(Validate(retArray));
mps[0] = inputArray;
Npy_XINCREF(retArray);
mps[1] = retArray;
if (0 > NpyUFunc_GenericFunction(op, 2, mps, 0, null, false, null, null))
{
result = null;
goto finish;
}
if (retArray != null)
{
result = retArray;
}
else
{
result = mps[op.nin];
}
finish:
Npy_XINCREF(result);
if (mps[1] != null && (mps[1].flags & NPYARRAYFLAGS.NPY_UPDATEIFCOPY) != 0)
{
NpyArray_ForceUpdate(mps[1]);
}
Npy_XDECREF(mps[1]);
return(result);
}
private static NpyUFuncObject DefaultOpControl(NpyArray_Ops ops, NpyUFuncGenericFunction UFunc)
{
const int numTypes = 10;
var loc = new NpyUFuncObject()
{
ops = ops,
name = "add",
identity = NpyUFuncIdentity.NpyUFunc_Zero,
nin = 1,
nargs = 1,
types = new NPY_TYPES[numTypes] {
NPY_TYPES.NPY_BYTE, NPY_TYPES.NPY_UBYTE,
NPY_TYPES.NPY_INT16, NPY_TYPES.NPY_UINT16,
NPY_TYPES.NPY_INT32, NPY_TYPES.NPY_UINT32,
NPY_TYPES.NPY_INT64, NPY_TYPES.NPY_UINT64,
NPY_TYPES.NPY_FLOAT, NPY_TYPES.NPY_DOUBLE
},
ntypes = numTypes,
functions = new NpyUFuncGenericFunction[numTypes]
{
UFunc, UFunc, UFunc, UFunc, UFunc, UFunc, UFunc, UFunc, UFunc, UFunc,
}
};
return(loc);
}
internal static NpyArray NpyArray_GenericBinaryFunction(NpyArray m1, NpyArray m2, NpyUFuncObject op, NpyArray outArray)
{
NpyArray[] mps = new NpyArray[npy_defs.NPY_MAXARGS];
NpyArray result;
int i;
Debug.Assert(Validate(op));
Debug.Assert(Validate(m1));
Debug.Assert(Validate(m2));
if (outArray != null)
{
Debug.Assert(Validate(outArray));
}
mps[0] = m1;
mps[1] = m2;
Npy_XINCREF(outArray);
mps[2] = outArray;
for (i = 0; i < 3; i++)
{
Npy_XINCREF(mps[i]);
}
if (0 > NpyUFunc_GenericFunction(op, 3, mps, 0, null, false, null, null))
{
result = null;
goto finish;
}
if (outArray != null)
{
result = outArray;
}
else
{
result = mps[2];
}
finish:
Npy_XINCREF(result);
for (i = 0; i < 3; i++)
{
if (mps[i] != null)
{
if ((mps[i].flags & NPYARRAYFLAGS.NPY_UPDATEIFCOPY) != 0)
{
NpyArray_ForceUpdate(mps[i]);
}
Npy_DECREF(mps[i]);
}
}
return(result);
}
internal static NpyUFuncObject NpyArray_SetNumericOp(NpyArray_Ops op, NpyUFuncObject func)
{
throw new NotImplementedException();
}
internal static NpyUFuncObject NpyArray_GetNumericOp(NpyArray_Ops op)
{
NpyUFuncObject loc = get_op_loc(op);
return((null != loc) ? loc : null);
}
static NpyUFuncObject get_op_loc(NpyArray_Ops op)
{
NpyUFuncObject loc = null;
switch (op)
{
case NpyArray_Ops.npy_op_add:
return(DefaultOpControl(op, UFuncAdd));
case NpyArray_Ops.npy_op_maximum:
return(DefaultOpControl(op, UFuncMax));
case NpyArray_Ops.npy_op_minimum:
return(DefaultOpControl(op, UFuncMin));
case NpyArray_Ops.npy_op_multiply:
return(DefaultOpControl(op, UFuncMultiply));
case NpyArray_Ops.npy_op_logical_or:
return(DefaultOpControl(op, UFuncLogicalOr));
case NpyArray_Ops.npy_op_logical_and:
return(DefaultOpControl(op, UFuncLogicalAnd));
case NpyArray_Ops.npy_op_subtract:
return(DefaultOpControl(op, UFuncSubtract));
case NpyArray_Ops.npy_op_divide:
return(DefaultOpControl(op, UFuncDivide));
case NpyArray_Ops.npy_op_remainder:
return(DefaultOpControl(op, UFuncRemainder));
case NpyArray_Ops.npy_op_fmod:
return(DefaultOpControl(op, UFuncFMod));
case NpyArray_Ops.npy_op_power:
return(DefaultOpControl(op, UFuncPower));
case NpyArray_Ops.npy_op_square:
return(DefaultOpControl(op, UFuncSquare));
case NpyArray_Ops.npy_op_reciprocal:
return(DefaultOpControl(op, UFuncReciprocal));
case NpyArray_Ops.npy_op_ones_like:
return(DefaultOpControl(op, UFuncOnesLike));
case NpyArray_Ops.npy_op_sqrt:
return(DefaultOpControl(op, UFuncSqrt));
case NpyArray_Ops.npy_op_negative:
return(DefaultOpControl(op, UFuncNegative));
case NpyArray_Ops.npy_op_absolute:
return(DefaultOpControl(op, UFuncAbsolute));
case NpyArray_Ops.npy_op_invert:
return(DefaultOpControl(op, UFuncInvert));
case NpyArray_Ops.npy_op_left_shift:
return(DefaultOpControl(op, UFuncLeftShift));
case NpyArray_Ops.npy_op_right_shift:
return(DefaultOpControl(op, UFuncRightShift));
case NpyArray_Ops.npy_op_bitwise_and:
return(DefaultOpControl(op, UFuncBitWiseAnd));
case NpyArray_Ops.npy_op_bitwise_xor:
return(DefaultOpControl(op, UFuncBitWiseXor));
case NpyArray_Ops.npy_op_bitwise_or:
return(DefaultOpControl(op, UFuncBitWiseOr));
case NpyArray_Ops.npy_op_less:
return(DefaultOpControl(op, UFuncLess));
case NpyArray_Ops.npy_op_less_equal:
return(DefaultOpControl(op, UFuncLessEqual));
case NpyArray_Ops.npy_op_equal:
return(DefaultOpControl(op, UFuncEqual));
case NpyArray_Ops.npy_op_not_equal:
return(DefaultOpControl(op, UFuncNotEqual));
case NpyArray_Ops.npy_op_greater:
return(DefaultOpControl(op, UFuncGreater));
case NpyArray_Ops.npy_op_greater_equal:
return(DefaultOpControl(op, UFuncGreaterEqual));
case NpyArray_Ops.npy_op_floor_divide:
return(DefaultOpControl(op, UFuncFloorDivide));
case NpyArray_Ops.npy_op_true_divide:
return(DefaultOpControl(op, UFuncTrueDivide));
case NpyArray_Ops.npy_op_floor:
return(DefaultOpControl(op, UFuncFloor));
case NpyArray_Ops.npy_op_ceil:
return(DefaultOpControl(op, UFuncCeil));
case NpyArray_Ops.npy_op_rint:
return(DefaultOpControl(op, UFuncRint));
case NpyArray_Ops.npy_op_conjugate:
return(DefaultOpControl(op, UFuncConjugate));
default:
loc = null;
break;
}
return(loc);
}
internal static bool Validate(NpyUFuncObject ufunc)
{
return(null != ufunc && npy_defs.NPY_VALID_MAGIC == ufunc.nob_magic_number);
}
internal static NpyArray NpyUFunc_GenericReduction(NpyUFuncObject self, NpyArray arr, NpyArray indices,
NpyArray _out, int axis, NpyArray_Descr otype, GenericReductionOp operation)
{
return(numpyinternal.NpyUFunc_GenericReduction(self, arr, indices, _out, axis, otype, operation, false));
}
internal static NpyUFuncObject NpyArray_SetNumericOp(UFuncOperation op, NpyUFuncObject func)
{
return(numpyinternal.NpyArray_SetNumericOp(op, func));
}
internal ufunc(NpyUFuncObject corePtr)
{
core = corePtr;
}
