Struct IntegrationState 

pub struct IntegrationState<I, O, F>
where
    F: PartialOrd + PartialEq,
{
    pub integral: Option<O>,
    pub prev_integral: Option<O>,
    pub best_integral: Option<O>,
    pub prev_best_integral: Option<O>,
    pub segments: SegmentHeap<I, O, F>,
    pub counts: HashMap<String, usize>,
    pub accumulate_values: bool,
}

Fields

integral: Option<O>

Current value of the integral

prev_integral: Option<O>

Previous value of the integral

best_integral: Option<O>

Lowest error value of the integral

prev_best_integral: Option<O>

Previous best parameter vector

segments: SegmentHeap<I, O, F>

segments in the integral

counts: HashMap<String, usize>

Evaluation counts

accumulate_values: bool

Whether to accumulate resolved values in the output

Implementations

impl<I, O, F> IntegrationState<I, O, F>

where O: IntegrationOutput<Float = F>, I: ComplexField<RealField = F> + Copy, F: IntegrableFloat,

pub fn param(self, param: O) -> Self

pub fn segments(self, segments: Vec<Segment<I, O, F>>) -> Self

pub fn pop_worst_segment(&mut self) -> Option<Segment<I, O, F>>

pub fn take_integral(&mut self) -> Option<O>

pub fn get_integral(&self) -> Option<&O>

pub fn get_prev_integral(&self) -> Option<&O>

pub fn take_prev_integral(&mut self) -> Option<O>

pub fn get_prev_best_integral(&self) -> Option<&O>

pub fn take_best_integral(&mut self) -> Option<O>

pub fn take_prev_best_integral(&mut self) -> Option<O>

pub fn into_resolved(self) -> Option<Values<I, O>>

Trait Implementations

impl<I, O, F, P> Calculation<P, IntegrationState<I, O, F>> for AdaptiveIntegrator<I>

where P: Integrable<Input = I, Output = O> + Send + Sync, I: ComplexField<RealField = F> + FromPrimitive + Copy, O: IntegrationOutput<Float = F, Scalar = I>, F: IntegrableFloat + RealField + FromPrimitive + AccumulateError<F> + RescaleError,

const NAME: &'static str = "Adaptive Integrator"

An identifier for the calculation.

type Error = IntegrationError<I>

The error associated with the problem

type Output = IntegrationResult<I, O>

The type returned to the caller.

fn initialise( &mut self, problem: &mut Problem<P>, state: IntegrationState<I, O, F>, ) -> Result<IntegrationState<I, O, F>, Self::Error>

Initialisation.

fn next( &mut self, problem: &mut Problem<P>, state: IntegrationState<I, O, F>, ) -> Result<IntegrationState<I, O, F>, Self::Error>

One iteration of the core algorithm

fn finalise( &mut self, _problem: &mut Problem<P>, state: IntegrationState<I, O, F>, ) -> Result<Self::Output, Self::Error>

Converts the internal state to the user-facing return datatype

impl<I, O, F, P> Calculation<P, IntegrationState<I, O, F>> for AdaptiveRectangularContourIntegrator<I>

where P: Integrable<Input = I, Output = O> + Send + Sync, I: ComplexField<RealField = F> + FromPrimitive + Copy, O: IntegrationOutput<Float = F, Scalar = I>, F: IntegrableFloat + RealField + FromPrimitive + AccumulateError<F> + RescaleError,

const NAME: &'static str = "Adaptive Contour Integrator"

An identifier for the calculation.

type Error = IntegrationError<I>

The error associated with the problem

type Output = IntegrationResult<I, O>

The type returned to the caller.

fn initialise( &mut self, problem: &mut Problem<P>, state: IntegrationState<I, O, F>, ) -> Result<IntegrationState<I, O, F>, Self::Error>

Initialisation.

fn next( &mut self, problem: &mut Problem<P>, state: IntegrationState<I, O, F>, ) -> Result<IntegrationState<I, O, F>, Self::Error>

One iteration of the core algorithm

fn finalise( &mut self, _problem: &mut Problem<P>, state: IntegrationState<I, O, F>, ) -> Result<Self::Output, Self::Error>

Converts the internal state to the user-facing return datatype

impl<I: Clone, O: Clone, F> Clone for IntegrationState<I, O, F>

where F: PartialOrd + PartialEq + Clone,

fn clone(&self) -> IntegrationState<I, O, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug, O: Debug, F> Debug for IntegrationState<I, O, F>

where F: PartialOrd + PartialEq + Debug,

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

Formats the value using the given formatter.

impl<I: Default, O: Default, F> Default for IntegrationState<I, O, F>

where F: PartialOrd + PartialEq + Default,

fn default() -> IntegrationState<I, O, F>

Returns the “default value” for a type.

impl<'de, I, O, F> Deserialize<'de> for IntegrationState<I, O, F>

where F: PartialOrd + PartialEq + Deserialize<'de>, I: Deserialize<'de>, O: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I, O, F> From<IntegrationState<I, O, F>> for IntegrationResult<I, O>

where O: IntegrationOutput<Float = F> + Clone, I: ComplexField<RealField = F> + Copy, F: IntegrableFloat,

fn from(val: IntegrationState<I, O, F>) -> Self

Converts to this type from the input type.

impl<I, O, F> Serialize for IntegrationState<I, O, F>

where F: PartialOrd + PartialEq + Serialize, I: Serialize, O: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<I, O, F> UserState for IntegrationState<I, O, F>

where I: ComplexField<RealField = F> + Copy, O: IntegrationOutput<Float = F>, F: IntegrableFloat,

type Float = F

type Param = O

fn new() -> Self

Create a new instance of the user-defined state object

fn is_initialised(&self) -> bool

fn update( &mut self, ) -> impl Into<Option<UpdateData<<Self as UserState>::Float>>>

fn get_param(&self) -> Option<&O>

fn last_was_best(&mut self)