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);
}
public static ndarray outer(NpyArray_Ops ops, dtype dtype, object a, object b, ndarray @out = null, int?axis = null)
{
var a1 = np.asanyarray(a);
var b1 = np.asanyarray(b);
List <npy_intp> destdims = new List <npy_intp>();
foreach (var dim in a1.shape.iDims)
{
destdims.Add(dim);
}
foreach (var dim in b1.shape.iDims)
{
destdims.Add(dim);
}
ndarray dest = @out;
if (dest == null)
{
dest = np.empty(new shape(destdims), dtype: dtype != null ? dtype : a1.Dtype);
}
return(NpyCoreApi.PerformOuterOp(a1, b1, dest, ops));
}
internal static ndarray reduce(NpyArray_Ops ops, object a, int axis = 0, dtype dtype = null, ndarray @out = null, bool keepdims = false)
{
ndarray arr = asanyarray(a);
if (arr == null)
{
throw new ValueError("unable to convert a to ndarray");
}
NPY_TYPES rtype = dtype != null ? dtype.TypeNum : arr.Dtype.TypeNum;
return(NpyCoreApi.PerformReduceOp(arr, axis, ops, rtype, @out, keepdims));
}
internal static ndarray reduceat(NpyArray_Ops ops, object a, object indices, int axis = 0, dtype dtype = null, ndarray @out = null)
{
ndarray arr = asanyarray(a);
if (arr == null)
{
throw new ValueError("unable to convert a to ndarray");
}
ndarray indicesarr = asanyarray(indices);
if (indicesarr == null)
{
throw new ValueError("unable to convert indices to ndarray");
}
NPY_TYPES rtype = dtype != null ? dtype.TypeNum : arr.Dtype.TypeNum;
return(NpyCoreApi.PerformReduceAtOp(arr, indicesarr, axis, ops, rtype, @out));
}
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);
}
