solvr 0.2.0

Advanced computing library for real-world problem solving - optimization, differential equations, interpolation, statistics, and more
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
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

//! CUDA implementation of sparse QR algorithms.

use crate::linalg::traits::sparse_qr::SparseQrAlgorithms;
use numr::algorithm::sparse_linalg::qr::{self, QrFactors, QrMetrics, QrOptions, QrSymbolic};
use numr::error::Result;
use numr::runtime::cuda::{CudaClient, CudaRuntime};
use numr::sparse::{CscData, SparseStorage};
use numr::tensor::Tensor;

impl SparseQrAlgorithms<CudaRuntime> for CudaClient {
    fn sparse_qr(
        &self,
        a: &CscData<CudaRuntime>,
        options: &QrOptions,
    ) -> Result<QrFactors<CudaRuntime>> {
        // `sparse_qr_simple_cuda` needs the CPU-resident CSC structure to run the
        // symbolic analysis host-side (avoids GPU→CPU transfers during traversal).
        let col_ptrs: Vec<i64> = a.col_ptrs().to_vec();
        let row_indices: Vec<i64> = a.row_indices().to_vec();
        qr::sparse_qr_simple_cuda(self, a, &col_ptrs, &row_indices, options)
    }

    fn sparse_qr_with_symbolic(
        &self,
        a: &CscData<CudaRuntime>,
        symbolic: &QrSymbolic,
        options: &QrOptions,
    ) -> Result<QrFactors<CudaRuntime>> {
        qr::sparse_qr_cuda(self, a, symbolic, options)
    }

    fn sparse_qr_with_metrics(
        &self,
        a: &CscData<CudaRuntime>,
        symbolic: &QrSymbolic,
        options: &QrOptions,
    ) -> Result<(QrFactors<CudaRuntime>, QrMetrics)> {
        // CUDA backend doesn't have a separate metrics variant;
        // factorize and compute metrics from the result.
        let factors = qr::sparse_qr_cuda(self, a, symbolic, options)?;
        let r_nnz = factors.r.nnz();
        let original_nnz = a.nnz();
        let metrics = QrMetrics {
            original_nnz,
            r_nnz,
            fill_ratio: if original_nnz > 0 {
                r_nnz as f64 / original_nnz as f64
            } else {
                0.0
            },
            numerical_rank: factors.rank,
        };
        Ok((factors, metrics))
    }

    fn sparse_qr_symbolic(
        &self,
        a: &CscData<CudaRuntime>,
        options: &QrOptions,
    ) -> Result<QrSymbolic> {
        let col_ptrs: Vec<i64> = a.col_ptrs().to_vec();
        let row_indices: Vec<i64> = a.row_indices().to_vec();
        let [m, n] = a.shape();
        qr::sparse_qr_symbolic(&col_ptrs, &row_indices, m, n, options)
    }

    fn sparse_qr_solve(
        &self,
        factors: &QrFactors<CudaRuntime>,
        b: &Tensor<CudaRuntime>,
    ) -> Result<Tensor<CudaRuntime>> {
        qr::sparse_qr_solve_cuda(self, factors, b)
    }

    fn sparse_least_squares(
        &self,
        factors: &QrFactors<CudaRuntime>,
        b: &Tensor<CudaRuntime>,
    ) -> Result<Tensor<CudaRuntime>> {
        // For CUDA, solve using the same solve path (works for overdetermined too)
        qr::sparse_qr_solve_cuda(self, factors, b)
    }
}