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

//! Generic implementations of global optimization algorithms.
//!
//! All algorithms use tensor operations and are generic over `R: Runtime<DType = DType>`.
use crate::DType;

pub mod basinhopping;
pub mod differential_evolution;
pub mod dual_annealing;
pub mod shgo;
pub mod simulated_annealing;

pub use basinhopping::basinhopping_impl;
pub use differential_evolution::differential_evolution_impl;
pub use dual_annealing::dual_annealing_impl;
pub use shgo::shgo_impl;
pub use simulated_annealing::simulated_annealing_impl;

use numr::ops::{CompareOps, TensorOps};
use numr::runtime::{Runtime, RuntimeClient};
use numr::tensor::Tensor;

use crate::optimize::error::{OptimizeError, OptimizeResult};

/// Validate that lower < upper for all dimensions using tensor ops.
pub(crate) fn validate_bounds<R, C>(
    client: &C,
    lower: &Tensor<R>,
    upper: &Tensor<R>,
) -> OptimizeResult<()>
where
    R: Runtime<DType = DType>,
    C: TensorOps<R> + CompareOps<R> + RuntimeClient<R>,
{
    let violations = client
        .ge(lower, upper)
        .map_err(|e| OptimizeError::NumericalError {
            message: format!("bounds check - {}", e),
        })?;

    let violation_sum =
        client
            .sum(&violations, &[0], false)
            .map_err(|e| OptimizeError::NumericalError {
                message: format!("sum violations - {}", e),
            })?;

    let sum_val: Vec<f64> = violation_sum.to_vec();
    if sum_val[0] > 0.0 {
        return Err(OptimizeError::InvalidInput {
            context: "lower bounds must be less than upper bounds".to_string(),
        });
    }

    Ok(())
}

/// Clamp tensor to bounds: max(lower, min(upper, x))
pub(crate) fn clamp_to_bounds<R, C>(
    client: &C,
    x: &Tensor<R>,
    lower: &Tensor<R>,
    upper: &Tensor<R>,
) -> OptimizeResult<Tensor<R>>
where
    R: Runtime<DType = DType>,
    C: TensorOps<R>,
{
    let clamped_upper = client
        .minimum(x, upper)
        .map_err(|e| OptimizeError::NumericalError {
            message: format!("clamp: min with upper - {}", e),
        })?;
    client
        .maximum(&clamped_upper, lower)
        .map_err(|e| OptimizeError::NumericalError {
            message: format!("clamp: max with lower - {}", e),
        })
}