Struct smoothed_online_convex_optimization::problem::SmoothedBalancedLoadOptimization

pub struct SmoothedBalancedLoadOptimization<'a, T> {
    pub d: i32,
    pub t_end: i32,
    pub bounds: Vec<T>,
    pub switching_cost: Vec<f64>,
    pub hitting_cost: Vec<FailableCostFn<'a, f64, DataCenterModelOutputFailure>>,
    pub load: Vec<T>,
}

Smoothed Balanced-Load Optimization (SBLO).

• SSCO
• hitting costs are computed by balancing incoming loads across all dimensions each of which is described by a convex cost function

Fields

d: i32

Number of dimensions.

t_end: i32

Finite, positive time horizon.

bounds: Vec<T>

Vector of upper bounds of each dimension.

switching_cost: Vec<f64>

Vector of positive real constants resembling the switching cost of each dimension.

hitting_cost: Vec<FailableCostFn<'a, f64, DataCenterModelOutputFailure>>

Positive increasing cost functions for each dimension.

load: Vec<T>

Non-negative load at each time step.

Implementations

impl<'a, T> SmoothedBalancedLoadOptimization<'a, T> where
    T: Value<'a>, 

pub fn into_ssco(
    self
) -> SimplifiedSmoothedConvexOptimization<'a, T, DataCenterModelOutputSuccess, DataCenterModelOutputFailure>

Convert to an instance of Simplified Smoothed Convex Optimization.

Trait Implementations

impl<'a, T> BaseProblem for SmoothedBalancedLoadOptimization<'a, T> where
    T: Value<'a>, 

fn d(&self) -> i32

Number of dimensions.

fn t_end(&self) -> i32

Finite, positive time horizon.

fn set_t_end(&mut self, t_end: i32)

Updates the time horizon.

fn inc_t_end(&mut self)

Increases the time horizon by one time step.

impl<'a, T: Clone> Clone for SmoothedBalancedLoadOptimization<'a, T>

fn clone(&self) -> SmoothedBalancedLoadOptimization<'a, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T> Debug for SmoothedBalancedLoadOptimization<'a, T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<'a> DefaultGivenOnlineProblem<i32, SmoothedBalancedLoadOptimization<'a, i32>, DataCenterModelOutputSuccess, DataCenterModelOutputFailure> for Memory<'a>

fn default(o: &Online<IntegralSmoothedBalancedLoadOptimization<'_>>) -> Self

impl<'a, T> Model<T, SmoothedBalancedLoadOptimization<'a, T>, DataCenterOfflineInput, DataCenterOnlineInput, DataCenterModelOutputSuccess, DataCenterModelOutputFailure> for DataCenterModel where
    T: Value<'a>, 

fn to(
    &self,
    _: DataCenterOfflineInput
) -> SmoothedBalancedLoadOptimization<'a, T>

Notes:

• Only allows for a single location, source, and job type.

fn update(
    &self,
    o: &mut Online<SmoothedBalancedLoadOptimization<'a, T>>,
    _: DataCenterOnlineInput
)

Performs an online update of the given problem instance $o$ with some $input$ (which may be uncertain).

impl<'a, T> Problem<T, DataCenterModelOutputSuccess, DataCenterModelOutputFailure> for SmoothedBalancedLoadOptimization<'a, T> where
    T: Value<'a>, 

fn hit_cost(
    &self,
    t: i32,
    x: Config<T>
) -> Cost<DataCenterModelOutputSuccess, DataCenterModelOutputFailure>

Hitting cost.

fn movement(&self, prev_x: Config<T>, x: Config<T>, inverted: bool) -> N64

Movement cost.

fn objective_function<'a>(&self, xs: &Schedule<T>) -> Result<Cost<C, D>> where
    T: Value<'a>, 

Objective function. Calculates the cost of a schedule.

fn inverted_objective_function<'a>(
    &self,
    xs: &Schedule<T>
) -> Result<Cost<C, D>> where
    T: Value<'a>, 

Inverted Objective function. Calculates the cost of a schedule. Pays the switching cost for powering down rather than powering up.

fn alpha_unfair_objective_function<'a>(
    &self,
    xs: &Schedule<T>,
    alpha: f64
) -> Result<Cost<C, D>> where
    T: Value<'a>, 

$\alpha$-unfair Objective function. Calculates the cost of a schedule.

fn objective_function_with_default<'a>(
    &self,
    xs: &Schedule<T>,
    default: &Config<T>
) -> Result<Cost<C, D>> where
    T: Value<'a>, 

Objective function starting from an initial configuration other than $\mathbf{0}$.

fn _objective_function_with_default<'a>(
    &self,
    xs: &Schedule<T>,
    default: &Config<T>,
    alpha: f64,
    inverted: bool
) -> Result<Cost<C, D>> where
    T: Value<'a>, 

fn total_movement<'a>(&self, xs: &Schedule<T>, inverted: bool) -> Result<N64> where
    T: Value<'a>, 

Movement in the decision space.

fn _default_config<'a>(&self) -> Config<T> where
    T: Value<'a>, 

impl<'a, T> VerifiableProblem for SmoothedBalancedLoadOptimization<'a, T> where
    T: Value<'a>, 

fn verify(&self) -> Result<()>