raddy 0.0.0-beta2

An automatic differentiation system for geometry and simulation.
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use crate::{types::admat, Ad};
use itertools::Itertools;
use na::{SMatrix, SVector};

#[inline]
/// Creates an inactive scalar Ad value with specified inputd dimensions
///
/// # Arguments
/// * `value` - The scalar value to wrap in an Ad type
///
/// # Type Parameters
/// * `N` - The input dimension (for derivatives)
///
/// # Returns
/// An `Ad<N>` instance representing an inactive scalar value
pub fn scalar<const N: usize>(value: f64) -> Ad<N> {
    Ad::inactive_scalar(value)
}

#[inline]
/// Creates a vector of inactive Ad values with separate input and vector dimensions
///
/// # Arguments
/// * `values` - Slice of f64 values to convert to inactive Ad values
///
/// # Type Parameters
/// * `N` - The input dimension (for derivatives)
/// * `L` - The length of the vector
///
/// # Returns
/// An SVector of `Ad<N>` values where each element is inactive
pub fn vector_from_slice<const N: usize, const L: usize>(values: &[f64]) -> SVector<Ad<N>, L> {
    Ad::inactive_from_slice(values)
}

/// Creates a vector of inactive Ad values with separate input and vector dimensions
///
/// # Arguments
/// * `values` - Slice of f64 values to convert to inactive Ad values
///
/// # Type Parameters
/// * `N` - The input dimension (for derivatives)
/// * `L` - The length of the vector
///
/// # Returns
/// An SVector of `Ad<N>` values where each element is inactive
pub fn vectpr<const N: usize, const L: usize>(values: &[f64]) -> SVector<Ad<N>, L> {
    Ad::inactive_from_slice(values)
}

/// Creates a matrix of inactive Ad values from a row-major slice
///
/// # Arguments
/// * `values` - Slice of f64 values in row-major order to convert to inactive Ad values
///
/// # Type Parameters
/// * `N` - The input dimension (for derivatives)
/// * `R` - The number of rows
/// * `C` - The number of columns
///
/// # Panics
/// Panics if the length of values does not equal R * C
///
/// # Returns
/// An SMatrix of `Ad<N>` values where each element is inactive
pub fn matrix_from_row_slice<const N: usize, const R: usize, const C: usize>(
    values: &[f64],
) -> SMatrix<Ad<N>, R, C> {
    assert_eq!(
        values.len(),
        R * C,
        "Slice mismatch matrix dimensions: found {}, expected : {} ({}x{})",
        values.len(),
        R * C,
        R,
        C
    );
    let mut res: admat<N, R, C> = SMatrix::zeros();

    for (r, c) in (0..R).cartesian_product(0..C) {
        res[(r, c)].value = values[r * C + c];
    }

    res
}

/// Creates a matrix of inactive Ad values from a column-major slice
///
/// # Arguments
/// * `values` - Slice of f64 values in column-major order to convert to inactive Ad values
///
/// # Type Parameters
/// * `N` - The input dimension (for derivatives)
/// * `R` - The number of rows
/// * `C` - The number of columns
///
/// # Panics
/// Panics if the length of values does not equal R * C
///
/// # Returns
/// An SMatrix of `Ad<N>` values where each element is inactive
pub fn matrix_from_column_slice<const N: usize, const R: usize, const C: usize>(
    values: &[f64],
) -> SMatrix<Ad<N>, R, C> {
    assert_eq!(
        values.len(),
        R * C,
        "Slice mismatch matrix dimensions: found {}, expected: {} ({}x{})",
        values.len(),
        R * C,
        R,
        C
    );
    let mut res: admat<N, R, C> = SMatrix::zeros();

    for (r, c) in (0..R).cartesian_product(0..C) {
        res[(r, c)].value = values[c * R + r];
    }

    res
}

/// Converts a matrix of f64 values to a matrix of inactive Ad values
///
/// # Arguments
/// * `matrix` - The matrix of f64 values to convert
///
/// # Type Parameters
/// * `N` - The input dimension (for derivatives)
/// * `R` - The number of rows
/// * `C` - The number of columns
///
/// # Returns
/// An SMatrix of `Ad<N>` values where each element is inactive
pub fn valmat<const N: usize, const R: usize, const C: usize>(
    matrix: SMatrix<f64, R, C>,
) -> SMatrix<Ad<N>, R, C> {
    let mut res: admat<N, R, C> = SMatrix::zeros();

    for (r, c) in (0..R).cartesian_product(0..C) {
        res[(r, c)].value = matrix[(r, c)];
    }

    res
}