Struct Resources

pub struct Resources {
    pub active: Vec<bool>,
    pub parameters: IndexSet<String>,
    pub constants: Vec<Float>,
    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)

parameters: IndexSet<String>

The set of all registered parameter names across registered Amplitudes

constants: Vec<Float>

Values of all constants across registered Amplitudes

caches: Vec<Cache>

The Cache for each Event

Implementations

impl Resources

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

Activate an Amplitude by name.

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

Activate several Amplitudes by name.

pub fn activate_all(&mut self)

Activate all registered Amplitudes.

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

Deactivate an Amplitude by name.

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

Deactivate several Amplitudes by name.

pub fn deactivate_all(&mut self)

Deactivate all registered Amplitudes.

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

Isolate an Amplitude by name (deactivate the rest).

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

Isolate several Amplitudes by name (deactivate the rest).

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

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 register_parameter(&mut self, pl: &ParameterLike) -> ParameterID

Register a free parameter (or constant) ParameterLike. This method should be called within the Amplitude::register method, and the resulting ParameterID should be stored to use later to retrieve the value from the Parameters wrapper object.

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 copy 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.