kryst 3.2.1

Krylov subspace and preconditioned iterative solvers for dense and sparse linear systems, with shared and distributed memory parallelism.
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

#[cfg(feature = "complex")]
fn main() {
    eprintln!("test_superlu_cli.rs is unavailable when built with --features complex");
}

use kryst::{KspOptions, PcOptions, error::KError};

#[cfg(not(feature = "complex"))]
fn main() -> Result<(), KError> {
    // Test command line parsing for SuperLU_DIST
    let args = vec![
        "test_program",
        "-ksp_type",
        "preonly",
        "-pc_type",
        "superlu_dist",
        "-pc_superlu_pivot_threshold",
        "0.5",
        "-pc_superlu_print_level",
        "1",
        "-pc_superlu_process_grid",
        "2",
        "3",
        "-pc_superlu_replace_tiny_pivot",
        "true",
        "-pc_superlu_iterative_refinement",
        "DOUBLE",
        "-pc_superlu_column_permutation",
        "NATURAL",
        "-pc_superlu_row_permutation",
        "LargeDiag",
        "-pc_superlu_static_pivoting",
        "false",
    ];

    // Parse KSP command line options
    let ksp_options = KspOptions::from_args(&args)?;

    // Parse PC command line options
    let pc_options = PcOptions::from_args(&args)?;

    // Verify the KSP type was parsed correctly
    assert_eq!(ksp_options.ksp_type, Some("preonly".to_string()));

    // Verify the PC type was parsed correctly
    assert_eq!(pc_options.pc_type, Some("superlu_dist".to_string()));

    // Verify SuperLU_DIST specific options were parsed correctly
    assert_eq!(pc_options.superlu_pivot_threshold, Some(0.5));
    assert_eq!(pc_options.superlu_print_level, Some(1));
    assert_eq!(pc_options.superlu_process_grid, Some((2, 3)));
    assert_eq!(pc_options.superlu_replace_tiny_pivots, Some(true));
    assert_eq!(
        pc_options.superlu_iterative_refinement,
        Some("DOUBLE".to_string())
    );
    assert_eq!(
        pc_options.superlu_column_permutation,
        Some("NATURAL".to_string())
    );
    assert_eq!(
        pc_options.superlu_row_permutation,
        Some("LargeDiag".to_string())
    );
    assert_eq!(pc_options.superlu_static_pivoting, Some(false));

    println!("✓ All SuperLU_DIST command line options parsed correctly");
    println!(
        "  - Pivot threshold: {:?}",
        pc_options.superlu_pivot_threshold
    );
    println!("  - Print level: {:?}", pc_options.superlu_print_level);
    println!("  - Process grid: {:?}", pc_options.superlu_process_grid);
    println!(
        "  - Replace tiny pivots: {:?}",
        pc_options.superlu_replace_tiny_pivots
    );
    println!(
        "  - Iterative refinement: {:?}",
        pc_options.superlu_iterative_refinement
    );
    println!(
        "  - Column permutation: {:?}",
        pc_options.superlu_column_permutation
    );
    println!(
        "  - Row permutation: {:?}",
        pc_options.superlu_row_permutation
    );
    println!(
        "  - Static pivoting: {:?}",
        pc_options.superlu_static_pivoting
    );

    println!("✓ SuperLU_DIST integration via PREONLY interface is working!");

    Ok(())
}