PageRenderTime 48ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 0ms

/src/bin/psi4/export_blas_lapack.cc

https://gitlab.com/y-shao/psi4public
C++ | 220 lines | 41 code | 5 blank | 174 comment | 0 complexity | af78d7038814ae4ed52b61dd983a4d0f MD5 | raw 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. #include <boost/python.hpp>
    24. 

  24. #include <libmints/psimath.h>
    25. 

  25. 

  26. using namespace boost::python;
    27. 

  27. 

  28. void export_blas_lapack()
    29. 

  29. {
    30. 

  30.     // BLAS Static Wrappers
    31. 

  31.     def("DGBMV", &psi::PSI_DGBMV, "docstring");
    32. 

  32.     def("DGEMM", &psi::PSI_DGEMM, "docstring");
    33. 

  33.     def("DGEMV", &psi::PSI_DGEMV, "docstring");
    34. 

  34.     def("DGER", &psi::PSI_DGER, "docstring");
    35. 

  35.     def("DSBMV", &psi::PSI_DSBMV, "docstring");
    36. 

  36.     def("DSYMM", &psi::PSI_DSYMM, "docstring");
    37. 

  37.     def("DSYMV", &psi::PSI_DSYMV, "docstring");
    38. 

  38.     def("DSYR", &psi::PSI_DSYR, "docstring");
    39. 

  39.     def("DSYR2", &psi::PSI_DSYR2, "docstring");
    40. 

  40.     def("DSYR2K", &psi::PSI_DSYR2K, "docstring");
    41. 

  41.     def("DSYRK", &psi::PSI_DSYRK, "docstring");
    42. 

  42.     def("DTBMV", &psi::PSI_DTBMV, "docstring");
    43. 

  43.     def("DTBSV", &psi::PSI_DTBSV, "docstring");
    44. 

  44.     def("DTRMM", &psi::PSI_DTRMM, "docstring");
    45. 

  45.     def("DTRMV", &psi::PSI_DTRMV, "docstring");
    46. 

  46.     def("DTRSM", &psi::PSI_DTRSM, "docstring");
    47. 

  47.     def("DTRSV", &psi::PSI_DTRSV, "docstring");
    48. 

  48.     def("DROT", &psi::PSI_DROT, "docstring");
    49. 

  49.     def("DSWAP", &psi::PSI_DSWAP, "docstring");
    50. 

  50.     def("DSCAL", &psi::PSI_DSCAL, "docstring");
    51. 

  51.     def("DAXPY", &psi::PSI_DAXPY, "docstring");
    52. 

  52.     def("DCOPY", &psi::PSI_DCOPY, "docstring");
    53. 

  53.     def("DDOT", &psi::PSI_DDOT, "docstring");
    54. 

  54.     def("DNRM2", &psi::PSI_DNRM2, "docstring");
    55. 

  55.     def("DASUM", &psi::PSI_DASUM, "docstring");
    56. 

  56.     def("IDAMAX", &psi::PSI_IDAMAX, "docstring");
    57. 

  57. 

  58.     // LAPACK static wrappers
    59. 

  59. 

  60.     def("DGEEV", &psi::PSI_DGEEV, "docstring");
    61. 

  61.     def("DSYEV", &psi::PSI_DSYEV, "docstring");
    62. 

  62.     def("DSYSV", &psi::PSI_DSYSV, "docstring");
    63. 

  63.     def("DGETRF", &psi::PSI_DGETRF, "docstring");
    64. 

  64.     def("DGETRS", &psi::PSI_DGETRS, "docstring");
    65. 

  65.     def("DGETRI", &psi::PSI_DGETRI, "docstring");
    66. 

  66.     def("DPOTRF", &psi::PSI_DPOTRF, "docstring");
    67. 

  67.     def("DPOTRS", &psi::PSI_DPOTRS, "docstring");
    68. 

  68.     def("DPOTRI", &psi::PSI_DPOTRI, "docstring");
    69. 

  69.     /**
    70. 

  70.     def("DBDSDC", &psi::PSI_DBDSDC);
    71. 

  71.     def("DBDSQR", &psi::PSI_DBDSQR);
    72. 

  72.     def("DDISNA", &psi::PSI_DDISNA);
    73. 

  73.     def("DGBBRD", &psi::PSI_DGBBRD);
    74. 

  74.     def("DGBCON", &psi::PSI_DGBCON);
    75. 

  75.     def("DGBEQU", &psi::PSI_DGBEQU);
    76. 

  76.     def("DGBRFS", &psi::PSI_DGBRFS);
    77. 

  77.     def("DGBSV", &psi::PSI_DGBSV);
    78. 

  78.     def("DGBSVX", &psi::PSI_DGBSVX);
    79. 

  79.     def("DGBTRF", &psi::PSI_DGBTRF);
    80. 

  80.     def("DGBTRS", &psi::PSI_DGBTRS);
    81. 

  81.     def("DGEBAK", &psi::PSI_DGEBAK);
    82. 

  82.     def("DGEBAL", &psi::PSI_DGEBAL);
    83. 

  83.     def("DGEBRD", &psi::PSI_DGEBRD);
    84. 

  84.     def("DGECON", &psi::PSI_DGECON);
    85. 

  85.     def("DGEEQU", &psi::PSI_DGEEQU);
    86. 

  86.     def("DGEES", &psi::PSI_DGEES);
    87. 

  87.     def("DGEESX", &psi::PSI_DGEESX);
    88. 

  88.     def("DGEEVX", &psi::PSI_DGEEVX);
    89. 

  89.     def("DGEGS", &psi::PSI_DGEGS);
    90. 

  90.     def("DGEGV", &psi::PSI_DGEGV);
    91. 

  91.     def("DGEHRD", &psi::PSI_DGEHRD);
    92. 

  92.     def("DGELQF", &psi::PSI_DGELQF);
    93. 

  93.     def("DGELS", &psi::PSI_DGELS);
    94. 

  94.     def("DGELSD", &psi::PSI_DGELSD);
    95. 

  95.     def("DGELSS", &psi::PSI_DGELSS);
    96. 

  96.     def("DGELSX", &psi::PSI_DGELSX);
    97. 

  97.     def("DGELSY", &psi::PSI_DGELSY);
    98. 

  98.     def("DGEQLF", &psi::PSI_DGEQLF);
    99. 

  99.     def("DGEQP3", &psi::PSI_DGEQP3);
    100. 

  100.     def("DGEQPF", &psi::PSI_DGEQPF);
    101. 

  101.     def("DGERFS", &psi::PSI_DGERFS);
    102. 

  102.     def("DGERQF", &psi::PSI_DGERQF);
    103. 

  103.     def("DGESDD", &psi::PSI_DGESDD);
    104. 

  104.     def("DGESV", &psi::PSI_DGESV);
    105. 

  105.     def("DGESVX", &psi::PSI_DGESVX);
    106. 

  106.     def("DGETRF", &psi::PSI_DGETRF);
    107. 

  107.     def("DGETRI", &psi::PSI_DGETRI);
    108. 

  108.     def("DGETRS", &psi::PSI_DGETRS);
    109. 

  109.     def("DGGBAK", &psi::PSI_DGGBAK);
    110. 

  110.     def("DGGBAL", &psi::PSI_DGGBAL);
    111. 

  111.     def("DGGES", &psi::PSI_DGGES);
    112. 

  112.     def("DGGESX", &psi::PSI_DGGESX);
    113. 

  113.     def("DGGEV", &psi::PSI_DGGEV);
    114. 

  114.     def("DGGEVX", &psi::PSI_DGGEVX);
    115. 

  115.     def("DGGGLM", &psi::PSI_DGGGLM);
    116. 

  116.     def("DGGHRD", &psi::PSI_DGGHRD);
    117. 

  117.     def("DGGLSE", &psi::PSI_DGGLSE);
    118. 

  118.     def("DGGQRF", &psi::PSI_DGGQRF);
    119. 

  119.     def("DGGRQF", &psi::PSI_DGGRQF);
    120. 

  120.     def("DGGSVD", &psi::PSI_DGGSVD);
    121. 

  121.     def("DGGSVP", &psi::PSI_DGGSVP);
    122. 

  122.     def("DGTCON", &psi::PSI_DGTCON);
    123. 

  123.     def("DGTRFS", &psi::PSI_DGTRFS);
    124. 

  124.     def("DGTSV", &psi::PSI_DGTSV);
    125. 

  125.     def("DGTSVX", &psi::PSI_DGTSVX);
    126. 

  126.     def("DGTTRF", &psi::PSI_DGTTRF);
    127. 

  127.     def("DGTTRS", &psi::PSI_DGTTRS);
    128. 

  128.     def("DHGEQZ", &psi::PSI_DHGEQZ);
    129. 

  129.     def("DHSEIN", &psi::PSI_DHSEIN);
    130. 

  130.     def("DHSEQR", &psi::PSI_DHSEQR);
    131. 

  131.     def("DORGBR", &psi::PSI_DORGBR);
    132. 

  132.     def("DORGHR", &psi::PSI_DORGHR);
    133. 

  133.     def("DORGLQ", &psi::PSI_DORGLQ);
    134. 

  134.     def("DORGQL", &psi::PSI_DORGQL);
    135. 

  135.     def("DORGQR", &psi::PSI_DORGQR);
    136. 

  136.     def("DORGRQ", &psi::PSI_DORGRQ);
    137. 

  137.     def("DORGTR", &psi::PSI_DORGTR);
    138. 

  138.     def("DORMBR", &psi::PSI_DORMBR);
    139. 

  139.     def("DORMHR", &psi::PSI_DORMHR);
    140. 

  140.     def("DORMLQ", &psi::PSI_DORMLQ);
    141. 

  141.     def("DORMQL", &psi::PSI_DORMQL);
    142. 

  142.     def("DORMQR", &psi::PSI_DORMQR);
    143. 

  143.     def("DORMR3", &psi::PSI_DORMR3);
    144. 

  144.     def("DORMRQ", &psi::PSI_DORMRQ);
    145. 

  145.     def("DORMRZ", &psi::PSI_DORMRZ);
    146. 

  146.     def("DORMTR", &psi::PSI_DORMTR);
    147. 

  147.     def("DPBCON", &psi::PSI_DPBCON);
    148. 

  148.     def("DPBEQU", &psi::PSI_DPBEQU);
    149. 

  149.     def("DPBRFS", &psi::PSI_DPBRFS);
    150. 

  150.     def("DPBSTF", &psi::PSI_DPBSTF);
    151. 

  151.     def("DPBSV", &psi::PSI_DPBSV);
    152. 

  152.     def("DPBSVX", &psi::PSI_DPBSVX);
    153. 

  153.     def("DPBTRF", &psi::PSI_DPBTRF);
    154. 

  154.     def("DPBTRS", &psi::PSI_DPBTRS);
    155. 

  155.     def("DPOCON", &psi::PSI_DPOCON);
    156. 

  156.     def("DPOEQU", &psi::PSI_DPOEQU);
    157. 

  157.     def("DPORFS", &psi::PSI_DPORFS);
    158. 

  158.     def("DPOSV", &psi::PSI_DPOSV);
    159. 

  159.     def("DPOSVX", &psi::PSI_DPOSVX);
    160. 

  160.     def("DPOTRF", &psi::PSI_DPOTRF);
    161. 

  161.     def("DPOTRI", &psi::PSI_DPOTRI);
    162. 

  162.     def("DPOTRS", &psi::PSI_DPOTRS);
    163. 

  163.     def("DPTCON", &psi::PSI_DPTCON);
    164. 

  164.     def("DPTEQR", &psi::PSI_DPTEQR);
    165. 

  165.     def("DPTRFS", &psi::PSI_DPTRFS);
    166. 

  166.     def("DPTSV", &psi::PSI_DPTSV);
    167. 

  167.     def("DPTSVX", &psi::PSI_DPTSVX);
    168. 

  168.     def("DPTTRF", &psi::PSI_DPTTRF);
    169. 

  169.     def("DPTTRS", &psi::PSI_DPTTRS);
    170. 

  170.     def("DSBEV", &psi::PSI_DSBEV);
    171. 

  171.     def("DSBEVD", &psi::PSI_DSBEVD);
    172. 

  172.     def("DSBEVX", &psi::PSI_DSBEVX);
    173. 

  173.     def("DSBGST", &psi::PSI_DSBGST);
    174. 

  174.     def("DSBGV", &psi::PSI_DSBGV);
    175. 

  175.     def("DSBGVD", &psi::PSI_DSBGVD);
    176. 

  176.     def("DSBGVX", &psi::PSI_DSBGVX);
    177. 

  177.     def("DSBTRD", &psi::PSI_DSBTRD);
    178. 

  178.     def("DSGESV", &psi::PSI_DSGESV);
    179. 

  179.     def("DSTEBZ", &psi::PSI_DSTEBZ);
    180. 

  180.     def("DSTEDC", &psi::PSI_DSTEDC);
    181. 

  181.     def("DSTEGR", &psi::PSI_DSTEGR);
    182. 

  182.     def("DSTEIN", &psi::PSI_DSTEIN);
    183. 

  183.     def("DSTEQR", &psi::PSI_DSTEQR);
    184. 

  184.     def("DSTERF", &psi::PSI_DSTERF);
    185. 

  185.     def("DSTEV", &psi::PSI_DSTEV);
    186. 

  186.     def("DSTEVD", &psi::PSI_DSTEVD);
    187. 

  187.     def("DSTEVR", &psi::PSI_DSTEVR);
    188. 

  188.     def("DSTEVX", &psi::PSI_DSTEVX);
    189. 

  189.     def("DSYCON", &psi::PSI_DSYCON);
    190. 

  190.     def("DSYGST", &psi::PSI_DSYGST);
    191. 

  191.     def("DSYGV", &psi::PSI_DSYGV);
    192. 

  192.     def("DSYGVD", &psi::PSI_DSYGVD);
    193. 

  193.     def("DSYGVX", &psi::PSI_DSYGVX);
    194. 

  194.     def("DSYRFS", &psi::PSI_DSYRFS);
    195. 

  195.     def("DSYTRD", &psi::PSI_DSYTRD);
    196. 

  196.     def("DSYTRF", &psi::PSI_DSYTRF);
    197. 

  197.     def("DSYTRI", &psi::PSI_DSYTRI);
    198. 

  198.     def("DSYTRS", &psi::PSI_DSYTRS);
    199. 

  199.     def("DTBCON", &psi::PSI_DTBCON);
    200. 

  200.     def("DTBRFS", &psi::PSI_DTBRFS);
    201. 

  201.     def("DTBTRS", &psi::PSI_DTBTRS);
    202. 

  202.     def("DTGEVC", &psi::PSI_DTGEVC);
    203. 

  203.     def("DTGEXC", &psi::PSI_DTGEXC);
    204. 

  204.     def("DTGSEN", &psi::PSI_DTGSEN);
    205. 

  205.     def("DTGSJA", &psi::PSI_DTGSJA);
    206. 

  206.     def("DTGSNA", &psi::PSI_DTGSNA);
    207. 

  207.     def("DTGSYL", &psi::PSI_DTGSYL);
    208. 

  208.     def("DTRCON", &psi::PSI_DTRCON);
    209. 

  209.     def("DTREVC", &psi::PSI_DTREVC);
    210. 

  210.     def("DTREXC", &psi::PSI_DTREXC);
    211. 

  211.     def("DTRRFS", &psi::PSI_DTRRFS);
    212. 

  212.     def("DTRSEN", &psi::PSI_DTRSEN);
    213. 

  213.     def("DTRSNA", &psi::PSI_DTRSNA);
    214. 

  214.     def("DTRSYL", &psi::PSI_DTRSYL);
    215. 

  215.     def("DTRTRI", &psi::PSI_DTRTRI);
    216. 

  216.     def("DTRTRS", &psi::PSI_DTRTRS);
    217. 

  217.     def("DTZRQF", &psi::PSI_DTZRQF);
    218. 

  218.     def("DTZRZF", &psi::PSI_DTZRZF);
    219. 

  219.     **/
    220. 

  220. }
    221. 

  221.