GSL 1.1.0

A rust binding for the GSL (the GNU scientific library)
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247

use libc::{c_double, c_char, c_void, size_t, c_int};

use super::{gsl_vector, gsl_matrix};

extern "C" {
    pub static gsl_multifit_fdfsolver_lmder: *mut gsl_multifit_fdfsolver_type;
    pub static gsl_multifit_fdfsolver_lmsder: *mut gsl_multifit_fdfsolver_type;

    pub static gsl_root_fsolver_bisection: *mut gsl_root_fsolver_type;
    pub static gsl_root_fsolver_brent: *mut gsl_root_fsolver_type;
    pub static gsl_root_fsolver_falsepos: *mut gsl_root_fsolver_type;

    pub static gsl_root_fdfsolver_newton: *mut gsl_root_fdfsolver_type;
    pub static gsl_root_fdfsolver_secant: *mut gsl_root_fdfsolver_type;
    pub static gsl_root_fdfsolver_steffenson: *mut gsl_root_fdfsolver_type;

    // multifit
    pub fn gsl_multifit_covar(j: *const gsl_matrix,
                              epsrel: c_double,
                              covar: *mut gsl_matrix)
                              -> c_int;

    pub fn gsl_multifit_fdfsolver_alloc(T: *const gsl_multifit_fdfsolver_type,
                                        n: size_t,
                                        p: size_t)
                                        -> *mut gsl_multifit_fdfsolver;
    pub fn gsl_multifit_fdfsolver_set(s: *mut gsl_multifit_fdfsolver,
                                      fdf: *mut gsl_multifit_function_fdf,
                                      x: *const gsl_vector)
                                      -> c_int;
    pub fn gsl_multifit_fdfsolver_iterate(s: *mut gsl_multifit_fdfsolver) -> c_int;
    pub fn gsl_multifit_fdfsolver_free(s: *mut gsl_multifit_fdfsolver);
    pub fn gsl_multifit_fdfsolver_name(s: *const gsl_multifit_fdfsolver) -> *const c_char;
    pub fn gsl_multifit_fdfsolver_position(s: *const gsl_multifit_fdfsolver) -> *mut gsl_vector;

    pub fn gsl_multifit_fsolver_alloc(T: *const gsl_multifit_fsolver_type,
                                      n: size_t,
                                      p: size_t)
                                      -> *mut gsl_multifit_fsolver;
    pub fn gsl_multifit_fsolver_free(s: *mut gsl_multifit_fsolver);
    pub fn gsl_multifit_fsolver_set(s: *mut gsl_multifit_fsolver,
                                    f: *mut ::MultiFitFunction,
                                    x: *const gsl_vector)
                                    -> c_int;
    pub fn gsl_multifit_fsolver_iterate(s: *mut gsl_multifit_fsolver) -> c_int;
    pub fn gsl_multifit_fsolver_name(s: *const gsl_multifit_fsolver) -> *const c_char;
    pub fn gsl_multifit_fsolver_position(s: *const gsl_multifit_fsolver) -> *mut gsl_vector;

    //pub fn gsl_multifit_robust_weight();
    //pub fn gsl_multifit_robust_residuals();

    pub fn gsl_multifit_gradient(j: *const gsl_matrix,
                                 f: *const gsl_vector,
                                 g: *mut gsl_vector)
                                 -> c_int;

    pub fn gsl_multifit_test_delta(dx: *const gsl_vector,
                                   x: *const gsl_vector,
                                   epsabs: c_double,
                                   epsrel: c_double)
                                   -> c_int;
    //pub fn gsl_multifit_test_gradient();

    // one-dimensional root
    pub fn gsl_root_fsolver_alloc(T: *const gsl_root_fsolver_type) -> *mut gsl_root_fsolver;
    pub fn gsl_root_fsolver_free(s: *mut gsl_root_fsolver);
    pub fn gsl_root_fsolver_set(s: *mut gsl_root_fsolver,
                                f: *mut gsl_function,
                                x_lower: c_double,
                                x_upper: c_double)
                                -> c_int;
    pub fn gsl_root_fsolver_iterate(s: *mut gsl_root_fsolver) -> c_int;
    pub fn gsl_root_fsolver_name(s: *const gsl_root_fsolver) -> *const c_char;
    pub fn gsl_root_fsolver_root(s: *const gsl_root_fsolver) -> c_double;
    pub fn gsl_root_fsolver_x_lower(s: *const gsl_root_fsolver) -> c_double;
    pub fn gsl_root_fsolver_x_upper(s: *const gsl_root_fsolver) -> c_double;

    pub fn gsl_root_fdfsolver_alloc(T: *const gsl_root_fdfsolver_type) -> *mut gsl_root_fdfsolver;
    pub fn gsl_root_fdfsolver_free(s: *mut gsl_root_fdfsolver);
    pub fn gsl_root_fdfsolver_set(s: *mut gsl_root_fdfsolver,
                                  fdf: *mut gsl_function_fdf,
                                  root: c_double)
                                  -> c_int;
    pub fn gsl_root_fdfsolver_iterate(s: *mut gsl_root_fdfsolver) -> c_int;
    pub fn gsl_root_fdfsolver_name(s: *const gsl_root_fdfsolver) -> *const c_char;
    pub fn gsl_root_fdfsolver_root(s: *const gsl_root_fdfsolver) -> c_double;

    pub fn gsl_root_test_interval(x_lower: c_double,
                                  x_upper: c_double,
                                  epsabs: c_double,
                                  epsrel: c_double)
                                  -> c_int;
    pub fn gsl_root_test_residual(f: c_double, epsabs: c_double) -> c_int;
    pub fn gsl_root_test_delta(x1: c_double,
                               x0: c_double,
                               epsabs: c_double,
                               epsrel: c_double)
                               -> c_int;
}

// multifit fsolver/fdfsolver types:

#[repr(C)]
pub struct gsl_multifit_fsolver_type {
    name: *const c_char,
    pub size: size_t,
    pub alloc: Option<extern "C" fn(state: *mut c_void, n: size_t, p: size_t) -> c_int>,
    pub set: Option<extern "C" fn(state: *mut c_void,
                                  function: *mut ::MultiFitFunction,
                                  x: *mut gsl_vector,
                                  f: *mut gsl_vector,
                                  dx: *mut gsl_vector)
                                  -> c_int>,
    pub iterate: Option<extern "C" fn(state: *mut c_void,
                                      function: *mut ::MultiFitFunction,
                                      x: *mut gsl_vector,
                                      f: *mut gsl_vector,
                                      dx: *mut gsl_vector)
                                      -> c_int>,
    pub free: Option<extern "C" fn(state: *mut c_void)>,
}

#[repr(C)]
pub struct gsl_multifit_fsolver {
    pub type_: *const gsl_multifit_fsolver_type,
    pub function: *mut ::MultiFitFunction,
    pub x: *mut gsl_vector,
    pub f: *mut gsl_vector,
    pub dx: *mut gsl_vector,
    pub state: *mut c_void,
}

#[repr(C)]
pub struct gsl_multifit_function_fdf {
    pub f: Option<extern "C" fn(x: *mut gsl_vector, params: *mut c_void, f: *mut gsl_vector)
                                -> c_int>,
    pub df: Option<extern "C" fn(x: *mut gsl_vector, params: *mut c_void, df: *mut gsl_matrix)
                                 -> c_int>,
    pub fdf: Option<extern "C" fn(x: *mut gsl_vector,
                                  params: *mut c_void,
                                  f: *mut gsl_vector,
                                  df: *mut gsl_matrix)
                                  -> c_int>,
    pub n: size_t,
    pub p: size_t,
    pub params: *mut c_void,
}

#[repr(C)]
pub struct gsl_multifit_fdfsolver_type {
    pub name: *const c_char,
    pub size: size_t,
    pub alloc: Option<extern "C" fn(state: *mut c_void, n: size_t, p: size_t) -> c_int>,
    pub set: Option<extern "C" fn(state: *mut c_void,
                                  fdf: *mut gsl_multifit_function_fdf,
                                  x: *mut gsl_vector,
                                  f: *mut gsl_vector,
                                  J: *mut gsl_matrix,
                                  dx: *mut gsl_vector)
                                  -> c_int>,
    pub iterate: Option<extern "C" fn(state: *mut c_void,
                                      fdf: *mut gsl_multifit_function_fdf,
                                      x: *mut gsl_vector,
                                      f: *mut gsl_vector,
                                      J: *mut gsl_matrix,
                                      dx: *mut gsl_vector)
                                      -> c_int>,
    pub free: Option<extern "C" fn(state: *mut c_void)>,
}

#[repr(C)]
pub struct gsl_multifit_fdfsolver {
    pub type_: *const gsl_multifit_fdfsolver_type,
    pub fdf: *mut gsl_multifit_function_fdf,
    pub x: *mut gsl_vector,
    pub f: *mut gsl_vector,
    pub J: *mut gsl_matrix,
    pub dx: *mut gsl_vector,
    pub state: *mut c_void,
}

// one dimensional root solvers:

#[repr(C)]
pub struct gsl_function {
    pub function: Option<extern "C" fn(x: c_double, params: *mut c_void) -> c_double>,
    pub params: *mut c_void,
}

#[repr(C)]
pub struct gsl_root_fsolver_type {
    pub name: c_char,
    pub size: size_t,
    pub set: Option<extern "C" fn(state: *mut c_void,
                                  f: *mut gsl_function,
                                  root: c_double,
                                  x_lower: c_double,
                                  x_upper: c_double)
                                  -> c_int>,
    pub iterate: Option<extern "C" fn(state: *mut c_void,
                                      f: *mut gsl_function,
                                      root: c_double,
                                      x_lower: c_double,
                                      x_upper: c_double)
                                      -> c_int>,
}

#[repr(C)]
pub struct gsl_root_fsolver {
    pub type_: *const gsl_root_fsolver_type,
    pub gsl_function: *mut gsl_function,
    pub root: c_double,
    pub x_lower: c_double,
    pub x_upper: c_double,
    pub state: *mut c_void,
}

#[repr(C)]
pub struct gsl_function_fdf {
    pub f: Option<extern "C" fn(x: c_double, params: *mut c_void) -> c_double>,
    pub df: Option<extern "C" fn(x: c_double, params: *mut c_void) -> c_double>,
    pub fdf: Option<extern "C" fn(x: c_double,
                                  params: *mut c_void,
                                  y: &mut c_double,
                                  dy: &mut c_double)>,
    pub params: *mut c_void,
}

#[repr(C)]
pub struct gsl_root_fdfsolver_type {
    pub name: c_char,
    pub size: size_t,
    pub set: Option<extern "C" fn(state: *mut c_void, f: *mut gsl_function_fdf, root: c_double)
                                  -> c_int>,
    pub iterate: Option<extern "C" fn(state: *mut c_void,
                                      f: *mut gsl_function_fdf,
                                      root: c_double)
                                      -> c_int>,
}

#[repr(C)]
pub struct gsl_root_fdfsolver {
    pub type_: *const gsl_root_fdfsolver_type,
    pub gsl_function: *mut gsl_function_fdf,
    pub root: c_double,
    pub state: *mut c_void,
}