Struct Breakpoints

pub struct Breakpoints {
    pub bs: Vec<N64>,
    pub next: Option<Arc<dyn Fn(f64) -> (Option<f64>, Option<f64>) + Send + Sync>>,
}

Sorted non-continuous or non-smooth points of a function.

Fields

bs: Vec<N64>

Finite vector of breakpoints.

next: Option<Arc<dyn Fn(f64) -> (Option<f64>, Option<f64>) + Send + Sync>>

Function which given a breakpoint returns the previous and next breakpoints (until there are none), respectively. The function is called to obtain the next breakpoint until the piecewise integrals converge to $0$ or the entire integral was integrated.

Implementations

impl Breakpoints

pub fn empty() -> Self

Empty set of breakpoints.

pub fn from(bs: Vec<f64>) -> Self

Generate breakpoints from a finite vector of breakpoints $bs$.

pub fn grid(d: f64) -> Self

Breakpoints on a grid with a mesh width of $d$.

pub fn add(&self, bs: &Vec<f64>) -> Self

Adds breakpoints in $bs$ to the set of breakpoints, unless already included. Note: The caller must ensure that there are no duplicates within $bs$.

Trait Implementations

impl Clone for Breakpoints

fn clone(&self) -> Breakpoints

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Breakpoints

fn default() -> Self

Returns the “default value” for a type.

impl IntoPy<Py<PyAny>> for Breakpoints

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

Performs the conversion.

impl PyClass for Breakpoints

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

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

impl PyClassImpl for Breakpoints

const DOC: &'static str = "Sorted non-continuous or non-smooth points of a function.\u{0}"

Class doc string

const IS_GC: bool = false

#[pyclass(gc)]

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

type Layout = PyCell<Breakpoints>

Layout

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerStub<Breakpoints>

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

fn new_impl(self) -> Option<newfunc>

impl PyMethods<Breakpoints> for PyClassImplCollector<Breakpoints>

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

impl PyMethodsProtocolSlots<Breakpoints> for PyClassImplCollector<Breakpoints>

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

impl PyTypeInfo for Breakpoints

const NAME: &'static str = "Breakpoints"

Class name.

const MODULE: Option<&'static str> = ::std::option::Option::None

Module name, if any.

type AsRefTarget = PyCell<Breakpoints>

Utility type to make Py::as_ref work.

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.