solvr 0.2.0-beta.2

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

//! Validation helpers for spatial algorithms.

use numr::dtype::DType;
use numr::error::{Error, Result};

/// Validate point set dtype (must be F32 or F64).
pub fn validate_points_dtype(dtype: DType, op: &'static str) -> Result<()> {
    match dtype {
        DType::F32 | DType::F64 => Ok(()),
        _ => Err(Error::UnsupportedDType { dtype, op }),
    }
}

/// Validate that points are 2D [n, d].
pub fn validate_points_2d(shape: &[usize], op: &'static str) -> Result<()> {
    if shape.len() != 2 {
        return Err(Error::InvalidArgument {
            arg: "points",
            reason: format!("{op} requires 2D point set [n, d], got {}-D", shape.len()),
        });
    }
    Ok(())
}

/// Validate that two point sets have matching dimensionality.
pub fn validate_matching_dims(
    x_shape: &[usize],
    y_shape: &[usize],
    op: &'static str,
) -> Result<()> {
    if x_shape.len() < 2 || y_shape.len() < 2 {
        return Err(Error::InvalidArgument {
            arg: "points",
            reason: format!("{op} requires 2D point sets"),
        });
    }
    if x_shape[1] != y_shape[1] {
        return Err(Error::InvalidArgument {
            arg: "points",
            reason: format!(
                "{op} requires matching dimensions: x has {} dims, y has {} dims",
                x_shape[1], y_shape[1]
            ),
        });
    }
    Ok(())
}

/// Validate k parameter for k-nearest neighbors.
pub fn validate_k(k: usize, n_points: usize, op: &'static str) -> Result<()> {
    if k == 0 {
        return Err(Error::InvalidArgument {
            arg: "k",
            reason: format!("{op} requires k > 0"),
        });
    }
    if k > n_points {
        return Err(Error::InvalidArgument {
            arg: "k",
            reason: format!("{op}: k={k} exceeds number of points {n_points}"),
        });
    }
    Ok(())
}

/// Validate radius parameter for radius search.
pub fn validate_radius(radius: f64, op: &'static str) -> Result<()> {
    if radius < 0.0 {
        return Err(Error::InvalidArgument {
            arg: "radius",
            reason: format!("{op} requires radius >= 0, got {radius}"),
        });
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_validate_points_dtype() {
        assert!(validate_points_dtype(DType::F32, "test").is_ok());
        assert!(validate_points_dtype(DType::F64, "test").is_ok());
        assert!(validate_points_dtype(DType::I32, "test").is_err());
    }

    #[test]
    fn test_validate_points_2d() {
        assert!(validate_points_2d(&[10, 3], "test").is_ok());
        assert!(validate_points_2d(&[10], "test").is_err());
        assert!(validate_points_2d(&[10, 3, 2], "test").is_err());
    }

    #[test]
    fn test_validate_k() {
        assert!(validate_k(5, 100, "test").is_ok());
        assert!(validate_k(0, 100, "test").is_err());
        assert!(validate_k(101, 100, "test").is_err());
    }
}