Struct PyComplex

pub struct PyComplex { /* private fields */ }

Create a complex number from a real part and an optional imaginary part.

This is equivalent to (real + imag*1j) where imag defaults to 0.

Implementations

impl PyComplex

pub fn to_complex64(self) -> Complex64

impl PyComplex

pub fn new_ref(value: Complex64, ctx: &Context) -> PyRef<Self>

pub fn to_complex(&self) -> Complex64

Trait Implementations

impl AsNumber for PyComplex

fn as_number() -> &'static PyNumberMethods

fn clone_exact(zelf: &Py<Self>, vm: &VirtualMachine) -> PyRef<Self>

fn number_downcast(num: PyNumber<'_>) -> &Py<Self>

fn number_downcast_exact(num: PyNumber<'_>, vm: &VirtualMachine) -> PyRef<Self>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl Clone for PyComplex

fn clone(&self) -> PyComplex

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Comparable for PyComplex

fn cmp( zelf: &Py<Self>, other: &PyObject, op: PyComparisonOp, vm: &VirtualMachine, ) -> PyResult<PyComparisonValue>

fn slot_richcompare( zelf: &PyObject, other: &PyObject, op: PyComparisonOp, vm: &VirtualMachine, ) -> PyResult<Either<PyObjectRef, PyComparisonValue>>

fn eq( zelf: &Py<Self>, other: PyObjectRef, vm: &VirtualMachine, ) -> PyResult<PyComparisonValue>

fn ne( zelf: &Py<Self>, other: PyObjectRef, vm: &VirtualMachine, ) -> PyResult<PyComparisonValue>

fn lt( zelf: &Py<Self>, other: PyObjectRef, vm: &VirtualMachine, ) -> PyResult<PyComparisonValue>

fn le( zelf: &Py<Self>, other: PyObjectRef, vm: &VirtualMachine, ) -> PyResult<PyComparisonValue>

fn ge( zelf: &Py<Self>, other: PyObjectRef, vm: &VirtualMachine, ) -> PyResult<PyComparisonValue>

fn gt( zelf: &Py<Self>, other: PyObjectRef, vm: &VirtualMachine, ) -> PyResult<PyComparisonValue>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl Constructor for PyComplex

type Args = ComplexArgs

fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult

fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl Debug for PyComplex

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Complex<f64>> for PyComplex

fn from(value: Complex64) -> Self

Converts to this type from the input type.

impl Hashable for PyComplex

fn hash(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyHash>

fn slot_hash(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyHash>

fn __hash__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyHash>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl MaybeTraverse for PyComplex

fn try_traverse(&self, tracer_fn: &mut TraverseFn<'_>)

const IS_TRACE: bool = false

if is traceable, will be used by vtable to determine

impl PartialEq for PyComplex

fn eq(&self, other: &PyComplex) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PyClassDef for PyComplex

const NAME: &'static str = "complex"

const MODULE_NAME: Option<&'static str> = None

const TP_NAME: &'static str = "complex"

const DOC: Option<&'static str>

const BASICSIZE: usize = 16usize

const UNHASHABLE: bool = false

type Base = PyBaseObject

impl PyClassImpl for PyComplex

const TP_FLAGS: PyTypeFlags

const METHOD_DEFS: &'static [PyMethodDef]

fn impl_extend_class(ctx: &Context, class: &'static Py<PyType>)

fn extend_slots(slots: &mut PyTypeSlots)

fn extend_class(ctx: &Context, class: &'static Py<PyType>)

where Self: Sized,

fn make_class(ctx: &Context) -> PyTypeRef

where Self: StaticType + Sized,

fn make_slots() -> PyTypeSlots

impl PyPayload for PyComplex

fn class(ctx: &Context) -> &'static Py<PyType>

fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef

fn _into_ref(self, cls: PyTypeRef, ctx: &Context) -> PyRef<Self>

fn into_exact_ref(self, ctx: &Context) -> PyRefExact<Self>

fn into_ref(self, ctx: &Context) -> PyRef<Self>

fn into_ref_with_type( self, vm: &VirtualMachine, cls: PyTypeRef, ) -> PyResult<PyRef<Self>>

impl Representable for PyComplex

fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String>

fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef>

fn __repr__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef>

fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl StaticType for PyComplex

fn static_cell() -> &'static StaticCell<PyTypeRef>

fn static_metaclass() -> &'static Py<PyType>

fn static_baseclass() -> &'static Py<PyType>

fn static_type() -> &'static Py<PyType>

fn init_manually(typ: PyTypeRef) -> &'static Py<PyType>

fn init_builtin_type() -> &'static Py<PyType>

where Self: PyClassImpl,

fn create_static_type() -> PyTypeRef

where Self: PyClassImpl,

impl Copy for PyComplex

impl StructuralPartialEq for PyComplex