1extern "C" {
2 fn malloc(_: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
3 fn calloc(_: ::std::os::raw::c_ulong, _: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
4 fn free(_: *mut ::std::os::raw::c_void);
5 fn copy_csc_mat(A: *const csc) -> *mut csc;
6 fn csc_spfree(A: *mut csc);
7 fn mat_vec(A: *const csc, x: *const c_float, y: *mut c_float, plus_eq: c_int);
8 fn vec_ew_prod(a: *const c_float, b: *const c_float, c: *mut c_float, n: c_int);
9 fn vec_mult_scalar(a: *mut c_float, sc: c_float, n: c_int);
10 fn prea_vec_copy(a: *const c_float, b: *mut c_float, n: c_int);
11 fn vec_copy(a: *mut c_float, n: c_int) -> *mut c_float;
12 fn osqp_toc(t: *mut OSQPTimer) -> c_float;
13 fn osqp_tic(t: *mut OSQPTimer);
14 fn printf(_: *const ::std::os::raw::c_char, _: ...) -> ::std::os::raw::c_int;
15 fn copy_settings(settings: *const OSQPSettings) -> *mut OSQPSettings;
16 fn print_setup_header(work: *const OSQPWorkspace);
17 fn print_header();
18 fn print_summary(work: *mut OSQPWorkspace);
19 fn print_footer(info: *mut OSQPInfo, polish_0: c_int);
20 fn fmod(_: ::std::os::raw::c_double, _: ::std::os::raw::c_double) -> ::std::os::raw::c_double;
21 fn compute_rho_estimate(work: *mut OSQPWorkspace) -> c_float;
22 fn adapt_rho(work: *mut OSQPWorkspace) -> c_int;
23 fn set_rho_vec(work: *mut OSQPWorkspace);
24 fn update_rho_vec(work: *mut OSQPWorkspace) -> c_int;
25 fn swap_vectors(a: *mut *mut c_float, b: *mut *mut c_float);
26 fn cold_start(work: *mut OSQPWorkspace);
27 fn update_xz_tilde(work: *mut OSQPWorkspace);
28 fn update_x(work: *mut OSQPWorkspace);
29 fn update_z(work: *mut OSQPWorkspace);
30 fn update_y(work: *mut OSQPWorkspace);
31 fn compute_obj_val(work: *mut OSQPWorkspace, x: *mut c_float) -> c_float;
32 fn has_solution(info: *mut OSQPInfo) -> c_int;
33 fn store_solution(work: *mut OSQPWorkspace);
34 fn update_info(
35 work: *mut OSQPWorkspace,
36 iter: c_int,
37 compute_objective: c_int,
38 polish_0: c_int,
39 );
40 fn reset_info(info: *mut OSQPInfo);
41 fn update_status(info: *mut OSQPInfo, status_val: c_int);
42 fn check_termination(work: *mut OSQPWorkspace, approximate: c_int) -> c_int;
43 fn validate_data(data: *const OSQPData) -> c_int;
44 fn validate_settings(settings: *const OSQPSettings) -> c_int;
45 fn scale_data(work: *mut OSQPWorkspace) -> c_int;
46 fn unscale_data(work: *mut OSQPWorkspace) -> c_int;
47 fn _osqp_error(
48 error_code: osqp_error_type,
49 function_name: *const ::std::os::raw::c_char,
50 ) -> c_int;
51 fn polish(work: *mut OSQPWorkspace) -> c_int;
52 fn load_linsys_solver(linsys_solver: linsys_solver_type) -> c_int;
53 fn unload_linsys_solver(linsys_solver: linsys_solver_type) -> c_int;
54 fn init_linsys_solver(
55 s: *mut *mut LinSysSolver,
56 P: *const csc,
57 A: *const csc,
58 sigma: c_float,
59 rho_vec: *const c_float,
60 linsys_solver: linsys_solver_type,
61 polish_0: c_int,
62 ) -> c_int;
63}
64pub type c_int = ::std::os::raw::c_longlong;
65pub type c_float = ::std::os::raw::c_double;
66pub type linsys_solver_type = ::std::os::raw::c_uint;
67pub const MKL_PARDISO_SOLVER: linsys_solver_type = 1;
68pub const QDLDL_SOLVER: linsys_solver_type = 0;
69pub type osqp_error_type = ::std::os::raw::c_uint;
70pub const OSQP_WORKSPACE_NOT_INIT_ERROR: osqp_error_type = 7;
71pub const OSQP_MEM_ALLOC_ERROR: osqp_error_type = 6;
72pub const OSQP_NONCVX_ERROR: osqp_error_type = 5;
73pub const OSQP_LINSYS_SOLVER_INIT_ERROR: osqp_error_type = 4;
74pub const OSQP_LINSYS_SOLVER_LOAD_ERROR: osqp_error_type = 3;
75pub const OSQP_SETTINGS_VALIDATION_ERROR: osqp_error_type = 2;
76pub const OSQP_DATA_VALIDATION_ERROR: osqp_error_type = 1;
77#[derive(Copy, Clone)]
78#[repr(C)]
79pub struct csc {
80 pub nzmax: c_int,
81 pub m: c_int,
82 pub n: c_int,
83 pub p: *mut c_int,
84 pub i: *mut c_int,
85 pub x: *mut c_float,
86 pub nz: c_int,
87}
88#[derive(Copy, Clone)]
89#[repr(C)]
90pub struct linsys_solver {
91 pub type_0: linsys_solver_type,
92 pub solve: Option::<unsafe extern "C" fn(*mut LinSysSolver, *mut c_float) -> c_int>,
93 pub free: Option::<unsafe extern "C" fn(*mut LinSysSolver) -> ()>,
94 pub update_matrices: Option::<
95 unsafe extern "C" fn(*mut LinSysSolver, *const csc, *const csc) -> c_int,
96 >,
97 pub update_rho_vec: Option::<
98 unsafe extern "C" fn(*mut LinSysSolver, *const c_float) -> c_int,
99 >,
100 pub nthreads: c_int,
101}
102pub type LinSysSolver = linsys_solver;
103#[derive(Copy, Clone)]
104#[repr(C)]
105pub struct OSQP_TIMER {
106 pub tic: uint64_t,
107 pub toc: uint64_t,
108 pub tinfo: mach_timebase_info_data_t,
109}
110pub type mach_timebase_info_data_t = mach_timebase_info;
111#[derive(Copy, Clone)]
112#[repr(C)]
113pub struct mach_timebase_info {
114 pub numer: uint32_t,
115 pub denom: uint32_t,
116}
117pub type uint32_t = ::std::os::raw::c_uint;
118pub type uint64_t = ::std::os::raw::c_ulonglong;
119pub type OSQPTimer = OSQP_TIMER;
120#[derive(Copy, Clone)]
121#[repr(C)]
122pub struct OSQPScaling {
123 pub c: c_float,
124 pub D: *mut c_float,
125 pub E: *mut c_float,
126 pub cinv: c_float,
127 pub Dinv: *mut c_float,
128 pub Einv: *mut c_float,
129}
130#[derive(Copy, Clone)]
131#[repr(C)]
132pub struct OSQPSolution {
133 pub x: *mut c_float,
134 pub y: *mut c_float,
135}
136#[derive(Copy, Clone)]
137#[repr(C)]
138pub struct OSQPInfo {
139 pub iter: c_int,
140 pub status: [::std::os::raw::c_char; 32],
141 pub status_val: c_int,
142 pub status_polish: c_int,
143 pub obj_val: c_float,
144 pub pri_res: c_float,
145 pub dua_res: c_float,
146 pub setup_time: c_float,
147 pub solve_time: c_float,
148 pub update_time: c_float,
149 pub polish_time: c_float,
150 pub run_time: c_float,
151 pub rho_updates: c_int,
152 pub rho_estimate: c_float,
153}
154#[derive(Copy, Clone)]
155#[repr(C)]
156pub struct OSQPPolish {
157 pub Ared: *mut csc,
158 pub n_low: c_int,
159 pub n_upp: c_int,
160 pub A_to_Alow: *mut c_int,
161 pub A_to_Aupp: *mut c_int,
162 pub Alow_to_A: *mut c_int,
163 pub Aupp_to_A: *mut c_int,
164 pub x: *mut c_float,
165 pub z: *mut c_float,
166 pub y: *mut c_float,
167 pub obj_val: c_float,
168 pub pri_res: c_float,
169 pub dua_res: c_float,
170}
171#[derive(Copy, Clone)]
172#[repr(C)]
173pub struct OSQPData {
174 pub n: c_int,
175 pub m: c_int,
176 pub P: *mut csc,
177 pub A: *mut csc,
178 pub q: *mut c_float,
179 pub l: *mut c_float,
180 pub u: *mut c_float,
181}
182#[derive(Copy, Clone)]
183#[repr(C)]
184pub struct OSQPSettings {
185 pub rho: c_float,
186 pub sigma: c_float,
187 pub scaling: c_int,
188 pub adaptive_rho: c_int,
189 pub adaptive_rho_interval: c_int,
190 pub adaptive_rho_tolerance: c_float,
191 pub adaptive_rho_fraction: c_float,
192 pub max_iter: c_int,
193 pub eps_abs: c_float,
194 pub eps_rel: c_float,
195 pub eps_prim_inf: c_float,
196 pub eps_dual_inf: c_float,
197 pub alpha: c_float,
198 pub linsys_solver: linsys_solver_type,
199 pub delta: c_float,
200 pub polish: c_int,
201 pub polish_refine_iter: c_int,
202 pub verbose: c_int,
203 pub scaled_termination: c_int,
204 pub check_termination: c_int,
205 pub warm_start: c_int,
206 pub time_limit: c_float,
207}
208#[derive(Copy, Clone)]
209#[repr(C)]
210pub struct OSQPWorkspace {
211 pub data: *mut OSQPData,
212 pub linsys_solver: *mut LinSysSolver,
213 pub pol: *mut OSQPPolish,
214 pub rho_vec: *mut c_float,
215 pub rho_inv_vec: *mut c_float,
216 pub constr_type: *mut c_int,
217 pub x: *mut c_float,
218 pub y: *mut c_float,
219 pub z: *mut c_float,
220 pub xz_tilde: *mut c_float,
221 pub x_prev: *mut c_float,
222 pub z_prev: *mut c_float,
223 pub Ax: *mut c_float,
224 pub Px: *mut c_float,
225 pub Aty: *mut c_float,
226 pub delta_y: *mut c_float,
227 pub Atdelta_y: *mut c_float,
228 pub delta_x: *mut c_float,
229 pub Pdelta_x: *mut c_float,
230 pub Adelta_x: *mut c_float,
231 pub D_temp: *mut c_float,
232 pub D_temp_A: *mut c_float,
233 pub E_temp: *mut c_float,
234 pub settings: *mut OSQPSettings,
235 pub scaling: *mut OSQPScaling,
236 pub solution: *mut OSQPSolution,
237 pub info: *mut OSQPInfo,
238 pub timer: *mut OSQPTimer,
239 pub first_run: c_int,
240 pub clear_update_time: c_int,
241 pub rho_update_from_solve: c_int,
242 pub summary_printed: c_int,
243}
244pub const RHO_EQ_OVER_RHO_INEQ: ::std::os::raw::c_double = 1e03f64;
245pub const c_free: unsafe extern "C" fn(*mut ::std::os::raw::c_void) -> () = free;
246pub const PRINT_INTERVAL: ::std::os::raw::c_int = 200 as ::std::os::raw::c_int;
247pub const c_fmod: unsafe extern "C" fn(
248 ::std::os::raw::c_double,
249 ::std::os::raw::c_double,
250) -> ::std::os::raw::c_double = fmod;
251pub const c_print: unsafe extern "C" fn(*const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int = printf;
252pub const OSQP_MAX_ITER_REACHED: ::std::os::raw::c_int = -(2 as ::std::os::raw::c_int);
253pub const OSQP_TIME_LIMIT_REACHED: ::std::os::raw::c_int = -(6 as ::std::os::raw::c_int);
254pub const OSQP_SOLVED: ::std::os::raw::c_int = 1 as ::std::os::raw::c_int;
255pub const OSQP_NULL: ::std::os::raw::c_int = 0 as ::std::os::raw::c_int;
256pub const c_malloc: unsafe extern "C" fn(::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void = malloc;
257pub const c_calloc: unsafe extern "C" fn(
258 ::std::os::raw::c_ulong,
259 ::std::os::raw::c_ulong,
260) -> *mut ::std::os::raw::c_void = calloc;
261pub const OSQP_UNSOLVED: ::std::os::raw::c_int = -(10 as ::std::os::raw::c_int);
262pub const RHO: ::std::os::raw::c_double = 0.1f64;
263pub const SIGMA: ::std::os::raw::c_double = 1E-06f64;
264pub const SCALING: ::std::os::raw::c_int = 10 as ::std::os::raw::c_int;
265pub const ADAPTIVE_RHO: ::std::os::raw::c_int = 1 as ::std::os::raw::c_int;
266pub const ADAPTIVE_RHO_INTERVAL: ::std::os::raw::c_int = 0 as ::std::os::raw::c_int;
267pub const ADAPTIVE_RHO_TOLERANCE: ::std::os::raw::c_int = 5 as ::std::os::raw::c_int;
268pub const ADAPTIVE_RHO_FRACTION: ::std::os::raw::c_double = 0.4f64;
269pub const MAX_ITER: ::std::os::raw::c_int = 4000 as ::std::os::raw::c_int;
270pub const EPS_ABS: ::std::os::raw::c_double = 1E-3f64;
271pub const EPS_REL: ::std::os::raw::c_double = 1E-3f64;
272pub const EPS_PRIM_INF: ::std::os::raw::c_double = 1E-4f64;
273pub const EPS_DUAL_INF: ::std::os::raw::c_double = 1E-4f64;
274pub const ALPHA: ::std::os::raw::c_double = 1.6f64;
275pub const LINSYS_SOLVER: ::std::os::raw::c_int = QDLDL_SOLVER as ::std::os::raw::c_int;
276pub const DELTA: ::std::os::raw::c_double = 1E-6f64;
277pub const POLISH: ::std::os::raw::c_int = 0 as ::std::os::raw::c_int;
278pub const POLISH_REFINE_ITER: ::std::os::raw::c_int = 3 as ::std::os::raw::c_int;
279pub const VERBOSE: ::std::os::raw::c_int = 1 as ::std::os::raw::c_int;
280pub const SCALED_TERMINATION: ::std::os::raw::c_int = 0 as ::std::os::raw::c_int;
281pub const CHECK_TERMINATION: ::std::os::raw::c_int = 25 as ::std::os::raw::c_int;
282pub const WARM_START: ::std::os::raw::c_int = 1 as ::std::os::raw::c_int;
283pub const TIME_LIMIT: ::std::os::raw::c_int = 0 as ::std::os::raw::c_int;
284#[no_mangle]
285pub unsafe extern "C" fn osqp_set_default_settings(mut settings: *mut OSQPSettings) {
286 (*settings).rho = RHO;
287 (*settings).sigma = SIGMA;
288 (*settings).scaling = SCALING as c_int;
289 (*settings).adaptive_rho = ADAPTIVE_RHO as c_int;
290 (*settings).adaptive_rho_interval = ADAPTIVE_RHO_INTERVAL as c_int;
291 (*settings).adaptive_rho_tolerance = ADAPTIVE_RHO_TOLERANCE as c_float;
292 (*settings).adaptive_rho_fraction = ADAPTIVE_RHO_FRACTION;
293 (*settings).max_iter = MAX_ITER as c_int;
294 (*settings).eps_abs = EPS_ABS;
295 (*settings).eps_rel = EPS_REL;
296 (*settings).eps_prim_inf = EPS_PRIM_INF;
297 (*settings).eps_dual_inf = EPS_DUAL_INF;
298 (*settings).alpha = ALPHA;
299 (*settings).linsys_solver = LINSYS_SOLVER as linsys_solver_type;
300 (*settings).delta = DELTA;
301 (*settings).polish = POLISH as c_int;
302 (*settings).polish_refine_iter = POLISH_REFINE_ITER as c_int;
303 (*settings).verbose = VERBOSE as c_int;
304 (*settings).scaled_termination = SCALED_TERMINATION as c_int;
305 (*settings).check_termination = CHECK_TERMINATION as c_int;
306 (*settings).warm_start = WARM_START as c_int;
307 (*settings).time_limit = TIME_LIMIT as c_float;
308}
309#[no_mangle]
310pub unsafe extern "C" fn osqp_setup(
311 mut workp: *mut *mut OSQPWorkspace,
312 mut data: *const OSQPData,
313 mut settings: *const OSQPSettings,
314) -> c_int {
315 let mut exitflag: c_int = 0;
316 let mut work: *mut OSQPWorkspace = 0 as *mut OSQPWorkspace;
317 if validate_data(data) != 0 {
318 return _osqp_error(
319 OSQP_DATA_VALIDATION_ERROR,
320 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
321 .as_ptr(),
322 );
323 }
324 if validate_settings(settings) != 0 {
325 return _osqp_error(
326 OSQP_SETTINGS_VALIDATION_ERROR,
327 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
328 .as_ptr(),
329 );
330 }
331 work = calloc(
332 1 as ::std::os::raw::c_int as ::std::os::raw::c_ulong,
333 ::std::mem::size_of::<OSQPWorkspace>() as ::std::os::raw::c_ulong,
334 ) as *mut OSQPWorkspace;
335 if work.is_null() {
336 return _osqp_error(
337 OSQP_MEM_ALLOC_ERROR,
338 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
339 .as_ptr(),
340 );
341 }
342 *workp = work;
343 let ref mut fresh0 = (*work).timer;
344 *fresh0 = malloc(::std::mem::size_of::<OSQPTimer>() as ::std::os::raw::c_ulong)
345 as *mut OSQPTimer;
346 if ((*work).timer).is_null() {
347 return _osqp_error(
348 OSQP_MEM_ALLOC_ERROR,
349 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
350 .as_ptr(),
351 );
352 }
353 osqp_tic((*work).timer);
354 let ref mut fresh1 = (*work).data;
355 *fresh1 = malloc(::std::mem::size_of::<OSQPData>() as ::std::os::raw::c_ulong)
356 as *mut OSQPData;
357 if ((*work).data).is_null() {
358 return _osqp_error(
359 OSQP_MEM_ALLOC_ERROR,
360 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
361 .as_ptr(),
362 );
363 }
364 (*(*work).data).n = (*data).n;
365 (*(*work).data).m = (*data).m;
366 let ref mut fresh2 = (*(*work).data).P;
367 *fresh2 = copy_csc_mat((*data).P);
368 let ref mut fresh3 = (*(*work).data).q;
369 *fresh3 = vec_copy((*data).q, (*data).n);
370 if ((*(*work).data).P).is_null() || ((*(*work).data).q).is_null() {
371 return _osqp_error(
372 OSQP_MEM_ALLOC_ERROR,
373 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
374 .as_ptr(),
375 );
376 }
377 let ref mut fresh4 = (*(*work).data).A;
378 *fresh4 = copy_csc_mat((*data).A);
379 if ((*(*work).data).A).is_null() {
380 return _osqp_error(
381 OSQP_MEM_ALLOC_ERROR,
382 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
383 .as_ptr(),
384 );
385 }
386 let ref mut fresh5 = (*(*work).data).l;
387 *fresh5 = vec_copy((*data).l, (*data).m);
388 let ref mut fresh6 = (*(*work).data).u;
389 *fresh6 = vec_copy((*data).u, (*data).m);
390 if (*data).m != 0 && (((*(*work).data).l).is_null() || ((*(*work).data).u).is_null())
391 {
392 return _osqp_error(
393 OSQP_MEM_ALLOC_ERROR,
394 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
395 .as_ptr(),
396 );
397 }
398 let ref mut fresh7 = (*work).rho_vec;
399 *fresh7 = malloc(
400 ((*data).m as ::std::os::raw::c_ulonglong)
401 .wrapping_mul(
402 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong as ::std::os::raw::c_ulonglong,
403 ) as ::std::os::raw::c_ulong,
404 ) as *mut c_float;
405 let ref mut fresh8 = (*work).rho_inv_vec;
406 *fresh8 = malloc(
407 ((*data).m as ::std::os::raw::c_ulonglong)
408 .wrapping_mul(
409 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong as ::std::os::raw::c_ulonglong,
410 ) as ::std::os::raw::c_ulong,
411 ) as *mut c_float;
412 if (*data).m != 0 && (((*work).rho_vec).is_null() || ((*work).rho_inv_vec).is_null())
413 {
414 return _osqp_error(
415 OSQP_MEM_ALLOC_ERROR,
416 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
417 .as_ptr(),
418 );
419 }
420 let ref mut fresh9 = (*work).constr_type;
421 *fresh9 = calloc(
422 (*data).m as ::std::os::raw::c_ulong,
423 ::std::mem::size_of::<c_int>() as ::std::os::raw::c_ulong,
424 ) as *mut c_int;
425 if (*data).m != 0 && ((*work).constr_type).is_null() {
426 return _osqp_error(
427 OSQP_MEM_ALLOC_ERROR,
428 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
429 .as_ptr(),
430 );
431 }
432 let ref mut fresh10 = (*work).x;
433 *fresh10 = calloc(
434 (*data).n as ::std::os::raw::c_ulong,
435 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong,
436 ) as *mut c_float;
437 let ref mut fresh11 = (*work).z;
438 *fresh11 = calloc(
439 (*data).m as ::std::os::raw::c_ulong,
440 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong,
441 ) as *mut c_float;
442 let ref mut fresh12 = (*work).xz_tilde;
443 *fresh12 = calloc(
444 ((*data).n + (*data).m) as ::std::os::raw::c_ulong,
445 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong,
446 ) as *mut c_float;
447 let ref mut fresh13 = (*work).x_prev;
448 *fresh13 = calloc(
449 (*data).n as ::std::os::raw::c_ulong,
450 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong,
451 ) as *mut c_float;
452 let ref mut fresh14 = (*work).z_prev;
453 *fresh14 = calloc(
454 (*data).m as ::std::os::raw::c_ulong,
455 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong,
456 ) as *mut c_float;
457 let ref mut fresh15 = (*work).y;
458 *fresh15 = calloc(
459 (*data).m as ::std::os::raw::c_ulong,
460 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong,
461 ) as *mut c_float;
462 if ((*work).x).is_null() || ((*work).xz_tilde).is_null()
463 || ((*work).x_prev).is_null()
464 {
465 return _osqp_error(
466 OSQP_MEM_ALLOC_ERROR,
467 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
468 .as_ptr(),
469 );
470 }
471 if (*data).m != 0
472 && (((*work).z).is_null() || ((*work).z_prev).is_null() || ((*work).y).is_null())
473 {
474 return _osqp_error(
475 OSQP_MEM_ALLOC_ERROR,
476 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
477 .as_ptr(),
478 );
479 }
480 cold_start(work);
481 let ref mut fresh16 = (*work).Ax;
482 *fresh16 = calloc(
483 (*data).m as ::std::os::raw::c_ulong,
484 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong,
485 ) as *mut c_float;
486 let ref mut fresh17 = (*work).Px;
487 *fresh17 = calloc(
488 (*data).n as ::std::os::raw::c_ulong,
489 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong,
490 ) as *mut c_float;
491 let ref mut fresh18 = (*work).Aty;
492 *fresh18 = calloc(
493 (*data).n as ::std::os::raw::c_ulong,
494 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong,
495 ) as *mut c_float;
496 let ref mut fresh19 = (*work).delta_y;
497 *fresh19 = calloc(
498 (*data).m as ::std::os::raw::c_ulong,
499 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong,
500 ) as *mut c_float;
501 let ref mut fresh20 = (*work).Atdelta_y;
502 *fresh20 = calloc(
503 (*data).n as ::std::os::raw::c_ulong,
504 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong,
505 ) as *mut c_float;
506 let ref mut fresh21 = (*work).delta_x;
507 *fresh21 = calloc(
508 (*data).n as ::std::os::raw::c_ulong,
509 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong,
510 ) as *mut c_float;
511 let ref mut fresh22 = (*work).Pdelta_x;
512 *fresh22 = calloc(
513 (*data).n as ::std::os::raw::c_ulong,
514 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong,
515 ) as *mut c_float;
516 let ref mut fresh23 = (*work).Adelta_x;
517 *fresh23 = calloc(
518 (*data).m as ::std::os::raw::c_ulong,
519 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong,
520 ) as *mut c_float;
521 if ((*work).Px).is_null() || ((*work).Aty).is_null() || ((*work).Atdelta_y).is_null()
522 || ((*work).delta_x).is_null() || ((*work).Pdelta_x).is_null()
523 {
524 return _osqp_error(
525 OSQP_MEM_ALLOC_ERROR,
526 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
527 .as_ptr(),
528 );
529 }
530 if (*data).m != 0
531 && (((*work).Ax).is_null() || ((*work).delta_y).is_null()
532 || ((*work).Adelta_x).is_null())
533 {
534 return _osqp_error(
535 OSQP_MEM_ALLOC_ERROR,
536 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
537 .as_ptr(),
538 );
539 }
540 let ref mut fresh24 = (*work).settings;
541 *fresh24 = copy_settings(settings);
542 if ((*work).settings).is_null() {
543 return _osqp_error(
544 OSQP_MEM_ALLOC_ERROR,
545 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
546 .as_ptr(),
547 );
548 }
549 if (*settings).scaling != 0 {
550 let ref mut fresh25 = (*work).scaling;
551 *fresh25 = malloc(::std::mem::size_of::<OSQPScaling>() as ::std::os::raw::c_ulong)
552 as *mut OSQPScaling;
553 if ((*work).scaling).is_null() {
554 return _osqp_error(
555 OSQP_MEM_ALLOC_ERROR,
556 (*::std::mem::transmute::<
557 &[u8; 11],
558 &[::std::os::raw::c_char; 11],
559 >(b"osqp_setup\0"))
560 .as_ptr(),
561 );
562 }
563 let ref mut fresh26 = (*(*work).scaling).D;
564 *fresh26 = malloc(
565 ((*data).n as ::std::os::raw::c_ulonglong)
566 .wrapping_mul(
567 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong
568 as ::std::os::raw::c_ulonglong,
569 ) as ::std::os::raw::c_ulong,
570 ) as *mut c_float;
571 let ref mut fresh27 = (*(*work).scaling).Dinv;
572 *fresh27 = malloc(
573 ((*data).n as ::std::os::raw::c_ulonglong)
574 .wrapping_mul(
575 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong
576 as ::std::os::raw::c_ulonglong,
577 ) as ::std::os::raw::c_ulong,
578 ) as *mut c_float;
579 let ref mut fresh28 = (*(*work).scaling).E;
580 *fresh28 = malloc(
581 ((*data).m as ::std::os::raw::c_ulonglong)
582 .wrapping_mul(
583 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong
584 as ::std::os::raw::c_ulonglong,
585 ) as ::std::os::raw::c_ulong,
586 ) as *mut c_float;
587 let ref mut fresh29 = (*(*work).scaling).Einv;
588 *fresh29 = malloc(
589 ((*data).m as ::std::os::raw::c_ulonglong)
590 .wrapping_mul(
591 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong
592 as ::std::os::raw::c_ulonglong,
593 ) as ::std::os::raw::c_ulong,
594 ) as *mut c_float;
595 if ((*(*work).scaling).D).is_null() || ((*(*work).scaling).Dinv).is_null() {
596 return _osqp_error(
597 OSQP_MEM_ALLOC_ERROR,
598 (*::std::mem::transmute::<
599 &[u8; 11],
600 &[::std::os::raw::c_char; 11],
601 >(b"osqp_setup\0"))
602 .as_ptr(),
603 );
604 }
605 if (*data).m != 0
606 && (((*(*work).scaling).E).is_null() || ((*(*work).scaling).Einv).is_null())
607 {
608 return _osqp_error(
609 OSQP_MEM_ALLOC_ERROR,
610 (*::std::mem::transmute::<
611 &[u8; 11],
612 &[::std::os::raw::c_char; 11],
613 >(b"osqp_setup\0"))
614 .as_ptr(),
615 );
616 }
617 let ref mut fresh30 = (*work).D_temp;
618 *fresh30 = malloc(
619 ((*data).n as ::std::os::raw::c_ulonglong)
620 .wrapping_mul(
621 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong
622 as ::std::os::raw::c_ulonglong,
623 ) as ::std::os::raw::c_ulong,
624 ) as *mut c_float;
625 let ref mut fresh31 = (*work).D_temp_A;
626 *fresh31 = malloc(
627 ((*data).n as ::std::os::raw::c_ulonglong)
628 .wrapping_mul(
629 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong
630 as ::std::os::raw::c_ulonglong,
631 ) as ::std::os::raw::c_ulong,
632 ) as *mut c_float;
633 let ref mut fresh32 = (*work).E_temp;
634 *fresh32 = malloc(
635 ((*data).m as ::std::os::raw::c_ulonglong)
636 .wrapping_mul(
637 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong
638 as ::std::os::raw::c_ulonglong,
639 ) as ::std::os::raw::c_ulong,
640 ) as *mut c_float;
641 if ((*work).D_temp).is_null() || ((*work).D_temp_A).is_null() {
642 return _osqp_error(
643 OSQP_MEM_ALLOC_ERROR,
644 (*::std::mem::transmute::<
645 &[u8; 11],
646 &[::std::os::raw::c_char; 11],
647 >(b"osqp_setup\0"))
648 .as_ptr(),
649 );
650 }
651 if (*data).m != 0 && ((*work).E_temp).is_null() {
652 return _osqp_error(
653 OSQP_MEM_ALLOC_ERROR,
654 (*::std::mem::transmute::<
655 &[u8; 11],
656 &[::std::os::raw::c_char; 11],
657 >(b"osqp_setup\0"))
658 .as_ptr(),
659 );
660 }
661 scale_data(work);
662 } else {
663 let ref mut fresh33 = (*work).scaling;
664 *fresh33 = OSQP_NULL as *mut OSQPScaling;
665 let ref mut fresh34 = (*work).D_temp;
666 *fresh34 = OSQP_NULL as *mut c_float;
667 let ref mut fresh35 = (*work).D_temp_A;
668 *fresh35 = OSQP_NULL as *mut c_float;
669 let ref mut fresh36 = (*work).E_temp;
670 *fresh36 = OSQP_NULL as *mut c_float;
671 }
672 set_rho_vec(work);
673 if load_linsys_solver((*(*work).settings).linsys_solver) != 0 {
674 return _osqp_error(
675 OSQP_LINSYS_SOLVER_LOAD_ERROR,
676 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
677 .as_ptr(),
678 );
679 }
680 exitflag = init_linsys_solver(
681 &mut (*work).linsys_solver,
682 (*(*work).data).P,
683 (*(*work).data).A,
684 (*(*work).settings).sigma,
685 (*work).rho_vec,
686 (*(*work).settings).linsys_solver,
687 0 as ::std::os::raw::c_int as c_int,
688 );
689 if exitflag != 0 {
690 return _osqp_error(
691 exitflag as osqp_error_type,
692 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
693 .as_ptr(),
694 );
695 }
696 let ref mut fresh37 = (*work).pol;
697 *fresh37 = malloc(::std::mem::size_of::<OSQPPolish>() as ::std::os::raw::c_ulong)
698 as *mut OSQPPolish;
699 if ((*work).pol).is_null() {
700 return _osqp_error(
701 OSQP_MEM_ALLOC_ERROR,
702 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
703 .as_ptr(),
704 );
705 }
706 let ref mut fresh38 = (*(*work).pol).Alow_to_A;
707 *fresh38 = malloc(
708 ((*data).m as ::std::os::raw::c_ulonglong)
709 .wrapping_mul(
710 ::std::mem::size_of::<c_int>() as ::std::os::raw::c_ulong as ::std::os::raw::c_ulonglong,
711 ) as ::std::os::raw::c_ulong,
712 ) as *mut c_int;
713 let ref mut fresh39 = (*(*work).pol).Aupp_to_A;
714 *fresh39 = malloc(
715 ((*data).m as ::std::os::raw::c_ulonglong)
716 .wrapping_mul(
717 ::std::mem::size_of::<c_int>() as ::std::os::raw::c_ulong as ::std::os::raw::c_ulonglong,
718 ) as ::std::os::raw::c_ulong,
719 ) as *mut c_int;
720 let ref mut fresh40 = (*(*work).pol).A_to_Alow;
721 *fresh40 = malloc(
722 ((*data).m as ::std::os::raw::c_ulonglong)
723 .wrapping_mul(
724 ::std::mem::size_of::<c_int>() as ::std::os::raw::c_ulong as ::std::os::raw::c_ulonglong,
725 ) as ::std::os::raw::c_ulong,
726 ) as *mut c_int;
727 let ref mut fresh41 = (*(*work).pol).A_to_Aupp;
728 *fresh41 = malloc(
729 ((*data).m as ::std::os::raw::c_ulonglong)
730 .wrapping_mul(
731 ::std::mem::size_of::<c_int>() as ::std::os::raw::c_ulong as ::std::os::raw::c_ulonglong,
732 ) as ::std::os::raw::c_ulong,
733 ) as *mut c_int;
734 let ref mut fresh42 = (*(*work).pol).x;
735 *fresh42 = malloc(
736 ((*data).n as ::std::os::raw::c_ulonglong)
737 .wrapping_mul(
738 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong as ::std::os::raw::c_ulonglong,
739 ) as ::std::os::raw::c_ulong,
740 ) as *mut c_float;
741 let ref mut fresh43 = (*(*work).pol).z;
742 *fresh43 = malloc(
743 ((*data).m as ::std::os::raw::c_ulonglong)
744 .wrapping_mul(
745 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong as ::std::os::raw::c_ulonglong,
746 ) as ::std::os::raw::c_ulong,
747 ) as *mut c_float;
748 let ref mut fresh44 = (*(*work).pol).y;
749 *fresh44 = malloc(
750 ((*data).m as ::std::os::raw::c_ulonglong)
751 .wrapping_mul(
752 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong as ::std::os::raw::c_ulonglong,
753 ) as ::std::os::raw::c_ulong,
754 ) as *mut c_float;
755 if ((*(*work).pol).x).is_null() {
756 return _osqp_error(
757 OSQP_MEM_ALLOC_ERROR,
758 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
759 .as_ptr(),
760 );
761 }
762 if (*data).m != 0
763 && (((*(*work).pol).Alow_to_A).is_null() || ((*(*work).pol).Aupp_to_A).is_null()
764 || ((*(*work).pol).A_to_Alow).is_null()
765 || ((*(*work).pol).A_to_Aupp).is_null() || ((*(*work).pol).z).is_null()
766 || ((*(*work).pol).y).is_null())
767 {
768 return _osqp_error(
769 OSQP_MEM_ALLOC_ERROR,
770 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
771 .as_ptr(),
772 );
773 }
774 let ref mut fresh45 = (*work).solution;
775 *fresh45 = calloc(
776 1 as ::std::os::raw::c_int as ::std::os::raw::c_ulong,
777 ::std::mem::size_of::<OSQPSolution>() as ::std::os::raw::c_ulong,
778 ) as *mut OSQPSolution;
779 if ((*work).solution).is_null() {
780 return _osqp_error(
781 OSQP_MEM_ALLOC_ERROR,
782 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
783 .as_ptr(),
784 );
785 }
786 let ref mut fresh46 = (*(*work).solution).x;
787 *fresh46 = calloc(
788 1 as ::std::os::raw::c_int as ::std::os::raw::c_ulong,
789 ((*data).n as ::std::os::raw::c_ulonglong)
790 .wrapping_mul(
791 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong as ::std::os::raw::c_ulonglong,
792 ) as ::std::os::raw::c_ulong,
793 ) as *mut c_float;
794 let ref mut fresh47 = (*(*work).solution).y;
795 *fresh47 = calloc(
796 1 as ::std::os::raw::c_int as ::std::os::raw::c_ulong,
797 ((*data).m as ::std::os::raw::c_ulonglong)
798 .wrapping_mul(
799 ::std::mem::size_of::<c_float>() as ::std::os::raw::c_ulong as ::std::os::raw::c_ulonglong,
800 ) as ::std::os::raw::c_ulong,
801 ) as *mut c_float;
802 if ((*(*work).solution).x).is_null() {
803 return _osqp_error(
804 OSQP_MEM_ALLOC_ERROR,
805 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
806 .as_ptr(),
807 );
808 }
809 if (*data).m != 0 && ((*(*work).solution).y).is_null() {
810 return _osqp_error(
811 OSQP_MEM_ALLOC_ERROR,
812 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
813 .as_ptr(),
814 );
815 }
816 let ref mut fresh48 = (*work).info;
817 *fresh48 = calloc(
818 1 as ::std::os::raw::c_int as ::std::os::raw::c_ulong,
819 ::std::mem::size_of::<OSQPInfo>() as ::std::os::raw::c_ulong,
820 ) as *mut OSQPInfo;
821 if ((*work).info).is_null() {
822 return _osqp_error(
823 OSQP_MEM_ALLOC_ERROR,
824 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_setup\0"))
825 .as_ptr(),
826 );
827 }
828 (*(*work).info).status_polish = 0 as ::std::os::raw::c_int as c_int;
829 update_status((*work).info, OSQP_UNSOLVED as c_int);
830 (*(*work).info).solve_time = 0.0f64;
831 (*(*work).info).update_time = 0.0f64;
832 (*(*work).info).polish_time = 0.0f64;
833 (*(*work).info).run_time = 0.0f64;
834 (*(*work).info).setup_time = osqp_toc((*work).timer);
835 (*work).first_run = 1 as ::std::os::raw::c_int as c_int;
836 (*work).clear_update_time = 0 as ::std::os::raw::c_int as c_int;
837 (*work).rho_update_from_solve = 0 as ::std::os::raw::c_int as c_int;
838 (*(*work).info).rho_updates = 0 as ::std::os::raw::c_int as c_int;
839 (*(*work).info).rho_estimate = (*(*work).settings).rho;
840 if (*(*work).settings).verbose != 0 {
841 print_setup_header(work);
842 }
843 (*work).summary_printed = 0 as ::std::os::raw::c_int as c_int;
844 return 0 as ::std::os::raw::c_int as c_int;
845}
846#[no_mangle]
847pub unsafe extern "C" fn osqp_solve(mut work: *mut OSQPWorkspace) -> c_int {
848 let mut current_block: u64;
849 let mut exitflag: c_int = 0;
850 let mut iter: c_int = 0;
851 let mut compute_cost_function: c_int = 0;
852 let mut can_check_termination: c_int = 0;
853 let mut temp_run_time: c_float = 0.;
854 let mut can_print: c_int = 0;
855 if work.is_null() {
856 return _osqp_error(
857 OSQP_WORKSPACE_NOT_INIT_ERROR,
858 (*::std::mem::transmute::<&[u8; 11], &[::std::os::raw::c_char; 11]>(b"osqp_solve\0"))
859 .as_ptr(),
860 );
861 }
862 if (*work).clear_update_time == 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
863 (*(*work).info).update_time = 0.0f64;
864 }
865 (*work).rho_update_from_solve = 1 as ::std::os::raw::c_int as c_int;
866 exitflag = 0 as ::std::os::raw::c_int as c_int;
867 can_check_termination = 0 as ::std::os::raw::c_int as c_int;
868 can_print = (*(*work).settings).verbose;
869 compute_cost_function = (*(*work).settings).verbose;
870 osqp_tic((*work).timer);
871 if (*(*work).settings).verbose != 0 {
872 print_header();
873 }
874 if (*(*work).settings).warm_start == 0 {
875 cold_start(work);
876 }
877 iter = 1 as ::std::os::raw::c_int as c_int;
878 loop {
879 if !(iter <= (*(*work).settings).max_iter) {
880 current_block = 13125627826496529465;
881 break;
882 }
883 swap_vectors(&mut (*work).x, &mut (*work).x_prev);
884 swap_vectors(&mut (*work).z, &mut (*work).z_prev);
885 update_xz_tilde(work);
886 update_x(work);
887 update_z(work);
888 update_y(work);
889 if (*work).first_run != 0 {
890 temp_run_time = (*(*work).info).setup_time + osqp_toc((*work).timer);
891 } else {
892 temp_run_time = (*(*work).info).update_time + osqp_toc((*work).timer);
893 }
894 if (*(*work).settings).time_limit != 0.
895 && temp_run_time >= (*(*work).settings).time_limit
896 {
897 update_status((*work).info, OSQP_TIME_LIMIT_REACHED as c_int);
898 if (*(*work).settings).verbose != 0 {
899 printf(
900 b"run time limit reached\n\0" as *const u8 as *const ::std::os::raw::c_char,
901 );
902 }
903 can_print = 0 as ::std::os::raw::c_int as c_int;
904 current_block = 13125627826496529465;
905 break;
906 } else {
907 can_check_termination = ((*(*work).settings).check_termination != 0
908 && iter % (*(*work).settings).check_termination
909 == 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong) as ::std::os::raw::c_int as c_int;
910 can_print = ((*(*work).settings).verbose != 0
911 && (iter % PRINT_INTERVAL as ::std::os::raw::c_longlong
912 == 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
913 || iter == 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong)) as ::std::os::raw::c_int
914 as c_int;
915 if can_check_termination != 0 || can_print != 0 {
916 update_info(
917 work,
918 iter,
919 compute_cost_function,
920 0 as ::std::os::raw::c_int as c_int,
921 );
922 if can_print != 0 {
923 print_summary(work);
924 }
925 if can_check_termination != 0 {
926 if check_termination(work, 0 as ::std::os::raw::c_int as c_int) != 0 {
927 current_block = 13125627826496529465;
928 break;
929 }
930 }
931 }
932 if (*(*work).settings).adaptive_rho != 0
933 && (*(*work).settings).adaptive_rho_interval == 0
934 {
935 if osqp_toc((*work).timer)
936 > (*(*work).settings).adaptive_rho_fraction
937 * (*(*work).info).setup_time
938 {
939 if (*(*work).settings).check_termination != 0 {
940 (*(*work).settings)
941 .adaptive_rho_interval = (iter as ::std::os::raw::c_double
942 + 0.5f64
943 * (*(*work).settings).check_termination as ::std::os::raw::c_double
944 - fmod(
945 iter as ::std::os::raw::c_double
946 + 0.5f64
947 * (*(*work).settings).check_termination as ::std::os::raw::c_double,
948 (*(*work).settings).check_termination as ::std::os::raw::c_double,
949 )) as c_int;
950 } else {
951 (*(*work).settings)
952 .adaptive_rho_interval = (iter as ::std::os::raw::c_double
953 + 0.5f64 * 25 as ::std::os::raw::c_int as ::std::os::raw::c_double
954 - fmod(
955 iter as ::std::os::raw::c_double
956 + 0.5f64 * 25 as ::std::os::raw::c_int as ::std::os::raw::c_double,
957 25 as ::std::os::raw::c_int as ::std::os::raw::c_double,
958 )) as c_int;
959 }
960 (*(*work).settings)
961 .adaptive_rho_interval = if (*(*work).settings)
962 .adaptive_rho_interval > (*(*work).settings).check_termination
963 {
964 (*(*work).settings).adaptive_rho_interval
965 } else {
966 (*(*work).settings).check_termination
967 };
968 }
969 }
970 if (*(*work).settings).adaptive_rho != 0
971 && (*(*work).settings).adaptive_rho_interval != 0
972 && iter % (*(*work).settings).adaptive_rho_interval
973 == 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
974 {
975 if can_check_termination == 0 && can_print == 0 {
976 update_info(
977 work,
978 iter,
979 compute_cost_function,
980 0 as ::std::os::raw::c_int as c_int,
981 );
982 }
983 if adapt_rho(work) != 0 {
984 printf(
985 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
986 (*::std::mem::transmute::<
987 &[u8; 11],
988 &[::std::os::raw::c_char; 11],
989 >(b"osqp_solve\0"))
990 .as_ptr(),
991 );
992 printf(b"Failed rho update\0" as *const u8 as *const ::std::os::raw::c_char);
993 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
994 exitflag = 1 as ::std::os::raw::c_int as c_int;
995 current_block = 4936170274040873418;
996 break;
997 }
998 }
999 iter += 1;
1000 }
1001 }
1002 match current_block {
1003 13125627826496529465 => {
1004 if can_check_termination == 0 {
1005 if can_print == 0 {
1006 update_info(
1007 work,
1008 iter - 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong,
1009 compute_cost_function,
1010 0 as ::std::os::raw::c_int as c_int,
1011 );
1012 }
1013 if (*(*work).settings).verbose != 0 && (*work).summary_printed == 0 {
1014 print_summary(work);
1015 }
1016 check_termination(work, 0 as ::std::os::raw::c_int as c_int);
1017 }
1018 if compute_cost_function == 0 && has_solution((*work).info) != 0 {
1019 (*(*work).info).obj_val = compute_obj_val(work, (*work).x);
1020 }
1021 if (*(*work).settings).verbose != 0 && (*work).summary_printed == 0 {
1022 print_summary(work);
1023 }
1024 if (*(*work).info).status_val == OSQP_UNSOLVED as ::std::os::raw::c_longlong {
1025 if check_termination(work, 1 as ::std::os::raw::c_int as c_int) == 0 {
1026 update_status((*work).info, OSQP_MAX_ITER_REACHED as c_int);
1027 }
1028 }
1029 if (*(*work).info).status_val == OSQP_TIME_LIMIT_REACHED as ::std::os::raw::c_longlong
1030 {
1031 if check_termination(work, 1 as ::std::os::raw::c_int as c_int) == 0 {
1032 update_status((*work).info, OSQP_TIME_LIMIT_REACHED as c_int);
1033 }
1034 }
1035 (*(*work).info).rho_estimate = compute_rho_estimate(work);
1036 (*(*work).info).solve_time = osqp_toc((*work).timer);
1037 if (*(*work).settings).polish != 0
1038 && (*(*work).info).status_val == OSQP_SOLVED as ::std::os::raw::c_longlong
1039 {
1040 polish(work);
1041 }
1042 if (*work).first_run != 0 {
1043 (*(*work).info)
1044 .run_time = (*(*work).info).setup_time + (*(*work).info).solve_time
1045 + (*(*work).info).polish_time;
1046 } else {
1047 (*(*work).info)
1048 .run_time = (*(*work).info).update_time + (*(*work).info).solve_time
1049 + (*(*work).info).polish_time;
1050 }
1051 if (*work).first_run != 0 {
1052 (*work).first_run = 0 as ::std::os::raw::c_int as c_int;
1053 }
1054 (*work).clear_update_time = 1 as ::std::os::raw::c_int as c_int;
1055 (*work).rho_update_from_solve = 0 as ::std::os::raw::c_int as c_int;
1056 if (*(*work).settings).verbose != 0 {
1057 print_footer((*work).info, (*(*work).settings).polish);
1058 }
1059 store_solution(work);
1060 }
1061 _ => {}
1062 }
1063 return exitflag;
1064}
1065#[no_mangle]
1066pub unsafe extern "C" fn osqp_cleanup(mut work: *mut OSQPWorkspace) -> c_int {
1067 let mut exitflag: c_int = 0 as ::std::os::raw::c_int as c_int;
1068 if !work.is_null() {
1069 if !((*work).data).is_null() {
1070 if !((*(*work).data).P).is_null() {
1071 csc_spfree((*(*work).data).P);
1072 }
1073 if !((*(*work).data).A).is_null() {
1074 csc_spfree((*(*work).data).A);
1075 }
1076 if !((*(*work).data).q).is_null() {
1077 free((*(*work).data).q as *mut ::std::os::raw::c_void);
1078 }
1079 if !((*(*work).data).l).is_null() {
1080 free((*(*work).data).l as *mut ::std::os::raw::c_void);
1081 }
1082 if !((*(*work).data).u).is_null() {
1083 free((*(*work).data).u as *mut ::std::os::raw::c_void);
1084 }
1085 free((*work).data as *mut ::std::os::raw::c_void);
1086 }
1087 if !((*work).scaling).is_null() {
1088 if !((*(*work).scaling).D).is_null() {
1089 free((*(*work).scaling).D as *mut ::std::os::raw::c_void);
1090 }
1091 if !((*(*work).scaling).Dinv).is_null() {
1092 free((*(*work).scaling).Dinv as *mut ::std::os::raw::c_void);
1093 }
1094 if !((*(*work).scaling).E).is_null() {
1095 free((*(*work).scaling).E as *mut ::std::os::raw::c_void);
1096 }
1097 if !((*(*work).scaling).Einv).is_null() {
1098 free((*(*work).scaling).Einv as *mut ::std::os::raw::c_void);
1099 }
1100 free((*work).scaling as *mut ::std::os::raw::c_void);
1101 }
1102 if !((*work).D_temp).is_null() {
1103 free((*work).D_temp as *mut ::std::os::raw::c_void);
1104 }
1105 if !((*work).D_temp_A).is_null() {
1106 free((*work).D_temp_A as *mut ::std::os::raw::c_void);
1107 }
1108 if !((*work).E_temp).is_null() {
1109 free((*work).E_temp as *mut ::std::os::raw::c_void);
1110 }
1111 if !((*work).linsys_solver).is_null() {
1112 if ((*(*work).linsys_solver).free).is_some() {
1113 ((*(*work).linsys_solver).free)
1114 .expect("non-null function pointer")((*work).linsys_solver);
1115 }
1116 }
1117 if !((*work).settings).is_null() {
1118 exitflag = unload_linsys_solver((*(*work).settings).linsys_solver);
1119 }
1120 if !((*work).pol).is_null() {
1121 if !((*(*work).pol).Alow_to_A).is_null() {
1122 free((*(*work).pol).Alow_to_A as *mut ::std::os::raw::c_void);
1123 }
1124 if !((*(*work).pol).Aupp_to_A).is_null() {
1125 free((*(*work).pol).Aupp_to_A as *mut ::std::os::raw::c_void);
1126 }
1127 if !((*(*work).pol).A_to_Alow).is_null() {
1128 free((*(*work).pol).A_to_Alow as *mut ::std::os::raw::c_void);
1129 }
1130 if !((*(*work).pol).A_to_Aupp).is_null() {
1131 free((*(*work).pol).A_to_Aupp as *mut ::std::os::raw::c_void);
1132 }
1133 if !((*(*work).pol).x).is_null() {
1134 free((*(*work).pol).x as *mut ::std::os::raw::c_void);
1135 }
1136 if !((*(*work).pol).z).is_null() {
1137 free((*(*work).pol).z as *mut ::std::os::raw::c_void);
1138 }
1139 if !((*(*work).pol).y).is_null() {
1140 free((*(*work).pol).y as *mut ::std::os::raw::c_void);
1141 }
1142 free((*work).pol as *mut ::std::os::raw::c_void);
1143 }
1144 if !((*work).rho_vec).is_null() {
1145 free((*work).rho_vec as *mut ::std::os::raw::c_void);
1146 }
1147 if !((*work).rho_inv_vec).is_null() {
1148 free((*work).rho_inv_vec as *mut ::std::os::raw::c_void);
1149 }
1150 if !((*work).constr_type).is_null() {
1151 free((*work).constr_type as *mut ::std::os::raw::c_void);
1152 }
1153 if !((*work).x).is_null() {
1154 free((*work).x as *mut ::std::os::raw::c_void);
1155 }
1156 if !((*work).z).is_null() {
1157 free((*work).z as *mut ::std::os::raw::c_void);
1158 }
1159 if !((*work).xz_tilde).is_null() {
1160 free((*work).xz_tilde as *mut ::std::os::raw::c_void);
1161 }
1162 if !((*work).x_prev).is_null() {
1163 free((*work).x_prev as *mut ::std::os::raw::c_void);
1164 }
1165 if !((*work).z_prev).is_null() {
1166 free((*work).z_prev as *mut ::std::os::raw::c_void);
1167 }
1168 if !((*work).y).is_null() {
1169 free((*work).y as *mut ::std::os::raw::c_void);
1170 }
1171 if !((*work).Ax).is_null() {
1172 free((*work).Ax as *mut ::std::os::raw::c_void);
1173 }
1174 if !((*work).Px).is_null() {
1175 free((*work).Px as *mut ::std::os::raw::c_void);
1176 }
1177 if !((*work).Aty).is_null() {
1178 free((*work).Aty as *mut ::std::os::raw::c_void);
1179 }
1180 if !((*work).delta_y).is_null() {
1181 free((*work).delta_y as *mut ::std::os::raw::c_void);
1182 }
1183 if !((*work).Atdelta_y).is_null() {
1184 free((*work).Atdelta_y as *mut ::std::os::raw::c_void);
1185 }
1186 if !((*work).delta_x).is_null() {
1187 free((*work).delta_x as *mut ::std::os::raw::c_void);
1188 }
1189 if !((*work).Pdelta_x).is_null() {
1190 free((*work).Pdelta_x as *mut ::std::os::raw::c_void);
1191 }
1192 if !((*work).Adelta_x).is_null() {
1193 free((*work).Adelta_x as *mut ::std::os::raw::c_void);
1194 }
1195 if !((*work).settings).is_null() {
1196 free((*work).settings as *mut ::std::os::raw::c_void);
1197 }
1198 if !((*work).solution).is_null() {
1199 if !((*(*work).solution).x).is_null() {
1200 free((*(*work).solution).x as *mut ::std::os::raw::c_void);
1201 }
1202 if !((*(*work).solution).y).is_null() {
1203 free((*(*work).solution).y as *mut ::std::os::raw::c_void);
1204 }
1205 free((*work).solution as *mut ::std::os::raw::c_void);
1206 }
1207 if !((*work).info).is_null() {
1208 free((*work).info as *mut ::std::os::raw::c_void);
1209 }
1210 if !((*work).timer).is_null() {
1211 free((*work).timer as *mut ::std::os::raw::c_void);
1212 }
1213 free(work as *mut ::std::os::raw::c_void);
1214 }
1215 return exitflag;
1216}
1217#[no_mangle]
1218pub unsafe extern "C" fn osqp_update_lin_cost(
1219 mut work: *mut OSQPWorkspace,
1220 mut q_new: *const c_float,
1221) -> c_int {
1222 if work.is_null() {
1223 return _osqp_error(
1224 OSQP_WORKSPACE_NOT_INIT_ERROR,
1225 (*::std::mem::transmute::<
1226 &[u8; 21],
1227 &[::std::os::raw::c_char; 21],
1228 >(b"osqp_update_lin_cost\0"))
1229 .as_ptr(),
1230 );
1231 }
1232 if (*work).clear_update_time == 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1233 (*work).clear_update_time = 0 as ::std::os::raw::c_int as c_int;
1234 (*(*work).info).update_time = 0.0f64;
1235 }
1236 osqp_tic((*work).timer);
1237 prea_vec_copy(q_new, (*(*work).data).q, (*(*work).data).n);
1238 if (*(*work).settings).scaling != 0 {
1239 vec_ew_prod(
1240 (*(*work).scaling).D,
1241 (*(*work).data).q,
1242 (*(*work).data).q,
1243 (*(*work).data).n,
1244 );
1245 vec_mult_scalar((*(*work).data).q, (*(*work).scaling).c, (*(*work).data).n);
1246 }
1247 reset_info((*work).info);
1248 let ref mut fresh49 = (*(*work).info).update_time;
1249 *fresh49 += osqp_toc((*work).timer);
1250 return 0 as ::std::os::raw::c_int as c_int;
1251}
1252#[no_mangle]
1253pub unsafe extern "C" fn osqp_update_bounds(
1254 mut work: *mut OSQPWorkspace,
1255 mut l_new: *const c_float,
1256 mut u_new: *const c_float,
1257) -> c_int {
1258 let mut i: c_int = 0;
1259 let mut exitflag: c_int = 0 as ::std::os::raw::c_int as c_int;
1260 if work.is_null() {
1261 return _osqp_error(
1262 OSQP_WORKSPACE_NOT_INIT_ERROR,
1263 (*::std::mem::transmute::<
1264 &[u8; 19],
1265 &[::std::os::raw::c_char; 19],
1266 >(b"osqp_update_bounds\0"))
1267 .as_ptr(),
1268 );
1269 }
1270 if (*work).clear_update_time == 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1271 (*work).clear_update_time = 0 as ::std::os::raw::c_int as c_int;
1272 (*(*work).info).update_time = 0.0f64;
1273 }
1274 osqp_tic((*work).timer);
1275 i = 0 as ::std::os::raw::c_int as c_int;
1276 while i < (*(*work).data).m {
1277 if *l_new.offset(i as isize) > *u_new.offset(i as isize) {
1278 printf(
1279 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1280 (*::std::mem::transmute::<
1281 &[u8; 19],
1282 &[::std::os::raw::c_char; 19],
1283 >(b"osqp_update_bounds\0"))
1284 .as_ptr(),
1285 );
1286 printf(
1287 b"lower bound must be lower than or equal to upper bound\0" as *const u8
1288 as *const ::std::os::raw::c_char,
1289 );
1290 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1291 return 1 as ::std::os::raw::c_int as c_int;
1292 }
1293 i += 1;
1294 }
1295 prea_vec_copy(l_new, (*(*work).data).l, (*(*work).data).m);
1296 prea_vec_copy(u_new, (*(*work).data).u, (*(*work).data).m);
1297 if (*(*work).settings).scaling != 0 {
1298 vec_ew_prod(
1299 (*(*work).scaling).E,
1300 (*(*work).data).l,
1301 (*(*work).data).l,
1302 (*(*work).data).m,
1303 );
1304 vec_ew_prod(
1305 (*(*work).scaling).E,
1306 (*(*work).data).u,
1307 (*(*work).data).u,
1308 (*(*work).data).m,
1309 );
1310 }
1311 reset_info((*work).info);
1312 exitflag = update_rho_vec(work);
1313 let ref mut fresh50 = (*(*work).info).update_time;
1314 *fresh50 += osqp_toc((*work).timer);
1315 return exitflag;
1316}
1317#[no_mangle]
1318pub unsafe extern "C" fn osqp_update_lower_bound(
1319 mut work: *mut OSQPWorkspace,
1320 mut l_new: *const c_float,
1321) -> c_int {
1322 let mut i: c_int = 0;
1323 let mut exitflag: c_int = 0 as ::std::os::raw::c_int as c_int;
1324 if work.is_null() {
1325 return _osqp_error(
1326 OSQP_WORKSPACE_NOT_INIT_ERROR,
1327 (*::std::mem::transmute::<
1328 &[u8; 24],
1329 &[::std::os::raw::c_char; 24],
1330 >(b"osqp_update_lower_bound\0"))
1331 .as_ptr(),
1332 );
1333 }
1334 if (*work).clear_update_time == 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1335 (*work).clear_update_time = 0 as ::std::os::raw::c_int as c_int;
1336 (*(*work).info).update_time = 0.0f64;
1337 }
1338 osqp_tic((*work).timer);
1339 prea_vec_copy(l_new, (*(*work).data).l, (*(*work).data).m);
1340 if (*(*work).settings).scaling != 0 {
1341 vec_ew_prod(
1342 (*(*work).scaling).E,
1343 (*(*work).data).l,
1344 (*(*work).data).l,
1345 (*(*work).data).m,
1346 );
1347 }
1348 i = 0 as ::std::os::raw::c_int as c_int;
1349 while i < (*(*work).data).m {
1350 if *((*(*work).data).l).offset(i as isize)
1351 > *((*(*work).data).u).offset(i as isize)
1352 {
1353 printf(
1354 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1355 (*::std::mem::transmute::<
1356 &[u8; 24],
1357 &[::std::os::raw::c_char; 24],
1358 >(b"osqp_update_lower_bound\0"))
1359 .as_ptr(),
1360 );
1361 printf(
1362 b"upper bound must be greater than or equal to lower bound\0"
1363 as *const u8 as *const ::std::os::raw::c_char,
1364 );
1365 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1366 return 1 as ::std::os::raw::c_int as c_int;
1367 }
1368 i += 1;
1369 }
1370 reset_info((*work).info);
1371 exitflag = update_rho_vec(work);
1372 let ref mut fresh51 = (*(*work).info).update_time;
1373 *fresh51 += osqp_toc((*work).timer);
1374 return exitflag;
1375}
1376#[no_mangle]
1377pub unsafe extern "C" fn osqp_update_upper_bound(
1378 mut work: *mut OSQPWorkspace,
1379 mut u_new: *const c_float,
1380) -> c_int {
1381 let mut i: c_int = 0;
1382 let mut exitflag: c_int = 0 as ::std::os::raw::c_int as c_int;
1383 if work.is_null() {
1384 return _osqp_error(
1385 OSQP_WORKSPACE_NOT_INIT_ERROR,
1386 (*::std::mem::transmute::<
1387 &[u8; 24],
1388 &[::std::os::raw::c_char; 24],
1389 >(b"osqp_update_upper_bound\0"))
1390 .as_ptr(),
1391 );
1392 }
1393 if (*work).clear_update_time == 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1394 (*work).clear_update_time = 0 as ::std::os::raw::c_int as c_int;
1395 (*(*work).info).update_time = 0.0f64;
1396 }
1397 osqp_tic((*work).timer);
1398 prea_vec_copy(u_new, (*(*work).data).u, (*(*work).data).m);
1399 if (*(*work).settings).scaling != 0 {
1400 vec_ew_prod(
1401 (*(*work).scaling).E,
1402 (*(*work).data).u,
1403 (*(*work).data).u,
1404 (*(*work).data).m,
1405 );
1406 }
1407 i = 0 as ::std::os::raw::c_int as c_int;
1408 while i < (*(*work).data).m {
1409 if *((*(*work).data).u).offset(i as isize)
1410 < *((*(*work).data).l).offset(i as isize)
1411 {
1412 printf(
1413 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1414 (*::std::mem::transmute::<
1415 &[u8; 24],
1416 &[::std::os::raw::c_char; 24],
1417 >(b"osqp_update_upper_bound\0"))
1418 .as_ptr(),
1419 );
1420 printf(
1421 b"lower bound must be lower than or equal to upper bound\0" as *const u8
1422 as *const ::std::os::raw::c_char,
1423 );
1424 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1425 return 1 as ::std::os::raw::c_int as c_int;
1426 }
1427 i += 1;
1428 }
1429 reset_info((*work).info);
1430 exitflag = update_rho_vec(work);
1431 let ref mut fresh52 = (*(*work).info).update_time;
1432 *fresh52 += osqp_toc((*work).timer);
1433 return exitflag;
1434}
1435#[no_mangle]
1436pub unsafe extern "C" fn osqp_warm_start(
1437 mut work: *mut OSQPWorkspace,
1438 mut x: *const c_float,
1439 mut y: *const c_float,
1440) -> c_int {
1441 if work.is_null() {
1442 return _osqp_error(
1443 OSQP_WORKSPACE_NOT_INIT_ERROR,
1444 (*::std::mem::transmute::<
1445 &[u8; 16],
1446 &[::std::os::raw::c_char; 16],
1447 >(b"osqp_warm_start\0"))
1448 .as_ptr(),
1449 );
1450 }
1451 if (*(*work).settings).warm_start == 0 {
1452 (*(*work).settings).warm_start = 1 as ::std::os::raw::c_int as c_int;
1453 }
1454 prea_vec_copy(x, (*work).x, (*(*work).data).n);
1455 prea_vec_copy(y, (*work).y, (*(*work).data).m);
1456 if (*(*work).settings).scaling != 0 {
1457 vec_ew_prod((*(*work).scaling).Dinv, (*work).x, (*work).x, (*(*work).data).n);
1458 vec_ew_prod((*(*work).scaling).Einv, (*work).y, (*work).y, (*(*work).data).m);
1459 vec_mult_scalar((*work).y, (*(*work).scaling).c, (*(*work).data).m);
1460 }
1461 mat_vec((*(*work).data).A, (*work).x, (*work).z, 0 as ::std::os::raw::c_int as c_int);
1462 return 0 as ::std::os::raw::c_int as c_int;
1463}
1464#[no_mangle]
1465pub unsafe extern "C" fn osqp_warm_start_x(
1466 mut work: *mut OSQPWorkspace,
1467 mut x: *const c_float,
1468) -> c_int {
1469 if work.is_null() {
1470 return _osqp_error(
1471 OSQP_WORKSPACE_NOT_INIT_ERROR,
1472 (*::std::mem::transmute::<
1473 &[u8; 18],
1474 &[::std::os::raw::c_char; 18],
1475 >(b"osqp_warm_start_x\0"))
1476 .as_ptr(),
1477 );
1478 }
1479 if (*(*work).settings).warm_start == 0 {
1480 (*(*work).settings).warm_start = 1 as ::std::os::raw::c_int as c_int;
1481 }
1482 prea_vec_copy(x, (*work).x, (*(*work).data).n);
1483 if (*(*work).settings).scaling != 0 {
1484 vec_ew_prod((*(*work).scaling).Dinv, (*work).x, (*work).x, (*(*work).data).n);
1485 }
1486 mat_vec((*(*work).data).A, (*work).x, (*work).z, 0 as ::std::os::raw::c_int as c_int);
1487 return 0 as ::std::os::raw::c_int as c_int;
1488}
1489#[no_mangle]
1490pub unsafe extern "C" fn osqp_warm_start_y(
1491 mut work: *mut OSQPWorkspace,
1492 mut y: *const c_float,
1493) -> c_int {
1494 if work.is_null() {
1495 return _osqp_error(
1496 OSQP_WORKSPACE_NOT_INIT_ERROR,
1497 (*::std::mem::transmute::<
1498 &[u8; 18],
1499 &[::std::os::raw::c_char; 18],
1500 >(b"osqp_warm_start_y\0"))
1501 .as_ptr(),
1502 );
1503 }
1504 if (*(*work).settings).warm_start == 0 {
1505 (*(*work).settings).warm_start = 1 as ::std::os::raw::c_int as c_int;
1506 }
1507 prea_vec_copy(y, (*work).y, (*(*work).data).m);
1508 if (*(*work).settings).scaling != 0 {
1509 vec_ew_prod((*(*work).scaling).Einv, (*work).y, (*work).y, (*(*work).data).m);
1510 vec_mult_scalar((*work).y, (*(*work).scaling).c, (*(*work).data).m);
1511 }
1512 return 0 as ::std::os::raw::c_int as c_int;
1513}
1514#[no_mangle]
1515pub unsafe extern "C" fn osqp_update_P(
1516 mut work: *mut OSQPWorkspace,
1517 mut Px_new: *const c_float,
1518 mut Px_new_idx: *const c_int,
1519 mut P_new_n: c_int,
1520) -> c_int {
1521 let mut i: c_int = 0;
1522 let mut exitflag: c_int = 0;
1523 let mut nnzP: c_int = 0;
1524 if work.is_null() {
1525 return _osqp_error(
1526 OSQP_WORKSPACE_NOT_INIT_ERROR,
1527 (*::std::mem::transmute::<
1528 &[u8; 14],
1529 &[::std::os::raw::c_char; 14],
1530 >(b"osqp_update_P\0"))
1531 .as_ptr(),
1532 );
1533 }
1534 if (*work).clear_update_time == 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1535 (*work).clear_update_time = 0 as ::std::os::raw::c_int as c_int;
1536 (*(*work).info).update_time = 0.0f64;
1537 }
1538 osqp_tic((*work).timer);
1539 nnzP = *((*(*(*work).data).P).p).offset((*(*(*work).data).P).n as isize);
1540 if !Px_new_idx.is_null() {
1541 if P_new_n > nnzP {
1542 printf(
1543 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1544 (*::std::mem::transmute::<
1545 &[u8; 14],
1546 &[::std::os::raw::c_char; 14],
1547 >(b"osqp_update_P\0"))
1548 .as_ptr(),
1549 );
1550 printf(
1551 b"new number of elements (%i) greater than elements in P (%i)\0"
1552 as *const u8 as *const ::std::os::raw::c_char,
1553 P_new_n as ::std::os::raw::c_int,
1554 nnzP as ::std::os::raw::c_int,
1555 );
1556 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1557 return 1 as ::std::os::raw::c_int as c_int;
1558 }
1559 }
1560 if (*(*work).settings).scaling != 0 {
1561 unscale_data(work);
1562 }
1563 if !Px_new_idx.is_null() {
1564 i = 0 as ::std::os::raw::c_int as c_int;
1565 while i < P_new_n {
1566 *((*(*(*work).data).P).x)
1567 .offset(
1568 *Px_new_idx.offset(i as isize) as isize,
1569 ) = *Px_new.offset(i as isize);
1570 i += 1;
1571 }
1572 } else {
1573 i = 0 as ::std::os::raw::c_int as c_int;
1574 while i < nnzP {
1575 *((*(*(*work).data).P).x).offset(i as isize) = *Px_new.offset(i as isize);
1576 i += 1;
1577 }
1578 }
1579 if (*(*work).settings).scaling != 0 {
1580 scale_data(work);
1581 }
1582 exitflag = ((*(*work).linsys_solver).update_matrices)
1583 .expect(
1584 "non-null function pointer",
1585 )((*work).linsys_solver, (*(*work).data).P, (*(*work).data).A);
1586 reset_info((*work).info);
1587 if exitflag < 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1588 printf(
1589 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1590 (*::std::mem::transmute::<
1591 &[u8; 14],
1592 &[::std::os::raw::c_char; 14],
1593 >(b"osqp_update_P\0"))
1594 .as_ptr(),
1595 );
1596 printf(
1597 b"new KKT matrix is not quasidefinite\0" as *const u8 as *const ::std::os::raw::c_char,
1598 );
1599 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1600 }
1601 let ref mut fresh53 = (*(*work).info).update_time;
1602 *fresh53 += osqp_toc((*work).timer);
1603 return exitflag;
1604}
1605#[no_mangle]
1606pub unsafe extern "C" fn osqp_update_A(
1607 mut work: *mut OSQPWorkspace,
1608 mut Ax_new: *const c_float,
1609 mut Ax_new_idx: *const c_int,
1610 mut A_new_n: c_int,
1611) -> c_int {
1612 let mut i: c_int = 0;
1613 let mut exitflag: c_int = 0;
1614 let mut nnzA: c_int = 0;
1615 if work.is_null() {
1616 return _osqp_error(
1617 OSQP_WORKSPACE_NOT_INIT_ERROR,
1618 (*::std::mem::transmute::<
1619 &[u8; 14],
1620 &[::std::os::raw::c_char; 14],
1621 >(b"osqp_update_A\0"))
1622 .as_ptr(),
1623 );
1624 }
1625 if (*work).clear_update_time == 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1626 (*work).clear_update_time = 0 as ::std::os::raw::c_int as c_int;
1627 (*(*work).info).update_time = 0.0f64;
1628 }
1629 osqp_tic((*work).timer);
1630 nnzA = *((*(*(*work).data).A).p).offset((*(*(*work).data).A).n as isize);
1631 if !Ax_new_idx.is_null() {
1632 if A_new_n > nnzA {
1633 printf(
1634 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1635 (*::std::mem::transmute::<
1636 &[u8; 14],
1637 &[::std::os::raw::c_char; 14],
1638 >(b"osqp_update_A\0"))
1639 .as_ptr(),
1640 );
1641 printf(
1642 b"new number of elements (%i) greater than elements in A (%i)\0"
1643 as *const u8 as *const ::std::os::raw::c_char,
1644 A_new_n as ::std::os::raw::c_int,
1645 nnzA as ::std::os::raw::c_int,
1646 );
1647 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1648 return 1 as ::std::os::raw::c_int as c_int;
1649 }
1650 }
1651 if (*(*work).settings).scaling != 0 {
1652 unscale_data(work);
1653 }
1654 if !Ax_new_idx.is_null() {
1655 i = 0 as ::std::os::raw::c_int as c_int;
1656 while i < A_new_n {
1657 *((*(*(*work).data).A).x)
1658 .offset(
1659 *Ax_new_idx.offset(i as isize) as isize,
1660 ) = *Ax_new.offset(i as isize);
1661 i += 1;
1662 }
1663 } else {
1664 i = 0 as ::std::os::raw::c_int as c_int;
1665 while i < nnzA {
1666 *((*(*(*work).data).A).x).offset(i as isize) = *Ax_new.offset(i as isize);
1667 i += 1;
1668 }
1669 }
1670 if (*(*work).settings).scaling != 0 {
1671 scale_data(work);
1672 }
1673 exitflag = ((*(*work).linsys_solver).update_matrices)
1674 .expect(
1675 "non-null function pointer",
1676 )((*work).linsys_solver, (*(*work).data).P, (*(*work).data).A);
1677 reset_info((*work).info);
1678 if exitflag < 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1679 printf(
1680 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1681 (*::std::mem::transmute::<
1682 &[u8; 14],
1683 &[::std::os::raw::c_char; 14],
1684 >(b"osqp_update_A\0"))
1685 .as_ptr(),
1686 );
1687 printf(
1688 b"new KKT matrix is not quasidefinite\0" as *const u8 as *const ::std::os::raw::c_char,
1689 );
1690 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1691 }
1692 let ref mut fresh54 = (*(*work).info).update_time;
1693 *fresh54 += osqp_toc((*work).timer);
1694 return exitflag;
1695}
1696#[no_mangle]
1697pub unsafe extern "C" fn osqp_update_P_A(
1698 mut work: *mut OSQPWorkspace,
1699 mut Px_new: *const c_float,
1700 mut Px_new_idx: *const c_int,
1701 mut P_new_n: c_int,
1702 mut Ax_new: *const c_float,
1703 mut Ax_new_idx: *const c_int,
1704 mut A_new_n: c_int,
1705) -> c_int {
1706 let mut i: c_int = 0;
1707 let mut exitflag: c_int = 0;
1708 let mut nnzP: c_int = 0;
1709 let mut nnzA: c_int = 0;
1710 if work.is_null() {
1711 return _osqp_error(
1712 OSQP_WORKSPACE_NOT_INIT_ERROR,
1713 (*::std::mem::transmute::<
1714 &[u8; 16],
1715 &[::std::os::raw::c_char; 16],
1716 >(b"osqp_update_P_A\0"))
1717 .as_ptr(),
1718 );
1719 }
1720 if (*work).clear_update_time == 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1721 (*work).clear_update_time = 0 as ::std::os::raw::c_int as c_int;
1722 (*(*work).info).update_time = 0.0f64;
1723 }
1724 osqp_tic((*work).timer);
1725 nnzP = *((*(*(*work).data).P).p).offset((*(*(*work).data).P).n as isize);
1726 nnzA = *((*(*(*work).data).A).p).offset((*(*(*work).data).A).n as isize);
1727 if !Px_new_idx.is_null() {
1728 if P_new_n > nnzP {
1729 printf(
1730 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1731 (*::std::mem::transmute::<
1732 &[u8; 16],
1733 &[::std::os::raw::c_char; 16],
1734 >(b"osqp_update_P_A\0"))
1735 .as_ptr(),
1736 );
1737 printf(
1738 b"new number of elements (%i) greater than elements in P (%i)\0"
1739 as *const u8 as *const ::std::os::raw::c_char,
1740 P_new_n as ::std::os::raw::c_int,
1741 nnzP as ::std::os::raw::c_int,
1742 );
1743 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1744 return 1 as ::std::os::raw::c_int as c_int;
1745 }
1746 }
1747 if !Ax_new_idx.is_null() {
1748 if A_new_n > nnzA {
1749 printf(
1750 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1751 (*::std::mem::transmute::<
1752 &[u8; 16],
1753 &[::std::os::raw::c_char; 16],
1754 >(b"osqp_update_P_A\0"))
1755 .as_ptr(),
1756 );
1757 printf(
1758 b"new number of elements (%i) greater than elements in A (%i)\0"
1759 as *const u8 as *const ::std::os::raw::c_char,
1760 A_new_n as ::std::os::raw::c_int,
1761 nnzA as ::std::os::raw::c_int,
1762 );
1763 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1764 return 2 as ::std::os::raw::c_int as c_int;
1765 }
1766 }
1767 if (*(*work).settings).scaling != 0 {
1768 unscale_data(work);
1769 }
1770 if !Px_new_idx.is_null() {
1771 i = 0 as ::std::os::raw::c_int as c_int;
1772 while i < P_new_n {
1773 *((*(*(*work).data).P).x)
1774 .offset(
1775 *Px_new_idx.offset(i as isize) as isize,
1776 ) = *Px_new.offset(i as isize);
1777 i += 1;
1778 }
1779 } else {
1780 i = 0 as ::std::os::raw::c_int as c_int;
1781 while i < nnzP {
1782 *((*(*(*work).data).P).x).offset(i as isize) = *Px_new.offset(i as isize);
1783 i += 1;
1784 }
1785 }
1786 if !Ax_new_idx.is_null() {
1787 i = 0 as ::std::os::raw::c_int as c_int;
1788 while i < A_new_n {
1789 *((*(*(*work).data).A).x)
1790 .offset(
1791 *Ax_new_idx.offset(i as isize) as isize,
1792 ) = *Ax_new.offset(i as isize);
1793 i += 1;
1794 }
1795 } else {
1796 i = 0 as ::std::os::raw::c_int as c_int;
1797 while i < nnzA {
1798 *((*(*(*work).data).A).x).offset(i as isize) = *Ax_new.offset(i as isize);
1799 i += 1;
1800 }
1801 }
1802 if (*(*work).settings).scaling != 0 {
1803 scale_data(work);
1804 }
1805 exitflag = ((*(*work).linsys_solver).update_matrices)
1806 .expect(
1807 "non-null function pointer",
1808 )((*work).linsys_solver, (*(*work).data).P, (*(*work).data).A);
1809 reset_info((*work).info);
1810 if exitflag < 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1811 printf(
1812 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1813 (*::std::mem::transmute::<
1814 &[u8; 16],
1815 &[::std::os::raw::c_char; 16],
1816 >(b"osqp_update_P_A\0"))
1817 .as_ptr(),
1818 );
1819 printf(
1820 b"new KKT matrix is not quasidefinite\0" as *const u8 as *const ::std::os::raw::c_char,
1821 );
1822 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1823 }
1824 let ref mut fresh55 = (*(*work).info).update_time;
1825 *fresh55 += osqp_toc((*work).timer);
1826 return exitflag;
1827}
1828#[no_mangle]
1829pub unsafe extern "C" fn osqp_update_rho(
1830 mut work: *mut OSQPWorkspace,
1831 mut rho_new: c_float,
1832) -> c_int {
1833 let mut exitflag: c_int = 0;
1834 let mut i: c_int = 0;
1835 if work.is_null() {
1836 return _osqp_error(
1837 OSQP_WORKSPACE_NOT_INIT_ERROR,
1838 (*::std::mem::transmute::<
1839 &[u8; 16],
1840 &[::std::os::raw::c_char; 16],
1841 >(b"osqp_update_rho\0"))
1842 .as_ptr(),
1843 );
1844 }
1845 if rho_new <= 0 as ::std::os::raw::c_int as ::std::os::raw::c_double {
1846 printf(
1847 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1848 (*::std::mem::transmute::<
1849 &[u8; 16],
1850 &[::std::os::raw::c_char; 16],
1851 >(b"osqp_update_rho\0"))
1852 .as_ptr(),
1853 );
1854 printf(b"rho must be positive\0" as *const u8 as *const ::std::os::raw::c_char);
1855 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1856 return 1 as ::std::os::raw::c_int as c_int;
1857 }
1858 if (*work).rho_update_from_solve == 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1859 if (*work).clear_update_time == 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1860 (*work).clear_update_time = 0 as ::std::os::raw::c_int as c_int;
1861 (*(*work).info).update_time = 0.0f64;
1862 }
1863 osqp_tic((*work).timer);
1864 }
1865 (*(*work).settings)
1866 .rho = if (if rho_new > 1e-06f64 { rho_new } else { 1e-06f64 }) < 1e06f64 {
1867 if rho_new > 1e-06f64 { rho_new } else { 1e-06f64 }
1868 } else {
1869 1e06f64
1870 };
1871 i = 0 as ::std::os::raw::c_int as c_int;
1872 while i < (*(*work).data).m {
1873 if *((*work).constr_type).offset(i as isize)
1874 == 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
1875 {
1876 *((*work).rho_vec).offset(i as isize) = (*(*work).settings).rho;
1877 *((*work).rho_inv_vec).offset(i as isize) = 1.0f64 / (*(*work).settings).rho;
1878 } else if *((*work).constr_type).offset(i as isize)
1879 == 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
1880 {
1881 *((*work).rho_vec)
1882 .offset(i as isize) = RHO_EQ_OVER_RHO_INEQ * (*(*work).settings).rho;
1883 *((*work).rho_inv_vec)
1884 .offset(i as isize) = 1.0f64 / *((*work).rho_vec).offset(i as isize);
1885 }
1886 i += 1;
1887 }
1888 exitflag = ((*(*work).linsys_solver).update_rho_vec)
1889 .expect("non-null function pointer")((*work).linsys_solver, (*work).rho_vec);
1890 if (*work).rho_update_from_solve == 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1891 let ref mut fresh56 = (*(*work).info).update_time;
1892 *fresh56 += osqp_toc((*work).timer);
1893 }
1894 return exitflag;
1895}
1896#[no_mangle]
1897pub unsafe extern "C" fn osqp_update_max_iter(
1898 mut work: *mut OSQPWorkspace,
1899 mut max_iter_new: c_int,
1900) -> c_int {
1901 if work.is_null() {
1902 return _osqp_error(
1903 OSQP_WORKSPACE_NOT_INIT_ERROR,
1904 (*::std::mem::transmute::<
1905 &[u8; 21],
1906 &[::std::os::raw::c_char; 21],
1907 >(b"osqp_update_max_iter\0"))
1908 .as_ptr(),
1909 );
1910 }
1911 if max_iter_new <= 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
1912 printf(
1913 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1914 (*::std::mem::transmute::<
1915 &[u8; 21],
1916 &[::std::os::raw::c_char; 21],
1917 >(b"osqp_update_max_iter\0"))
1918 .as_ptr(),
1919 );
1920 printf(b"max_iter must be positive\0" as *const u8 as *const ::std::os::raw::c_char);
1921 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1922 return 1 as ::std::os::raw::c_int as c_int;
1923 }
1924 (*(*work).settings).max_iter = max_iter_new;
1925 return 0 as ::std::os::raw::c_int as c_int;
1926}
1927#[no_mangle]
1928pub unsafe extern "C" fn osqp_update_eps_abs(
1929 mut work: *mut OSQPWorkspace,
1930 mut eps_abs_new: c_float,
1931) -> c_int {
1932 if work.is_null() {
1933 return _osqp_error(
1934 OSQP_WORKSPACE_NOT_INIT_ERROR,
1935 (*::std::mem::transmute::<
1936 &[u8; 20],
1937 &[::std::os::raw::c_char; 20],
1938 >(b"osqp_update_eps_abs\0"))
1939 .as_ptr(),
1940 );
1941 }
1942 if eps_abs_new < 0.0f64 {
1943 printf(
1944 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1945 (*::std::mem::transmute::<
1946 &[u8; 20],
1947 &[::std::os::raw::c_char; 20],
1948 >(b"osqp_update_eps_abs\0"))
1949 .as_ptr(),
1950 );
1951 printf(b"eps_abs must be nonnegative\0" as *const u8 as *const ::std::os::raw::c_char);
1952 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1953 return 1 as ::std::os::raw::c_int as c_int;
1954 }
1955 (*(*work).settings).eps_abs = eps_abs_new;
1956 return 0 as ::std::os::raw::c_int as c_int;
1957}
1958#[no_mangle]
1959pub unsafe extern "C" fn osqp_update_eps_rel(
1960 mut work: *mut OSQPWorkspace,
1961 mut eps_rel_new: c_float,
1962) -> c_int {
1963 if work.is_null() {
1964 return _osqp_error(
1965 OSQP_WORKSPACE_NOT_INIT_ERROR,
1966 (*::std::mem::transmute::<
1967 &[u8; 20],
1968 &[::std::os::raw::c_char; 20],
1969 >(b"osqp_update_eps_rel\0"))
1970 .as_ptr(),
1971 );
1972 }
1973 if eps_rel_new < 0.0f64 {
1974 printf(
1975 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
1976 (*::std::mem::transmute::<
1977 &[u8; 20],
1978 &[::std::os::raw::c_char; 20],
1979 >(b"osqp_update_eps_rel\0"))
1980 .as_ptr(),
1981 );
1982 printf(b"eps_rel must be nonnegative\0" as *const u8 as *const ::std::os::raw::c_char);
1983 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
1984 return 1 as ::std::os::raw::c_int as c_int;
1985 }
1986 (*(*work).settings).eps_rel = eps_rel_new;
1987 return 0 as ::std::os::raw::c_int as c_int;
1988}
1989#[no_mangle]
1990pub unsafe extern "C" fn osqp_update_eps_prim_inf(
1991 mut work: *mut OSQPWorkspace,
1992 mut eps_prim_inf_new: c_float,
1993) -> c_int {
1994 if work.is_null() {
1995 return _osqp_error(
1996 OSQP_WORKSPACE_NOT_INIT_ERROR,
1997 (*::std::mem::transmute::<
1998 &[u8; 25],
1999 &[::std::os::raw::c_char; 25],
2000 >(b"osqp_update_eps_prim_inf\0"))
2001 .as_ptr(),
2002 );
2003 }
2004 if eps_prim_inf_new < 0.0f64 {
2005 printf(
2006 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
2007 (*::std::mem::transmute::<
2008 &[u8; 25],
2009 &[::std::os::raw::c_char; 25],
2010 >(b"osqp_update_eps_prim_inf\0"))
2011 .as_ptr(),
2012 );
2013 printf(
2014 b"eps_prim_inf must be nonnegative\0" as *const u8 as *const ::std::os::raw::c_char,
2015 );
2016 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
2017 return 1 as ::std::os::raw::c_int as c_int;
2018 }
2019 (*(*work).settings).eps_prim_inf = eps_prim_inf_new;
2020 return 0 as ::std::os::raw::c_int as c_int;
2021}
2022#[no_mangle]
2023pub unsafe extern "C" fn osqp_update_eps_dual_inf(
2024 mut work: *mut OSQPWorkspace,
2025 mut eps_dual_inf_new: c_float,
2026) -> c_int {
2027 if work.is_null() {
2028 return _osqp_error(
2029 OSQP_WORKSPACE_NOT_INIT_ERROR,
2030 (*::std::mem::transmute::<
2031 &[u8; 25],
2032 &[::std::os::raw::c_char; 25],
2033 >(b"osqp_update_eps_dual_inf\0"))
2034 .as_ptr(),
2035 );
2036 }
2037 if eps_dual_inf_new < 0.0f64 {
2038 printf(
2039 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
2040 (*::std::mem::transmute::<
2041 &[u8; 25],
2042 &[::std::os::raw::c_char; 25],
2043 >(b"osqp_update_eps_dual_inf\0"))
2044 .as_ptr(),
2045 );
2046 printf(
2047 b"eps_dual_inf must be nonnegative\0" as *const u8 as *const ::std::os::raw::c_char,
2048 );
2049 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
2050 return 1 as ::std::os::raw::c_int as c_int;
2051 }
2052 (*(*work).settings).eps_dual_inf = eps_dual_inf_new;
2053 return 0 as ::std::os::raw::c_int as c_int;
2054}
2055#[no_mangle]
2056pub unsafe extern "C" fn osqp_update_alpha(
2057 mut work: *mut OSQPWorkspace,
2058 mut alpha_new: c_float,
2059) -> c_int {
2060 if work.is_null() {
2061 return _osqp_error(
2062 OSQP_WORKSPACE_NOT_INIT_ERROR,
2063 (*::std::mem::transmute::<
2064 &[u8; 18],
2065 &[::std::os::raw::c_char; 18],
2066 >(b"osqp_update_alpha\0"))
2067 .as_ptr(),
2068 );
2069 }
2070 if alpha_new <= 0.0f64 || alpha_new >= 2.0f64 {
2071 printf(
2072 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
2073 (*::std::mem::transmute::<
2074 &[u8; 18],
2075 &[::std::os::raw::c_char; 18],
2076 >(b"osqp_update_alpha\0"))
2077 .as_ptr(),
2078 );
2079 printf(b"alpha must be between 0 and 2\0" as *const u8 as *const ::std::os::raw::c_char);
2080 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
2081 return 1 as ::std::os::raw::c_int as c_int;
2082 }
2083 (*(*work).settings).alpha = alpha_new;
2084 return 0 as ::std::os::raw::c_int as c_int;
2085}
2086#[no_mangle]
2087pub unsafe extern "C" fn osqp_update_warm_start(
2088 mut work: *mut OSQPWorkspace,
2089 mut warm_start_new: c_int,
2090) -> c_int {
2091 if work.is_null() {
2092 return _osqp_error(
2093 OSQP_WORKSPACE_NOT_INIT_ERROR,
2094 (*::std::mem::transmute::<
2095 &[u8; 23],
2096 &[::std::os::raw::c_char; 23],
2097 >(b"osqp_update_warm_start\0"))
2098 .as_ptr(),
2099 );
2100 }
2101 if warm_start_new != 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
2102 && warm_start_new != 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
2103 {
2104 printf(
2105 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
2106 (*::std::mem::transmute::<
2107 &[u8; 23],
2108 &[::std::os::raw::c_char; 23],
2109 >(b"osqp_update_warm_start\0"))
2110 .as_ptr(),
2111 );
2112 printf(
2113 b"warm_start should be either 0 or 1\0" as *const u8 as *const ::std::os::raw::c_char,
2114 );
2115 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
2116 return 1 as ::std::os::raw::c_int as c_int;
2117 }
2118 (*(*work).settings).warm_start = warm_start_new;
2119 return 0 as ::std::os::raw::c_int as c_int;
2120}
2121#[no_mangle]
2122pub unsafe extern "C" fn osqp_update_scaled_termination(
2123 mut work: *mut OSQPWorkspace,
2124 mut scaled_termination_new: c_int,
2125) -> c_int {
2126 if work.is_null() {
2127 return _osqp_error(
2128 OSQP_WORKSPACE_NOT_INIT_ERROR,
2129 (*::std::mem::transmute::<
2130 &[u8; 31],
2131 &[::std::os::raw::c_char; 31],
2132 >(b"osqp_update_scaled_termination\0"))
2133 .as_ptr(),
2134 );
2135 }
2136 if scaled_termination_new != 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
2137 && scaled_termination_new != 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
2138 {
2139 printf(
2140 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
2141 (*::std::mem::transmute::<
2142 &[u8; 31],
2143 &[::std::os::raw::c_char; 31],
2144 >(b"osqp_update_scaled_termination\0"))
2145 .as_ptr(),
2146 );
2147 printf(
2148 b"scaled_termination should be either 0 or 1\0" as *const u8
2149 as *const ::std::os::raw::c_char,
2150 );
2151 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
2152 return 1 as ::std::os::raw::c_int as c_int;
2153 }
2154 (*(*work).settings).scaled_termination = scaled_termination_new;
2155 return 0 as ::std::os::raw::c_int as c_int;
2156}
2157#[no_mangle]
2158pub unsafe extern "C" fn osqp_update_check_termination(
2159 mut work: *mut OSQPWorkspace,
2160 mut check_termination_new: c_int,
2161) -> c_int {
2162 if work.is_null() {
2163 return _osqp_error(
2164 OSQP_WORKSPACE_NOT_INIT_ERROR,
2165 (*::std::mem::transmute::<
2166 &[u8; 30],
2167 &[::std::os::raw::c_char; 30],
2168 >(b"osqp_update_check_termination\0"))
2169 .as_ptr(),
2170 );
2171 }
2172 if check_termination_new < 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
2173 printf(
2174 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
2175 (*::std::mem::transmute::<
2176 &[u8; 30],
2177 &[::std::os::raw::c_char; 30],
2178 >(b"osqp_update_check_termination\0"))
2179 .as_ptr(),
2180 );
2181 printf(
2182 b"check_termination should be nonnegative\0" as *const u8
2183 as *const ::std::os::raw::c_char,
2184 );
2185 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
2186 return 1 as ::std::os::raw::c_int as c_int;
2187 }
2188 (*(*work).settings).check_termination = check_termination_new;
2189 return 0 as ::std::os::raw::c_int as c_int;
2190}
2191#[no_mangle]
2192pub unsafe extern "C" fn osqp_update_delta(
2193 mut work: *mut OSQPWorkspace,
2194 mut delta_new: c_float,
2195) -> c_int {
2196 if work.is_null() {
2197 return _osqp_error(
2198 OSQP_WORKSPACE_NOT_INIT_ERROR,
2199 (*::std::mem::transmute::<
2200 &[u8; 18],
2201 &[::std::os::raw::c_char; 18],
2202 >(b"osqp_update_delta\0"))
2203 .as_ptr(),
2204 );
2205 }
2206 if delta_new <= 0.0f64 {
2207 printf(
2208 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
2209 (*::std::mem::transmute::<
2210 &[u8; 18],
2211 &[::std::os::raw::c_char; 18],
2212 >(b"osqp_update_delta\0"))
2213 .as_ptr(),
2214 );
2215 printf(b"delta must be positive\0" as *const u8 as *const ::std::os::raw::c_char);
2216 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
2217 return 1 as ::std::os::raw::c_int as c_int;
2218 }
2219 (*(*work).settings).delta = delta_new;
2220 return 0 as ::std::os::raw::c_int as c_int;
2221}
2222#[no_mangle]
2223pub unsafe extern "C" fn osqp_update_polish(
2224 mut work: *mut OSQPWorkspace,
2225 mut polish_new: c_int,
2226) -> c_int {
2227 if work.is_null() {
2228 return _osqp_error(
2229 OSQP_WORKSPACE_NOT_INIT_ERROR,
2230 (*::std::mem::transmute::<
2231 &[u8; 19],
2232 &[::std::os::raw::c_char; 19],
2233 >(b"osqp_update_polish\0"))
2234 .as_ptr(),
2235 );
2236 }
2237 if polish_new != 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
2238 && polish_new != 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
2239 {
2240 printf(
2241 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
2242 (*::std::mem::transmute::<
2243 &[u8; 19],
2244 &[::std::os::raw::c_char; 19],
2245 >(b"osqp_update_polish\0"))
2246 .as_ptr(),
2247 );
2248 printf(b"polish should be either 0 or 1\0" as *const u8 as *const ::std::os::raw::c_char);
2249 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
2250 return 1 as ::std::os::raw::c_int as c_int;
2251 }
2252 (*(*work).settings).polish = polish_new;
2253 (*(*work).info).polish_time = 0.0f64;
2254 return 0 as ::std::os::raw::c_int as c_int;
2255}
2256#[no_mangle]
2257pub unsafe extern "C" fn osqp_update_polish_refine_iter(
2258 mut work: *mut OSQPWorkspace,
2259 mut polish_refine_iter_new: c_int,
2260) -> c_int {
2261 if work.is_null() {
2262 return _osqp_error(
2263 OSQP_WORKSPACE_NOT_INIT_ERROR,
2264 (*::std::mem::transmute::<
2265 &[u8; 31],
2266 &[::std::os::raw::c_char; 31],
2267 >(b"osqp_update_polish_refine_iter\0"))
2268 .as_ptr(),
2269 );
2270 }
2271 if polish_refine_iter_new < 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong {
2272 printf(
2273 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
2274 (*::std::mem::transmute::<
2275 &[u8; 31],
2276 &[::std::os::raw::c_char; 31],
2277 >(b"osqp_update_polish_refine_iter\0"))
2278 .as_ptr(),
2279 );
2280 printf(
2281 b"polish_refine_iter must be nonnegative\0" as *const u8
2282 as *const ::std::os::raw::c_char,
2283 );
2284 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
2285 return 1 as ::std::os::raw::c_int as c_int;
2286 }
2287 (*(*work).settings).polish_refine_iter = polish_refine_iter_new;
2288 return 0 as ::std::os::raw::c_int as c_int;
2289}
2290#[no_mangle]
2291pub unsafe extern "C" fn osqp_update_verbose(
2292 mut work: *mut OSQPWorkspace,
2293 mut verbose_new: c_int,
2294) -> c_int {
2295 if work.is_null() {
2296 return _osqp_error(
2297 OSQP_WORKSPACE_NOT_INIT_ERROR,
2298 (*::std::mem::transmute::<
2299 &[u8; 20],
2300 &[::std::os::raw::c_char; 20],
2301 >(b"osqp_update_verbose\0"))
2302 .as_ptr(),
2303 );
2304 }
2305 if verbose_new != 0 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
2306 && verbose_new != 1 as ::std::os::raw::c_int as ::std::os::raw::c_longlong
2307 {
2308 printf(
2309 b"ERROR in %s: \0" as *const u8 as *const ::std::os::raw::c_char,
2310 (*::std::mem::transmute::<
2311 &[u8; 20],
2312 &[::std::os::raw::c_char; 20],
2313 >(b"osqp_update_verbose\0"))
2314 .as_ptr(),
2315 );
2316 printf(b"verbose should be either 0 or 1\0" as *const u8 as *const ::std::os::raw::c_char);
2317 printf(b"\n\0" as *const u8 as *const ::std::os::raw::c_char);
2318 return 1 as ::std::os::raw::c_int as c_int;
2319 }
2320 (*(*work).settings).verbose = verbose_new;
2321 return 0 as ::std::os::raw::c_int as c_int;
2322}
2323#[no_mangle]
2324pub unsafe extern "C" fn osqp_update_time_limit(
2325 mut work: *mut OSQPWorkspace,
2326 mut time_limit_new: c_float,
2327) -> c_int {
2328 if work.is_null() {
2329 return _osqp_error(
2330 OSQP_WORKSPACE_NOT_INIT_ERROR,
2331 (*::std::mem::transmute::<
2332 &[u8; 23],
2333 &[::std::os::raw::c_char; 23],
2334 >(b"osqp_update_time_limit\0"))
2335 .as_ptr(),
2336 );
2337 }
2338 if time_limit_new < 0.0f64 {
2339 printf(
2340 b"time_limit must be nonnegative\n\0" as *const u8 as *const ::std::os::raw::c_char,
2341 );
2342 return 1 as ::std::os::raw::c_int as c_int;
2343 }
2344 (*(*work).settings).time_limit = time_limit_new;
2345 return 0 as ::std::os::raw::c_int as c_int;
2346}