Struct numpy::npyffi::array::PyArrayModule

pub struct PyArrayModule { /* fields omitted */ }

Low-Level binding for Array API https://docs.scipy.org/doc/numpy/reference/c-api.array.html

Most of Array API is exposed as the related function of this module object. Some APIs (including most accessor) in the above URL are not implemented since they are defined as C macro, and cannot be called from rust. Some of these are implemented on the high-level interface as a Rust function.

Methods

impl PyArrayModule

fn import(py: Python) -> PyResult<Self>

Import numpy.core.multiarray to use Array API.

unsafe fn PyArray_GetNDArrayCVersion(&self) -> c_uint

unsafe fn PyArray_SetNumericOps(&self, dict: *mut PyObject) -> c_int

unsafe fn PyArray_GetNumericOps(&self) -> *mut PyObject

unsafe fn PyArray_INCREF(&self, mp: *mut PyArrayObject) -> c_int

unsafe fn PyArray_XDECREF(&self, mp: *mut PyArrayObject) -> c_int

unsafe fn PyArray_SetStringFunction(&self, op: *mut PyObject, repr: c_int)

unsafe fn PyArray_DescrFromType(&self, type_: c_int) -> *mut PyArray_Descr

unsafe fn PyArray_TypeObjectFromType(&self, type_: c_int) -> *mut PyObject

unsafe fn PyArray_Zero(&self, arr: *mut PyArrayObject) -> *mut c_char

unsafe fn PyArray_One(&self, arr: *mut PyArrayObject) -> *mut c_char

unsafe fn PyArray_CastToType(
    &self,
    arr: *mut PyArrayObject,
    dtype: *mut PyArray_Descr,
    is_f_order: c_int
) -> *mut PyObject

unsafe fn PyArray_CastTo(
    &self,
    out: *mut PyArrayObject,
    mp: *mut PyArrayObject
) -> c_int

unsafe fn PyArray_CastAnyTo(
    &self,
    out: *mut PyArrayObject,
    mp: *mut PyArrayObject
) -> c_int

unsafe fn PyArray_CanCastSafely(&self, fromtype: c_int, totype: c_int) -> c_int

unsafe fn PyArray_CanCastTo(
    &self,
    from: *mut PyArray_Descr,
    to: *mut PyArray_Descr
) -> npy_bool

unsafe fn PyArray_ObjectType(
    &self,
    op: *mut PyObject,
    minimum_type: c_int
) -> c_int

unsafe fn PyArray_DescrFromObject(
    &self,
    op: *mut PyObject,
    mintype: *mut PyArray_Descr
) -> *mut PyArray_Descr

unsafe fn PyArray_ConvertToCommonType(
    &self,
    op: *mut PyObject,
    retn: *mut c_int
) -> *mut *mut PyArrayObject

unsafe fn PyArray_DescrFromScalar(
    &self,
    sc: *mut PyObject
) -> *mut PyArray_Descr

unsafe fn PyArray_DescrFromTypeObject(
    &self,
    type_: *mut PyObject
) -> *mut PyArray_Descr

unsafe fn PyArray_Size(&self, op: *mut PyObject) -> npy_intp

unsafe fn PyArray_Scalar(
    &self,
    data: *mut c_void,
    descr: *mut PyArray_Descr,
    base: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_FromScalar(
    &self,
    scalar: *mut PyObject,
    outcode: *mut PyArray_Descr
) -> *mut PyObject

unsafe fn PyArray_ScalarAsCtype(
    &self,
    scalar: *mut PyObject,
    ctypeptr: *mut c_void
)

unsafe fn PyArray_CastScalarToCtype(
    &self,
    scalar: *mut PyObject,
    ctypeptr: *mut c_void,
    outcode: *mut PyArray_Descr
) -> c_int

unsafe fn PyArray_CastScalarDirect(
    &self,
    scalar: *mut PyObject,
    indescr: *mut PyArray_Descr,
    ctypeptr: *mut c_void,
    outtype: c_int
) -> c_int

unsafe fn PyArray_ScalarFromObject(
    &self,
    object: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_GetCastFunc(
    &self,
    descr: *mut PyArray_Descr,
    type_num: c_int
) -> PyArray_VectorUnaryFunc

unsafe fn PyArray_FromDims(
    &self,
    nd: c_int,
    d: *mut c_int,
    type_: c_int
) -> *mut PyObject

unsafe fn PyArray_FromDimsAndDataAndDescr(
    &self,
    nd: c_int,
    d: *mut c_int,
    descr: *mut PyArray_Descr,
    data: *mut c_char
) -> *mut PyObject

unsafe fn PyArray_FromAny(
    &self,
    op: *mut PyObject,
    newtype: *mut PyArray_Descr,
    min_depth: c_int,
    max_depth: c_int,
    flags: c_int,
    context: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_EnsureArray(&self, op: *mut PyObject) -> *mut PyObject

unsafe fn PyArray_EnsureAnyArray(&self, op: *mut PyObject) -> *mut PyObject

unsafe fn PyArray_FromFile(
    &self,
    fp: *mut FILE,
    dtype: *mut PyArray_Descr,
    num: npy_intp,
    sep: *mut c_char
) -> *mut PyObject

unsafe fn PyArray_FromString(
    &self,
    data: *mut c_char,
    slen: npy_intp,
    dtype: *mut PyArray_Descr,
    num: npy_intp,
    sep: *mut c_char
) -> *mut PyObject

unsafe fn PyArray_FromBuffer(
    &self,
    buf: *mut PyObject,
    type_: *mut PyArray_Descr,
    count: npy_intp,
    offset: npy_intp
) -> *mut PyObject

unsafe fn PyArray_FromIter(
    &self,
    obj: *mut PyObject,
    dtype: *mut PyArray_Descr,
    count: npy_intp
) -> *mut PyObject

unsafe fn PyArray_Return(&self, mp: *mut PyArrayObject) -> *mut PyObject

unsafe fn PyArray_GetField(
    &self,
    self_: *mut PyArrayObject,
    typed: *mut PyArray_Descr,
    offset: c_int
) -> *mut PyObject

unsafe fn PyArray_SetField(
    &self,
    self_: *mut PyArrayObject,
    dtype: *mut PyArray_Descr,
    offset: c_int,
    val: *mut PyObject
) -> c_int

unsafe fn PyArray_Byteswap(
    &self,
    self_: *mut PyArrayObject,
    inplace: npy_bool
) -> *mut PyObject

unsafe fn PyArray_Resize(
    &self,
    self_: *mut PyArrayObject,
    newshape: *mut PyArray_Dims,
    refcheck: c_int,
    order: NPY_ORDER
) -> *mut PyObject

unsafe fn PyArray_MoveInto(
    &self,
    dst: *mut PyArrayObject,
    src: *mut PyArrayObject
) -> c_int

unsafe fn PyArray_CopyInto(
    &self,
    dst: *mut PyArrayObject,
    src: *mut PyArrayObject
) -> c_int

unsafe fn PyArray_CopyAnyInto(
    &self,
    dst: *mut PyArrayObject,
    src: *mut PyArrayObject
) -> c_int

unsafe fn PyArray_CopyObject(
    &self,
    dest: *mut PyArrayObject,
    src_object: *mut PyObject
) -> c_int

unsafe fn PyArray_NewCopy(
    &self,
    obj: *mut PyArrayObject,
    order: NPY_ORDER
) -> *mut PyObject

unsafe fn PyArray_ToList(&self, self_: *mut PyArrayObject) -> *mut PyObject

unsafe fn PyArray_ToString(
    &self,
    self_: *mut PyArrayObject,
    order: NPY_ORDER
) -> *mut PyObject

unsafe fn PyArray_ToFile(
    &self,
    self_: *mut PyArrayObject,
    fp: *mut FILE,
    sep: *mut c_char,
    format: *mut c_char
) -> c_int

unsafe fn PyArray_Dump(
    &self,
    self_: *mut PyObject,
    file: *mut PyObject,
    protocol: c_int
) -> c_int

unsafe fn PyArray_Dumps(
    &self,
    self_: *mut PyObject,
    protocol: c_int
) -> *mut PyObject

unsafe fn PyArray_ValidType(&self, type_: c_int) -> c_int

unsafe fn PyArray_UpdateFlags(&self, ret: *mut PyArrayObject, flagmask: c_int)

unsafe fn PyArray_New(
    &self,
    subtype: *mut PyTypeObject,
    nd: c_int,
    dims: *mut npy_intp,
    type_num: c_int,
    strides: *mut npy_intp,
    data: *mut c_void,
    itemsize: c_int,
    flags: c_int,
    obj: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_NewFromDescr(
    &self,
    subtype: *mut PyTypeObject,
    descr: *mut PyArray_Descr,
    nd: c_int,
    dims: *mut npy_intp,
    strides: *mut npy_intp,
    data: *mut c_void,
    flags: c_int,
    obj: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_DescrNew(
    &self,
    base: *mut PyArray_Descr
) -> *mut PyArray_Descr

unsafe fn PyArray_DescrNewFromType(&self, type_num: c_int) -> *mut PyArray_Descr

unsafe fn PyArray_GetPriority(&self, obj: *mut PyObject, default_: f64) -> f64

unsafe fn PyArray_IterNew(&self, obj: *mut PyObject) -> *mut PyObject

unsafe fn PyArray_PyIntAsInt(&self, o: *mut PyObject) -> c_int

unsafe fn PyArray_PyIntAsIntp(&self, o: *mut PyObject) -> npy_intp

unsafe fn PyArray_Broadcast(&self, mit: *mut PyArrayMultiIterObject) -> c_int

unsafe fn PyArray_FillObjectArray(
    &self,
    arr: *mut PyArrayObject,
    obj: *mut PyObject
)

unsafe fn PyArray_FillWithScalar(
    &self,
    arr: *mut PyArrayObject,
    obj: *mut PyObject
) -> c_int

unsafe fn PyArray_CheckStrides(
    &self,
    elsize: c_int,
    nd: c_int,
    numbytes: npy_intp,
    offset: npy_intp,
    dims: *mut npy_intp,
    newstrides: *mut npy_intp
) -> npy_bool

unsafe fn PyArray_DescrNewByteorder(
    &self,
    self_: *mut PyArray_Descr,
    newendian: c_char
) -> *mut PyArray_Descr

unsafe fn PyArray_IterAllButAxis(
    &self,
    obj: *mut PyObject,
    inaxis: *mut c_int
) -> *mut PyObject

unsafe fn PyArray_CheckFromAny(
    &self,
    op: *mut PyObject,
    descr: *mut PyArray_Descr,
    min_depth: c_int,
    max_depth: c_int,
    requires: c_int,
    context: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_FromArray(
    &self,
    arr: *mut PyArrayObject,
    newtype: *mut PyArray_Descr,
    flags: c_int
) -> *mut PyObject

unsafe fn PyArray_FromInterface(&self, origin: *mut PyObject) -> *mut PyObject

unsafe fn PyArray_FromStructInterface(
    &self,
    input: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_FromArrayAttr(
    &self,
    op: *mut PyObject,
    typecode: *mut PyArray_Descr,
    context: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_ScalarKind(
    &self,
    typenum: c_int,
    arr: *mut *mut PyArrayObject
) -> NPY_SCALARKIND

unsafe fn PyArray_CanCoerceScalar(
    &self,
    thistype: c_int,
    neededtype: c_int,
    scalar: NPY_SCALARKIND
) -> c_int

unsafe fn PyArray_NewFlagsObject(&self, obj: *mut PyObject) -> *mut PyObject

unsafe fn PyArray_CanCastScalar(
    &self,
    from: *mut PyTypeObject,
    to: *mut PyTypeObject
) -> npy_bool

unsafe fn PyArray_CompareUCS4(
    &self,
    s1: *mut npy_ucs4,
    s2: *mut npy_ucs4,
    len: usize
) -> c_int

unsafe fn PyArray_RemoveSmallest(
    &self,
    multi: *mut PyArrayMultiIterObject
) -> c_int

unsafe fn PyArray_ElementStrides(&self, obj: *mut PyObject) -> c_int

unsafe fn PyArray_Item_INCREF(
    &self,
    data: *mut c_char,
    descr: *mut PyArray_Descr
)

unsafe fn PyArray_Item_XDECREF(
    &self,
    data: *mut c_char,
    descr: *mut PyArray_Descr
)

unsafe fn PyArray_FieldNames(&self, fields: *mut PyObject) -> *mut PyObject

unsafe fn PyArray_Transpose(
    &self,
    ap: *mut PyArrayObject,
    permute: *mut PyArray_Dims
) -> *mut PyObject

unsafe fn PyArray_TakeFrom(
    &self,
    self0: *mut PyArrayObject,
    indices0: *mut PyObject,
    axis: c_int,
    out: *mut PyArrayObject,
    clipmode: NPY_CLIPMODE
) -> *mut PyObject

unsafe fn PyArray_PutTo(
    &self,
    self_: *mut PyArrayObject,
    values0: *mut PyObject,
    indices0: *mut PyObject,
    clipmode: NPY_CLIPMODE
) -> *mut PyObject

unsafe fn PyArray_PutMask(
    &self,
    self_: *mut PyArrayObject,
    values0: *mut PyObject,
    mask0: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_Repeat(
    &self,
    aop: *mut PyArrayObject,
    op: *mut PyObject,
    axis: c_int
) -> *mut PyObject

unsafe fn PyArray_Choose(
    &self,
    ip: *mut PyArrayObject,
    op: *mut PyObject,
    out: *mut PyArrayObject,
    clipmode: NPY_CLIPMODE
) -> *mut PyObject

unsafe fn PyArray_Sort(
    &self,
    op: *mut PyArrayObject,
    axis: c_int,
    which: NPY_SORTKIND
) -> c_int

unsafe fn PyArray_ArgSort(
    &self,
    op: *mut PyArrayObject,
    axis: c_int,
    which: NPY_SORTKIND
) -> *mut PyObject

unsafe fn PyArray_SearchSorted(
    &self,
    op1: *mut PyArrayObject,
    op2: *mut PyObject,
    side: NPY_SEARCHSIDE,
    perm: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_ArgMax(
    &self,
    op: *mut PyArrayObject,
    axis: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_ArgMin(
    &self,
    op: *mut PyArrayObject,
    axis: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_Reshape(
    &self,
    self_: *mut PyArrayObject,
    shape: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_Newshape(
    &self,
    self_: *mut PyArrayObject,
    newdims: *mut PyArray_Dims,
    order: NPY_ORDER
) -> *mut PyObject

unsafe fn PyArray_Squeeze(&self, self_: *mut PyArrayObject) -> *mut PyObject

unsafe fn PyArray_View(
    &self,
    self_: *mut PyArrayObject,
    type_: *mut PyArray_Descr,
    pytype: *mut PyTypeObject
) -> *mut PyObject

unsafe fn PyArray_SwapAxes(
    &self,
    ap: *mut PyArrayObject,
    a1: c_int,
    a2: c_int
) -> *mut PyObject

unsafe fn PyArray_Max(
    &self,
    ap: *mut PyArrayObject,
    axis: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_Min(
    &self,
    ap: *mut PyArrayObject,
    axis: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_Ptp(
    &self,
    ap: *mut PyArrayObject,
    axis: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_Mean(
    &self,
    self_: *mut PyArrayObject,
    axis: c_int,
    rtype: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_Trace(
    &self,
    self_: *mut PyArrayObject,
    offset: c_int,
    axis1: c_int,
    axis2: c_int,
    rtype: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_Diagonal(
    &self,
    self_: *mut PyArrayObject,
    offset: c_int,
    axis1: c_int,
    axis2: c_int
) -> *mut PyObject

unsafe fn PyArray_Clip(
    &self,
    self_: *mut PyArrayObject,
    min: *mut PyObject,
    max: *mut PyObject,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_Conjugate(
    &self,
    self_: *mut PyArrayObject,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_Nonzero(&self, self_: *mut PyArrayObject) -> *mut PyObject

unsafe fn PyArray_Std(
    &self,
    self_: *mut PyArrayObject,
    axis: c_int,
    rtype: c_int,
    out: *mut PyArrayObject,
    variance: c_int
) -> *mut PyObject

unsafe fn PyArray_Sum(
    &self,
    self_: *mut PyArrayObject,
    axis: c_int,
    rtype: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_CumSum(
    &self,
    self_: *mut PyArrayObject,
    axis: c_int,
    rtype: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_Prod(
    &self,
    self_: *mut PyArrayObject,
    axis: c_int,
    rtype: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_CumProd(
    &self,
    self_: *mut PyArrayObject,
    axis: c_int,
    rtype: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_All(
    &self,
    self_: *mut PyArrayObject,
    axis: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_Any(
    &self,
    self_: *mut PyArrayObject,
    axis: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_Compress(
    &self,
    self_: *mut PyArrayObject,
    condition: *mut PyObject,
    axis: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_Flatten(
    &self,
    a: *mut PyArrayObject,
    order: NPY_ORDER
) -> *mut PyObject

unsafe fn PyArray_Ravel(
    &self,
    arr: *mut PyArrayObject,
    order: NPY_ORDER
) -> *mut PyObject

unsafe fn PyArray_MultiplyList(&self, l1: *mut npy_intp, n: c_int) -> npy_intp

unsafe fn PyArray_MultiplyIntList(&self, l1: *mut c_int, n: c_int) -> c_int

unsafe fn PyArray_GetPtr(
    &self,
    obj: *mut PyArrayObject,
    ind: *mut npy_intp
) -> *mut c_void

unsafe fn PyArray_CompareLists(
    &self,
    l1: *mut npy_intp,
    l2: *mut npy_intp,
    n: c_int
) -> c_int

unsafe fn PyArray_AsCArray(
    &self,
    op: *mut *mut PyObject,
    ptr: *mut c_void,
    dims: *mut npy_intp,
    nd: c_int,
    typedescr: *mut PyArray_Descr
) -> c_int

unsafe fn PyArray_As1D(
    &self,
    op: *mut *mut PyObject,
    ptr: *mut *mut c_char,
    d1: *mut c_int,
    typecode: c_int
) -> c_int

unsafe fn PyArray_As2D(
    &self,
    op: *mut *mut PyObject,
    ptr: *mut *mut *mut c_char,
    d1: *mut c_int,
    d2: *mut c_int,
    typecode: c_int
) -> c_int

unsafe fn PyArray_Free(&self, op: *mut PyObject, ptr: *mut c_void) -> c_int

unsafe fn PyArray_Converter(
    &self,
    object: *mut PyObject,
    address: *mut *mut PyObject
) -> c_int

unsafe fn PyArray_IntpFromSequence(
    &self,
    seq: *mut PyObject,
    vals: *mut npy_intp,
    maxvals: c_int
) -> c_int

unsafe fn PyArray_Concatenate(
    &self,
    op: *mut PyObject,
    axis: c_int
) -> *mut PyObject

unsafe fn PyArray_InnerProduct(
    &self,
    op1: *mut PyObject,
    op2: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_MatrixProduct(
    &self,
    op1: *mut PyObject,
    op2: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_CopyAndTranspose(&self, op: *mut PyObject) -> *mut PyObject

unsafe fn PyArray_Correlate(
    &self,
    op1: *mut PyObject,
    op2: *mut PyObject,
    mode: c_int
) -> *mut PyObject

unsafe fn PyArray_TypestrConvert(
    &self,
    itemsize: c_int,
    gentype: c_int
) -> c_int

unsafe fn PyArray_DescrConverter(
    &self,
    obj: *mut PyObject,
    at: *mut *mut PyArray_Descr
) -> c_int

unsafe fn PyArray_DescrConverter2(
    &self,
    obj: *mut PyObject,
    at: *mut *mut PyArray_Descr
) -> c_int

unsafe fn PyArray_IntpConverter(
    &self,
    obj: *mut PyObject,
    seq: *mut PyArray_Dims
) -> c_int

unsafe fn PyArray_BufferConverter(
    &self,
    obj: *mut PyObject,
    buf: *mut PyArray_Chunk
) -> c_int

unsafe fn PyArray_AxisConverter(
    &self,
    obj: *mut PyObject,
    axis: *mut c_int
) -> c_int

unsafe fn PyArray_BoolConverter(
    &self,
    object: *mut PyObject,
    val: *mut npy_bool
) -> c_int

unsafe fn PyArray_ByteorderConverter(
    &self,
    obj: *mut PyObject,
    endian: *mut c_char
) -> c_int

unsafe fn PyArray_OrderConverter(
    &self,
    object: *mut PyObject,
    val: *mut NPY_ORDER
) -> c_int

unsafe fn PyArray_EquivTypes(
    &self,
    type1: *mut PyArray_Descr,
    type2: *mut PyArray_Descr
) -> c_uchar

unsafe fn PyArray_Zeros(
    &self,
    nd: c_int,
    dims: *mut npy_intp,
    type_: *mut PyArray_Descr,
    is_f_order: c_int
) -> *mut PyObject

unsafe fn PyArray_Empty(
    &self,
    nd: c_int,
    dims: *mut npy_intp,
    type_: *mut PyArray_Descr,
    is_f_order: c_int
) -> *mut PyObject

unsafe fn PyArray_Where(
    &self,
    condition: *mut PyObject,
    x: *mut PyObject,
    y: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_Arange(
    &self,
    start: f64,
    stop: f64,
    step: f64,
    type_num: c_int
) -> *mut PyObject

unsafe fn PyArray_ArangeObj(
    &self,
    start: *mut PyObject,
    stop: *mut PyObject,
    step: *mut PyObject,
    dtype: *mut PyArray_Descr
) -> *mut PyObject

unsafe fn PyArray_SortkindConverter(
    &self,
    obj: *mut PyObject,
    sortkind: *mut NPY_SORTKIND
) -> c_int

unsafe fn PyArray_LexSort(
    &self,
    sort_keys: *mut PyObject,
    axis: c_int
) -> *mut PyObject

unsafe fn PyArray_Round(
    &self,
    a: *mut PyArrayObject,
    decimals: c_int,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_EquivTypenums(
    &self,
    typenum1: c_int,
    typenum2: c_int
) -> c_uchar

unsafe fn PyArray_RegisterDataType(&self, descr: *mut PyArray_Descr) -> c_int

unsafe fn PyArray_RegisterCastFunc(
    &self,
    descr: *mut PyArray_Descr,
    totype: c_int,
    castfunc: PyArray_VectorUnaryFunc
) -> c_int

unsafe fn PyArray_RegisterCanCast(
    &self,
    descr: *mut PyArray_Descr,
    totype: c_int,
    scalar: NPY_SCALARKIND
) -> c_int

unsafe fn PyArray_InitArrFuncs(&self, f: *mut PyArray_ArrFuncs)

unsafe fn PyArray_IntTupleFromIntp(
    &self,
    len: c_int,
    vals: *mut npy_intp
) -> *mut PyObject

unsafe fn PyArray_TypeNumFromName(&self, str: *mut c_char) -> c_int

unsafe fn PyArray_ClipmodeConverter(
    &self,
    object: *mut PyObject,
    val: *mut NPY_CLIPMODE
) -> c_int

unsafe fn PyArray_OutputConverter(
    &self,
    object: *mut PyObject,
    address: *mut *mut PyArrayObject
) -> c_int

unsafe fn PyArray_BroadcastToShape(
    &self,
    obj: *mut PyObject,
    dims: *mut npy_intp,
    nd: c_int
) -> *mut PyObject

unsafe fn _PyArray_SigintHandler(&self, signum: c_int)

unsafe fn _PyArray_GetSigintBuf(&self) -> *mut c_void

unsafe fn PyArray_DescrAlignConverter(
    &self,
    obj: *mut PyObject,
    at: *mut *mut PyArray_Descr
) -> c_int

unsafe fn PyArray_DescrAlignConverter2(
    &self,
    obj: *mut PyObject,
    at: *mut *mut PyArray_Descr
) -> c_int

unsafe fn PyArray_SearchsideConverter(
    &self,
    obj: *mut PyObject,
    addr: *mut c_void
) -> c_int

unsafe fn PyArray_CheckAxis(
    &self,
    arr: *mut PyArrayObject,
    axis: *mut c_int,
    flags: c_int
) -> *mut PyObject

unsafe fn PyArray_OverflowMultiplyList(
    &self,
    l1: *mut npy_intp,
    n: c_int
) -> npy_intp

unsafe fn PyArray_CompareString(
    &self,
    s1: *mut c_char,
    s2: *mut c_char,
    len: usize
) -> c_int

unsafe fn PyArray_GetEndianness(&self) -> c_int

unsafe fn PyArray_GetNDArrayCFeatureVersion(&self) -> c_uint

unsafe fn PyArray_Correlate2(
    &self,
    op1: *mut PyObject,
    op2: *mut PyObject,
    mode: c_int
) -> *mut PyObject

unsafe fn PyArray_NeighborhoodIterNew(
    &self,
    x: *mut PyArrayIterObject,
    bounds: *mut npy_intp,
    mode: c_int,
    fill: *mut PyArrayObject
) -> *mut PyObject

unsafe fn PyArray_SetDatetimeParseFunction(&self, op: *mut PyObject)

unsafe fn PyArray_DatetimeToDatetimeStruct(
    &self,
    val: npy_datetime,
    fr: NPY_DATETIMEUNIT,
    result: *mut npy_datetimestruct
)

unsafe fn PyArray_TimedeltaToTimedeltaStruct(
    &self,
    val: npy_timedelta,
    fr: NPY_DATETIMEUNIT,
    result: *mut npy_timedeltastruct
)

unsafe fn PyArray_DatetimeStructToDatetime(
    &self,
    fr: NPY_DATETIMEUNIT,
    d: *mut npy_datetimestruct
) -> npy_datetime

unsafe fn PyArray_TimedeltaStructToTimedelta(
    &self,
    fr: NPY_DATETIMEUNIT,
    d: *mut npy_timedeltastruct
) -> npy_datetime

unsafe fn NpyIter_New(
    &self,
    op: *mut PyArrayObject,
    flags: npy_uint32,
    order: NPY_ORDER,
    casting: NPY_CASTING,
    dtype: *mut PyArray_Descr
) -> *mut NpyIter

unsafe fn NpyIter_MultiNew(
    &self,
    nop: c_int,
    op_in: *mut *mut PyArrayObject,
    flags: npy_uint32,
    order: NPY_ORDER,
    casting: NPY_CASTING,
    op_flags: *mut npy_uint32,
    op_request_dtypes: *mut *mut PyArray_Descr
) -> *mut NpyIter

unsafe fn NpyIter_AdvancedNew(
    &self,
    nop: c_int,
    op_in: *mut *mut PyArrayObject,
    flags: npy_uint32,
    order: NPY_ORDER,
    casting: NPY_CASTING,
    op_flags: *mut npy_uint32,
    op_request_dtypes: *mut *mut PyArray_Descr,
    oa_ndim: c_int,
    op_axes: *mut *mut c_int,
    itershape: *mut npy_intp,
    buffersize: npy_intp
) -> *mut NpyIter

unsafe fn NpyIter_Copy(&self, iter: *mut NpyIter) -> *mut NpyIter

unsafe fn NpyIter_Deallocate(&self, iter: *mut NpyIter) -> c_int

unsafe fn NpyIter_HasDelayedBufAlloc(&self, iter: *mut NpyIter) -> npy_bool

unsafe fn NpyIter_HasExternalLoop(&self, iter: *mut NpyIter) -> npy_bool

unsafe fn NpyIter_EnableExternalLoop(&self, iter: *mut NpyIter) -> c_int

unsafe fn NpyIter_GetInnerStrideArray(
    &self,
    iter: *mut NpyIter
) -> *mut npy_intp

unsafe fn NpyIter_GetInnerLoopSizePtr(
    &self,
    iter: *mut NpyIter
) -> *mut npy_intp

unsafe fn NpyIter_Reset(
    &self,
    iter: *mut NpyIter,
    errmsg: *mut *mut c_char
) -> c_int

unsafe fn NpyIter_ResetBasePointers(
    &self,
    iter: *mut NpyIter,
    baseptrs: *mut *mut c_char,
    errmsg: *mut *mut c_char
) -> c_int

unsafe fn NpyIter_ResetToIterIndexRange(
    &self,
    iter: *mut NpyIter,
    istart: npy_intp,
    iend: npy_intp,
    errmsg: *mut *mut c_char
) -> c_int

unsafe fn NpyIter_GetNDim(&self, iter: *mut NpyIter) -> c_int

unsafe fn NpyIter_GetNOp(&self, iter: *mut NpyIter) -> c_int

unsafe fn NpyIter_GetIterNext(
    &self,
    iter: *mut NpyIter,
    errmsg: *mut *mut c_char
) -> NpyIter_IterNextFunc

unsafe fn NpyIter_GetIterSize(&self, iter: *mut NpyIter) -> npy_intp

unsafe fn NpyIter_GetIterIndexRange(
    &self,
    iter: *mut NpyIter,
    istart: *mut npy_intp,
    iend: *mut npy_intp
)

unsafe fn NpyIter_GetIterIndex(&self, iter: *mut NpyIter) -> npy_intp

unsafe fn NpyIter_GotoIterIndex(
    &self,
    iter: *mut NpyIter,
    iterindex: npy_intp
) -> c_int

unsafe fn NpyIter_HasMultiIndex(&self, iter: *mut NpyIter) -> npy_bool

unsafe fn NpyIter_GetShape(
    &self,
    iter: *mut NpyIter,
    outshape: *mut npy_intp
) -> c_int

unsafe fn NpyIter_GetGetMultiIndex(
    &self,
    iter: *mut NpyIter,
    errmsg: *mut *mut c_char
) -> NpyIter_GetMultiIndexFunc

unsafe fn NpyIter_GotoMultiIndex(
    &self,
    iter: *mut NpyIter,
    multi_index: *mut npy_intp
) -> c_int

unsafe fn NpyIter_RemoveMultiIndex(&self, iter: *mut NpyIter) -> c_int

unsafe fn NpyIter_HasIndex(&self, iter: *mut NpyIter) -> npy_bool

unsafe fn NpyIter_IsBuffered(&self, iter: *mut NpyIter) -> npy_bool

unsafe fn NpyIter_IsGrowInner(&self, iter: *mut NpyIter) -> npy_bool

unsafe fn NpyIter_GetBufferSize(&self, iter: *mut NpyIter) -> npy_intp

unsafe fn NpyIter_GetIndexPtr(&self, iter: *mut NpyIter) -> *mut npy_intp

unsafe fn NpyIter_GotoIndex(
    &self,
    iter: *mut NpyIter,
    flat_index: npy_intp
) -> c_int

unsafe fn NpyIter_GetDataPtrArray(&self, iter: *mut NpyIter) -> *mut *mut c_char

unsafe fn NpyIter_GetDescrArray(
    &self,
    iter: *mut NpyIter
) -> *mut *mut PyArray_Descr

unsafe fn NpyIter_GetOperandArray(
    &self,
    iter: *mut NpyIter
) -> *mut *mut PyArrayObject

unsafe fn NpyIter_GetIterView(
    &self,
    iter: *mut NpyIter,
    i: npy_intp
) -> *mut PyArrayObject

unsafe fn NpyIter_GetReadFlags(
    &self,
    iter: *mut NpyIter,
    outreadflags: *mut c_char
)

unsafe fn NpyIter_GetWriteFlags(
    &self,
    iter: *mut NpyIter,
    outwriteflags: *mut c_char
)

unsafe fn NpyIter_DebugPrint(&self, iter: *mut NpyIter)

unsafe fn NpyIter_IterationNeedsAPI(&self, iter: *mut NpyIter) -> npy_bool

unsafe fn NpyIter_GetInnerFixedStrideArray(
    &self,
    iter: *mut NpyIter,
    out_strides: *mut npy_intp
)

unsafe fn NpyIter_RemoveAxis(&self, iter: *mut NpyIter, axis: c_int) -> c_int

unsafe fn NpyIter_GetAxisStrideArray(
    &self,
    iter: *mut NpyIter,
    axis: c_int
) -> *mut npy_intp

unsafe fn NpyIter_RequiresBuffering(&self, iter: *mut NpyIter) -> npy_bool

unsafe fn NpyIter_GetInitialDataPtrArray(
    &self,
    iter: *mut NpyIter
) -> *mut *mut c_char

unsafe fn NpyIter_CreateCompatibleStrides(
    &self,
    iter: *mut NpyIter,
    itemsize: npy_intp,
    outstrides: *mut npy_intp
) -> c_int

unsafe fn PyArray_CastingConverter(
    &self,
    obj: *mut PyObject,
    casting: *mut NPY_CASTING
) -> c_int

unsafe fn PyArray_CountNonzero(&self, self_: *mut PyArrayObject) -> npy_intp

unsafe fn PyArray_PromoteTypes(
    &self,
    type1: *mut PyArray_Descr,
    type2: *mut PyArray_Descr
) -> *mut PyArray_Descr

unsafe fn PyArray_MinScalarType(
    &self,
    arr: *mut PyArrayObject
) -> *mut PyArray_Descr

unsafe fn PyArray_ResultType(
    &self,
    narrs: npy_intp,
    arr: *mut *mut PyArrayObject,
    ndtypes: npy_intp,
    dtypes: *mut *mut PyArray_Descr
) -> *mut PyArray_Descr

unsafe fn PyArray_CanCastArrayTo(
    &self,
    arr: *mut PyArrayObject,
    to: *mut PyArray_Descr,
    casting: NPY_CASTING
) -> npy_bool

unsafe fn PyArray_CanCastTypeTo(
    &self,
    from: *mut PyArray_Descr,
    to: *mut PyArray_Descr,
    casting: NPY_CASTING
) -> npy_bool

unsafe fn PyArray_EinsteinSum(
    &self,
    subscripts: *mut c_char,
    nop: npy_intp,
    op_in: *mut *mut PyArrayObject,
    dtype: *mut PyArray_Descr,
    order: NPY_ORDER,
    casting: NPY_CASTING,
    out: *mut PyArrayObject
) -> *mut PyArrayObject

unsafe fn PyArray_NewLikeArray(
    &self,
    prototype: *mut PyArrayObject,
    order: NPY_ORDER,
    dtype: *mut PyArray_Descr,
    subok: c_int
) -> *mut PyObject

unsafe fn PyArray_GetArrayParamsFromObject(
    &self,
    op: *mut PyObject,
    requested_dtype: *mut PyArray_Descr,
    writeable: npy_bool,
    out_dtype: *mut *mut PyArray_Descr,
    out_ndim: *mut c_int,
    out_dims: *mut npy_intp,
    out_arr: *mut *mut PyArrayObject,
    context: *mut PyObject
) -> c_int

unsafe fn PyArray_ConvertClipmodeSequence(
    &self,
    object: *mut PyObject,
    modes: *mut NPY_CLIPMODE,
    n: c_int
) -> c_int

unsafe fn PyArray_MatrixProduct2(
    &self,
    op1: *mut PyObject,
    op2: *mut PyObject,
    out: *mut PyArrayObject
) -> *mut PyObject

unsafe fn NpyIter_IsFirstVisit(
    &self,
    iter: *mut NpyIter,
    iop: c_int
) -> npy_bool

unsafe fn PyArray_SetBaseObject(
    &self,
    arr: *mut PyArrayObject,
    obj: *mut PyObject
) -> c_int

unsafe fn PyArray_CreateSortedStridePerm(
    &self,
    ndim: c_int,
    strides: *mut npy_intp,
    out_strideperm: *mut npy_stride_sort_item
)

unsafe fn PyArray_RemoveAxesInPlace(
    &self,
    arr: *mut PyArrayObject,
    flags: *mut npy_bool
)

unsafe fn PyArray_DebugPrint(&self, obj: *mut PyArrayObject)

unsafe fn PyArray_FailUnlessWriteable(
    &self,
    obj: *mut PyArrayObject,
    name: *const c_char
) -> c_int

unsafe fn PyArray_SetUpdateIfCopyBase(
    &self,
    arr: *mut PyArrayObject,
    base: *mut PyArrayObject
) -> c_int

unsafe fn PyDataMem_NEW(&self, size: usize) -> *mut c_void

unsafe fn PyDataMem_FREE(&self, ptr: *mut c_void)

unsafe fn PyDataMem_RENEW(&self, ptr: *mut c_void, size: usize) -> *mut c_void

unsafe fn PyDataMem_SetEventHook(
    &self,
    newhook: PyDataMem_EventHookFunc,
    user_data: *mut c_void,
    old_data: *mut *mut c_void
) -> PyDataMem_EventHookFunc

unsafe fn PyArray_MapIterSwapAxes(
    &self,
    mit: *mut PyArrayMapIterObject,
    ret: *mut *mut PyArrayObject,
    getmap: c_int
)

unsafe fn PyArray_MapIterArray(
    &self,
    a: *mut PyArrayObject,
    index: *mut PyObject
) -> *mut PyObject

unsafe fn PyArray_MapIterNext(&self, mit: *mut PyArrayMapIterObject)

unsafe fn PyArray_Partition(
    &self,
    op: *mut PyArrayObject,
    ktharray: *mut PyArrayObject,
    axis: c_int,
    which: NPY_SELECTKIND
) -> c_int

unsafe fn PyArray_ArgPartition(
    &self,
    op: *mut PyArrayObject,
    ktharray: *mut PyArrayObject,
    axis: c_int,
    which: NPY_SELECTKIND
) -> *mut PyObject

unsafe fn PyArray_SelectkindConverter(
    &self,
    obj: *mut PyObject,
    selectkind: *mut NPY_SELECTKIND
) -> c_int

unsafe fn PyDataMem_NEW_ZEROED(&self, size: usize, elsize: usize) -> *mut c_void

unsafe fn PyArray_CheckAnyScalarExact(&self, obj: *mut PyObject) -> c_int

unsafe fn PyArray_MapIterArrayCopyIfOverlap(
    &self,
    a: *mut PyArrayObject,
    index: *mut PyObject,
    copy_if_overlap: c_int,
    extra_op: *mut PyArrayObject
) -> *mut PyObject

impl PyArrayModule

unsafe fn get_type_object(&self, ty: ArrayType) -> *mut PyTypeObject

Methods from Deref<Target = PyModule>

fn dict(&self, py: Python) -> PyDict

Return the dictionary object that implements module's namespace; this object is the same as the __dict__ attribute of the module object.

fn name(&'a self, py: Python) -> Result<&'a str, PyErr>

Gets the module name.

May fail if the module does not have a __name__ attribute.

fn filename(&'a self, py: Python) -> Result<&'a str, PyErr>

Gets the module filename.

May fail if the module does not have a __file__ attribute.

fn get(&self, py: Python, name: &str) -> Result<PyObject, PyErr>

Gets a member from the module. This is equivalent to the Python expression: getattr(module, name)

fn call<A>(
    &self,
    py: Python,
    name: &str,
    args: A,
    kwargs: Option<&PyDict>
) -> Result<PyObject, PyErr> where
    A: ToPyObject<ObjectType = PyTuple>, 

Calls a function in the module. This is equivalent to the Python expression: getattr(module, name)(*args, **kwargs)

fn add<V>(&self, py: Python, name: &str, value: V) -> Result<(), PyErr> where
    V: ToPyObject, 

Adds a member to the module.

This is a convenience function which can be used from the module's initialization function.

fn add_class<T>(&self, py: Python<'p>) -> Result<(), PyErr> where
    T: PythonObjectFromPyClassMacro, 

Adds a new extension type to the module.

This is a convenience function that initializes the py_class!(), sets new_type.__module__ to this module's name,

Trait Implementations

impl Deref for PyArrayModule

type Target = PyModule

The resulting type after dereferencing

fn deref(&self) -> &Self::Target

The method called to dereference a value