PageRenderTime 72ms CodeModel.GetById 25ms RepoModel.GetById 1ms app.codeStats 1ms

/src/lib/libqt/lapack_intfc.cc

https://gitlab.com/y-shao/psi4public
C++ | 12343 lines | 893 code | 121 blank | 11329 comment | 0 complexity | 5f62f5e55b7d33b0f1c546d75ddc1322 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

    

  1. /*
    2. 

  2.  *@BEGIN LICENSE
    3. 

  3.  *
    4. 

  4.  * PSI4: an ab initio quantum chemistry software package
    5. 

  5.  *
    6. 

  6.  * This program is free software; you can redistribute it and/or modify
    7. 

  7.  * it under the terms of the GNU General Public License as published by
    8. 

  8.  * the Free Software Foundation; either version 2 of the License, or
    9. 

  9.  * (at your option) any later version.
    10. 

  10.  *
    11. 

  11.  * This program is distributed in the hope that it will be useful,
    12. 

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    13. 

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    14. 

  14.  * GNU General Public License for more details.
    15. 

  15.  *
    16. 

  16.  * You should have received a copy of the GNU General Public License along
    17. 

  17.  * with this program; if not, write to the Free Software Foundation, Inc.,
    18. 

  18.  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
    19. 

  19.  *
    20. 

  20.  *@END LICENSE
    21. 

  21.  */
    22. 

  22. 

  23. /**!
    24. 

  24. ** \file
    25. 

  25. ** \brief Interface to all LAPACK routines
    26. 

  26. ** \ingroup QT
    27. 

  27. **
    28. 

  28. ** Autogenerated by Rob Parrish on 1/23/2011
    29. 

  29. **
    30. 

  30. */
    31. 

  31. 

  32. #include "qt.h"
    33. 

  33. #include "lapack_intfc_mangle.h"
    34. 

  34. 

  35. extern "C" {
    36. 

  36. extern int F_DBDSDC(char*, char*, int*, double*, double*, double*, int*, double*, int*, double*, int*, double*, int*,  int*);
    37. 

  37. extern int F_DBDSQR(char*, int*, int*, int*, int*, double*, double*, double*, int*, double*, int*, double*, int*, double*,  int*);
    38. 

  38. extern int F_DDISNA(char*, int*, int*, double*, double*,  int*);
    39. 

  39. extern int F_DGBBRD(char*, int*, int*, int*, int*, int*, double*, int*, double*, double*, double*, int*, double*, int*, double*, int*, double*,  int*);
    40. 

  40. extern int F_DGBCON(char*, int*, int*, int*, double*, int*, int*, double*, double*, double*, int*,  int*);
    41. 

  41. extern int F_DGBEQU(int*, int*, int*, int*, double*, int*, double*, double*, double*, double*, double*,  int*);
    42. 

  42. extern int F_DGBRFS(char*, int*, int*, int*, int*, double*, int*, double*, int*, int*, double*, int*, double*, int*, double*, double*, double*, int*,  int*);
    43. 

  43. extern int F_DGBSV(int*, int*, int*, int*, double*, int*, int*, double*, int*,  int*);
    44. 

  44. extern int F_DGBSVX(char*, char*, int*, int*, int*, int*, double*, int*, double*, int*, int*, char*, double*, double*, double*, int*, double*, int*, double*, double*, double*, double*, int*,  int*);
    45. 

  45. extern int F_DGBTRF(int*, int*, int*, int*, double*, int*, int*,  int*);
    46. 

  46. extern int F_DGBTRS(char*, int*, int*, int*, int*, double*, int*, int*, double*, int*,  int*);
    47. 

  47. extern int F_DGEBAK(char*, char*, int*, int*, int*, double*, int*, double*, int*,  int*);
    48. 

  48. extern int F_DGEBAL(char*, int*, double*, int*, int*, int*, double*,  int*);
    49. 

  49. extern int F_DGEBRD(int*, int*, double*, int*, double*, double*, double*, double*, double*, int*,  int*);
    50. 

  50. extern int F_DGECON(char*, int*, double*, int*, double*, double*, double*, int*,  int*);
    51. 

  51. extern int F_DGEEQU(int*, int*, double*, int*, double*, double*, double*, double*, double*,  int*);
    52. 

  52. extern int F_DGEES(char*, char*, int*, double*, int*, int*, double*, double*, double*, int*, double*, int*,  int*);
    53. 

  53. extern int F_DGEESX(char*, char*, char*, int*, double*, int*, int*, double*, double*, double*, int*, double*, double*, double*, int*, int*, int*,  int*);
    54. 

  54. extern int F_DGEEV(char*, char*, int*, double*, int*, double*, double*, double*, int*, double*, int*, double*, int*,  int*);
    55. 

  55. extern int F_DGEEVX(char*, char*, char*, char*, int*, double*, int*, double*, double*, double*, int*, double*, int*, int*, int*, double*, double*, double*, double*, double*, int*, int*,  int*);
    56. 

  56. extern int F_DGEGS(char*, char*, int*, double*, int*, double*, int*, double*, double*, double*, double*, int*, double*, int*, double*, int*,  int*);
    57. 

  57. extern int F_DGEGV(char*, char*, int*, double*, int*, double*, int*, double*, double*, double*, double*, int*, double*, int*, double*, int*,  int*);
    58. 

  58. extern int F_DGEHRD(int*, int*, int*, double*, int*, double*, double*, int*,  int*);
    59. 

  59. extern int F_DGELQF(int*, int*, double*, int*, double*, double*, int*,  int*);
    60. 

  60. extern int F_DGELS(char*, int*, int*, int*, double*, int*, double*, int*, double*, int*,  int*);
    61. 

  61. extern int F_DGELSD(int*, int*, int*, double*, int*, double*, int*, double*, double*, int*, double*, int*, int*,  int*);
    62. 

  62. extern int F_DGELSS(int*, int*, int*, double*, int*, double*, int*, double*, double*, int*, double*, int*,  int*);
    63. 

  63. extern int F_DGELSX(int*, int*, int*, double*, int*, double*, int*, int*, double*, int*, double*,  int*);
    64. 

  64. extern int F_DGELSY(int*, int*, int*, double*, int*, double*, int*, int*, double*, int*, double*, int*,  int*);
    65. 

  65. extern int F_DGEQLF(int*, int*, double*, int*, double*, double*, int*,  int*);
    66. 

  66. extern int F_DGEQP3(int*, int*, double*, int*, int*, double*, double*, int*,  int*);
    67. 

  67. extern int F_DGEQPF(int*, int*, double*, int*, int*, double*, double*,  int*);
    68. 

  68. extern int F_DGEQRF(int*, int*, double*, int*, double*, double*, int*,  int*);
    69. 

  69. extern int F_DGERFS(char*, int*, int*, double*, int*, double*, int*, int*, double*, int*, double*, int*, double*, double*, double*, int*,  int*);
    70. 

  70. extern int F_DGERQF(int*, int*, double*, int*, double*, double*, int*,  int*);
    71. 

  71. extern int F_DGESDD(char*, int*, int*, double*, int*, double*, double*, int*, double*, int*, double*, int*, int*,  int*);
    72. 

  72. extern int F_DGESV(int*, int*, double*, int*, int*, double*, int*,  int*);
    73. 

  73. extern int F_DGESVX(char*, char*, int*, int*, double*, int*, double*, int*, int*, char*, double*, double*, double*, int*, double*, int*, double*, double*, double*, double*, int*,  int*);
    74. 

  74. extern int F_DGETRF(int*, int*, double*, int*, int*,  int*);
    75. 

  75. extern int F_DGETRI(int*, double*, int*, int*, double*, int*,  int*);
    76. 

  76. extern int F_DGETRS(char*, int*, int*, double*, int*, int*, double*, int*,  int*);
    77. 

  77. extern int F_DGGBAK(char*, char*, int*, int*, int*, double*, double*, int*, double*, int*,  int*);
    78. 

  78. extern int F_DGGBAL(char*, int*, double*, int*, double*, int*, int*, int*, double*, double*, double*,  int*);
    79. 

  79. extern int F_DGGES(char*, char*, char*, int*, double*, int*, double*, int*, int*, double*, double*, double*, double*, int*, double*, int*, double*, int*,  int*);
    80. 

  80. extern int F_DGGESX(char*, char*, char*, char*, int*, double*, int*, double*, int*, int*, double*, double*, double*, double*, int*, double*, int*, double*, double*, double*, int*, int*, int*,  int*);
    81. 

  81. extern int F_DGGEV(char*, char*, int*, double*, int*, double*, int*, double*, double*, double*, double*, int*, double*, int*, double*, int*,  int*);
    82. 

  82. extern int F_DGGEVX(char*, char*, char*, char*, int*, double*, int*, double*, int*, double*, double*, double*, double*, int*, double*, int*, int*, int*, double*, double*, double*, double*, double*, double*, double*, int*, int*,  int*);
    83. 

  83. extern int F_DGGGLM(int*, int*, int*, double*, int*, double*, int*, double*, double*, double*, double*, int*,  int*);
    84. 

  84. extern int F_DGGHRD(char*, char*, int*, int*, int*, double*, int*, double*, int*, double*, int*, double*, int*,  int*);
    85. 

  85. extern int F_DGGLSE(int*, int*, int*, double*, int*, double*, int*, double*, double*, double*, double*, int*,  int*);
    86. 

  86. extern int F_DGGQRF(int*, int*, int*, double*, int*, double*, double*, int*, double*, double*, int*,  int*);
    87. 

  87. extern int F_DGGRQF(int*, int*, int*, double*, int*, double*, double*, int*, double*, double*, int*,  int*);
    88. 

  88. extern int F_DGGSVD(char*, char*, char*, int*, int*, int*, int*, int*, double*, int*, double*, int*, double*, double*, double*, int*, double*, int*, double*, int*, double*, int*,  int*);
    89. 

  89. extern int F_DGGSVP(char*, char*, char*, int*, int*, int*, double*, int*, double*, int*, double*, double*, int*, int*, double*, int*, double*, int*, double*, int*, int*, double*, double*,  int*);
    90. 

  90. extern int F_DGTCON(char*, int*, double*, double*, double*, double*, int*, double*, double*, double*, int*,  int*);
    91. 

  91. extern int F_DGTRFS(char*, int*, int*, double*, double*, double*, double*, double*, double*, double*, int*, double*, int*, double*, int*, double*, double*, double*, int*,  int*);
    92. 

  92. extern int F_DGTSV(int*, int*, double*, double*, double*, double*, int*,  int*);
    93. 

  93. extern int F_DGTSVX(char*, char*, int*, int*, double*, double*, double*, double*, double*, double*, double*, int*, double*, int*, double*, int*, double*,  int*);
    94. 

  94. extern int F_DGTTRF(int*, double*, double*, double*, double*, int*,  int*);
    95. 

  95. extern int F_DGTTRS(char*, int*, int*, double*, double*, double*, double*, int*, double*, int*,  int*);
    96. 

  96. extern int F_DHGEQZ(char*, char*, char*, int*, int*, int*, double*, int*, double*, int*, double*, double*, double*, double*, int*, double*, int*, double*, int*,  int*);
    97. 

  97. extern int F_DHSEIN(char*, char*, char*, int*, double*, int*, double*, double*, double*, int*, double*, int*, int*, int*, double*, int*, int*,  int*);
    98. 

  98. extern int F_DHSEQR(char*, char*, int*, int*, int*, double*, int*, double*, double*, double*, int*, double*, int*,  int*);
    99. 

  99. extern int F_DOPGTR(char*, int*, double*, double*, double*, int*, double*,  int*);
    100. 

  100. extern int F_DOPMTR(char*, char*, char*, int*, int*, double*, double*, double*, int*, double*,  int*);
    101. 

  101. extern int F_DORGBR(char*, int*, int*, int*, double*, int*, double*, double*, int*,  int*);
    102. 

  102. extern int F_DORGHR(int*, int*, int*, double*, int*, double*, double*, int*,  int*);
    103. 

  103. extern int F_DORGLQ(int*, int*, int*, double*, int*, double*, double*, int*,  int*);
    104. 

  104. extern int F_DORGQL(int*, int*, int*, double*, int*, double*, double*, int*,  int*);
    105. 

  105. extern int F_DORGQR(int*, int*, int*, double*, int*, double*, double*, int*,  int*);
    106. 

  106. extern int F_DORGRQ(int*, int*, int*, double*, int*, double*, double*, int*,  int*);
    107. 

  107. extern int F_DORGTR(char*, int*, double*, int*, double*, double*, int*,  int*);
    108. 

  108. extern int F_DORMBR(char*, char*, char*, int*, int*, int*, double*, int*, double*, double*, int*, double*, int*,  int*);
    109. 

  109. extern int F_DORMHR(char*, char*, int*, int*, int*, int*, double*, int*, double*, double*, int*, double*, int*,  int*);
    110. 

  110. extern int F_DORMLQ(char*, char*, int*, int*, int*, double*, int*, double*, double*, int*, double*, int*,  int*);
    111. 

  111. extern int F_DORMQL(char*, char*, int*, int*, int*, double*, int*, double*, double*, int*, double*, int*,  int*);
    112. 

  112. extern int F_DORMQR(char*, char*, int*, int*, int*, double*, int*, double*, double*, int*, double*, int*,  int*);
    113. 

  113. extern int F_DORMR3(char*, char*, int*, int*, int*, int*, double*, int*, double*, double*, int*, double*,  int*);
    114. 

  114. extern int F_DORMRQ(char*, char*, int*, int*, int*, double*, int*, double*, double*, int*, double*, int*,  int*);
    115. 

  115. extern int F_DORMRZ(char*, char*, int*, int*, int*, int*, double*, int*, double*, double*, int*, double*, int*,  int*);
    116. 

  116. extern int F_DORMTR(char*, char*, char*, int*, int*, double*, int*, double*, double*, int*, double*, int*,  int*);
    117. 

  117. extern int F_DPBCON(char*, int*, int*, double*, int*, double*, double*, double*, int*,  int*);
    118. 

  118. extern int F_DPBEQU(char*, int*, int*, double*, int*, double*, double*, double*,  int*);
    119. 

  119. extern int F_DPBRFS(char*, int*, int*, int*, double*, int*, double*, int*, double*, int*, double*, int*, double*, double*, double*, int*,  int*);
    120. 

  120. extern int F_DPBSTF(char*, int*, int*, double*, int*,  int*);
    121. 

  121. extern int F_DPBSV(char*, int*, int*, int*, double*, int*, double*, int*,  int*);
    122. 

  122. extern int F_DPBSVX(char*, char*, int*, int*, int*, double*, int*, double*, int*, char*, double*, double*, int*, double*, int*, double*, double*, double*, double*, int*,  int*);
    123. 

  123. extern int F_DPBTRF(char*, int*, int*, double*, int*,  int*);
    124. 

  124. extern int F_DPBTRS(char*, int*, int*, int*, double*, int*, double*, int*,  int*);
    125. 

  125. extern int F_DPOCON(char*, int*, double*, int*, double*, double*, double*, int*,  int*);
    126. 

  126. extern int F_DPOEQU(int*, double*, int*, double*, double*, double*,  int*);
    127. 

  127. extern int F_DPORFS(char*, int*, int*, double*, int*, double*, int*, double*, int*, double*, int*, double*, double*, double*, int*,  int*);
    128. 

  128. extern int F_DPOSV(char*, int*, int*, double*, int*, double*, int*,  int*);
    129. 

  129. extern int F_DPOSVX(char*, char*, int*, int*, double*, int*, double*, int*, char*, double*, double*, int*, double*, int*, double*, double*, double*, double*, int*,  int*);
    130. 

  130. extern int F_DPOTRF(char*, int*, double*, int*,  int*);
    131. 

  131. extern int F_DPOTRI(char*, int*, double*, int*,  int*);
    132. 

  132. extern int F_DPOTRS(char*, int*, int*, double*, int*, double*, int*,  int*);
    133. 

  133. extern int F_DPPCON(char*, int*, double*, double*, double*, double*, int*,  int*);
    134. 

  134. extern int F_DPPEQU(char*, int*, double*, double*, double*, double*,  int*);
    135. 

  135. extern int F_DPPRFS(char*, int*, int*, double*, double*, double*, int*, double*, int*, double*, double*, double*, int*,  int*);
    136. 

  136. extern int F_DPPSV(char*, int*, int*, double*, double*, int*,  int*);
    137. 

  137. extern int F_DPPSVX(char*, char*, int*, int*, double*, double*, char*, double*, double*, int*, double*, int*, double*, double*, double*, double*, int*,  int*);
    138. 

  138. extern int F_DPPTRF(char*, int*, double*,  int*);
    139. 

  139. extern int F_DPPTRI(char*, int*, double*,  int*);
    140. 

  140. extern int F_DPPTRS(char*, int*, int*, double*, double*, int*,  int*);
    141. 

  141. extern int F_DPTCON(int*, double*, double*, double*, double*, double*,  int*);
    142. 

  142. extern int F_DPTEQR(char*, int*, double*, double*, double*, int*, double*,  int*);
    143. 

  143. extern int F_DPTRFS(int*, int*, double*, double*, double*, double*, double*, int*, double*, int*, double*, double*, double*,  int*);
    144. 

  144. extern int F_DPTSV(int*, int*, double*, double*, double*, int*,  int*);
    145. 

  145. extern int F_DPTSVX(char*, int*, int*, double*, double*, double*, double*, double*, int*, double*, int*, double*, double*, double*, double*,  int*);
    146. 

  146. extern int F_DPTTRF(int*, double*, double*,  int*);
    147. 

  147. extern int F_DPTTRS(int*, int*, double*, double*, double*, int*,  int*);
    148. 

  148. extern int F_DSBEV(char*, char*, int*, int*, double*, int*, double*, double*, int*, double*,  int*);
    149. 

  149. extern int F_DSBEVD(char*, char*, int*, int*, double*, int*, double*, double*, int*, double*, int*, int*, int*,  int*);
    150. 

  150. extern int F_DSBEVX(char*, char*, char*, int*, int*, double*, int*, double*, int*, double*, double*, int*, int*, double*, int*, double*, double*, int*, double*, int*, int*,  int*);
    151. 

  151. extern int F_DSBGST(char*, char*, int*, int*, int*, double*, int*, double*, int*, double*, int*, double*,  int*);
    152. 

  152. extern int F_DSBGV(char*, char*, int*, int*, int*, double*, int*, double*, int*, double*, double*, int*, double*,  int*);
    153. 

  153. extern int F_DSBGVD(char*, char*, int*, int*, int*, double*, int*, double*, int*, double*, double*, int*, double*, int*, int*, int*,  int*);
    154. 

  154. extern int F_DSBGVX(char*, char*, char*, int*, int*, int*, double*, int*, double*, int*, double*, int*, double*, double*, int*, int*, double*, int*, double*, double*, int*, double*, int*, int*,  int*);
    155. 

  155. extern int F_DSBTRD(char*, char*, int*, int*, double*, int*, double*, double*, double*, int*, double*,  int*);
    156. 

  156. extern int F_DSGESV(int*, int*, double*, int*, int*, double*, int*, double*, int*, double*, int*,  int*);
    157. 

  157. extern int F_DSPCON(char*, int*, double*, int*, double*, double*, double*, int*,  int*);
    158. 

  158. extern int F_DSPEV(char*, char*, int*, double*, double*, double*, int*, double*,  int*);
    159. 

  159. extern int F_DSPEVD(char*, char*, int*, double*, double*, double*, int*, double*, int*, int*, int*,  int*);
    160. 

  160. extern int F_DSPEVX(char*, char*, char*, int*, double*, double*, double*, int*, int*, double*, int*, double*, double*, int*, double*, int*, int*,  int*);
    161. 

  161. extern int F_DSPGST(int*, char*, int*, double*, double*,  int*);
    162. 

  162. extern int F_DSPGV(int*, char*, char*, int*, double*, double*, double*, double*, int*, double*,  int*);
    163. 

  163. extern int F_DSPGVD(int*, char*, char*, int*, double*, double*, double*, double*, int*, double*, int*, int*, int*,  int*);
    164. 

  164. extern int F_DSPGVX(int*, char*, char*, char*, int*, double*, double*, double*, double*, int*, int*, double*, int*, double*, double*, int*, double*, int*, int*,  int*);
    165. 

  165. extern int F_DSPRFS(char*, int*, int*, double*, double*, int*, double*, int*, double*, int*, double*, double*, double*, int*,  int*);
    166. 

  166. extern int F_DSPSV(char*, int*, int*, double*, int*, double*, int*,  int*);
    167. 

  167. extern int F_DSPSVX(char*, char*, int*, int*, double*, double*, int*, double*, int*, double*, int*, double*,  int*);
    168. 

  168. extern int F_DSPTRD(char*, int*, double*, double*, double*, double*,  int*);
    169. 

  169. extern int F_DSPTRF(char*, int*, double*, int*,  int*);
    170. 

  170. extern int F_DSPTRI(char*, int*, double*, int*, double*,  int*);
    171. 

  171. extern int F_DSPTRS(char*, int*, int*, double*, int*, double*, int*,  int*);
    172. 

  172. extern int F_DSTEBZ(char*, char*, int*, double*, double*, int*, int*, double*, double*, double*, int*, int*, double*, int*, int*, double*, int*,  int*);
    173. 

  173. extern int F_DSTEDC(char*, int*, double*, double*, double*, int*, double*, int*, int*, int*,  int*);
    174. 

  174. extern int F_DSTEGR(char*, char*, int*, double*, double*, double*, double*, int*, int*, double*, int*, double*, double*, int*, int*, double*, int*, int*, int*,  int*);
    175. 

  175. extern int F_DSTEIN(int*, double*, double*, int*, double*, int*, int*, double*, int*, double*, int*, int*,  int*);
    176. 

  176. extern int F_DSTEQR(char*, int*, double*, double*, double*, int*, double*,  int*);
    177. 

  177. extern int F_DSTERF(int*, double*, double*,  int*);
    178. 

  178. extern int F_DSTEV(char*, int*, double*, double*, double*, int*, double*,  int*);
    179. 

  179. extern int F_DSTEVD(char*, int*, double*, double*, double*, int*, double*, int*, int*, int*,  int*);
    180. 

  180. extern int F_DSTEVR(char*, char*, int*, double*, double*, double*, double*, int*, int*, double*, int*, double*, double*, int*, int*, double*, int*, int*, int*,  int*);
    181. 

  181. extern int F_DSTEVX(char*, char*, int*, double*, double*, double*, double*, int*, int*, double*, int*, double*, double*, int*, double*, int*, int*,  int*);
    182. 

  182. extern int F_DSYCON(char*, int*, double*, int*, int*, double*, double*, double*, int*,  int*);
    183. 

  183. extern int F_DSYEV(char*, char*, int*, double*, int*, double*, double*, int*,  int*);
    184. 

  184. extern int F_DSYEVD(char*, char*, int*, double*, int*, double*, double*, int*, int*, int*,  int*);
    185. 

  185. extern int F_DSYEVR(char*, char*, char*, int*, double*, int*, double*, double*, int*, int*, double*, int*, double*, double*, int*, int*, double*, int*, int*, int*,  int*);
    186. 

  186. extern int F_DSYEVX(char*, char*, char*, int*, double*, int*, double*, double*, int*, int*, double*, int*, double*, double*, int*, double*, int*, int*, int*,  int*);
    187. 

  187. extern int F_DSYGST(int*, char*, int*, double*, int*, double*, int*,  int*);
    188. 

  188. extern int F_DSYGV(int*, char*, char*, int*, double*, int*, double*, int*, double*, double*, int*,  int*);
    189. 

  189. extern int F_DSYGVD(int*, char*, char*, int*, double*, int*, double*, int*, double*, double*, int*, int*, int*,  int*);
    190. 

  190. extern int F_DSYGVX(int*, char*, char*, char*, int*, double*, int*, double*, int*, double*, double*, int*, int*, double*, int*, double*, double*, int*, double*, int*, int*, int*,  int*);
    191. 

  191. extern int F_DSYRFS(char*, int*, int*, double*, int*, double*, int*, int*, double*, int*, double*, int*, double*, double*, double*, int*,  int*);
    192. 

  192. extern int F_DSYSV(char*, int*, int*, double*, int*, int*, double*, int*, double*, int*,  int*);
    193. 

  193. extern int F_DSYSVX(char*, char*, int*, int*, double*, int*, double*, int*, int*, double*, int*, double*, int*, double*,  int*);
    194. 

  194. extern int F_DSYTRD(char*, int*, double*, int*, double*, double*, double*, double*, int*,  int*);
    195. 

  195. extern int F_DSYTRF(char*, int*, double*, int*, int*, double*, int*,  int*);
    196. 

  196. extern int F_DSYTRI(char*, int*, double*, int*, int*, double*,  int*);
    197. 

  197. extern int F_DSYTRS(char*, int*, int*, double*, int*, int*, double*, int*,  int*);
    198. 

  198. extern int F_DTBCON(char*, char*, char*, int*, int*, double*, int*, double*, double*, int*,  int*);
    199. 

  199. extern int F_DTBRFS(char*, char*, char*, int*, int*, int*, double*, int*, double*, int*, double*, int*, double*, double*, double*, int*,  int*);
    200. 

  200. extern int F_DTBTRS(char*, char*, char*, int*, int*, int*, double*, int*, double*, int*,  int*);
    201. 

  201. extern int F_DTGEVC(char*, char*, int*, double*, int*, double*, int*, double*, int*, double*, int*, int*, int*, double*,  int*);
    202. 

  202. extern int F_DTGEXC(int*, double*, int*, double*, int*, double*, int*, double*, int*, int*, int*, double*, int*,  int*);
    203. 

  203. extern int F_DTGSEN(int*, int*, double*, int*, double*, int*, double*, double*, double*, double*, int*, double*, int*, int*, double*, double*, double*, double*, int*, int*, int*,  int*);
    204. 

  204. extern int F_DTGSJA(char*, char*, char*, int*, int*, int*, int*, int*, double*, int*, double*, int*, double*, double*, double*, double*, double*, int*, double*, int*, double*, int*, double*, int*,  int*);
    205. 

  205. extern int F_DTGSNA(char*, char*, int*, double*, int*, double*, int*, double*, int*, double*, int*, double*, double*, int*, int*, double*, int*, int*,  int*);
    206. 

  206. extern int F_DTGSYL(char*, int*, int*, int*, double*, int*, double*, int*, double*, int*, double*, int*, double*, int*, double*, int*, double*, double*, double*, int*, int*,  int*);
    207. 

  207. extern int F_DTPCON(char*, char*, char*, int*, double*, double*, double*, int*,  int*);
    208. 

  208. extern int F_DTPRFS(char*, char*, char*, int*, int*, double*, double*, int*, double*, int*, double*, double*, double*, int*,  int*);
    209. 

  209. extern int F_DTPTRI(char*, char*, int*, double*,  int*);
    210. 

  210. extern int F_DTPTRS(char*, char*, char*, int*, int*, double*, double*, int*,  int*);
    211. 

  211. extern int F_DTRCON(char*, char*, char*, int*, double*, int*, double*, double*, int*,  int*);
    212. 

  212. extern int F_DTREVC(char*, char*, int*, double*, int*, double*, int*, double*, int*, int*, int*, double*,  int*);
    213. 

  213. extern int F_DTREXC(char*, int*, double*, int*, double*, int*, int*, int*, double*,  int*);
    214. 

  214. extern int F_DTRRFS(char*, char*, char*, int*, int*, double*, int*, double*, int*, double*, int*, double*, double*, double*, int*,  int*);
    215. 

  215. extern int F_DTRSEN(char*, char*, int*, double*, int*, double*, int*, double*, double*, int*, double*, double*, double*, int*, int*, int*,  int*);
    216. 

  216. extern int F_DTRSNA(char*, char*, int*, double*, int*, double*, int*, double*, int*, double*, double*, int*, int*, double*, int*, int*,  int*);
    217. 

  217. extern int F_DTRSYL(char*, char*, int*, int*, int*, double*, int*, double*, int*, double*, int*, double*,  int*);
    218. 

  218. extern int F_DTRTRI(char*, char*, int*, double*, int*,  int*);
    219. 

  219. extern int F_DTRTRS(char*, char*, char*, int*, int*, double*, int*, double*, int*,  int*);
    220. 

  220. extern int F_DTZRQF(int*, int*, double*, int*, double*,  int*);
    221. 

  221. extern int F_DTZRZF(int*, int*, double*, int*, double*, double*, int*,  int*);
    222. 

  222. }
    223. 

  223. 

  224. namespace psi {
    225. 

  225. /**
    226. 

  226. *  Purpose
    227. 

  227. *  =======
    228. 

  228. *
    229. 

  229. *  DBDSDC computes the singular value decomposition (SVD) of a real
    230. 

  230. *  N-by-N (upper or lower) bidiagonal matrix B:  B = U * S * VT,
    231. 

  231. *  using a divide and conquer method, where S is a diagonal matrix
    232. 

  232. *  with non-negative diagonal elements (the singular values of B), and
    233. 

  233. *  U and VT are orthogonal matrices of left and right singular vectors,
    234. 

  234. *  respectively. DBDSDC can be used to compute all singular values,
    235. 

  235. *  and optionally, singular vectors or singular vectors in compact form.
    236. 

  236. *
    237. 

  237. *  This code makes very mild assumptions about floating point
    238. 

  238. *  arithmetic. It will work on machines with a guard digit in
    239. 

  239. *  add/subtract, or on those binary machines without guard digits
    240. 

  240. *  which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2.
    241. 

  241. *  It could conceivably fail on hexadecimal or decimal machines
    242. 

  242. *  without guard digits, but we know of none.  See DLASD3 for details.
    243. 

  243. *
    244. 

  244. *  The code currently calls DLASDQ if singular values only are desired.
    245. 

  245. *  However, it can be slightly modified to compute singular values
    246. 

  246. *  using the divide and conquer method.
    247. 

  247. *
    248. 

  248. *  Arguments
    249. 

  249. *  =========
    250. 

  250. *
    251. 

  251. *  UPLO    (input) CHARACTER*1
    252. 

  252. *          = 'U':  B is upper bidiagonal.
    253. 

  253. *          = 'L':  B is lower bidiagonal.
    254. 

  254. *
    255. 

  255. *  COMPQ   (input) CHARACTER*1
    256. 

  256. *          Specifies whether singular vectors are to be computed
    257. 

  257. *          as follows:
    258. 

  258. *          = 'N':  Compute singular values only;
    259. 

  259. *          = 'P':  Compute singular values and compute singular
    260. 

  260. *                  vectors in compact form;
    261. 

  261. *          = 'I':  Compute singular values and singular vectors.
    262. 

  262. *
    263. 

  263. *  N       (input) INTEGER
    264. 

  264. *          The order of the matrix B.  N >= 0.
    265. 

  265. *
    266. 

  266. *  D       (input/output) DOUBLE PRECISION array, dimension (N)
    267. 

  267. *          On entry, the n diagonal elements of the bidiagonal matrix B.
    268. 

  268. *          On exit, if INFO=0, the singular values of B.
    269. 

  269. *
    270. 

  270. *  E       (input/output) DOUBLE PRECISION array, dimension (N-1)
    271. 

  271. *          On entry, the elements of E contain the offdiagonal
    272. 

  272. *          elements of the bidiagonal matrix whose SVD is desired.
    273. 

  273. *          On exit, E has been destroyed.
    274. 

  274. *
    275. 

  275. *  U       (output) DOUBLE PRECISION array, dimension (LDU,N)
    276. 

  276. *          If  COMPQ = 'I', then:
    277. 

  277. *             On exit, if INFO = 0, U contains the left singular vectors
    278. 

  278. *             of the bidiagonal matrix.
    279. 

  279. *          For other values of COMPQ, U is not referenced.
    280. 

  280. *
    281. 

  281. *  LDU     (input) INTEGER
    282. 

  282. *          The leading dimension of the array U.  LDU >= 1.
    283. 

  283. *          If singular vectors are desired, then LDU >= max( 1, N ).
    284. 

  284. *
    285. 

  285. *  VT      (output) DOUBLE PRECISION array, dimension (LDVT,N)
    286. 

  286. *          If  COMPQ = 'I', then:
    287. 

  287. *             On exit, if INFO = 0, VT' contains the right singular
    288. 

  288. *             vectors of the bidiagonal matrix.
    289. 

  289. *          For other values of COMPQ, VT is not referenced.
    290. 

  290. *
    291. 

  291. *  LDVT    (input) INTEGER
    292. 

  292. *          The leading dimension of the array VT.  LDVT >= 1.
    293. 

  293. *          If singular vectors are desired, then LDVT >= max( 1, N ).
    294. 

  294. *
    295. 

  295. *  Q       (output) DOUBLE PRECISION array, dimension (LDQ)
    296. 

  296. *          If  COMPQ = 'P', then:
    297. 

  297. *             On exit, if INFO = 0, Q and IQ contain the left
    298. 

  298. *             and right singular vectors in a compact form,
    299. 

  299. *             requiring O(N log N) space instead of 2*N**2.
    300. 

  300. *             In particular, Q contains all the DOUBLE PRECISION data in
    301. 

  301. *             LDQ >= N*(11 + 2*SMLSIZ + 8*INT(LOG_2(N/(SMLSIZ+1))))
    302. 

  302. *             words of memory, where SMLSIZ is returned by ILAENV and
    303. 

  303. *             is equal to the maximum size of the subproblems at the
    304. 

  304. *             bottom of the computation tree (usually about 25).
    305. 

  305. *          For other values of COMPQ, Q is not referenced.
    306. 

  306. *
    307. 

  307. *  IQ      (output) INTEGER array, dimension (LDIQ)
    308. 

  308. *          If  COMPQ = 'P', then:
    309. 

  309. *             On exit, if INFO = 0, Q and IQ contain the left
    310. 

  310. *             and right singular vectors in a compact form,
    311. 

  311. *             requiring O(N log N) space instead of 2*N**2.
    312. 

  312. *             In particular, IQ contains all INTEGER data in
    313. 

  313. *             LDIQ >= N*(3 + 3*INT(LOG_2(N/(SMLSIZ+1))))
    314. 

  314. *             words of memory, where SMLSIZ is returned by ILAENV and
    315. 

  315. *             is equal to the maximum size of the subproblems at the
    316. 

  316. *             bottom of the computation tree (usually about 25).
    317. 

  317. *          For other values of COMPQ, IQ is not referenced.
    318. 

  318. *
    319. 

  319. *  WORK    (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK))
    320. 

  320. *          If COMPQ = 'N' then LWORK >= (4 * N).
    321. 

  321. *          If COMPQ = 'P' then LWORK >= (6 * N).
    322. 

  322. *          If COMPQ = 'I' then LWORK >= (3 * N**2 + 4 * N).
    323. 

  323. *
    324. 

  324. *  IWORK   (workspace) INTEGER array, dimension (8*N)
    325. 

  325. *
    326. 

  326. *  C++ Return value: INFO    (output) INTEGER
    327. 

  327. *          = 0:  successful exit.
    328. 

  328. *          < 0:  if INFO = -i, the i-th argument had an illegal value.
    329. 

  329. *          > 0:  The algorithm failed to compute a singular value.
    330. 

  330. *                The update process of divide and conquer failed.
    331. 

  331. *
    332. 

  332. *  Further Details
    333. 

  333. *  ===============
    334. 

  334. *
    335. 

  335. *  Based on contributions by
    336. 

  336. *     Ming Gu and Huan Ren, Computer Science Division, University of
    337. 

  337. *     California at Berkeley, USA
    338. 

  338. *
    339. 

  339. *  =====================================================================
    340. 

  340. *  Changed dimension statement in comment describing E from (N) to
    341. 

  341. *  (N-1).  Sven, 17 Feb 05.
    342. 

  342. *  =====================================================================
    343. 

  343. *
    344. 

  344. *     .. Parameters ..
    345. 

  345. **/
    346. 

  346. int C_DBDSDC(char uplo, char compq, int n, double* d, double* e, double* u, int ldu, double* vt, int ldvt, double* q, int* iq, double* work, int* iwork)
    347. 

  347. {
    348. 

  348.     int info;
    349. 

  349.     ::F_DBDSDC(&uplo, &compq, &n, d, e, u, &ldu, vt, &ldvt, q, iq, work, iwork, &info);
    350. 

  350.     return info;
    351. 

  351. }
    352. 

  352. 

  353. /**
    354. 

  354. *  Purpose
    355. 

  355. *  =======
    356. 

  356. *
    357. 

  357. *  DBDSQR computes the singular values and, optionally, the right and/or
    358. 

  358. *  left singular vectors from the singular value decomposition (SVD) of
    359. 

  359. *  a real N-by-N (upper or lower) bidiagonal matrix B using the implicit
    360. 

  360. *  zero-shift QR algorithm.  The SVD of B has the form
    361. 

  361. * 
    362. 

  362. *     B = Q * S * P**T
    363. 

  363. * 
    364. 

  364. *  where S is the diagonal matrix of singular values, Q is an orthogonal
    365. 

  365. *  matrix of left singular vectors, and P is an orthogonal matrix of
    366. 

  366. *  right singular vectors.  If left singular vectors are requested, this
    367. 

  367. *  subroutine actually returns U*Q instead of Q, and, if right singular
    368. 

  368. *  vectors are requested, this subroutine returns P**T*VT instead of
    369. 

  369. *  P**T, for given real input matrices U and VT.  When U and VT are the
    370. 

  370. *  orthogonal matrices that reduce a general matrix A to bidiagonal
    371. 

  371. *  form:  A = U*B*VT, as computed by DGEBRD, then
    372. 

  372. *
    373. 

  373. *     A = (U*Q) * S * (P**T*VT)
    374. 

  374. *
    375. 

  375. *  is the SVD of A.  Optionally, the subroutine may also compute Q**T*C
    376. 

  376. *  for a given real input matrix C.
    377. 

  377. *
    378. 

  378. *  See "Computing  Small Singular Values of Bidiagonal Matrices With
    379. 

  379. *  Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan,
    380. 

  380. *  LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11,
    381. 

  381. *  no. 5, pp. 873-912, Sept 1990) and
    382. 

  382. *  "Accurate singular values and differential qd algorithms," by
    383. 

  383. *  B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics
    384. 

  384. *  Department, University of California at Berkeley, July 1992
    385. 

  385. *  for a detailed description of the algorithm.
    386. 

  386. *
    387. 

  387. *  Arguments
    388. 

  388. *  =========
    389. 

  389. *
    390. 

  390. *  UPLO    (input) CHARACTER*1
    391. 

  391. *          = 'U':  B is upper bidiagonal;
    392. 

  392. *          = 'L':  B is lower bidiagonal.
    393. 

  393. *
    394. 

  394. *  N       (input) INTEGER
    395. 

  395. *          The order of the matrix B.  N >= 0.
    396. 

  396. *
    397. 

  397. *  NCVT    (input) INTEGER
    398. 

  398. *          The number of columns of the matrix VT. NCVT >= 0.
    399. 

  399. *
    400. 

  400. *  NRU     (input) INTEGER
    401. 

  401. *          The number of rows of the matrix U. NRU >= 0.
    402. 

  402. *
    403. 

  403. *  NCC     (input) INTEGER
    404. 

  404. *          The number of columns of the matrix C. NCC >= 0.
    405. 

  405. *
    406. 

  406. *  D       (input/output) DOUBLE PRECISION array, dimension (N)
    407. 

  407. *          On entry, the n diagonal elements of the bidiagonal matrix B.
    408. 

  408. *          On exit, if INFO=0, the singular values of B in decreasing
    409. 

  409. *          order.
    410. 

  410. *
    411. 

  411. *  E       (input/output) DOUBLE PRECISION array, dimension (N-1)
    412. 

  412. *          On entry, the N-1 offdiagonal elements of the bidiagonal
    413. 

  413. *          matrix B. 
    414. 

  414. *          On exit, if INFO = 0, E is destroyed; if INFO > 0, D and E
    415. 

  415. *          will contain the diagonal and superdiagonal elements of a
    416. 

  416. *          bidiagonal matrix orthogonally equivalent to the one given
    417. 

  417. *          as input.
    418. 

  418. *
    419. 

  419. *  VT      (input/output) DOUBLE PRECISION array, dimension (LDVT, NCVT)
    420. 

  420. *          On entry, an N-by-NCVT matrix VT.
    421. 

  421. *          On exit, VT is overwritten by P**T * VT.
    422. 

  422. *          Not referenced if NCVT = 0.
    423. 

  423. *
    424. 

  424. *  LDVT    (input) INTEGER
    425. 

  425. *          The leading dimension of the array VT.
    426. 

  426. *          LDVT >= max(1,N) if NCVT > 0; LDVT >= 1 if NCVT = 0.
    427. 

  427. *
    428. 

  428. *  U       (input/output) DOUBLE PRECISION array, dimension (LDU, N)
    429. 

  429. *          On entry, an NRU-by-N matrix U.
    430. 

  430. *          On exit, U is overwritten by U * Q.
    431. 

  431. *          Not referenced if NRU = 0.
    432. 

  432. *
    433. 

  433. *  LDU     (input) INTEGER
    434. 

  434. *          The leading dimension of the array U.  LDU >= max(1,NRU).
    435. 

  435. *
    436. 

  436. *  C       (input/output) DOUBLE PRECISION array, dimension (LDC, NCC)
    437. 

  437. *          On entry, an N-by-NCC matrix C.
    438. 

  438. *          On exit, C is overwritten by Q**T * C.
    439. 

  439. *          Not referenced if NCC = 0.
    440. 

  440. *
    441. 

  441. *  LDC     (input) INTEGER
    442. 

  442. *          The leading dimension of the array C.
    443. 

  443. *          LDC >= max(1,N) if NCC > 0; LDC >=1 if NCC = 0.
    444. 

  444. *
    445. 

  445. *  WORK    (workspace) DOUBLE PRECISION array, dimension (4*N)
    446. 

  446. *
    447. 

  447. *  C++ Return value: INFO    (output) INTEGER
    448. 

  448. *          = 0:  successful exit
    449. 

  449. *          < 0:  If INFO = -i, the i-th argument had an illegal value
    450. 

  450. *          > 0:
    451. 

  451. *             if NCVT = NRU = NCC = 0,
    452. 

  452. *                = 1, a split was marked by a positive value in E
    453. 

  453. *                = 2, current block of Z not diagonalized after 30*N
    454. 

  454. *                     iterations (in inner while loop)
    455. 

  455. *                = 3, termination criterion of outer while loop not met 
    456. 

  456. *                     (program created more than N unreduced blocks)
    457. 

  457. *             else NCVT = NRU = NCC = 0,
    458. 

  458. *                   the algorithm did not converge; D and E contain the
    459. 

  459. *                   elements of a bidiagonal matrix which is orthogonally
    460. 

  460. *                   similar to the input matrix B;  if INFO = i, i
    461. 

  461. *                   elements of E have not converged to zero.
    462. 

  462. *
    463. 

  463. *  Internal Parameters
    464. 

  464. *  ===================
    465. 

  465. *
    466. 

  466. *  TOLMUL  DOUBLE PRECISION, default = max(10,min(100,EPS**(-1/8)))
    467. 

  467. *          TOLMUL controls the convergence criterion of the QR loop.
    468. 

  468. *          If it is positive, TOLMUL*EPS is the desired relative
    469. 

  469. *             precision in the computed singular values.
    470. 

  470. *          If it is negative, abs(TOLMUL*EPS*sigma_max) is the
    471. 

  471. *             desired absolute accuracy in the computed singular
    472. 

  472. *             values (corresponds to relative accuracy
    473. 

  473. *             abs(TOLMUL*EPS) in the largest singular value.
    474. 

  474. *          abs(TOLMUL) should be between 1 and 1/EPS, and preferably
    475. 

  475. *             between 10 (for fast convergence) and .1/EPS
    476. 

  476. *             (for there to be some accuracy in the results).
    477. 

  477. *          Default is to lose at either one eighth or 2 of the
    478. 

  478. *             available decimal digits in each computed singular value
    479. 

  479. *             (whichever is smaller).
    480. 

  480. *
    481. 

  481. *  MAXITR  INTEGER, default = 6
    482. 

  482. *          MAXITR controls the maximum number of passes of the
    483. 

  483. *          algorithm through its inner loop. The algorithms stops
    484. 

  484. *          (and so fails to converge) if the number of passes
    485. 

  485. *          through the inner loop exceeds MAXITR*N**2.
    486. 

  486. *
    487. 

  487. *  =====================================================================
    488. 

  488. *
    489. 

  489. *     .. Parameters ..
    490. 

  490. **/
    491. 

  491. int C_DBDSQR(char uplo, int n, int ncvt, int nru, int ncc, double* d, double* e, double* vt, int ldvt, double* u, int ldu, double* c, int ldc, double* work)
    492. 

  492. {
    493. 

  493.     int info;
    494. 

  494.     ::F_DBDSQR(&uplo, &n, &ncvt, &nru, &ncc, d, e, vt, &ldvt, u, &ldu, c, &ldc, work, &info);
    495. 

  495.     return info;
    496. 

  496. }
    497. 

  497. 

  498. /**
    499. 

  499. *  Purpose
    500. 

  500. *  =======
    501. 

  501. *
    502. 

  502. *  DDISNA computes the reciprocal condition numbers for the eigenvectors
    503. 

  503. *  of a real symmetric or complex Hermitian matrix or for the left or
    504. 

  504. *  right singular vectors of a general m-by-n matrix. The reciprocal
    505. 

  505. *  condition number is the 'gap' between the corresponding eigenvalue or
    506. 

  506. *  singular value and the nearest other one.
    507. 

  507. *
    508. 

  508. *  The bound on the error, measured by angle in radians, in the I-th
    509. 

  509. *  computed vector is given by
    510. 

  510. *
    511. 

  511. *         DLAMCH( 'E' ) * ( ANORM / SEP( I ) )
    512. 

  512. *
    513. 

  513. *  where ANORM = 2-norm(A) = max( abs( D(j) ) ).  SEP(I) is not allowed
    514. 

  514. *  to be smaller than DLAMCH( 'E' )*ANORM in order to limit the size of
    515. 

  515. *  the error bound.
    516. 

  516. *
    517. 

  517. *  DDISNA may also be used to compute error bounds for eigenvectors of
    518. 

  518. *  the generalized symmetric definite eigenproblem.
    519. 

  519. *
    520. 

  520. *  Arguments
    521. 

  521. *  =========
    522. 

  522. *
    523. 

  523. *  JOB     (input) CHARACTER*1
    524. 

  524. *          Specifies for which problem the reciprocal condition numbers
    525. 

  525. *          should be computed:
    526. 

  526. *          = 'E':  the eigenvectors of a symmetric/Hermitian matrix;
    527. 

  527. *          = 'L':  the left singular vectors of a general matrix;
    528. 

  528. *          = 'R':  the right singular vectors of a general matrix.
    529. 

  529. *
    530. 

  530. *  M       (input) INTEGER
    531. 

  531. *          The number of rows of the matrix. M >= 0.
    532. 

  532. *
    533. 

  533. *  N       (input) INTEGER
    534. 

  534. *          If JOB = 'L' or 'R', the number of columns of the matrix,
    535. 

  535. *          in which case N >= 0. Ignored if JOB = 'E'.
    536. 

  536. *
    537. 

  537. *  D       (input) DOUBLE PRECISION array, dimension (M) if JOB = 'E'
    538. 

  538. *                              dimension (min(M,N)) if JOB = 'L' or 'R'
    539. 

  539. *          The eigenvalues (if JOB = 'E') or singular values (if JOB =
    540. 

  540. *          'L' or 'R') of the matrix, in either increasing or decreasing
    541. 

  541. *          order. If singular values, they must be non-negative.
    542. 

  542. *
    543. 

  543. *  SEP     (output) DOUBLE PRECISION array, dimension (M) if JOB = 'E'
    544. 

  544. *                               dimension (min(M,N)) if JOB = 'L' or 'R'
    545. 

  545. *          The reciprocal condition numbers of the vectors.
    546. 

  546. *
    547. 

  547. *  C++ Return value: INFO    (output) INTEGER
    548. 

  548. *          = 0:  successful exit.
    549. 

  549. *          < 0:  if INFO = -i, the i-th argument had an illegal value.
    550. 

  550. *
    551. 

  551. *  =====================================================================
    552. 

  552. *
    553. 

  553. *     .. Parameters ..
    554. 

  554. **/
    555. 

  555. int C_DDISNA(char job, int m, int n, double* d, double* sep)
    556. 

  556. {
    557. 

  557.     int info;
    558. 

  558.     ::F_DDISNA(&job, &m, &n, d, sep, &info);
    559. 

  559.     return info;
    560. 

  560. }
    561. 

  561. 

  562. /**
    563. 

  563. *  Purpose
    564. 

  564. *  =======
    565. 

  565. *
    566. 

  566. *  DGBBRD reduces a real general m-by-n band matrix A to upper
    567. 

  567. *  bidiagonal form B by an orthogonal transformation: Q' * A * P = B.
    568. 

  568. *
    569. 

  569. *  The routine computes B, and optionally forms Q or P', or computes
    570. 

  570. *  Q'*C for a given matrix C.
    571. 

  571. *
    572. 

  572. *  Arguments
    573. 

  573. *  =========
    574. 

  574. *
    575. 

  575. *  VECT    (input) CHARACTER*1
    576. 

  576. *          Specifies whether or not the matrices Q and P' are to be
    577. 

  577. *          formed.
    578. 

  578. *          = 'N': do not form Q or P';
    579. 

  579. *          = 'Q': form Q only;
    580. 

  580. *          = 'P': form P' only;
    581. 

  581. *          = 'B': form both.
    582. 

  582. *
    583. 

  583. *  M       (input) INTEGER
    584. 

  584. *          The number of rows of the matrix A.  M >= 0.
    585. 

  585. *
    586. 

  586. *  N       (input) INTEGER
    587. 

  587. *          The number of columns of the matrix A.  N >= 0.
    588. 

  588. *
    589. 

  589. *  NCC     (input) INTEGER
    590. 

  590. *          The number of columns of the matrix C.  NCC >= 0.
    591. 

  591. *
    592. 

  592. *  KL      (input) INTEGER
    593. 

  593. *          The number of subdiagonals of the matrix A. KL >= 0.
    594. 

  594. *
    595. 

  595. *  KU      (input) INTEGER
    596. 

  596. *          The number of superdiagonals of the matrix A. KU >= 0.
    597. 

  597. *
    598. 

  598. *  AB      (input/output) DOUBLE PRECISION array, dimension (LDAB,N)
    599. 

  599. *          On entry, the m-by-n band matrix A, stored in rows 1 to
    600. 

  600. *          KL+KU+1. The j-th column of A is stored in the j-th column of
    601. 

  601. *          the array AB as follows:
    602. 

  602. *          AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl).
    603. 

  603. *          On exit, A is overwritten by values generated during the
    604. 

  604. *          reduction.
    605. 

  605. *
    606. 

  606. *  LDAB    (input) INTEGER
    607. 

  607. *          The leading dimension of the array A. LDAB >= KL+KU+1.
    608. 

  608. *
    609. 

  609. *  D       (output) DOUBLE PRECISION array, dimension (min(M,N))
    610. 

  610. *          The diagonal elements of the bidiagonal matrix B.
    611. 

  611. *
    612. 

  612. *  E       (output) DOUBLE PRECISION array, dimension (min(M,N)-1)
    613. 

  613. *          The superdiagonal elements of the bidiagonal matrix B.
    614. 

  614. *
    615. 

  615. *  Q       (output) DOUBLE PRECISION array, dimension (LDQ,M)
    616. 

  616. *          If VECT = 'Q' or 'B', the m-by-m orthogonal matrix Q.
    617. 

  617. *          If VECT = 'N' or 'P', the array Q is not referenced.
    618. 

  618. *
    619. 

  619. *  LDQ     (input) INTEGER
    620. 

  620. *          The leading dimension of the array Q.
    621. 

  621. *          LDQ >= max(1,M) if VECT = 'Q' or 'B'; LDQ >= 1 otherwise.
    622. 

  622. *
    623. 

  623. *  PT      (output) DOUBLE PRECISION array, dimension (LDPT,N)
    624. 

  624. *          If VECT = 'P' or 'B', the n-by-n orthogonal matrix P'.
    625. 

  625. *          If VECT = 'N' or 'Q', the array PT is not referenced.
    626. 

  626. *
    627. 

  627. *  LDPT    (input) INTEGER
    628. 

  628. *          The leading dimension of the array PT.
    629. 

  629. *          LDPT >= max(1,N) if VECT = 'P' or 'B'; LDPT >= 1 otherwise.
    630. 

  630. *
    631. 

  631. *  C       (input/output) DOUBLE PRECISION array, dimension (LDC,NCC)
    632. 

  632. *          On entry, an m-by-ncc matrix C.
    633. 

  633. *          On exit, C is overwritten by Q'*C.
    634. 

  634. *          C is not referenced if NCC = 0.
    635. 

  635. *
    636. 

  636. *  LDC     (input) INTEGER
    637. 

  637. *          The leading dimension of the array C.
    638. 

  638. *          LDC >= max(1,M) if NCC > 0; LDC >= 1 if NCC = 0.
    639. 

  639. *
    640. 

  640. *  WORK    (workspace) DOUBLE PRECISION array, dimension (2*max(M,N))
    641. 

  641. *
    642. 

  642. *  C++ Return value: INFO    (output) INTEGER
    643. 

  643. *          = 0:  successful exit.
    644. 

  644. *          < 0:  if INFO = -i, the i-th argument had an illegal value.
    645. 

  645. *
    646. 

  646. *  =====================================================================
    647. 

  647. *
    648. 

  648. *     .. Parameters ..
    649. 

  649. **/
    650. 

  650. int C_DGBBRD(char vect, int m, int n, int ncc, int kl, int ku, double* ab, int ldab, double* d, double* e, double* q, int ldq, double* pt, int ldpt, double* c, int ldc, double* work)
    651. 

  651. {
    652. 

  652.     int info;
    653. 

  653.     ::F_DGBBRD(&vect, &m, &n, &ncc, &kl, &ku, ab, &ldab, d, e, q, &ldq, pt, &ldpt, c, &ldc, work, &info);
    654. 

  654.     return info;
    655. 

  655. }
    656. 

  656. 

  657. /**
    658. 

  658. *  Purpose
    659. 

  659. *  =======
    660. 

  660. *
    661. 

  661. *  DGBCON estimates the reciprocal of the condition number of a real
    662. 

  662. *  general band matrix A, in either the 1-norm or the infinity-norm,
    663. 

  663. *  using the LU factorization computed by DGBTRF.
    664. 

  664. *
    665. 

  665. *  An estimate is obtained for norm(inv(A)), and the reciprocal of the
    666. 

  666. *  condition number is computed as
    667. 

  667. *     RCOND = 1 / ( norm(A) * norm(inv(A)) ).
    668. 

  668. *
    669. 

  669. *  Arguments
    670. 

  670. *  =========
    671. 

  671. *
    672. 

  672. *  NORM    (input) CHARACTER*1
    673. 

  673. *          Specifies whether the 1-norm condition number or the
    674. 

  674. *          infinity-norm condition number is required:
    675. 

  675. *          = '1' or 'O':  1-norm;
    676. 

  676. *          = 'I':         Infinity-norm.
    677. 

  677. *
    678. 

  678. *  N       (input) INTEGER
    679. 

  679. *          The order of the matrix A.  N >= 0.
    680. 

  680. *
    681. 

  681. *  KL      (input) INTEGER
    682. 

  682. *          The number of subdiagonals within the band of A.  KL >= 0.
    683. 

  683. *
    684. 

  684. *  KU      (input) INTEGER
    685. 

  685. *          The number of superdiagonals within the band of A.  KU >= 0.
    686. 

  686. *
    687. 

  687. *  AB      (input) DOUBLE PRECISION array, dimension (LDAB,N)
    688. 

  688. *          Details of the LU factorization of the band matrix A, as
    689. 

  689. *          computed by DGBTRF.  U is stored as an upper triangular band
    690. 

  690. *          matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and
    691. 

  691. *          the multipliers used during the factorization are stored in
    692. 

  692. *          rows KL+KU+2 to 2*KL+KU+1.
    693. 

  693. *
    694. 

  694. *  LDAB    (input) INTEGER
    695. 

  695. *          The leading dimension of the array AB.  LDAB >= 2*KL+KU+1.
    696. 

  696. *
    697. 

  697. *  IPIV    (input) INTEGER array, dimension (N)
    698. 

  698. *          The pivot indices; for 1 <= i <= N, row i of the matrix was
    699. 

  699. *          interchanged with row IPIV(i).
    700. 

  700. *
    701. 

  701. *  ANORM   (input) DOUBLE PRECISION
    702. 

  702. *          If NORM = '1' or 'O', the 1-norm of the original matrix A.
    703. 

  703. *          If NORM = 'I', the infinity-norm of the original matrix A.
    704. 

  704. *
    705. 

  705. *  RCOND   (output) DOUBLE PRECISION
    706. 

  706. *          The reciprocal of the condition number of the matrix A,
    707. 

  707. *          computed as RCOND = 1/(norm(A) * norm(inv(A))).
    708. 

  708. *
    709. 

  709. *  WORK    (workspace) DOUBLE PRECISION array, dimension (3*N)
    710. 

  710. *
    711. 

  711. *  IWORK   (workspace) INTEGER array, dimension (N)
    712. 

  712. *
    713. 

  713. *  C++ Return value: INFO    (output) INTEGER
    714. 

  714. *          = 0:  successful exit
    715. 

  715. *          < 0: if INFO = -i, the i-th argument had an illegal value
    716. 

  716. *
    717. 

  717. *  =====================================================================
    718. 

  718. *
    719. 

  719. *     .. Parameters ..
    720. 

  720. **/
    721. 

  721. int C_DGBCON(char norm, int n, int kl, int ku, double* ab, int ldab, int* ipiv, double anorm, double* rcond, double* work, int* iwork)
    722. 

  722. {
    723. 

  723.     int info;
    724. 

  724.     ::F_DGBCON(&norm, &n, &kl, &ku, ab, &ldab, ipiv, &anorm, rcond, work, iwork, &info);
    725. 

  725.     return info;
    726. 

  726. }
    727. 

  727. 

  728. /**
    729. 

  729. *  Purpose
    730. 

  730. *  =======
    731. 

  731. *
    732. 

  732. *  DGBEQU computes row and column scalings intended to equilibrate an
    733. 

  733. *  M-by-N band matrix A and reduce its condition number.  R returns the
    734. 

  734. *  row scale factors and C the column scale factors, chosen to try to
    735. 

  735. *  make the largest element in each row and column of the matrix B with
    736. 

  736. *  elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.
    737. 

  737. *
    738. 

  738. *  R(i) and C(j) are restricted to be between SMLNUM = smallest safe
    739. 

  739. *  number and BIGNUM = largest safe number.  Use of these scaling
    740. 

  740. *  factors is not guaranteed to reduce the condition number of A but
    741. 

  741. *  works well in practice.
    742. 

  742. *
    743. 

  743. *  Arguments
    744. 

  744. *  =========
    745. 

  745. *
    746. 

  746. *  M       (input) INTEGER
    747. 

  747. *          The number of rows of the matrix A.  M >= 0.
    748. 

  748. *
    749. 

  749. *  N       (input) INTEGER
    750. 

  750. *          The number of columns of the matrix A.  N >= 0.
    751. 

  751. *
    752. 

  752. *  KL      (input) INTEGER
    753. 

  753. *          The number of subdiagonals within the band of A.  KL >= 0.
    754. 

  754. *
    755. 

  755. *  KU      (input) INTEGER
    756. 

  756. *          The number of superdiagonals within the band of A.  KU >= 0.
    757. 

  757. *
    758. 

  758. *  AB      (input) DOUBLE PRECISION array, dimension (LDAB,N)
    759. 

  759. *          The band matrix A, stored in rows 1 to KL+KU+1.  The j-th
    760. 

  760. *          column of A is stored in the j-th column of the array AB as
    761. 

  761. *          follows:
    762. 

  762. *          AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl).
    763. 

  763. *
    764. 

  764. *  LDAB    (input) INTEGER
    765. 

  765. *          The leading dimension of the array AB.  LDAB >= KL+KU+1.
    766. 

  766. *
    767. 

  767. *  R       (output) DOUBLE PRECISION array, dimension (M)
    768. 

  768. *          If INFO = 0, or INFO > M, R contains the row scale factors
    769. 

  769. *          for A.
    770. 

  770. *
    771. 

  771. *  C       (output) DOUBLE PRECISION array, dimension (N)
    772. 

  772. *          If INFO = 0, C contains the column scale factors for A.
    773. 

  773. *
    774. 

  774. *  ROWCND  (output) DOUBLE PRECISION
    775. 

  775. *          If INFO = 0 or INFO > M, ROWCND contains the ratio of the
    776. 

  776. *          smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and
    777. 

  777. *          AMAX is neither too large nor too small, it is not worth
    778. 

  778. *          scaling by R.
    779. 

  779. *
    780. 

  780. *  COLCND  (output) DOUBLE PRECISION
    781. 

  781. *          If INFO = 0, COLCND contains the ratio of the smallest
    782. 

  782. *          C(i) to the largest C(i).  If COLCND >= 0.1, it is not
    783. 

  783. *          worth scaling by C.
    784. 

  784. *
    785. 

  785. *  AMAX    (output) DOUBLE PRECISION
    786. 

  786. *          Absolute value of largest matrix element.  If AMAX is very
    787. 

  787. *          close to overflow or very close to underflow, the matrix
    788. 

  788. *          should be scaled.
    789. 

  789. *
    790. 

  790. *  C++ Return value: INFO    (output) INTEGER
    791. 

  791. *          = 0:  successful exit
    792. 

  792. *          < 0:  if INFO = -i, the i-th argument had an illegal value
    793. 

  793. *          > 0:  if INFO = i, and i is
    794. 

  794. *                <= M:  the i-th row of A is exactly zero
    795. 

  795. *                >  M:  the (i-M)-th column of A is exactly zero
    796. 

  796. *
    797. 

  797. *  =====================================================================
    798. 

  798. *
    799. 

  799. *     .. Parameters ..
    800. 

  800. **/
    801. 

  801. int C_DGBEQU(int m, int n, int kl, int ku, double* ab, int ldab, double* r, double* c, double* rowcnd, double* colcnd, double* amax)
    802. 

  802. {
    803. 

  803.     int info;
    804. 

  804.     ::F_DGBEQU(&m, &n, &kl, &ku, ab, &ldab, r, c, rowcnd, colcnd, amax, &info);
    805. 

  805.     return info;
    806. 

  806. }
    807. 

  807. 

  808. /**
    809. 

  809. *  Purpose
    810. 

  810. *  =======
    811. 

  811. *
    812. 

  812. *  DGBRFS improves the computed solution to a system of linear
    813. 

  813. *  equations when the coefficient matrix is banded, and provides
    814. 

  814. *  error bounds and backward error estimates for the solution.
    815. 

  815. *
    816. 

  816. *  Arguments
    817. 

  817. *  =========
    818. 

  818. *
    819. 

  819. *  TRANS   (input) CHARACTER*1
    820. 

  820. *          Specifies the form of the system of equations:
    821. 

  821. *          = 'N':  A * X = B     (No transpose)
    822. 

  822. *          = 'T':  A**T * X = B  (Transpose)
    823. 

  823. *          = 'C':  A**H * X = B  (Conjugate transpose = Transpose)
    824. 

  824. *
    825. 

  825. *  N       (input) INTEGER
    826. 

  826. *          The order of the matrix A.  N >= 0.
    827. 

  827. *
    828. 

  828. *  KL      (input) INTEGER
    829. 

  829. *          The number of subdiagonals within the band of A.  KL >= 0.
    830. 

  830. *
    831. 

  831. *  KU      (input) INTEGER
    832. 

  832. *          The number of superdiagonals within the band of A.  KU >= 0.
    833. 

  833. *
    834. 

  834. *  NRHS    (input) INTEGER
    835. 

  835. *          The number of right hand sides, i.e., the number of columns
    836. 

  836. *          of the matrices B and X.  NRHS >= 0.
    837. 

  837. *
    838. 

  838. *  AB      (input) DOUBLE PRECISION array, dimension (LDAB,N)
    839. 

  839. *          The original band matrix A, stored in rows 1 to KL+KU+1.
    840. 

  840. *          The j-th column of A is stored in the j-th column of the
    841. 

  841. *          array AB as follows:
    842. 

  842. *          AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl).
    843. 

  843. *
    844. 

  844. *  LDAB    (input) INTEGER
    845. 

  845. *          The leading dimension of the array AB.  LDAB >= KL+KU+1.
    846. 

  846. *
    847. 

  847. *  AFB     (input) DOUBLE PRECISION array, dimension (LDAFB,N)
    848. 

  848. *          Details of the LU factorization of the band matrix A, as
    849. 

  849. *          computed by DGBTRF.  U is stored as an upper triangular band
    850. 

  850. *          matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and
    851. 

  851. *          the multipliers used during the factorization are stored in
    852. 

  852. *          rows KL+KU+2 to 2*KL+KU+1.
    853. 

  853. *
    854. 

  854. *  LDAFB   (input) INTEGER
    855. 

  855. *          The leading dimension of the array AFB.  LDAFB >= 2*KL*KU+1.
    856. 

  856. *
    857. 

  857. *  IPIV    (input) INTEGER array, dimension (N)
    858. 

  858. *          The pivot indices from DGBTRF; for 1<=i<=N, row i of the
    859. 

  859. *          matrix was interchanged with row IPIV(i).
    860. 

  860. *
    861. 

  861. *  B       (input) DOUBLE PRECISION array, dimension (LDB,NRHS)
    862. 

  862. *          The right hand side matrix B.
    863. 

  863. *
    864. 

  864. *  LDB     (input) INTEGER
    865. 

  865. *          The leading dimension of the array B.  LDB >= max(1,N).
    866. 

  866. *
    867. 

  867. *  X       (input/output) DOUBLE PRECISION array, dimension (LDX,NRHS)
    868. 

  868. *          On entry, the solution matrix X, as computed by DGBTRS.
    869. 

  869. *          On exit, the improved solution matrix X.
    870. 

  870. *
    871. 

  871. *  LDX     (input) INTEGER
    872. 

  872. *          The leading dimension of the array X.  LDX >= max(1,N).
    873. 

  873. *
    874. 

  874. *  FERR    (output) DOUBLE PRECISION array, dimension (NRHS)
    875. 

  875. *          The estimated forward error bound for each solution vector
    876. 

  876. *          X(j) (the j-th column of the solution matrix X).
    877. 

  877. *          If XTRUE is the true solution corresponding to X(j), FERR(j)
    878. 

  878. *          is an estimated upper bound for the magnitude of the largest
    879. 

  879. *          element in (X(j) - XTRUE) divided by the magnitude of the
    880. 

  880. *          largest element in X(j).  The estimate is as reliable as
    881. 

  881. *          the estimate for RCOND, and is almost always a slight
    882. 

  882. *          overestimate of the true error.
    883. 

  883. *
    884. 

  884. *  BERR    (output) DOUBLE PRECISION array, dimension (NRHS)
    885. 

  885. *          The componentwise relative backward error of each solution
    886. 

  886. *          vector X(j) (i.e., the smallest relative change in
    887. 

  887. *          any element of A or B that makes X(j) an exact solution).
    888. 

  888. *
    889. 

  889. *  WORK    (workspace) DOUBLE PRECISION array, dimension (3*N)
    890. 

  890. *
    891. 

  891. *  IWORK   (workspace) INTEGER array, dimension (N)
    892. 

  892. *
    893. 

  893. *  C++ Return value: INFO    (output) INTEGER
    894. 

  894. *          = 0:  successful exit
    895. 

  895. *          < 0:  if INFO = -i, the i-th argument had an illegal value
    896. 

  896. *
    897. 

  897. *  Internal Parameters
    898. 

  898. *  ===================
    899. 

  899. *
    900. 

  900. *  ITMAX is the maximum number of steps of iterative refinement.
    901. 

  901. *
    902. 

  902. *  =====================================================================
    903. 

  903. *
    904. 

  904. *     .. Parameters ..
    905. 

  905. **/
    906. 

  906. int C_DGBRFS(char trans, int n, int kl, int ku, int nrhs, double* ab, int ldab, double* afb, int ldafb, int* ipiv, double* b, int ldb, double* x, int ldx, double* ferr, double* berr, double* work, int* iwork)
    907. 

  907. {
    908. 

  908.     int info;
    909. 

  909.     ::F_DGBRFS(&trans, &n, &kl, &ku, &nrhs, ab, &ldab, afb, &ldafb, ipiv, b, &ldb, x, &ldx, ferr, berr, work, iwork, &info);
    910. 

  910.     return info;
    911. 

  911. }
    912. 

  912. 

  913. /**
    914. 

  914. *  Purpose
    915. 

  915. *  =======
    916. 

  916. *
    917. 

  917. *  DGBSV computes the solution to a real system of linear equations
    918. 

  918. *  A * X = B, where A is a band matrix of order N with KL subdiagonals
    919. 

  919. *  and KU superdiagonals, and X and B are N-by-NRHS matrices.
    920. 

  920. *
    921. 

  921. *  The LU decomposition with partial pivoting and row interchanges is
    922. 

  922. *  used to factor A as A = L * U, where L is a product of permutation
    923. 

  923. *  and unit lower triangular matrices with KL subdiagonals, and U is
    924. 

  924. *  upper triangular with KL+KU superdiagonals.  The factored form of A
    925. 

  925. *  is then used to solve the system of equations A * X = B.
    926. 

  926. *
    927. 

  927. *  Arguments
    928. 

  928. *  =========
    929. 

  929. *
    930. 

  930. *  N       (input) INTEGER
    931. 

  931. *          The number of linear equations, i.e., the order of the
    932. 

  932. *          matrix A.  N >= 0.
    933. 

  933. *
    934. 

  934. *  KL      (input) INTEGER
    935. 

  935. *          The number of subdiagonals within the band of A.  KL >= 0.
    936. 

  936. *
    937. 

  937. *  KU      (input) INTEGER
    938. 

  938. *          The number of superdiagonals within the band of A.  KU >= 0.
    939. 

  939. *
    940. 

  940. *  NRHS    (input) INTEGER
    941. 

  941. *          The…
    942.

Large files files are truncated, but you can click here to view the full file