1!--------------------------------------------------------------------------------------------------! 2! DFTB+: general package for performing fast atomistic simulations ! 3! Copyright (C) 2006 - 2019 DFTB+ developers group ! 4! ! 5! See the LICENSE file for terms of usage and distribution. ! 6!--------------------------------------------------------------------------------------------------! 7 8!> Interface wrapper for the blas routines. 9!> 10!> ALL BLAS routines which are called from the main code must be included here. 11module dftbp_blas 12 use dftbp_accuracy, only : rsp, rdp 13 public 14 15 interface 16 17 18 !> performs the symmetric rank 1 operation 19 !> A := alpha*x*x**T + A 20 subroutine ssyr(uplo, nn, alpha, xx, incx, aa, lda) 21 import rsp 22 23 !> Upper 'U' or lower 'L' triangle 24 character, intent(in) :: uplo 25 26 !> matrix size 27 integer, intent(in) :: nn 28 29 !> scaling factor 30 real(rsp), intent(in) :: alpha 31 32 !> vector 33 real(rsp), intent(in) :: xx(*) 34 35 !> stride 36 integer, intent(in) :: incx 37 38 !> leading matrix dimension 39 integer, intent(in) :: lda 40 41 !> matrix A 42 real(rsp), intent(inout) :: aa(lda, *) 43 end subroutine ssyr 44 45 46 !> performs the symmetric rank 1 operation 47 !> A := alpha*x*x**T + A 48 subroutine dsyr(uplo, nn, alpha, xx, incx, aa, lda) 49 import rdp 50 51 !> Upper 'U' or lower 'L' triangle 52 character, intent(in) :: uplo 53 54 !> matrix size 55 integer, intent(in) :: nn 56 57 !> scale factor 58 real(rdp), intent(in) :: alpha 59 60 !> vector 61 real(rdp), intent(in) :: xx(*) 62 63 !> stride 64 integer, intent(in) :: incx 65 66 !> leading matrix dimension 67 integer, intent(in) :: lda 68 69 !> matrix A 70 real(rdp), intent(inout) :: aa(lda, *) 71 end subroutine dsyr 72 73 74 !> performs the hermitian rank 1 operation 75 !> A := alpha*x*x**H + A, 76 subroutine cher(uplo, nn, alpha, xx, incx, aa, lda) 77 import rsp 78 79 !> Upper 'U' or lower 'L' triangle 80 character, intent(in) :: uplo 81 82 !> matrix size 83 integer, intent(in) :: nn 84 85 !> scaling factor 86 real(rsp), intent(in) :: alpha 87 88 !> vector 89 complex(rsp), intent(in) :: xx(*) 90 91 !> stride 92 integer, intent(in) :: incx 93 94 !> leading matrix dimension 95 integer, intent(in) :: lda 96 97 !> matrix A 98 complex(rsp), intent(inout) :: aa(lda, *) 99 end subroutine cher 100 101 102 !> performs the hermitian rank 1 operation 103 !> A := alpha*x*x**H + A, 104 subroutine zher(uplo, nn, alpha, xx, incx, aa, lda) 105 import rdp 106 107 !> Upper 'U' or lower 'L' triangle 108 character, intent(in) :: uplo 109 110 !> matrix size 111 integer, intent(in) :: nn 112 113 !> scale factor 114 real(rdp), intent(in) :: alpha 115 116 !> vector 117 complex(rdp), intent(in) :: xx(*) 118 119 !> stride 120 integer, intent(in) :: incx 121 122 !> leading matrix dimension 123 integer, intent(in) :: lda 124 125 !> matrix A 126 complex(rdp), intent(inout) :: aa(lda, *) 127 end subroutine zher 128 129 130 !> performs the rank 1 operation 131 !> A := alpha*x*y**T + A, 132 subroutine sger(mm, nn, alpha, xx, incx, yy, incy, aa, lda) 133 import rsp 134 135 !> matrix sizing 136 integer, intent(in) :: mm 137 138 !> matrix size 139 integer, intent(in) :: nn 140 141 !> scaling factor 142 real(rsp), intent(in) :: alpha 143 144 !> vector 145 real(rsp), intent(in) :: xx(*) 146 147 !> stride 148 integer, intent(in) :: incx 149 150 !> vector 151 real(rsp), intent(in) :: yy(*) 152 153 !> stride 154 integer, intent(in) :: incy 155 156 !> leading matrix dimension 157 integer, intent(in) :: lda 158 159 !> matrix A 160 real(rsp), intent(inout) :: aa(lda, *) 161 end subroutine sger 162 163 164 !> performs the rank 1 operation 165 !> A := alpha*x*y**T + A, 166 subroutine dger(mm, nn, alpha, xx, incx, yy, incy, aa, lda) 167 import rdp 168 169 !> matrix sizing 170 integer, intent(in) :: mm 171 172 !> matrix size 173 integer, intent(in) :: nn 174 175 !> scale factor 176 real(rdp), intent(in) :: alpha 177 178 !> vector 179 real(rdp), intent(in) :: xx(*) 180 181 !> stride 182 integer, intent(in) :: incx 183 184 !> vector 185 real(rdp), intent(in) :: yy(*) 186 187 !> stride 188 integer, intent(in) :: incy 189 190 !> leading matrix dimension 191 integer, intent(in) :: lda 192 193 !> matrix A 194 real(rdp), intent(inout) :: aa(lda, *) 195 end subroutine dger 196 197 198 !> performs the rank 1 operation 199 !> A := alpha*x*y**H + A, 200 subroutine cgerc(mm, nn, alpha, xx, incx, yy, incy, aa, lda) 201 import rsp 202 203 !> matrix sizing 204 integer, intent(in) :: mm 205 206 !> matrix size 207 integer, intent(in) :: nn 208 209 !> scale factor 210 complex(rsp), intent(in) :: alpha 211 212 !> vector 213 complex(rsp), intent(in) :: xx(*) 214 215 !> stride 216 integer, intent(in) :: incx 217 218 !> vector 219 complex(rsp), intent(in) :: yy(*) 220 221 !> stride 222 integer, intent(in) :: incy 223 224 !> leading matrix dimension 225 integer, intent(in) :: lda 226 227 !> matrix A 228 complex(rsp), intent(inout) :: aa(lda, *) 229 end subroutine cgerc 230 231 232 !> performs the rank 1 operation 233 !> A := alpha*x*y**H + A, 234 subroutine zgerc(mm, nn, alpha, xx, incx, yy, incy, aa, lda) 235 import rdp 236 237 !> matrix sizing 238 integer, intent(in) :: mm 239 240 !> matrix size 241 integer, intent(in) :: nn 242 243 !> scale factor 244 complex(rdp), intent(in) :: alpha 245 246 !> vector 247 complex(rdp), intent(in) :: xx(*) 248 249 !> stride 250 integer, intent(in) :: incx 251 252 !> vector 253 complex(rdp), intent(in) :: yy(*) 254 255 !> stride 256 integer, intent(in) :: incy 257 258 !> leading matrix dimension 259 integer, intent(in) :: lda 260 261 !> matrix A 262 complex(rdp), intent(inout) :: aa(lda, *) 263 end subroutine zgerc 264 265 266 !> performs the matrix-vector operation 267 !> y := alpha*A*x + beta*y 268 subroutine ssymv(uplo, nn, alpha, aa, lda, xx, incx, beta, yy, incy) 269 import rsp 270 271 !> Upper 'U' or lower 'L' triangle 272 character, intent(in) :: uplo 273 274 !> matrix size 275 integer, intent(in) :: nn 276 277 !> scaling factor 278 real(rsp), intent(in) :: alpha 279 280 !> leading matrix dimension 281 integer, intent(in) :: lda 282 283 !> matrix A 284 real(rsp), intent(in) :: aa(lda, *) 285 286 !> vector 287 real(rsp), intent(in) :: xx(*) 288 289 !> stride 290 integer, intent(in) :: incx 291 292 !> scale factor 293 real(rsp), intent(in) :: beta 294 295 !> vector 296 real(rsp), intent(inout) :: yy(*) 297 298 !> stride 299 integer, intent(in) :: incy 300 end subroutine ssymv 301 302 303 !> performs the matrix-vector operation 304 !> y := alpha*A*x + beta*y 305 subroutine dsymv(uplo, nn, alpha, aa, lda, xx, incx, beta, yy, incy) 306 import rdp 307 308 !> Upper 'U' or lower 'L' triangle 309 character, intent(in) :: uplo 310 311 !> matrix size 312 integer, intent(in) :: nn 313 314 !> scale factor 315 real(rdp), intent(in) :: alpha 316 317 !> leading matrix dimension 318 integer, intent(in) :: lda 319 320 !> matrix A 321 real(rdp), intent(in) :: aa(lda, *) 322 323 !> vector 324 real(rdp), intent(in) :: xx(*) 325 326 !> stride 327 integer, intent(in) :: incx 328 329 !> scaling factor 330 real(rdp), intent(in) :: beta 331 332 !> vector 333 real(rdp), intent(inout) :: yy(*) 334 335 !> stride 336 integer, intent(in) :: incy 337 end subroutine dsymv 338 339 340 !> performs the matrix-vector operation 341 !> y := alpha*A*x + beta*y 342 subroutine chemv(uplo, nn, alpha, aa, lda, xx, incx, beta, yy, incy) 343 import rsp 344 345 !> Upper 'U' or lower 'L' triangle 346 character, intent(in) :: uplo 347 348 !> matrix size 349 integer, intent(in) :: nn 350 351 !> scale factor 352 complex(rsp), intent(in) :: alpha 353 354 !> leading matrix dimension 355 integer, intent(in) :: lda 356 357 !> matrix A 358 complex(rsp), intent(in) :: aa(lda, *) 359 360 !> vector 361 complex(rsp), intent(in) :: xx(*) 362 363 !> stride 364 integer, intent(in) :: incx 365 366 !> scaling factor 367 complex(rsp), intent(in) :: beta 368 369 !> vector 370 complex(rsp), intent(inout) :: yy(*) 371 372 !> stride 373 integer, intent(in) :: incy 374 end subroutine chemv 375 376 377 !> performs the matrix-vector operation 378 !> y := alpha*A*x + beta*y 379 subroutine zhemv(uplo, nn, alpha, aa, lda, xx, incx, beta, yy, incy) 380 import rdp 381 382 !> Upper 'U' or lower 'L' triangle 383 character, intent(in) :: uplo 384 385 !> matrix size 386 integer, intent(in) :: nn 387 388 !> scale factor 389 complex(rdp), intent(in) :: alpha 390 391 !> leading matrix dimension 392 integer, intent(in) :: lda 393 394 !> matrix A 395 complex(rdp), intent(in) :: aa(lda, *) 396 397 !> vector 398 complex(rdp), intent(in) :: xx(*) 399 400 !> stride 401 integer, intent(in) :: incx 402 403 !> scale factor 404 complex(rdp), intent(in) :: beta 405 406 !> vector 407 complex(rdp), intent(inout) :: yy(*) 408 409 !> stride 410 integer, intent(in) :: incy 411 end subroutine zhemv 412 413 414 !> performs one of the matrix-vector operations 415 !> y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, 416 subroutine sgemv(trans, mm, nn, alpha, aa, lda, xx, incx, beta, yy, incy) 417 import rsp 418 419 !> should transposition be used 420 character, intent(in) :: trans 421 422 !> matrix sizing 423 integer, intent(in) :: mm 424 425 !> matrix size 426 integer, intent(in) :: nn 427 428 !> scaling factor 429 real(rsp), intent(in) :: alpha 430 431 !> leading matrix dimension 432 integer, intent(in) :: lda 433 434 !> matrix A 435 real(rsp), intent(in) :: aa(lda, *) 436 437 !> vector 438 real(rsp), intent(in) :: xx(*) 439 440 !> stride 441 integer, intent(in) :: incx 442 443 !> scale factor 444 real(rsp), intent(in) :: beta 445 446 !> vector 447 real(rsp), intent(inout) :: yy(*) 448 449 !> stride 450 integer, intent(in) :: incy 451 end subroutine sgemv 452 453 454 !> performs one of the matrix-vector operations 455 !> y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, 456 subroutine dgemv(trans, mm, nn, alpha, aa, lda, xx, incx, beta, yy, incy) 457 import rdp 458 459 !> should transposition be used 460 character, intent(in) :: trans 461 462 !> matrix sizing 463 integer, intent(in) :: mm 464 465 !> matrix size 466 integer, intent(in) :: nn 467 468 !> scale factor 469 real(rdp), intent(in) :: alpha 470 471 !> leading matrix dimension 472 integer, intent(in) :: lda 473 474 !> matrix A 475 real(rdp), intent(in) :: aa(lda, *) 476 477 !> vector 478 real(rdp), intent(in) :: xx(*) 479 480 !> stride 481 integer, intent(in) :: incx 482 483 !> scaling factor 484 real(rdp), intent(in) :: beta 485 486 !> vector 487 real(rdp), intent(inout) :: yy(*) 488 489 !> stride 490 integer, intent(in) :: incy 491 end subroutine dgemv 492 493 494 !> performs the matrix-vector operation 495 !> y := alpha*A*x + beta*y, 496 subroutine ssbmv(uplo, nn, kk, alpha, aa, lda, xx, incx, beta, yy, incy) 497 import rsp 498 499 !> Upper 'U' or lower 'L' triangle 500 character, intent(in) :: uplo 501 502 !> matrix size 503 integer, intent(in) :: nn 504 505 !> number of superdiagonals 506 integer, intent(in) :: kk 507 508 !> scaling factor 509 real(rsp), intent(in) :: alpha 510 511 !> leading matrix dimension 512 integer, intent(in) :: lda 513 514 !> matrix A 515 real(rsp), intent(in) :: aa(lda, *) 516 517 !> vector 518 real(rsp), intent(in) :: xx(*) 519 520 !> stride 521 integer, intent(in) :: incx 522 523 !> scale factor 524 real(rsp), intent(in) :: beta 525 526 !> vector 527 real(rsp), intent(inout) :: yy(*) 528 529 !> stride 530 integer, intent(in) :: incy 531 end subroutine ssbmv 532 533 534 !> performs the matrix-vector operation 535 !> y := alpha*A*x + beta*y, 536 subroutine dsbmv(uplo, nn, kk, alpha, aa, lda, xx, incx, beta, yy, incy) 537 import rdp 538 539 !> Upper 'U' or lower 'L' triangle 540 character, intent(in) :: uplo 541 542 !> matrix size 543 integer, intent(in) :: nn 544 545 !> number of superdiagonals 546 integer, intent(in) :: kk 547 548 !> scale factor 549 real(rdp), intent(in) :: alpha 550 551 !> leading matrix dimension 552 integer, intent(in) :: lda 553 554 !> matrix A 555 real(rdp), intent(in) :: aa(lda, *) 556 557 !> vector 558 real(rdp), intent(in) :: xx(*) 559 560 !> stride 561 integer, intent(in) :: incx 562 563 !> scaling factor 564 real(rdp), intent(in) :: beta 565 566 !> vector 567 real(rdp), intent(inout) :: yy(*) 568 569 !> stride 570 integer, intent(in) :: incy 571 end subroutine dsbmv 572 573 574 !> performs one of the matrix-matrix operations 575 !> C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, 576 subroutine ssymm(side, uplo, mm, nn, alpha, aa, lda, bb, ldb, beta, cc, ldc) 577 import rsp 578 579 !> side of the product 580 character, intent(in) :: side 581 582 !> upper or lower matrix 583 character, intent(in) :: uplo 584 585 !> matrix sizing 586 integer, intent(in) :: mm 587 588 !> matrix size 589 integer, intent(in) :: nn 590 591 !> scaling factor 592 real(rsp), intent(in) :: alpha 593 594 !> leading matrix dimension 595 integer, intent(in) :: lda 596 597 !> matrix A 598 real(rsp), intent(in) :: aa(lda, *) 599 600 !> leading matrix dimension 601 integer, intent(in) :: ldb 602 603 !> matrix B 604 real(rsp), intent(in) :: bb(ldb, *) 605 606 !> scale factor 607 real(rsp), intent(in) :: beta 608 609 !> leading matrix dimension 610 integer, intent(in) :: ldc 611 612 !> matrix C 613 real(rsp), intent(inout) :: cc(ldc, *) 614 end subroutine ssymm 615 616 617 !> performs one of the matrix-matrix operations 618 !> C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, 619 subroutine dsymm(side, uplo, mm, nn, alpha, aa, lda, bb, ldb, beta, cc, ldc) 620 import rdp 621 622 !> side of the product 623 character, intent(in) :: side 624 625 !> upper or lower matrix 626 character, intent(in) :: uplo 627 628 !> matrix sizing 629 integer, intent(in) :: mm 630 631 !> matrix size 632 integer, intent(in) :: nn 633 634 !> scale factor 635 real(rdp), intent(in) :: alpha 636 637 !> leading matrix dimension 638 integer, intent(in) :: lda 639 640 !> matrix A 641 real(rdp), intent(in) :: aa(lda, *) 642 643 !> leading matrix dimension 644 integer, intent(in) :: ldb 645 646 !> matrix B 647 real(rdp), intent(in) :: bb(ldb, *) 648 649 !> scaling factor 650 real(rdp), intent(in) :: beta 651 652 !> leading matrix dimension 653 integer, intent(in) :: ldc 654 655 !> matrix C 656 real(rdp), intent(inout) :: cc(ldc, *) 657 end subroutine dsymm 658 659 660 !> performs one of the matrix-matrix operations 661 !> C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, 662 subroutine chemm(side, uplo, mm, nn, alpha, aa, lda, bb, ldb, beta, cc, ldc) 663 import rsp 664 665 !> side of the product 666 character, intent(in) :: side 667 668 !> upper or lower matrix 669 character, intent(in) :: uplo 670 671 !> matrix sizing 672 integer, intent(in) :: mm 673 674 !> matrix size 675 integer, intent(in) :: nn 676 677 !> scale factor 678 complex(rsp), intent(in) :: alpha 679 680 !> leading matrix dimension 681 integer, intent(in) :: lda 682 683 !> matrix A 684 complex(rsp), intent(in) :: aa(lda, *) 685 686 !> leading matrix dimension 687 integer, intent(in) :: ldb 688 689 !> matrix B 690 complex(rsp), intent(in) :: bb(ldb, *) 691 692 !> scaling factor 693 complex(rsp), intent(in) :: beta 694 695 !> leading matrix dimension 696 integer, intent(in) :: ldc 697 698 !> matrix C 699 complex(rsp), intent(inout) :: cc(ldc, *) 700 end subroutine chemm 701 702 703 !> performs one of the matrix-matrix operations 704 !> C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, 705 subroutine zhemm(side, uplo, mm, nn, alpha, aa, lda, bb, ldb, beta, cc, ldc) 706 import rdp 707 708 !> side of the product 709 character, intent(in) :: side 710 711 !> upper or lower matrix 712 character, intent(in) :: uplo 713 714 !> matrix sizing 715 integer, intent(in) :: mm 716 717 !> matrix size 718 integer, intent(in) :: nn 719 720 !> scale factor 721 complex(rdp), intent(in) :: alpha 722 723 !> leading matrix dimension 724 integer, intent(in) :: lda 725 726 !> matrix A 727 complex(rdp), intent(in) :: aa(lda, *) 728 729 !> leading matrix dimension 730 integer, intent(in) :: ldb 731 732 !> matrix B 733 complex(rdp), intent(in) :: bb(ldb, *) 734 735 !> scale factor 736 complex(rdp), intent(in) :: beta 737 738 !> leading matrix dimension 739 integer, intent(in) :: ldc 740 741 !> matrix C 742 complex(rdp), intent(inout) :: cc(ldc, *) 743 end subroutine zhemm 744 745 746 !> performs one of the matrix-matrix operations 747 !> C := alpha*op( A )*op( B ) + beta*C, where op( X ) is one of 748 !> op( X ) = X, or op( X ) = X**T 749 subroutine sgemm(transa, transb, mm, nn, kk, alpha, aa, lda, bb, ldb, beta,& 750 & cc, ldc) 751 import rsp 752 753 !> On entry, TRANSA specifies the form of op( A ) to be used 754 character, intent(in) :: transa 755 756 !> on entry specifies op(B) 757 !> should transposition be used 758 character, intent(in) :: transb 759 760 !> matrix sizing 761 integer, intent(in) :: mm 762 763 !> matrix size 764 integer, intent(in) :: nn 765 766 !> shared index size 767 integer, intent(in) :: kk 768 769 !> scaling factor 770 real(rsp), intent(in) :: alpha 771 772 !> leading matrix dimension 773 integer, intent(in) :: lda 774 775 !> matrix A 776 real(rsp), intent(in) :: aa(lda, *) 777 778 !> leading matrix dimension 779 integer, intent(in) :: ldb 780 781 !> matrix B 782 real(rsp), intent(in) :: bb(ldb, *) 783 784 !> scale factor 785 real(rsp), intent(in) :: beta 786 787 !> leading matrix dimension 788 integer, intent(in) :: ldc 789 790 !> matrix C 791 real(rsp), intent(inout) :: cc(ldc, *) 792 end subroutine sgemm 793 794 795 !> performs one of the matrix-matrix operations 796 !> C := alpha*op( A )*op( B ) + beta*C, where op( X ) is one of 797 !> op( X ) = X, or op( X ) = X**T 798 subroutine dgemm(transa, transb, mm, nn, kk, alpha, aa, lda, bb, ldb, beta,& 799 & cc, ldc) 800 import rdp 801 802 !> On entry, TRANSA specifies the form of op( A ) to be used 803 character, intent(in) :: transa 804 805 !> on entry specifies op(B) 806 !> should transposition be used 807 character, intent(in) :: transb 808 809 !> matrix sizing 810 integer, intent(in) :: mm 811 812 !> matrix size 813 integer, intent(in) :: nn 814 815 !> shared index size 816 integer, intent(in) :: kk 817 818 !> scale factor 819 real(rdp), intent(in) :: alpha 820 821 !> leading matrix dimension 822 integer, intent(in) :: lda 823 824 !> matrix A 825 real(rdp), intent(in) :: aa(lda, *) 826 827 !> leading matrix dimension 828 integer, intent(in) :: ldb 829 830 !> matrix B 831 real(rdp), intent(in) :: bb(ldb, *) 832 833 !> scaling factor 834 real(rdp), intent(in) :: beta 835 836 !> leading matrix dimension 837 integer, intent(in) :: ldc 838 839 !> matrix C 840 real(rdp), intent(inout) :: cc(ldc, *) 841 end subroutine dgemm 842 843 844 !> performs one of the matrix-matrix operations 845 !> C := alpha*op( A )*op( B ) + beta*C, where op( X ) is one of 846 !> op( X ) = X, op( X ) = X**T, or op( X ) = X**H 847 subroutine cgemm(transa, transb, mm, nn, kk, alpha, aa, lda, bb, ldb, beta,& 848 & cc, ldc) 849 import rsp 850 851 !> On entry, TRANSA specifies the form of op( A ) to be used 852 character, intent(in) :: transa 853 854 !> on entry specifies op(B) 855 !> should transposition be used 856 character, intent(in) :: transb 857 858 !> matrix sizing 859 integer, intent(in) :: mm 860 861 !> matrix size 862 integer, intent(in) :: nn 863 864 !> shared index size 865 integer, intent(in) :: kk 866 867 !> scale factor 868 complex(rsp), intent(in) :: alpha 869 870 !> leading matrix dimension 871 integer, intent(in) :: lda 872 873 !> matrix A 874 complex(rsp), intent(in) :: aa(lda, *) 875 876 !> leading matrix dimension 877 integer, intent(in) :: ldb 878 879 !> matrix B 880 complex(rsp), intent(in) :: bb(ldb, *) 881 882 !> scaling factor 883 complex(rsp), intent(in) :: beta 884 885 !> leading matrix dimension 886 integer, intent(in) :: ldc 887 888 !> matrix C 889 complex(rsp), intent(inout) :: cc(ldc, *) 890 end subroutine cgemm 891 892 893 !> performs one of the matrix-matrix operations 894 !> C := alpha*op( A )*op( B ) + beta*C, where op( X ) is one of 895 !> op( X ) = X, op( X ) = X**T, or op( X ) = X**H 896 subroutine zgemm(transa, transb, mm, nn, kk, alpha, aa, lda, bb, ldb, beta,& 897 & cc, ldc) 898 import rdp 899 900 !> On entry, TRANSA specifies the form of op( A ) to be used 901 character, intent(in) :: transa 902 903 !> on entry specifies op(B) 904 !> should transposition be used 905 character, intent(in) :: transb 906 907 !> matrix sizing 908 integer, intent(in) :: mm 909 910 !> matrix size 911 integer, intent(in) :: nn 912 913 !> shared index size 914 integer, intent(in) :: kk 915 916 !> scale factor 917 complex(rdp), intent(in) :: alpha 918 919 !> leading matrix dimension 920 integer, intent(in) :: lda 921 922 !> matrix A 923 complex(rdp), intent(in) :: aa(lda, *) 924 925 !> leading matrix dimension 926 integer, intent(in) :: ldb 927 928 !> matrix B 929 complex(rdp), intent(in) :: bb(ldb, *) 930 931 !> scale factor 932 complex(rdp), intent(in) :: beta 933 934 !> leading matrix dimension 935 integer, intent(in) :: ldc 936 937 !> matrix C 938 complex(rdp), intent(inout) :: cc(ldc, *) 939 end subroutine zgemm 940 941 942 !> performs one of the symmetric rank k operations 943 !> C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C 944 subroutine ssyrk(uplo, trans, nn, kk, alpha, aa, lda, beta, cc, ldc) 945 import rsp 946 947 !> Upper 'U' or lower 'L' triangle 948 character, intent(in) :: uplo 949 950 !> should transposition be used 951 character, intent(in) :: trans 952 953 !> matrix size 954 integer, intent(in) :: nn 955 956 !> rank 957 integer, intent(in) :: kk 958 959 !> scaling factor 960 real(rsp), intent(in) :: alpha 961 962 !> leading matrix dimension 963 integer, intent(in) :: lda 964 965 !> matrix A 966 real(rsp), intent(in) :: aa(lda, *) 967 968 !> scale factor 969 real(rsp), intent(in) :: beta 970 971 !> leading matrix dimension 972 integer, intent(in) :: ldc 973 974 !> matrix C 975 real(rsp), intent(inout) :: cc(ldc, *) 976 end subroutine ssyrk 977 978 979 !> performs one of the symmetric rank k operations 980 !> C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C 981 subroutine dsyrk(uplo, trans, nn, kk, alpha, aa, lda, beta, cc, ldc) 982 import rdp 983 984 !> Upper 'U' or lower 'L' triangle 985 character, intent(in) :: uplo 986 987 !> should transposition be used 988 character, intent(in) :: trans 989 990 !> matrix size 991 integer, intent(in) :: nn 992 993 !> rank 994 integer, intent(in) :: kk 995 996 !> scale factor 997 real(rdp), intent(in) :: alpha 998 999 !> leading matrix dimension 1000 integer, intent(in) :: lda 1001 1002 !> matrix A 1003 real(rdp), intent(in) :: aa(lda, *) 1004 1005 !> scaling factor 1006 real(rdp), intent(in) :: beta 1007 1008 !> leading matrix dimension 1009 integer, intent(in) :: ldc 1010 1011 !> matrix C 1012 real(rdp), intent(inout) :: cc(ldc, *) 1013 end subroutine dsyrk 1014 1015 1016 !> performs one of the symmetric rank k operations 1017 !> C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C 1018 subroutine cherk(uplo, trans, nn, kk, alpha, aa, lda, beta, cc, ldc) 1019 import rsp 1020 1021 !> Upper 'U' or lower 'L' triangle 1022 character, intent(in) :: uplo 1023 1024 !> should transposition be used 1025 character, intent(in) :: trans 1026 1027 !> matrix size 1028 integer, intent(in) :: nn 1029 1030 !> rank 1031 integer, intent(in) :: kk 1032 1033 !> scaling factor 1034 real(rsp), intent(in) :: alpha 1035 1036 !> leading matrix dimension 1037 integer, intent(in) :: lda 1038 1039 !> matrix A 1040 complex(rsp), intent(in) :: aa(lda, *) 1041 1042 !> scale factor 1043 real(rsp), intent(in) :: beta 1044 1045 !> leading matrix dimension 1046 integer, intent(in) :: ldc 1047 1048 !> matrix C 1049 complex(rsp), intent(inout) :: cc(ldc, *) 1050 end subroutine cherk 1051 1052 1053 !> performs one of the symmetric rank k operations 1054 !> C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C 1055 subroutine zherk(uplo, trans, nn, kk, alpha, aa, lda, beta, cc, ldc) 1056 import rdp 1057 1058 !> Upper 'U' or lower 'L' triangle 1059 character, intent(in) :: uplo 1060 1061 !> should transposition be used 1062 character, intent(in) :: trans 1063 1064 !> matrix size 1065 integer, intent(in) :: nn 1066 1067 !> rank 1068 integer, intent(in) :: kk 1069 1070 !> scale factor 1071 real(rdp), intent(in) :: alpha 1072 1073 !> leading matrix dimension 1074 integer, intent(in) :: lda 1075 1076 !> matrix A 1077 complex(rdp), intent(in) :: aa(lda, *) 1078 1079 !> scaling factor 1080 real(rdp), intent(in) :: beta 1081 1082 !> leading matrix dimension 1083 integer, intent(in) :: ldc 1084 1085 !> matrix C 1086 complex(rdp), intent(inout) :: cc(ldc, *) 1087 end subroutine zherk 1088 1089 1090 !> solves one of the matrix equations 1091 !> op( A )*X = alpha*B, or X*op( A ) = alpha*B 1092 subroutine strsm(side, uplo, transa, diag, mm, nn, alpha, aa, lda, bb, ldb) 1093 import rsp 1094 1095 !> side of the product 1096 character, intent(in) :: side 1097 1098 !> Upper 'U' or lower 'L' triangle 1099 character, intent(in) :: uplo 1100 1101 !> On entry, TRANSA specifies the form of op( A ) to be used 1102 character, intent(in) :: transa 1103 1104 !> On entry, DIAG specifies whether or not A is unit triangular 1105 character, intent(in) :: diag 1106 1107 !> matrix sizing 1108 integer, intent(in) :: mm 1109 1110 !> matrix size 1111 integer, intent(in) :: nn 1112 1113 !> scaling factor 1114 real(rsp), intent(in) :: alpha 1115 1116 !> leading matrix dimension 1117 integer, intent(in) :: lda 1118 1119 !> matrix A 1120 real(rsp), intent(in) :: aa(lda, *) 1121 1122 !> leading matrix dimension 1123 integer, intent(in) :: ldb 1124 1125 !> matrix B 1126 real(rsp), intent(inout) :: bb(ldb, *) 1127 end subroutine strsm 1128 1129 1130 !> solves one of the matrix equations 1131 !> op( A )*X = alpha*B, or X*op( A ) = alpha*B 1132 subroutine dtrsm(side, uplo, transa, diag, mm, nn, alpha, aa, lda, bb, ldb) 1133 import rdp 1134 1135 !> side of the product 1136 character, intent(in) :: side 1137 1138 !> Upper 'U' or lower 'L' triangle 1139 character, intent(in) :: uplo 1140 1141 !> On entry, TRANSA specifies the form of op( A ) to be used 1142 character, intent(in) :: transa 1143 1144 !> On entry, DIAG specifies whether or not A is unit triangular 1145 character, intent(in) :: diag 1146 1147 !> matrix sizing 1148 integer, intent(in) :: mm 1149 1150 !> matrix size 1151 integer, intent(in) :: nn 1152 1153 !> scale factor 1154 real(rdp), intent(in) :: alpha 1155 1156 !> leading matrix dimension 1157 integer, intent(in) :: lda 1158 1159 !> matrix A 1160 real(rdp), intent(in) :: aa(lda, *) 1161 1162 !> leading matrix dimension 1163 integer, intent(in) :: ldb 1164 1165 !> matrix B 1166 real(rdp), intent(inout) :: bb(ldb, *) 1167 end subroutine dtrsm 1168 1169 1170 !> solves one of the matrix equations 1171 !> op( A )*X = alpha*B, or X*op( A ) = alpha*B 1172 subroutine ctrsm(side, uplo, transa, diag, mm, nn, alpha, aa, lda, bb, ldb) 1173 import rsp 1174 1175 !> side of the product 1176 character, intent(in) :: side 1177 1178 !> Upper 'U' or lower 'L' triangle 1179 character, intent(in) :: uplo 1180 1181 !> On entry, TRANSA specifies the form of op( A ) to be used 1182 character, intent(in) :: transa 1183 1184 !> On entry, DIAG specifies whether or not A is unit triangular 1185 character, intent(in) :: diag 1186 1187 !> matrix sizing 1188 integer, intent(in) :: mm 1189 1190 !> matrix size 1191 integer, intent(in) :: nn 1192 1193 !> scale factor 1194 complex(rsp), intent(in) :: alpha 1195 1196 !> leading matrix dimension 1197 integer, intent(in) :: lda 1198 1199 !> matrix A 1200 complex(rsp), intent(in) :: aa(lda, *) 1201 1202 !> leading matrix dimension 1203 integer, intent(in) :: ldb 1204 1205 !> matrix B 1206 complex(rsp), intent(inout) :: bb(ldb, *) 1207 end subroutine ctrsm 1208 1209 1210 !> solves one of the matrix equations 1211 !> op( A )*X = alpha*B, or X*op( A ) = alpha*B 1212 subroutine ztrsm(side, uplo, transa, diag, mm, nn, alpha, aa, lda, bb, ldb) 1213 import rdp 1214 1215 !> side of the product 1216 character, intent(in) :: side 1217 1218 !> Upper 'U' or lower 'L' triangle 1219 character, intent(in) :: uplo 1220 1221 !> On entry, TRANSA specifies the form of op( A ) to be used 1222 character, intent(in) :: transa 1223 1224 !> On entry, DIAG specifies whether or not A is unit triangular 1225 character, intent(in) :: diag 1226 1227 !> matrix sizing 1228 integer, intent(in) :: mm 1229 1230 !> matrix size 1231 integer, intent(in) :: nn 1232 1233 !> scale factor 1234 complex(rdp), intent(in) :: alpha 1235 1236 !> leading matrix dimension 1237 integer, intent(in) :: lda 1238 1239 !> matrix A 1240 complex(rdp), intent(in) :: aa(lda, *) 1241 1242 !> leading matrix dimension 1243 integer, intent(in) :: ldb 1244 1245 !> matrix B 1246 complex(rdp), intent(inout) :: bb(ldb, *) 1247 end subroutine ztrsm 1248 1249 1250 !> performs one of the matrix-matrix operations 1251 !> B := alpha*op( A )*B, or B := alpha*B*op( A ), where op( A ) = A or op( A ) = A**T. 1252 subroutine strmm(side, uplo, transa, diag, mm, nn, alpha, aa, lda, bb, ldb) 1253 import rsp 1254 1255 !> side of the product 1256 character, intent(in) :: side 1257 1258 !> Upper 'U' or lower 'L' triangle 1259 character, intent(in) :: uplo 1260 1261 !> On entry, TRANSA specifies the form of op( A ) to be used 1262 character, intent(in) :: transa 1263 1264 !> On entry, DIAG specifies whether or not A is unit triangular 1265 character, intent(in) :: diag 1266 1267 !> matrix sizing 1268 integer, intent(in) :: mm 1269 1270 !> matrix size 1271 integer, intent(in) :: nn 1272 1273 !> scaling factor 1274 real(rsp), intent(in) :: alpha 1275 1276 !> leading matrix dimension 1277 integer, intent(in) :: lda 1278 1279 !> matrix A 1280 real(rsp), intent(in) :: aa(lda, *) 1281 1282 !> leading matrix dimension 1283 integer, intent(in) :: ldb 1284 1285 !> matrix B 1286 real(rsp), intent(inout) :: bb(ldb, *) 1287 end subroutine strmm 1288 1289 1290 !> performs one of the matrix-matrix operations 1291 !> B := alpha*op( A )*B, or B := alpha*B*op( A ), where op( A ) = A or op( A ) = A**T. 1292 subroutine dtrmm(side, uplo, transa, diag, mm, nn, alpha, aa, lda, bb, ldb) 1293 import rdp 1294 1295 !> side of the product 1296 character, intent(in) :: side 1297 1298 !> Upper 'U' or lower 'L' triangle 1299 character, intent(in) :: uplo 1300 1301 !> On entry, TRANSA specifies the form of op( A ) to be used 1302 character, intent(in) :: transa 1303 1304 !> On entry, DIAG specifies whether or not A is unit triangular 1305 character, intent(in) :: diag 1306 1307 !> matrix sizing 1308 integer, intent(in) :: mm 1309 1310 !> matrix size 1311 integer, intent(in) :: nn 1312 1313 !> scale factor 1314 real(rdp), intent(in) :: alpha 1315 1316 !> leading matrix dimension 1317 integer, intent(in) :: lda 1318 1319 !> matrix A 1320 real(rdp), intent(in) :: aa(lda, *) 1321 1322 !> leading matrix dimension 1323 integer, intent(in) :: ldb 1324 1325 !> matrix B 1326 real(rdp), intent(inout) :: bb(ldb, *) 1327 end subroutine dtrmm 1328 1329 1330 !> performs one of the matrix-matrix operations 1331 !> B := alpha*op( A )*B, or B := alpha*B*op( A ), 1332 !> where op( A ) = A, op( A ) = A**T or op( A ) = A**H. 1333 subroutine ctrmm(side, uplo, transa, diag, mm, nn, alpha, aa, lda, bb, ldb) 1334 import rsp 1335 1336 !> side of the product 1337 character, intent(in) :: side 1338 1339 !> Upper 'U' or lower 'L' triangle 1340 character, intent(in) :: uplo 1341 1342 !> On entry, TRANSA specifies the form of op( A ) to be used 1343 character, intent(in) :: transa 1344 1345 !> On entry, DIAG specifies whether or not A is unit triangular 1346 character, intent(in) :: diag 1347 1348 !> matrix sizing 1349 integer, intent(in) :: mm 1350 1351 !> matrix size 1352 integer, intent(in) :: nn 1353 1354 !> scale factor 1355 complex(rsp), intent(in) :: alpha 1356 1357 !> leading matrix dimension 1358 integer, intent(in) :: lda 1359 1360 !> matrix A 1361 complex(rsp), intent(in) :: aa(lda, *) 1362 1363 !> leading matrix dimension 1364 integer, intent(in) :: ldb 1365 1366 !> matrix B 1367 complex(rsp), intent(inout) :: bb(ldb, *) 1368 end subroutine ctrmm 1369 1370 1371 !> performs one of the matrix-matrix operations 1372 !> B := alpha*op( A )*B, or B := alpha*B*op( A ), 1373 !> where op( A ) = A, op( A ) = A**T or op( A ) = A**H. 1374 subroutine ztrmm(side, uplo, transa, diag, mm, nn, alpha, aa, lda, bb, ldb) 1375 import rdp 1376 1377 !> side of the product 1378 character, intent(in) :: side 1379 1380 !> Upper 'U' or lower 'L' triangle 1381 character, intent(in) :: uplo 1382 1383 !> On entry, TRANSA specifies the form of op( A ) to be used 1384 character, intent(in) :: transa 1385 1386 !> On entry, DIAG specifies whether or not A is unit triangular 1387 character, intent(in) :: diag 1388 1389 !> matrix sizing 1390 integer, intent(in) :: mm 1391 1392 !> matrix size 1393 integer, intent(in) :: nn 1394 1395 !> scale factor 1396 complex(rdp), intent(in) :: alpha 1397 1398 !> leading matrix dimension 1399 integer, intent(in) :: lda 1400 1401 !> matrix A 1402 complex(rdp), intent(in) :: aa(lda, *) 1403 1404 !> leading matrix dimension 1405 integer, intent(in) :: ldb 1406 1407 !> matrix B 1408 complex(rdp), intent(inout) :: bb(ldb, *) 1409 end subroutine ztrmm 1410 1411 end interface 1412 1413end module dftbp_blas 1414