Function mosek::sparse_triangular_solve_dense

source · 
pub fn sparse_triangular_solve_dense(
    transposed_: i32,
    lnzc_: &[i32],
    lptrc_: &[i64],
    lsubc_: &[i32],
    lvalc_: &[f64],
    b_: &mut [f64]
) -> Result<(), String>
Expand description

Solves a sparse triangular system of linear equations.

§Arguments

  • transposed_ Controls whether the solve is with L or the transposed L.

    See Transpose

  • lnzc_ lnzc[j] is the number of nonzeros in column j.

  • lptrc_ lptrc[j] is a pointer to the first row index and value in column j.

  • lsubc_ Row indexes for each column stored sequentially.

  • lvalc_ The value corresponding to row indexed stored lsubc.

  • b_ The right-hand side of linear equation system to be solved as a dense vector.

Full documentation: https://docs.mosek.com/latest/capi/alphabetic-functionalities.html#mosek.env.sparsetriangularsolvedense

Examples found in repository?
examples/sparsecholesky.rs (line 72)
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() -> Result<(),String> {
    /* Create the mosek environment. */
    //Example from the manual
    //Observe that anzc, aptrc, asubc and avalc only specify the lower triangular part.
    let n     = 4;
    let anzc  = [4, 1, 1, 1];
    let asubc = [0, 1, 2, 3, 1, 2, 3];
    let aptrc = [0, 4, 5, 6];
    let avalc = [4.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0];
    let b     = [13.0, 3.0, 4.0, 5.0];

    let mut perm   = Vec::new();
    let mut lnzc   = Vec::new();
    let mut lsubc  = Vec::new();
    let mut diag   = Vec::new();
    let mut lptrc  = Vec::new();
    let mut lvalc  = Vec::new();
    let mut lensubnval = 0;

    mosek::compute_sparse_cholesky(0,        //Mosek chooses number of threads
                                   1,        //Apply reordering heuristic
                                   1.0e-14,  //Singularity tolerance
                                   &anzc, &aptrc, &asubc, &avalc,
                                   & mut perm, & mut diag,
                                   & mut lnzc, & mut lptrc, & mut lensubnval, & mut lsubc, & mut lvalc)?;
    print_sparse(n, perm.as_slice(), diag.as_slice(), lnzc.as_slice(), lptrc.as_slice(), lsubc.as_slice(), lvalc.as_slice());

    /* Permuted b is stored as x. */
    let mut x : Vec<f64> = perm.iter().map(|&i| b[i as usize]).collect();

    /*Compute  inv(L)*x.*/
    mosek::sparse_triangular_solve_dense(Transpose::NO,  lnzc.as_slice(), lptrc.as_slice(), lsubc.as_slice(), lvalc.as_slice(), x.as_mut_slice())?;
    /*Compute  inv(L^T)*x.*/
    mosek::sparse_triangular_solve_dense(Transpose::YES, lnzc.as_slice(), lptrc.as_slice(), lsubc.as_slice(), lvalc.as_slice(), x.as_mut_slice())?;

    print!("\nSolution A x = b, x = [ {:?} ]",
           iproduct!(0..n,izip!(perm.iter(),x.iter()))
           .filter_map(|(i,(&pj,&xj))|if pj as usize == i { Some(xj) } else { None })
           .collect::<Vec<f64>>());
    let n     = 3;
    let anzc  = [3, 2, 1];
    let asubc = [0, 1, 2, 1, 2, 2];
    let aptrc = [0, 3, 5, ];
    let avalc = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0];

    let mut perm   = Vec::new();
    let mut lnzc   = Vec::new();
    let mut lsubc  = Vec::new();
    let mut diag   = Vec::new();
    let mut lptrc  = Vec::new();
    let mut lvalc  = Vec::new();
    let mut lensubnval = 0;

    mosek::compute_sparse_cholesky(0,        //Mosek chooses number of threads
                                   1,        //Apply reordering heuristic
                                   1.0e-14,  //Singularity tolerance
                                   &anzc, &aptrc, &asubc, &avalc,
                                   & mut perm, & mut diag,
                                   & mut lnzc, & mut lptrc, & mut lensubnval, & mut lsubc, & mut lvalc)?;

    print_sparse(n, perm.as_slice(), diag.as_slice(), lnzc.as_slice(), lptrc.as_slice(), lsubc.as_slice(), lvalc.as_slice());

    Ok(())
}