rgsl/types/
multilarge_linear.rs

1//
2// A rust binding for the GSL library by Guillaume Gomez (guillaume1.gomez@gmail.com)
3//
4
5use crate::{MatrixF64, Value, VectorF64};
6use ffi::FFI;
7
8ffi_wrapper!(MultilargeLinearType, *const sys::gsl_multilarge_linear_type);
9
10impl MultilargeLinearType {
11    #[doc(alias = "gsl_multilarge_linear_normal")]
12    pub fn normal() -> MultilargeLinearType {
13        ffi_wrap!(gsl_multilarge_linear_normal)
14    }
15
16    #[doc(alias = "gsl_multilarge_linear_tsqr")]
17    pub fn tsqr() -> MultilargeLinearType {
18        ffi_wrap!(gsl_multilarge_linear_tsqr)
19    }
20}
21
22ffi_wrapper!(
23    MultilargeLinearWorkspace,
24    *mut sys::gsl_multilarge_linear_workspace,
25    gsl_multilarge_linear_free
26);
27
28impl MultilargeLinearWorkspace {
29    #[doc(alias = "gsl_multilarge_linear_alloc")]
30    pub fn new(t: MultilargeLinearType, p: usize) -> Option<Self> {
31        let s = unsafe { sys::gsl_multilarge_linear_alloc(t.unwrap_shared(), p) };
32        if s.is_null() {
33            None
34        } else {
35            Some(Self::wrap(s))
36        }
37    }
38
39    #[doc(alias = "gsl_multilarge_linear_name")]
40    pub fn name(&self) -> Option<String> {
41        let n = unsafe { sys::gsl_multilarge_linear_name(self.unwrap_shared()) };
42        if n.is_null() {
43            return None;
44        }
45        let mut len = 0;
46        loop {
47            if unsafe { *n.offset(len) } == 0 {
48                break;
49            }
50            len += 1;
51        }
52        let slice = unsafe { std::slice::from_raw_parts(n as _, len as _) };
53        std::str::from_utf8(slice).ok().map(|x| x.to_owned())
54    }
55
56    #[doc(alias = "gsl_multilarge_linear_reset")]
57    pub fn reset(&mut self) -> Result<(), Value> {
58        let ret = unsafe { sys::gsl_multilarge_linear_reset(self.unwrap_unique()) };
59        result_handler!(ret, ())
60    }
61
62    #[doc(alias = "gsl_multilarge_linear_accumulate")]
63    pub fn accumulate(&mut self, x: &mut MatrixF64, y: &mut VectorF64) -> Result<(), Value> {
64        let ret = unsafe {
65            sys::gsl_multilarge_linear_accumulate(
66                x.unwrap_unique(),
67                y.unwrap_unique(),
68                self.unwrap_unique(),
69            )
70        };
71        result_handler!(ret, ())
72    }
73
74    /// Returns `(rnorm, snorm)`.
75    #[doc(alias = "gsl_multilarge_linear_solve")]
76    pub fn solve(&mut self, lambda: f64, c: &mut VectorF64) -> Result<(f64, f64), Value> {
77        let mut rnorm = 0.;
78        let mut snorm = 0.;
79        let ret = unsafe {
80            sys::gsl_multilarge_linear_solve(
81                lambda,
82                c.unwrap_unique(),
83                &mut rnorm,
84                &mut snorm,
85                self.unwrap_unique(),
86            )
87        };
88        result_handler!(ret, (rnorm, snorm))
89    }
90
91    /// Returns `rcond`.
92    #[doc(alias = "gsl_multilarge_linear_rcond")]
93    pub fn rcond(&mut self) -> Result<f64, Value> {
94        let mut rcond = 0.;
95        let ret = unsafe { sys::gsl_multilarge_linear_rcond(&mut rcond, self.unwrap_unique()) };
96        result_handler!(ret, rcond)
97    }
98
99    #[cfg(feature = "v2_2")]
100    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_2")))]
101    #[doc(alias = "gsl_multilarge_linear_lcurve")]
102    pub fn lcurve(
103        &mut self,
104        reg_param: &mut VectorF64,
105        rho: &mut VectorF64,
106        eta: &mut VectorF64,
107    ) -> Result<(), Value> {
108        let ret = unsafe {
109            sys::gsl_multilarge_linear_lcurve(
110                reg_param.unwrap_unique(),
111                rho.unwrap_unique(),
112                eta.unwrap_unique(),
113                self.unwrap_unique(),
114            )
115        };
116        result_handler!(ret, ())
117    }
118
119    #[doc(alias = "gsl_multilarge_linear_wstdform1")]
120    pub fn wstdform1(
121        &mut self,
122        L: &VectorF64,
123        X: &MatrixF64,
124        w: &VectorF64,
125        y: &VectorF64,
126        Xs: &mut MatrixF64,
127        ys: &mut VectorF64,
128    ) -> Result<(), Value> {
129        let ret = unsafe {
130            sys::gsl_multilarge_linear_wstdform1(
131                L.unwrap_shared(),
132                X.unwrap_shared(),
133                w.unwrap_shared(),
134                y.unwrap_shared(),
135                Xs.unwrap_unique(),
136                ys.unwrap_unique(),
137                self.unwrap_unique(),
138            )
139        };
140        result_handler!(ret, ())
141    }
142
143    #[doc(alias = "gsl_multilarge_linear_stdform1")]
144    pub fn stdform1(
145        &mut self,
146        L: &VectorF64,
147        X: &MatrixF64,
148        y: &VectorF64,
149        Xs: &mut MatrixF64,
150        ys: &mut VectorF64,
151    ) -> Result<(), Value> {
152        let ret = unsafe {
153            sys::gsl_multilarge_linear_stdform1(
154                L.unwrap_shared(),
155                X.unwrap_shared(),
156                y.unwrap_shared(),
157                Xs.unwrap_unique(),
158                ys.unwrap_unique(),
159                self.unwrap_unique(),
160            )
161        };
162        result_handler!(ret, ())
163    }
164
165    #[doc(alias = "gsl_multilarge_linear_wstdform2")]
166    pub fn wstdform2(
167        &mut self,
168        LQR: &MatrixF64,
169        Ltau: &VectorF64,
170        X: &MatrixF64,
171        w: &VectorF64,
172        y: &VectorF64,
173        Xs: &mut MatrixF64,
174        ys: &mut VectorF64,
175    ) -> Result<(), Value> {
176        let ret = unsafe {
177            sys::gsl_multilarge_linear_wstdform2(
178                LQR.unwrap_shared(),
179                Ltau.unwrap_shared(),
180                X.unwrap_shared(),
181                w.unwrap_shared(),
182                y.unwrap_shared(),
183                Xs.unwrap_unique(),
184                ys.unwrap_unique(),
185                self.unwrap_unique(),
186            )
187        };
188        result_handler!(ret, ())
189    }
190
191    #[doc(alias = "gsl_multilarge_linear_stdform2")]
192    pub fn stdform2(
193        &mut self,
194        LQR: &MatrixF64,
195        Ltau: &VectorF64,
196        X: &MatrixF64,
197        y: &VectorF64,
198        Xs: &mut MatrixF64,
199        ys: &mut VectorF64,
200    ) -> Result<(), Value> {
201        let ret = unsafe {
202            sys::gsl_multilarge_linear_stdform2(
203                LQR.unwrap_shared(),
204                Ltau.unwrap_shared(),
205                X.unwrap_shared(),
206                y.unwrap_shared(),
207                Xs.unwrap_unique(),
208                ys.unwrap_unique(),
209                self.unwrap_unique(),
210            )
211        };
212        result_handler!(ret, ())
213    }
214
215    #[doc(alias = "gsl_multilarge_linear_genform1")]
216    pub fn genform1(
217        &mut self,
218        L: &VectorF64,
219        cs: &VectorF64,
220        c: &mut VectorF64,
221    ) -> Result<(), Value> {
222        let ret = unsafe {
223            sys::gsl_multilarge_linear_genform1(
224                L.unwrap_shared(),
225                cs.unwrap_shared(),
226                c.unwrap_unique(),
227                self.unwrap_unique(),
228            )
229        };
230        result_handler!(ret, ())
231    }
232
233    #[doc(alias = "gsl_multilarge_linear_genform2")]
234    pub fn genform2(
235        &mut self,
236        LQR: &MatrixF64,
237        Ltau: &VectorF64,
238        cs: &VectorF64,
239        c: &mut VectorF64,
240    ) -> Result<(), Value> {
241        let ret = unsafe {
242            sys::gsl_multilarge_linear_genform2(
243                LQR.unwrap_shared(),
244                Ltau.unwrap_shared(),
245                cs.unwrap_shared(),
246                c.unwrap_unique(),
247                self.unwrap_unique(),
248            )
249        };
250        result_handler!(ret, ())
251    }
252
253    #[cfg(feature = "v2_7")]
254    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_7")))]
255    #[doc(alias = "gsl_multilarge_linear_matrix_ptr")]
256    pub fn matrix<F: FnOnce(&MatrixF64)>(&self, f: F) {
257        f(&MatrixF64::soft_wrap(unsafe {
258            sys::gsl_multilarge_linear_matrix_ptr(self.unwrap_shared()) as _
259        }))
260    }
261
262    #[cfg(feature = "v2_7")]
263    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_7")))]
264    #[doc(alias = "gsl_multilarge_linear_rhs_ptr")]
265    pub fn rhs<F: FnOnce(&VectorF64)>(&self, f: F) {
266        f(&VectorF64::soft_wrap(unsafe {
267            sys::gsl_multilarge_linear_rhs_ptr(self.unwrap_shared()) as _
268        }))
269    }
270}
rgsl/types/multilarge_linear.rs

rgsl/types/
multilarge_linear.rs
