EllCalcCore Class Reference

Ellipsoid Search Space. More...

#include <ell_calc_core.hpp>

Public Member Functions
	EllCalcCore (const size_t ndim) noexcept
	~EllCalcCore () noexcept=default
EllCalcCore &	operator= (const EllCalcCore &) noexcept=default
EllCalcCore &	operator= (EllCalcCore &&) noexcept=default
	EllCalcCore (EllCalcCore &&E) noexcept=default
	EllCalcCore (const EllCalcCore &E) noexcept=default
auto	calc_parallel_cut (const double beta0, const double beta1, const double tsq) const noexcept -> std::tuple< double, double, double >
	Compute new ellipsoid parameters for parallel bias cut.
auto	calc_parallel_cut_fast_old (const double beta0, const double beta1, const double tsq, const double b0b1, const double eta) const noexcept -> std::tuple< double, double, double >
auto	calc_parallel_cut_fast (const double beta0, const double beta1, const double tsq, const double b0b1, const double eta) const noexcept -> std::tuple< double, double, double >
	Fast parallel cut computation with pre-computed values.
auto	calc_parallel_central_cut (const double beta1, const double tsq) const noexcept -> std::tuple< double, double, double >
	Compute new ellipsoid parameters for parallel central cut.
auto	calc_bias_cut (const double beta, const double tau) const noexcept -> std::tuple< double, double, double >
	Compute new ellipsoid parameters for bias (deep) cut.
auto	calc_bias_cut_fast (const double beta, const double tau, const double eta) const noexcept -> std::tuple< double, double, double >
	Fast bias cut computation with pre-computed eta.
auto	calc_central_cut (const double tau) const noexcept -> std::tuple< double, double, double >
	Compute new ellipsoid parameters for central cut.

Detailed Description

Ellipsoid Search Space.

EllCalcCore = {x | (x - xc)' mq^-1 (x - xc) ≤ κ}

Keep $Q$ symmetric but no promise of positive definite

Constructor & Destructor Documentation

EllCalcCore() [1/3]

EllCalcCore::EllCalcCore ( const size_t  ndim )

inlineexplicitnoexcept

Constructor for EllCalcCore class. Initializes member variables based on input ndim.

Example: EllCalcCore E(2);

Parameters

[in]

ndim

Number of dimensions for EllCalcCore object.

~EllCalcCore()

EllCalcCore::~EllCalcCore ( )

defaultnoexcept

EllCalcCore() [2/3]

EllCalcCore::EllCalcCore ( EllCalcCore &&  E )

defaultnoexcept

Move constructor for EllCalcCore.

This is a move constructor that allows EllCalcCore objects to be efficiently moved instead of copied. It takes an rvalue reference to another EllCalcCore object and steals its resources.

Parameters

[in]

E

An rvalue reference to the EllCalcCore object being moved.

EllCalcCore() [3/3]

EllCalcCore::EllCalcCore ( const EllCalcCore &  E )

defaultnoexcept

Copy constructor for EllCalcCore.

Allows copying an existing EllCalcCore object into a new EllCalcCore object. The new object will be an exact copy of the original.

Parameters

[in]

E

The EllCalcCore object to copy.

Member Function Documentation

calc_bias_cut()

auto EllCalcCore::calc_bias_cut ( const double  beta, const double  tau  ) const -> std::tuple<double, double, double>

inlinenoexcept

Compute new ellipsoid parameters for bias (deep) cut.

Single constraint with bias:

\[ g^T (x - x_c) + \beta \le 0, \qquad \beta \ge 0 \]

With \(\eta = \tau + n\beta\), the update is:

\[ \rho = \frac{2\beta}{n+1}, \quad \sigma = \frac{n^2}{n^2-1}\Bigl(1 - \frac{\eta^2}{n\tau^2}\Bigr), \quad \delta = \frac{n^2}{n^2-1}\Bigl(1 - \frac{\eta^2}{\tau^2}\Bigr) \]

Delegates to calc_bias_cut_fast().

Parameters

[in]	beta	Bias parameter (≥ 0)
[in]	tau	Square root of τ² (i.e. the ellipsoid radius)

Returns

Tuple (rho, sigma, delta)

calc_bias_cut_fast()

auto EllCalcCore::calc_bias_cut_fast ( const double  beta, const double  tau, const double  eta  ) const -> std::tuple< double, double, double >

noexcept

Fast bias cut computation with pre-computed eta.

Uses pre-computed \(\eta = \tau + n\beta\) to directly compute:

\[ \rho = \frac{2\beta}{n+1}, \qquad \sigma = \frac{n^2}{n^2-1}\Bigl(1 - \frac{\eta^2}{n\tau^2}\Bigr), \qquad \delta = \frac{n^2}{n^2-1}\Bigl(1 - \frac{\eta^2}{\tau^2}\Bigr) \]

Parameters

[in]	beta	Bias parameter
[in]	tau	Ellipsoid radius
[in]	eta	Intermediate value (tau + n × beta)

Returns

Tuple (rho, sigma, delta)

calc_central_cut()

auto EllCalcCore::calc_central_cut ( const double  tau ) const -> std::tuple< double, double, double >

noexcept

Compute new ellipsoid parameters for central cut.

A central cut through the ellipsoid center:

\[ g^T (x - x_c) \le 0 \]

The update formulas are:

\[ \rho = \frac{1}{n+1}, \qquad \sigma = \frac{n^2}{n^2-1}, \qquad \delta = \frac{n^2}{n^2-1} \]

where \(n\) is the dimension and \(\tau\) is the ellipsoid radius. The cut passes through the ellipsoid center, making \(\beta = 0\).

Parameters

[in]

tau

Ellipsoid radius (τ)

Returns

Tuple (rho, sigma, delta)

calc_parallel_central_cut()

auto EllCalcCore::calc_parallel_central_cut ( const double  beta1, const double  tsq  ) const -> std::tuple< double, double, double >

noexcept

Compute new ellipsoid parameters for parallel central cut.

One central cut through the center plus one parallel constraint:

\[ g^T (x - x_c) \le 0 \quad\text{and}\quad g^T (x - x_c) + \beta_1 \ge 0 \]

Parameters

[in]	beta1	Upper bound of the parallel constraint
[in]	tsq	Squared ellipsoid radius τ²

Returns

Tuple (rho, sigma, delta)

calc_parallel_cut()

auto EllCalcCore::calc_parallel_cut ( const double  beta0, const double  beta1, const double  tsq  ) const -> std::tuple<double, double, double>

inlinenoexcept

Compute new ellipsoid parameters for parallel bias cut.

Two parallel constraints:

\[ \beta_0 \le g^T (x - x_c) \le \beta_1 \]

Computes intermediate values \(b_0 b_1\) and \(\eta = \tau^2 + n b_0 b_1\), then delegates to calc_parallel_cut_fast().

Parameters

[in]	beta0	Lower bound of the parallel cut
[in]	beta1	Upper bound of the parallel cut
[in]	tsq	Squared ellipsoid radius τ²

Returns

Tuple (rho, sigma, delta) — step size, scaling factor, contraction

calc_parallel_cut_fast()

auto EllCalcCore::calc_parallel_cut_fast ( const double  beta0, const double  beta1, const double  tsq, const double  b0b1, const double  eta  ) const -> std::tuple< double, double, double >

noexcept

Fast parallel cut computation with pre-computed values.

Uses pre-computed b0b1 and eta to compute rho, sigma, delta for parallel bias cuts without re-computing intermediates.

Parameters

[in]	beta0	First parallel cut parameter
[in]	beta1	Second parallel cut parameter
[in]	tsq	Squared tau (τ²)
[in]	b0b1	Product beta0 × beta1
[in]	eta	Intermediate value (tsq + n × b0b1)

Returns

Tuple (rho, sigma, delta)

calc_parallel_cut_fast_old()

auto EllCalcCore::calc_parallel_cut_fast_old ( const double  beta0, const double  beta1, const double  tsq, const double  b0b1, const double  eta  ) const -> std::tuple< double, double, double >

noexcept

operator=() [1/2]

EllCalcCore & EllCalcCore::operator= ( const EllCalcCore &  )

defaultnoexcept

operator=() [2/2]

EllCalcCore & EllCalcCore::operator= ( EllCalcCore &&  )

defaultnoexcept

---

The documentation for this class was generated from the following file:

• ellalgo/ell_calc_core.hpp