Struct numpy::npyffi::array::PyArrayAPI

pub struct PyArrayAPI { /* fields omitted */ }

See PY_ARRAY_API for more.

Implementations

impl PyArrayAPI

pub unsafe fn PyArray_GetNDArrayCVersion(&self) -> c_uint

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub 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

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

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

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

pub 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub 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

pub 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

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

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

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

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

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

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

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

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

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

pub 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

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

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

pub 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub 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

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

pub 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub unsafe fn _PyArray_SigintHandler(&self, signum: c_int)

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

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

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

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

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

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

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

pub unsafe fn PyArray_GetEndianness(&self) -> c_int

pub unsafe fn PyArray_GetNDArrayCFeatureVersion(&self) -> c_uint

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

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

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

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

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

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

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

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

pub 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

pub 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub 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 PyObject

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

pub 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub unsafe fn PyArray_ResolveWritebackIfCopy(
    &self,
    self_: *mut PyArrayObject
) -> c_int

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

impl PyArrayAPI

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

Get the pointer of the type object that self refers.

Trait Implementations

impl Sync for PyArrayAPI