Uni20
Asynchronous tensor and runtime library.
Loading...
Searching...
No Matches
mplapack/general.hpp
Go to the documentation of this file.
1#pragma once
2
9#include <uni20/backend/backend.hpp>
10#include <uni20/backend/lapack/common.hpp>
11#include <uni20/backend/lapack/mplapack/common.hpp>
12#include <uni20/config.hpp>
13#include <uni20/core/types.hpp>
14
15#include <memory>
16
17#if !(UNI20_HAS_MPLAPACK_FLOAT128)
18#error "uni20/backend/lapack/mplapack/general.hpp requires MPLAPACK float128 support"
19#endif
20
21// clang-format off
22#include <mplapack_config.h>
23#include <mplapack_binary128.h>
24// clang-format on
25
26namespace uni20::lapack::unchecked
27{
28
29[[nodiscard]] inline blas_int gesv(blas_int n, blas_int nrhs, uni20::float128* a, blas_int lda, blas_int* ipiv,
30 uni20::float128* b, blas_int ldb)
31{
32 UNI20_EXTERNAL_API_CALL(LAPACK, Rgesv, n, nrhs, a, lda, ipiv, b, ldb);
33 mplapackint mplapack_info = 0;
34 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::make_mplapack_int_work(n);
35 Rgesv(static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a, static_cast<mplapackint>(lda),
36 mplapack_ipiv.data(), b, static_cast<mplapackint>(ldb), mplapack_info);
37 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_ipiv, ipiv, n);
38 return static_cast<blas_int>(mplapack_info);
39}
40
41[[nodiscard]] inline blas_int gesv(blas_int n, blas_int nrhs, uni20::complex<uni20::float128>* a, blas_int lda,
42 blas_int* ipiv, uni20::complex<uni20::float128>* b, blas_int ldb)
43{
44 UNI20_EXTERNAL_API_CALL(LAPACK, Cgesv, n, nrhs, a, lda, ipiv, b, ldb);
45 mplapackint mplapack_info = 0;
46 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::make_mplapack_int_work(n);
47 Cgesv(static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a, static_cast<mplapackint>(lda),
48 mplapack_ipiv.data(), b, static_cast<mplapackint>(ldb), mplapack_info);
49 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_ipiv, ipiv, n);
50 return static_cast<blas_int>(mplapack_info);
51}
52
53[[nodiscard]] inline blas_int gesvx(char fact, char trans, blas_int n, blas_int nrhs, uni20::float128* a, blas_int lda,
54 uni20::float128* af, blas_int ldaf, blas_int* ipiv, char& equed,
55 uni20::float128* row_scale, uni20::float128* column_scale, uni20::float128* b,
56 blas_int ldb, uni20::float128* x, blas_int ldx, uni20::float128& rcond,
57 uni20::float128* forward_error, uni20::float128* backward_error,
58 uni20::float128* work, blas_int* iwork)
59{
60 UNI20_EXTERNAL_API_CALL(LAPACK, Rgesvx, fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, row_scale, column_scale,
61 b, ldb, x, ldx, work, iwork);
62 mplapackint mplapack_info = 0;
63 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::to_mplapack_ints(ipiv, n);
64 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(n);
65 Rgesvx(&fact, &trans, static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a, static_cast<mplapackint>(lda),
66 af, static_cast<mplapackint>(ldaf), mplapack_ipiv.data(), &equed, row_scale, column_scale, b,
67 static_cast<mplapackint>(ldb), x, static_cast<mplapackint>(ldx), rcond, forward_error, backward_error, work,
68 mplapack_iwork.data(), mplapack_info);
69 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_ipiv, ipiv, n);
70 return static_cast<blas_int>(mplapack_info);
71}
72
73[[nodiscard]] inline blas_int geequ(blas_int m, blas_int n, uni20::float128* a, blas_int lda,
74 uni20::float128* row_scale, uni20::float128* column_scale,
75 uni20::float128& row_condition, uni20::float128& column_condition,
76 uni20::float128& max_abs)
77{
78 UNI20_EXTERNAL_API_CALL(LAPACK, Rgeequ, m, n, a, lda, row_scale, column_scale);
79 mplapackint mplapack_info = 0;
80 Rgeequ(static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), row_scale,
81 column_scale, row_condition, column_condition, max_abs, mplapack_info);
82 return static_cast<blas_int>(mplapack_info);
83}
84
85[[nodiscard]] inline blas_int getrf(blas_int m, blas_int n, uni20::float128* a, blas_int lda, blas_int* ipiv)
86{
87 UNI20_EXTERNAL_API_CALL(LAPACK, Rgetrf, m, n, a, lda, ipiv);
88 mplapackint mplapack_info = 0;
89 blas_int const pivot_count = std::min(m, n);
90 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::make_mplapack_int_work(pivot_count);
91 Rgetrf(static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda),
92 mplapack_ipiv.data(), mplapack_info);
93 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_ipiv, ipiv, pivot_count);
94 return static_cast<blas_int>(mplapack_info);
95}
96
97[[nodiscard]] inline blas_int getrf(blas_int m, blas_int n, uni20::complex<uni20::float128>* a, blas_int lda,
98 blas_int* ipiv)
99{
100 UNI20_EXTERNAL_API_CALL(LAPACK, Cgetrf, m, n, a, lda, ipiv);
101 mplapackint mplapack_info = 0;
102 blas_int const pivot_count = std::min(m, n);
103 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::make_mplapack_int_work(pivot_count);
104 Cgetrf(static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda),
105 mplapack_ipiv.data(), mplapack_info);
106 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_ipiv, ipiv, pivot_count);
107 return static_cast<blas_int>(mplapack_info);
108}
109
110[[nodiscard]] inline blas_int getrs(char trans, blas_int n, blas_int nrhs, uni20::float128* a, blas_int lda,
111 blas_int const* ipiv, uni20::float128* b, blas_int ldb)
112{
113 UNI20_EXTERNAL_API_CALL(LAPACK, Rgetrs, trans, n, nrhs, a, lda, ipiv, b, ldb);
114 mplapackint mplapack_info = 0;
115 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::to_mplapack_ints(ipiv, n);
116 Rgetrs(&trans, static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a, static_cast<mplapackint>(lda),
117 mplapack_ipiv.data(), b, static_cast<mplapackint>(ldb), mplapack_info);
118 return static_cast<blas_int>(mplapack_info);
119}
120
121[[nodiscard]] inline blas_int getrs(char trans, blas_int n, blas_int nrhs, uni20::complex<uni20::float128>* a,
122 blas_int lda, blas_int const* ipiv, uni20::complex<uni20::float128>* b,
123 blas_int ldb)
124{
125 UNI20_EXTERNAL_API_CALL(LAPACK, Cgetrs, trans, n, nrhs, a, lda, ipiv, b, ldb);
126 mplapackint mplapack_info = 0;
127 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::to_mplapack_ints(ipiv, n);
128 Cgetrs(&trans, static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a, static_cast<mplapackint>(lda),
129 mplapack_ipiv.data(), b, static_cast<mplapackint>(ldb), mplapack_info);
130 return static_cast<blas_int>(mplapack_info);
131}
132
133[[nodiscard]] inline blas_int gerfs(char trans, blas_int n, blas_int nrhs, uni20::float128* a, blas_int lda,
134 uni20::float128* factors, blas_int factor_lda, blas_int const* ipiv,
135 uni20::float128* b, blas_int ldb, uni20::float128* x, blas_int ldx,
136 uni20::float128* forward_error, uni20::float128* backward_error,
137 uni20::float128* work, blas_int* iwork)
138{
139 UNI20_EXTERNAL_API_CALL(LAPACK, Rgerfs, trans, n, nrhs, a, lda, factors, factor_lda, ipiv, b, ldb, x, ldx,
140 forward_error, backward_error, work, iwork);
141 mplapackint mplapack_info = 0;
142 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::to_mplapack_ints(ipiv, n);
143 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(n);
144 Rgerfs(&trans, static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a, static_cast<mplapackint>(lda), factors,
145 static_cast<mplapackint>(factor_lda), mplapack_ipiv.data(), b, static_cast<mplapackint>(ldb), x,
146 static_cast<mplapackint>(ldx), forward_error, backward_error, work, mplapack_iwork.data(), mplapack_info);
147 return static_cast<blas_int>(mplapack_info);
148}
149
150[[nodiscard]] inline blas_int getri(blas_int n, uni20::float128* a, blas_int lda, blas_int* ipiv, uni20::float128* work,
151 blas_int lwork)
152{
153 UNI20_EXTERNAL_API_CALL(LAPACK, Rgetri, n, a, lda, ipiv, work, lwork);
154 mplapackint mplapack_info = 0;
155 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::to_mplapack_ints(ipiv, n);
156 Rgetri(static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), mplapack_ipiv.data(), work,
157 static_cast<mplapackint>(lwork), mplapack_info);
158 return static_cast<blas_int>(mplapack_info);
159}
160
161[[nodiscard]] inline blas_int getri(blas_int n, uni20::complex<uni20::float128>* a, blas_int lda, blas_int* ipiv,
162 uni20::complex<uni20::float128>* work, blas_int lwork)
163{
164 UNI20_EXTERNAL_API_CALL(LAPACK, Cgetri, n, a, lda, ipiv, work, lwork);
165 mplapackint mplapack_info = 0;
166 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::to_mplapack_ints(ipiv, n);
167 Cgetri(static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), mplapack_ipiv.data(), work,
168 static_cast<mplapackint>(lwork), mplapack_info);
169 return static_cast<blas_int>(mplapack_info);
170}
171
172[[nodiscard]] inline blas_int gecon(char norm, blas_int n, uni20::float128 const* a, blas_int lda,
173 uni20::float128 anorm, uni20::float128& rcond, uni20::float128* work,
174 blas_int* iwork)
175{
176 UNI20_EXTERNAL_API_CALL(LAPACK, Rgecon, norm, n, a, lda, anorm, work, iwork);
177 mplapackint mplapack_info = 0;
178 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(n);
179 Rgecon(&norm, static_cast<mplapackint>(n), const_cast<uni20::float128*>(a), static_cast<mplapackint>(lda), anorm,
180 rcond, work, mplapack_iwork.data(), mplapack_info);
181 return static_cast<blas_int>(mplapack_info);
182}
183
184[[nodiscard]] inline blas_int gecon(char norm, blas_int n, uni20::complex<uni20::float128> const* a, blas_int lda,
185 uni20::float128 anorm, uni20::float128& rcond,
186 uni20::complex<uni20::float128>* work, uni20::float128* rwork)
187{
188 UNI20_EXTERNAL_API_CALL(LAPACK, Cgecon, norm, n, a, lda, anorm, work, rwork);
189 mplapackint mplapack_info = 0;
190 Cgecon(&norm, static_cast<mplapackint>(n), const_cast<uni20::complex<uni20::float128>*>(a),
191 static_cast<mplapackint>(lda), anorm, rcond, work, rwork, mplapack_info);
192 return static_cast<blas_int>(mplapack_info);
193}
194
195[[nodiscard]] inline blas_int gels(char trans, blas_int m, blas_int n, blas_int nrhs, uni20::float128* a, blas_int lda,
196 uni20::float128* b, blas_int ldb, uni20::float128* work, blas_int lwork)
197{
198 UNI20_EXTERNAL_API_CALL(LAPACK, Rgels, trans, m, n, nrhs, a, lda, b, ldb, work, lwork);
199 mplapackint mplapack_info = 0;
200 Rgels(&trans, static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a,
201 static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb), work, static_cast<mplapackint>(lwork),
202 mplapack_info);
203 return static_cast<blas_int>(mplapack_info);
204}
205
206[[nodiscard]] inline blas_int gelss(blas_int m, blas_int n, blas_int nrhs, uni20::float128* a, blas_int lda,
207 uni20::float128* b, blas_int ldb, uni20::float128* s, uni20::float128 rcond,
208 blas_int& rank, uni20::float128* work, blas_int lwork)
209{
210 UNI20_EXTERNAL_API_CALL(LAPACK, Rgelss, m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork);
211 mplapackint mplapack_rank = 0;
212 mplapackint mplapack_info = 0;
213 Rgelss(static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a,
214 static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb), s, rcond, mplapack_rank, work,
215 static_cast<mplapackint>(lwork), mplapack_info);
216 rank = static_cast<blas_int>(mplapack_rank);
217 return static_cast<blas_int>(mplapack_info);
218}
219
221[[nodiscard]] inline blas_int gelss(blas_int m, blas_int n, blas_int nrhs, uni20::complex<uni20::float128>* a,
222 blas_int lda, uni20::complex<uni20::float128>* b, blas_int ldb, uni20::float128* s,
223 uni20::float128 rcond, blas_int& rank, uni20::complex<uni20::float128>* work,
224 blas_int lwork, uni20::float128* rwork)
225{
226 UNI20_EXTERNAL_API_CALL(LAPACK, Cgelss, m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork);
227 mplapackint provider_rank = 0, info = 0;
228 Cgelss(static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a,
229 static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb), s, rcond, provider_rank, work,
230 static_cast<mplapackint>(lwork), rwork, info);
231 rank = static_cast<blas_int>(provider_rank);
232 return static_cast<blas_int>(info);
233}
234
235[[nodiscard]] inline blas_int gelsd(blas_int m, blas_int n, blas_int nrhs, uni20::float128* a, blas_int lda,
236 uni20::float128* b, blas_int ldb, uni20::float128* s, uni20::float128 rcond,
237 blas_int& rank, uni20::float128* work, blas_int lwork, blas_int* iwork)
238{
239 UNI20_EXTERNAL_API_CALL(LAPACK, Rgelsd, m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork);
240 mplapackint mplapack_rank = 0;
241 mplapackint mplapack_info = 0;
242 blas_int const iwork_size = uni20::lapack::mplapack::detail::gelsd_iwork_size(m, n);
243 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
244 Rgelsd(static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a,
245 static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb), s, rcond, mplapack_rank, work,
246 static_cast<mplapackint>(lwork), mplapack_iwork.data(), mplapack_info);
247 rank = static_cast<blas_int>(mplapack_rank);
248 return static_cast<blas_int>(mplapack_info);
249}
250
251[[nodiscard]] inline blas_int gelsy(blas_int m, blas_int n, blas_int nrhs, uni20::float128* a, blas_int lda,
252 uni20::float128* b, blas_int ldb, blas_int* jpvt, uni20::float128 rcond,
253 blas_int& rank, uni20::float128* work, blas_int lwork)
254{
255 UNI20_EXTERNAL_API_CALL(LAPACK, Rgelsy, m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork);
256 mplapackint mplapack_rank = 0;
257 mplapackint mplapack_info = 0;
258 std::vector<mplapackint> mplapack_jpvt = uni20::lapack::mplapack::detail::to_mplapack_ints(jpvt, n);
259 Rgelsy(static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a,
260 static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb), mplapack_jpvt.data(), rcond, mplapack_rank,
261 work, static_cast<mplapackint>(lwork), mplapack_info);
262 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_jpvt, jpvt, n);
263 rank = static_cast<blas_int>(mplapack_rank);
264 return static_cast<blas_int>(mplapack_info);
265}
266
267[[nodiscard]] inline blas_int geqrf(blas_int m, blas_int n, uni20::float128* a, blas_int lda, uni20::float128* tau,
268 uni20::float128* work, blas_int lwork)
269{
270 UNI20_EXTERNAL_API_CALL(LAPACK, Rgeqrf, m, n, a, lda, tau, work, lwork);
271 mplapackint mplapack_info = 0;
272 Rgeqrf(static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), tau, work,
273 static_cast<mplapackint>(lwork), mplapack_info);
274 return static_cast<blas_int>(mplapack_info);
275}
276
277[[nodiscard]] inline blas_int geqrf(blas_int m, blas_int n, uni20::complex<uni20::float128>* a, blas_int lda,
278 uni20::complex<uni20::float128>* tau, uni20::complex<uni20::float128>* work,
279 blas_int lwork)
280{
281 UNI20_EXTERNAL_API_CALL(LAPACK, Cgeqrf, m, n, a, lda, tau, work, lwork);
282 mplapackint mplapack_info = 0;
283 Cgeqrf(static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), tau, work,
284 static_cast<mplapackint>(lwork), mplapack_info);
285 return static_cast<blas_int>(mplapack_info);
286}
287
288[[nodiscard]] inline blas_int gelqf(blas_int m, blas_int n, uni20::float128* a, blas_int lda, uni20::float128* tau,
289 uni20::float128* work, blas_int lwork)
290{
291 UNI20_EXTERNAL_API_CALL(LAPACK, Rgelqf, m, n, a, lda, tau, work, lwork);
292 mplapackint mplapack_info = 0;
293 Rgelqf(static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), tau, work,
294 static_cast<mplapackint>(lwork), mplapack_info);
295 return static_cast<blas_int>(mplapack_info);
296}
297
298[[nodiscard]] inline blas_int gelqf(blas_int m, blas_int n, uni20::complex<uni20::float128>* a, blas_int lda,
299 uni20::complex<uni20::float128>* tau, uni20::complex<uni20::float128>* work,
300 blas_int lwork)
301{
302 UNI20_EXTERNAL_API_CALL(LAPACK, Cgelqf, m, n, a, lda, tau, work, lwork);
303 mplapackint mplapack_info = 0;
304 Cgelqf(static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), tau, work,
305 static_cast<mplapackint>(lwork), mplapack_info);
306 return static_cast<blas_int>(mplapack_info);
307}
308
309[[nodiscard]] inline blas_int geqlf(blas_int m, blas_int n, uni20::float128* a, blas_int lda, uni20::float128* tau,
310 uni20::float128* work, blas_int lwork)
311{
312 UNI20_EXTERNAL_API_CALL(LAPACK, Rgeqlf, m, n, a, lda, tau, work, lwork);
313 mplapackint mplapack_info = 0;
314 Rgeqlf(static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), tau, work,
315 static_cast<mplapackint>(lwork), mplapack_info);
316 return static_cast<blas_int>(mplapack_info);
317}
318
319[[nodiscard]] inline blas_int gerqf(blas_int m, blas_int n, uni20::float128* a, blas_int lda, uni20::float128* tau,
320 uni20::float128* work, blas_int lwork)
321{
322 UNI20_EXTERNAL_API_CALL(LAPACK, Rgerqf, m, n, a, lda, tau, work, lwork);
323 mplapackint mplapack_info = 0;
324 Rgerqf(static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), tau, work,
325 static_cast<mplapackint>(lwork), mplapack_info);
326 return static_cast<blas_int>(mplapack_info);
327}
328
329[[nodiscard]] inline blas_int orgqr(blas_int m, blas_int n, blas_int k, uni20::float128* a, blas_int lda,
330 uni20::float128* tau, uni20::float128* work, blas_int lwork)
331{
332 UNI20_EXTERNAL_API_CALL(LAPACK, Rorgqr, m, n, k, a, lda, tau, work, lwork);
333 mplapackint mplapack_info = 0;
334 Rorgqr(static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(k), a,
335 static_cast<mplapackint>(lda), tau, work, static_cast<mplapackint>(lwork), mplapack_info);
336 return static_cast<blas_int>(mplapack_info);
337}
338
339[[nodiscard]] inline blas_int orgqr(blas_int m, blas_int n, blas_int k, uni20::complex<uni20::float128>* a,
340 blas_int lda, uni20::complex<uni20::float128>* tau,
341 uni20::complex<uni20::float128>* work, blas_int lwork)
342{
343 UNI20_EXTERNAL_API_CALL(LAPACK, Cungqr, m, n, k, a, lda, tau, work, lwork);
344 mplapackint mplapack_info = 0;
345 Cungqr(static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(k), a,
346 static_cast<mplapackint>(lda), tau, work, static_cast<mplapackint>(lwork), mplapack_info);
347 return static_cast<blas_int>(mplapack_info);
348}
349
350[[nodiscard]] inline blas_int orglq(blas_int m, blas_int n, blas_int k, uni20::float128* a, blas_int lda,
351 uni20::float128* tau, uni20::float128* work, blas_int lwork)
352{
353 UNI20_EXTERNAL_API_CALL(LAPACK, Rorglq, m, n, k, a, lda, tau, work, lwork);
354 mplapackint mplapack_info = 0;
355 Rorglq(static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(k), a,
356 static_cast<mplapackint>(lda), tau, work, static_cast<mplapackint>(lwork), mplapack_info);
357 return static_cast<blas_int>(mplapack_info);
358}
359
360[[nodiscard]] inline blas_int orglq(blas_int m, blas_int n, blas_int k, uni20::complex<uni20::float128>* a,
361 blas_int lda, uni20::complex<uni20::float128>* tau,
362 uni20::complex<uni20::float128>* work, blas_int lwork)
363{
364 UNI20_EXTERNAL_API_CALL(LAPACK, Cunglq, m, n, k, a, lda, tau, work, lwork);
365 mplapackint mplapack_info = 0;
366 Cunglq(static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(k), a,
367 static_cast<mplapackint>(lda), tau, work, static_cast<mplapackint>(lwork), mplapack_info);
368 return static_cast<blas_int>(mplapack_info);
369}
370
371[[nodiscard]] inline blas_int orgql(blas_int m, blas_int n, blas_int k, uni20::float128* a, blas_int lda,
372 uni20::float128* tau, uni20::float128* work, blas_int lwork)
373{
374 UNI20_EXTERNAL_API_CALL(LAPACK, Rorgql, m, n, k, a, lda, tau, work, lwork);
375 mplapackint mplapack_info = 0;
376 Rorgql(static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(k), a,
377 static_cast<mplapackint>(lda), tau, work, static_cast<mplapackint>(lwork), mplapack_info);
378 return static_cast<blas_int>(mplapack_info);
379}
380
381[[nodiscard]] inline blas_int orgrq(blas_int m, blas_int n, blas_int k, uni20::float128* a, blas_int lda,
382 uni20::float128* tau, uni20::float128* work, blas_int lwork)
383{
384 UNI20_EXTERNAL_API_CALL(LAPACK, Rorgrq, m, n, k, a, lda, tau, work, lwork);
385 mplapackint mplapack_info = 0;
386 Rorgrq(static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(k), a,
387 static_cast<mplapackint>(lda), tau, work, static_cast<mplapackint>(lwork), mplapack_info);
388 return static_cast<blas_int>(mplapack_info);
389}
390
391[[nodiscard]] inline blas_int ormqr(char side, char trans, blas_int m, blas_int n, blas_int k, uni20::float128* a,
392 blas_int lda, uni20::float128* tau, uni20::float128* c, blas_int ldc,
393 uni20::float128* work, blas_int lwork)
394{
395 UNI20_EXTERNAL_API_CALL(LAPACK, Rormqr, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork);
396 mplapackint mplapack_info = 0;
397 Rormqr(&side, &trans, static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(k), a,
398 static_cast<mplapackint>(lda), tau, c, static_cast<mplapackint>(ldc), work, static_cast<mplapackint>(lwork),
399 mplapack_info);
400 return static_cast<blas_int>(mplapack_info);
401}
402
403[[nodiscard]] inline blas_int ormlq(char side, char trans, blas_int m, blas_int n, blas_int k, uni20::float128* a,
404 blas_int lda, uni20::float128* tau, uni20::float128* c, blas_int ldc,
405 uni20::float128* work, blas_int lwork)
406{
407 UNI20_EXTERNAL_API_CALL(LAPACK, Rormlq, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork);
408 mplapackint mplapack_info = 0;
409 Rormlq(&side, &trans, static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(k), a,
410 static_cast<mplapackint>(lda), tau, c, static_cast<mplapackint>(ldc), work, static_cast<mplapackint>(lwork),
411 mplapack_info);
412 return static_cast<blas_int>(mplapack_info);
413}
414
415[[nodiscard]] inline blas_int ormql(char side, char trans, blas_int m, blas_int n, blas_int k, uni20::float128* a,
416 blas_int lda, uni20::float128* tau, uni20::float128* c, blas_int ldc,
417 uni20::float128* work, blas_int lwork)
418{
419 UNI20_EXTERNAL_API_CALL(LAPACK, Rormql, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork);
420 mplapackint mplapack_info = 0;
421 Rormql(&side, &trans, static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(k), a,
422 static_cast<mplapackint>(lda), tau, c, static_cast<mplapackint>(ldc), work, static_cast<mplapackint>(lwork),
423 mplapack_info);
424 return static_cast<blas_int>(mplapack_info);
425}
426
427[[nodiscard]] inline blas_int ormrq(char side, char trans, blas_int m, blas_int n, blas_int k, uni20::float128* a,
428 blas_int lda, uni20::float128* tau, uni20::float128* c, blas_int ldc,
429 uni20::float128* work, blas_int lwork)
430{
431 UNI20_EXTERNAL_API_CALL(LAPACK, Rormrq, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork);
432 mplapackint mplapack_info = 0;
433 Rormrq(&side, &trans, static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(k), a,
434 static_cast<mplapackint>(lda), tau, c, static_cast<mplapackint>(ldc), work, static_cast<mplapackint>(lwork),
435 mplapack_info);
436 return static_cast<blas_int>(mplapack_info);
437}
438
439[[nodiscard]] inline blas_int gebrd(blas_int m, blas_int n, uni20::float128* a, blas_int lda, uni20::float128* d,
440 uni20::float128* e, uni20::float128* tauq, uni20::float128* taup,
441 uni20::float128* work, blas_int lwork)
442{
443 UNI20_EXTERNAL_API_CALL(LAPACK, Rgebrd, m, n, a, lda, d, e, tauq, taup, work, lwork);
444 mplapackint mplapack_info = 0;
445 Rgebrd(static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), d, e, tauq, taup,
446 work, static_cast<mplapackint>(lwork), mplapack_info);
447 return static_cast<blas_int>(mplapack_info);
448}
449
450[[nodiscard]] inline blas_int gehrd(blas_int n, blas_int first, blas_int last, uni20::float128* a, blas_int lda,
451 uni20::float128* tau, uni20::float128* work, blas_int lwork)
452{
453 UNI20_EXTERNAL_API_CALL(LAPACK, Rgehrd, n, first, last, a, lda, tau, work, lwork);
454 mplapackint mplapack_info = 0;
455 Rgehrd(static_cast<mplapackint>(n), static_cast<mplapackint>(first), static_cast<mplapackint>(last), a,
456 static_cast<mplapackint>(lda), tau, work, static_cast<mplapackint>(lwork), mplapack_info);
457 return static_cast<blas_int>(mplapack_info);
458}
459
460[[nodiscard]] inline blas_int geqp3(blas_int m, blas_int n, uni20::float128* a, blas_int lda, blas_int* jpvt,
461 uni20::float128* tau, uni20::float128* work, blas_int lwork)
462{
463 UNI20_EXTERNAL_API_CALL(LAPACK, Rgeqp3, m, n, a, lda, jpvt, tau, work, lwork);
464 mplapackint mplapack_info = 0;
465 std::vector<mplapackint> mplapack_jpvt = uni20::lapack::mplapack::detail::to_mplapack_ints(jpvt, n);
466 Rgeqp3(static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda),
467 mplapack_jpvt.data(), tau, work, static_cast<mplapackint>(lwork), mplapack_info);
468 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_jpvt, jpvt, n);
469 return static_cast<blas_int>(mplapack_info);
470}
471
472[[nodiscard]] inline blas_int sytrd(char uplo, blas_int n, uni20::float128* a, blas_int lda, uni20::float128* d,
473 uni20::float128* e, uni20::float128* tau, uni20::float128* work, blas_int lwork)
474{
475 UNI20_EXTERNAL_API_CALL(LAPACK, Rsytrd, uplo, n, a, lda, d, e, tau, work, lwork);
476 mplapackint mplapack_info = 0;
477 Rsytrd(&uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), d, e, tau, work,
478 static_cast<mplapackint>(lwork), mplapack_info);
479 return static_cast<blas_int>(mplapack_info);
480}
481
482[[nodiscard]] inline blas_int syev(char jobz, char uplo, blas_int n, uni20::float128* a, blas_int lda,
483 uni20::float128* w, uni20::float128* work, blas_int lwork)
484{
485 UNI20_EXTERNAL_API_CALL(LAPACK, Rsyev, jobz, uplo, n, a, lda, w, work, lwork);
486 mplapackint mplapack_info = 0;
487 Rsyev(&jobz, &uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), w, work,
488 static_cast<mplapackint>(lwork), mplapack_info);
489 return static_cast<blas_int>(mplapack_info);
490}
491
492[[nodiscard]] inline blas_int syevd(char jobz, char uplo, blas_int n, uni20::float128* a, blas_int lda,
493 uni20::float128* w, uni20::float128* work, blas_int lwork, blas_int* iwork,
494 blas_int liwork)
495{
496 UNI20_EXTERNAL_API_CALL(LAPACK, Rsyevd, jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork);
497 mplapackint mplapack_info = 0;
498 blas_int const iwork_size = std::max<blas_int>(1, liwork == -1 ? blas_int{1} : liwork);
499 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
500 Rsyevd(&jobz, &uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), w, work,
501 static_cast<mplapackint>(lwork), mplapack_iwork.data(), static_cast<mplapackint>(liwork), mplapack_info);
502 uni20::lapack::mplapack::detail::copy_from_mplapack_query_int_work(mplapack_iwork, iwork, liwork);
503 return static_cast<blas_int>(mplapack_info);
504}
505
506[[nodiscard]] inline blas_int syevr(char jobz, char range, char uplo, blas_int n, uni20::float128* a, blas_int lda,
507 uni20::float128 vl, uni20::float128 vu, blas_int il, blas_int iu,
508 uni20::float128 abstol, blas_int& selected_count, uni20::float128* w,
509 uni20::float128* z, blas_int ldz, blas_int* isuppz, uni20::float128* work,
510 blas_int lwork, blas_int* iwork, blas_int liwork)
511{
512 UNI20_EXTERNAL_API_CALL(LAPACK, Rsyevr, jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, selected_count, w, z,
513 ldz, isuppz, work, lwork, iwork, liwork);
514 mplapackint mplapack_selected_count = static_cast<mplapackint>(selected_count);
515 mplapackint mplapack_info = 0;
516 blas_int const support_size = 2 * std::max<blas_int>(1, n);
517 blas_int const iwork_size = std::max<blas_int>(1, liwork == -1 ? blas_int{1} : liwork);
518 std::vector<mplapackint> mplapack_isuppz;
519 if (isuppz != nullptr)
520 {
521 mplapack_isuppz = uni20::lapack::mplapack::detail::make_mplapack_int_work(support_size);
522 }
523 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
524 Rsyevr(&jobz, &range, &uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), vl, vu,
525 static_cast<mplapackint>(il), static_cast<mplapackint>(iu), abstol, mplapack_selected_count, w, z,
526 static_cast<mplapackint>(ldz), isuppz == nullptr ? nullptr : mplapack_isuppz.data(), work,
527 static_cast<mplapackint>(lwork), mplapack_iwork.data(), static_cast<mplapackint>(liwork), mplapack_info);
528 selected_count = static_cast<blas_int>(mplapack_selected_count);
529 if (isuppz != nullptr)
530 {
531 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_isuppz, isuppz, support_size);
532 }
533 uni20::lapack::mplapack::detail::copy_from_mplapack_query_int_work(mplapack_iwork, iwork, liwork);
534 return static_cast<blas_int>(mplapack_info);
535}
536
537[[nodiscard]] inline blas_int sygv(blas_int itype, char jobz, char uplo, blas_int n, uni20::float128* a, blas_int lda,
538 uni20::float128* b, blas_int ldb, uni20::float128* w, uni20::float128* work,
539 blas_int lwork)
540{
541 UNI20_EXTERNAL_API_CALL(LAPACK, Rsygv, itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork);
542 mplapackint mplapack_info = 0;
543 Rsygv(static_cast<mplapackint>(itype), &jobz, &uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), b,
544 static_cast<mplapackint>(ldb), w, work, static_cast<mplapackint>(lwork), mplapack_info);
545 return static_cast<blas_int>(mplapack_info);
546}
547
548[[nodiscard]] inline blas_int sygvd(blas_int itype, char jobz, char uplo, blas_int n, uni20::float128* a, blas_int lda,
549 uni20::float128* b, blas_int ldb, uni20::float128* w, uni20::float128* work,
550 blas_int lwork, blas_int* iwork, blas_int liwork)
551{
552 UNI20_EXTERNAL_API_CALL(LAPACK, Rsygvd, itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, iwork, liwork);
553 mplapackint mplapack_info = 0;
554 blas_int const iwork_size = std::max<blas_int>(1, liwork == -1 ? blas_int{1} : liwork);
555 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
556 Rsygvd(static_cast<mplapackint>(itype), &jobz, &uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda),
557 b, static_cast<mplapackint>(ldb), w, work, static_cast<mplapackint>(lwork), mplapack_iwork.data(),
558 static_cast<mplapackint>(liwork), mplapack_info);
559 uni20::lapack::mplapack::detail::copy_from_mplapack_query_int_work(mplapack_iwork, iwork, liwork);
560 return static_cast<blas_int>(mplapack_info);
561}
562
563[[nodiscard]] inline blas_int sygvx(blas_int itype, char jobz, char range, char uplo, blas_int n, uni20::float128* a,
564 blas_int lda, uni20::float128* b, blas_int ldb, uni20::float128 vl,
565 uni20::float128 vu, blas_int il, blas_int iu, uni20::float128 abstol,
566 blas_int& selected_count, uni20::float128* w, uni20::float128* z, blas_int ldz,
567 uni20::float128* work, blas_int lwork, blas_int* iwork, blas_int* ifail)
568{
569 UNI20_EXTERNAL_API_CALL(LAPACK, Rsygvx, itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol,
570 selected_count, w, z, ldz, work, lwork, iwork, ifail);
571 mplapackint mplapack_selected_count = static_cast<mplapackint>(selected_count);
572 mplapackint mplapack_info = 0;
573 blas_int const iwork_size = 5 * std::max<blas_int>(1, n);
574 blas_int const fail_size = std::max<blas_int>(1, n);
575 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
576 std::vector<mplapackint> mplapack_ifail;
577 if (ifail != nullptr)
578 {
579 mplapack_ifail = uni20::lapack::mplapack::detail::make_mplapack_int_work(fail_size);
580 }
581 Rsygvx(static_cast<mplapackint>(itype), &jobz, &range, &uplo, static_cast<mplapackint>(n), a,
582 static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb), vl, vu, static_cast<mplapackint>(il),
583 static_cast<mplapackint>(iu), abstol, mplapack_selected_count, w, z, static_cast<mplapackint>(ldz), work,
584 static_cast<mplapackint>(lwork), mplapack_iwork.data(), ifail == nullptr ? nullptr : mplapack_ifail.data(),
585 mplapack_info);
586 selected_count = static_cast<blas_int>(mplapack_selected_count);
587 if (ifail != nullptr)
588 {
589 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_ifail, ifail, fail_size);
590 }
591 return static_cast<blas_int>(mplapack_info);
592}
593
594[[nodiscard]] inline blas_int heev(char jobz, char uplo, blas_int n, uni20::complex<uni20::float128>* a, blas_int lda,
595 uni20::float128* w, uni20::complex<uni20::float128>* work, blas_int lwork,
596 uni20::float128* rwork)
597{
598 UNI20_EXTERNAL_API_CALL(LAPACK, Cheev, jobz, uplo, n, a, lda, w, work, lwork, rwork);
599 mplapackint mplapack_info = 0;
600 Cheev(&jobz, &uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), w, work,
601 static_cast<mplapackint>(lwork), rwork, mplapack_info);
602 return static_cast<blas_int>(mplapack_info);
603}
604
605[[nodiscard]] inline blas_int heevd(char jobz, char uplo, blas_int n, uni20::complex<uni20::float128>* a, blas_int lda,
606 uni20::float128* w, uni20::complex<uni20::float128>* work, blas_int lwork,
607 uni20::float128* rwork, blas_int lrwork, blas_int* iwork, blas_int liwork)
608{
609 UNI20_EXTERNAL_API_CALL(LAPACK, Cheevd, jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork);
610 mplapackint mplapack_info = 0;
611 blas_int const iwork_size = std::max<blas_int>(1, liwork == -1 ? blas_int{1} : liwork);
612 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
613 Cheevd(&jobz, &uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), w, work,
614 static_cast<mplapackint>(lwork), rwork, static_cast<mplapackint>(lrwork), mplapack_iwork.data(),
615 static_cast<mplapackint>(liwork), mplapack_info);
616 uni20::lapack::mplapack::detail::copy_from_mplapack_query_int_work(mplapack_iwork, iwork, liwork);
617 return static_cast<blas_int>(mplapack_info);
618}
619
620[[nodiscard]] inline blas_int heevr(char jobz, char range, char uplo, blas_int n, uni20::complex<uni20::float128>* a,
621 blas_int lda, uni20::float128 vl, uni20::float128 vu, blas_int il, blas_int iu,
622 uni20::float128 abstol, blas_int& selected_count, uni20::float128* w,
623 uni20::complex<uni20::float128>* z, blas_int ldz, blas_int* isuppz,
624 uni20::complex<uni20::float128>* work, blas_int lwork, uni20::float128* rwork,
625 blas_int lrwork, blas_int* iwork, blas_int liwork)
626{
627 UNI20_EXTERNAL_API_CALL(LAPACK, Cheevr, jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, selected_count, w, z,
628 ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork);
629 mplapackint mplapack_selected_count = static_cast<mplapackint>(selected_count);
630 mplapackint mplapack_info = 0;
631 blas_int const support_size = 2 * std::max<blas_int>(1, n);
632 blas_int const iwork_size = std::max<blas_int>(1, liwork == -1 ? blas_int{1} : liwork);
633 std::vector<mplapackint> mplapack_isuppz;
634 if (isuppz != nullptr)
635 {
636 mplapack_isuppz = uni20::lapack::mplapack::detail::make_mplapack_int_work(support_size);
637 }
638 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
639 Cheevr(&jobz, &range, &uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), vl, vu,
640 static_cast<mplapackint>(il), static_cast<mplapackint>(iu), abstol, mplapack_selected_count, w, z,
641 static_cast<mplapackint>(ldz), isuppz == nullptr ? nullptr : mplapack_isuppz.data(), work,
642 static_cast<mplapackint>(lwork), rwork, static_cast<mplapackint>(lrwork), mplapack_iwork.data(),
643 static_cast<mplapackint>(liwork), mplapack_info);
644 selected_count = static_cast<blas_int>(mplapack_selected_count);
645 if (isuppz != nullptr)
646 {
647 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_isuppz, isuppz, support_size);
648 }
649 uni20::lapack::mplapack::detail::copy_from_mplapack_query_int_work(mplapack_iwork, iwork, liwork);
650 return static_cast<blas_int>(mplapack_info);
651}
652
653[[nodiscard]] inline blas_int hegv(blas_int itype, char jobz, char uplo, blas_int n, uni20::complex<uni20::float128>* a,
654 blas_int lda, uni20::complex<uni20::float128>* b, blas_int ldb, uni20::float128* w,
655 uni20::complex<uni20::float128>* work, blas_int lwork, uni20::float128* rwork)
656{
657 UNI20_EXTERNAL_API_CALL(LAPACK, Chegv, itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork);
658 mplapackint mplapack_info = 0;
659 Chegv(static_cast<mplapackint>(itype), &jobz, &uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), b,
660 static_cast<mplapackint>(ldb), w, work, static_cast<mplapackint>(lwork), rwork, mplapack_info);
661 return static_cast<blas_int>(mplapack_info);
662}
663
664[[nodiscard]] inline blas_int hegvd(blas_int itype, char jobz, char uplo, blas_int n,
665 uni20::complex<uni20::float128>* a, blas_int lda,
666 uni20::complex<uni20::float128>* b, blas_int ldb, uni20::float128* w,
667 uni20::complex<uni20::float128>* work, blas_int lwork, uni20::float128* rwork,
668 blas_int lrwork, blas_int* iwork, blas_int liwork)
669{
670 UNI20_EXTERNAL_API_CALL(LAPACK, Chegvd, itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork,
671 liwork);
672 mplapackint mplapack_info = 0;
673 blas_int const iwork_size = std::max<blas_int>(1, liwork == -1 ? blas_int{1} : liwork);
674 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
675 Chegvd(static_cast<mplapackint>(itype), &jobz, &uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda),
676 b, static_cast<mplapackint>(ldb), w, work, static_cast<mplapackint>(lwork), rwork,
677 static_cast<mplapackint>(lrwork), mplapack_iwork.data(), static_cast<mplapackint>(liwork), mplapack_info);
678 uni20::lapack::mplapack::detail::copy_from_mplapack_query_int_work(mplapack_iwork, iwork, liwork);
679 return static_cast<blas_int>(mplapack_info);
680}
681
682[[nodiscard]] inline blas_int hegvx(blas_int itype, char jobz, char range, char uplo, blas_int n,
683 uni20::complex<uni20::float128>* a, blas_int lda,
684 uni20::complex<uni20::float128>* b, blas_int ldb, uni20::float128 vl,
685 uni20::float128 vu, blas_int il, blas_int iu, uni20::float128 abstol,
686 blas_int& selected_count, uni20::float128* w, uni20::complex<uni20::float128>* z,
687 blas_int ldz, uni20::complex<uni20::float128>* work, blas_int lwork,
688 uni20::float128* rwork, blas_int* iwork, blas_int* ifail)
689{
690 UNI20_EXTERNAL_API_CALL(LAPACK, Chegvx, itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol,
691 selected_count, w, z, ldz, work, lwork, rwork, iwork, ifail);
692 mplapackint mplapack_selected_count = static_cast<mplapackint>(selected_count);
693 mplapackint mplapack_info = 0;
694 blas_int const iwork_size = 5 * std::max<blas_int>(1, n);
695 blas_int const fail_size = std::max<blas_int>(1, n);
696 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
697 std::vector<mplapackint> mplapack_ifail;
698 if (ifail != nullptr)
699 {
700 mplapack_ifail = uni20::lapack::mplapack::detail::make_mplapack_int_work(fail_size);
701 }
702 Chegvx(static_cast<mplapackint>(itype), &jobz, &range, &uplo, static_cast<mplapackint>(n), a,
703 static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb), vl, vu, static_cast<mplapackint>(il),
704 static_cast<mplapackint>(iu), abstol, mplapack_selected_count, w, z, static_cast<mplapackint>(ldz), work,
705 static_cast<mplapackint>(lwork), rwork, mplapack_iwork.data(),
706 ifail == nullptr ? nullptr : mplapack_ifail.data(), mplapack_info);
707 selected_count = static_cast<blas_int>(mplapack_selected_count);
708 if (ifail != nullptr)
709 {
710 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_ifail, ifail, fail_size);
711 }
712 return static_cast<blas_int>(mplapack_info);
713}
714
715[[nodiscard]] inline blas_int geev(char jobvl, char jobvr, blas_int n, uni20::float128* a, blas_int lda,
716 uni20::float128* wr, uni20::float128* wi, uni20::float128* vl, blas_int ldvl,
717 uni20::float128* vr, blas_int ldvr, uni20::float128* work, blas_int lwork)
718{
719 UNI20_EXTERNAL_API_CALL(LAPACK, Rgeev, jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork);
720 mplapackint mplapack_info = 0;
721 Rgeev(&jobvl, &jobvr, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), wr, wi, vl,
722 static_cast<mplapackint>(ldvl), vr, static_cast<mplapackint>(ldvr), work, static_cast<mplapackint>(lwork),
723 mplapack_info);
724 return static_cast<blas_int>(mplapack_info);
725}
726
727[[nodiscard]] inline blas_int geevx(char balanc, char jobvl, char jobvr, char sense, blas_int n, uni20::float128* a,
728 blas_int lda, uni20::float128* wr, uni20::float128* wi, uni20::float128* vl,
729 blas_int ldvl, uni20::float128* vr, blas_int ldvr, blas_int& ilo, blas_int& ihi,
730 uni20::float128* scale, uni20::float128& abnrm, uni20::float128* rconde,
731 uni20::float128* rcondv, uni20::float128* work, blas_int lwork, blas_int* iwork)
732{
733 UNI20_EXTERNAL_API_CALL(LAPACK, Rgeevx, balanc, jobvl, jobvr, sense, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, ilo, ihi,
734 scale, abnrm, rconde, rcondv, work, lwork, iwork);
735 mplapackint mplapack_ilo = static_cast<mplapackint>(ilo);
736 mplapackint mplapack_ihi = static_cast<mplapackint>(ihi);
737 mplapackint mplapack_info = 0;
738 blas_int const iwork_size = std::max<blas_int>(1, 2 * n - 2);
739 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
740 Rgeevx(&balanc, &jobvl, &jobvr, &sense, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), wr, wi, vl,
741 static_cast<mplapackint>(ldvl), vr, static_cast<mplapackint>(ldvr), mplapack_ilo, mplapack_ihi, scale, abnrm,
742 rconde, rcondv, work, static_cast<mplapackint>(lwork), mplapack_iwork.data(), mplapack_info);
743 ilo = static_cast<blas_int>(mplapack_ilo);
744 ihi = static_cast<blas_int>(mplapack_ihi);
745 return static_cast<blas_int>(mplapack_info);
746}
747
748[[nodiscard]] inline blas_int gebal(char job, blas_int n, uni20::float128* a, blas_int lda, blas_int& first,
749 blas_int& last, uni20::float128* scale)
750{
751 UNI20_EXTERNAL_API_CALL(LAPACK, Rgebal, job, n, a, lda, first, last, scale);
752 mplapackint mplapack_first = static_cast<mplapackint>(first);
753 mplapackint mplapack_last = static_cast<mplapackint>(last);
754 mplapackint mplapack_info = 0;
755 Rgebal(&job, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), mplapack_first, mplapack_last, scale,
756 mplapack_info);
757 first = static_cast<blas_int>(mplapack_first);
758 last = static_cast<blas_int>(mplapack_last);
759 return static_cast<blas_int>(mplapack_info);
760}
761
762[[nodiscard]] inline blas_int gebak(char job, char side, blas_int n, blas_int first, blas_int last,
763 uni20::float128* scale, blas_int vector_count, uni20::float128* vectors,
764 blas_int leading_dimension)
765{
766 UNI20_EXTERNAL_API_CALL(LAPACK, Rgebak, job, side, n, first, last, scale, vector_count, vectors, leading_dimension);
767 mplapackint mplapack_info = 0;
768 Rgebak(&job, &side, static_cast<mplapackint>(n), static_cast<mplapackint>(first), static_cast<mplapackint>(last),
769 scale, static_cast<mplapackint>(vector_count), vectors, static_cast<mplapackint>(leading_dimension),
770 mplapack_info);
771 return static_cast<blas_int>(mplapack_info);
772}
773
774[[nodiscard]] inline blas_int geev(char jobvl, char jobvr, blas_int n, uni20::complex<uni20::float128>* a, blas_int lda,
775 uni20::complex<uni20::float128>* w, uni20::complex<uni20::float128>* vl,
776 blas_int ldvl, uni20::complex<uni20::float128>* vr, blas_int ldvr,
777 uni20::complex<uni20::float128>* work, blas_int lwork, uni20::float128* rwork)
778{
779 UNI20_EXTERNAL_API_CALL(LAPACK, Cgeev, jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork);
780 mplapackint mplapack_info = 0;
781 Cgeev(&jobvl, &jobvr, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), w, vl,
782 static_cast<mplapackint>(ldvl), vr, static_cast<mplapackint>(ldvr), work, static_cast<mplapackint>(lwork),
783 rwork, mplapack_info);
784 return static_cast<blas_int>(mplapack_info);
785}
786
787[[nodiscard]] inline blas_int gees(char jobvs, char sort, blas_int n, uni20::float128* a, blas_int lda,
788 blas_int& selected_dimension, uni20::float128* wr, uni20::float128* wi,
789 uni20::float128* vs, blas_int ldvs, uni20::float128* work, blas_int lwork,
790 blas_int* bwork)
791{
792 UNI20_EXTERNAL_API_CALL(LAPACK, Rgees, jobvs, sort, n, a, lda, selected_dimension, wr, wi, vs, ldvs, work, lwork,
793 bwork);
794 mplapackint mplapack_selected_dimension = static_cast<mplapackint>(selected_dimension);
795 mplapackint mplapack_info = 0;
796 blas_int const bwork_size = std::max<blas_int>(1, n);
797 std::unique_ptr<bool[]> mplapack_bwork;
798 if (bwork != nullptr)
799 {
800 mplapack_bwork = std::make_unique<bool[]>(static_cast<std::size_t>(bwork_size));
801 for (blas_int i = 0; i < n; ++i)
802 {
803 mplapack_bwork[static_cast<std::size_t>(i)] = bwork[i] != 0;
804 }
805 }
806 Rgees(&jobvs, &sort, nullptr, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda),
807 mplapack_selected_dimension, wr, wi, vs, static_cast<mplapackint>(ldvs), work, static_cast<mplapackint>(lwork),
808 mplapack_bwork.get(), mplapack_info);
809 selected_dimension = static_cast<blas_int>(mplapack_selected_dimension);
810 if (bwork != nullptr)
811 {
812 for (blas_int i = 0; i < n; ++i)
813 {
814 bwork[i] = mplapack_bwork[static_cast<std::size_t>(i)] ? 1 : 0;
815 }
816 }
817 return static_cast<blas_int>(mplapack_info);
818}
819
820[[nodiscard]] inline blas_int gees(char jobvs, char sort, blas_int n, uni20::complex<uni20::float128>* a, blas_int lda,
821 blas_int& selected_dimension, uni20::complex<uni20::float128>* w,
822 uni20::complex<uni20::float128>* vs, blas_int ldvs,
823 uni20::complex<uni20::float128>* work, blas_int lwork, uni20::float128* rwork,
824 blas_int* bwork)
825{
826 UNI20_EXTERNAL_API_CALL(LAPACK, Cgees, jobvs, sort, n, a, lda, selected_dimension, w, vs, ldvs, work, lwork, rwork,
827 bwork);
828 mplapackint mplapack_selected_dimension = static_cast<mplapackint>(selected_dimension);
829 mplapackint mplapack_info = 0;
830 blas_int const bwork_size = std::max<blas_int>(1, n);
831 std::unique_ptr<bool[]> mplapack_bwork;
832 if (bwork != nullptr)
833 {
834 mplapack_bwork = std::make_unique<bool[]>(static_cast<std::size_t>(bwork_size));
835 for (blas_int i = 0; i < n; ++i)
836 {
837 mplapack_bwork[static_cast<std::size_t>(i)] = bwork[i] != 0;
838 }
839 }
840 Cgees(&jobvs, &sort, nullptr, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda),
841 mplapack_selected_dimension, w, vs, static_cast<mplapackint>(ldvs), work, static_cast<mplapackint>(lwork),
842 rwork, mplapack_bwork.get(), mplapack_info);
843 selected_dimension = static_cast<blas_int>(mplapack_selected_dimension);
844 if (bwork != nullptr)
845 {
846 for (blas_int i = 0; i < n; ++i)
847 {
848 bwork[i] = mplapack_bwork[static_cast<std::size_t>(i)] ? 1 : 0;
849 }
850 }
851 return static_cast<blas_int>(mplapack_info);
852}
853
854[[nodiscard]] inline blas_int hseqr(char job, char compz, blas_int n, blas_int first, blas_int last, uni20::float128* h,
855 blas_int ldh, uni20::float128* wr, uni20::float128* wi, uni20::float128* z,
856 blas_int ldz, uni20::float128* work, blas_int lwork)
857{
858 UNI20_EXTERNAL_API_CALL(LAPACK, Rhseqr, job, compz, n, first, last, h, ldh, wr, wi, z, ldz, work, lwork);
859 mplapackint mplapack_info = 0;
860 Rhseqr(&job, &compz, static_cast<mplapackint>(n), static_cast<mplapackint>(first), static_cast<mplapackint>(last), h,
861 static_cast<mplapackint>(ldh), wr, wi, z, static_cast<mplapackint>(ldz), work, static_cast<mplapackint>(lwork),
862 mplapack_info);
863 return static_cast<blas_int>(mplapack_info);
864}
865
866[[nodiscard]] inline blas_int trexc(char compq, blas_int n, uni20::float128* t, blas_int ldt, uni20::float128* q,
867 blas_int ldq, blas_int& first, blas_int& last, uni20::float128* work)
868{
869 UNI20_EXTERNAL_API_CALL(LAPACK, Rtrexc, compq, n, t, ldt, q, ldq, first, last, work);
870 mplapackint mplapack_first = static_cast<mplapackint>(first);
871 mplapackint mplapack_last = static_cast<mplapackint>(last);
872 mplapackint mplapack_info = 0;
873 Rtrexc(&compq, static_cast<mplapackint>(n), t, static_cast<mplapackint>(ldt), q, static_cast<mplapackint>(ldq),
874 mplapack_first, mplapack_last, work, mplapack_info);
875 first = static_cast<blas_int>(mplapack_first);
876 last = static_cast<blas_int>(mplapack_last);
877 return static_cast<blas_int>(mplapack_info);
878}
879
880[[nodiscard]] inline blas_int trexc(char compq, blas_int n, uni20::complex<uni20::float128>* t, blas_int ldt,
881 uni20::complex<uni20::float128>* q, blas_int ldq, blas_int& first, blas_int& last)
882{
883 UNI20_EXTERNAL_API_CALL(LAPACK, Ctrexc, compq, n, t, ldt, q, ldq, first, last);
884 mplapackint mplapack_first = static_cast<mplapackint>(first);
885 mplapackint mplapack_last = static_cast<mplapackint>(last);
886 mplapackint mplapack_info = 0;
887 Ctrexc(&compq, static_cast<mplapackint>(n), t, static_cast<mplapackint>(ldt), q, static_cast<mplapackint>(ldq),
888 mplapack_first, mplapack_last, mplapack_info);
889 first = static_cast<blas_int>(mplapack_first);
890 last = static_cast<blas_int>(mplapack_last);
891 return static_cast<blas_int>(mplapack_info);
892}
893
894[[nodiscard]] inline blas_int trsen(char job, char compq, blas_int* select, blas_int n, uni20::float128* t,
895 blas_int ldt, uni20::float128* q, blas_int ldq, uni20::float128* wr,
896 uni20::float128* wi, blas_int& selected_dimension,
897 uni20::float128& reciprocal_eigenvalue_cluster_condition,
898 uni20::float128& reciprocal_invariant_subspace_condition, uni20::float128* work,
899 blas_int lwork, blas_int* iwork, blas_int liwork)
900{
901 UNI20_EXTERNAL_API_CALL(LAPACK, Rtrsen, job, compq, select, n, t, ldt, q, ldq, wr, wi, selected_dimension,
902 reciprocal_eigenvalue_cluster_condition, reciprocal_invariant_subspace_condition, work, lwork,
903 iwork, liwork);
904 mplapackint mplapack_selected_dimension = static_cast<mplapackint>(selected_dimension);
905 mplapackint mplapack_info = 0;
906 blas_int const select_size = std::max<blas_int>(1, n);
907 blas_int const iwork_size = std::max<blas_int>(1, liwork == -1 ? blas_int{1} : liwork);
908 std::unique_ptr<bool[]> mplapack_select;
909 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
910 if (select != nullptr)
911 {
912 mplapack_select = std::make_unique<bool[]>(static_cast<std::size_t>(select_size));
913 for (blas_int i = 0; i < n; ++i)
914 {
915 mplapack_select[static_cast<std::size_t>(i)] = select[i] != 0;
916 }
917 }
918 Rtrsen(&job, &compq, mplapack_select.get(), static_cast<mplapackint>(n), t, static_cast<mplapackint>(ldt), q,
919 static_cast<mplapackint>(ldq), wr, wi, mplapack_selected_dimension, reciprocal_eigenvalue_cluster_condition,
920 reciprocal_invariant_subspace_condition, work, static_cast<mplapackint>(lwork), mplapack_iwork.data(),
921 static_cast<mplapackint>(liwork), mplapack_info);
922 selected_dimension = static_cast<blas_int>(mplapack_selected_dimension);
923 if (select != nullptr)
924 {
925 for (blas_int i = 0; i < n; ++i)
926 {
927 select[i] = mplapack_select[static_cast<std::size_t>(i)] ? 1 : 0;
928 }
929 }
930 uni20::lapack::mplapack::detail::copy_from_mplapack_query_int_work(mplapack_iwork, iwork, liwork);
931 return static_cast<blas_int>(mplapack_info);
932}
933
934[[nodiscard]] inline blas_int trevc(char side, char howmny, blas_int* select, blas_int n, uni20::float128* t,
935 blas_int ldt, uni20::float128* vl, blas_int ldvl, uni20::float128* vr,
936 blas_int ldvr, blas_int mm, blas_int& computed_vectors, uni20::float128* work)
937{
938 UNI20_EXTERNAL_API_CALL(LAPACK, Rtrevc, side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, computed_vectors,
939 work);
940 mplapackint mplapack_computed_vectors = static_cast<mplapackint>(computed_vectors);
941 mplapackint mplapack_info = 0;
942 blas_int const select_size = std::max<blas_int>(1, n);
943 std::unique_ptr<bool[]> mplapack_select;
944 if (select != nullptr)
945 {
946 mplapack_select = std::make_unique<bool[]>(static_cast<std::size_t>(select_size));
947 for (blas_int i = 0; i < n; ++i)
948 {
949 mplapack_select[static_cast<std::size_t>(i)] = select[i] != 0;
950 }
951 }
952 Rtrevc(&side, &howmny, mplapack_select.get(), static_cast<mplapackint>(n), t, static_cast<mplapackint>(ldt), vl,
953 static_cast<mplapackint>(ldvl), vr, static_cast<mplapackint>(ldvr), static_cast<mplapackint>(mm),
954 mplapack_computed_vectors, work, mplapack_info);
955 computed_vectors = static_cast<blas_int>(mplapack_computed_vectors);
956 if (select != nullptr)
957 {
958 for (blas_int i = 0; i < n; ++i)
959 {
960 select[i] = mplapack_select[static_cast<std::size_t>(i)] ? 1 : 0;
961 }
962 }
963 return static_cast<blas_int>(mplapack_info);
964}
965
966[[nodiscard]] inline blas_int trsna(char job, char howmny, blas_int* select, blas_int n, uni20::float128* t,
967 blas_int ldt, uni20::float128* vl, blas_int ldvl, uni20::float128* vr,
968 blas_int ldvr, uni20::float128* reciprocal_eigenvalue_condition_numbers,
969 uni20::float128* reciprocal_eigenvector_condition_numbers, blas_int mm,
970 blas_int& computed_estimates, uni20::float128* work, blas_int ldwork,
971 blas_int* iwork)
972{
973 UNI20_EXTERNAL_API_CALL(LAPACK, Rtrsna, job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr,
974 reciprocal_eigenvalue_condition_numbers, reciprocal_eigenvector_condition_numbers, mm,
975 computed_estimates, work, ldwork, iwork);
976 mplapackint mplapack_computed_estimates = static_cast<mplapackint>(computed_estimates);
977 mplapackint mplapack_info = 0;
978 blas_int const select_size = std::max<blas_int>(1, n);
979 blas_int const iwork_size = std::max<blas_int>(1, 2 * std::max<blas_int>(1, n) - 2);
980 std::unique_ptr<bool[]> mplapack_select;
981 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
982 if (select != nullptr)
983 {
984 mplapack_select = std::make_unique<bool[]>(static_cast<std::size_t>(select_size));
985 for (blas_int i = 0; i < n; ++i)
986 {
987 mplapack_select[static_cast<std::size_t>(i)] = select[i] != 0;
988 }
989 }
990 Rtrsna(&job, &howmny, mplapack_select.get(), static_cast<mplapackint>(n), t, static_cast<mplapackint>(ldt), vl,
991 static_cast<mplapackint>(ldvl), vr, static_cast<mplapackint>(ldvr), reciprocal_eigenvalue_condition_numbers,
992 reciprocal_eigenvector_condition_numbers, static_cast<mplapackint>(mm), mplapack_computed_estimates, work,
993 static_cast<mplapackint>(ldwork), mplapack_iwork.data(), mplapack_info);
994 computed_estimates = static_cast<blas_int>(mplapack_computed_estimates);
995 if (select != nullptr)
996 {
997 for (blas_int i = 0; i < n; ++i)
998 {
999 select[i] = mplapack_select[static_cast<std::size_t>(i)] ? 1 : 0;
1000 }
1001 }
1002 return static_cast<blas_int>(mplapack_info);
1003}
1004
1005[[nodiscard]] inline blas_int ggev(char jobvl, char jobvr, blas_int n, uni20::float128* a, blas_int lda,
1006 uni20::float128* b, blas_int ldb, uni20::float128* alphar, uni20::float128* alphai,
1007 uni20::float128* beta, uni20::float128* vl, blas_int ldvl, uni20::float128* vr,
1008 blas_int ldvr, uni20::float128* work, blas_int lwork)
1009{
1010 UNI20_EXTERNAL_API_CALL(LAPACK, Rggev, jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr,
1011 work, lwork);
1012 mplapackint mplapack_info = 0;
1013 Rggev(&jobvl, &jobvr, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb),
1014 alphar, alphai, beta, vl, static_cast<mplapackint>(ldvl), vr, static_cast<mplapackint>(ldvr), work,
1015 static_cast<mplapackint>(lwork), mplapack_info);
1016 return static_cast<blas_int>(mplapack_info);
1017}
1018
1019[[nodiscard]] inline blas_int ggevx(char balanc, char jobvl, char jobvr, char sense, blas_int n, uni20::float128* a,
1020 blas_int lda, uni20::float128* b, blas_int ldb, uni20::float128* alphar,
1021 uni20::float128* alphai, uni20::float128* beta, uni20::float128* vl, blas_int ldvl,
1022 uni20::float128* vr, blas_int ldvr, blas_int& ilo, blas_int& ihi,
1023 uni20::float128* lscale, uni20::float128* rscale, uni20::float128& abnrm,
1024 uni20::float128& bbnrm, uni20::float128* rconde, uni20::float128* rcondv,
1025 uni20::float128* work, blas_int lwork, blas_int* iwork, blas_int* bwork)
1026{
1027 UNI20_EXTERNAL_API_CALL(LAPACK, Rggevx, balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alphar, alphai, beta, vl,
1028 ldvl, vr, ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, iwork,
1029 bwork);
1030 mplapackint mplapack_ilo = static_cast<mplapackint>(ilo);
1031 mplapackint mplapack_ihi = static_cast<mplapackint>(ihi);
1032 mplapackint mplapack_info = 0;
1033 blas_int const iwork_size = std::max<blas_int>(1, n + 6);
1034 blas_int const bwork_size = std::max<blas_int>(1, n);
1035 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
1036 std::unique_ptr<bool[]> mplapack_bwork;
1037 if (bwork != nullptr)
1038 {
1039 mplapack_bwork = std::make_unique<bool[]>(static_cast<std::size_t>(bwork_size));
1040 for (blas_int i = 0; i < n; ++i)
1041 {
1042 mplapack_bwork[static_cast<std::size_t>(i)] = bwork[i] != 0;
1043 }
1044 }
1045 Rggevx(&balanc, &jobvl, &jobvr, &sense, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), b,
1046 static_cast<mplapackint>(ldb), alphar, alphai, beta, vl, static_cast<mplapackint>(ldvl), vr,
1047 static_cast<mplapackint>(ldvr), mplapack_ilo, mplapack_ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work,
1048 static_cast<mplapackint>(lwork), mplapack_iwork.data(), mplapack_bwork.get(), mplapack_info);
1049 ilo = static_cast<blas_int>(mplapack_ilo);
1050 ihi = static_cast<blas_int>(mplapack_ihi);
1051 if (bwork != nullptr)
1052 {
1053 for (blas_int i = 0; i < n; ++i)
1054 {
1055 bwork[i] = mplapack_bwork[static_cast<std::size_t>(i)] ? 1 : 0;
1056 }
1057 }
1058 return static_cast<blas_int>(mplapack_info);
1059}
1060
1061[[nodiscard]] inline blas_int ggbal(char job, blas_int n, uni20::float128* a, blas_int lda, uni20::float128* b,
1062 blas_int ldb, blas_int& first, blas_int& last, uni20::float128* lscale,
1063 uni20::float128* rscale, uni20::float128* work)
1064{
1065 UNI20_EXTERNAL_API_CALL(LAPACK, Rggbal, job, n, a, lda, b, ldb, first, last, lscale, rscale, work);
1066 mplapackint mplapack_first = static_cast<mplapackint>(first);
1067 mplapackint mplapack_last = static_cast<mplapackint>(last);
1068 mplapackint mplapack_info = 0;
1069 Rggbal(&job, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb),
1070 mplapack_first, mplapack_last, lscale, rscale, work, mplapack_info);
1071 first = static_cast<blas_int>(mplapack_first);
1072 last = static_cast<blas_int>(mplapack_last);
1073 return static_cast<blas_int>(mplapack_info);
1074}
1075
1076[[nodiscard]] inline blas_int ggbak(char job, char side, blas_int n, blas_int first, blas_int last,
1077 uni20::float128* lscale, uni20::float128* rscale, blas_int vector_count,
1078 uni20::float128* vectors, blas_int leading_dimension)
1079{
1080 UNI20_EXTERNAL_API_CALL(LAPACK, Rggbak, job, side, n, first, last, lscale, rscale, vector_count, vectors,
1081 leading_dimension);
1082 mplapackint mplapack_info = 0;
1083 Rggbak(&job, &side, static_cast<mplapackint>(n), static_cast<mplapackint>(first), static_cast<mplapackint>(last),
1084 lscale, rscale, static_cast<mplapackint>(vector_count), vectors, static_cast<mplapackint>(leading_dimension),
1085 mplapack_info);
1086 return static_cast<blas_int>(mplapack_info);
1087}
1088
1089[[nodiscard]] inline blas_int gges(char jobvsl, char jobvsr, char sort, blas_int n, uni20::float128* a, blas_int lda,
1090 uni20::float128* b, blas_int ldb, blas_int& selected_dimension,
1091 uni20::float128* alphar, uni20::float128* alphai, uni20::float128* beta,
1092 uni20::float128* vsl, blas_int ldvsl, uni20::float128* vsr, blas_int ldvsr,
1093 uni20::float128* work, blas_int lwork, blas_int* bwork)
1094{
1095 UNI20_EXTERNAL_API_CALL(LAPACK, Rgges, jobvsl, jobvsr, sort, n, a, lda, b, ldb, selected_dimension, alphar, alphai,
1096 beta, vsl, ldvsl, vsr, ldvsr, work, lwork, bwork);
1097 mplapackint mplapack_selected_dimension = static_cast<mplapackint>(selected_dimension);
1098 mplapackint mplapack_info = 0;
1099 blas_int const bwork_size = std::max<blas_int>(1, n);
1100 std::unique_ptr<bool[]> mplapack_bwork;
1101 if (bwork != nullptr)
1102 {
1103 mplapack_bwork = std::make_unique<bool[]>(static_cast<std::size_t>(bwork_size));
1104 }
1105 Rgges(&jobvsl, &jobvsr, &sort, nullptr, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), b,
1106 static_cast<mplapackint>(ldb), mplapack_selected_dimension, alphar, alphai, beta, vsl,
1107 static_cast<mplapackint>(ldvsl), vsr, static_cast<mplapackint>(ldvsr), work, static_cast<mplapackint>(lwork),
1108 mplapack_bwork.get(), mplapack_info);
1109 selected_dimension = static_cast<blas_int>(mplapack_selected_dimension);
1110 if (bwork != nullptr)
1111 {
1112 for (blas_int i = 0; i < n; ++i)
1113 {
1114 bwork[i] = mplapack_bwork[static_cast<std::size_t>(i)] ? 1 : 0;
1115 }
1116 }
1117 return static_cast<blas_int>(mplapack_info);
1118}
1119
1120[[nodiscard]] inline blas_int gghrd(char compq, char compz, blas_int n, blas_int first, blas_int last,
1121 uni20::float128* a, blas_int lda, uni20::float128* b, blas_int ldb,
1122 uni20::float128* q, blas_int ldq, uni20::float128* z, blas_int ldz)
1123{
1124 UNI20_EXTERNAL_API_CALL(LAPACK, Rgghrd, compq, compz, n, first, last, a, lda, b, ldb, q, ldq, z, ldz);
1125 mplapackint mplapack_info = 0;
1126 Rgghrd(&compq, &compz, static_cast<mplapackint>(n), static_cast<mplapackint>(first), static_cast<mplapackint>(last),
1127 a, static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb), q, static_cast<mplapackint>(ldq), z,
1128 static_cast<mplapackint>(ldz), mplapack_info);
1129 return static_cast<blas_int>(mplapack_info);
1130}
1131
1132[[nodiscard]] inline blas_int hgeqz(char job, char compq, char compz, blas_int n, blas_int first, blas_int last,
1133 uni20::float128* h, blas_int ldh, uni20::float128* t, blas_int ldt,
1134 uni20::float128* alphar, uni20::float128* alphai, uni20::float128* beta,
1135 uni20::float128* q, blas_int ldq, uni20::float128* z, blas_int ldz,
1136 uni20::float128* work, blas_int lwork)
1137{
1138 UNI20_EXTERNAL_API_CALL(LAPACK, Rhgeqz, job, compq, compz, n, first, last, h, ldh, t, ldt, alphar, alphai, beta, q,
1139 ldq, z, ldz, work, lwork);
1140 mplapackint mplapack_info = 0;
1141 Rhgeqz(&job, &compq, &compz, static_cast<mplapackint>(n), static_cast<mplapackint>(first),
1142 static_cast<mplapackint>(last), h, static_cast<mplapackint>(ldh), t, static_cast<mplapackint>(ldt), alphar,
1143 alphai, beta, q, static_cast<mplapackint>(ldq), z, static_cast<mplapackint>(ldz), work,
1144 static_cast<mplapackint>(lwork), mplapack_info);
1145 return static_cast<blas_int>(mplapack_info);
1146}
1147
1148[[nodiscard]] inline blas_int tgexc(bool wantq, bool wantz, blas_int n, uni20::float128* a, blas_int lda,
1149 uni20::float128* b, blas_int ldb, uni20::float128* q, blas_int ldq,
1150 uni20::float128* z, blas_int ldz, blas_int& first, blas_int& last,
1151 uni20::float128* work, blas_int lwork)
1152{
1153 UNI20_EXTERNAL_API_CALL(LAPACK, Rtgexc, wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, first, last, work, lwork);
1154 mplapackint mplapack_first = static_cast<mplapackint>(first);
1155 mplapackint mplapack_last = static_cast<mplapackint>(last);
1156 mplapackint mplapack_info = 0;
1157 Rtgexc(wantq, wantz, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb),
1158 q, static_cast<mplapackint>(ldq), z, static_cast<mplapackint>(ldz), mplapack_first, mplapack_last, work,
1159 static_cast<mplapackint>(lwork), mplapack_info);
1160 first = static_cast<blas_int>(mplapack_first);
1161 last = static_cast<blas_int>(mplapack_last);
1162 return static_cast<blas_int>(mplapack_info);
1163}
1164
1165[[nodiscard]] inline blas_int tgsen(blas_int ijob, bool wantq, bool wantz, blas_int* select, blas_int n,
1166 uni20::float128* a, blas_int lda, uni20::float128* b, blas_int ldb,
1167 uni20::float128* alphar, uni20::float128* alphai, uni20::float128* beta,
1168 uni20::float128* q, blas_int ldq, uni20::float128* z, blas_int ldz,
1169 blas_int& selected_dimension, uni20::float128& pl, uni20::float128& pr,
1170 uni20::float128* dif, uni20::float128* work, blas_int lwork, blas_int* iwork,
1171 blas_int liwork)
1172{
1173 UNI20_EXTERNAL_API_CALL(LAPACK, Rtgsen, ijob, wantq, wantz, select, n, a, lda, b, ldb, alphar, alphai, beta, q, ldq,
1174 z, ldz, selected_dimension, pl, pr, dif, work, lwork, iwork, liwork);
1175 mplapackint mplapack_selected_dimension = static_cast<mplapackint>(selected_dimension);
1176 mplapackint mplapack_info = 0;
1177 blas_int const select_size = std::max<blas_int>(1, n);
1178 blas_int const iwork_size = std::max<blas_int>(1, liwork == -1 ? blas_int{1} : liwork);
1179 std::unique_ptr<bool[]> mplapack_select;
1180 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
1181 if (select != nullptr)
1182 {
1183 mplapack_select = std::make_unique<bool[]>(static_cast<std::size_t>(select_size));
1184 for (blas_int i = 0; i < n; ++i)
1185 {
1186 mplapack_select[static_cast<std::size_t>(i)] = select[i] != 0;
1187 }
1188 }
1189 Rtgsen(static_cast<mplapackint>(ijob), wantq, wantz, mplapack_select.get(), static_cast<mplapackint>(n), a,
1190 static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb), alphar, alphai, beta, q,
1191 static_cast<mplapackint>(ldq), z, static_cast<mplapackint>(ldz), mplapack_selected_dimension, pl, pr, dif,
1192 work, static_cast<mplapackint>(lwork), mplapack_iwork.data(), static_cast<mplapackint>(liwork), mplapack_info);
1193 selected_dimension = static_cast<blas_int>(mplapack_selected_dimension);
1194 if (select != nullptr)
1195 {
1196 for (blas_int i = 0; i < n; ++i)
1197 {
1198 select[i] = mplapack_select[static_cast<std::size_t>(i)] ? 1 : 0;
1199 }
1200 }
1201 uni20::lapack::mplapack::detail::copy_from_mplapack_query_int_work(mplapack_iwork, iwork, liwork);
1202 return static_cast<blas_int>(mplapack_info);
1203}
1204
1205[[nodiscard]] inline blas_int tgevc(char side, char howmny, blas_int* select, blas_int n, uni20::float128* s,
1206 blas_int lds, uni20::float128* p, blas_int ldp, uni20::float128* vl, blas_int ldvl,
1207 uni20::float128* vr, blas_int ldvr, blas_int mm, blas_int& computed_vectors,
1208 uni20::float128* work)
1209{
1210 UNI20_EXTERNAL_API_CALL(LAPACK, Rtgevc, side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm,
1211 computed_vectors, work);
1212 mplapackint mplapack_computed_vectors = static_cast<mplapackint>(computed_vectors);
1213 mplapackint mplapack_info = 0;
1214 blas_int const select_size = std::max<blas_int>(1, n);
1215 std::unique_ptr<bool[]> mplapack_select;
1216 if (select != nullptr)
1217 {
1218 mplapack_select = std::make_unique<bool[]>(static_cast<std::size_t>(select_size));
1219 for (blas_int i = 0; i < n; ++i)
1220 {
1221 mplapack_select[static_cast<std::size_t>(i)] = select[i] != 0;
1222 }
1223 }
1224 Rtgevc(&side, &howmny, mplapack_select.get(), static_cast<mplapackint>(n), s, static_cast<mplapackint>(lds), p,
1225 static_cast<mplapackint>(ldp), vl, static_cast<mplapackint>(ldvl), vr, static_cast<mplapackint>(ldvr),
1226 static_cast<mplapackint>(mm), mplapack_computed_vectors, work, mplapack_info);
1227 computed_vectors = static_cast<blas_int>(mplapack_computed_vectors);
1228 if (select != nullptr)
1229 {
1230 for (blas_int i = 0; i < n; ++i)
1231 {
1232 select[i] = mplapack_select[static_cast<std::size_t>(i)] ? 1 : 0;
1233 }
1234 }
1235 return static_cast<blas_int>(mplapack_info);
1236}
1237
1238[[nodiscard]] inline blas_int tgsna(char job, char howmny, blas_int* select, blas_int n, uni20::float128* a,
1239 blas_int lda, uni20::float128* b, blas_int ldb, uni20::float128* vl, blas_int ldvl,
1240 uni20::float128* vr, blas_int ldvr,
1241 uni20::float128* reciprocal_eigenvalue_condition_numbers,
1242 uni20::float128* reciprocal_eigenvector_condition_numbers, blas_int mm,
1243 blas_int& computed_estimates, uni20::float128* work, blas_int lwork,
1244 blas_int* iwork)
1245{
1246 UNI20_EXTERNAL_API_CALL(LAPACK, Rtgsna, job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr,
1247 reciprocal_eigenvalue_condition_numbers, reciprocal_eigenvector_condition_numbers, mm,
1248 computed_estimates, work, lwork, iwork);
1249 mplapackint mplapack_computed_estimates = static_cast<mplapackint>(computed_estimates);
1250 mplapackint mplapack_info = 0;
1251 blas_int const select_size = std::max<blas_int>(1, n);
1252 blas_int const iwork_size = std::max<blas_int>(1, n + 6);
1253 std::unique_ptr<bool[]> mplapack_select;
1254 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
1255 if (select != nullptr)
1256 {
1257 mplapack_select = std::make_unique<bool[]>(static_cast<std::size_t>(select_size));
1258 for (blas_int i = 0; i < n; ++i)
1259 {
1260 mplapack_select[static_cast<std::size_t>(i)] = select[i] != 0;
1261 }
1262 }
1263 Rtgsna(&job, &howmny, mplapack_select.get(), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), b,
1264 static_cast<mplapackint>(ldb), vl, static_cast<mplapackint>(ldvl), vr, static_cast<mplapackint>(ldvr),
1265 reciprocal_eigenvalue_condition_numbers, reciprocal_eigenvector_condition_numbers,
1266 static_cast<mplapackint>(mm), mplapack_computed_estimates, work, static_cast<mplapackint>(lwork),
1267 mplapack_iwork.data(), mplapack_info);
1268 computed_estimates = static_cast<blas_int>(mplapack_computed_estimates);
1269 if (select != nullptr)
1270 {
1271 for (blas_int i = 0; i < n; ++i)
1272 {
1273 select[i] = mplapack_select[static_cast<std::size_t>(i)] ? 1 : 0;
1274 }
1275 }
1276 return static_cast<blas_int>(mplapack_info);
1277}
1278
1279[[nodiscard]] inline blas_int orgbr(char vect, blas_int m, blas_int n, blas_int k, uni20::float128* a, blas_int lda,
1280 uni20::float128* tau, uni20::float128* work, blas_int lwork)
1281{
1282 UNI20_EXTERNAL_API_CALL(LAPACK, Rorgbr, vect, m, n, k, a, lda, tau, work, lwork);
1283 mplapackint mplapack_info = 0;
1284 Rorgbr(&vect, static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(k), a,
1285 static_cast<mplapackint>(lda), tau, work, static_cast<mplapackint>(lwork), mplapack_info);
1286 return static_cast<blas_int>(mplapack_info);
1287}
1288
1289[[nodiscard]] inline blas_int orghr(blas_int n, blas_int first, blas_int last, uni20::float128* a, blas_int lda,
1290 uni20::float128 const* tau, uni20::float128* work, blas_int lwork)
1291{
1292 UNI20_EXTERNAL_API_CALL(LAPACK, Rorghr, n, first, last, a, lda, tau, work, lwork);
1293 mplapackint mplapack_info = 0;
1294 Rorghr(static_cast<mplapackint>(n), static_cast<mplapackint>(first), static_cast<mplapackint>(last), a,
1295 static_cast<mplapackint>(lda), const_cast<uni20::float128*>(tau), work, static_cast<mplapackint>(lwork),
1296 mplapack_info);
1297 return static_cast<blas_int>(mplapack_info);
1298}
1299
1300[[nodiscard]] inline blas_int orgtr(char uplo, blas_int n, uni20::float128* a, blas_int lda, uni20::float128 const* tau,
1301 uni20::float128* work, blas_int lwork)
1302{
1303 UNI20_EXTERNAL_API_CALL(LAPACK, Rorgtr, uplo, n, a, lda, tau, work, lwork);
1304 mplapackint mplapack_info = 0;
1305 Rorgtr(&uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), const_cast<uni20::float128*>(tau), work,
1306 static_cast<mplapackint>(lwork), mplapack_info);
1307 return static_cast<blas_int>(mplapack_info);
1308}
1309
1310[[nodiscard]] inline blas_int ormhr(char side, char trans, blas_int m, blas_int n, blas_int first, blas_int last,
1311 uni20::float128* a, blas_int lda, uni20::float128 const* tau, uni20::float128* c,
1312 blas_int ldc, uni20::float128* work, blas_int lwork)
1313{
1314 UNI20_EXTERNAL_API_CALL(LAPACK, Rormhr, side, trans, m, n, first, last, a, lda, tau, c, ldc, work, lwork);
1315 mplapackint mplapack_info = 0;
1316 Rormhr(&side, &trans, static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(first),
1317 static_cast<mplapackint>(last), a, static_cast<mplapackint>(lda), const_cast<uni20::float128*>(tau), c,
1318 static_cast<mplapackint>(ldc), work, static_cast<mplapackint>(lwork), mplapack_info);
1319 return static_cast<blas_int>(mplapack_info);
1320}
1321
1322[[nodiscard]] inline blas_int ormtr(char side, char uplo, char trans, blas_int m, blas_int n, uni20::float128* a,
1323 blas_int lda, uni20::float128 const* tau, uni20::float128* c, blas_int ldc,
1324 uni20::float128* work, blas_int lwork)
1325{
1326 UNI20_EXTERNAL_API_CALL(LAPACK, Rormtr, side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork);
1327 mplapackint mplapack_info = 0;
1328 Rormtr(&side, &uplo, &trans, static_cast<mplapackint>(m), static_cast<mplapackint>(n), a,
1329 static_cast<mplapackint>(lda), const_cast<uni20::float128*>(tau), c, static_cast<mplapackint>(ldc), work,
1330 static_cast<mplapackint>(lwork), mplapack_info);
1331 return static_cast<blas_int>(mplapack_info);
1332}
1333
1334[[nodiscard]] inline blas_int ormbr(char vect, char side, char trans, blas_int m, blas_int n, blas_int k,
1335 uni20::float128* a, blas_int lda, uni20::float128* tau, uni20::float128* c,
1336 blas_int ldc, uni20::float128* work, blas_int lwork)
1337{
1338 UNI20_EXTERNAL_API_CALL(LAPACK, Rormbr, vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork);
1339 mplapackint mplapack_info = 0;
1340 Rormbr(&vect, &side, &trans, static_cast<mplapackint>(m), static_cast<mplapackint>(n), static_cast<mplapackint>(k), a,
1341 static_cast<mplapackint>(lda), tau, c, static_cast<mplapackint>(ldc), work, static_cast<mplapackint>(lwork),
1342 mplapack_info);
1343 return static_cast<blas_int>(mplapack_info);
1344}
1345
1346[[nodiscard]] inline blas_int gesvd(char jobu, char jobvt, blas_int m, blas_int n, uni20::float128* a, blas_int lda,
1347 uni20::float128* s, uni20::float128* u, blas_int ldu, uni20::float128* vt,
1348 blas_int ldvt, uni20::float128* work, blas_int lwork)
1349{
1350 UNI20_EXTERNAL_API_CALL(LAPACK, Rgesvd, jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork);
1351 mplapackint mplapack_info = 0;
1352 Rgesvd(&jobu, &jobvt, static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), s,
1353 u, static_cast<mplapackint>(ldu), vt, static_cast<mplapackint>(ldvt), work, static_cast<mplapackint>(lwork),
1354 mplapack_info);
1355 return static_cast<blas_int>(mplapack_info);
1356}
1357
1358[[nodiscard]] inline blas_int gesvd(char jobu, char jobvt, blas_int m, blas_int n, uni20::complex<uni20::float128>* a,
1359 blas_int lda, uni20::float128* s, uni20::complex<uni20::float128>* u, blas_int ldu,
1360 uni20::complex<uni20::float128>* vt, blas_int ldvt,
1361 uni20::complex<uni20::float128>* work, blas_int lwork, uni20::float128* rwork)
1362{
1363 UNI20_EXTERNAL_API_CALL(LAPACK, Cgesvd, jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork);
1364 mplapackint mplapack_info = 0;
1365 Cgesvd(&jobu, &jobvt, static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), s,
1366 u, static_cast<mplapackint>(ldu), vt, static_cast<mplapackint>(ldvt), work, static_cast<mplapackint>(lwork),
1367 rwork, mplapack_info);
1368 return static_cast<blas_int>(mplapack_info);
1369}
1370
1371[[nodiscard]] inline blas_int gesdd(char jobz, blas_int m, blas_int n, uni20::float128* a, blas_int lda,
1372 uni20::float128* s, uni20::float128* u, blas_int ldu, uni20::float128* vt,
1373 blas_int ldvt, uni20::float128* work, blas_int lwork, blas_int* iwork)
1374{
1375 UNI20_EXTERNAL_API_CALL(LAPACK, Rgesdd, jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork);
1376 mplapackint mplapack_info = 0;
1377 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(8 * std::min(m, n));
1378 Rgesdd(&jobz, static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), s, u,
1379 static_cast<mplapackint>(ldu), vt, static_cast<mplapackint>(ldvt), work, static_cast<mplapackint>(lwork),
1380 mplapack_iwork.data(), mplapack_info);
1381 return static_cast<blas_int>(mplapack_info);
1382}
1383
1384[[nodiscard]] inline blas_int gesdd(char jobz, blas_int m, blas_int n, uni20::complex<uni20::float128>* a, blas_int lda,
1385 uni20::float128* s, uni20::complex<uni20::float128>* u, blas_int ldu,
1386 uni20::complex<uni20::float128>* vt, blas_int ldvt,
1387 uni20::complex<uni20::float128>* work, blas_int lwork, uni20::float128* rwork,
1388 blas_int* iwork)
1389{
1390 UNI20_EXTERNAL_API_CALL(LAPACK, Cgesdd, jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork);
1391 mplapackint mplapack_info = 0;
1392 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(8 * std::min(m, n));
1393 Cgesdd(&jobz, static_cast<mplapackint>(m), static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), s, u,
1394 static_cast<mplapackint>(ldu), vt, static_cast<mplapackint>(ldvt), work, static_cast<mplapackint>(lwork),
1395 rwork, mplapack_iwork.data(), mplapack_info);
1396 return static_cast<blas_int>(mplapack_info);
1397}
1398
1399[[nodiscard]] inline blas_int gesvdx(char jobu, char jobvt, char range, blas_int m, blas_int n, uni20::float128* a,
1400 blas_int lda, uni20::float128 vl, uni20::float128 vu, blas_int il, blas_int iu,
1401 blas_int& selected_count, uni20::float128* singular_values, uni20::float128* u,
1402 blas_int ldu, uni20::float128* vt, blas_int ldvt, uni20::float128* work,
1403 blas_int lwork, blas_int* iwork)
1404{
1405 UNI20_EXTERNAL_API_CALL(LAPACK, Rgesvdx, jobu, jobvt, range, m, n, a, lda, vl, vu, il, iu, selected_count,
1406 singular_values, u, ldu, vt, ldvt, work, lwork, iwork);
1407 mplapackint mplapack_selected_count = static_cast<mplapackint>(selected_count);
1408 mplapackint mplapack_info = 0;
1409 blas_int const iwork_size = 12 * std::max<blas_int>(1, std::min(m, n));
1410 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
1411 Rgesvdx(&jobu, &jobvt, &range, static_cast<mplapackint>(m), static_cast<mplapackint>(n), a,
1412 static_cast<mplapackint>(lda), vl, vu, static_cast<mplapackint>(il), static_cast<mplapackint>(iu),
1413 mplapack_selected_count, singular_values, u, static_cast<mplapackint>(ldu), vt,
1414 static_cast<mplapackint>(ldvt), work, static_cast<mplapackint>(lwork), mplapack_iwork.data(), mplapack_info);
1415 selected_count = static_cast<blas_int>(mplapack_selected_count);
1416 return static_cast<blas_int>(mplapack_info);
1417}
1418
1419[[nodiscard]] inline blas_int gesvdx(char jobu, char jobvt, char range, blas_int m, blas_int n,
1420 uni20::complex<uni20::float128>* a, blas_int lda, uni20::float128 vl,
1421 uni20::float128 vu, blas_int il, blas_int iu, blas_int& selected_count,
1422 uni20::float128* singular_values, uni20::complex<uni20::float128>* u, blas_int ldu,
1423 uni20::complex<uni20::float128>* vt, blas_int ldvt,
1424 uni20::complex<uni20::float128>* work, blas_int lwork, uni20::float128* rwork,
1425 blas_int* iwork)
1426{
1427 UNI20_EXTERNAL_API_CALL(LAPACK, Cgesvdx, jobu, jobvt, range, m, n, a, lda, vl, vu, il, iu, selected_count,
1428 singular_values, u, ldu, vt, ldvt, work, lwork, rwork, iwork);
1429 mplapackint mplapack_selected_count = static_cast<mplapackint>(selected_count);
1430 mplapackint mplapack_info = 0;
1431 blas_int const iwork_size = 12 * std::max<blas_int>(1, std::min(m, n));
1432 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
1433 Cgesvdx(&jobu, &jobvt, &range, static_cast<mplapackint>(m), static_cast<mplapackint>(n), a,
1434 static_cast<mplapackint>(lda), vl, vu, static_cast<mplapackint>(il), static_cast<mplapackint>(iu),
1435 mplapack_selected_count, singular_values, u, static_cast<mplapackint>(ldu), vt,
1436 static_cast<mplapackint>(ldvt), work, static_cast<mplapackint>(lwork), rwork, mplapack_iwork.data(),
1437 mplapack_info);
1438 selected_count = static_cast<blas_int>(mplapack_selected_count);
1439 return static_cast<blas_int>(mplapack_info);
1440}
1441
1442[[nodiscard]] inline blas_int bdsqr(char uplo, blas_int n, blas_int ncvt, blas_int nru, blas_int ncc,
1443 uni20::float128* d, uni20::float128* e, uni20::float128* vt, blas_int ldvt,
1444 uni20::float128* u, blas_int ldu, uni20::float128* c, blas_int ldc,
1445 uni20::float128* work)
1446{
1447 UNI20_EXTERNAL_API_CALL(LAPACK, Rbdsqr, uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work);
1448 mplapackint mplapack_info = 0;
1449 Rbdsqr(&uplo, static_cast<mplapackint>(n), static_cast<mplapackint>(ncvt), static_cast<mplapackint>(nru),
1450 static_cast<mplapackint>(ncc), d, e, vt, static_cast<mplapackint>(ldvt), u, static_cast<mplapackint>(ldu), c,
1451 static_cast<mplapackint>(ldc), work, mplapack_info);
1452 return static_cast<blas_int>(mplapack_info);
1453}
1454
1455[[nodiscard]] inline blas_int bdsdc(char uplo, char compq, blas_int n, uni20::float128* d, uni20::float128* e,
1456 uni20::float128* u, blas_int ldu, uni20::float128* vt, blas_int ldvt,
1457 uni20::float128* q, blas_int* iq, uni20::float128* work, blas_int* iwork)
1458{
1459 UNI20_EXTERNAL_API_CALL(LAPACK, Rbdsdc, uplo, compq, n, d, e, u, ldu, vt, ldvt, q, iq, work, iwork);
1460 mplapackint mplapack_info = 0;
1461 std::vector<mplapackint> mplapack_iq = uni20::lapack::mplapack::detail::to_mplapack_ints(iq, 1);
1462 blas_int const iwork_size = 8 * std::max<blas_int>(1, n);
1463 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
1464 Rbdsdc(&uplo, &compq, static_cast<mplapackint>(n), d, e, u, static_cast<mplapackint>(ldu), vt,
1465 static_cast<mplapackint>(ldvt), q, mplapack_iq.data(), work, mplapack_iwork.data(), mplapack_info);
1466 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_iq, iq, 1);
1467 return static_cast<blas_int>(mplapack_info);
1468}
1469
1470[[nodiscard]] inline blas_int bdsvdx(char uplo, char jobz, char range, blas_int n, uni20::float128* d,
1471 uni20::float128* e, uni20::float128 vl, uni20::float128 vu, blas_int il,
1472 blas_int iu, blas_int& selected_count, uni20::float128* singular_values,
1473 uni20::float128* z, blas_int ldz, uni20::float128* work, blas_int* iwork)
1474{
1475 UNI20_EXTERNAL_API_CALL(LAPACK, Rbdsvdx, uplo, jobz, range, n, d, e, vl, vu, il, iu, selected_count, singular_values,
1476 z, ldz, work, iwork);
1477 mplapackint mplapack_selected_count = static_cast<mplapackint>(selected_count);
1478 mplapackint mplapack_info = 0;
1479 blas_int const iwork_size = 12 * std::max<blas_int>(1, n);
1480 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(iwork_size);
1481 Rbdsvdx(&uplo, &jobz, &range, static_cast<mplapackint>(n), d, e, vl, vu, static_cast<mplapackint>(il),
1482 static_cast<mplapackint>(iu), mplapack_selected_count, singular_values, z, static_cast<mplapackint>(ldz),
1483 work, mplapack_iwork.data(), mplapack_info);
1484 selected_count = static_cast<blas_int>(mplapack_selected_count);
1485 return static_cast<blas_int>(mplapack_info);
1486}
1487
1488[[nodiscard]] inline blas_int potrf(char uplo, blas_int n, uni20::float128* a, blas_int lda)
1489{
1490 UNI20_EXTERNAL_API_CALL(LAPACK, Rpotrf, uplo, n, a, lda);
1491 mplapackint mplapack_info = 0;
1492 Rpotrf(&uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), mplapack_info);
1493 return static_cast<blas_int>(mplapack_info);
1494}
1495
1496[[nodiscard]] inline blas_int pstrf(char uplo, blas_int n, uni20::float128* a, blas_int lda, blas_int* pivots,
1497 blas_int& rank, uni20::float128 tolerance, uni20::float128* work)
1498{
1499 UNI20_EXTERNAL_API_CALL(LAPACK, Rpstrf, uplo, n, a, lda, pivots, rank, tolerance, work);
1500 mplapackint mplapack_rank = static_cast<mplapackint>(rank);
1501 mplapackint mplapack_info = 0;
1502 std::vector<mplapackint> mplapack_pivots = uni20::lapack::mplapack::detail::to_mplapack_ints(pivots, n);
1503 Rpstrf(&uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), mplapack_pivots.data(), mplapack_rank,
1504 tolerance, work, mplapack_info);
1505 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_pivots, pivots, n);
1506 rank = static_cast<blas_int>(mplapack_rank);
1507 return static_cast<blas_int>(mplapack_info);
1508}
1509
1510[[nodiscard]] inline blas_int potri(char uplo, blas_int n, uni20::float128* a, blas_int lda)
1511{
1512 UNI20_EXTERNAL_API_CALL(LAPACK, Rpotri, uplo, n, a, lda);
1513 mplapackint mplapack_info = 0;
1514 Rpotri(&uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), mplapack_info);
1515 return static_cast<blas_int>(mplapack_info);
1516}
1517
1518[[nodiscard]] inline blas_int potrs(char uplo, blas_int n, blas_int nrhs, uni20::float128* a, blas_int lda,
1519 uni20::float128* b, blas_int ldb)
1520{
1521 UNI20_EXTERNAL_API_CALL(LAPACK, Rpotrs, uplo, n, nrhs, a, lda, b, ldb);
1522 mplapackint mplapack_info = 0;
1523 Rpotrs(&uplo, static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a, static_cast<mplapackint>(lda), b,
1524 static_cast<mplapackint>(ldb), mplapack_info);
1525 return static_cast<blas_int>(mplapack_info);
1526}
1527
1528[[nodiscard]] inline blas_int porfs(char uplo, blas_int n, blas_int nrhs, uni20::float128* a, blas_int lda,
1529 uni20::float128* factors, blas_int factor_lda, uni20::float128* b, blas_int ldb,
1530 uni20::float128* x, blas_int ldx, uni20::float128* forward_error,
1531 uni20::float128* backward_error, uni20::float128* work, blas_int* iwork)
1532{
1533 UNI20_EXTERNAL_API_CALL(LAPACK, Rporfs, uplo, n, nrhs, a, lda, factors, factor_lda, b, ldb, x, ldx, forward_error,
1534 backward_error, work, iwork);
1535 mplapackint mplapack_info = 0;
1536 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(n);
1537 Rporfs(&uplo, static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a, static_cast<mplapackint>(lda), factors,
1538 static_cast<mplapackint>(factor_lda), b, static_cast<mplapackint>(ldb), x, static_cast<mplapackint>(ldx),
1539 forward_error, backward_error, work, mplapack_iwork.data(), mplapack_info);
1540 return static_cast<blas_int>(mplapack_info);
1541}
1542
1543[[nodiscard]] inline blas_int posvx(char fact, char uplo, blas_int n, blas_int nrhs, uni20::float128* a, blas_int lda,
1544 uni20::float128* af, blas_int ldaf, char& equed, uni20::float128* scale,
1545 uni20::float128* b, blas_int ldb, uni20::float128* x, blas_int ldx,
1546 uni20::float128& rcond, uni20::float128* forward_error,
1547 uni20::float128* backward_error, uni20::float128* work, blas_int* iwork)
1548{
1549 UNI20_EXTERNAL_API_CALL(LAPACK, Rposvx, fact, uplo, n, nrhs, a, lda, af, ldaf, equed, scale, b, ldb, x, ldx, work,
1550 iwork);
1551 mplapackint mplapack_info = 0;
1552 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(n);
1553 Rposvx(&fact, &uplo, static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a, static_cast<mplapackint>(lda),
1554 af, static_cast<mplapackint>(ldaf), &equed, scale, b, static_cast<mplapackint>(ldb), x,
1555 static_cast<mplapackint>(ldx), rcond, forward_error, backward_error, work, mplapack_iwork.data(),
1556 mplapack_info);
1557 return static_cast<blas_int>(mplapack_info);
1558}
1559
1560[[nodiscard]] inline blas_int poequ(blas_int n, uni20::float128* a, blas_int lda, uni20::float128* scale,
1561 uni20::float128& scale_condition, uni20::float128& max_abs)
1562{
1563 UNI20_EXTERNAL_API_CALL(LAPACK, Rpoequ, n, a, lda, scale);
1564 mplapackint mplapack_info = 0;
1565 Rpoequ(static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), scale, scale_condition, max_abs, mplapack_info);
1566 return static_cast<blas_int>(mplapack_info);
1567}
1568
1569[[nodiscard]] inline blas_int pocon(char uplo, blas_int n, uni20::float128* a, blas_int lda,
1570 uni20::float128 matrix_one_norm, uni20::float128& rcond, uni20::float128* work,
1571 blas_int* iwork)
1572{
1573 UNI20_EXTERNAL_API_CALL(LAPACK, Rpocon, uplo, n, a, lda, matrix_one_norm, work, iwork);
1574 mplapackint mplapack_info = 0;
1575 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(n);
1576 Rpocon(&uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), matrix_one_norm, rcond, work,
1577 mplapack_iwork.data(), mplapack_info);
1578 return static_cast<blas_int>(mplapack_info);
1579}
1580
1581[[nodiscard]] inline blas_int sytrf(char uplo, blas_int n, uni20::float128* a, blas_int lda, blas_int* ipiv,
1582 uni20::float128* work, blas_int lwork)
1583{
1584 UNI20_EXTERNAL_API_CALL(LAPACK, Rsytrf, uplo, n, a, lda, ipiv, work, lwork);
1585 mplapackint mplapack_info = 0;
1586 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::make_mplapack_int_work(n);
1587 Rsytrf(&uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), mplapack_ipiv.data(), work,
1588 static_cast<mplapackint>(lwork), mplapack_info);
1589 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_ipiv, ipiv, n);
1590 return static_cast<blas_int>(mplapack_info);
1591}
1592
1593[[nodiscard]] inline blas_int sytrs(char uplo, blas_int n, blas_int nrhs, uni20::float128* a, blas_int lda,
1594 blas_int const* ipiv, uni20::float128* b, blas_int ldb)
1595{
1596 UNI20_EXTERNAL_API_CALL(LAPACK, Rsytrs, uplo, n, nrhs, a, lda, ipiv, b, ldb);
1597 mplapackint mplapack_info = 0;
1598 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::to_mplapack_ints(ipiv, n);
1599 Rsytrs(&uplo, static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a, static_cast<mplapackint>(lda),
1600 mplapack_ipiv.data(), b, static_cast<mplapackint>(ldb), mplapack_info);
1601 return static_cast<blas_int>(mplapack_info);
1602}
1603
1604[[nodiscard]] inline blas_int sytri(char uplo, blas_int n, uni20::float128* a, blas_int lda, blas_int const* ipiv,
1605 uni20::float128* work)
1606{
1607 UNI20_EXTERNAL_API_CALL(LAPACK, Rsytri, uplo, n, a, lda, ipiv, work);
1608 mplapackint mplapack_info = 0;
1609 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::to_mplapack_ints(ipiv, n);
1610 Rsytri(&uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), mplapack_ipiv.data(), work,
1611 mplapack_info);
1612 return static_cast<blas_int>(mplapack_info);
1613}
1614
1615[[nodiscard]] inline blas_int syrfs(char uplo, blas_int n, blas_int nrhs, uni20::float128* a, blas_int lda,
1616 uni20::float128* factors, blas_int factor_lda, blas_int const* ipiv,
1617 uni20::float128* b, blas_int ldb, uni20::float128* x, blas_int ldx,
1618 uni20::float128* forward_error, uni20::float128* backward_error,
1619 uni20::float128* work, blas_int* iwork)
1620{
1621 UNI20_EXTERNAL_API_CALL(LAPACK, Rsyrfs, uplo, n, nrhs, a, lda, factors, factor_lda, ipiv, b, ldb, x, ldx,
1622 forward_error, backward_error, work, iwork);
1623 mplapackint mplapack_info = 0;
1624 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::to_mplapack_ints(ipiv, n);
1625 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(n);
1626 Rsyrfs(&uplo, static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a, static_cast<mplapackint>(lda), factors,
1627 static_cast<mplapackint>(factor_lda), mplapack_ipiv.data(), b, static_cast<mplapackint>(ldb), x,
1628 static_cast<mplapackint>(ldx), forward_error, backward_error, work, mplapack_iwork.data(), mplapack_info);
1629 return static_cast<blas_int>(mplapack_info);
1630}
1631
1632[[nodiscard]] inline blas_int sysvx(char fact, char uplo, blas_int n, blas_int nrhs, uni20::float128* a, blas_int lda,
1633 uni20::float128* af, blas_int ldaf, blas_int* ipiv, uni20::float128* b,
1634 blas_int ldb, uni20::float128* x, blas_int ldx, uni20::float128& rcond,
1635 uni20::float128* forward_error, uni20::float128* backward_error,
1636 uni20::float128* work, blas_int lwork, blas_int* iwork)
1637{
1638 UNI20_EXTERNAL_API_CALL(LAPACK, Rsysvx, fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, work, lwork,
1639 iwork);
1640 mplapackint mplapack_info = 0;
1641 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::to_mplapack_ints(ipiv, n);
1642 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(n);
1643 Rsysvx(&fact, &uplo, static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a, static_cast<mplapackint>(lda),
1644 af, static_cast<mplapackint>(ldaf), mplapack_ipiv.data(), b, static_cast<mplapackint>(ldb), x,
1645 static_cast<mplapackint>(ldx), rcond, forward_error, backward_error, work, static_cast<mplapackint>(lwork),
1646 mplapack_iwork.data(), mplapack_info);
1647 uni20::lapack::mplapack::detail::copy_from_mplapack_ints(mplapack_ipiv, ipiv, n);
1648 return static_cast<blas_int>(mplapack_info);
1649}
1650
1651[[nodiscard]] inline blas_int sycon(char uplo, blas_int n, uni20::float128* a, blas_int lda, blas_int const* ipiv,
1652 uni20::float128 matrix_one_norm, uni20::float128& rcond, uni20::float128* work,
1653 blas_int* iwork)
1654{
1655 UNI20_EXTERNAL_API_CALL(LAPACK, Rsycon, uplo, n, a, lda, ipiv, matrix_one_norm, work, iwork);
1656 mplapackint mplapack_info = 0;
1657 std::vector<mplapackint> mplapack_ipiv = uni20::lapack::mplapack::detail::to_mplapack_ints(ipiv, n);
1658 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(n);
1659 Rsycon(&uplo, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), mplapack_ipiv.data(), matrix_one_norm,
1660 rcond, work, mplapack_iwork.data(), mplapack_info);
1661 return static_cast<blas_int>(mplapack_info);
1662}
1663
1664[[nodiscard]] inline blas_int trtrs(char uplo, char trans, char diag, blas_int n, blas_int nrhs, uni20::float128* a,
1665 blas_int lda, uni20::float128* b, blas_int ldb)
1666{
1667 UNI20_EXTERNAL_API_CALL(LAPACK, Rtrtrs, uplo, trans, diag, n, nrhs, a, lda, b, ldb);
1668 mplapackint mplapack_info = 0;
1669 Rtrtrs(&uplo, &trans, &diag, static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a,
1670 static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb), mplapack_info);
1671 return static_cast<blas_int>(mplapack_info);
1672}
1673
1674[[nodiscard]] inline blas_int trrfs(char uplo, char trans, char diag, blas_int n, blas_int nrhs, uni20::float128* a,
1675 blas_int lda, uni20::float128* b, blas_int ldb, uni20::float128* x, blas_int ldx,
1676 uni20::float128* forward_error, uni20::float128* backward_error,
1677 uni20::float128* work, blas_int* iwork)
1678{
1679 UNI20_EXTERNAL_API_CALL(LAPACK, Rtrrfs, uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, forward_error,
1680 backward_error, work, iwork);
1681 mplapackint mplapack_info = 0;
1682 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(n);
1683 Rtrrfs(&uplo, &trans, &diag, static_cast<mplapackint>(n), static_cast<mplapackint>(nrhs), a,
1684 static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb), x, static_cast<mplapackint>(ldx),
1685 forward_error, backward_error, work, mplapack_iwork.data(), mplapack_info);
1686 return static_cast<blas_int>(mplapack_info);
1687}
1688
1689[[nodiscard]] inline blas_int trtri(char uplo, char diag, blas_int n, uni20::float128* a, blas_int lda)
1690{
1691 UNI20_EXTERNAL_API_CALL(LAPACK, Rtrtri, uplo, diag, n, a, lda);
1692 mplapackint mplapack_info = 0;
1693 Rtrtri(&uplo, &diag, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), mplapack_info);
1694 return static_cast<blas_int>(mplapack_info);
1695}
1696
1697[[nodiscard]] inline blas_int trcon(char norm, char uplo, char diag, blas_int n, uni20::float128* a, blas_int lda,
1698 uni20::float128& rcond, uni20::float128* work, blas_int* iwork)
1699{
1700 UNI20_EXTERNAL_API_CALL(LAPACK, Rtrcon, norm, uplo, diag, n, a, lda, work, iwork);
1701 mplapackint mplapack_info = 0;
1702 std::vector<mplapackint> mplapack_iwork = uni20::lapack::mplapack::detail::make_mplapack_int_work(n);
1703 Rtrcon(&norm, &uplo, &diag, static_cast<mplapackint>(n), a, static_cast<mplapackint>(lda), rcond, work,
1704 mplapack_iwork.data(), mplapack_info);
1705 return static_cast<blas_int>(mplapack_info);
1706}
1707
1708[[nodiscard]] inline blas_int trsyl(char trans_a, char trans_b, blas_int sign, blas_int m, blas_int n,
1709 uni20::float128* a, blas_int lda, uni20::float128* b, blas_int ldb,
1710 uni20::float128* c, blas_int ldc, uni20::float128& scale)
1711{
1712 UNI20_EXTERNAL_API_CALL(LAPACK, Rtrsyl, trans_a, trans_b, sign, m, n, a, lda, b, ldb, c, ldc);
1713 mplapackint mplapack_info = 0;
1714 Rtrsyl(&trans_a, &trans_b, static_cast<mplapackint>(sign), static_cast<mplapackint>(m), static_cast<mplapackint>(n),
1715 a, static_cast<mplapackint>(lda), b, static_cast<mplapackint>(ldb), c, static_cast<mplapackint>(ldc), scale,
1716 mplapack_info);
1717 return static_cast<blas_int>(mplapack_info);
1718}
1719
1720} // namespace uni20::lapack::unchecked
common.hpp
Shared helpers for LAPACK backend wrappers.
common.hpp
Shared helpers for MPLAPACK LAPACK wrappers.
UNI20_EXTERNAL_API_CALL
#define UNI20_EXTERNAL_API_CALL(module, func,...)
Emits a trace log entry for an outgoing backend API call.
Definition backend.hpp:90
uni20::complex
typename detail::complex_type< Real >::type complex
Project-level complex scalar spelling.
Definition types.hpp:66
uni20::cli
Definition cli.cpp:6
uni20::lapack::unchecked
Definition mplapack/band.hpp:25
uni20::lapack::unchecked::trevc
blas_int trevc(char side, char howmny, blas_int *select, blas_int n, uni20::float128 *t, blas_int ldt, uni20::float128 *vl, blas_int ldvl, uni20::float128 *vr, blas_int ldvr, blas_int mm, blas_int &computed_vectors, uni20::float128 *work)
Definition mplapack/general.hpp:934
uni20::lapack::unchecked::sygv
blas_int sygv(blas_int itype, char jobz, char uplo, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, uni20::float128 *w, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:537
uni20::lapack::unchecked::getri
blas_int getri(blas_int n, uni20::float128 *a, blas_int lda, blas_int *ipiv, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:150
uni20::lapack::unchecked::syevd
blas_int syevd(char jobz, char uplo, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *w, uni20::float128 *work, blas_int lwork, blas_int *iwork, blas_int liwork)
Definition mplapack/general.hpp:492
uni20::lapack::unchecked::gesdd
blas_int gesdd(char jobz, blas_int m, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *s, uni20::float128 *u, blas_int ldu, uni20::float128 *vt, blas_int ldvt, uni20::float128 *work, blas_int lwork, blas_int *iwork)
Definition mplapack/general.hpp:1371
uni20::lapack::unchecked::gghrd
blas_int gghrd(char compq, char compz, blas_int n, blas_int first, blas_int last, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, uni20::float128 *q, blas_int ldq, uni20::float128 *z, blas_int ldz)
Definition mplapack/general.hpp:1120
uni20::lapack::unchecked::tgexc
blas_int tgexc(bool wantq, bool wantz, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, uni20::float128 *q, blas_int ldq, uni20::float128 *z, blas_int ldz, blas_int &first, blas_int &last, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:1148
uni20::lapack::unchecked::gges
blas_int gges(char jobvsl, char jobvsr, char sort, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, blas_int &selected_dimension, uni20::float128 *alphar, uni20::float128 *alphai, uni20::float128 *beta, uni20::float128 *vsl, blas_int ldvsl, uni20::float128 *vsr, blas_int ldvsr, uni20::float128 *work, blas_int lwork, blas_int *bwork)
Definition mplapack/general.hpp:1089
uni20::lapack::unchecked::hegv
blas_int hegv(blas_int itype, char jobz, char uplo, blas_int n, uni20::complex< uni20::float128 > *a, blas_int lda, uni20::complex< uni20::float128 > *b, blas_int ldb, uni20::float128 *w, uni20::complex< uni20::float128 > *work, blas_int lwork, uni20::float128 *rwork)
Definition mplapack/general.hpp:653
uni20::lapack::unchecked::sygvd
blas_int sygvd(blas_int itype, char jobz, char uplo, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, uni20::float128 *w, uni20::float128 *work, blas_int lwork, blas_int *iwork, blas_int liwork)
Definition mplapack/general.hpp:548
uni20::lapack::unchecked::gebal
blas_int gebal(char job, blas_int n, uni20::float128 *a, blas_int lda, blas_int &first, blas_int &last, uni20::float128 *scale)
Definition mplapack/general.hpp:748
uni20::lapack::unchecked::ormqr
blas_int ormqr(char side, char trans, blas_int m, blas_int n, blas_int k, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *c, blas_int ldc, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:391
uni20::lapack::unchecked::orgrq
blas_int orgrq(blas_int m, blas_int n, blas_int k, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:381
uni20::lapack::unchecked::orghr
blas_int orghr(blas_int n, blas_int first, blas_int last, uni20::float128 *a, blas_int lda, uni20::float128 const *tau, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:1289
uni20::lapack::unchecked::orglq
blas_int orglq(blas_int m, blas_int n, blas_int k, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:350
uni20::lapack::unchecked::gerqf
blas_int gerqf(blas_int m, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:319
uni20::lapack::unchecked::potrs
blas_int potrs(char uplo, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb)
Definition mplapack/general.hpp:1518
uni20::lapack::unchecked::trsyl
blas_int trsyl(char trans_a, char trans_b, blas_int sign, blas_int m, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, uni20::float128 *c, blas_int ldc, uni20::float128 &scale)
Definition mplapack/general.hpp:1708
uni20::lapack::unchecked::getrf
blas_int getrf(blas_int m, blas_int n, uni20::float128 *a, blas_int lda, blas_int *ipiv)
Definition mplapack/general.hpp:85
uni20::lapack::unchecked::sygvx
blas_int sygvx(blas_int itype, char jobz, char range, char uplo, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, uni20::float128 vl, uni20::float128 vu, blas_int il, blas_int iu, uni20::float128 abstol, blas_int &selected_count, uni20::float128 *w, uni20::float128 *z, blas_int ldz, uni20::float128 *work, blas_int lwork, blas_int *iwork, blas_int *ifail)
Definition mplapack/general.hpp:563
uni20::lapack::unchecked::hegvd
blas_int hegvd(blas_int itype, char jobz, char uplo, blas_int n, uni20::complex< uni20::float128 > *a, blas_int lda, uni20::complex< uni20::float128 > *b, blas_int ldb, uni20::float128 *w, uni20::complex< uni20::float128 > *work, blas_int lwork, uni20::float128 *rwork, blas_int lrwork, blas_int *iwork, blas_int liwork)
Definition mplapack/general.hpp:664
uni20::lapack::unchecked::orgtr
blas_int orgtr(char uplo, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 const *tau, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:1300
uni20::lapack::unchecked::gebak
blas_int gebak(char job, char side, blas_int n, blas_int first, blas_int last, uni20::float128 *scale, blas_int vector_count, uni20::float128 *vectors, blas_int leading_dimension)
Definition mplapack/general.hpp:762
uni20::lapack::unchecked::syevr
blas_int syevr(char jobz, char range, char uplo, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 vl, uni20::float128 vu, blas_int il, blas_int iu, uni20::float128 abstol, blas_int &selected_count, uni20::float128 *w, uni20::float128 *z, blas_int ldz, blas_int *isuppz, uni20::float128 *work, blas_int lwork, blas_int *iwork, blas_int liwork)
Definition mplapack/general.hpp:506
uni20::lapack::unchecked::hseqr
blas_int hseqr(char job, char compz, blas_int n, blas_int first, blas_int last, uni20::float128 *h, blas_int ldh, uni20::float128 *wr, uni20::float128 *wi, uni20::float128 *z, blas_int ldz, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:854
uni20::lapack::unchecked::sytri
blas_int sytri(char uplo, blas_int n, uni20::float128 *a, blas_int lda, blas_int const *ipiv, uni20::float128 *work)
Definition mplapack/general.hpp:1604
uni20::lapack::unchecked::ormrq
blas_int ormrq(char side, char trans, blas_int m, blas_int n, blas_int k, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *c, blas_int ldc, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:427
uni20::lapack::unchecked::gesvx
blas_int gesvx(char fact, char trans, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, uni20::float128 *af, blas_int ldaf, blas_int *ipiv, char &equed, uni20::float128 *row_scale, uni20::float128 *column_scale, uni20::float128 *b, blas_int ldb, uni20::float128 *x, blas_int ldx, uni20::float128 &rcond, uni20::float128 *forward_error, uni20::float128 *backward_error, uni20::float128 *work, blas_int *iwork)
Definition mplapack/general.hpp:53
uni20::lapack::unchecked::geev
blas_int geev(char jobvl, char jobvr, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *wr, uni20::float128 *wi, uni20::float128 *vl, blas_int ldvl, uni20::float128 *vr, blas_int ldvr, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:715
uni20::lapack::unchecked::trrfs
blas_int trrfs(char uplo, char trans, char diag, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, uni20::float128 *x, blas_int ldx, uni20::float128 *forward_error, uni20::float128 *backward_error, uni20::float128 *work, blas_int *iwork)
Definition mplapack/general.hpp:1674
uni20::lapack::unchecked::tgevc
blas_int tgevc(char side, char howmny, blas_int *select, blas_int n, uni20::float128 *s, blas_int lds, uni20::float128 *p, blas_int ldp, uni20::float128 *vl, blas_int ldvl, uni20::float128 *vr, blas_int ldvr, blas_int mm, blas_int &computed_vectors, uni20::float128 *work)
Definition mplapack/general.hpp:1205
uni20::lapack::unchecked::syev
blas_int syev(char jobz, char uplo, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *w, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:482
uni20::lapack::unchecked::poequ
blas_int poequ(blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *scale, uni20::float128 &scale_condition, uni20::float128 &max_abs)
Definition mplapack/general.hpp:1560
uni20::lapack::unchecked::tgsna
blas_int tgsna(char job, char howmny, blas_int *select, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, uni20::float128 *vl, blas_int ldvl, uni20::float128 *vr, blas_int ldvr, uni20::float128 *reciprocal_eigenvalue_condition_numbers, uni20::float128 *reciprocal_eigenvector_condition_numbers, blas_int mm, blas_int &computed_estimates, uni20::float128 *work, blas_int lwork, blas_int *iwork)
Definition mplapack/general.hpp:1238
uni20::lapack::unchecked::gelsy
blas_int gelsy(blas_int m, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, blas_int *jpvt, uni20::float128 rcond, blas_int &rank, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:251
uni20::lapack::unchecked::trtri
blas_int trtri(char uplo, char diag, blas_int n, uni20::float128 *a, blas_int lda)
Definition mplapack/general.hpp:1689
uni20::lapack::unchecked::trsna
blas_int trsna(char job, char howmny, blas_int *select, blas_int n, uni20::float128 *t, blas_int ldt, uni20::float128 *vl, blas_int ldvl, uni20::float128 *vr, blas_int ldvr, uni20::float128 *reciprocal_eigenvalue_condition_numbers, uni20::float128 *reciprocal_eigenvector_condition_numbers, blas_int mm, blas_int &computed_estimates, uni20::float128 *work, blas_int ldwork, blas_int *iwork)
Definition mplapack/general.hpp:966
uni20::lapack::unchecked::gehrd
blas_int gehrd(blas_int n, blas_int first, blas_int last, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:450
uni20::lapack::unchecked::gerfs
blas_int gerfs(char trans, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, uni20::float128 *factors, blas_int factor_lda, blas_int const *ipiv, uni20::float128 *b, blas_int ldb, uni20::float128 *x, blas_int ldx, uni20::float128 *forward_error, uni20::float128 *backward_error, uni20::float128 *work, blas_int *iwork)
Definition mplapack/general.hpp:133
uni20::lapack::unchecked::ggevx
blas_int ggevx(char balanc, char jobvl, char jobvr, char sense, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, uni20::float128 *alphar, uni20::float128 *alphai, uni20::float128 *beta, uni20::float128 *vl, blas_int ldvl, uni20::float128 *vr, blas_int ldvr, blas_int &ilo, blas_int &ihi, uni20::float128 *lscale, uni20::float128 *rscale, uni20::float128 &abnrm, uni20::float128 &bbnrm, uni20::float128 *rconde, uni20::float128 *rcondv, uni20::float128 *work, blas_int lwork, blas_int *iwork, blas_int *bwork)
Definition mplapack/general.hpp:1019
uni20::lapack::unchecked::bdsvdx
blas_int bdsvdx(char uplo, char jobz, char range, blas_int n, uni20::float128 *d, uni20::float128 *e, uni20::float128 vl, uni20::float128 vu, blas_int il, blas_int iu, blas_int &selected_count, uni20::float128 *singular_values, uni20::float128 *z, blas_int ldz, uni20::float128 *work, blas_int *iwork)
Definition mplapack/general.hpp:1470
uni20::lapack::unchecked::sysvx
blas_int sysvx(char fact, char uplo, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, uni20::float128 *af, blas_int ldaf, blas_int *ipiv, uni20::float128 *b, blas_int ldb, uni20::float128 *x, blas_int ldx, uni20::float128 &rcond, uni20::float128 *forward_error, uni20::float128 *backward_error, uni20::float128 *work, blas_int lwork, blas_int *iwork)
Definition mplapack/general.hpp:1632
uni20::lapack::unchecked::ggbal
blas_int ggbal(char job, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, blas_int &first, blas_int &last, uni20::float128 *lscale, uni20::float128 *rscale, uni20::float128 *work)
Definition mplapack/general.hpp:1061
uni20::lapack::unchecked::sycon
blas_int sycon(char uplo, blas_int n, uni20::float128 *a, blas_int lda, blas_int const *ipiv, uni20::float128 matrix_one_norm, uni20::float128 &rcond, uni20::float128 *work, blas_int *iwork)
Definition mplapack/general.hpp:1651
uni20::lapack::unchecked::trexc
blas_int trexc(char compq, blas_int n, uni20::float128 *t, blas_int ldt, uni20::float128 *q, blas_int ldq, blas_int &first, blas_int &last, uni20::float128 *work)
Definition mplapack/general.hpp:866
uni20::lapack::unchecked::bdsqr
blas_int bdsqr(char uplo, blas_int n, blas_int ncvt, blas_int nru, blas_int ncc, uni20::float128 *d, uni20::float128 *e, uni20::float128 *vt, blas_int ldvt, uni20::float128 *u, blas_int ldu, uni20::float128 *c, blas_int ldc, uni20::float128 *work)
Definition mplapack/general.hpp:1442
uni20::lapack::unchecked::gecon
blas_int gecon(char norm, blas_int n, uni20::float128 const *a, blas_int lda, uni20::float128 anorm, uni20::float128 &rcond, uni20::float128 *work, blas_int *iwork)
Definition mplapack/general.hpp:172
uni20::lapack::unchecked::gels
blas_int gels(char trans, blas_int m, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:195
uni20::lapack::unchecked::ggev
blas_int ggev(char jobvl, char jobvr, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, uni20::float128 *alphar, uni20::float128 *alphai, uni20::float128 *beta, uni20::float128 *vl, blas_int ldvl, uni20::float128 *vr, blas_int ldvr, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:1005
uni20::lapack::unchecked::heevr
blas_int heevr(char jobz, char range, char uplo, blas_int n, uni20::complex< uni20::float128 > *a, blas_int lda, uni20::float128 vl, uni20::float128 vu, blas_int il, blas_int iu, uni20::float128 abstol, blas_int &selected_count, uni20::float128 *w, uni20::complex< uni20::float128 > *z, blas_int ldz, blas_int *isuppz, uni20::complex< uni20::float128 > *work, blas_int lwork, uni20::float128 *rwork, blas_int lrwork, blas_int *iwork, blas_int liwork)
Definition mplapack/general.hpp:620
uni20::lapack::unchecked::orgql
blas_int orgql(blas_int m, blas_int n, blas_int k, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:371
uni20::lapack::unchecked::ormbr
blas_int ormbr(char vect, char side, char trans, blas_int m, blas_int n, blas_int k, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *c, blas_int ldc, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:1334
uni20::lapack::unchecked::gelss
blas_int gelss(blas_int m, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, uni20::float128 *s, uni20::float128 rcond, blas_int &rank, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:206
uni20::lapack::unchecked::potrf
blas_int potrf(char uplo, blas_int n, uni20::float128 *a, blas_int lda)
Definition mplapack/general.hpp:1488
uni20::lapack::unchecked::hgeqz
blas_int hgeqz(char job, char compq, char compz, blas_int n, blas_int first, blas_int last, uni20::float128 *h, blas_int ldh, uni20::float128 *t, blas_int ldt, uni20::float128 *alphar, uni20::float128 *alphai, uni20::float128 *beta, uni20::float128 *q, blas_int ldq, uni20::float128 *z, blas_int ldz, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:1132
uni20::lapack::unchecked::geqrf
blas_int geqrf(blas_int m, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:267
uni20::lapack::unchecked::hegvx
blas_int hegvx(blas_int itype, char jobz, char range, char uplo, blas_int n, uni20::complex< uni20::float128 > *a, blas_int lda, uni20::complex< uni20::float128 > *b, blas_int ldb, uni20::float128 vl, uni20::float128 vu, blas_int il, blas_int iu, uni20::float128 abstol, blas_int &selected_count, uni20::float128 *w, uni20::complex< uni20::float128 > *z, blas_int ldz, uni20::complex< uni20::float128 > *work, blas_int lwork, uni20::float128 *rwork, blas_int *iwork, blas_int *ifail)
Definition mplapack/general.hpp:682
uni20::lapack::unchecked::gesvdx
blas_int gesvdx(char jobu, char jobvt, char range, blas_int m, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 vl, uni20::float128 vu, blas_int il, blas_int iu, blas_int &selected_count, uni20::float128 *singular_values, uni20::float128 *u, blas_int ldu, uni20::float128 *vt, blas_int ldvt, uni20::float128 *work, blas_int lwork, blas_int *iwork)
Definition mplapack/general.hpp:1399
uni20::lapack::unchecked::sytrs
blas_int sytrs(char uplo, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, blas_int const *ipiv, uni20::float128 *b, blas_int ldb)
Definition mplapack/general.hpp:1593
uni20::lapack::unchecked::gelsd
blas_int gelsd(blas_int m, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, uni20::float128 *s, uni20::float128 rcond, blas_int &rank, uni20::float128 *work, blas_int lwork, blas_int *iwork)
Definition mplapack/general.hpp:235
uni20::lapack::unchecked::trcon
blas_int trcon(char norm, char uplo, char diag, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 &rcond, uni20::float128 *work, blas_int *iwork)
Definition mplapack/general.hpp:1697
uni20::lapack::unchecked::potri
blas_int potri(char uplo, blas_int n, uni20::float128 *a, blas_int lda)
Definition mplapack/general.hpp:1510
uni20::lapack::unchecked::pocon
blas_int pocon(char uplo, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 matrix_one_norm, uni20::float128 &rcond, uni20::float128 *work, blas_int *iwork)
Definition mplapack/general.hpp:1569
uni20::lapack::unchecked::geqp3
blas_int geqp3(blas_int m, blas_int n, uni20::float128 *a, blas_int lda, blas_int *jpvt, uni20::float128 *tau, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:460
uni20::lapack::unchecked::posvx
blas_int posvx(char fact, char uplo, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, uni20::float128 *af, blas_int ldaf, char &equed, uni20::float128 *scale, uni20::float128 *b, blas_int ldb, uni20::float128 *x, blas_int ldx, uni20::float128 &rcond, uni20::float128 *forward_error, uni20::float128 *backward_error, uni20::float128 *work, blas_int *iwork)
Definition mplapack/general.hpp:1543
uni20::lapack::unchecked::ggbak
blas_int ggbak(char job, char side, blas_int n, blas_int first, blas_int last, uni20::float128 *lscale, uni20::float128 *rscale, blas_int vector_count, uni20::float128 *vectors, blas_int leading_dimension)
Definition mplapack/general.hpp:1076
uni20::lapack::unchecked::heevd
blas_int heevd(char jobz, char uplo, blas_int n, uni20::complex< uni20::float128 > *a, blas_int lda, uni20::float128 *w, uni20::complex< uni20::float128 > *work, blas_int lwork, uni20::float128 *rwork, blas_int lrwork, blas_int *iwork, blas_int liwork)
Definition mplapack/general.hpp:605
uni20::lapack::unchecked::sytrd
blas_int sytrd(char uplo, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *d, uni20::float128 *e, uni20::float128 *tau, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:472
uni20::lapack::unchecked::gees
blas_int gees(char jobvs, char sort, blas_int n, uni20::float128 *a, blas_int lda, blas_int &selected_dimension, uni20::float128 *wr, uni20::float128 *wi, uni20::float128 *vs, blas_int ldvs, uni20::float128 *work, blas_int lwork, blas_int *bwork)
Definition mplapack/general.hpp:787
uni20::lapack::unchecked::orgqr
blas_int orgqr(blas_int m, blas_int n, blas_int k, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:329
uni20::lapack::unchecked::ormql
blas_int ormql(char side, char trans, blas_int m, blas_int n, blas_int k, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *c, blas_int ldc, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:415
uni20::lapack::unchecked::geqlf
blas_int geqlf(blas_int m, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:309
uni20::lapack::unchecked::gelqf
blas_int gelqf(blas_int m, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:288
uni20::lapack::unchecked::orgbr
blas_int orgbr(char vect, blas_int m, blas_int n, blas_int k, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:1279
uni20::lapack::unchecked::heev
blas_int heev(char jobz, char uplo, blas_int n, uni20::complex< uni20::float128 > *a, blas_int lda, uni20::float128 *w, uni20::complex< uni20::float128 > *work, blas_int lwork, uni20::float128 *rwork)
Definition mplapack/general.hpp:594
uni20::lapack::unchecked::geevx
blas_int geevx(char balanc, char jobvl, char jobvr, char sense, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *wr, uni20::float128 *wi, uni20::float128 *vl, blas_int ldvl, uni20::float128 *vr, blas_int ldvr, blas_int &ilo, blas_int &ihi, uni20::float128 *scale, uni20::float128 &abnrm, uni20::float128 *rconde, uni20::float128 *rcondv, uni20::float128 *work, blas_int lwork, blas_int *iwork)
Definition mplapack/general.hpp:727
uni20::lapack::unchecked::gesv
blas_int gesv(blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, blas_int *ipiv, uni20::float128 *b, blas_int ldb)
Definition mplapack/general.hpp:29
uni20::lapack::unchecked::trtrs
blas_int trtrs(char uplo, char trans, char diag, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb)
Definition mplapack/general.hpp:1664
uni20::lapack::unchecked::gesvd
blas_int gesvd(char jobu, char jobvt, blas_int m, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *s, uni20::float128 *u, blas_int ldu, uni20::float128 *vt, blas_int ldvt, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:1346
uni20::lapack::unchecked::sytrf
blas_int sytrf(char uplo, blas_int n, uni20::float128 *a, blas_int lda, blas_int *ipiv, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:1581
uni20::lapack::unchecked::tgsen
blas_int tgsen(blas_int ijob, bool wantq, bool wantz, blas_int *select, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *b, blas_int ldb, uni20::float128 *alphar, uni20::float128 *alphai, uni20::float128 *beta, uni20::float128 *q, blas_int ldq, uni20::float128 *z, blas_int ldz, blas_int &selected_dimension, uni20::float128 &pl, uni20::float128 &pr, uni20::float128 *dif, uni20::float128 *work, blas_int lwork, blas_int *iwork, blas_int liwork)
Definition mplapack/general.hpp:1165
uni20::lapack::unchecked::ormhr
blas_int ormhr(char side, char trans, blas_int m, blas_int n, blas_int first, blas_int last, uni20::float128 *a, blas_int lda, uni20::float128 const *tau, uni20::float128 *c, blas_int ldc, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:1310
uni20::lapack::unchecked::ormlq
blas_int ormlq(char side, char trans, blas_int m, blas_int n, blas_int k, uni20::float128 *a, blas_int lda, uni20::float128 *tau, uni20::float128 *c, blas_int ldc, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:403
uni20::lapack::unchecked::bdsdc
blas_int bdsdc(char uplo, char compq, blas_int n, uni20::float128 *d, uni20::float128 *e, uni20::float128 *u, blas_int ldu, uni20::float128 *vt, blas_int ldvt, uni20::float128 *q, blas_int *iq, uni20::float128 *work, blas_int *iwork)
Definition mplapack/general.hpp:1455
uni20::lapack::unchecked::syrfs
blas_int syrfs(char uplo, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, uni20::float128 *factors, blas_int factor_lda, blas_int const *ipiv, uni20::float128 *b, blas_int ldb, uni20::float128 *x, blas_int ldx, uni20::float128 *forward_error, uni20::float128 *backward_error, uni20::float128 *work, blas_int *iwork)
Definition mplapack/general.hpp:1615
uni20::lapack::unchecked::ormtr
blas_int ormtr(char side, char uplo, char trans, blas_int m, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 const *tau, uni20::float128 *c, blas_int ldc, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:1322
uni20::lapack::unchecked::pstrf
blas_int pstrf(char uplo, blas_int n, uni20::float128 *a, blas_int lda, blas_int *pivots, blas_int &rank, uni20::float128 tolerance, uni20::float128 *work)
Definition mplapack/general.hpp:1496
uni20::lapack::unchecked::getrs
blas_int getrs(char trans, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, blas_int const *ipiv, uni20::float128 *b, blas_int ldb)
Definition mplapack/general.hpp:110
uni20::lapack::unchecked::trsen
blas_int trsen(char job, char compq, blas_int *select, blas_int n, uni20::float128 *t, blas_int ldt, uni20::float128 *q, blas_int ldq, uni20::float128 *wr, uni20::float128 *wi, blas_int &selected_dimension, uni20::float128 &reciprocal_eigenvalue_cluster_condition, uni20::float128 &reciprocal_invariant_subspace_condition, uni20::float128 *work, blas_int lwork, blas_int *iwork, blas_int liwork)
Definition mplapack/general.hpp:894
uni20::lapack::unchecked::porfs
blas_int porfs(char uplo, blas_int n, blas_int nrhs, uni20::float128 *a, blas_int lda, uni20::float128 *factors, blas_int factor_lda, uni20::float128 *b, blas_int ldb, uni20::float128 *x, blas_int ldx, uni20::float128 *forward_error, uni20::float128 *backward_error, uni20::float128 *work, blas_int *iwork)
Definition mplapack/general.hpp:1528
uni20::lapack::unchecked::gebrd
blas_int gebrd(blas_int m, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *d, uni20::float128 *e, uni20::float128 *tauq, uni20::float128 *taup, uni20::float128 *work, blas_int lwork)
Definition mplapack/general.hpp:439
uni20::lapack::unchecked::geequ
blas_int geequ(blas_int m, blas_int n, uni20::float128 *a, blas_int lda, uni20::float128 *row_scale, uni20::float128 *column_scale, uni20::float128 &row_condition, uni20::float128 &column_condition, uni20::float128 &max_abs)
Definition mplapack/general.hpp:73
uni20::presentation
Definition data_table.cpp:8
uni20::norm
mpreal norm(mpcomplex const &z)
Definition mpcomplex.hpp:494
uni20::scale
void scale(Tensor &tensor, Scalar factor)
Multiply every stored numerical block by a scalar in place.
Definition block_tensor_linear.hpp:400
uni20::beta
mpreal beta(mpreal const &a, mpreal const &x)
Real Beta function; positive rational/integer pairs retain exact values.
Definition mpreal_special.hpp:164
Generated by doxygen 1.9.8