sanos 0.2.1

SANOS: Smooth strictly Arbitrage-free Non-parametric Option Surfaces (Rust implementation)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

use resopt::{DefaultSolver, Solver};

use crate::density::MartingaleDensity;
use crate::error::{SanosError, SanosResult};
use crate::fit::builder::build_resopt_problem;
use crate::fit::config::FitConfig;
use crate::fit::extract::extract_density;
use crate::fit::kernels::KernelSet;
use crate::market::OptionBook;

#[derive(Debug, Clone)]
pub struct SolveResult {
    pub density: MartingaleDensity,
    pub objective_value: f64,
}

/// Solve the SANOS calibration problem using resopt (L2 objective with Clarabel).
///
/// 1. Builds the constrained residual problem from (book, kernels, config).
/// 2. Solves with the default resopt solver (Clarabel).
/// 3. Extracts the martingale density from the solution vector.
pub fn solve(
    book: &OptionBook,
    kernels: &KernelSet,
    cfg: &FitConfig,
    total_variances: Option<&[f64]>,
) -> SanosResult<SolveResult> {
    cfg.validate()?;
    kernels.validate()?;

    let (problem, layout) = build_resopt_problem(book, kernels, cfg, total_variances)?;

    let result = DefaultSolver::new().solve(&problem).map_err(|e| {
        SanosError::External {
            msg: format!("resopt solve failed: {e}"),
        }
    })?;

    if !result.is_solved() {
        return Err(SanosError::External {
            msg: format!("resopt solver did not converge: {:?}", result.status()),
        });
    }

    let solution = result.solution().ok_or_else(|| SanosError::External {
        msg: "resopt returned solved status but no solution".to_string(),
    })?;

    let x = solution.x();
    let objective_value = result.objective_value().unwrap_or(0.0);
    let density = extract_density(&layout, x, kernels)?;

    Ok(SolveResult {
        density,
        objective_value,
    })
}