Struct qoqo_calculator_pyo3::CalculatorFloatWrapper

pub struct CalculatorFloatWrapper {
    pub cf_internal: CalculatorFloat,
}

Fields

cf_internal: CalculatorFloat

Trait Implementations

impl Clone for CalculatorFloatWrapper

fn clone(&self) -> CalculatorFloatWrapper

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CalculatorFloatWrapper

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

Formats the value using the given formatter.

impl IntoPy<Py<PyAny>> for CalculatorFloatWrapper

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

Performs the conversion.

impl PyClass for CalculatorFloatWrapper

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<CalculatorFloatWrapper> for PyClassImplCollector<CalculatorFloatWrapper>

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

impl PyClassImpl for CalculatorFloatWrapper

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<CalculatorFloatWrapper>

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 get_call() -> Option<PyCFunctionWithKeywords>

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

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

impl PyClassNewImpl<CalculatorFloatWrapper> for PyClassImplCollector<CalculatorFloatWrapper>

fn new_impl(self) -> Option<newfunc>

impl PyMethods<CalculatorFloatWrapper> for PyClassImplCollector<CalculatorFloatWrapper>

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

impl<'p> PyNumberAbsProtocol<'p> for CalculatorFloatWrapper

type Result = PyResult<CalculatorFloatWrapper>

impl<'p> PyNumberAddProtocol<'p> for CalculatorFloatWrapper

type Left = Py<PyAny>

type Right = Py<PyAny>

type Result = PyResult<CalculatorFloatWrapper>

impl<'p> PyNumberFloatProtocol<'p> for CalculatorFloatWrapper

type Result = PyResult<f64>

impl<'p> PyNumberIAddProtocol<'p> for CalculatorFloatWrapper

type Other = Py<PyAny>

type Result = PyResult<()>

impl<'p> PyNumberIMulProtocol<'p> for CalculatorFloatWrapper

type Other = Py<PyAny>

type Result = PyResult<()>

impl<'p> PyNumberISubProtocol<'p> for CalculatorFloatWrapper

type Other = Py<PyAny>

type Result = PyResult<()>

impl<'p> PyNumberITruedivProtocol<'p> for CalculatorFloatWrapper

type Other = Py<PyAny>

type Result = PyResult<()>

impl<'p> PyNumberInvertProtocol<'p> for CalculatorFloatWrapper

type Result = PyResult<CalculatorFloatWrapper>

impl<'p> PyNumberMulProtocol<'p> for CalculatorFloatWrapper

type Left = Py<PyAny>

type Right = Py<PyAny>

type Result = PyResult<CalculatorFloatWrapper>

impl<'p> PyNumberNegProtocol<'p> for CalculatorFloatWrapper

type Result = PyResult<CalculatorFloatWrapper>

impl<'p> PyNumberPowProtocol<'p> for CalculatorFloatWrapper

type Left = CalculatorFloatWrapper

type Right = Py<PyAny>

type Modulo = CalculatorFloatWrapper

type Result = PyResult<CalculatorFloatWrapper>

impl<'p> PyNumberProtocol<'p> for CalculatorFloatWrapper

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

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

Arguments

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

Returns

PyResult<CalculatorFloatWrapper> - lhs + rhs

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

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

Arguments

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

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

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

Arguments

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

Returns

PyResult<CalculatorFloatWrapper> - lhs - rhs

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

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

Arguments

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

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

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

Arguments

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

Returns

PyResult<CalculatorFloatWrapper> - lhs * rhs

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

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

Arguments

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

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

Return pow (power) for CalculatorFloat and generic type Py<PyAny>.

Arguments

• other - Any Python object that can be converted to CalculatorFloat

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

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

Arguments

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

Returns

PyResult<CalculatorFloatWrapper> - lhs / rhs

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

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

Arguments

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

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

Implement Python minus sign for CalculatorFloat.

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

Return Python absolute value abs(x) for CalculatorFloat.

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

Implement Python Inverse 1/x for CalculatorFloat.

fn __float__(
    &'p self
) -> <CalculatorFloatWrapper as PyNumberFloatProtocol<'p>>::Result

Implement the x.float() (float(x)) Python magic method to convert a CalculatorFloat into a float.

Returns

• PyResult<f64>

Converts the Rust Panic when CalculatorFloat contains symbolic string value into a Python error

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 __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 __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<CalculatorFloatWrapper> for PyClassImplCollector<CalculatorFloatWrapper>

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

impl<'p> PyNumberSubProtocol<'p> for CalculatorFloatWrapper

type Left = Py<PyAny>

type Right = Py<PyAny>

type Result = PyResult<CalculatorFloatWrapper>

impl<'p> PyNumberTruedivProtocol<'p> for CalculatorFloatWrapper

type Left = Py<PyAny>

type Right = Py<PyAny>

type Result = PyResult<CalculatorFloatWrapper>

impl<'p> PyObjectProtocol<'p> for CalculatorFloatWrapper

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

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

Arguments

• &self - the CalculatorFloatWrapper 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 __repr__(
    &'p self
) -> <CalculatorFloatWrapper as PyObjectReprProtocol<'p>>::Result

Return the repr magic method to represent objects in Python of CalculatorFloat.

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 __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<CalculatorFloatWrapper> for PyClassImplCollector<CalculatorFloatWrapper>

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

impl<'p> PyObjectReprProtocol<'p> for CalculatorFloatWrapper

type Result = PyResult<String>

impl<'p> PyObjectRichcmpProtocol<'p> for CalculatorFloatWrapper

type Other = Py<PyAny>

type Result = PyResult<bool>

impl PyTypeInfo for CalculatorFloatWrapper

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.