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 
31 #define CASADI_PREFIX(ID) casadi_##ID
32 #define CASADI_CAST(TYPE, ARG) static_cast<TYPE>(ARG)
33 
35 namespace casadi {
37  template<typename T1>
38  void casadi_copy(const T1* x, casadi_int n, T1* y);
39 
41  template<typename T1>
42  void casadi_swap(casadi_int n, T1* x, casadi_int inc_x, T1* y, casadi_int inc_y);
43 
45  template<typename T1>
46  void casadi_project(const T1* x, const casadi_int* sp_x, T1* y, const casadi_int* sp_y, T1* w);
47 
49  template<typename T1, typename T2>
50  void casadi_densify(const T1* x, const casadi_int* sp_x, T2* y, casadi_int tr);
51 
53  template<typename T1, typename T2>
54  void casadi_sparsify(const T1* x, T2* y, const casadi_int* sp_y, casadi_int tr);
55 
57  template<typename T1>
58  void casadi_scal(casadi_int n, T1 alpha, T1* x);
59 
61  template<typename T1>
62  void casadi_axpy(casadi_int n, T1 alpha, const T1* x, T1* y);
63 
65  template<typename T1>
66  T1 casadi_dot(casadi_int n, const T1* x, const T1* y);
67 
69  template<typename T1>
70  T1 casadi_max_viol(casadi_int n, const T1* x, const T1* lb, const T1* ub);
71 
73  template<typename T1>
74  T1 casadi_sum_viol(casadi_int n, const T1* x, const T1* lb, const T1* ub);
75 
77  template<typename T1>
78  casadi_int casadi_iamax(casadi_int n, const T1* x, casadi_int inc_x);
79 
81  template<typename T1>
82  void casadi_clear(T1* x, casadi_int n);
83 
85  template<typename T1>
86  void casadi_fill(T1* x, casadi_int n, T1 alpha);
87 
89  template<typename T1>
90  void casadi_mtimes(const T1* x, const casadi_int* sp_x, const T1* y, const casadi_int* sp_y,
91  T1* z, const casadi_int* sp_z, T1* w, casadi_int tr);
92 
94  template<typename T1>
95  void casadi_mv(const T1* x, const casadi_int* sp_x, const T1* y, T1* z, casadi_int tr);
96 
98  template<typename T1>
99  void casadi_triusolve(const casadi_int* sp_a, const T1* nz_a, T1* x, int tr, int unity,
100  casadi_int nrhs);
101 
103  template<typename T1>
104  void casadi_trilsolve(const casadi_int* sp_a, const T1* nz_a, T1* x, int tr, int unity,
105  casadi_int nrhs);
106 
108  template<typename T1>
109  void casadi_trans(const T1* x, const casadi_int* sp_x, T1* y, const casadi_int* sp_y,
110  casadi_int* tmp);
111 
113  template<typename T1>
114  T1 casadi_norm_1(casadi_int n, const T1* x);
115 
117  template<typename T1>
118  T1 casadi_norm_2(casadi_int n, const T1* x);
119 
123  template<typename T1>
124  T1 casadi_norm_inf(casadi_int n, const T1* x);
125 
132  template<typename T1>
133  T1 casadi_norm_inf_mul(const T1* x, const casadi_int* sp_x, const T1* y, const casadi_int* sp_y,
134  T1* dwork, casadi_int* iwork);
135 
137  template<typename T1>
138  T1 casadi_bilin(const T1* A, const casadi_int* sp_A, const T1* x, const T1* y);
139 
141  template<typename T1>
142  void casadi_kron(const T1* a, const casadi_int* sp_a, const T1* b, const casadi_int* sp_b, T1* r);
143 
145  template<typename T1>
146  void casadi_rank1(T1* A, const casadi_int* sp_A, T1 alpha, const T1* x);
147 
149  template<typename T1>
150  void casadi_getu(const T1* x, const casadi_int* sp_x, T1* v);
151 
153  template<typename T1>
154  T1 casadi_polyval(const T1* p, casadi_int n, T1 x);
155 
156  // Loop over corners of a hypercube
157  casadi_int casadi_flip(casadi_int* corner, casadi_int ndim);
158 
159  // Find the interval to which a value belongs
160  template<typename T1>
161  casadi_int casadi_low(T1 x, const T1* grid, casadi_int ng, casadi_int lookup_mode);
162 
163  // Get weights for the multilinear interpolant
164  template<typename T1>
165  void casadi_interpn_weights(casadi_int ndim, const T1* grid, const casadi_int* offset,
166  const T1* x, T1* alpha, casadi_int* index);
167 
168  // Get coefficients for the multilinear interpolant
169  template<typename T1>
170  T1 casadi_interpn_interpolate(casadi_int ndim, const casadi_int* offset, const T1* values,
171  const T1* alpha, const casadi_int* index,
172  const casadi_int* corner, T1* coeff);
173 
174  // Multilinear interpolant
175  template<typename T1>
176  T1 casadi_interpn(casadi_int ndim, const T1* grid, const casadi_int* offset, const T1* values,
177  const T1* x, casadi_int* iw, T1* w);
178 
179  // Multilinear interpolant - calculate gradient
180  template<typename T1>
181  void casadi_interpn_grad(T1* grad, casadi_int ndim, const T1* grid, const casadi_int* offset,
182  const T1* values, const T1* x, casadi_int* iw, T1* w);
183 
184  // De boor single basis evaluation
185  template<typename T1>
186  void casadi_de_boor(T1 x, const T1* knots, casadi_int n_knots, casadi_int degree, T1* boor);
187 
188  // De boor nd evaluation
189  template<typename T1>
190  void casadi_nd_boor_eval(T1* ret, casadi_int n_dims, const T1* knots, const casadi_int* offset,
191  const casadi_int* degree, const casadi_int* strides, const T1* c,
192  casadi_int m,
193  const T1* x, const casadi_int* lookup_mode, casadi_int* iw, T1* w);
194 
195  template<typename T1>
196  T1 casadi_mmax(const T1* x, casadi_int n, T1 is_dense);
197 
198  template<typename T1>
199  T1 casadi_mmin(const T1* x, casadi_int n, casadi_int is_dense);
200 
201  template<typename T1>
202  T1 casadi_vfmax(const T1* x, casadi_int n, T1 r);
203 
204  template<typename T1>
205  T1 casadi_vfmin(const T1* x, casadi_int n, T1 r);
206 
207  // Alias names
208  inline void casadi_fill_casadi_int(casadi_int* x, casadi_int n, casadi_int alpha) {
209  casadi_fill(x, n, alpha);
210  }
211 
212  // Alias names
213  inline void casadi_clear_casadi_int(casadi_int* x, casadi_int n) {
214  casadi_clear(x, n);
215  }
216 
217  template<typename T1>
218  void casadi_bound_consistency(casadi_int n, T1* x, T1* lam,
219  const T1* lbx, const T1* ubx);
220 
221  // Numerically accurate logsumexp
222  template<typename T1>
223  T1 casadi_logsumexp(const T1* x, casadi_int n);
224 
225  template <class T1>
226  struct casadi_newton_mem;
227 
228  // Newton step
229  template<typename T1>
230  int casadi_newton(const casadi_newton_mem<T1>* m);
231 
232  // Dense matrix multiplication
233  #define CASADI_GEMM_NT(M, N, K, A, LDA, B, LDB, C, LDC) \
234  for (i=0, rr=C; i<M; ++i) \
235  for (j=0; j<N; ++j, ++rr) \
236  for (k=0, ss=A+i*LDA, tt=B+j*LDB; k<K; ++k) \
237  *rr += *ss++**tt++;
238 
239  // Template function implementations
240  #include "casadi_copy.hpp"
241  #include "casadi_cvx.hpp"
242  #include "casadi_swap.hpp"
243  #include "casadi_project.hpp"
244  #include "casadi_tri_project.hpp"
245  #include "casadi_densify.hpp"
246  #include "casadi_sparsify.hpp"
247  #include "casadi_scal.hpp"
248  #include "casadi_iamax.hpp"
249  #include "casadi_axpy.hpp"
250  #include "casadi_dot.hpp"
251  #include "casadi_kron.hpp"
252  #include "casadi_clear.hpp"
253  #include "casadi_clip_max.hpp"
254  #include "casadi_clip_min.hpp"
255  #include "casadi_fill.hpp"
256  #include "casadi_max_viol.hpp"
257  #include "casadi_mmin.hpp"
258  #include "casadi_mmax.hpp"
259  #include "casadi_vfmin.hpp"
260  #include "casadi_vfmax.hpp"
261  #include "casadi_vector_fmin.hpp"
262  #include "casadi_vector_fmax.hpp"
263  #include "casadi_sum_viol.hpp"
264  #include "casadi_mtimes.hpp"
265  #include "casadi_mv.hpp"
266  #include "casadi_trilsolve.hpp"
267  #include "casadi_triusolve.hpp"
268  #include "casadi_trans.hpp"
269  #include "casadi_norm_1.hpp"
270  #include "casadi_norm_2.hpp"
271  #include "casadi_norm_inf.hpp"
272  #include "casadi_masked_norm_inf.hpp"
273  #include "casadi_norm_inf_mul.hpp"
274  #include "casadi_bilin.hpp"
275  #include "casadi_rank1.hpp"
276  #include "casadi_low.hpp"
277  #include "casadi_flip.hpp"
278  #include "casadi_polyval.hpp"
279  #include "casadi_de_boor.hpp"
280  #include "casadi_nd_boor_eval.hpp"
281  #include "casadi_nd_boor_dual_eval.hpp"
282  #include "casadi_interpn_weights.hpp"
283  #include "casadi_interpn_interpolate.hpp"
284  #include "casadi_interpn.hpp"
285  #include "casadi_interpn_grad.hpp"
286  #include "casadi_mv_dense.hpp"
287  #include "casadi_finite_diff.hpp"
288  #include "casadi_file_slurp.hpp"
289  #include "casadi_ldl.hpp"
290  #include "casadi_qr.hpp"
291  #include "casadi_qp.hpp"
292  #include "casadi_qrqp.hpp"
293  #include "casadi_kkt.hpp"
294  #include "casadi_ipqp.hpp"
295  #include "casadi_oracle.hpp"
296  #include "casadi_nlp.hpp"
297  #include "casadi_sqpmethod.hpp"
298  #include "casadi_feasiblesqpmethod.hpp"
299  #include "casadi_bfgs.hpp"
300  #include "casadi_regularize.hpp"
301  #include "casadi_newton.hpp"
302  #include "casadi_bound_consistency.hpp"
303  #include "casadi_lsqr.hpp"
304  #include "casadi_dense_lsqr.hpp"
305  #include "casadi_cache.hpp"
306  #include "casadi_convexify.hpp"
307  #include "casadi_logsumexp.hpp"
308  #include "casadi_sum.hpp"
309  #include "casadi_sparsity.hpp"
310  #include "casadi_jac.hpp"
311  #include "casadi_oracle_callback.hpp"
312  #include "casadi_ocp_block.hpp"
313  #include "casadi_scaled_copy.hpp"
314 } // namespace casadi
315 
317 
318 #endif // CASADI_CASADI_RUNTIME_HPP
casadi
The casadi namespace.
Definition: binary_mx_impl.hpp:36
casadi_newton_mem
Definition: casadi_newton.hpp:23