/library/src/math_kernel/lapacke/lapacke.h

https://bitbucket.org/Fourbe/speakerid · C Header · 16287 lines · 15565 code · 658 blank · 64 comment · 0 complexity · cf8dfa969a7c47726917cb3bf83247fc MD5 · raw file

Large files are truncated click here to view the full file

    

  1. /*****************************************************************************
    2. 

  2.   Copyright (c) 2010, Intel Corp.
    3. 

  3.   All rights reserved.
    4. 

    5. 

  5.   Redistribution and use in source and binary forms, with or without
    6. 

  6.   modification, are permitted provided that the following conditions are met:
    7. 

    8. 

  8.     * Redistributions of source code must retain the above copyright notice,
    9. 

  9.       this list of conditions and the following disclaimer.
    10. 

  10.     * Redistributions in binary form must reproduce the above copyright
    11. 

  11.       notice, this list of conditions and the following disclaimer in the
    12. 

  12.       documentation and/or other materials provided with the distribution.
    13. 

  13.     * Neither the name of Intel Corporation nor the names of its contributors
    14. 

  14.       may be used to endorse or promote products derived from this software
    15. 

  15.       without specific prior written permission.
    16. 

    17. 

  17.   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    18. 

  18.   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    19. 

  19.   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    20. 

  20.   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
    21. 

  21.   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    22. 

  22.   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    23. 

  23.   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    24. 

  24.   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    25. 

  25.   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    26. 

  26.   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
    27. 

  27.   THE POSSIBILITY OF SUCH DAMAGE.
    28. 

  28. ******************************************************************************
    29. 

  29. * Contents: Native C interface to LAPACK
    30. 

  30. * Author: Intel Corporation
    31. 

  31. * Generated November, 2011
    32. 

  32. *****************************************************************************/
    33. 

  33. 

  34. #ifndef _LAPACKE_H_
    35. 

  35. #define _LAPACKE_H_
    36. 

  36. 

  37. /*
    38. 

  38. *  Turn on HAVE_LAPACK_CONFIG_H to redefine C-LAPACK datatypes
    39. 

  39. */
    40. 

  40. #ifdef HAVE_LAPACK_CONFIG_H
    41. 

  41. #include "lapacke_config.h"
    42. 

  42. #endif
    43. 

  43. 

  44. #ifdef __cplusplus
    45. 

  45. extern "C" {
    46. 

  46. #endif /* __cplusplus */
    47. 

  47. 

  48. #include <stdlib.h>
    49. 

  49. 

  50. #ifndef lapack_int
    51. 

  51. #define lapack_int     int
    52. 

  52. #endif
    53. 

  53. 

  54. #ifndef lapack_logical
    55. 

  55. #define lapack_logical lapack_int
    56. 

  56. #endif
    57. 

  57. 

  58. /* Complex types are structures equivalent to the
    59. 

  59. * Fortran complex types COMPLEX(4) and COMPLEX(8).
    60. 

  60. *
    61. 

  61. * One can also redefine the types with his own types
    62. 

  62. * for example by including in the code definitions like
    63. 

  63. *
    64. 

  64. * #define lapack_complex_float std::complex<float>
    65. 

  65. * #define lapack_complex_double std::complex<double>
    66. 

  66. *
    67. 

  67. * or define these types in the command line:
    68. 

  68. *
    69. 

  69. * -Dlapack_complex_float="std::complex<float>"
    70. 

  70. * -Dlapack_complex_double="std::complex<double>"
    71. 

  71. */
    72. 

  72. 

  73. #ifndef LAPACK_COMPLEX_CUSTOM
    74. 

  74. 

  75. /* Complex type (single precision) */
    76. 

  76. #ifndef lapack_complex_float
    77. 

  77. #include <complex.h>
    78. 

  78. #define lapack_complex_float    float _Complex
    79. 

  79. #endif
    80. 

  80. 

  81. #ifndef lapack_complex_float_real
    82. 

  82. #define lapack_complex_float_real(z)       (creal(z))
    83. 

  83. #endif
    84. 

  84. 

  85. #ifndef lapack_complex_float_imag
    86. 

  86. #define lapack_complex_float_imag(z)       (cimag(z))
    87. 

  87. #endif
    88. 

  88. 

  89. lapack_complex_float lapack_make_complex_float( float re, float im );
    90. 

  90. 

  91. /* Complex type (double precision) */
    92. 

  92. #ifndef lapack_complex_double
    93. 

  93. #include <complex.h>
    94. 

  94. #define lapack_complex_double   double _Complex
    95. 

  95. #endif
    96. 

  96. 

  97. #ifndef lapack_complex_double_real
    98. 

  98. #define lapack_complex_double_real(z)      (creal(z))
    99. 

  99. #endif
    100. 

  100. 

  101. #ifndef lapack_complex_double_imag
    102. 

  102. #define lapack_complex_double_imag(z)       (cimag(z))
    103. 

  103. #endif
    104. 

  104. 

  105. lapack_complex_double lapack_make_complex_double( double re, double im );
    106. 

  106. 

  107. #endif
    108. 

  108. 

  109. #ifndef LAPACKE_malloc
    110. 

  110. #define LAPACKE_malloc( size ) malloc( size )
    111. 

  111. #endif
    112. 

  112. #ifndef LAPACKE_free
    113. 

  113. #define LAPACKE_free( p )      free( p )
    114. 

  114. #endif
    115. 

  115. 

  116. #define LAPACK_C2INT( x ) (lapack_int)(*((float*)&x ))
    117. 

  117. #define LAPACK_Z2INT( x ) (lapack_int)(*((double*)&x ))
    118. 

  118. 

  119. #define LAPACK_ROW_MAJOR               101
    120. 

  120. #define LAPACK_COL_MAJOR               102
    121. 

  121. 

  122. #define LAPACK_WORK_MEMORY_ERROR       -1010
    123. 

  123. #define LAPACK_TRANSPOSE_MEMORY_ERROR  -1011
    124. 

  124. 

  125. /* Callback logical functions of one, two, or three arguments are used
    126. 

  126. *  to select eigenvalues to sort to the top left of the Schur form.
    127. 

  127. *  The value is selected if function returns TRUE (non-zero). */
    128. 

  128. 

  129. typedef lapack_logical (*LAPACK_S_SELECT2) ( const float*, const float* );
    130. 

  130. typedef lapack_logical (*LAPACK_S_SELECT3)
    131. 

  131.     ( const float*, const float*, const float* );
    132. 

  132. typedef lapack_logical (*LAPACK_D_SELECT2) ( const double*, const double* );
    133. 

  133. typedef lapack_logical (*LAPACK_D_SELECT3)
    134. 

  134.     ( const double*, const double*, const double* );
    135. 

  135. 

  136. typedef lapack_logical (*LAPACK_C_SELECT1) ( const lapack_complex_float* );
    137. 

  137. typedef lapack_logical (*LAPACK_C_SELECT2)
    138. 

  138.     ( const lapack_complex_float*, const lapack_complex_float* );
    139. 

  139. typedef lapack_logical (*LAPACK_Z_SELECT1) ( const lapack_complex_double* );
    140. 

  140. typedef lapack_logical (*LAPACK_Z_SELECT2)
    141. 

  141.     ( const lapack_complex_double*, const lapack_complex_double* );
    142. 

  142. 

  143. #include "lapacke_mangling.h"
    144. 

  144. 

  145. #define LAPACK_lsame LAPACK_GLOBAL(lsame,LSAME)
    146. 

  146. lapack_logical LAPACK_lsame( char* ca,  char* cb,
    147. 

  147.                               lapack_int lca, lapack_int lcb );
    148. 

  148. 

  149. /* C-LAPACK function prototypes */
    150. 

  150. 

  151. lapack_int LAPACKE_sbdsdc( int matrix_order, char uplo, char compq,
    152. 

  152.                            lapack_int n, float* d, float* e, float* u,
    153. 

  153.                            lapack_int ldu, float* vt, lapack_int ldvt, float* q,
    154. 

  154.                            lapack_int* iq );
    155. 

  155. lapack_int LAPACKE_dbdsdc( int matrix_order, char uplo, char compq,
    156. 

  156.                            lapack_int n, double* d, double* e, double* u,
    157. 

  157.                            lapack_int ldu, double* vt, lapack_int ldvt,
    158. 

  158.                            double* q, lapack_int* iq );
    159. 

  159. 

  160. lapack_int LAPACKE_sbdsqr( int matrix_order, char uplo, lapack_int n,
    161. 

  161.                            lapack_int ncvt, lapack_int nru, lapack_int ncc,
    162. 

  162.                            float* d, float* e, float* vt, lapack_int ldvt,
    163. 

  163.                            float* u, lapack_int ldu, float* c, lapack_int ldc );
    164. 

  164. lapack_int LAPACKE_dbdsqr( int matrix_order, char uplo, lapack_int n,
    165. 

  165.                            lapack_int ncvt, lapack_int nru, lapack_int ncc,
    166. 

  166.                            double* d, double* e, double* vt, lapack_int ldvt,
    167. 

  167.                            double* u, lapack_int ldu, double* c,
    168. 

  168.                            lapack_int ldc );
    169. 

  169. lapack_int LAPACKE_cbdsqr( int matrix_order, char uplo, lapack_int n,
    170. 

  170.                            lapack_int ncvt, lapack_int nru, lapack_int ncc,
    171. 

  171.                            float* d, float* e, lapack_complex_float* vt,
    172. 

  172.                            lapack_int ldvt, lapack_complex_float* u,
    173. 

  173.                            lapack_int ldu, lapack_complex_float* c,
    174. 

  174.                            lapack_int ldc );
    175. 

  175. lapack_int LAPACKE_zbdsqr( int matrix_order, char uplo, lapack_int n,
    176. 

  176.                            lapack_int ncvt, lapack_int nru, lapack_int ncc,
    177. 

  177.                            double* d, double* e, lapack_complex_double* vt,
    178. 

  178.                            lapack_int ldvt, lapack_complex_double* u,
    179. 

  179.                            lapack_int ldu, lapack_complex_double* c,
    180. 

  180.                            lapack_int ldc );
    181. 

  181. 

  182. lapack_int LAPACKE_sdisna( char job, lapack_int m, lapack_int n, const float* d,
    183. 

  183.                            float* sep );
    184. 

  184. lapack_int LAPACKE_ddisna( char job, lapack_int m, lapack_int n,
    185. 

  185.                            const double* d, double* sep );
    186. 

  186. 

  187. lapack_int LAPACKE_sgbbrd( int matrix_order, char vect, lapack_int m,
    188. 

  188.                            lapack_int n, lapack_int ncc, lapack_int kl,
    189. 

  189.                            lapack_int ku, float* ab, lapack_int ldab, float* d,
    190. 

  190.                            float* e, float* q, lapack_int ldq, float* pt,
    191. 

  191.                            lapack_int ldpt, float* c, lapack_int ldc );
    192. 

  192. lapack_int LAPACKE_dgbbrd( int matrix_order, char vect, lapack_int m,
    193. 

  193.                            lapack_int n, lapack_int ncc, lapack_int kl,
    194. 

  194.                            lapack_int ku, double* ab, lapack_int ldab,
    195. 

  195.                            double* d, double* e, double* q, lapack_int ldq,
    196. 

  196.                            double* pt, lapack_int ldpt, double* c,
    197. 

  197.                            lapack_int ldc );
    198. 

  198. lapack_int LAPACKE_cgbbrd( int matrix_order, char vect, lapack_int m,
    199. 

  199.                            lapack_int n, lapack_int ncc, lapack_int kl,
    200. 

  200.                            lapack_int ku, lapack_complex_float* ab,
    201. 

  201.                            lapack_int ldab, float* d, float* e,
    202. 

  202.                            lapack_complex_float* q, lapack_int ldq,
    203. 

  203.                            lapack_complex_float* pt, lapack_int ldpt,
    204. 

  204.                            lapack_complex_float* c, lapack_int ldc );
    205. 

  205. lapack_int LAPACKE_zgbbrd( int matrix_order, char vect, lapack_int m,
    206. 

  206.                            lapack_int n, lapack_int ncc, lapack_int kl,
    207. 

  207.                            lapack_int ku, lapack_complex_double* ab,
    208. 

  208.                            lapack_int ldab, double* d, double* e,
    209. 

  209.                            lapack_complex_double* q, lapack_int ldq,
    210. 

  210.                            lapack_complex_double* pt, lapack_int ldpt,
    211. 

  211.                            lapack_complex_double* c, lapack_int ldc );
    212. 

  212. 

  213. lapack_int LAPACKE_sgbcon( int matrix_order, char norm, lapack_int n,
    214. 

  214.                            lapack_int kl, lapack_int ku, const float* ab,
    215. 

  215.                            lapack_int ldab, const lapack_int* ipiv, float anorm,
    216. 

  216.                            float* rcond );
    217. 

  217. lapack_int LAPACKE_dgbcon( int matrix_order, char norm, lapack_int n,
    218. 

  218.                            lapack_int kl, lapack_int ku, const double* ab,
    219. 

  219.                            lapack_int ldab, const lapack_int* ipiv,
    220. 

  220.                            double anorm, double* rcond );
    221. 

  221. lapack_int LAPACKE_cgbcon( int matrix_order, char norm, lapack_int n,
    222. 

  222.                            lapack_int kl, lapack_int ku,
    223. 

  223.                            const lapack_complex_float* ab, lapack_int ldab,
    224. 

  224.                            const lapack_int* ipiv, float anorm, float* rcond );
    225. 

  225. lapack_int LAPACKE_zgbcon( int matrix_order, char norm, lapack_int n,
    226. 

  226.                            lapack_int kl, lapack_int ku,
    227. 

  227.                            const lapack_complex_double* ab, lapack_int ldab,
    228. 

  228.                            const lapack_int* ipiv, double anorm,
    229. 

  229.                            double* rcond );
    230. 

  230. 

  231. lapack_int LAPACKE_sgbequ( int matrix_order, lapack_int m, lapack_int n,
    232. 

  232.                            lapack_int kl, lapack_int ku, const float* ab,
    233. 

  233.                            lapack_int ldab, float* r, float* c, float* rowcnd,
    234. 

  234.                            float* colcnd, float* amax );
    235. 

  235. lapack_int LAPACKE_dgbequ( int matrix_order, lapack_int m, lapack_int n,
    236. 

  236.                            lapack_int kl, lapack_int ku, const double* ab,
    237. 

  237.                            lapack_int ldab, double* r, double* c,
    238. 

  238.                            double* rowcnd, double* colcnd, double* amax );
    239. 

  239. lapack_int LAPACKE_cgbequ( int matrix_order, lapack_int m, lapack_int n,
    240. 

  240.                            lapack_int kl, lapack_int ku,
    241. 

  241.                            const lapack_complex_float* ab, lapack_int ldab,
    242. 

  242.                            float* r, float* c, float* rowcnd, float* colcnd,
    243. 

  243.                            float* amax );
    244. 

  244. lapack_int LAPACKE_zgbequ( int matrix_order, lapack_int m, lapack_int n,
    245. 

  245.                            lapack_int kl, lapack_int ku,
    246. 

  246.                            const lapack_complex_double* ab, lapack_int ldab,
    247. 

  247.                            double* r, double* c, double* rowcnd, double* colcnd,
    248. 

  248.                            double* amax );
    249. 

  249. 

  250. lapack_int LAPACKE_sgbequb( int matrix_order, lapack_int m, lapack_int n,
    251. 

  251.                             lapack_int kl, lapack_int ku, const float* ab,
    252. 

  252.                             lapack_int ldab, float* r, float* c, float* rowcnd,
    253. 

  253.                             float* colcnd, float* amax );
    254. 

  254. lapack_int LAPACKE_dgbequb( int matrix_order, lapack_int m, lapack_int n,
    255. 

  255.                             lapack_int kl, lapack_int ku, const double* ab,
    256. 

  256.                             lapack_int ldab, double* r, double* c,
    257. 

  257.                             double* rowcnd, double* colcnd, double* amax );
    258. 

  258. lapack_int LAPACKE_cgbequb( int matrix_order, lapack_int m, lapack_int n,
    259. 

  259.                             lapack_int kl, lapack_int ku,
    260. 

  260.                             const lapack_complex_float* ab, lapack_int ldab,
    261. 

  261.                             float* r, float* c, float* rowcnd, float* colcnd,
    262. 

  262.                             float* amax );
    263. 

  263. lapack_int LAPACKE_zgbequb( int matrix_order, lapack_int m, lapack_int n,
    264. 

  264.                             lapack_int kl, lapack_int ku,
    265. 

  265.                             const lapack_complex_double* ab, lapack_int ldab,
    266. 

  266.                             double* r, double* c, double* rowcnd,
    267. 

  267.                             double* colcnd, double* amax );
    268. 

  268. 

  269. lapack_int LAPACKE_sgbrfs( int matrix_order, char trans, lapack_int n,
    270. 

  270.                            lapack_int kl, lapack_int ku, lapack_int nrhs,
    271. 

  271.                            const float* ab, lapack_int ldab, const float* afb,
    272. 

  272.                            lapack_int ldafb, const lapack_int* ipiv,
    273. 

  273.                            const float* b, lapack_int ldb, float* x,
    274. 

  274.                            lapack_int ldx, float* ferr, float* berr );
    275. 

  275. lapack_int LAPACKE_dgbrfs( int matrix_order, char trans, lapack_int n,
    276. 

  276.                            lapack_int kl, lapack_int ku, lapack_int nrhs,
    277. 

  277.                            const double* ab, lapack_int ldab, const double* afb,
    278. 

  278.                            lapack_int ldafb, const lapack_int* ipiv,
    279. 

  279.                            const double* b, lapack_int ldb, double* x,
    280. 

  280.                            lapack_int ldx, double* ferr, double* berr );
    281. 

  281. lapack_int LAPACKE_cgbrfs( int matrix_order, char trans, lapack_int n,
    282. 

  282.                            lapack_int kl, lapack_int ku, lapack_int nrhs,
    283. 

  283.                            const lapack_complex_float* ab, lapack_int ldab,
    284. 

  284.                            const lapack_complex_float* afb, lapack_int ldafb,
    285. 

  285.                            const lapack_int* ipiv,
    286. 

  286.                            const lapack_complex_float* b, lapack_int ldb,
    287. 

  287.                            lapack_complex_float* x, lapack_int ldx, float* ferr,
    288. 

  288.                            float* berr );
    289. 

  289. lapack_int LAPACKE_zgbrfs( int matrix_order, char trans, lapack_int n,
    290. 

  290.                            lapack_int kl, lapack_int ku, lapack_int nrhs,
    291. 

  291.                            const lapack_complex_double* ab, lapack_int ldab,
    292. 

  292.                            const lapack_complex_double* afb, lapack_int ldafb,
    293. 

  293.                            const lapack_int* ipiv,
    294. 

  294.                            const lapack_complex_double* b, lapack_int ldb,
    295. 

  295.                            lapack_complex_double* x, lapack_int ldx,
    296. 

  296.                            double* ferr, double* berr );
    297. 

  297. 

  298. lapack_int LAPACKE_sgbrfsx( int matrix_order, char trans, char equed,
    299. 

  299.                             lapack_int n, lapack_int kl, lapack_int ku,
    300. 

  300.                             lapack_int nrhs, const float* ab, lapack_int ldab,
    301. 

  301.                             const float* afb, lapack_int ldafb,
    302. 

  302.                             const lapack_int* ipiv, const float* r,
    303. 

  303.                             const float* c, const float* b, lapack_int ldb,
    304. 

  304.                             float* x, lapack_int ldx, float* rcond, float* berr,
    305. 

  305.                             lapack_int n_err_bnds, float* err_bnds_norm,
    306. 

  306.                             float* err_bnds_comp, lapack_int nparams,
    307. 

  307.                             float* params );
    308. 

  308. lapack_int LAPACKE_dgbrfsx( int matrix_order, char trans, char equed,
    309. 

  309.                             lapack_int n, lapack_int kl, lapack_int ku,
    310. 

  310.                             lapack_int nrhs, const double* ab, lapack_int ldab,
    311. 

  311.                             const double* afb, lapack_int ldafb,
    312. 

  312.                             const lapack_int* ipiv, const double* r,
    313. 

  313.                             const double* c, const double* b, lapack_int ldb,
    314. 

  314.                             double* x, lapack_int ldx, double* rcond,
    315. 

  315.                             double* berr, lapack_int n_err_bnds,
    316. 

  316.                             double* err_bnds_norm, double* err_bnds_comp,
    317. 

  317.                             lapack_int nparams, double* params );
    318. 

  318. lapack_int LAPACKE_cgbrfsx( int matrix_order, char trans, char equed,
    319. 

  319.                             lapack_int n, lapack_int kl, lapack_int ku,
    320. 

  320.                             lapack_int nrhs, const lapack_complex_float* ab,
    321. 

  321.                             lapack_int ldab, const lapack_complex_float* afb,
    322. 

  322.                             lapack_int ldafb, const lapack_int* ipiv,
    323. 

  323.                             const float* r, const float* c,
    324. 

  324.                             const lapack_complex_float* b, lapack_int ldb,
    325. 

  325.                             lapack_complex_float* x, lapack_int ldx,
    326. 

  326.                             float* rcond, float* berr, lapack_int n_err_bnds,
    327. 

  327.                             float* err_bnds_norm, float* err_bnds_comp,
    328. 

  328.                             lapack_int nparams, float* params );
    329. 

  329. lapack_int LAPACKE_zgbrfsx( int matrix_order, char trans, char equed,
    330. 

  330.                             lapack_int n, lapack_int kl, lapack_int ku,
    331. 

  331.                             lapack_int nrhs, const lapack_complex_double* ab,
    332. 

  332.                             lapack_int ldab, const lapack_complex_double* afb,
    333. 

  333.                             lapack_int ldafb, const lapack_int* ipiv,
    334. 

  334.                             const double* r, const double* c,
    335. 

  335.                             const lapack_complex_double* b, lapack_int ldb,
    336. 

  336.                             lapack_complex_double* x, lapack_int ldx,
    337. 

  337.                             double* rcond, double* berr, lapack_int n_err_bnds,
    338. 

  338.                             double* err_bnds_norm, double* err_bnds_comp,
    339. 

  339.                             lapack_int nparams, double* params );
    340. 

  340. 

  341. lapack_int LAPACKE_sgbsv( int matrix_order, lapack_int n, lapack_int kl,
    342. 

  342.                           lapack_int ku, lapack_int nrhs, float* ab,
    343. 

  343.                           lapack_int ldab, lapack_int* ipiv, float* b,
    344. 

  344.                           lapack_int ldb );
    345. 

  345. lapack_int LAPACKE_dgbsv( int matrix_order, lapack_int n, lapack_int kl,
    346. 

  346.                           lapack_int ku, lapack_int nrhs, double* ab,
    347. 

  347.                           lapack_int ldab, lapack_int* ipiv, double* b,
    348. 

  348.                           lapack_int ldb );
    349. 

  349. lapack_int LAPACKE_cgbsv( int matrix_order, lapack_int n, lapack_int kl,
    350. 

  350.                           lapack_int ku, lapack_int nrhs,
    351. 

  351.                           lapack_complex_float* ab, lapack_int ldab,
    352. 

  352.                           lapack_int* ipiv, lapack_complex_float* b,
    353. 

  353.                           lapack_int ldb );
    354. 

  354. lapack_int LAPACKE_zgbsv( int matrix_order, lapack_int n, lapack_int kl,
    355. 

  355.                           lapack_int ku, lapack_int nrhs,
    356. 

  356.                           lapack_complex_double* ab, lapack_int ldab,
    357. 

  357.                           lapack_int* ipiv, lapack_complex_double* b,
    358. 

  358.                           lapack_int ldb );
    359. 

  359. 

  360. lapack_int LAPACKE_sgbsvx( int matrix_order, char fact, char trans,
    361. 

  361.                            lapack_int n, lapack_int kl, lapack_int ku,
    362. 

  362.                            lapack_int nrhs, float* ab, lapack_int ldab,
    363. 

  363.                            float* afb, lapack_int ldafb, lapack_int* ipiv,
    364. 

  364.                            char* equed, float* r, float* c, float* b,
    365. 

  365.                            lapack_int ldb, float* x, lapack_int ldx,
    366. 

  366.                            float* rcond, float* ferr, float* berr,
    367. 

  367.                            float* rpivot );
    368. 

  368. lapack_int LAPACKE_dgbsvx( int matrix_order, char fact, char trans,
    369. 

  369.                            lapack_int n, lapack_int kl, lapack_int ku,
    370. 

  370.                            lapack_int nrhs, double* ab, lapack_int ldab,
    371. 

  371.                            double* afb, lapack_int ldafb, lapack_int* ipiv,
    372. 

  372.                            char* equed, double* r, double* c, double* b,
    373. 

  373.                            lapack_int ldb, double* x, lapack_int ldx,
    374. 

  374.                            double* rcond, double* ferr, double* berr,
    375. 

  375.                            double* rpivot );
    376. 

  376. lapack_int LAPACKE_cgbsvx( int matrix_order, char fact, char trans,
    377. 

  377.                            lapack_int n, lapack_int kl, lapack_int ku,
    378. 

  378.                            lapack_int nrhs, lapack_complex_float* ab,
    379. 

  379.                            lapack_int ldab, lapack_complex_float* afb,
    380. 

  380.                            lapack_int ldafb, lapack_int* ipiv, char* equed,
    381. 

  381.                            float* r, float* c, lapack_complex_float* b,
    382. 

  382.                            lapack_int ldb, lapack_complex_float* x,
    383. 

  383.                            lapack_int ldx, float* rcond, float* ferr,
    384. 

  384.                            float* berr, float* rpivot );
    385. 

  385. lapack_int LAPACKE_zgbsvx( int matrix_order, char fact, char trans,
    386. 

  386.                            lapack_int n, lapack_int kl, lapack_int ku,
    387. 

  387.                            lapack_int nrhs, lapack_complex_double* ab,
    388. 

  388.                            lapack_int ldab, lapack_complex_double* afb,
    389. 

  389.                            lapack_int ldafb, lapack_int* ipiv, char* equed,
    390. 

  390.                            double* r, double* c, lapack_complex_double* b,
    391. 

  391.                            lapack_int ldb, lapack_complex_double* x,
    392. 

  392.                            lapack_int ldx, double* rcond, double* ferr,
    393. 

  393.                            double* berr, double* rpivot );
    394. 

  394. 

  395. lapack_int LAPACKE_sgbsvxx( int matrix_order, char fact, char trans,
    396. 

  396.                             lapack_int n, lapack_int kl, lapack_int ku,
    397. 

  397.                             lapack_int nrhs, float* ab, lapack_int ldab,
    398. 

  398.                             float* afb, lapack_int ldafb, lapack_int* ipiv,
    399. 

  399.                             char* equed, float* r, float* c, float* b,
    400. 

  400.                             lapack_int ldb, float* x, lapack_int ldx,
    401. 

  401.                             float* rcond, float* rpvgrw, float* berr,
    402. 

  402.                             lapack_int n_err_bnds, float* err_bnds_norm,
    403. 

  403.                             float* err_bnds_comp, lapack_int nparams,
    404. 

  404.                             float* params );
    405. 

  405. lapack_int LAPACKE_dgbsvxx( int matrix_order, char fact, char trans,
    406. 

  406.                             lapack_int n, lapack_int kl, lapack_int ku,
    407. 

  407.                             lapack_int nrhs, double* ab, lapack_int ldab,
    408. 

  408.                             double* afb, lapack_int ldafb, lapack_int* ipiv,
    409. 

  409.                             char* equed, double* r, double* c, double* b,
    410. 

  410.                             lapack_int ldb, double* x, lapack_int ldx,
    411. 

  411.                             double* rcond, double* rpvgrw, double* berr,
    412. 

  412.                             lapack_int n_err_bnds, double* err_bnds_norm,
    413. 

  413.                             double* err_bnds_comp, lapack_int nparams,
    414. 

  414.                             double* params );
    415. 

  415. lapack_int LAPACKE_cgbsvxx( int matrix_order, char fact, char trans,
    416. 

  416.                             lapack_int n, lapack_int kl, lapack_int ku,
    417. 

  417.                             lapack_int nrhs, lapack_complex_float* ab,
    418. 

  418.                             lapack_int ldab, lapack_complex_float* afb,
    419. 

  419.                             lapack_int ldafb, lapack_int* ipiv, char* equed,
    420. 

  420.                             float* r, float* c, lapack_complex_float* b,
    421. 

  421.                             lapack_int ldb, lapack_complex_float* x,
    422. 

  422.                             lapack_int ldx, float* rcond, float* rpvgrw,
    423. 

  423.                             float* berr, lapack_int n_err_bnds,
    424. 

  424.                             float* err_bnds_norm, float* err_bnds_comp,
    425. 

  425.                             lapack_int nparams, float* params );
    426. 

  426. lapack_int LAPACKE_zgbsvxx( int matrix_order, char fact, char trans,
    427. 

  427.                             lapack_int n, lapack_int kl, lapack_int ku,
    428. 

  428.                             lapack_int nrhs, lapack_complex_double* ab,
    429. 

  429.                             lapack_int ldab, lapack_complex_double* afb,
    430. 

  430.                             lapack_int ldafb, lapack_int* ipiv, char* equed,
    431. 

  431.                             double* r, double* c, lapack_complex_double* b,
    432. 

  432.                             lapack_int ldb, lapack_complex_double* x,
    433. 

  433.                             lapack_int ldx, double* rcond, double* rpvgrw,
    434. 

  434.                             double* berr, lapack_int n_err_bnds,
    435. 

  435.                             double* err_bnds_norm, double* err_bnds_comp,
    436. 

  436.                             lapack_int nparams, double* params );
    437. 

  437. 

  438. lapack_int LAPACKE_sgbtrf( int matrix_order, lapack_int m, lapack_int n,
    439. 

  439.                            lapack_int kl, lapack_int ku, float* ab,
    440. 

  440.                            lapack_int ldab, lapack_int* ipiv );
    441. 

  441. lapack_int LAPACKE_dgbtrf( int matrix_order, lapack_int m, lapack_int n,
    442. 

  442.                            lapack_int kl, lapack_int ku, double* ab,
    443. 

  443.                            lapack_int ldab, lapack_int* ipiv );
    444. 

  444. lapack_int LAPACKE_cgbtrf( int matrix_order, lapack_int m, lapack_int n,
    445. 

  445.                            lapack_int kl, lapack_int ku,
    446. 

  446.                            lapack_complex_float* ab, lapack_int ldab,
    447. 

  447.                            lapack_int* ipiv );
    448. 

  448. lapack_int LAPACKE_zgbtrf( int matrix_order, lapack_int m, lapack_int n,
    449. 

  449.                            lapack_int kl, lapack_int ku,
    450. 

  450.                            lapack_complex_double* ab, lapack_int ldab,
    451. 

  451.                            lapack_int* ipiv );
    452. 

  452. 

  453. lapack_int LAPACKE_sgbtrs( int matrix_order, char trans, lapack_int n,
    454. 

  454.                            lapack_int kl, lapack_int ku, lapack_int nrhs,
    455. 

  455.                            const float* ab, lapack_int ldab,
    456. 

  456.                            const lapack_int* ipiv, float* b, lapack_int ldb );
    457. 

  457. lapack_int LAPACKE_dgbtrs( int matrix_order, char trans, lapack_int n,
    458. 

  458.                            lapack_int kl, lapack_int ku, lapack_int nrhs,
    459. 

  459.                            const double* ab, lapack_int ldab,
    460. 

  460.                            const lapack_int* ipiv, double* b, lapack_int ldb );
    461. 

  461. lapack_int LAPACKE_cgbtrs( int matrix_order, char trans, lapack_int n,
    462. 

  462.                            lapack_int kl, lapack_int ku, lapack_int nrhs,
    463. 

  463.                            const lapack_complex_float* ab, lapack_int ldab,
    464. 

  464.                            const lapack_int* ipiv, lapack_complex_float* b,
    465. 

  465.                            lapack_int ldb );
    466. 

  466. lapack_int LAPACKE_zgbtrs( int matrix_order, char trans, lapack_int n,
    467. 

  467.                            lapack_int kl, lapack_int ku, lapack_int nrhs,
    468. 

  468.                            const lapack_complex_double* ab, lapack_int ldab,
    469. 

  469.                            const lapack_int* ipiv, lapack_complex_double* b,
    470. 

  470.                            lapack_int ldb );
    471. 

  471. 

  472. lapack_int LAPACKE_sgebak( int matrix_order, char job, char side, lapack_int n,
    473. 

  473.                            lapack_int ilo, lapack_int ihi, const float* scale,
    474. 

  474.                            lapack_int m, float* v, lapack_int ldv );
    475. 

  475. lapack_int LAPACKE_dgebak( int matrix_order, char job, char side, lapack_int n,
    476. 

  476.                            lapack_int ilo, lapack_int ihi, const double* scale,
    477. 

  477.                            lapack_int m, double* v, lapack_int ldv );
    478. 

  478. lapack_int LAPACKE_cgebak( int matrix_order, char job, char side, lapack_int n,
    479. 

  479.                            lapack_int ilo, lapack_int ihi, const float* scale,
    480. 

  480.                            lapack_int m, lapack_complex_float* v,
    481. 

  481.                            lapack_int ldv );
    482. 

  482. lapack_int LAPACKE_zgebak( int matrix_order, char job, char side, lapack_int n,
    483. 

  483.                            lapack_int ilo, lapack_int ihi, const double* scale,
    484. 

  484.                            lapack_int m, lapack_complex_double* v,
    485. 

  485.                            lapack_int ldv );
    486. 

  486. 

  487. lapack_int LAPACKE_sgebal( int matrix_order, char job, lapack_int n, float* a,
    488. 

  488.                            lapack_int lda, lapack_int* ilo, lapack_int* ihi,
    489. 

  489.                            float* scale );
    490. 

  490. lapack_int LAPACKE_dgebal( int matrix_order, char job, lapack_int n, double* a,
    491. 

  491.                            lapack_int lda, lapack_int* ilo, lapack_int* ihi,
    492. 

  492.                            double* scale );
    493. 

  493. lapack_int LAPACKE_cgebal( int matrix_order, char job, lapack_int n,
    494. 

  494.                            lapack_complex_float* a, lapack_int lda,
    495. 

  495.                            lapack_int* ilo, lapack_int* ihi, float* scale );
    496. 

  496. lapack_int LAPACKE_zgebal( int matrix_order, char job, lapack_int n,
    497. 

  497.                            lapack_complex_double* a, lapack_int lda,
    498. 

  498.                            lapack_int* ilo, lapack_int* ihi, double* scale );
    499. 

  499. 

  500. lapack_int LAPACKE_sgebrd( int matrix_order, lapack_int m, lapack_int n,
    501. 

  501.                            float* a, lapack_int lda, float* d, float* e,
    502. 

  502.                            float* tauq, float* taup );
    503. 

  503. lapack_int LAPACKE_dgebrd( int matrix_order, lapack_int m, lapack_int n,
    504. 

  504.                            double* a, lapack_int lda, double* d, double* e,
    505. 

  505.                            double* tauq, double* taup );
    506. 

  506. lapack_int LAPACKE_cgebrd( int matrix_order, lapack_int m, lapack_int n,
    507. 

  507.                            lapack_complex_float* a, lapack_int lda, float* d,
    508. 

  508.                            float* e, lapack_complex_float* tauq,
    509. 

  509.                            lapack_complex_float* taup );
    510. 

  510. lapack_int LAPACKE_zgebrd( int matrix_order, lapack_int m, lapack_int n,
    511. 

  511.                            lapack_complex_double* a, lapack_int lda, double* d,
    512. 

  512.                            double* e, lapack_complex_double* tauq,
    513. 

  513.                            lapack_complex_double* taup );
    514. 

  514. 

  515. lapack_int LAPACKE_sgecon( int matrix_order, char norm, lapack_int n,
    516. 

  516.                            const float* a, lapack_int lda, float anorm,
    517. 

  517.                            float* rcond );
    518. 

  518. lapack_int LAPACKE_dgecon( int matrix_order, char norm, lapack_int n,
    519. 

  519.                            const double* a, lapack_int lda, double anorm,
    520. 

  520.                            double* rcond );
    521. 

  521. lapack_int LAPACKE_cgecon( int matrix_order, char norm, lapack_int n,
    522. 

  522.                            const lapack_complex_float* a, lapack_int lda,
    523. 

  523.                            float anorm, float* rcond );
    524. 

  524. lapack_int LAPACKE_zgecon( int matrix_order, char norm, lapack_int n,
    525. 

  525.                            const lapack_complex_double* a, lapack_int lda,
    526. 

  526.                            double anorm, double* rcond );
    527. 

  527. 

  528. lapack_int LAPACKE_sgeequ( int matrix_order, lapack_int m, lapack_int n,
    529. 

  529.                            const float* a, lapack_int lda, float* r, float* c,
    530. 

  530.                            float* rowcnd, float* colcnd, float* amax );
    531. 

  531. lapack_int LAPACKE_dgeequ( int matrix_order, lapack_int m, lapack_int n,
    532. 

  532.                            const double* a, lapack_int lda, double* r,
    533. 

  533.                            double* c, double* rowcnd, double* colcnd,
    534. 

  534.                            double* amax );
    535. 

  535. lapack_int LAPACKE_cgeequ( int matrix_order, lapack_int m, lapack_int n,
    536. 

  536.                            const lapack_complex_float* a, lapack_int lda,
    537. 

  537.                            float* r, float* c, float* rowcnd, float* colcnd,
    538. 

  538.                            float* amax );
    539. 

  539. lapack_int LAPACKE_zgeequ( int matrix_order, lapack_int m, lapack_int n,
    540. 

  540.                            const lapack_complex_double* a, lapack_int lda,
    541. 

  541.                            double* r, double* c, double* rowcnd, double* colcnd,
    542. 

  542.                            double* amax );
    543. 

  543. 

  544. lapack_int LAPACKE_sgeequb( int matrix_order, lapack_int m, lapack_int n,
    545. 

  545.                             const float* a, lapack_int lda, float* r, float* c,
    546. 

  546.                             float* rowcnd, float* colcnd, float* amax );
    547. 

  547. lapack_int LAPACKE_dgeequb( int matrix_order, lapack_int m, lapack_int n,
    548. 

  548.                             const double* a, lapack_int lda, double* r,
    549. 

  549.                             double* c, double* rowcnd, double* colcnd,
    550. 

  550.                             double* amax );
    551. 

  551. lapack_int LAPACKE_cgeequb( int matrix_order, lapack_int m, lapack_int n,
    552. 

  552.                             const lapack_complex_float* a, lapack_int lda,
    553. 

  553.                             float* r, float* c, float* rowcnd, float* colcnd,
    554. 

  554.                             float* amax );
    555. 

  555. lapack_int LAPACKE_zgeequb( int matrix_order, lapack_int m, lapack_int n,
    556. 

  556.                             const lapack_complex_double* a, lapack_int lda,
    557. 

  557.                             double* r, double* c, double* rowcnd,
    558. 

  558.                             double* colcnd, double* amax );
    559. 

  559. 

  560. lapack_int LAPACKE_sgees( int matrix_order, char jobvs, char sort,
    561. 

  561.                           LAPACK_S_SELECT2 select, lapack_int n, float* a,
    562. 

  562.                           lapack_int lda, lapack_int* sdim, float* wr,
    563. 

  563.                           float* wi, float* vs, lapack_int ldvs );
    564. 

  564. lapack_int LAPACKE_dgees( int matrix_order, char jobvs, char sort,
    565. 

  565.                           LAPACK_D_SELECT2 select, lapack_int n, double* a,
    566. 

  566.                           lapack_int lda, lapack_int* sdim, double* wr,
    567. 

  567.                           double* wi, double* vs, lapack_int ldvs );
    568. 

  568. lapack_int LAPACKE_cgees( int matrix_order, char jobvs, char sort,
    569. 

  569.                           LAPACK_C_SELECT1 select, lapack_int n,
    570. 

  570.                           lapack_complex_float* a, lapack_int lda,
    571. 

  571.                           lapack_int* sdim, lapack_complex_float* w,
    572. 

  572.                           lapack_complex_float* vs, lapack_int ldvs );
    573. 

  573. lapack_int LAPACKE_zgees( int matrix_order, char jobvs, char sort,
    574. 

  574.                           LAPACK_Z_SELECT1 select, lapack_int n,
    575. 

  575.                           lapack_complex_double* a, lapack_int lda,
    576. 

  576.                           lapack_int* sdim, lapack_complex_double* w,
    577. 

  577.                           lapack_complex_double* vs, lapack_int ldvs );
    578. 

  578. 

  579. lapack_int LAPACKE_sgeesx( int matrix_order, char jobvs, char sort,
    580. 

  580.                            LAPACK_S_SELECT2 select, char sense, lapack_int n,
    581. 

  581.                            float* a, lapack_int lda, lapack_int* sdim,
    582. 

  582.                            float* wr, float* wi, float* vs, lapack_int ldvs,
    583. 

  583.                            float* rconde, float* rcondv );
    584. 

  584. lapack_int LAPACKE_dgeesx( int matrix_order, char jobvs, char sort,
    585. 

  585.                            LAPACK_D_SELECT2 select, char sense, lapack_int n,
    586. 

  586.                            double* a, lapack_int lda, lapack_int* sdim,
    587. 

  587.                            double* wr, double* wi, double* vs, lapack_int ldvs,
    588. 

  588.                            double* rconde, double* rcondv );
    589. 

  589. lapack_int LAPACKE_cgeesx( int matrix_order, char jobvs, char sort,
    590. 

  590.                            LAPACK_C_SELECT1 select, char sense, lapack_int n,
    591. 

  591.                            lapack_complex_float* a, lapack_int lda,
    592. 

  592.                            lapack_int* sdim, lapack_complex_float* w,
    593. 

  593.                            lapack_complex_float* vs, lapack_int ldvs,
    594. 

  594.                            float* rconde, float* rcondv );
    595. 

  595. lapack_int LAPACKE_zgeesx( int matrix_order, char jobvs, char sort,
    596. 

  596.                            LAPACK_Z_SELECT1 select, char sense, lapack_int n,
    597. 

  597.                            lapack_complex_double* a, lapack_int lda,
    598. 

  598.                            lapack_int* sdim, lapack_complex_double* w,
    599. 

  599.                            lapack_complex_double* vs, lapack_int ldvs,
    600. 

  600.                            double* rconde, double* rcondv );
    601. 

  601. 

  602. lapack_int LAPACKE_sgeev( int matrix_order, char jobvl, char jobvr,
    603. 

  603.                           lapack_int n, float* a, lapack_int lda, float* wr,
    604. 

  604.                           float* wi, float* vl, lapack_int ldvl, float* vr,
    605. 

  605.                           lapack_int ldvr );
    606. 

  606. lapack_int LAPACKE_dgeev( int matrix_order, char jobvl, char jobvr,
    607. 

  607.                           lapack_int n, double* a, lapack_int lda, double* wr,
    608. 

  608.                           double* wi, double* vl, lapack_int ldvl, double* vr,
    609. 

  609.                           lapack_int ldvr );
    610. 

  610. lapack_int LAPACKE_cgeev( int matrix_order, char jobvl, char jobvr,
    611. 

  611.                           lapack_int n, lapack_complex_float* a, lapack_int lda,
    612. 

  612.                           lapack_complex_float* w, lapack_complex_float* vl,
    613. 

  613.                           lapack_int ldvl, lapack_complex_float* vr,
    614. 

  614.                           lapack_int ldvr );
    615. 

  615. lapack_int LAPACKE_zgeev( int matrix_order, char jobvl, char jobvr,
    616. 

  616.                           lapack_int n, lapack_complex_double* a,
    617. 

  617.                           lapack_int lda, lapack_complex_double* w,
    618. 

  618.                           lapack_complex_double* vl, lapack_int ldvl,
    619. 

  619.                           lapack_complex_double* vr, lapack_int ldvr );
    620. 

  620. 

  621. lapack_int LAPACKE_sgeevx( int matrix_order, char balanc, char jobvl,
    622. 

  622.                            char jobvr, char sense, lapack_int n, float* a,
    623. 

  623.                            lapack_int lda, float* wr, float* wi, float* vl,
    624. 

  624.                            lapack_int ldvl, float* vr, lapack_int ldvr,
    625. 

  625.                            lapack_int* ilo, lapack_int* ihi, float* scale,
    626. 

  626.                            float* abnrm, float* rconde, float* rcondv );
    627. 

  627. lapack_int LAPACKE_dgeevx( int matrix_order, char balanc, char jobvl,
    628. 

  628.                            char jobvr, char sense, lapack_int n, double* a,
    629. 

  629.                            lapack_int lda, double* wr, double* wi, double* vl,
    630. 

  630.                            lapack_int ldvl, double* vr, lapack_int ldvr,
    631. 

  631.                            lapack_int* ilo, lapack_int* ihi, double* scale,
    632. 

  632.                            double* abnrm, double* rconde, double* rcondv );
    633. 

  633. lapack_int LAPACKE_cgeevx( int matrix_order, char balanc, char jobvl,
    634. 

  634.                            char jobvr, char sense, lapack_int n,
    635. 

  635.                            lapack_complex_float* a, lapack_int lda,
    636. 

  636.                            lapack_complex_float* w, lapack_complex_float* vl,
    637. 

  637.                            lapack_int ldvl, lapack_complex_float* vr,
    638. 

  638.                            lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
    639. 

  639.                            float* scale, float* abnrm, float* rconde,
    640. 

  640.                            float* rcondv );
    641. 

  641. lapack_int LAPACKE_zgeevx( int matrix_order, char balanc, char jobvl,
    642. 

  642.                            char jobvr, char sense, lapack_int n,
    643. 

  643.                            lapack_complex_double* a, lapack_int lda,
    644. 

  644.                            lapack_complex_double* w, lapack_complex_double* vl,
    645. 

  645.                            lapack_int ldvl, lapack_complex_double* vr,
    646. 

  646.                            lapack_int ldvr, lapack_int* ilo, lapack_int* ihi,
    647. 

  647.                            double* scale, double* abnrm, double* rconde,
    648. 

  648.                            double* rcondv );
    649. 

  649. 

  650. lapack_int LAPACKE_sgehrd( int matrix_order, lapack_int n, lapack_int ilo,
    651. 

  651.                            lapack_int ihi, float* a, lapack_int lda,
    652. 

  652.                            float* tau );
    653. 

  653. lapack_int LAPACKE_dgehrd( int matrix_order, lapack_int n, lapack_int ilo,
    654. 

  654.                            lapack_int ihi, double* a, lapack_int lda,
    655. 

  655.                            double* tau );
    656. 

  656. lapack_int LAPACKE_cgehrd( int matrix_order, lapack_int n, lapack_int ilo,
    657. 

  657.                            lapack_int ihi, lapack_complex_float* a,
    658. 

  658.                            lapack_int lda, lapack_complex_float* tau );
    659. 

  659. lapack_int LAPACKE_zgehrd( int matrix_order, lapack_int n, lapack_int ilo,
    660. 

  660.                            lapack_int ihi, lapack_complex_double* a,
    661. 

  661.                            lapack_int lda, lapack_complex_double* tau );
    662. 

  662. 

  663. lapack_int LAPACKE_sgejsv( int matrix_order, char joba, char jobu, char jobv,
    664. 

  664.                            char jobr, char jobt, char jobp, lapack_int m,
    665. 

  665.                            lapack_int n, float* a, lapack_int lda, float* sva,
    666. 

  666.                            float* u, lapack_int ldu, float* v, lapack_int ldv,
    667. 

  667.                            float* stat, lapack_int* istat );
    668. 

  668. lapack_int LAPACKE_dgejsv( int matrix_order, char joba, char jobu, char jobv,
    669. 

  669.                            char jobr, char jobt, char jobp, lapack_int m,
    670. 

  670.                            lapack_int n, double* a, lapack_int lda, double* sva,
    671. 

  671.                            double* u, lapack_int ldu, double* v, lapack_int ldv,
    672. 

  672.                            double* stat, lapack_int* istat );
    673. 

  673. 

  674. lapack_int LAPACKE_sgelq2( int matrix_order, lapack_int m, lapack_int n,
    675. 

  675.                            float* a, lapack_int lda, float* tau );
    676. 

  676. lapack_int LAPACKE_dgelq2( int matrix_order, lapack_int m, lapack_int n,
    677. 

  677.                            double* a, lapack_int lda, double* tau );
    678. 

  678. lapack_int LAPACKE_cgelq2( int matrix_order, lapack_int m, lapack_int n,
    679. 

  679.                            lapack_complex_float* a, lapack_int lda,
    680. 

  680.                            lapack_complex_float* tau );
    681. 

  681. lapack_int LAPACKE_zgelq2( int matrix_order, lapack_int m, lapack_int n,
    682. 

  682.                            lapack_complex_double* a, lapack_int lda,
    683. 

  683.                            lapack_complex_double* tau );
    684. 

  684. 

  685. lapack_int LAPACKE_sgelqf( int matrix_order, lapack_int m, lapack_int n,
    686. 

  686.                            float* a, lapack_int lda, float* tau );
    687. 

  687. lapack_int LAPACKE_dgelqf( int matrix_order, lapack_int m, lapack_int n,
    688. 

  688.                            double* a, lapack_int lda, double* tau );
    689. 

  689. lapack_int LAPACKE_cgelqf( int matrix_order, lapack_int m, lapack_int n,
    690. 

  690.                            lapack_complex_float* a, lapack_int lda,
    691. 

  691.                            lapack_complex_float* tau );
    692. 

  692. lapack_int LAPACKE_zgelqf( int matrix_order, lapack_int m, lapack_int n,
    693. 

  693.                            lapack_complex_double* a, lapack_int lda,
    694. 

  694.                            lapack_complex_double* tau );
    695. 

  695. 

  696. lapack_int LAPACKE_sgels( int matrix_order, char trans, lapack_int m,
    697. 

  697.                           lapack_int n, lapack_int nrhs, float* a,
    698. 

  698.                           lapack_int lda, float* b, lapack_int ldb );
    699. 

  699. lapack_int LAPACKE_dgels( int matrix_order, char trans, lapack_int m,
    700. 

  700.                           lapack_int n, lapack_int nrhs, double* a,
    701. 

  701.                           lapack_int lda, double* b, lapack_int ldb );
    702. 

  702. lapack_int LAPACKE_cgels( int matrix_order, char trans, lapack_int m,
    703. 

  703.                           lapack_int n, lapack_int nrhs,
    704. 

  704.                           lapack_complex_float* a, lapack_int lda,
    705. 

  705.                           lapack_complex_float* b, lapack_int ldb );
    706. 

  706. lapack_int LAPACKE_zgels( int matrix_order, char trans, lapack_int m,
    707. 

  707.                           lapack_int n, lapack_int nrhs,
    708. 

  708.                           lapack_complex_double* a, lapack_int lda,
    709. 

  709.                           lapack_complex_double* b, lapack_int ldb );
    710. 

  710. 

  711. lapack_int LAPACKE_sgelsd( int matrix_order, lapack_int m, lapack_int n,
    712. 

  712.                            lapack_int nrhs, float* a, lapack_int lda, float* b,
    713. 

  713.                            lapack_int ldb, float* s, float rcond,
    714. 

  714.                            lapack_int* rank );
    715. 

  715. lapack_int LAPACKE_dgelsd( int matrix_order, lapack_int m, lapack_int n,
    716. 

  716.                            lapack_int nrhs, double* a, lapack_int lda,
    717. 

  717.                            double* b, lapack_int ldb, double* s, double rcond,
    718. 

  718.                            lapack_int* rank );
    719. 

  719. lapack_int LAPACKE_cgelsd( int matrix_order, lapack_int m, lapack_int n,
    720. 

  720.                            lapack_int nrhs, lapack_complex_float* a,
    721. 

  721.                            lapack_int lda, lapack_complex_float* b,
    722. 

  722.                            lapack_int ldb, float* s, float rcond,
    723. 

  723.                            lapack_int* rank );
    724. 

  724. lapack_int LAPACKE_zgelsd( int matrix_order, lapack_int m, lapack_int n,
    725. 

  725.                            lapack_int nrhs, lapack_complex_double* a,
    726. 

  726.                            lapack_int lda, lapack_complex_double* b,
    727. 

  727.                            lapack_int ldb, double* s, double rcond,
    728. 

  728.                            lapack_int* rank );
    729. 

  729. 

  730. lapack_int LAPACKE_sgelss( int matrix_order, lapack_int m, lapack_int n,
    731. 

  731.                            lapack_int nrhs, float* a, lapack_int lda, float* b,
    732. 

  732.                            lapack_int ldb, float* s, float rcond,
    733. 

  733.                            lapack_int* rank );
    734. 

  734. lapack_int LAPACKE_dgelss( int matrix_order, lapack_int m, lapack_int n,
    735. 

  735.                            lapack_int nrhs, double* a, lapack_int lda,
    736. 

  736.                            double* b, lapack_int ldb, double* s, double rcond,
    737. 

  737.                            lapack_int* rank );
    738. 

  738. lapack_int LAPACKE_cgelss( int matrix_order, lapack_int m, lapack_int n,
    739. 

  739.                            lapack_int nrhs, lapack_complex_float* a,
    740. 

  740.                            lapack_int lda, lapack_complex_float* b,
    741. 

  741.                            lapack_int ldb, float* s, float rcond,
    742. 

  742.                            lapack_int* rank );
    743. 

  743. lapack_int LAPACKE_zgelss( int matrix_order, lapack_int m, lapack_int n,
    744. 

  744.                            lapack_int nrhs, lapack_complex_double* a,
    745. 

  745.                            lapack_int lda, lapack_complex_double* b,
    746. 

  746.                            lapack_int ldb, double* s, double rcond,
    747. 

  747.                            lapack_int* rank );
    748. 

  748. 

  749. lapack_int LAPACKE_sgelsy( int matrix_order, lapack_int m, lapack_int n,
    750. 

  750.                            lapack_int nrhs, float* a, lapack_int lda, float* b,
    751. 

  751.                            lapack_int ldb, lapack_int* jpvt, float rcond,
    752. 

  752.                            lapack_int* rank );
    753. 

  753. lapack_int LAPACKE_dgelsy( int matrix_order, lapack_int m, lapack_int n,
    754. 

  754.                            lapack_int nrhs, double* a, lapack_int lda,
    755. 

  755.                            double* b, lapack_int ldb, lapack_int* jpvt,
    756. 

  756.                            double rcond, lapack_int* rank );
    757. 

  757. lapack_int LAPACKE_cgelsy( int matrix_order, lapack_int m, lapack_int n,
    758. 

  758.                            lapack_int nrhs, lapack_complex_float* a,
    759. 

  759.                            lapack_int lda, lapack_complex_float* b,
    760. 

  760.                            lapack_int ldb, lapack_int* jpvt, float rcond,
    761. 

  761.                            lapack_int* rank );
    762. 

  762. lapack_int LAPACKE_zgelsy( int matrix_order, lapack_int m, lapack_int n,
    763. 

  763.                            lapack_int nrhs, lapack_complex_double* a,
    764. 

  764.                            lapack_int lda, lapack_complex_double* b,
    765. 

  765.                            lapack_int ldb, lapack_int* jpvt, double rcond,
    766. 

  766.                            lapack_int* rank );
    767. 

  767. 

  768. lapack_int LAPACKE_sgeqlf( int matrix_order, lapack_int m, lapack_int n,
    769. 

  769.                            float* a, lapack_int lda, float* tau );
    770. 

  770. lapack_int LAPACKE_dgeqlf( int matrix_order, lapack_int m, lapack_int n,
    771. 

  771.                            double* a, lapack_int lda, double* tau );
    772. 

  772. lapack_int LAPACKE_cgeqlf( int matrix_order, lapack_int m, lapack_int n,
    773. 

  773.                            lapack_complex_float* a, lapack_int lda,
    774. 

  774.                            lapack_complex_float* tau );
    775. 

  775. lapack_int LAPACKE_zgeqlf( int matrix_order, lapack_int m, lapack_int n,
    776. 

  776.                            lapack_complex_double* a, lapack_int lda,
    777. 

  777.                            lapack_complex_double* tau );
    778. 

  778. 

  779. lapack_int LAPACKE_sgeqp3( int matrix_order, lapack_int m, lapack_int n,
    780. 

  780.                            float* a, lapack_int lda, lapack_int* jpvt,
    781. 

  781.                            float* tau );
    782. 

  782. lapack_int LAPACKE_dgeqp3( int matrix_order, lapack_int m, lapack_int n,
    783. 

  783.                            double* a, lapack_int lda, lapack_int* jpvt,
    784. 

  784.                            double* tau );
    785. 

  785. lapack_int LAPACKE_cgeqp3( int matrix_order, lapack_int m, lapack_int n,
    786. 

  786.                            lapack_complex_float* a, lapack_int lda,
    787. 

  787.                            lapack_int* jpvt, lapack_complex_float* tau );
    788. 

  788. lapack_int LAPACKE_zgeqp3( int matrix_order, lapack_int m, lapack_int n,
    789. 

  789.                            lapack_complex_double* a, lapack_int lda,
    790. 

  790.                            lapack_int* jpvt, lapack_complex_double* tau );
    791. 

  791. 

  792. lapack_int LAPACKE_sgeqpf( int matrix_order, lapack_int m, lapack_int n,
    793. 

  793.                            float* a, lapack_int lda, lapack_int* jpvt,
    794. 

  794.                            float* tau );
    795. 

  795. lapack_int LAPACKE_dgeqpf( int matrix_order, lapack_int m, lapack_int n,
    796. 

  796.                            double* a, lapack_int lda, lapack_int* jpvt,
    797. 

  797.                            double* tau );
    798. 

  798. lapack_int LAPACKE_cgeqpf( int matrix_order, lapack_int m, lapack_int n,
    799. 

  799.                            lapack_complex_float* a, lapack_int lda,
    800. 

  800.                            lapack_int* jpvt, lapack_complex_float* tau );
    801. 

  801. lapack_int LAPACKE_zgeqpf( int matrix_order, lapack_int m, lapack_int n,
    802. 

  802.                            lapack_complex_double* a, lapack_int lda,
    803. 

  803.                            lapack_int* jpvt, lapack_complex_double* tau );
    804. 

  804. 

  805. lapack_int LAPACKE_sgeqr2( int matrix_order, lapack_int m, lapack_int n,
    806. 

  806.                            float* a, lapack_int lda, float* tau );
    807. 

  807. lapack_int LAPACKE_dgeqr2( int matrix_order, lapack_int m, lapack_int n,
    808. 

  808.                            double* a, lapack_int lda, double* tau );
    809. 

  809. lapack_int LAPACKE_cgeqr2( int matrix_order, lapack_int m, lapack_int n,
    810. 

  810.                            lapack_complex_float* a, lapack_int lda,
    811. 

  811.                            lapack_complex_float* tau );
    812. 

  812. lapack_int LAPACKE_zgeqr2( int matrix_order, lapack_int m, lapack_int n,
    813. 

  813.                            lapack_complex_double* a, lapack_int lda,
    814. 

  814.                            lapack_complex_double* tau );
    815. 

  815. 

  816. lapack_int LAPACKE_sgeqrf( int matrix_order, lapack_int m, lapack_int n,
    817. 

  817.                            float* a, lapack_int lda, float* tau );
    818. 

  818. lapack_int LAPACKE_dgeqrf( int matrix_order, lapack_int m, lapack_int n,
    819. 

  819.                            double* a, lapack_int lda, double* tau );
    820. 

  820. lapack_int LAPACKE_cgeqrf( int matrix_order, lapack_int m, lapack_int n,
    821. 

  821.                            lapack_complex_float* a, lapack_int lda,
    822. 

  822.                            lapack_complex_float* tau );
    823. 

  823. lapack_int LAPACKE_zgeqrf( int matrix_order, lapack_int m, lapack_int n,
    824. 

  824.                            lapack_complex_double* a, lapack_int lda,
    825. 

  825.                            lapack_complex_double* tau );
    826. 

  826. 

  827. lapack_int LAPACKE_sgeqrfp( int matrix_order, lapack_int m, lapack_int n,
    828. 

  828.                             float* a, lapack_int lda, float* tau );
    829. 

  829. lapack_int LAPACKE_dgeqrfp( int matrix_order, lapack_int m, lapack_int n,
    830. 

  830.                             double* a, lapack_int lda, double* tau );
    831. 

  831. lapack_int LAPACKE_cgeqrfp( int matrix_order, lapack_int m, lapack_int n,
    832. 

  832.                             lapack_complex_float* a, lapack_int lda,
    833. 

  833.                             lapack_complex_float* tau );
    834. 

  834. lapack_int LAPACKE_zgeqrfp( int matrix_order, lapack_int m, lapack_int n,
    835. 

  835.                             lapack_complex_double* a, lapack_int lda,
    836. 

  836.                             lapack_complex_double* tau );
    837. 

  837. 

  838. lapack_int LAPACKE_sgerfs( int matrix_order, char trans, lapack_int n,
    839. 

  839.                            lapack_int nrhs, const float* a, lapack_int lda,
    840. 

  840.                            const float* af, lapack_int ldaf,
    841. 

  841.                            const lapack_int* ipiv, const float* b,…
    842.