Struct PortfolioSequence 

pub struct PortfolioSequence { /* private fields */ }

A rolling solve sequence over a fixed portfolio structure.

Built by PortfolioProblem::sequence or PortfolioProblem::sequence_with. Owns a Workspace, so equilibration and SMW-reduced factorizations persist across dates, and manages warm starts internally: each solve starts from the previous solution’s full primal/dual iterate.

Solution::solve_time on sequence solves covers iteration only; the one-time setup was paid when the sequence was constructed.

Implementations

impl PortfolioSequence

pub fn dimension(&self) -> usize

Number of portfolio weights.

pub const fn settings(&self) -> &SolverSettings

Settings every solve in this sequence iterates with.

pub const fn factorizations(&self) -> usize

Number of reduced factorizations built since construction (including the initial one). A stable count across rolling dates demonstrates factorization reuse.

Examples found in repository

examples/sequence.rs (line 42)

fn main() -> Result<(), Box<dyn Error>> {
    let exposures: Vec<f64> = (0..ASSETS * FACTORS)
        .map(|index| 0.3 * (index as f64 * 12.9898).sin())
        .collect();
    let problem = PortfolioProblem::new(
        Matrix::new(ASSETS, FACTORS, exposures)?,
        FactorCovariance::Diagonal(vec![0.06; FACTORS]),
        vec![0.1; ASSETS],
        expected_returns(0),
    )?
    .with_risk_aversion(6.0)?
    .with_bounds(vec![0.0; ASSETS], vec![0.2; ASSETS])?
    .with_quadratic_turnover(vec![1.0 / ASSETS as f64; ASSETS], 0.5)?;

    let mut sequence = problem.sequence()?;
    let mut previous_weights: Option<Vec<f64>> = None;

    println!("date | status | iterations | new factorizations | one-way turnover");
    println!("---|---|---|---|---");
    for date in 0..DATES {
        let factorizations_before = sequence.factorizations();
        let step = RebalanceStep {
            expected_returns: (date > 0).then(|| expected_returns(date)),
            previous_weights: previous_weights.clone(),
            ..RebalanceStep::default()
        };
        let solution = sequence.solve_next(&step)?;
        if solution.status != SolveStatus::Solved {
            return Err(format!(
                "date {date} stopped with status '{}' after {} iterations",
                solution.status, solution.iterations
            )
            .into());
        }

        let turnover = previous_weights.as_ref().map_or(0.0, |previous| {
            solution
                .x
                .iter()
                .zip(previous)
                .map(|(new, old)| (new - old).abs())
                .sum::<f64>()
                / 2.0
        });
        println!(
            "{date} | {} | {} | {} | {turnover:.6}",
            solution.status,
            solution.iterations,
            sequence.factorizations() - factorizations_before,
        );
        previous_weights = Some(solution.x);
    }
    println!(
        "total reduced factorizations across {DATES} dates: {}",
        sequence.factorizations()
    );
    Ok(())
}

pub fn solve_next( &mut self, step: &RebalanceStep, ) -> Result<Solution, PortfolioError>

Applies one step’s data changes, then solves, warm-started from the previous solution.

The step is validated in full before any state changes, so an Err leaves the sequence exactly as it was. The first solve of a sequence is cold; every later solve chains the previous full primal/dual iterate (unless the previous solve failed numerically, which would make a non-finite start).

Errors

Returns PortfolioError when the step data has wrong dimensions or non-finite values, updates a constraint the base problem does not have (budget / turnover anchor), or moves the budget outside what the box constraints can reach.

Examples found in repository

examples/sequence.rs (line 48)

fn main() -> Result<(), Box<dyn Error>> {
    let exposures: Vec<f64> = (0..ASSETS * FACTORS)
        .map(|index| 0.3 * (index as f64 * 12.9898).sin())
        .collect();
    let problem = PortfolioProblem::new(
        Matrix::new(ASSETS, FACTORS, exposures)?,
        FactorCovariance::Diagonal(vec![0.06; FACTORS]),
        vec![0.1; ASSETS],
        expected_returns(0),
    )?
    .with_risk_aversion(6.0)?
    .with_bounds(vec![0.0; ASSETS], vec![0.2; ASSETS])?
    .with_quadratic_turnover(vec![1.0 / ASSETS as f64; ASSETS], 0.5)?;

    let mut sequence = problem.sequence()?;
    let mut previous_weights: Option<Vec<f64>> = None;

    println!("date | status | iterations | new factorizations | one-way turnover");
    println!("---|---|---|---|---");
    for date in 0..DATES {
        let factorizations_before = sequence.factorizations();
        let step = RebalanceStep {
            expected_returns: (date > 0).then(|| expected_returns(date)),
            previous_weights: previous_weights.clone(),
            ..RebalanceStep::default()
        };
        let solution = sequence.solve_next(&step)?;
        if solution.status != SolveStatus::Solved {
            return Err(format!(
                "date {date} stopped with status '{}' after {} iterations",
                solution.status, solution.iterations
            )
            .into());
        }

        let turnover = previous_weights.as_ref().map_or(0.0, |previous| {
            solution
                .x
                .iter()
                .zip(previous)
                .map(|(new, old)| (new - old).abs())
                .sum::<f64>()
                / 2.0
        });
        println!(
            "{date} | {} | {} | {} | {turnover:.6}",
            solution.status,
            solution.iterations,
            sequence.factorizations() - factorizations_before,
        );
        previous_weights = Some(solution.x);
    }
    println!(
        "total reduced factorizations across {DATES} dates: {}",
        sequence.factorizations()
    );
    Ok(())
}