casadi_runtime.hpp
1 /*
2  * This file is part of CasADi.
3  *
4  * CasADi -- A symbolic framework for dynamic optimization.
5  * Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
6  * KU Leuven. All rights reserved.
7  * Copyright (C) 2011-2014 Greg Horn
8  *
9  * CasADi is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 3 of the License, or (at your option) any later version.
13  *
14  * CasADi is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with CasADi; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  *
23  */
24 
25 
26 #ifndef CASADI_CASADI_RUNTIME_HPP
27 #define CASADI_CASADI_RUNTIME_HPP
28 
29 #include "../calculus.hpp"
30 #ifndef SWIG
31 #include <casadi/core/casadi_export.h>
32 #endif // SWIG
33 
34 #define CASADI_PREFIX(ID) casadi_##ID
35 #define CASADI_CAST(TYPE, ARG) static_cast<TYPE>(ARG)
36 
38 namespace casadi {
40  template<typename T1>
41  void casadi_copy(const T1* x, casadi_int n, T1* y);
42 
44  template<typename T1>
45  void casadi_swap(casadi_int n, T1* x, casadi_int inc_x, T1* y, casadi_int inc_y);
46 
48  template<typename T1>
49  void casadi_project(const T1* x, const casadi_int* sp_x, T1* y, const casadi_int* sp_y, T1* w);
50 
52  template<typename T1, typename T2>
53  void casadi_densify(const T1* x, const casadi_int* sp_x, T2* y, casadi_int tr);
54 
56  template<typename T1, typename T2>
57  void casadi_sparsify(const T1* x, T2* y, const casadi_int* sp_y, casadi_int tr);
58 
60  template<typename T1>
61  void casadi_scal(casadi_int n, T1 alpha, T1* x);
62 
64  template<typename T1>
65  void casadi_axpy(casadi_int n, T1 alpha, const T1* x, T1* y);
66 
68  template<typename T1>
69  T1 casadi_dot(casadi_int n, const T1* x, const T1* y);
70 
72  template<typename T1>
73  T1 casadi_max_viol(casadi_int n, const T1* x, const T1* lb, const T1* ub);
74 
76  template<typename T1>
77  T1 casadi_sum_viol(casadi_int n, const T1* x, const T1* lb, const T1* ub);
78 
80  template<typename T1>
81  casadi_int casadi_iamax(casadi_int n, const T1* x, casadi_int inc_x);
82 
84  template<typename T1>
85  void casadi_clear(T1* x, casadi_int n);
86 
88  template<typename T1>
89  void casadi_fill(T1* x, casadi_int n, T1 alpha);
90 
92  template<typename T1>
93  void casadi_mtimes(const T1* x, const casadi_int* sp_x, const T1* y, const casadi_int* sp_y,
94  T1* z, const casadi_int* sp_z, T1* w, casadi_int tr);
95 
97  template<typename T1>
98  void casadi_mtimes_dense(const T1* x, casadi_int nrow_x, casadi_int ncol_x,
99  const T1* y, casadi_int ncol_y, T1* z, casadi_int tr);
100 
102  template<typename T1>
103  void casadi_mtimes_dense_sparse(const T1* x, casadi_int nrow_x,
104  const T1* y, const casadi_int* sp_y, T1* z);
105 
107  template<typename T1>
108  void casadi_mv(const T1* x, const casadi_int* sp_x, const T1* y, T1* z, casadi_int tr);
109 
111  template<typename T1>
112  void casadi_triusolve(const casadi_int* sp_a, const T1* nz_a, T1* x, int tr, int unity,
113  casadi_int nrhs);
114 
116  template<typename T1>
117  void casadi_trilsolve(const casadi_int* sp_a, const T1* nz_a, T1* x, int tr, int unity,
118  casadi_int nrhs);
119 
121  template<typename T1>
122  void casadi_trans(const T1* x, const casadi_int* sp_x, T1* y, const casadi_int* sp_y,
123  casadi_int* tmp);
124 
126  template<typename T1>
127  T1 casadi_norm_1(casadi_int n, const T1* x);
128 
130  template<typename T1>
131  T1 casadi_norm_2(casadi_int n, const T1* x);
132 
133 #if !defined(SWIG) && defined(CASADI_L1_BLAS)
134  typedef void (*casadi_daxpy_t)(casadi_int, double, const double*, double*);
135  typedef double (*casadi_ddot_t )(casadi_int, const double*, const double*);
136  typedef void (*casadi_dscal_t)(casadi_int, double, double*);
137  typedef double (*casadi_dnrm2_t)(casadi_int, const double*);
138  typedef double (*casadi_dasum_t)(casadi_int, const double*);
139  typedef void (*casadi_dcopy_t)(const double*, casadi_int, double*);
140  extern CASADI_EXPORT casadi_daxpy_t casadi_daxpy_hook;
141  extern CASADI_EXPORT casadi_ddot_t casadi_ddot_hook;
142  extern CASADI_EXPORT casadi_dscal_t casadi_dscal_hook;
143  extern CASADI_EXPORT casadi_dnrm2_t casadi_dnrm2_hook;
144  extern CASADI_EXPORT casadi_dasum_t casadi_dasum_hook;
145  extern CASADI_EXPORT casadi_dcopy_t casadi_dcopy_hook;
146  inline void casadi_axpy(casadi_int n, double alpha, const double* x, double* y) {
147  if (casadi_daxpy_hook) { casadi_daxpy_hook(n, alpha, x, y); return; }
148  casadi_axpy<double>(n, alpha, x, y);
149  }
150  inline double casadi_dot(casadi_int n, const double* x, const double* y) {
151  if (casadi_ddot_hook) return casadi_ddot_hook(n, x, y);
152  return casadi_dot<double>(n, x, y);
153  }
154  inline void casadi_scal(casadi_int n, double alpha, double* x) {
155  if (casadi_dscal_hook) { casadi_dscal_hook(n, alpha, x); return; }
156  casadi_scal<double>(n, alpha, x);
157  }
158  inline double casadi_norm_2(casadi_int n, const double* x) {
159  if (casadi_dnrm2_hook) return casadi_dnrm2_hook(n, x);
160  return casadi_norm_2<double>(n, x);
161  }
162  inline double casadi_norm_1(casadi_int n, const double* x) {
163  if (casadi_dasum_hook) return casadi_dasum_hook(n, x);
164  return casadi_norm_1<double>(n, x);
165  }
166  inline void casadi_copy(const double* x, casadi_int n, double* y) {
167  if (casadi_dcopy_hook) { casadi_dcopy_hook(x, n, y); return; }
168  casadi_copy<double>(x, n, y);
169  }
170 #endif // !SWIG && CASADI_L1_BLAS
171 
175  template<typename T1>
176  T1 casadi_norm_inf(casadi_int n, const T1* x);
177 
184  template<typename T1>
185  T1 casadi_norm_inf_mul(const T1* x, const casadi_int* sp_x, const T1* y, const casadi_int* sp_y,
186  T1* dwork, casadi_int* iwork);
187 
189  template<typename T1>
190  T1 casadi_bilin(const T1* A, const casadi_int* sp_A, const T1* x, const T1* y);
191 
193  template<typename T1>
194  void casadi_kron(const T1* a, const casadi_int* sp_a, const T1* b, const casadi_int* sp_b, T1* r);
195 
197  template<typename T1>
198  void casadi_kron_dense(const T1* a, casadi_int mA, casadi_int nA,
199  const T1* b, casadi_int mB, casadi_int nB, T1* r);
200 
202  template<typename T1>
203  void casadi_kron_dense_sparse(const T1* a, casadi_int mA, casadi_int nA,
204  const T1* b, const casadi_int* sp_b, T1* r);
205 
207  template<typename T1>
208  void casadi_kron_sparse_dense(const T1* a, const casadi_int* sp_a,
209  const T1* b, casadi_int mB, casadi_int nB, T1* r);
210 
212  template<typename T1>
213  void casadi_kron_contract_inner(const T1* m, const casadi_int* sp_m,
214  const T1* b, const casadi_int* sp_b,
215  T1* y, const casadi_int* sp_y, T1* w);
216 
218  template<typename T1>
219  void casadi_kron_contract_inner_dense(const T1* m, casadi_int mA, casadi_int nA,
220  const T1* b, casadi_int mB, casadi_int nB,
221  T1* y);
222 
224  template<typename T1>
225  void casadi_kron_contract_inner_dense_sparse(const T1* m, casadi_int mA, casadi_int nA,
226  const T1* b, const casadi_int* sp_b,
227  T1* y);
228 
230  template<typename T1>
231  void casadi_kron_contract_inner_sparse_dense(const T1* m, const casadi_int* sp_m,
232  const T1* b, casadi_int mB, casadi_int nB,
233  T1* y, const casadi_int* sp_y);
234 
236  template<typename T1>
237  void casadi_kron_contract_outer(const T1* m, const casadi_int* sp_m,
238  const T1* a, const casadi_int* sp_a,
239  T1* y, const casadi_int* sp_y, T1* w);
240 
242  template<typename T1>
243  void casadi_kron_contract_outer_dense(const T1* m, casadi_int mB, casadi_int nB,
244  const T1* a, casadi_int mA, casadi_int nA,
245  T1* y);
246 
248  template<typename T1>
249  void casadi_kron_contract_outer_dense_sparse(const T1* m, casadi_int mB, casadi_int nB,
250  const T1* a, const casadi_int* sp_a,
251  T1* y);
252 
254  template<typename T1>
255  void casadi_kron_contract_outer_sparse_dense(const T1* m, const casadi_int* sp_m,
256  const T1* a, casadi_int mA, casadi_int nA,
257  T1* y, const casadi_int* sp_y);
258 
260  template<typename T1>
261  void casadi_rank1(T1* A, const casadi_int* sp_A, T1 alpha, const T1* x);
262 
264  template<typename T1>
265  void casadi_getu(const T1* x, const casadi_int* sp_x, T1* v);
266 
268  template<typename T1>
269  T1 casadi_polyval(const T1* p, casadi_int n, T1 x);
270 
271  // Loop over corners of a hypercube
272  casadi_int casadi_flip(casadi_int* corner, casadi_int ndim);
273 
274  // Find the interval to which a value belongs
275  template<typename T1>
276  casadi_int casadi_low(T1 x, const T1* grid, casadi_int ng, casadi_int lookup_mode);
277 
278  // Get weights for the multilinear interpolant
279  template<typename T1>
280  void casadi_interpn_weights(casadi_int ndim, const T1* grid, const casadi_int* offset,
281  const T1* x, T1* alpha, casadi_int* index);
282 
283  // Get coefficients for the multilinear interpolant
284  template<typename T1>
285  T1 casadi_interpn_interpolate(casadi_int ndim, const casadi_int* offset, const T1* values,
286  const T1* alpha, const casadi_int* index,
287  const casadi_int* corner, T1* coeff);
288 
289  // Multilinear interpolant
290  template<typename T1>
291  T1 casadi_interpn(casadi_int ndim, const T1* grid, const casadi_int* offset, const T1* values,
292  const T1* x, casadi_int* iw, T1* w);
293 
294  // Multilinear interpolant - calculate gradient
295  template<typename T1>
296  void casadi_interpn_grad(T1* grad, casadi_int ndim, const T1* grid, const casadi_int* offset,
297  const T1* values, const T1* x, casadi_int* iw, T1* w);
298 
299  // De boor single basis evaluation
300  template<typename T1>
301  void casadi_de_boor(T1 x, const T1* knots, casadi_int n_knots, casadi_int degree, T1* boor);
302 
303  // Tensor times vector (ttv) in all modes — recursive multi-mode contraction
304  template<typename T1>
305  void casadi_tensor_ttv(T1* ret, casadi_int dim, casadi_int n_dims,
306  const T1* all_w, const casadi_int* w_offset,
307  const casadi_int* starts, const casadi_int* strides,
308  const T1* c, casadi_int m,
309  T1 weight, casadi_int offset);
310 
311  // De boor nd evaluation
312  template<typename T1>
313  void casadi_nd_boor_eval(T1* ret, casadi_int n_dims, const T1* knots, const casadi_int* offset,
314  const casadi_int* degree, const casadi_int* strides, const T1* c,
315  casadi_int m,
316  const T1* x, const casadi_int* lookup_mode, casadi_int* iw, T1* w);
317 
318  template<typename T1>
319  T1 casadi_mmax(const T1* x, casadi_int n, T1 is_dense);
320 
321  template<typename T1>
322  T1 casadi_mmin(const T1* x, casadi_int n, casadi_int is_dense);
323 
324  template<typename T1>
325  T1 casadi_vfmax(const T1* x, casadi_int n, T1 r);
326 
327  template<typename T1>
328  T1 casadi_vfmin(const T1* x, casadi_int n, T1 r);
329 
330  // Alias names
331  inline void casadi_fill_casadi_int(casadi_int* x, casadi_int n, casadi_int alpha) {
332  casadi_fill(x, n, alpha);
333  }
334 
335  // Alias names
336  inline void casadi_clear_casadi_int(casadi_int* x, casadi_int n) {
337  casadi_clear(x, n);
338  }
339 
340  template<typename T1>
341  void casadi_bound_consistency(casadi_int n, T1* x, T1* lam,
342  const T1* lbx, const T1* ubx);
343 
344  // Numerically accurate logsumexp
345  template<typename T1>
346  T1 casadi_logsumexp(const T1* x, casadi_int n);
347 
348  template <class T1>
349  struct casadi_newton_mem;
350 
351  // Newton step
352  template<typename T1>
353  int casadi_newton(const casadi_newton_mem<T1>* m);
354 
355  // Dense matrix multiplication
356  #define CASADI_GEMM_NT(M, N, K, A, LDA, B, LDB, C, LDC) \
357  for (i=0, rr=C; i<M; ++i) \
358  for (j=0; j<N; ++j, ++rr) \
359  for (k=0, ss=A+i*LDA, tt=B+j*LDB; k<K; ++k) \
360  *rr += *ss++**tt++;
361 
362  // Template function implementations
363  #include "casadi_copy.hpp"
364  #include "casadi_cvx.hpp"
365  #include "casadi_swap.hpp"
366  #include "casadi_project.hpp"
367  #include "casadi_tri_project.hpp"
368  #include "casadi_densify.hpp"
369  #include "casadi_sparsify.hpp"
370  #include "casadi_scal.hpp"
371  #include "casadi_iamax.hpp"
372  #include "casadi_axpy.hpp"
373  #include "casadi_dot.hpp"
374  #include "casadi_kron.hpp"
375  #include "casadi_kron_dense.hpp"
376  #include "casadi_kron_dense_sparse.hpp"
377  #include "casadi_kron_sparse_dense.hpp"
378  #include "casadi_kron_contract_inner.hpp"
379  #include "casadi_kron_contract_inner_dense.hpp"
380  #include "casadi_kron_contract_inner_dense_sparse.hpp"
381  #include "casadi_kron_contract_inner_sparse_dense.hpp"
382  #include "casadi_kron_contract_outer.hpp"
383  #include "casadi_kron_contract_outer_dense.hpp"
384  #include "casadi_kron_contract_outer_dense_sparse.hpp"
385  #include "casadi_kron_contract_outer_sparse_dense.hpp"
386  #include "casadi_clear.hpp"
387  #include "casadi_clip_max.hpp"
388  #include "casadi_clip_min.hpp"
389  #include "casadi_fill.hpp"
390  #include "casadi_max_viol.hpp"
391  #include "casadi_mmin.hpp"
392  #include "casadi_mmax.hpp"
393  #include "casadi_vfmin.hpp"
394  #include "casadi_vfmax.hpp"
395  #include "casadi_vector_fmin.hpp"
396  #include "casadi_vector_fmax.hpp"
397  #include "casadi_sum_viol.hpp"
398  #include "casadi_mtimes.hpp"
399  #include "casadi_mtimes_dense.hpp"
400  #include "casadi_mtimes_dense_sparse.hpp"
401  #include "casadi_mv.hpp"
402  #include "casadi_trilsolve.hpp"
403  #include "casadi_triusolve.hpp"
404  #include "casadi_trans.hpp"
405  #include "casadi_norm_1.hpp"
406  #include "casadi_norm_2.hpp"
407  #include "casadi_norm_inf.hpp"
408  #include "casadi_masked_norm_inf.hpp"
409  #include "casadi_norm_inf_mul.hpp"
410  #include "casadi_bilin.hpp"
411  #include "casadi_rank1.hpp"
412  #include "casadi_low.hpp"
413  #include "casadi_flip.hpp"
414  #include "casadi_polyval.hpp"
415  #include "casadi_de_boor.hpp"
416  #include "casadi_tensor_ttv.hpp"
417  #include "casadi_nd_boor_eval.hpp"
418  #include "casadi_nd_boor_dual_eval.hpp"
419  #include "casadi_interpn_weights.hpp"
420  #include "casadi_interpn_interpolate.hpp"
421  #include "casadi_interpn.hpp"
422  #include "casadi_interpn_grad.hpp"
423  #include "casadi_mv_dense.hpp"
424  #include "casadi_finite_diff.hpp"
425  #include "casadi_file_slurp.hpp"
426  #include "casadi_ldl.hpp"
427  #include "casadi_qr.hpp"
428  #include "casadi_det.hpp"
429  #include "casadi_qp.hpp"
430  #include "casadi_qrqp.hpp"
431  #include "casadi_kkt.hpp"
432  #include "casadi_ipqp.hpp"
433  #include "casadi_oracle.hpp"
434  #include "casadi_nlp.hpp"
435  #include "casadi_sqpmethod.hpp"
436  #include "casadi_feasiblesqpmethod.hpp"
437  #include "casadi_bfgs.hpp"
438  #include "casadi_regularize.hpp"
439  #include "casadi_newton.hpp"
440  #include "casadi_bound_consistency.hpp"
441  #include "casadi_lsqr.hpp"
442  #include "casadi_dense_lsqr.hpp"
443  #include "casadi_cache.hpp"
444  #include "casadi_convexify.hpp"
445  #include "casadi_socp.hpp"
446  #include "casadi_logsumexp.hpp"
447  #include "casadi_sum.hpp"
448  #include "casadi_sparsity.hpp"
449  #include "casadi_jac.hpp"
450  #include "casadi_oracle_callback.hpp"
451  #include "casadi_ocp_block.hpp"
452  #include "casadi_scaled_copy.hpp"
453 } // namespace casadi
454 
456 
457 #endif // CASADI_CASADI_RUNTIME_HPP
casadi
The casadi namespace.
Definition: archiver.hpp:32
casadi_newton_mem
Definition: casadi_newton.hpp:23