Struct Resources 

pub struct Resources {
    pub active: Vec<bool>,
    pub free_parameters: IndexSet<String>,
    pub fixed_parameters: IndexSet<String>,
    pub constants: Vec<f64>,
    pub caches: Vec<Cache>,
    /* private fields */
}

The main resource manager for cached values, amplitudes, parameters, and constants.

Fields

active: Vec<bool>

A list indicating which amplitudes are active (using AmplitudeIDs as indices)

free_parameters: IndexSet<String>

The set of all registered free parameter names across registered [Amplitude]s

fixed_parameters: IndexSet<String>

The set of all registered fixed parameter names across registered [Amplitude]s

constants: Vec<f64>

Values of all constants/fixed parameters across registered [Amplitude]s

caches: Vec<Cache>

The Cache for each EventData

Implementations

impl Resources

pub fn with_transform(transform: ParameterTransform) -> Self

Create a new Resources instance with a parameter transform applied.

pub fn free_parameter_names(&self) -> Vec<String>

The list of free parameter names.

pub fn fixed_parameter_names(&self) -> Vec<String>

The list of fixed parameter names.

pub fn parameter_names(&self) -> Vec<String>

All parameter names (free first, then fixed).

pub fn n_free_parameters(&self) -> usize

Number of free parameters.

pub fn n_fixed_parameters(&self) -> usize

Number of fixed parameters.

pub fn n_parameters(&self) -> usize

Total number of parameters.

pub fn activate<T: AsRef<str>>(&mut self, name: T)

Activate an Amplitude by name.

pub fn activate_many<T: AsRef<str>>(&mut self, names: &[T])

Activate several Amplitudes by name.

pub fn activate_strict<T: AsRef<str>>(&mut self, name: T) -> LadduResult<()>

Activate an Amplitude by name, returning an error if it is missing.

pub fn activate_many_strict<T: AsRef<str>>( &mut self, names: &[T], ) -> LadduResult<()>

Activate several Amplitudes by name, returning an error if any are missing.

pub fn activate_all(&mut self)

Activate all registered Amplitudes.

pub fn deactivate<T: AsRef<str>>(&mut self, name: T)

Deactivate an Amplitude by name.

pub fn deactivate_many<T: AsRef<str>>(&mut self, names: &[T])

Deactivate several Amplitudes by name.

pub fn deactivate_strict<T: AsRef<str>>(&mut self, name: T) -> LadduResult<()>

Deactivate an Amplitude by name, returning an error if it is missing.

pub fn deactivate_many_strict<T: AsRef<str>>( &mut self, names: &[T], ) -> LadduResult<()>

Deactivate several Amplitudes by name, returning an error if any are missing.

pub fn deactivate_all(&mut self)

Deactivate all registered Amplitudes.

pub fn isolate<T: AsRef<str>>(&mut self, name: T)

Isolate an Amplitude by name (deactivate the rest).

pub fn isolate_strict<T: AsRef<str>>(&mut self, name: T) -> LadduResult<()>

Isolate an Amplitude by name (deactivate the rest), returning an error if it is missing.

pub fn isolate_many<T: AsRef<str>>(&mut self, names: &[T])

Isolate several Amplitudes by name (deactivate the rest).

pub fn isolate_many_strict<T: AsRef<str>>( &mut self, names: &[T], ) -> LadduResult<()>

Isolate several Amplitudes by name (deactivate the rest), returning an error if any are missing.

pub fn register_amplitude(&mut self, name: &str) -> LadduResult<AmplitudeID>

Register an Amplitude with the Resources manager. This method should be called at the end of the Amplitude::register method. The Amplitude should probably obtain a name String in its constructor.

Errors

The Amplitude’s name must be unique and not already registered, else this will return a RegistrationError.

pub fn amplitude_id(&self, name: &str) -> Option<AmplitudeID>

Fetch the AmplitudeID for a previously registered amplitude by name.

pub fn register_parameter( &mut self, p: &ParameterLike, ) -> LadduResult<ParameterID>

Register a parameter. This method should be called within Amplitude::register. The resulting ParameterID should be stored to retrieve the value from the Parameters wrapper.

Errors

Returns an error if the parameter is unnamed, if the name is reused with incompatible fixed/free status or fixed value, or if renaming causes a conflict.

pub fn register_scalar(&mut self, name: Option<&str>) -> ScalarID

Register a scalar with an optional name (names are unique to the Cache so two different registrations of the same type which share a name will also share values and may overwrite each other). This method should be called within the Amplitude::register method, and the resulting ScalarID should be stored to use later to retrieve the value from the Cache.

pub fn register_complex_scalar(&mut self, name: Option<&str>) -> ComplexScalarID

Register a complex scalar with an optional name (names are unique to the Cache so two different registrations of the same type which share a name will also share values and may overwrite each other). This method should be called within the Amplitude::register method, and the resulting ComplexScalarID should be stored to use later to retrieve the value from the Cache.

pub fn register_vector<const R: usize>( &mut self, name: Option<&str>, ) -> VectorID<R>

Register a vector with an optional name (names are unique to the Cache so two different registrations of the same type which share a name will also share values and may overwrite each other). This method should be called within the Amplitude::register method, and the resulting VectorID should be stored to use later to retrieve the value from the Cache.

pub fn register_complex_vector<const R: usize>( &mut self, name: Option<&str>, ) -> ComplexVectorID<R>

Register a complex-valued vector with an optional name (names are unique to the Cache so two different registrations of the same type which share a name will also share values and may overwrite each other). This method should be called within the Amplitude::register method, and the resulting ComplexVectorID should be stored to use later to retrieve the value from the Cache.

pub fn register_matrix<const R: usize, const C: usize>( &mut self, name: Option<&str>, ) -> MatrixID<R, C>

Register a matrix with an optional name (names are unique to the Cache so two different registrations of the same type which share a name will also share values and may overwrite each other). This method should be called within the Amplitude::register method, and the resulting MatrixID should be stored to use later to retrieve the value from the Cache.

pub fn register_complex_matrix<const R: usize, const C: usize>( &mut self, name: Option<&str>, ) -> ComplexMatrixID<R, C>

Register a complex-valued matrix with an optional name (names are unique to the Cache so two different registrations of the same type which share a name will also share values and may overwrite each other). This method should be called within the Amplitude::register method, and the resulting ComplexMatrixID should be stored to use later to retrieve the value from the Cache.

Trait Implementations

impl Clone for Resources

fn clone(&self) -> Resources

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Resources

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

Formats the value using the given formatter.

impl Default for Resources

fn default() -> Resources

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Resources

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Resources

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

where __S: Serializer,

Serialize this value into the given Serde serializer.