1extern "C" {
2 fn c_strcpy(dest: *mut ::std::os::raw::c_char, source: *const ::std::os::raw::c_char);
3 fn sqrt(_: ::std::os::raw::c_double) -> ::std::os::raw::c_double;
4 fn printf(_: *const ::std::os::raw::c_char, _: ...) -> ::std::os::raw::c_int;
5 fn osqp_toc(t: *mut OSQPTimer) -> c_float;
6 fn prea_vec_copy(a: *const c_float, b: *mut c_float, n: c_int);
7 fn vec_set_scalar(a: *mut c_float, sc: c_float, n: c_int);
8 fn vec_mult_scalar(a: *mut c_float, sc: c_float, n: c_int);
9 fn vec_add_scaled(
10 c: *mut c_float,
11 a: *const c_float,
12 b: *const c_float,
13 n: c_int,
14 sc: c_float,
15 );
16 fn vec_norm_inf(v: *const c_float, l: c_int) -> c_float;
17 fn vec_scaled_norm_inf(S: *const c_float, v: *const c_float, l: c_int) -> c_float;
18 fn vec_prod(a: *const c_float, b: *const c_float, n: c_int) -> c_float;
19 fn vec_ew_prod(a: *const c_float, b: *const c_float, c: *mut c_float, n: c_int);
20 fn mat_vec(A: *const csc, x: *const c_float, y: *mut c_float, plus_eq: c_int);
21 fn mat_tpose_vec(
22 A: *const csc,
23 x: *const c_float,
24 y: *mut c_float,
25 plus_eq: c_int,
26 skip_diag: c_int,
27 );
28 fn quad_form(P: *const csc, x: *const c_float) -> c_float;
29 fn osqp_update_rho(work: *mut OSQPWorkspace, rho_new: c_float) -> c_int;
30 fn project(work: *mut OSQPWorkspace, z: *mut c_float);
31 fn unscale_solution(work: *mut OSQPWorkspace) -> c_int;
32}
33pub type c_int = ::std::os::raw::c_longlong;
34pub type c_float = ::std::os::raw::c_double;
35pub type linsys_solver_type = ::std::os::raw::c_uint;
36pub const MKL_PARDISO_SOLVER: linsys_solver_type = 1;
37pub const QDLDL_SOLVER: linsys_solver_type = 0;
38#[derive(Copy, Clone)]
39#[repr(C)]
40pub struct csc {
41 pub nzmax: c_int,
42 pub m: c_int,
43 pub n: c_int,
44 pub p: *mut c_int,
45 pub i: *mut c_int,
46 pub x: *mut c_float,
47 pub nz: c_int,
48}
49#[derive(Copy, Clone)]
50#[repr(C)]
51pub struct linsys_solver {
52 pub type_0: linsys_solver_type,
53 pub solve: Option::<unsafe extern "C" fn(*mut LinSysSolver, *mut c_float) -> c_int>,
54 pub free: Option::<unsafe extern "C" fn(*mut LinSysSolver) -> ()>,
55 pub update_matrices: Option::<
56 unsafe extern "C" fn(*mut LinSysSolver, *const csc, *const csc) -> c_int,
57 >,
58 pub update_rho_vec: Option::<
59 unsafe extern "C" fn(*mut LinSysSolver, *const c_float) -> c_int,
60 >,
61 pub nthreads: c_int,
62}
63pub type LinSysSolver = linsys_solver;
64#[derive(Copy, Clone)]
65#[repr(C)]
66pub struct OSQP_TIMER {
67 pub tic: uint64_t,
68 pub toc: uint64_t,
69 pub tinfo: mach_timebase_info_data_t,
70}
71pub type mach_timebase_info_data_t = mach_timebase_info;
72#[derive(Copy, Clone)]
73#[repr(C)]
74pub struct mach_timebase_info {
75 pub numer: uint32_t,
76 pub denom: uint32_t,
77}
78pub type uint32_t = ::std::os::raw::c_uint;
79pub type uint64_t = ::std::os::raw::c_ulonglong;
80pub type OSQPTimer = OSQP_TIMER;
81#[derive(Copy, Clone)]
82#[repr(C)]
83pub struct OSQPScaling {
84 pub c: c_float,
85 pub D: *mut c_float,
86 pub E: *mut c_float,
87 pub cinv: c_float,
88 pub Dinv: *mut c_float,
89 pub Einv: *mut c_float,
90}
91#[derive(Copy, Clone)]
92#[repr(C)]
93pub struct OSQPSolution {
94 pub x: *mut c_float,
95 pub y: *mut c_float,
96}
97#[derive(Copy, Clone)]
98#[repr(C)]
99pub struct OSQPInfo {
100 pub iter: c_int,
101 pub status: [::std::os::raw::c_char; 32],
102 pub status_val: c_int,
103 pub status_polish: c_int,
104 pub obj_val: c_float,
105 pub pri_res: c_float,
106 pub dua_res: c_float,
107 pub setup_time: c_float,
108 pub solve_time: c_float,
109 pub update_time: c_float,
110 pub polish_time: c_float,
111 pub run_time: c_float,
112 pub rho_updates: c_int,
113 pub rho_estimate: c_float,
114}
115#[derive(Copy, Clone)]
116#[repr(C)]
117pub struct OSQPPolish {
118 pub Ared: *mut csc,
119 pub n_low: c_int,
120 pub n_upp: c_int,
121 pub A_to_Alow: *mut c_int,
122 pub A_to_Aupp: *mut c_int,
123 pub Alow_to_A: *mut c_int,
124 pub Aupp_to_A: *mut c_int,
125 pub x: *mut c_float,
126 pub z: *mut c_float,
127 pub y: *mut c_float,
128 pub obj_val: c_float,
129 pub pri_res: c_float,
130 pub dua_res: c_float,
131}
132#[derive(Copy, Clone)]
133#[repr(C)]
134pub struct OSQPData {
135 pub n: c_int,
136 pub m: c_int,
137 pub P: *mut csc,
138 pub A: *mut csc,
139 pub q: *mut c_float,
140 pub l: *mut c_float,
141 pub u: *mut c_float,
142}
143#[derive(Copy, Clone)]
144#[repr(C)]
145pub struct OSQPSettings {
146 pub rho: c_float,
147 pub sigma: c_float,
148 pub scaling: c_int,
149 pub adaptive_rho: c_int,
150 pub adaptive_rho_interval: c_int,
151 pub adaptive_rho_tolerance: c_float,
152 pub adaptive_rho_fraction: c_float,
153 pub max_iter: c_int,
154 pub eps_abs: c_float,
155 pub eps_rel: c_float,
156 pub eps_prim_inf: c_float,
157 pub eps_dual_inf: c_float,
158 pub alpha: c_float,
159 pub linsys_solver: linsys_solver_type,
160 pub delta: c_float,
161 pub polish: c_int,
162 pub polish_refine_iter: c_int,
163 pub verbose: c_int,
164 pub scaled_termination: c_int,
165 pub check_termination: c_int,
166 pub warm_start: c_int,
167 pub time_limit: c_float,
168}
169#[derive(Copy, Clone)]
170#[repr(C)]
171pub struct OSQPWorkspace {
172 pub data: *mut OSQPData,
173 pub linsys_solver: *mut LinSysSolver,
174 pub pol: *mut OSQPPolish,
175 pub rho_vec: *mut c_float,
176 pub rho_inv_vec: *mut c_float,
177 pub constr_type: *mut c_int,
178 pub x: *mut c_float,
179 pub y: *mut c_float,
180 pub z: *mut c_float,
181 pub xz_tilde: *mut c_float,
182 pub x_prev: *mut c_float,
183 pub z_prev: *mut c_float,
184 pub Ax: *mut c_float,
185 pub Px: *mut c_float,
186 pub Aty: *mut c_float,
187 pub delta_y: *mut c_float,
188 pub Atdelta_y: *mut c_float,
189 pub delta_x: *mut c_float,
190 pub Pdelta_x: *mut c_float,
191 pub Adelta_x: *mut c_float,
192 pub D_temp: *mut c_float,
193 pub D_temp_A: *mut c_float,
194 pub E_temp: *mut c_float,
195 pub settings: *mut OSQPSettings,
196 pub scaling: *mut OSQPScaling,
197 pub solution: *mut OSQPSolution,
198 pub info: *mut OSQPInfo,
199 pub timer: *mut OSQPTimer,
200 pub first_run: c_int,
201 pub clear_update_time: c_int,
202 pub rho_update_from_solve: c_int,
203 pub summary_printed: c_int,
204}
205pub const c_print: unsafe extern "C" fn(*const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int = printf;
206pub const OSQP_SOLVED: ::std::os::raw::c_int = 1 as ::std::os::raw::c_int;
207pub const OSQP_SOLVED_INACCURATE: ::std::os::raw::c_int = 2 as ::std::os::raw::c_int;
208pub const OSQP_MAX_ITER_REACHED: ::std::os::raw::c_int = -(2 as ::std::os::raw::c_int);
209pub const OSQP_TIME_LIMIT_REACHED: ::std::os::raw::c_int = -(6 as ::std::os::raw::c_int);
210pub const OSQP_SIGINT: ::std::os::raw::c_int = -(5 as ::std::os::raw::c_int);
211pub const OSQP_UNSOLVED: ::std::os::raw::c_int = -(10 as ::std::os::raw::c_int);
212pub const OSQP_NAN: ::std::os::raw::c_ulong = 0x7fc00000 as ::std::os::raw::c_ulong;
213pub const OSQP_PRIMAL_INFEASIBLE: ::std::os::raw::c_int = -(3 as ::std::os::raw::c_int);
214pub const OSQP_PRIMAL_INFEASIBLE_INACCURATE: ::std::os::raw::c_int = 3 as ::std::os::raw::c_int;
215pub const OSQP_DUAL_INFEASIBLE: ::std::os::raw::c_int = -(4 as ::std::os::raw::c_int);
216pub const OSQP_DUAL_INFEASIBLE_INACCURATE: ::std::os::raw::c_int = 4 as ::std::os::raw::c_int;
217pub const OSQP_NON_CVX: ::std::os::raw::c_int = -(7 as ::std::os::raw::c_int);
218pub const c_sqrt: unsafe extern "C" fn(::std::os::raw::c_double) -> ::std::os::raw::c_double = sqrt;
219pub const OSQP_INFTY: ::std::os::raw::c_double = 1e30f64;
220pub const OSQP_DIVISION_TOL: ::std::os::raw::c_double = 1.0f64 / OSQP_INFTY;
221pub const MIN_SCALING: ::std::os::raw::c_double = 1e-04f64;
222pub const RHO_EQ_OVER_RHO_INEQ: ::std::os::raw::c_double = 1e03f64;
223pub const RHO_TOL: ::std::os::raw::c_double = 1e-04f64;
224pub const RHO_MIN: ::std::os::raw::c_double = 1e-06f64;
225#[no_mangle]
226pub unsafe extern "C" fn compute_rho_estimate(mut work: *mut OSQPWorkspace) -> c_float {
227 let mut n: c_int = 0;
228 let mut m: c_int = 0;
229 let mut pri_res: c_float = 0.;
230 let mut dua_res: c_float = 0.;
231 let mut pri_res_norm: c_float = 0.;
232 let mut dua_res_norm: c_float = 0.;
233 let mut temp_res_norm: c_float = 0.;
234 let mut rho_estimate: c_float = 0.;
235 n = (*(*work).data).n;
236 m = (*(*work).data).m;
237 pri_res = vec_norm_inf((*work).z_prev, m);
238 dua_res = vec_norm_inf((*work).x_prev, n);
239 pri_res_norm = vec_norm_inf((*work).z, m);
240 temp_res_norm = vec_norm_inf((*work).Ax, m);
241 pri_res_norm = if pri_res_norm > temp_res_norm {
242 pri_res_norm
243 } else {
244 temp_res_norm
245 };
246 pri_res /= pri_res_norm + OSQP_DIVISION_TOL;
247 dua_res_norm = vec_norm_inf((*(*work).data).q, n);
248 temp_res_norm = vec_norm_inf((*work).Aty, n);
249 dua_res_norm = if dua_res_norm > temp_res_norm {
250 dua_res_norm
251 } else {
252 temp_res_norm
253 };
254 temp_res_norm = vec_norm_inf((*work).Px, n);
255 dua_res_norm = if dua_res_norm > temp_res_norm {
256 dua_res_norm
257 } else {
258 temp_res_norm
259 };
260 dua_res /= dua_res_norm + OSQP_DIVISION_TOL;
261 rho_estimate = (*(*work).settings).rho * sqrt(pri_res / dua_res);
262 rho_estimate = if (if rho_estimate > 1e-06f64 { rho_estimate } else { 1e-06f64 })
263 < 1e06f64
264 {
265 if rho_estimate > 1e-06f64 { rho_estimate } else { 1e-06f64 }
266 } else {
267 1e06f64
268 };
269 return rho_estimate;
270}
271#[no_mangle]
272pub unsafe extern "C" fn adapt_rho(mut work: *mut OSQPWorkspace) -> c_int {
273 let mut exitflag: c_int = 0;
274 let mut rho_new: c_float = 0.;
275 exitflag = 0 as ::std::os::raw::c_int as c_int;
276 rho_new = compute_rho_estimate(work);
277 (*(*work).info).rho_estimate = rho_new;
278 if rho_new > (*(*work).settings).rho * (*(*work).settings).adaptive_rho_tolerance
279 || rho_new < (*(*work).settings).rho / (*(*work).settings).adaptive_rho_tolerance
280 {
281 exitflag = osqp_update_rho(work, rho_new);
282 let ref mut fresh0 = (*(*work).info).rho_updates;
283 *fresh0 += 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong;
284 }
285 return exitflag;
286}
287#[no_mangle]
288pub unsafe extern "C" fn set_rho_vec(mut work: *mut OSQPWorkspace) {
289 let mut i: c_int = 0;
290 (*(*work).settings)
291 .rho = if (if (*(*work).settings).rho > 1e-06f64 {
292 (*(*work).settings).rho
293 } else {
294 1e-06f64
295 }) < 1e06f64
296 {
297 if (*(*work).settings).rho > 1e-06f64 {
298 (*(*work).settings).rho
299 } else {
300 1e-06f64
301 }
302 } else {
303 1e06f64
304 };
305 i = 0 as ::std::os::raw::c_int as c_int;
306 while i < (*(*work).data).m {
307 if *((*(*work).data).l).offset(i as isize) < -OSQP_INFTY * MIN_SCALING
308 && *((*(*work).data).u).offset(i as isize) > OSQP_INFTY * MIN_SCALING
309 {
310 *((*work).constr_type).offset(i as isize) = -(1 as ::std::os::raw::c_int) as c_int;
311 *((*work).rho_vec).offset(i as isize) = RHO_MIN;
312 } else if *((*(*work).data).u).offset(i as isize)
313 - *((*(*work).data).l).offset(i as isize) < RHO_TOL
314 {
315 *((*work).constr_type).offset(i as isize) = 1 as ::std::os::raw::c_int as c_int;
316 *((*work).rho_vec)
317 .offset(i as isize) = RHO_EQ_OVER_RHO_INEQ * (*(*work).settings).rho;
318 } else {
319 *((*work).constr_type).offset(i as isize) = 0 as ::std::os::raw::c_int as c_int;
320 *((*work).rho_vec).offset(i as isize) = (*(*work).settings).rho;
321 }
322 *((*work).rho_inv_vec)
323 .offset(i as isize) = 1.0f64 / *((*work).rho_vec).offset(i as isize);
324 i += 1;
325 }
326}
327#[no_mangle]
328pub unsafe extern "C" fn update_rho_vec(mut work: *mut OSQPWorkspace) -> c_int {
329 let mut i: c_int = 0;
330 let mut exitflag: c_int = 0;
331 let mut constr_type_changed: c_int = 0;
332 exitflag = 0 as ::std::os::raw::c_int as c_int;
333 constr_type_changed = 0 as ::std::os::raw::c_int as c_int;
334 i = 0 as ::std::os::raw::c_int as c_int;
335 while i < (*(*work).data).m {
336 if *((*(*work).data).l).offset(i as isize) < -OSQP_INFTY * MIN_SCALING
337 && *((*(*work).data).u).offset(i as isize) > OSQP_INFTY * MIN_SCALING
338 {
339 if *((*work).constr_type).offset(i as isize)
340 != -(1 as ::std::os::raw::c_int) as ::std::os::raw::c_longlong
341 {
342 *((*work).constr_type).offset(i as isize) = -(1 as ::std::os::raw::c_int) as c_int;
343 *((*work).rho_vec).offset(i as isize) = RHO_MIN;
344 *((*work).rho_inv_vec).offset(i as isize) = 1.0f64 / RHO_MIN;
345 constr_type_changed = 1 as ::std::os::raw::c_int as c_int;
346 }
347 } else if *((*(*work).data).u).offset(i as isize)
348 - *((*(*work).data).l).offset(i as isize) < RHO_TOL
349 {
350 if *((*work).constr_type).offset(i as isize)
351 != 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
352 {
353 *((*work).constr_type).offset(i as isize) = 1 as ::std::os::raw::c_int as c_int;
354 *((*work).rho_vec)
355 .offset(i as isize) = RHO_EQ_OVER_RHO_INEQ * (*(*work).settings).rho;
356 *((*work).rho_inv_vec)
357 .offset(i as isize) = 1.0f64 / *((*work).rho_vec).offset(i as isize);
358 constr_type_changed = 1 as ::std::os::raw::c_int as c_int;
359 }
360 } else if *((*work).constr_type).offset(i as isize)
361 != 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
362 {
363 *((*work).constr_type).offset(i as isize) = 0 as ::std::os::raw::c_int as c_int;
364 *((*work).rho_vec).offset(i as isize) = (*(*work).settings).rho;
365 *((*work).rho_inv_vec).offset(i as isize) = 1.0f64 / (*(*work).settings).rho;
366 constr_type_changed = 1 as ::std::os::raw::c_int as c_int;
367 }
368 i += 1;
369 }
370 if constr_type_changed == 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
371 exitflag = ((*(*work).linsys_solver).update_rho_vec)
372 .expect("non-null function pointer")((*work).linsys_solver, (*work).rho_vec);
373 }
374 return exitflag;
375}
376#[no_mangle]
377pub unsafe extern "C" fn swap_vectors(
378 mut a: *mut *mut c_float,
379 mut b: *mut *mut c_float,
380) {
381 let mut temp: *mut c_float = 0 as *mut c_float;
382 temp = *b;
383 *b = *a;
384 *a = temp;
385}
386#[no_mangle]
387pub unsafe extern "C" fn cold_start(mut work: *mut OSQPWorkspace) {
388 vec_set_scalar((*work).x, 0.0f64, (*(*work).data).n);
389 vec_set_scalar((*work).z, 0.0f64, (*(*work).data).m);
390 vec_set_scalar((*work).y, 0.0f64, (*(*work).data).m);
391}
392unsafe extern "C" fn compute_rhs(mut work: *mut OSQPWorkspace) {
393 let mut i: c_int = 0;
394 i = 0 as ::std::os::raw::c_int as c_int;
395 while i < (*(*work).data).n {
396 *((*work).xz_tilde)
397 .offset(
398 i as isize,
399 ) = (*(*work).settings).sigma * *((*work).x_prev).offset(i as isize)
400 - *((*(*work).data).q).offset(i as isize);
401 i += 1;
402 }
403 i = 0 as ::std::os::raw::c_int as c_int;
404 while i < (*(*work).data).m {
405 *((*work).xz_tilde)
406 .offset(
407 (i + (*(*work).data).n) as isize,
408 ) = *((*work).z_prev).offset(i as isize)
409 - *((*work).rho_inv_vec).offset(i as isize)
410 * *((*work).y).offset(i as isize);
411 i += 1;
412 }
413}
414#[no_mangle]
415pub unsafe extern "C" fn update_xz_tilde(mut work: *mut OSQPWorkspace) {
416 compute_rhs(work);
417 ((*(*work).linsys_solver).solve)
418 .expect("non-null function pointer")((*work).linsys_solver, (*work).xz_tilde);
419}
420#[no_mangle]
421pub unsafe extern "C" fn update_x(mut work: *mut OSQPWorkspace) {
422 let mut i: c_int = 0;
423 i = 0 as ::std::os::raw::c_int as c_int;
424 while i < (*(*work).data).n {
425 *((*work).x)
426 .offset(
427 i as isize,
428 ) = (*(*work).settings).alpha * *((*work).xz_tilde).offset(i as isize)
429 + (1.0f64 - (*(*work).settings).alpha)
430 * *((*work).x_prev).offset(i as isize);
431 i += 1;
432 }
433 i = 0 as ::std::os::raw::c_int as c_int;
434 while i < (*(*work).data).n {
435 *((*work).delta_x)
436 .offset(
437 i as isize,
438 ) = *((*work).x).offset(i as isize) - *((*work).x_prev).offset(i as isize);
439 i += 1;
440 }
441}
442#[no_mangle]
443pub unsafe extern "C" fn update_z(mut work: *mut OSQPWorkspace) {
444 let mut i: c_int = 0;
445 i = 0 as ::std::os::raw::c_int as c_int;
446 while i < (*(*work).data).m {
447 *((*work).z)
448 .offset(
449 i as isize,
450 ) = (*(*work).settings).alpha
451 * *((*work).xz_tilde).offset((i + (*(*work).data).n) as isize)
452 + (1.0f64 - (*(*work).settings).alpha) * *((*work).z_prev).offset(i as isize)
453 + *((*work).rho_inv_vec).offset(i as isize)
454 * *((*work).y).offset(i as isize);
455 i += 1;
456 }
457 project(work, (*work).z);
458}
459#[no_mangle]
460pub unsafe extern "C" fn update_y(mut work: *mut OSQPWorkspace) {
461 let mut i: c_int = 0;
462 i = 0 as ::std::os::raw::c_int as c_int;
463 while i < (*(*work).data).m {
464 *((*work).delta_y)
465 .offset(
466 i as isize,
467 ) = *((*work).rho_vec).offset(i as isize)
468 * ((*(*work).settings).alpha
469 * *((*work).xz_tilde).offset((i + (*(*work).data).n) as isize)
470 + (1.0f64 - (*(*work).settings).alpha)
471 * *((*work).z_prev).offset(i as isize)
472 - *((*work).z).offset(i as isize));
473 let ref mut fresh1 = *((*work).y).offset(i as isize);
474 *fresh1 += *((*work).delta_y).offset(i as isize);
475 i += 1;
476 }
477}
478#[no_mangle]
479pub unsafe extern "C" fn compute_obj_val(
480 mut work: *mut OSQPWorkspace,
481 mut x: *mut c_float,
482) -> c_float {
483 let mut obj_val: c_float = 0.;
484 obj_val = quad_form((*(*work).data).P, x)
485 + vec_prod((*(*work).data).q, x, (*(*work).data).n);
486 if (*(*work).settings).scaling != 0 {
487 obj_val *= (*(*work).scaling).cinv;
488 }
489 return obj_val;
490}
491#[no_mangle]
492pub unsafe extern "C" fn compute_pri_res(
493 mut work: *mut OSQPWorkspace,
494 mut x: *mut c_float,
495 mut z: *mut c_float,
496) -> c_float {
497 mat_vec((*(*work).data).A, x, (*work).Ax, 0 as ::std::os::raw::c_int as c_int);
498 vec_add_scaled(
499 (*work).z_prev,
500 (*work).Ax,
501 z,
502 (*(*work).data).m,
503 -(1 as ::std::os::raw::c_int) as c_float,
504 );
505 if (*(*work).settings).scaling != 0 && (*(*work).settings).scaled_termination == 0 {
506 return vec_scaled_norm_inf(
507 (*(*work).scaling).Einv,
508 (*work).z_prev,
509 (*(*work).data).m,
510 );
511 }
512 return vec_norm_inf((*work).z_prev, (*(*work).data).m);
513}
514#[no_mangle]
515pub unsafe extern "C" fn compute_pri_tol(
516 mut work: *mut OSQPWorkspace,
517 mut eps_abs: c_float,
518 mut eps_rel: c_float,
519) -> c_float {
520 let mut max_rel_eps: c_float = 0.;
521 let mut temp_rel_eps: c_float = 0.;
522 if (*(*work).settings).scaling != 0 && (*(*work).settings).scaled_termination == 0 {
523 max_rel_eps = vec_scaled_norm_inf(
524 (*(*work).scaling).Einv,
525 (*work).z,
526 (*(*work).data).m,
527 );
528 temp_rel_eps = vec_scaled_norm_inf(
529 (*(*work).scaling).Einv,
530 (*work).Ax,
531 (*(*work).data).m,
532 );
533 max_rel_eps = if max_rel_eps > temp_rel_eps {
534 max_rel_eps
535 } else {
536 temp_rel_eps
537 };
538 } else {
539 max_rel_eps = vec_norm_inf((*work).z, (*(*work).data).m);
540 temp_rel_eps = vec_norm_inf((*work).Ax, (*(*work).data).m);
541 max_rel_eps = if max_rel_eps > temp_rel_eps {
542 max_rel_eps
543 } else {
544 temp_rel_eps
545 };
546 }
547 return eps_abs + eps_rel * max_rel_eps;
548}
549#[no_mangle]
550pub unsafe extern "C" fn compute_dua_res(
551 mut work: *mut OSQPWorkspace,
552 mut x: *mut c_float,
553 mut y: *mut c_float,
554) -> c_float {
555 prea_vec_copy((*(*work).data).q, (*work).x_prev, (*(*work).data).n);
556 mat_vec((*(*work).data).P, x, (*work).Px, 0 as ::std::os::raw::c_int as c_int);
557 mat_tpose_vec(
558 (*(*work).data).P,
559 x,
560 (*work).Px,
561 1 as ::std::os::raw::c_int as c_int,
562 1 as ::std::os::raw::c_int as c_int,
563 );
564 vec_add_scaled(
565 (*work).x_prev,
566 (*work).x_prev,
567 (*work).Px,
568 (*(*work).data).n,
569 1 as ::std::os::raw::c_int as c_float,
570 );
571 if (*(*work).data).m > 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
572 mat_tpose_vec(
573 (*(*work).data).A,
574 y,
575 (*work).Aty,
576 0 as ::std::os::raw::c_int as c_int,
577 0 as ::std::os::raw::c_int as c_int,
578 );
579 vec_add_scaled(
580 (*work).x_prev,
581 (*work).x_prev,
582 (*work).Aty,
583 (*(*work).data).n,
584 1 as ::std::os::raw::c_int as c_float,
585 );
586 }
587 if (*(*work).settings).scaling != 0 && (*(*work).settings).scaled_termination == 0 {
588 return (*(*work).scaling).cinv
589 * vec_scaled_norm_inf(
590 (*(*work).scaling).Dinv,
591 (*work).x_prev,
592 (*(*work).data).n,
593 );
594 }
595 return vec_norm_inf((*work).x_prev, (*(*work).data).n);
596}
597#[no_mangle]
598pub unsafe extern "C" fn compute_dua_tol(
599 mut work: *mut OSQPWorkspace,
600 mut eps_abs: c_float,
601 mut eps_rel: c_float,
602) -> c_float {
603 let mut max_rel_eps: c_float = 0.;
604 let mut temp_rel_eps: c_float = 0.;
605 if (*(*work).settings).scaling != 0 && (*(*work).settings).scaled_termination == 0 {
606 max_rel_eps = vec_scaled_norm_inf(
607 (*(*work).scaling).Dinv,
608 (*(*work).data).q,
609 (*(*work).data).n,
610 );
611 temp_rel_eps = vec_scaled_norm_inf(
612 (*(*work).scaling).Dinv,
613 (*work).Aty,
614 (*(*work).data).n,
615 );
616 max_rel_eps = if max_rel_eps > temp_rel_eps {
617 max_rel_eps
618 } else {
619 temp_rel_eps
620 };
621 temp_rel_eps = vec_scaled_norm_inf(
622 (*(*work).scaling).Dinv,
623 (*work).Px,
624 (*(*work).data).n,
625 );
626 max_rel_eps = if max_rel_eps > temp_rel_eps {
627 max_rel_eps
628 } else {
629 temp_rel_eps
630 };
631 max_rel_eps *= (*(*work).scaling).cinv;
632 } else {
633 max_rel_eps = vec_norm_inf((*(*work).data).q, (*(*work).data).n);
634 temp_rel_eps = vec_norm_inf((*work).Aty, (*(*work).data).n);
635 max_rel_eps = if max_rel_eps > temp_rel_eps {
636 max_rel_eps
637 } else {
638 temp_rel_eps
639 };
640 temp_rel_eps = vec_norm_inf((*work).Px, (*(*work).data).n);
641 max_rel_eps = if max_rel_eps > temp_rel_eps {
642 max_rel_eps
643 } else {
644 temp_rel_eps
645 };
646 }
647 return eps_abs + eps_rel * max_rel_eps;
648}
649#[no_mangle]
650pub unsafe extern "C" fn is_primal_infeasible(
651 mut work: *mut OSQPWorkspace,
652 mut eps_prim_inf: c_float,
653) -> c_int {
654 let mut i: c_int = 0;
655 let mut norm_delta_y: c_float = 0.;
656 let mut ineq_lhs: c_float = 0.0f64;
657 i = 0 as ::std::os::raw::c_int as c_int;
658 while i < (*(*work).data).m {
659 if *((*(*work).data).u).offset(i as isize) > OSQP_INFTY * MIN_SCALING {
660 if *((*(*work).data).l).offset(i as isize) < -OSQP_INFTY * MIN_SCALING {
661 *((*work).delta_y).offset(i as isize) = 0.0f64;
662 } else {
663 *((*work).delta_y)
664 .offset(
665 i as isize,
666 ) = if *((*work).delta_y).offset(i as isize) < 0.0f64 {
667 *((*work).delta_y).offset(i as isize)
668 } else {
669 0.0f64
670 };
671 }
672 } else if *((*(*work).data).l).offset(i as isize) < -OSQP_INFTY * MIN_SCALING {
673 *((*work).delta_y)
674 .offset(
675 i as isize,
676 ) = if *((*work).delta_y).offset(i as isize) > 0.0f64 {
677 *((*work).delta_y).offset(i as isize)
678 } else {
679 0.0f64
680 };
681 }
682 i += 1;
683 }
684 if (*(*work).settings).scaling != 0 && (*(*work).settings).scaled_termination == 0 {
685 vec_ew_prod(
686 (*(*work).scaling).E,
687 (*work).delta_y,
688 (*work).Adelta_x,
689 (*(*work).data).m,
690 );
691 norm_delta_y = vec_norm_inf((*work).Adelta_x, (*(*work).data).m);
692 } else {
693 norm_delta_y = vec_norm_inf((*work).delta_y, (*(*work).data).m);
694 }
695 if norm_delta_y > OSQP_DIVISION_TOL {
696 i = 0 as ::std::os::raw::c_int as c_int;
697 while i < (*(*work).data).m {
698 ineq_lhs
699 += *((*(*work).data).u).offset(i as isize)
700 * (if *((*work).delta_y).offset(i as isize)
701 > 0 as ::std::os::raw::c_int as ::std::os::raw::c_double
702 {
703 *((*work).delta_y).offset(i as isize)
704 } else {
705 0 as ::std::os::raw::c_int as ::std::os::raw::c_double
706 })
707 + *((*(*work).data).l).offset(i as isize)
708 * (if *((*work).delta_y).offset(i as isize)
709 < 0 as ::std::os::raw::c_int as ::std::os::raw::c_double
710 {
711 *((*work).delta_y).offset(i as isize)
712 } else {
713 0 as ::std::os::raw::c_int as ::std::os::raw::c_double
714 });
715 i += 1;
716 }
717 if ineq_lhs < eps_prim_inf * norm_delta_y {
718 mat_tpose_vec(
719 (*(*work).data).A,
720 (*work).delta_y,
721 (*work).Atdelta_y,
722 0 as ::std::os::raw::c_int as c_int,
723 0 as ::std::os::raw::c_int as c_int,
724 );
725 if (*(*work).settings).scaling != 0
726 && (*(*work).settings).scaled_termination == 0
727 {
728 vec_ew_prod(
729 (*(*work).scaling).Dinv,
730 (*work).Atdelta_y,
731 (*work).Atdelta_y,
732 (*(*work).data).n,
733 );
734 }
735 return (vec_norm_inf((*work).Atdelta_y, (*(*work).data).n)
736 < eps_prim_inf * norm_delta_y) as ::std::os::raw::c_int as c_int;
737 }
738 }
739 return 0 as ::std::os::raw::c_int as c_int;
740}
741#[no_mangle]
742pub unsafe extern "C" fn is_dual_infeasible(
743 mut work: *mut OSQPWorkspace,
744 mut eps_dual_inf: c_float,
745) -> c_int {
746 let mut i: c_int = 0;
747 let mut norm_delta_x: c_float = 0.;
748 let mut cost_scaling: c_float = 0.;
749 if (*(*work).settings).scaling != 0 && (*(*work).settings).scaled_termination == 0 {
750 norm_delta_x = vec_scaled_norm_inf(
751 (*(*work).scaling).D,
752 (*work).delta_x,
753 (*(*work).data).n,
754 );
755 cost_scaling = (*(*work).scaling).c;
756 } else {
757 norm_delta_x = vec_norm_inf((*work).delta_x, (*(*work).data).n);
758 cost_scaling = 1.0f64;
759 }
760 if norm_delta_x > OSQP_DIVISION_TOL {
761 if vec_prod((*(*work).data).q, (*work).delta_x, (*(*work).data).n)
762 < cost_scaling * eps_dual_inf * norm_delta_x
763 {
764 mat_vec(
765 (*(*work).data).P,
766 (*work).delta_x,
767 (*work).Pdelta_x,
768 0 as ::std::os::raw::c_int as c_int,
769 );
770 mat_tpose_vec(
771 (*(*work).data).P,
772 (*work).delta_x,
773 (*work).Pdelta_x,
774 1 as ::std::os::raw::c_int as c_int,
775 1 as ::std::os::raw::c_int as c_int,
776 );
777 if (*(*work).settings).scaling != 0
778 && (*(*work).settings).scaled_termination == 0
779 {
780 vec_ew_prod(
781 (*(*work).scaling).Dinv,
782 (*work).Pdelta_x,
783 (*work).Pdelta_x,
784 (*(*work).data).n,
785 );
786 }
787 if vec_norm_inf((*work).Pdelta_x, (*(*work).data).n)
788 < cost_scaling * eps_dual_inf * norm_delta_x
789 {
790 mat_vec(
791 (*(*work).data).A,
792 (*work).delta_x,
793 (*work).Adelta_x,
794 0 as ::std::os::raw::c_int as c_int,
795 );
796 if (*(*work).settings).scaling != 0
797 && (*(*work).settings).scaled_termination == 0
798 {
799 vec_ew_prod(
800 (*(*work).scaling).Einv,
801 (*work).Adelta_x,
802 (*work).Adelta_x,
803 (*(*work).data).m,
804 );
805 }
806 i = 0 as ::std::os::raw::c_int as c_int;
807 while i < (*(*work).data).m {
808 if *((*(*work).data).u).offset(i as isize) < OSQP_INFTY * MIN_SCALING
809 && *((*work).Adelta_x).offset(i as isize)
810 > eps_dual_inf * norm_delta_x
811 || *((*(*work).data).l).offset(i as isize)
812 > -OSQP_INFTY * MIN_SCALING
813 && *((*work).Adelta_x).offset(i as isize)
814 < -eps_dual_inf * norm_delta_x
815 {
816 return 0 as ::std::os::raw::c_int as c_int;
817 }
818 i += 1;
819 }
820 return 1 as ::std::os::raw::c_int as c_int;
821 }
822 }
823 }
824 return 0 as ::std::os::raw::c_int as c_int;
825}
826#[no_mangle]
827pub unsafe extern "C" fn has_solution(mut info: *mut OSQPInfo) -> c_int {
828 return ((*info).status_val != OSQP_PRIMAL_INFEASIBLE as ::std::os::raw::c_longlong
829 && (*info).status_val != OSQP_PRIMAL_INFEASIBLE_INACCURATE as ::std::os::raw::c_longlong
830 && (*info).status_val != OSQP_DUAL_INFEASIBLE as ::std::os::raw::c_longlong
831 && (*info).status_val != OSQP_DUAL_INFEASIBLE_INACCURATE as ::std::os::raw::c_longlong
832 && (*info).status_val != OSQP_NON_CVX as ::std::os::raw::c_longlong) as ::std::os::raw::c_int
833 as c_int;
834}
835#[no_mangle]
836pub unsafe extern "C" fn store_solution(mut work: *mut OSQPWorkspace) {
837 let mut norm_vec: c_float = 0.;
838 if has_solution((*work).info) != 0 {
839 prea_vec_copy((*work).x, (*(*work).solution).x, (*(*work).data).n);
840 prea_vec_copy((*work).y, (*(*work).solution).y, (*(*work).data).m);
841 if (*(*work).settings).scaling != 0 {
842 unscale_solution(work);
843 }
844 } else {
845 vec_set_scalar((*(*work).solution).x, OSQP_NAN as c_float, (*(*work).data).n);
846 vec_set_scalar((*(*work).solution).y, OSQP_NAN as c_float, (*(*work).data).m);
847 if (*(*work).info).status_val == OSQP_PRIMAL_INFEASIBLE as ::std::os::raw::c_longlong
848 || (*(*work).info).status_val
849 == OSQP_PRIMAL_INFEASIBLE_INACCURATE as ::std::os::raw::c_longlong
850 {
851 norm_vec = vec_norm_inf((*work).delta_y, (*(*work).data).m);
852 vec_mult_scalar((*work).delta_y, 1.0f64 / norm_vec, (*(*work).data).m);
853 }
854 if (*(*work).info).status_val == OSQP_DUAL_INFEASIBLE as ::std::os::raw::c_longlong
855 || (*(*work).info).status_val
856 == OSQP_DUAL_INFEASIBLE_INACCURATE as ::std::os::raw::c_longlong
857 {
858 norm_vec = vec_norm_inf((*work).delta_x, (*(*work).data).n);
859 vec_mult_scalar((*work).delta_x, 1.0f64 / norm_vec, (*(*work).data).n);
860 }
861 cold_start(work);
862 };
863}
864#[no_mangle]
865pub unsafe extern "C" fn update_info(
866 mut work: *mut OSQPWorkspace,
867 mut iter: c_int,
868 mut compute_objective: c_int,
869 mut polish: c_int,
870) {
871 let mut x: *mut c_float = 0 as *mut c_float;
872 let mut z: *mut c_float = 0 as *mut c_float;
873 let mut y: *mut c_float = 0 as *mut c_float;
874 let mut obj_val: *mut c_float = 0 as *mut c_float;
875 let mut pri_res: *mut c_float = 0 as *mut c_float;
876 let mut dua_res: *mut c_float = 0 as *mut c_float;
877 let mut run_time: *mut c_float = 0 as *mut c_float;
878 if polish != 0 {
879 x = (*(*work).pol).x;
880 y = (*(*work).pol).y;
881 z = (*(*work).pol).z;
882 obj_val = &mut (*(*work).pol).obj_val;
883 pri_res = &mut (*(*work).pol).pri_res;
884 dua_res = &mut (*(*work).pol).dua_res;
885 run_time = &mut (*(*work).info).polish_time;
886 } else {
887 x = (*work).x;
888 y = (*work).y;
889 z = (*work).z;
890 obj_val = &mut (*(*work).info).obj_val;
891 pri_res = &mut (*(*work).info).pri_res;
892 dua_res = &mut (*(*work).info).dua_res;
893 (*(*work).info).iter = iter;
894 run_time = &mut (*(*work).info).solve_time;
895 }
896 if compute_objective != 0 {
897 *obj_val = compute_obj_val(work, x);
898 }
899 if (*(*work).data).m == 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
900 *pri_res = 0.0f64;
901 } else {
902 *pri_res = compute_pri_res(work, x, z);
903 }
904 *dua_res = compute_dua_res(work, x, y);
905 *run_time = osqp_toc((*work).timer);
906 (*work).summary_printed = 0 as ::std::os::raw::c_int as c_int;
907}
908#[no_mangle]
909pub unsafe extern "C" fn reset_info(mut info: *mut OSQPInfo) {
910 (*info).solve_time = 0.0f64;
911 (*info).polish_time = 0.0f64;
912 update_status(info, OSQP_UNSOLVED as c_int);
913 (*info).rho_updates = 0 as ::std::os::raw::c_int as c_int;
914}
915#[no_mangle]
916pub unsafe extern "C" fn update_status(mut info: *mut OSQPInfo, mut status_val: c_int) {
917 (*info).status_val = status_val;
918 if status_val == OSQP_SOLVED as ::std::os::raw::c_longlong {
919 c_strcpy(
920 ((*info).status).as_mut_ptr(),
921 b"solved\0" as *const u8 as *const ::std::os::raw::c_char,
922 );
923 }
924 if status_val == OSQP_SOLVED_INACCURATE as ::std::os::raw::c_longlong {
925 c_strcpy(
926 ((*info).status).as_mut_ptr(),
927 b"solved inaccurate\0" as *const u8 as *const ::std::os::raw::c_char,
928 );
929 } else if status_val == OSQP_PRIMAL_INFEASIBLE as ::std::os::raw::c_longlong {
930 c_strcpy(
931 ((*info).status).as_mut_ptr(),
932 b"primal infeasible\0" as *const u8 as *const ::std::os::raw::c_char,
933 );
934 } else if status_val == OSQP_PRIMAL_INFEASIBLE_INACCURATE as ::std::os::raw::c_longlong {
935 c_strcpy(
936 ((*info).status).as_mut_ptr(),
937 b"primal infeasible inaccurate\0" as *const u8 as *const ::std::os::raw::c_char,
938 );
939 } else if status_val == OSQP_UNSOLVED as ::std::os::raw::c_longlong {
940 c_strcpy(
941 ((*info).status).as_mut_ptr(),
942 b"unsolved\0" as *const u8 as *const ::std::os::raw::c_char,
943 );
944 } else if status_val == OSQP_DUAL_INFEASIBLE as ::std::os::raw::c_longlong {
945 c_strcpy(
946 ((*info).status).as_mut_ptr(),
947 b"dual infeasible\0" as *const u8 as *const ::std::os::raw::c_char,
948 );
949 } else if status_val == OSQP_DUAL_INFEASIBLE_INACCURATE as ::std::os::raw::c_longlong {
950 c_strcpy(
951 ((*info).status).as_mut_ptr(),
952 b"dual infeasible inaccurate\0" as *const u8 as *const ::std::os::raw::c_char,
953 );
954 } else if status_val == OSQP_MAX_ITER_REACHED as ::std::os::raw::c_longlong {
955 c_strcpy(
956 ((*info).status).as_mut_ptr(),
957 b"maximum iterations reached\0" as *const u8 as *const ::std::os::raw::c_char,
958 );
959 } else if status_val == OSQP_TIME_LIMIT_REACHED as ::std::os::raw::c_longlong {
960 c_strcpy(
961 ((*info).status).as_mut_ptr(),
962 b"run time limit reached\0" as *const u8 as *const ::std::os::raw::c_char,
963 );
964 } else if status_val == OSQP_SIGINT as ::std::os::raw::c_longlong {
965 c_strcpy(
966 ((*info).status).as_mut_ptr(),
967 b"interrupted\0" as *const u8 as *const ::std::os::raw::c_char,
968 );
969 } else if status_val == OSQP_NON_CVX as ::std::os::raw::c_longlong {
970 c_strcpy(
971 ((*info).status).as_mut_ptr(),
972 b"problem non convex\0" as *const u8 as *const ::std::os::raw::c_char,
973 );
974 }
975}
976#[no_mangle]
977pub unsafe extern "C" fn check_termination(
978 mut work: *mut OSQPWorkspace,
979 mut approximate: c_int,
980) -> c_int {
981 let mut eps_prim: c_float = 0.;
982 let mut eps_dual: c_float = 0.;
983 let mut eps_prim_inf: c_float = 0.;
984 let mut eps_dual_inf: c_float = 0.;
985 let mut exitflag: c_int = 0;
986 let mut prim_res_check: c_int = 0;
987 let mut dual_res_check: c_int = 0;
988 let mut prim_inf_check: c_int = 0;
989 let mut dual_inf_check: c_int = 0;
990 let mut eps_abs: c_float = 0.;
991 let mut eps_rel: c_float = 0.;
992 exitflag = 0 as ::std::os::raw::c_int as c_int;
993 prim_res_check = 0 as ::std::os::raw::c_int as c_int;
994 dual_res_check = 0 as ::std::os::raw::c_int as c_int;
995 prim_inf_check = 0 as ::std::os::raw::c_int as c_int;
996 dual_inf_check = 0 as ::std::os::raw::c_int as c_int;
997 eps_abs = (*(*work).settings).eps_abs;
998 eps_rel = (*(*work).settings).eps_rel;
999 eps_prim_inf = (*(*work).settings).eps_prim_inf;
1000 eps_dual_inf = (*(*work).settings).eps_dual_inf;
1001 if (*(*work).info).pri_res > OSQP_INFTY || (*(*work).info).dua_res > OSQP_INFTY {
1002 update_status((*work).info, OSQP_NON_CVX as c_int);
1003 (*(*work).info).obj_val = OSQP_NAN as c_float;
1004 return 1 as ::std::os::raw::c_int as c_int;
1005 }
1006 if approximate != 0 {
1007 eps_abs *= 10 as ::std::os::raw::c_int as ::std::os::raw::c_double;
1008 eps_rel *= 10 as ::std::os::raw::c_int as ::std::os::raw::c_double;
1009 eps_prim_inf *= 10 as ::std::os::raw::c_int as ::std::os::raw::c_double;
1010 eps_dual_inf *= 10 as ::std::os::raw::c_int as ::std::os::raw::c_double;
1011 }
1012 if (*(*work).data).m == 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1013 prim_res_check = 1 as ::std::os::raw::c_int as c_int;
1014 } else {
1015 eps_prim = compute_pri_tol(work, eps_abs, eps_rel);
1016 if (*(*work).info).pri_res < eps_prim {
1017 prim_res_check = 1 as ::std::os::raw::c_int as c_int;
1018 } else {
1019 prim_inf_check = is_primal_infeasible(work, eps_prim_inf);
1020 }
1021 }
1022 eps_dual = compute_dua_tol(work, eps_abs, eps_rel);
1023 if (*(*work).info).dua_res < eps_dual {
1024 dual_res_check = 1 as ::std::os::raw::c_int as c_int;
1025 } else {
1026 dual_inf_check = is_dual_infeasible(work, eps_dual_inf);
1027 }
1028 if prim_res_check != 0 && dual_res_check != 0 {
1029 if approximate != 0 {
1030 update_status((*work).info, OSQP_SOLVED_INACCURATE as c_int);
1031 } else {
1032 update_status((*work).info, OSQP_SOLVED as c_int);
1033 }
1034 exitflag = 1 as ::std::os::raw::c_int as c_int;
1035 } else if prim_inf_check != 0 {
1036 if approximate != 0 {
1037 update_status((*work).info, OSQP_PRIMAL_INFEASIBLE_INACCURATE as c_int);
1038 } else {
1039 update_status((*work).info, OSQP_PRIMAL_INFEASIBLE as c_int);
1040 }
1041 if (*(*work).settings).scaling != 0
1042 && (*(*work).settings).scaled_termination == 0
1043 {
1044 vec_ew_prod(
1045 (*(*work).scaling).E,
1046 (*work).delta_y,
1047 (*work).delta_y,
1048 (*(*work).data).m,
1049 );
1050 }
1051 (*(*work).info).obj_val = OSQP_INFTY;
1052 exitflag = 1 as ::std::os::raw::c_int as c_int;
1053 } else if dual_inf_check != 0 {
1054 if approximate != 0 {
1055 update_status((*work).info, OSQP_DUAL_INFEASIBLE_INACCURATE as c_int);
1056 } else {
1057 update_status((*work).info, OSQP_DUAL_INFEASIBLE as c_int);
1058 }
1059 if (*(*work).settings).scaling != 0
1060 && (*(*work).settings).scaled_termination == 0
1061 {
1062 vec_ew_prod(
1063 (*(*work).scaling).D,
1064 (*work).delta_x,
1065 (*work).delta_x,
1066 (*(*work).data).n,
1067 );
1068 }
1069 (*(*work).info).obj_val = -OSQP_INFTY;
1070 exitflag = 1 as ::std::os::raw::c_int as c_int;
1071 }
1072 return exitflag;
1073}
1074#[no_mangle]
1075pub unsafe extern "C" fn validate_data(mut data: *const OSQPData) -> c_int {
1076 let mut j: c_int = 0;
1077 let mut ptr: c_int = 0;
1078 if data.is_null() {
1079 printf(
1080 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1081 (*::std::mem::transmute::<
1082 &[u8; 14],
1083 &[::std::os::raw::c_char; 14],
1084 >(b"validate_data\0"))
1085 .as_ptr(),
1086 );
1087 printf(b"Missing data\0" as *const u8 as *const ::std::os::raw::c_char);
1088 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1089 return 1 as ::std::os::raw::c_int as c_int;
1090 }
1091 if ((*data).P).is_null() {
1092 printf(
1093 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1094 (*::std::mem::transmute::<
1095 &[u8; 14],
1096 &[::std::os::raw::c_char; 14],
1097 >(b"validate_data\0"))
1098 .as_ptr(),
1099 );
1100 printf(b"Missing matrix P\0" as *const u8 as *const ::std::os::raw::c_char);
1101 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1102 return 1 as ::std::os::raw::c_int as c_int;
1103 }
1104 if ((*data).A).is_null() {
1105 printf(
1106 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1107 (*::std::mem::transmute::<
1108 &[u8; 14],
1109 &[::std::os::raw::c_char; 14],
1110 >(b"validate_data\0"))
1111 .as_ptr(),
1112 );
1113 printf(b"Missing matrix A\0" as *const u8 as *const ::std::os::raw::c_char);
1114 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1115 return 1 as ::std::os::raw::c_int as c_int;
1116 }
1117 if ((*data).q).is_null() {
1118 printf(
1119 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1120 (*::std::mem::transmute::<
1121 &[u8; 14],
1122 &[::std::os::raw::c_char; 14],
1123 >(b"validate_data\0"))
1124 .as_ptr(),
1125 );
1126 printf(b"Missing vector q\0" as *const u8 as *const ::std::os::raw::c_char);
1127 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1128 return 1 as ::std::os::raw::c_int as c_int;
1129 }
1130 if (*data).n <= 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
1131 || (*data).m < 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
1132 {
1133 printf(
1134 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1135 (*::std::mem::transmute::<
1136 &[u8; 14],
1137 &[::std::os::raw::c_char; 14],
1138 >(b"validate_data\0"))
1139 .as_ptr(),
1140 );
1141 printf(
1142 b"n must be positive and m nonnegative; n = %i, m = %i\0" as *const u8
1143 as *const ::std::os::raw::c_char,
1144 (*data).n as ::std::os::raw::c_int,
1145 (*data).m as ::std::os::raw::c_int,
1146 );
1147 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1148 return 1 as ::std::os::raw::c_int as c_int;
1149 }
1150 if (*(*data).P).m != (*data).n {
1151 printf(
1152 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1153 (*::std::mem::transmute::<
1154 &[u8; 14],
1155 &[::std::os::raw::c_char; 14],
1156 >(b"validate_data\0"))
1157 .as_ptr(),
1158 );
1159 printf(
1160 b"P does not have dimension n x n with n = %i\0" as *const u8
1161 as *const ::std::os::raw::c_char,
1162 (*data).n as ::std::os::raw::c_int,
1163 );
1164 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1165 return 1 as ::std::os::raw::c_int as c_int;
1166 }
1167 if (*(*data).P).m != (*(*data).P).n {
1168 printf(
1169 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1170 (*::std::mem::transmute::<
1171 &[u8; 14],
1172 &[::std::os::raw::c_char; 14],
1173 >(b"validate_data\0"))
1174 .as_ptr(),
1175 );
1176 printf(b"P is not square\0" as *const u8 as *const ::std::os::raw::c_char);
1177 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1178 return 1 as ::std::os::raw::c_int as c_int;
1179 }
1180 j = 0 as ::std::os::raw::c_int as c_int;
1181 while j < (*data).n {
1182 ptr = *((*(*data).P).p).offset(j as isize);
1183 while ptr
1184 < *((*(*data).P).p)
1185 .offset((j + 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong) as isize)
1186 {
1187 if *((*(*data).P).i).offset(ptr as isize) > j {
1188 printf(
1189 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1190 (*::std::mem::transmute::<
1191 &[u8; 14],
1192 &[::std::os::raw::c_char; 14],
1193 >(b"validate_data\0"))
1194 .as_ptr(),
1195 );
1196 printf(
1197 b"P is not upper triangular\0" as *const u8 as *const ::std::os::raw::c_char,
1198 );
1199 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1200 return 1 as ::std::os::raw::c_int as c_int;
1201 }
1202 ptr += 1;
1203 }
1204 j += 1;
1205 }
1206 if (*(*data).A).m != (*data).m || (*(*data).A).n != (*data).n {
1207 printf(
1208 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1209 (*::std::mem::transmute::<
1210 &[u8; 14],
1211 &[::std::os::raw::c_char; 14],
1212 >(b"validate_data\0"))
1213 .as_ptr(),
1214 );
1215 printf(
1216 b"A does not have dimension %i x %i\0" as *const u8 as *const ::std::os::raw::c_char,
1217 (*data).m as ::std::os::raw::c_int,
1218 (*data).n as ::std::os::raw::c_int,
1219 );
1220 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1221 return 1 as ::std::os::raw::c_int as c_int;
1222 }
1223 j = 0 as ::std::os::raw::c_int as c_int;
1224 while j < (*data).m {
1225 if *((*data).l).offset(j as isize) > *((*data).u).offset(j as isize) {
1226 printf(
1227 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1228 (*::std::mem::transmute::<
1229 &[u8; 14],
1230 &[::std::os::raw::c_char; 14],
1231 >(b"validate_data\0"))
1232 .as_ptr(),
1233 );
1234 printf(
1235 b"Lower bound at index %d is greater than upper bound: %.4e > %.4e\0"
1236 as *const u8 as *const ::std::os::raw::c_char,
1237 j as ::std::os::raw::c_int,
1238 *((*data).l).offset(j as isize),
1239 *((*data).u).offset(j as isize),
1240 );
1241 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1242 return 1 as ::std::os::raw::c_int as c_int;
1243 }
1244 j += 1;
1245 }
1246 return 0 as ::std::os::raw::c_int as c_int;
1247}
1248#[no_mangle]
1249pub unsafe extern "C" fn validate_linsys_solver(mut linsys_solver: c_int) -> c_int {
1250 if linsys_solver != QDLDL_SOLVER as ::std::os::raw::c_int as ::std::os::raw::c_longlong
1251 && linsys_solver != MKL_PARDISO_SOLVER as ::std::os::raw::c_int as ::std::os::raw::c_longlong
1252 {
1253 return 1 as ::std::os::raw::c_int as c_int;
1254 }
1255 return 0 as ::std::os::raw::c_int as c_int;
1256}
1257#[no_mangle]
1258pub unsafe extern "C" fn validate_settings(mut settings: *const OSQPSettings) -> c_int {
1259 if settings.is_null() {
1260 printf(
1261 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1262 (*::std::mem::transmute::<
1263 &[u8; 18],
1264 &[::std::os::raw::c_char; 18],
1265 >(b"validate_settings\0"))
1266 .as_ptr(),
1267 );
1268 printf(b"Missing settings!\0" as *const u8 as *const ::std::os::raw::c_char);
1269 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1270 return 1 as ::std::os::raw::c_int as c_int;
1271 }
1272 if (*settings).scaling < 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1273 printf(
1274 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1275 (*::std::mem::transmute::<
1276 &[u8; 18],
1277 &[::std::os::raw::c_char; 18],
1278 >(b"validate_settings\0"))
1279 .as_ptr(),
1280 );
1281 printf(b"scaling must be nonnegative\0" as *const u8 as *const ::std::os::raw::c_char);
1282 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1283 return 1 as ::std::os::raw::c_int as c_int;
1284 }
1285 if (*settings).adaptive_rho != 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
1286 && (*settings).adaptive_rho != 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
1287 {
1288 printf(
1289 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1290 (*::std::mem::transmute::<
1291 &[u8; 18],
1292 &[::std::os::raw::c_char; 18],
1293 >(b"validate_settings\0"))
1294 .as_ptr(),
1295 );
1296 printf(
1297 b"adaptive_rho must be either 0 or 1\0" as *const u8 as *const ::std::os::raw::c_char,
1298 );
1299 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1300 return 1 as ::std::os::raw::c_int as c_int;
1301 }
1302 if (*settings).adaptive_rho_interval < 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1303 printf(
1304 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1305 (*::std::mem::transmute::<
1306 &[u8; 18],
1307 &[::std::os::raw::c_char; 18],
1308 >(b"validate_settings\0"))
1309 .as_ptr(),
1310 );
1311 printf(
1312 b"adaptive_rho_interval must be nonnegative\0" as *const u8
1313 as *const ::std::os::raw::c_char,
1314 );
1315 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1316 return 1 as ::std::os::raw::c_int as c_int;
1317 }
1318 if (*settings).adaptive_rho_fraction <= 0 as ::std::os::raw::c_int as ::std::os::raw::c_double {
1319 printf(
1320 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1321 (*::std::mem::transmute::<
1322 &[u8; 18],
1323 &[::std::os::raw::c_char; 18],
1324 >(b"validate_settings\0"))
1325 .as_ptr(),
1326 );
1327 printf(
1328 b"adaptive_rho_fraction must be positive\0" as *const u8
1329 as *const ::std::os::raw::c_char,
1330 );
1331 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1332 return 1 as ::std::os::raw::c_int as c_int;
1333 }
1334 if (*settings).adaptive_rho_tolerance < 1.0f64 {
1335 printf(
1336 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1337 (*::std::mem::transmute::<
1338 &[u8; 18],
1339 &[::std::os::raw::c_char; 18],
1340 >(b"validate_settings\0"))
1341 .as_ptr(),
1342 );
1343 printf(
1344 b"adaptive_rho_tolerance must be >= 1\0" as *const u8 as *const ::std::os::raw::c_char,
1345 );
1346 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1347 return 1 as ::std::os::raw::c_int as c_int;
1348 }
1349 if (*settings).polish_refine_iter < 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1350 printf(
1351 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1352 (*::std::mem::transmute::<
1353 &[u8; 18],
1354 &[::std::os::raw::c_char; 18],
1355 >(b"validate_settings\0"))
1356 .as_ptr(),
1357 );
1358 printf(
1359 b"polish_refine_iter must be nonnegative\0" as *const u8
1360 as *const ::std::os::raw::c_char,
1361 );
1362 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1363 return 1 as ::std::os::raw::c_int as c_int;
1364 }
1365 if (*settings).rho <= 0.0f64 {
1366 printf(
1367 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1368 (*::std::mem::transmute::<
1369 &[u8; 18],
1370 &[::std::os::raw::c_char; 18],
1371 >(b"validate_settings\0"))
1372 .as_ptr(),
1373 );
1374 printf(b"rho must be positive\0" as *const u8 as *const ::std::os::raw::c_char);
1375 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1376 return 1 as ::std::os::raw::c_int as c_int;
1377 }
1378 if (*settings).sigma <= 0.0f64 {
1379 printf(
1380 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1381 (*::std::mem::transmute::<
1382 &[u8; 18],
1383 &[::std::os::raw::c_char; 18],
1384 >(b"validate_settings\0"))
1385 .as_ptr(),
1386 );
1387 printf(b"sigma must be positive\0" as *const u8 as *const ::std::os::raw::c_char);
1388 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1389 return 1 as ::std::os::raw::c_int as c_int;
1390 }
1391 if (*settings).delta <= 0.0f64 {
1392 printf(
1393 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1394 (*::std::mem::transmute::<
1395 &[u8; 18],
1396 &[::std::os::raw::c_char; 18],
1397 >(b"validate_settings\0"))
1398 .as_ptr(),
1399 );
1400 printf(b"delta must be positive\0" as *const u8 as *const ::std::os::raw::c_char);
1401 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1402 return 1 as ::std::os::raw::c_int as c_int;
1403 }
1404 if (*settings).max_iter <= 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1405 printf(
1406 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1407 (*::std::mem::transmute::<
1408 &[u8; 18],
1409 &[::std::os::raw::c_char; 18],
1410 >(b"validate_settings\0"))
1411 .as_ptr(),
1412 );
1413 printf(b"max_iter must be positive\0" as *const u8 as *const ::std::os::raw::c_char);
1414 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1415 return 1 as ::std::os::raw::c_int as c_int;
1416 }
1417 if (*settings).eps_abs < 0.0f64 {
1418 printf(
1419 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1420 (*::std::mem::transmute::<
1421 &[u8; 18],
1422 &[::std::os::raw::c_char; 18],
1423 >(b"validate_settings\0"))
1424 .as_ptr(),
1425 );
1426 printf(b"eps_abs must be nonnegative\0" as *const u8 as *const ::std::os::raw::c_char);
1427 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1428 return 1 as ::std::os::raw::c_int as c_int;
1429 }
1430 if (*settings).eps_rel < 0.0f64 {
1431 printf(
1432 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1433 (*::std::mem::transmute::<
1434 &[u8; 18],
1435 &[::std::os::raw::c_char; 18],
1436 >(b"validate_settings\0"))
1437 .as_ptr(),
1438 );
1439 printf(b"eps_rel must be nonnegative\0" as *const u8 as *const ::std::os::raw::c_char);
1440 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1441 return 1 as ::std::os::raw::c_int as c_int;
1442 }
1443 if (*settings).eps_rel == 0.0f64 && (*settings).eps_abs == 0.0f64 {
1444 printf(
1445 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1446 (*::std::mem::transmute::<
1447 &[u8; 18],
1448 &[::std::os::raw::c_char; 18],
1449 >(b"validate_settings\0"))
1450 .as_ptr(),
1451 );
1452 printf(
1453 b"at least one of eps_abs and eps_rel must be positive\0" as *const u8
1454 as *const ::std::os::raw::c_char,
1455 );
1456 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1457 return 1 as ::std::os::raw::c_int as c_int;
1458 }
1459 if (*settings).eps_prim_inf <= 0.0f64 {
1460 printf(
1461 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1462 (*::std::mem::transmute::<
1463 &[u8; 18],
1464 &[::std::os::raw::c_char; 18],
1465 >(b"validate_settings\0"))
1466 .as_ptr(),
1467 );
1468 printf(b"eps_prim_inf must be positive\0" as *const u8 as *const ::std::os::raw::c_char);
1469 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1470 return 1 as ::std::os::raw::c_int as c_int;
1471 }
1472 if (*settings).eps_dual_inf <= 0.0f64 {
1473 printf(
1474 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1475 (*::std::mem::transmute::<
1476 &[u8; 18],
1477 &[::std::os::raw::c_char; 18],
1478 >(b"validate_settings\0"))
1479 .as_ptr(),
1480 );
1481 printf(b"eps_dual_inf must be positive\0" as *const u8 as *const ::std::os::raw::c_char);
1482 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1483 return 1 as ::std::os::raw::c_int as c_int;
1484 }
1485 if (*settings).alpha <= 0.0f64 || (*settings).alpha >= 2.0f64 {
1486 printf(
1487 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1488 (*::std::mem::transmute::<
1489 &[u8; 18],
1490 &[::std::os::raw::c_char; 18],
1491 >(b"validate_settings\0"))
1492 .as_ptr(),
1493 );
1494 printf(
1495 b"alpha must be strictly between 0 and 2\0" as *const u8
1496 as *const ::std::os::raw::c_char,
1497 );
1498 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1499 return 1 as ::std::os::raw::c_int as c_int;
1500 }
1501 if validate_linsys_solver((*settings).linsys_solver as c_int) != 0 {
1502 printf(
1503 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1504 (*::std::mem::transmute::<
1505 &[u8; 18],
1506 &[::std::os::raw::c_char; 18],
1507 >(b"validate_settings\0"))
1508 .as_ptr(),
1509 );
1510 printf(b"linsys_solver not recognized\0" as *const u8 as *const ::std::os::raw::c_char);
1511 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1512 return 1 as ::std::os::raw::c_int as c_int;
1513 }
1514 if (*settings).verbose != 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
1515 && (*settings).verbose != 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
1516 {
1517 printf(
1518 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1519 (*::std::mem::transmute::<
1520 &[u8; 18],
1521 &[::std::os::raw::c_char; 18],
1522 >(b"validate_settings\0"))
1523 .as_ptr(),
1524 );
1525 printf(b"verbose must be either 0 or 1\0" as *const u8 as *const ::std::os::raw::c_char);
1526 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1527 return 1 as ::std::os::raw::c_int as c_int;
1528 }
1529 if (*settings).scaled_termination != 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
1530 && (*settings).scaled_termination != 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
1531 {
1532 printf(
1533 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1534 (*::std::mem::transmute::<
1535 &[u8; 18],
1536 &[::std::os::raw::c_char; 18],
1537 >(b"validate_settings\0"))
1538 .as_ptr(),
1539 );
1540 printf(
1541 b"scaled_termination must be either 0 or 1\0" as *const u8
1542 as *const ::std::os::raw::c_char,
1543 );
1544 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1545 return 1 as ::std::os::raw::c_int as c_int;
1546 }
1547 if (*settings).check_termination < 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1548 printf(
1549 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1550 (*::std::mem::transmute::<
1551 &[u8; 18],
1552 &[::std::os::raw::c_char; 18],
1553 >(b"validate_settings\0"))
1554 .as_ptr(),
1555 );
1556 printf(
1557 b"check_termination must be nonnegative\0" as *const u8
1558 as *const ::std::os::raw::c_char,
1559 );
1560 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1561 return 1 as ::std::os::raw::c_int as c_int;
1562 }
1563 if (*settings).warm_start != 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
1564 && (*settings).warm_start != 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
1565 {
1566 printf(
1567 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1568 (*::std::mem::transmute::<
1569 &[u8; 18],
1570 &[::std::os::raw::c_char; 18],
1571 >(b"validate_settings\0"))
1572 .as_ptr(),
1573 );
1574 printf(
1575 b"warm_start must be either 0 or 1\0" as *const u8 as *const ::std::os::raw::c_char,
1576 );
1577 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1578 return 1 as ::std::os::raw::c_int as c_int;
1579 }
1580 if (*settings).time_limit < 0.0f64 {
1581 printf(
1582 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1583 (*::std::mem::transmute::<
1584 &[u8; 18],
1585 &[::std::os::raw::c_char; 18],
1586 >(b"validate_settings\0"))
1587 .as_ptr(),
1588 );
1589 printf(
1590 b"time_limit must be nonnegative\n\0" as *const u8 as *const ::std::os::raw::c_char,
1591 );
1592 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1593 return 1 as ::std::os::raw::c_int as c_int;
1594 }
1595 return 0 as ::std::os::raw::c_int as c_int;
1596}