Struct qoqo_calculator_pyo3::CalculatorComplexWrapper

pub struct CalculatorComplexWrapper {
    pub cc_internal: CalculatorComplex,
}

Fields

cc_internal: CalculatorComplex

Trait Implementations

impl Clone for CalculatorComplexWrapper

fn clone(&self) -> CalculatorComplexWrapper

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CalculatorComplexWrapper

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

Formats the value using the given formatter.

impl IntoPy<Py<PyAny>> for CalculatorComplexWrapper

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl PyClass for CalculatorComplexWrapper

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

impl PyClassDescriptors<CalculatorComplexWrapper> for PyClassImplCollector<CalculatorComplexWrapper>

fn py_class_descriptors(self) -> &'static [PyMethodDefType]

impl PyClassImpl for CalculatorComplexWrapper

const DOC: &'static str

Class doc string

const IS_GC: bool

#[pyclass(gc)]

const IS_BASETYPE: bool

#[pyclass(subclass)]

const IS_SUBCLASS: bool

#[pyclass(extends=…)]

type Layout = PyCell<Self>

Layout

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerStub<CalculatorComplexWrapper>

This handles following two situations:

fn for_each_method_def(visitor: &mut dyn FnMut(&[PyMethodDefType]))

fn get_new() -> Option<newfunc>

fn get_alloc() -> Option<allocfunc>

fn get_free() -> Option<freefunc>

fn for_each_proto_slot(visitor: &mut dyn FnMut(&[PyType_Slot]))

fn get_buffer() -> Option<&'static PyBufferProcs>

impl PyClassNewImpl<CalculatorComplexWrapper> for PyClassImplCollector<CalculatorComplexWrapper>

fn new_impl(self) -> Option<newfunc>

impl PyMethods<CalculatorComplexWrapper> for PyClassImplCollector<CalculatorComplexWrapper>

fn py_methods(self) -> &'static [PyMethodDefType]

impl PyMethodsProtocolSlots<CalculatorComplexWrapper> for PyClassImplCollector<CalculatorComplexWrapper>

fn methods_protocol_slots(self) -> &'static [PyType_Slot]

impl<'p> PyNumberAbsProtocol<'p> for CalculatorComplexWrapper

type Result = PyResult<CalculatorFloatWrapper>

impl<'p> PyNumberAddProtocol<'p> for CalculatorComplexWrapper

type Left = Py<PyAny>

type Right = Py<PyAny>

type Result = PyResult<CalculatorComplexWrapper>

impl<'p> PyNumberIAddProtocol<'p> for CalculatorComplexWrapper

type Other = Py<PyAny>

type Result = PyResult<()>

impl<'p> PyNumberIMulProtocol<'p> for CalculatorComplexWrapper

type Other = Py<PyAny>

type Result = PyResult<()>

impl<'p> PyNumberISubProtocol<'p> for CalculatorComplexWrapper

type Other = Py<PyAny>

type Result = PyResult<()>

impl<'p> PyNumberITruedivProtocol<'p> for CalculatorComplexWrapper

type Other = Py<PyAny>

type Result = PyResult<()>

impl<'p> PyNumberInvertProtocol<'p> for CalculatorComplexWrapper

type Result = PyResult<CalculatorComplexWrapper>

impl<'p> PyNumberMulProtocol<'p> for CalculatorComplexWrapper

type Left = Py<PyAny>

type Right = Py<PyAny>

type Result = PyResult<CalculatorComplexWrapper>

impl<'p> PyNumberNegProtocol<'p> for CalculatorComplexWrapper

type Result = PyResult<CalculatorComplexWrapper>

impl<'p> PyNumberProtocol<'p> for CalculatorComplexWrapper

fn __add__(
    lhs: <CalculatorComplexWrapper as PyNumberAddProtocol<'p>>::Left,
    rhs: <CalculatorComplexWrapper as PyNumberAddProtocol<'p>>::Right
) -> <CalculatorComplexWrapper as PyNumberAddProtocol<'p>>::Result

Implement the + (add) magic method to add two CalculatorComplexes.

Arguments

• lhs - the first CalculatorComplexWrapper object in the operation
• rhs - the second CalculatorComplexWrapper object in the operation

Returns

PyResult<CalculatorComplexWrapper> - lhs + rhs

fn __iadd__(
    &'p mut self,
    other: <CalculatorComplexWrapper as PyNumberIAddProtocol<'p>>::Other
) -> <CalculatorComplexWrapper as PyNumberIAddProtocol<'p>>::Result

Implement the += (iadd) magic method to add a CalculatorComplex to another CalculatorComplex.

Arguments

• self - the CalculatorComplexWrapper object
• other - the CalculatorComplexWrapper object to be added to self

fn __sub__(
    lhs: <CalculatorComplexWrapper as PyNumberSubProtocol<'p>>::Left,
    rhs: <CalculatorComplexWrapper as PyNumberSubProtocol<'p>>::Right
) -> <CalculatorComplexWrapper as PyNumberSubProtocol<'p>>::Result

Implement the - (sub) magic method to subtract two CalculatorComplexes.

Arguments

• lhs - the first CalculatorComplexWrapper object in the operation
• rhs - the second CalculatorComplexWrapper object in the operation

Returns

PyResult<CalculatorComplexWrapper> - lhs - rhs

fn __isub__(
    &'p mut self,
    other: <CalculatorComplexWrapper as PyNumberISubProtocol<'p>>::Other
) -> <CalculatorComplexWrapper as PyNumberISubProtocol<'p>>::Result

Implement the -= (isub) magic method to subtract a CalculatorComplex from another CalculatorComplex.

Arguments

• self - the CalculatorComplexWrapper object
• other - the CalculatorComplexWrapper object to be subtracted from self

fn __mul__(
    lhs: <CalculatorComplexWrapper as PyNumberMulProtocol<'p>>::Left,
    rhs: <CalculatorComplexWrapper as PyNumberMulProtocol<'p>>::Right
) -> <CalculatorComplexWrapper as PyNumberMulProtocol<'p>>::Result

Implement the * (mul) magic method to multiply two CalculatorComplexes.

Arguments

• lhs - the first CalculatorComplexWrapper object in the operation
• rhs - the second CalculatorComplexWrapper object in the operation

Returns

PyResult<CalculatorComplexWrapper> - lhs * rhs

fn __imul__(
    &'p mut self,
    other: <CalculatorComplexWrapper as PyNumberIMulProtocol<'p>>::Other
) -> <CalculatorComplexWrapper as PyNumberIMulProtocol<'p>>::Result

Implement the *= (imul) magic method to multiply a CalculatorComplex by another CalculatorComplex.

Arguments

• self - the CalculatorComplexWrapper object
• other - the CalculatorComplexWrapper object to multiply self by

fn __truediv__(
    lhs: <CalculatorComplexWrapper as PyNumberTruedivProtocol<'p>>::Left,
    rhs: <CalculatorComplexWrapper as PyNumberTruedivProtocol<'p>>::Right
) -> <CalculatorComplexWrapper as PyNumberTruedivProtocol<'p>>::Result

Implement the / (truediv) magic method to divide two CalculatorComplexes.

Arguments

• lhs - the first CalculatorComplexWrapper object in the operation
• rhs - the second CalculatorComplexWrapper object in the operation

Returns

PyResult<CalculatorComplexWrapper> - lhs / rhs

fn __itruediv__(
    &'p mut self,
    other: <CalculatorComplexWrapper as PyNumberITruedivProtocol<'p>>::Other
) -> <CalculatorComplexWrapper as PyNumberITruedivProtocol<'p>>::Result

Implement the /= (itruediv) magic method to divide a CalculatorComplex by another CalculatorComplex.

Arguments

• self - the CalculatorComplexWrapper object
• other - the CalculatorComplexWrapper object to divide self by

fn __neg__(
    &'p self
) -> <CalculatorComplexWrapper as PyNumberNegProtocol<'p>>::Result

Implement Python minus sign for CalculatorComplex.

fn __abs__(
    &'p self
) -> <CalculatorComplexWrapper as PyNumberAbsProtocol<'p>>::Result

Return Python absolute value abs(x) for CalculatorComplex.

fn __invert__(
    &'p self
) -> <CalculatorComplexWrapper as PyNumberInvertProtocol<'p>>::Result

Implement Python Inverse 1/x for CalculatorComplex.

fn __matmul__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberMatmulProtocol<'p>, 

fn __floordiv__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberFloordivProtocol<'p>, 

fn __mod__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberModProtocol<'p>, 

fn __divmod__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberDivmodProtocol<'p>, 

fn __pow__(
    lhs: Self::Left,
    rhs: Self::Right,
    modulo: Option<Self::Modulo>
) -> Self::Result where
    Self: PyNumberPowProtocol<'p>, 

fn __lshift__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberLShiftProtocol<'p>, 

fn __rshift__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberRShiftProtocol<'p>, 

fn __and__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberAndProtocol<'p>, 

fn __xor__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberXorProtocol<'p>, 

fn __or__(lhs: Self::Left, rhs: Self::Right) -> Self::Result where
    Self: PyNumberOrProtocol<'p>, 

fn __radd__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRAddProtocol<'p>, 

fn __rsub__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRSubProtocol<'p>, 

fn __rmul__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRMulProtocol<'p>, 

fn __rmatmul__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRMatmulProtocol<'p>, 

fn __rtruediv__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRTruedivProtocol<'p>, 

fn __rfloordiv__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRFloordivProtocol<'p>, 

fn __rmod__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRModProtocol<'p>, 

fn __rdivmod__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRDivmodProtocol<'p>, 

fn __rpow__(
    &'p self,
    other: Self::Other,
    modulo: Option<Self::Modulo>
) -> Self::Result where
    Self: PyNumberRPowProtocol<'p>, 

fn __rlshift__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRLShiftProtocol<'p>, 

fn __rrshift__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRRShiftProtocol<'p>, 

fn __rand__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRAndProtocol<'p>, 

fn __rxor__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberRXorProtocol<'p>, 

fn __ror__(&'p self, other: Self::Other) -> Self::Result where
    Self: PyNumberROrProtocol<'p>, 

fn __imatmul__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIMatmulProtocol<'p>, 

fn __ifloordiv__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIFloordivProtocol<'p>, 

fn __imod__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIModProtocol<'p>, 

fn __ipow__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIPowProtocol<'p>, 

fn __ilshift__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberILShiftProtocol<'p>, 

fn __irshift__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIRShiftProtocol<'p>, 

fn __iand__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIAndProtocol<'p>, 

fn __ixor__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIXorProtocol<'p>, 

fn __ior__(&'p mut self, other: Self::Other) -> Self::Result where
    Self: PyNumberIOrProtocol<'p>, 

fn __pos__(&'p self) -> Self::Result where
    Self: PyNumberPosProtocol<'p>, 

fn __complex__(&'p self) -> Self::Result where
    Self: PyNumberComplexProtocol<'p>, 

👎 Deprecated since 0.14.0:

prefer implementing __complex__ in #[pymethods] instead of in a protocol

fn __int__(&'p self) -> Self::Result where
    Self: PyNumberIntProtocol<'p>, 

fn __float__(&'p self) -> Self::Result where
    Self: PyNumberFloatProtocol<'p>, 

fn __index__(&'p self) -> Self::Result where
    Self: PyNumberIndexProtocol<'p>, 

fn __round__(&'p self, ndigits: Option<Self::NDigits>) -> Self::Result where
    Self: PyNumberRoundProtocol<'p>, 

👎 Deprecated since 0.14.0:

prefer implementing __round__ in #[pymethods] instead of in a protocol

impl PyNumberProtocolSlots<CalculatorComplexWrapper> for PyClassImplCollector<CalculatorComplexWrapper>

fn number_protocol_slots(self) -> &'static [PyType_Slot]

impl<'p> PyNumberSubProtocol<'p> for CalculatorComplexWrapper

type Left = Py<PyAny>

type Right = Py<PyAny>

type Result = PyResult<CalculatorComplexWrapper>

impl<'p> PyNumberTruedivProtocol<'p> for CalculatorComplexWrapper

type Left = Py<PyAny>

type Right = Py<PyAny>

type Result = PyResult<CalculatorComplexWrapper>

impl<'p> PyObjectProtocol<'p> for CalculatorComplexWrapper

fn __richcmp__(
    &'p self,
    other: <CalculatorComplexWrapper as PyObjectRichcmpProtocol<'p>>::Other,
    op: CompareOp
) -> <CalculatorComplexWrapper as PyObjectRichcmpProtocol<'p>>::Result

Return the richcmp magic method to perform rich comparison. operations on CalculatorComplex.

Arguments

• &self - the CalculatorComplexWrapper object
• other - the object to compare self to
• op - equal or not equal

Returns

PyResult<bool> - whether the two operations compared evaluated to True or False

fn __getattr__(&'p self, name: Self::Name) -> Self::Result where
    Self: PyObjectGetAttrProtocol<'p>, 

fn __setattr__(
    &'p mut self,
    name: Self::Name,
    value: Self::Value
) -> Self::Result where
    Self: PyObjectSetAttrProtocol<'p>, 

fn __delattr__(&'p mut self, name: Self::Name) -> Self::Result where
    Self: PyObjectDelAttrProtocol<'p>, 

fn __str__(&'p self) -> Self::Result where
    Self: PyObjectStrProtocol<'p>, 

fn __repr__(&'p self) -> Self::Result where
    Self: PyObjectReprProtocol<'p>, 

fn __format__(&'p self, format_spec: Self::Format) -> Self::Result where
    Self: PyObjectFormatProtocol<'p>, 

👎 Deprecated since 0.14.0:

prefer implementing __format__ in #[pymethods] instead of in a protocol

fn __hash__(&'p self) -> Self::Result where
    Self: PyObjectHashProtocol<'p>, 

fn __bytes__(&'p self) -> Self::Result where
    Self: PyObjectBytesProtocol<'p>, 

👎 Deprecated since 0.14.0:

prefer implementing __bytes__ in #[pymethods] instead of in a protocol

fn __bool__(&'p self) -> Self::Result where
    Self: PyObjectBoolProtocol<'p>, 

impl PyObjectProtocolSlots<CalculatorComplexWrapper> for PyClassImplCollector<CalculatorComplexWrapper>

fn object_protocol_slots(self) -> &'static [PyType_Slot]

impl<'p> PyObjectRichcmpProtocol<'p> for CalculatorComplexWrapper

type Other = Py<PyAny>

type Result = PyResult<bool>

impl PyTypeInfo for CalculatorComplexWrapper

type AsRefTarget = PyCell<Self>

Utility type to make Py::as_ref work.

const NAME: &'static str

Class name.

const MODULE: Option<&'static str>

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

PyTypeObject instance for this type.

fn is_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.