12    integer, 
intent(in) :: nv, nu
 
   13    real(kind=
rp), 
intent(inout) :: v(nv*nv), u(nu*nu)
 
   14    real(kind=
rp), 
intent(inout) :: a(nv,nu), bt(nu,nv)
 
   15    real(kind=
rp) :: work(0:nu**2*nv)
 
   17    call mxm(a, nv, u, nu, work, nu)
 
   18    call mxm(work, nv, bt, nu, v, nv)
 
 
   23    integer, 
intent(in) :: nv, nu
 
   24    real(kind=
rp), 
intent(inout) :: v(nv*nv*nv), u(nu*nu*nu)
 
   25    real(kind=
rp), 
intent(inout) :: a(nv,nu),bt(nu, nv),ct(nu,nv)
 
 
   65    integer, 
intent(in) :: nv, nu
 
   66    real(kind=
rp), 
intent(inout) :: v(nv*nv*nv), u(nu*nu*nu)
 
   67    real(kind=
rp), 
intent(inout) :: a(nv,nu),bt(nu, nv),ct(nu,nv)
 
   68    real(kind=
rp) :: work(nu**2*nv), work2(nu*nv**2)
 
   70    integer :: i, j, k, l, nunu, nvnu, nvnv
 
   81             tmp = tmp + a(i,k) * u(k + nu * (j - 1))
 
   90             ii = l + nv * (j - 1) + nvnv * (i - 1)
 
   93                jj = l + nv * (k - 1) + nvnu * (i - 1)
 
   94                tmp = tmp + work(jj) * bt(k,j)
 
  103          jj = i + nvnv * (j - 1)
 
  106             ii = i + nvnv * (k - 1)
 
  107             tmp = tmp + work2(ii) * ct(k, j)
 
 
  116    integer, 
intent(in) :: n
 
  117    real(kind=
rp), 
intent(inout) :: v(n*n*n), u(n*n*n)
 
  118    real(kind=
rp), 
intent(inout) :: a(n,n), bt(n,n), ct(n,n)
 
  119    real(kind=
rp) :: work(n**3), work2(n**3), tmp
 
  120    integer :: i, j, l, k
 
  121    integer :: ii, jj, nn
 
  130             tmp = tmp + a(i,k) * u(k + n * (j - 1))
 
  139             ii = l + n * (j - 1) + nn * (i - 1)
 
  142                tmp = tmp + work(l + n * (k - 1) + nn * (i - 1)) * bt(k,j)
 
  151          jj = i + nn * (j - 1)
 
  154             tmp = tmp + work2(i + nn * (k - 1)) * ct(k, j)
 
 
  163    integer, 
parameter :: n = 14
 
  164    integer, 
parameter :: nn = n**2
 
  165    real(kind=
rp), 
intent(inout) :: v(n*n*n), u(n*n*n)
 
  166    real(kind=
rp), 
intent(inout) :: a(n,n), bt(n,n), ct(n,n)
 
  167    real(kind=
rp) :: work(n**3), work2(n**3)
 
  174          work(ii) = a(i,1) * u(1 + n * (j - 1)) &
 
  175                   + a(i,2) * u(2 + n * (j - 1)) &
 
  176                   + a(i,3) * u(3 + n * (j - 1)) &
 
  177                   + a(i,4) * u(4 + n * (j - 1)) &
 
  178                   + a(i,5) * u(5 + n * (j - 1)) &
 
  179                   + a(i,6) * u(6 + n * (j - 1)) &
 
  180                   + a(i,7) * u(7 + n * (j - 1)) &
 
  181                   + a(i,8) * u(8 + n * (j - 1)) &
 
  182                   + a(i,9) * u(9 + n * (j - 1)) &
 
  183                   + a(i,10) * u(10 + n * (j - 1)) &
 
  184                   + a(i,11) * u(11 + n * (j - 1)) &
 
  185                   + a(i,12) * u(12 + n * (j - 1)) &
 
  186                   + a(i,13) * u(13 + n * (j - 1)) &
 
  187                   + a(i,14) * u(14 + n * (j - 1))
 
  194             ii = l + n * (j - 1) + nn * (i - 1)
 
  195             work2(ii) = work(l + n * (1 - 1) + nn * (i - 1)) * bt(1,j) &
 
  196                       + work(l + n * (2 - 1) + nn * (i - 1)) * bt(2,j) &
 
  197                       + work(l + n * (3 - 1) + nn * (i - 1)) * bt(3,j) &
 
  198                       + work(l + n * (4 - 1) + nn * (i - 1)) * bt(4,j) &
 
  199                       + work(l + n * (5 - 1) + nn * (i - 1)) * bt(5,j) &
 
  200                       + work(l + n * (6 - 1) + nn * (i - 1)) * bt(6,j) &
 
  201                       + work(l + n * (7 - 1) + nn * (i - 1)) * bt(7,j) &
 
  202                       + work(l + n * (8 - 1) + nn * (i - 1)) * bt(8,j) &
 
  203                       + work(l + n * (9 - 1) + nn * (i - 1)) * bt(9,j) &
 
  204                       + work(l + n * (10 - 1) + nn * (i - 1)) * bt(10,j) &
 
  205                       + work(l + n * (11 - 1) + nn * (i - 1)) * bt(11,j) &
 
  206                       + work(l + n * (12 - 1) + nn * (i - 1)) * bt(12,j) &
 
  207                       + work(l + n * (13 - 1) + nn * (i - 1)) * bt(13,j) &
 
  208                       + work(l + n * (14 - 1) + nn * (i - 1)) * bt(14,j)
 
  215          jj = i + nn * (j - 1)
 
  216          v(jj) = work2(i + nn * (1 - 1)) * ct(1, j) &
 
  217                + work2(i + nn * (2 - 1)) * ct(2, j) &
 
  218                + work2(i + nn * (3 - 1)) * ct(3, j) &
 
  219                + work2(i + nn * (4 - 1)) * ct(4, j) &
 
  220                + work2(i + nn * (5 - 1)) * ct(5, j) &
 
  221                + work2(i + nn * (6 - 1)) * ct(6, j) &
 
  222                + work2(i + nn * (7 - 1)) * ct(7, j) &
 
  223                + work2(i + nn * (8 - 1)) * ct(8, j) &
 
  224                + work2(i + nn * (9 - 1)) * ct(9, j) &
 
  225                + work2(i + nn * (10 - 1)) * ct(10, j) &
 
  226                + work2(i + nn * (11 - 1)) * ct(11, j) &
 
  227                + work2(i + nn * (12 - 1)) * ct(12, j) &
 
  228                + work2(i + nn * (13 - 1)) * ct(13, j) &
 
  229                + work2(i + nn * (14 - 1)) * ct(14, j)
 
 
  236    integer, 
parameter :: n = 13
 
  237    integer, 
parameter :: nn = n**2
 
  238    real(kind=
rp), 
intent(inout) :: v(n*n*n), u(n*n*n)
 
  239    real(kind=
rp), 
intent(inout) :: a(n,n), bt(n,n), ct(n,n)
 
  240    real(kind=
rp) :: work(n**3), work2(n**3)
 
  247          work(ii) = a(i,1) * u(1 + n * (j - 1)) &
 
  248                   + a(i,2) * u(2 + n * (j - 1)) &
 
  249                   + a(i,3) * u(3 + n * (j - 1)) &
 
  250                   + a(i,4) * u(4 + n * (j - 1)) &
 
  251                   + a(i,5) * u(5 + n * (j - 1)) &
 
  252                   + a(i,6) * u(6 + n * (j - 1)) &
 
  253                   + a(i,7) * u(7 + n * (j - 1)) &
 
  254                   + a(i,8) * u(8 + n * (j - 1)) &
 
  255                   + a(i,9) * u(9 + n * (j - 1)) &
 
  256                   + a(i,10) * u(10 + n * (j - 1)) &
 
  257                   + a(i,11) * u(11 + n * (j - 1)) &
 
  258                   + a(i,12) * u(12 + n * (j - 1)) &
 
  259                   + a(i,13) * u(13 + n * (j - 1))
 
  266             ii = l + n * (j - 1) + nn * (i - 1)
 
  267             work2(ii) = work(l + n * (1 - 1) + nn * (i - 1)) * bt(1,j) &
 
  268                       + work(l + n * (2 - 1) + nn * (i - 1)) * bt(2,j) &
 
  269                       + work(l + n * (3 - 1) + nn * (i - 1)) * bt(3,j) &
 
  270                       + work(l + n * (4 - 1) + nn * (i - 1)) * bt(4,j) &
 
  271                       + work(l + n * (5 - 1) + nn * (i - 1)) * bt(5,j) &
 
  272                       + work(l + n * (6 - 1) + nn * (i - 1)) * bt(6,j) &
 
  273                       + work(l + n * (7 - 1) + nn * (i - 1)) * bt(7,j) &
 
  274                       + work(l + n * (8 - 1) + nn * (i - 1)) * bt(8,j) &
 
  275                       + work(l + n * (9 - 1) + nn * (i - 1)) * bt(9,j) &
 
  276                       + work(l + n * (10 - 1) + nn * (i - 1)) * bt(10,j) &
 
  277                       + work(l + n * (11 - 1) + nn * (i - 1)) * bt(11,j) &
 
  278                       + work(l + n * (12 - 1) + nn * (i - 1)) * bt(12,j) &
 
  279                       + work(l + n * (13 - 1) + nn * (i - 1)) * bt(13,j)
 
  286          jj = i + nn * (j - 1)
 
  287          v(jj) = work2(i + nn * (1 - 1)) * ct(1, j) &
 
  288                + work2(i + nn * (2 - 1)) * ct(2, j) &
 
  289                + work2(i + nn * (3 - 1)) * ct(3, j) &
 
  290                + work2(i + nn * (4 - 1)) * ct(4, j) &
 
  291                + work2(i + nn * (5 - 1)) * ct(5, j) &
 
  292                + work2(i + nn * (6 - 1)) * ct(6, j) &
 
  293                + work2(i + nn * (7 - 1)) * ct(7, j) &
 
  294                + work2(i + nn * (8 - 1)) * ct(8, j) &
 
  295                + work2(i + nn * (9 - 1)) * ct(9, j) &
 
  296                + work2(i + nn * (10 - 1)) * ct(10, j) &
 
  297                + work2(i + nn * (11 - 1)) * ct(11, j) &
 
  298                + work2(i + nn * (12 - 1)) * ct(12, j) &
 
  299                + work2(i + nn * (13 - 1)) * ct(13, j)
 
 
  306    integer, 
parameter :: n = 12
 
  307    integer, 
parameter :: nn = n**2
 
  308    real(kind=
rp), 
intent(inout) :: v(n*n*n), u(n*n*n)
 
  309    real(kind=
rp), 
intent(inout) :: a(n,n), bt(n,n), ct(n,n)
 
  310    real(kind=
rp) :: work(n**3), work2(n**3)
 
  317          work(ii) = a(i,1) * u(1 + n * (j - 1)) &
 
  318                   + a(i,2) * u(2 + n * (j - 1)) &
 
  319                   + a(i,3) * u(3 + n * (j - 1)) &
 
  320                   + a(i,4) * u(4 + n * (j - 1)) &
 
  321                   + a(i,5) * u(5 + n * (j - 1)) &
 
  322                   + a(i,6) * u(6 + n * (j - 1)) &
 
  323                   + a(i,7) * u(7 + n * (j - 1)) &
 
  324                   + a(i,8) * u(8 + n * (j - 1)) &
 
  325                   + a(i,9) * u(9 + n * (j - 1)) &
 
  326                   + a(i,10) * u(10 + n * (j - 1)) &
 
  327                   + a(i,11) * u(11 + n * (j - 1)) &
 
  328                   + a(i,12) * u(12 + n * (j - 1))
 
  335             ii = l + n * (j - 1) + nn * (i - 1)
 
  336             work2(ii) = work(l + n * (1 - 1) + nn * (i - 1)) * bt(1,j) &
 
  337                       + work(l + n * (2 - 1) + nn * (i - 1)) * bt(2,j) &
 
  338                       + work(l + n * (3 - 1) + nn * (i - 1)) * bt(3,j) &
 
  339                       + work(l + n * (4 - 1) + nn * (i - 1)) * bt(4,j) &
 
  340                       + work(l + n * (5 - 1) + nn * (i - 1)) * bt(5,j) &
 
  341                       + work(l + n * (6 - 1) + nn * (i - 1)) * bt(6,j) &
 
  342                       + work(l + n * (7 - 1) + nn * (i - 1)) * bt(7,j) &
 
  343                       + work(l + n * (8 - 1) + nn * (i - 1)) * bt(8,j) &
 
  344                       + work(l + n * (9 - 1) + nn * (i - 1)) * bt(9,j) &
 
  345                       + work(l + n * (10 - 1) + nn * (i - 1)) * bt(10,j) &
 
  346                       + work(l + n * (11 - 1) + nn * (i - 1)) * bt(11,j) &
 
  347                       + work(l + n * (12 - 1) + nn * (i - 1)) * bt(12,j)
 
  354          jj = i + nn * (j - 1)
 
  355          v(jj) = work2(i + nn * (1 - 1)) * ct(1, j) &
 
  356                + work2(i + nn * (2 - 1)) * ct(2, j) &
 
  357                + work2(i + nn * (3 - 1)) * ct(3, j) &
 
  358                + work2(i + nn * (4 - 1)) * ct(4, j) &
 
  359                + work2(i + nn * (5 - 1)) * ct(5, j) &
 
  360                + work2(i + nn * (6 - 1)) * ct(6, j) &
 
  361                + work2(i + nn * (7 - 1)) * ct(7, j) &
 
  362                + work2(i + nn * (8 - 1)) * ct(8, j) &
 
  363                + work2(i + nn * (9 - 1)) * ct(9, j) &
 
  364                + work2(i + nn * (10 - 1)) * ct(10, j) &
 
  365                + work2(i + nn * (11 - 1)) * ct(11, j) &
 
  366                + work2(i + nn * (12 - 1)) * ct(12, j)
 
 
  373    integer, 
parameter :: n = 11
 
  374    integer, 
parameter :: nn = n**2
 
  375    real(kind=
rp), 
intent(inout) :: v(n*n*n), u(n*n*n)
 
  376    real(kind=
rp), 
intent(inout) :: a(n,n), bt(n,n), ct(n,n)
 
  377    real(kind=
rp) :: work(n**3), work2(n**3)
 
  384          work(ii) = a(i,1) * u(1 + n * (j - 1)) &
 
  385                   + a(i,2) * u(2 + n * (j - 1)) &
 
  386                   + a(i,3) * u(3 + n * (j - 1)) &
 
  387                   + a(i,4) * u(4 + n * (j - 1)) &
 
  388                   + a(i,5) * u(5 + n * (j - 1)) &
 
  389                   + a(i,6) * u(6 + n * (j - 1)) &
 
  390                   + a(i,7) * u(7 + n * (j - 1)) &
 
  391                   + a(i,8) * u(8 + n * (j - 1)) &
 
  392                   + a(i,9) * u(9 + n * (j - 1)) &
 
  393                   + a(i,10) * u(10 + n * (j - 1)) &
 
  394                   + a(i,11) * u(11 + n * (j - 1))
 
  401             ii = l + n * (j - 1) + nn * (i - 1)
 
  402             work2(ii) = work(l + n * (1 - 1) + nn * (i - 1)) * bt(1,j) &
 
  403                       + work(l + n * (2 - 1) + nn * (i - 1)) * bt(2,j) &
 
  404                       + work(l + n * (3 - 1) + nn * (i - 1)) * bt(3,j) &
 
  405                       + work(l + n * (4 - 1) + nn * (i - 1)) * bt(4,j) &
 
  406                       + work(l + n * (5 - 1) + nn * (i - 1)) * bt(5,j) &
 
  407                       + work(l + n * (6 - 1) + nn * (i - 1)) * bt(6,j) &
 
  408                       + work(l + n * (7 - 1) + nn * (i - 1)) * bt(7,j) &
 
  409                       + work(l + n * (8 - 1) + nn * (i - 1)) * bt(8,j) &
 
  410                       + work(l + n * (9 - 1) + nn * (i - 1)) * bt(9,j) &
 
  411                       + work(l + n * (10 - 1) + nn * (i - 1)) * bt(10,j) &
 
  412                       + work(l + n * (11 - 1) + nn * (i - 1)) * bt(11,j)
 
  419          jj = i + nn * (j - 1)
 
  420          v(jj) = work2(i + nn * (1 - 1)) * ct(1, j) &
 
  421                + work2(i + nn * (2 - 1)) * ct(2, j) &
 
  422                + work2(i + nn * (3 - 1)) * ct(3, j) &
 
  423                + work2(i + nn * (4 - 1)) * ct(4, j) &
 
  424                + work2(i + nn * (5 - 1)) * ct(5, j) &
 
  425                + work2(i + nn * (6 - 1)) * ct(6, j) &
 
  426                + work2(i + nn * (7 - 1)) * ct(7, j) &
 
  427                + work2(i + nn * (8 - 1)) * ct(8, j) &
 
  428                + work2(i + nn * (9 - 1)) * ct(9, j) &
 
  429                + work2(i + nn * (10 - 1)) * ct(10, j) &
 
  430                + work2(i + nn * (11 - 1)) * ct(11, j)
 
 
  437    integer, 
parameter :: n = 10
 
  438    integer, 
parameter :: nn = n**2
 
  439    real(kind=
rp), 
intent(inout) :: v(n*n*n), u(n*n*n)
 
  440    real(kind=
rp), 
intent(inout) :: a(n,n), bt(n,n), ct(n,n)
 
  441    real(kind=
rp) :: work(n**3), work2(n**3)
 
  448          work(ii) = a(i,1) * u(1 + n * (j - 1)) &
 
  449                   + a(i,2) * u(2 + n * (j - 1)) &
 
  450                   + a(i,3) * u(3 + n * (j - 1)) &
 
  451                   + a(i,4) * u(4 + n * (j - 1)) &
 
  452                   + a(i,5) * u(5 + n * (j - 1)) &
 
  453                   + a(i,6) * u(6 + n * (j - 1)) &
 
  454                   + a(i,7) * u(7 + n * (j - 1)) &
 
  455                   + a(i,8) * u(8 + n * (j - 1)) &
 
  456                   + a(i,9) * u(9 + n * (j - 1)) &
 
  457                   + a(i,10) * u(10 + n * (j - 1))
 
  464             ii = l + n * (j - 1) + nn * (i - 1)
 
  465             work2(ii) = work(l + n * (1 - 1) + nn * (i - 1)) * bt(1,j) &
 
  466                       + work(l + n * (2 - 1) + nn * (i - 1)) * bt(2,j) &
 
  467                       + work(l + n * (3 - 1) + nn * (i - 1)) * bt(3,j) &
 
  468                       + work(l + n * (4 - 1) + nn * (i - 1)) * bt(4,j) &
 
  469                       + work(l + n * (5 - 1) + nn * (i - 1)) * bt(5,j) &
 
  470                       + work(l + n * (6 - 1) + nn * (i - 1)) * bt(6,j) &
 
  471                       + work(l + n * (7 - 1) + nn * (i - 1)) * bt(7,j) &
 
  472                       + work(l + n * (8 - 1) + nn * (i - 1)) * bt(8,j) &
 
  473                       + work(l + n * (9 - 1) + nn * (i - 1)) * bt(9,j) &
 
  474                       + work(l + n * (10 - 1) + nn * (i - 1)) * bt(10,j)
 
  481          jj = i + nn * (j - 1)
 
  482          v(jj) = work2(i + nn * (1 - 1)) * ct(1, j) &
 
  483                + work2(i + nn * (2 - 1)) * ct(2, j) &
 
  484                + work2(i + nn * (3 - 1)) * ct(3, j) &
 
  485                + work2(i + nn * (4 - 1)) * ct(4, j) &
 
  486                + work2(i + nn * (5 - 1)) * ct(5, j) &
 
  487                + work2(i + nn * (6 - 1)) * ct(6, j) &
 
  488                + work2(i + nn * (7 - 1)) * ct(7, j) &
 
  489                + work2(i + nn * (8 - 1)) * ct(8, j) &
 
  490                + work2(i + nn * (9 - 1)) * ct(9, j) &
 
  491                + work2(i + nn * (10 - 1)) * ct(10, j)
 
 
  498    integer, 
parameter :: n = 9
 
  499    integer, 
parameter :: nn = n**2
 
  500    real(kind=
rp), 
intent(inout) :: v(n*n*n), u(n*n*n)
 
  501    real(kind=
rp), 
intent(inout) :: a(n,n), bt(n,n), ct(n,n)
 
  502    real(kind=
rp) :: work(n**3), work2(n**3)
 
  509          work(ii) = a(i,1) * u(1 + n * (j - 1)) &
 
  510                   + a(i,2) * u(2 + n * (j - 1)) &
 
  511                   + a(i,3) * u(3 + n * (j - 1)) &
 
  512                   + a(i,4) * u(4 + n * (j - 1)) &
 
  513                   + a(i,5) * u(5 + n * (j - 1)) &
 
  514                   + a(i,6) * u(6 + n * (j - 1)) &
 
  515                   + a(i,7) * u(7 + n * (j - 1)) &
 
  516                   + a(i,8) * u(8 + n * (j - 1)) &
 
  517                   + a(i,9) * u(9 + n * (j - 1))
 
  524             ii = l + n * (j - 1) + nn * (i - 1)
 
  525             work2(ii) = work(l + n * (1 - 1) + nn * (i - 1)) * bt(1,j) &
 
  526                       + work(l + n * (2 - 1) + nn * (i - 1)) * bt(2,j) &
 
  527                       + work(l + n * (3 - 1) + nn * (i - 1)) * bt(3,j) &
 
  528                       + work(l + n * (4 - 1) + nn * (i - 1)) * bt(4,j) &
 
  529                       + work(l + n * (5 - 1) + nn * (i - 1)) * bt(5,j) &
 
  530                       + work(l + n * (6 - 1) + nn * (i - 1)) * bt(6,j) &
 
  531                       + work(l + n * (7 - 1) + nn * (i - 1)) * bt(7,j) &
 
  532                       + work(l + n * (8 - 1) + nn * (i - 1)) * bt(8,j) &
 
  533                       + work(l + n * (9 - 1) + nn * (i - 1)) * bt(9,j)
 
  540          jj = i + nn * (j - 1)
 
  541          v(jj) = work2(i + nn * (1 - 1)) * ct(1, j) &
 
  542                + work2(i + nn * (2 - 1)) * ct(2, j) &
 
  543                + work2(i + nn * (3 - 1)) * ct(3, j) &
 
  544                + work2(i + nn * (4 - 1)) * ct(4, j) &
 
  545                + work2(i + nn * (5 - 1)) * ct(5, j) &
 
  546                + work2(i + nn * (6 - 1)) * ct(6, j) &
 
  547                + work2(i + nn * (7 - 1)) * ct(7, j) &
 
  548                + work2(i + nn * (8 - 1)) * ct(8, j) &
 
  549                + work2(i + nn * (9 - 1)) * ct(9, j)
 
 
  556    integer, 
parameter :: n = 8
 
  557    integer, 
parameter :: nn = n**2
 
  558    real(kind=
rp), 
intent(inout) :: v(n*n*n), u(n*n*n)
 
  559    real(kind=
rp), 
intent(inout) :: a(n,n), bt(n,n), ct(n,n)
 
  560    real(kind=
rp) :: work(n**3), work2(n**3)
 
  567          work(ii) = a(i,1) * u(1 + n * (j - 1)) &
 
  568                   + a(i,2) * u(2 + n * (j - 1)) &
 
  569                   + a(i,3) * u(3 + n * (j - 1)) &
 
  570                   + a(i,4) * u(4 + n * (j - 1)) &
 
  571                   + a(i,5) * u(5 + n * (j - 1)) &
 
  572                   + a(i,6) * u(6 + n * (j - 1)) &
 
  573                   + a(i,7) * u(7 + n * (j - 1)) &
 
  574                   + a(i,8) * u(8 + n * (j - 1))
 
  581             ii = l + n * (j - 1) + nn * (i - 1)
 
  582             work2(ii) = work(l + n * (1 - 1) + nn * (i - 1)) * bt(1,j) &
 
  583                       + work(l + n * (2 - 1) + nn * (i - 1)) * bt(2,j) &
 
  584                       + work(l + n * (3 - 1) + nn * (i - 1)) * bt(3,j) &
 
  585                       + work(l + n * (4 - 1) + nn * (i - 1)) * bt(4,j) &
 
  586                       + work(l + n * (5 - 1) + nn * (i - 1)) * bt(5,j) &
 
  587                       + work(l + n * (6 - 1) + nn * (i - 1)) * bt(6,j) &
 
  588                       + work(l + n * (7 - 1) + nn * (i - 1)) * bt(7,j) &
 
  589                       + work(l + n * (8 - 1) + nn * (i - 1)) * bt(8,j)
 
  596          jj = i + nn * (j - 1)
 
  597          v(jj) = work2(i + nn * (1 - 1)) * ct(1, j) &
 
  598                + work2(i + nn * (2 - 1)) * ct(2, j) &
 
  599                + work2(i + nn * (3 - 1)) * ct(3, j) &
 
  600                + work2(i + nn * (4 - 1)) * ct(4, j) &
 
  601                + work2(i + nn * (5 - 1)) * ct(5, j) &
 
  602                + work2(i + nn * (6 - 1)) * ct(6, j) &
 
  603                + work2(i + nn * (7 - 1)) * ct(7, j) &
 
  604                + work2(i + nn * (8 - 1)) * ct(8, j)
 
 
  611    integer, 
parameter :: n = 7
 
  612    integer, 
parameter :: nn = n**2
 
  613    real(kind=
rp), 
intent(inout) :: v(n*n*n), u(n*n*n)
 
  614    real(kind=
rp), 
intent(inout) :: a(n,n), bt(n,n), ct(n,n)
 
  615    real(kind=
rp) :: work(n**3), work2(n**3)
 
  622          work(ii) = a(i,1) * u(1 + n * (j - 1)) &
 
  623                   + a(i,2) * u(2 + n * (j - 1)) &
 
  624                   + a(i,3) * u(3 + n * (j - 1)) &
 
  625                   + a(i,4) * u(4 + n * (j - 1)) &
 
  626                   + a(i,5) * u(5 + n * (j - 1)) &
 
  627                   + a(i,6) * u(6 + n * (j - 1)) &
 
  628                   + a(i,7) * u(7 + n * (j - 1))
 
  635             ii = l + n * (j - 1) + nn * (i - 1)
 
  636             work2(ii) = work(l + n * (1 - 1) + nn * (i - 1)) * bt(1,j) &
 
  637                       + work(l + n * (2 - 1) + nn * (i - 1)) * bt(2,j) &
 
  638                       + work(l + n * (3 - 1) + nn * (i - 1)) * bt(3,j) &
 
  639                       + work(l + n * (4 - 1) + nn * (i - 1)) * bt(4,j) &
 
  640                       + work(l + n * (5 - 1) + nn * (i - 1)) * bt(5,j) &
 
  641                       + work(l + n * (6 - 1) + nn * (i - 1)) * bt(6,j) &
 
  642                       + work(l + n * (7 - 1) + nn * (i - 1)) * bt(7,j)
 
  649          jj = i + nn * (j - 1)
 
  650          v(jj) = work2(i + nn * (1 - 1)) * ct(1, j) &
 
  651                + work2(i + nn * (2 - 1)) * ct(2, j) &
 
  652                + work2(i + nn * (3 - 1)) * ct(3, j) &
 
  653                + work2(i + nn * (4 - 1)) * ct(4, j) &
 
  654                + work2(i + nn * (5 - 1)) * ct(5, j) &
 
  655                + work2(i + nn * (6 - 1)) * ct(6, j) &
 
  656                + work2(i + nn * (7 - 1)) * ct(7, j)
 
 
  663    integer, 
parameter :: n = 6
 
  664    integer, 
parameter :: nn = n**2
 
  665    real(kind=
rp), 
intent(inout) :: v(n*n*n), u(n*n*n)
 
  666    real(kind=
rp), 
intent(inout) :: a(n,n), bt(n,n), ct(n,n)
 
  667    real(kind=
rp) :: work(n**3), work2(n**3)
 
  674          work(ii) = a(i,1) * u(1 + n * (j - 1)) &
 
  675                   + a(i,2) * u(2 + n * (j - 1)) &
 
  676                   + a(i,3) * u(3 + n * (j - 1)) &
 
  677                   + a(i,4) * u(4 + n * (j - 1)) &
 
  678                   + a(i,5) * u(5 + n * (j - 1)) &
 
  679                   + a(i,6) * u(6 + n * (j - 1))
 
  686             ii = l + n * (j - 1) + nn * (i - 1)
 
  687             work2(ii) = work(l + n * (1 - 1) + nn * (i - 1)) * bt(1,j) &
 
  688                       + work(l + n * (2 - 1) + nn * (i - 1)) * bt(2,j) &
 
  689                       + work(l + n * (3 - 1) + nn * (i - 1)) * bt(3,j) &
 
  690                       + work(l + n * (4 - 1) + nn * (i - 1)) * bt(4,j) &
 
  691                       + work(l + n * (5 - 1) + nn * (i - 1)) * bt(5,j) &
 
  692                       + work(l + n * (6 - 1) + nn * (i - 1)) * bt(6,j)
 
  699          jj = i + nn * (j - 1)
 
  700          v(jj) = work2(i + nn * (1 - 1)) * ct(1, j) &
 
  701                + work2(i + nn * (2 - 1)) * ct(2, j) &
 
  702                + work2(i + nn * (3 - 1)) * ct(3, j) &
 
  703                + work2(i + nn * (4 - 1)) * ct(4, j) &
 
  704                + work2(i + nn * (5 - 1)) * ct(5, j) &
 
  705                + work2(i + nn * (6 - 1)) * ct(6, j)
 
 
  712    integer, 
parameter :: n = 5
 
  713    integer, 
parameter :: nn = n**2
 
  714    real(kind=
rp), 
intent(inout) :: v(n*n*n), u(n*n*n)
 
  715    real(kind=
rp), 
intent(inout) :: a(n,n), bt(n,n), ct(n,n)
 
  716    real(kind=
rp) :: work(n**3), work2(n**3)
 
  723          work(ii) = a(i,1) * u(1 + n * (j - 1)) &
 
  724                   + a(i,2) * u(2 + n * (j - 1)) &
 
  725                   + a(i,3) * u(3 + n * (j - 1)) &
 
  726                   + a(i,4) * u(4 + n * (j - 1)) &
 
  727                   + a(i,5) * u(5 + n * (j - 1))
 
  734             ii = l + n * (j - 1) + nn * (i - 1)
 
  735             work2(ii) = work(l + n * (1 - 1) + nn * (i - 1)) * bt(1,j) &
 
  736                       + work(l + n * (2 - 1) + nn * (i - 1)) * bt(2,j) &
 
  737                       + work(l + n * (3 - 1) + nn * (i - 1)) * bt(3,j) &
 
  738                       + work(l + n * (4 - 1) + nn * (i - 1)) * bt(4,j) &
 
  739                       + work(l + n * (5 - 1) + nn * (i - 1)) * bt(5,j)
 
  746          jj = i + nn * (j - 1)
 
  747          v(jj) = work2(i + nn * (1 - 1)) * ct(1, j) &
 
  748                + work2(i + nn * (2 - 1)) * ct(2, j) &
 
  749                + work2(i + nn * (3 - 1)) * ct(3, j) &
 
  750                + work2(i + nn * (4 - 1)) * ct(4, j) &
 
  751                + work2(i + nn * (5 - 1)) * ct(5, j)
 
 
  758    integer, 
parameter :: n = 4
 
  759    integer, 
parameter :: nn = n**2
 
  760    real(kind=
rp), 
intent(inout) :: v(n*n*n), u(n*n*n)
 
  761    real(kind=
rp), 
intent(inout) :: a(n,n), bt(n,n), ct(n,n)
 
  762    real(kind=
rp) :: work(n**3), work2(n**3)
 
  769          work(ii) = a(i,1) * u(1 + n * (j - 1)) &
 
  770                   + a(i,2) * u(2 + n * (j - 1)) &
 
  771                   + a(i,3) * u(3 + n * (j - 1)) &
 
  772                   + a(i,4) * u(4 + n * (j - 1))
 
  779             ii = l + n * (j - 1) + nn * (i - 1)
 
  780             work2(ii) = work(l + n * (1 - 1) + nn * (i - 1)) * bt(1,j) &
 
  781                       + work(l + n * (2 - 1) + nn * (i - 1)) * bt(2,j) &
 
  782                       + work(l + n * (3 - 1) + nn * (i - 1)) * bt(3,j) &
 
  783                       + work(l + n * (4 - 1) + nn * (i - 1)) * bt(4,j)
 
  790          jj = i + nn * (j - 1)
 
  791          v(jj) = work2(i + nn * (1 - 1)) * ct(1, j) &
 
  792                + work2(i + nn * (2 - 1)) * ct(2, j) &
 
  793                + work2(i + nn * (3 - 1)) * ct(3, j) &
 
  794                + work2(i + nn * (4 - 1)) * ct(4, j)
 
 
  801    integer, 
parameter :: n = 3
 
  802    integer, 
parameter :: nn = n**2
 
  803    real(kind=
rp), 
intent(inout) :: v(n*n*n), u(n*n*n)
 
  804    real(kind=
rp), 
intent(inout) :: a(n,n), bt(n,n), ct(n,n)
 
  805    real(kind=
rp) :: work(n**3), work2(n**3)
 
  812          work(ii) = a(i,1) * u(1 + n * (j - 1)) &
 
  813                   + a(i,2) * u(2 + n * (j - 1)) &
 
  814                   + a(i,3) * u(3 + n * (j - 1))
 
  821             ii = l + n * (j - 1) + nn * (i - 1)
 
  822             work2(ii) = work(l + n * (1 - 1) + nn * (i - 1)) * bt(1,j) &
 
  823                       + work(l + n * (2 - 1) + nn * (i - 1)) * bt(2,j) &
 
  824                       + work(l + n * (3 - 1) + nn * (i - 1)) * bt(3,j)
 
  831          jj = i + nn * (j - 1)
 
  832          v(jj) = work2(i + nn * (1 - 1)) * ct(1, j) &
 
  833                + work2(i + nn * (2 - 1)) * ct(2, j) &
 
  834                + work2(i + nn * (3 - 1)) * ct(3, j)
 
 
  841    integer, 
parameter :: n = 2
 
  842    integer, 
parameter :: nn = n**2
 
  843    real(kind=
rp), 
intent(inout) :: v(n*n*n), u(n*n*n)
 
  844    real(kind=
rp), 
intent(inout) :: a(n,n), bt(n,n), ct(n,n)
 
  845    real(kind=
rp) :: work(n**3), work2(n**3)
 
  852          work(ii) = a(i,1) * u(1 + n * (j - 1)) &
 
  853                   + a(i,2) * u(2 + n * (j - 1))
 
  860             ii = l + n * (j - 1) + nn * (i - 1)
 
  861             work2(ii) = work(l + n * (1 - 1) + nn * (i - 1)) * bt(1,j) &
 
  862                       + work(l + n * (2 - 1) + nn * (i - 1)) * bt(2,j)
 
  869          jj = i + nn * (j - 1)
 
  870          v(jj) = work2(i + nn * (1 - 1)) * ct(1, j) &
 
  871                + work2(i + nn * (2 - 1)) * ct(2, j)
 
 
  878    integer, 
intent(in) :: nv, nu, nelv
 
  879    real(kind=
rp), 
intent(inout) :: v(nv*nv*nv,nelv), u(nu*nu*nu,nelv)
 
  880    real(kind=
rp), 
intent(inout) :: a(nv,nu), bt(nu, nv), ct(nu,nv)
 
  882    if (nu .eq. 2 .and. nv .eq. 4) 
then 
  884    else if (nu .eq. 4) 
then 
 
  893    integer, 
intent(in) :: nv, nu, nelv
 
  894    real(kind=
rp), 
intent(inout) :: v(nv*nv*nv,nelv), u(nu*nu*nu,nelv)
 
  895    real(kind=
rp), 
intent(inout) :: a(nv,nu), bt(nu, nv), ct(nu,nv)
 
  896    real(kind=
rp) :: work(nu**2*nv), work2(nu*nv**2), tmp
 
  897    integer :: ie, i, j, k, l, ii, jj
 
  898    integer :: nunu, nvnu, nvnv
 
  907             ii = i + nv * (j - 1)
 
  910                tmp = tmp + a(i,k) * u(k + nu * (j - 1), ie)
 
  919                ii = l + nv * (j - 1) + nvnv * (i - 1)
 
  922                   jj = l + nv * (k - 1) + nvnu * (i - 1)
 
  923                   tmp = tmp + work(jj) * bt(k,j)
 
  932             jj = i + nvnv * (j - 1)
 
  935                ii = i + nvnv * (k - 1)
 
  936                tmp = tmp + work2(ii) * ct(k, j)
 
 
  946    integer, 
parameter :: nu = 2
 
  947    integer, 
parameter :: nv = 4
 
  948    integer, 
parameter :: nunu = 4
 
  949    integer, 
parameter :: nvnu = 8
 
  950    integer, 
parameter :: nvnv = 16
 
  951    integer, 
intent(in) :: nelv
 
  952    real(kind=
rp), 
intent(inout) :: v(nv*nv*nv,nelv), u(nu*nu*nu,nelv)
 
  953    real(kind=
rp), 
intent(inout) :: a(nv,nu), bt(nu, nv), ct(nu,nv)
 
  954    real(kind=
rp) :: work(nu**2*nv), work2(nu*nv**2), tmp
 
  955    integer :: ie, i, j, k, l, ii, jj
 
  960             ii = i + nv * (j - 1)
 
  961             work(ii) = a(i,1) * u(1 + nu * (j - 1), ie) &
 
  962                      + a(i,2) * u(2 + nu * (j - 1), ie)
 
  969                ii = l + nv * (j - 1) + nvnv * (i - 1)
 
  972                   jj = l + nv * (k - 1) + nvnu * (i - 1)
 
  973                   tmp = tmp + work(jj) * bt(k,j)
 
  982             jj = i + nvnv * (j - 1)
 
  983             v(jj, ie) = work2(i + nvnv * (1 - 1)) * ct(1, j) &
 
  984                       + work2(i + nvnv * (2 - 1)) * ct(2, j)
 
 
  992    integer, 
parameter :: nu = 4
 
  993    integer, 
parameter :: nunu = 16
 
  994    integer, 
intent(in) :: nv, nelv
 
  995    real(kind=
rp), 
intent(inout) :: v(nv*nv*nv,nelv), u(nu*nu*nu,nelv)
 
  996    real(kind=
rp), 
intent(inout) :: a(nv,nu), bt(nu, nv), ct(nu,nv)
 
  997    real(kind=
rp) :: work(nu**2*nv), work2(nu*nv**2), tmp
 
  998    integer :: ie, i, j, k, l, ii, jj
 
  999    integer :: nvnu, nvnv
 
 1007             ii = i + nv * (j - 1)
 
 1008             work(ii) = a(i,1) * u(1 + nu * (j - 1), ie) &
 
 1009                      + a(i,2) * u(2 + nu * (j - 1), ie) &
 
 1010                      + a(i,3) * u(3 + nu * (j - 1), ie) &
 
 1011                      + a(i,4) * u(4 + nu * (j - 1), ie)
 
 1018                ii = l + nv * (j - 1) + nvnv * (i - 1)
 
 1021                   jj = l + nv * (k - 1) + nvnu * (i - 1)
 
 1022                   tmp = tmp + work(jj) * bt(k,j)
 
 1031             jj = i + nvnv * (j - 1)
 
 1032             v(jj, ie) = work2(i + nvnv * (1 - 1)) * ct(1, j) &
 
 1033                       + work2(i + nvnv * (2 - 1)) * ct(2, j) &
 
 1034                       + work2(i + nvnv * (3 - 1)) * ct(3, j) &
 
 1035                       + work2(i + nvnv * (4 - 1)) * ct(4, j)
 
 
 1043    integer, 
intent(in) :: nv, nu, nelv
 
 1044    real(kind=
rp), 
intent(inout) :: v(nv*nv*nv*nelv)
 
 1045    real(kind=
rp), 
intent(inout) :: a(nv,nu), bt(nu, nv), ct(nu,nv)
 
 1047    if (nu .eq. 4 .and. nv .eq. 2) 
then 
 
 1056    integer, 
intent(in) :: nv, nu, nelv
 
 1057    real(kind=
rp), 
intent(inout) :: v(nv*nv*nv*nelv)
 
 1058    real(kind=
rp), 
intent(inout) :: a(nv,nu), bt(nu, nv), ct(nu,nv)
 
 1059    real(kind=
rp) :: work(nu**2*nv), work2(nu*nv**2)
 
 1060    integer :: e, e0, ee, es, iu, iv, nu3, nv3
 
 1061    integer :: i, j, k, l, ii, jj, kk
 
 1062    integer :: nunu, nvnu, nvnv
 
 1063    real(kind=
rp) :: tmp
 
 1088             ii = i + nv * (j - 1)
 
 1091                kk = k + nu * (j - 1) + iu
 
 1092                tmp = tmp + a(i,k) * v(kk)
 
 1101                ii = l + nv * (j - 1) + nvnv * (i - 1)
 
 1104                   jj = l + nv * (k - 1) + nvnu * (i - 1)
 
 1105                   tmp = tmp + work(jj) * bt(k,j)
 
 1114             jj = i + nvnv * (j - 1) + iv
 
 1117                ii = i + nvnv * (k - 1)
 
 1118                tmp = tmp + work2(ii) * ct(k, j)
 
 
 1128    integer, 
parameter :: nu = 4
 
 1129    integer, 
parameter :: nv = 2
 
 1130    integer, 
parameter :: nunu = 16
 
 1131    integer, 
parameter :: nvnu = 8
 
 1132    integer, 
parameter :: nvnv = 4
 
 1133    integer, 
parameter :: nununu = 64
 
 1134    integer, 
parameter :: nvnvnv = 8
 
 1135    integer, 
intent(in) :: nelv
 
 1136    real(kind=
rp), 
intent(inout) :: v(nv*nv*nv*nelv)
 
 1137    real(kind=
rp), 
intent(inout) :: a(nv,nu), bt(nu, nv), ct(nu,nv)
 
 1138    real(kind=
rp) :: work(nu**2*nv), work2(nu*nv**2)
 
 1139    integer :: e, iu, iv
 
 1140    integer :: i, j, k, l, ii, jj
 
 1141    real(kind=
rp) :: tmp
 
 1149             ii = i + nv * (j - 1)
 
 1150             work(ii) = a(i,1) * v(1 + nu * (j - 1) + iu) &
 
 1151                      + a(i,2) * v(2 + nu * (j - 1) + iu) &
 
 1152                      + a(i,3) * v(3 + nu * (j - 1) + iu) &
 
 1153                      + a(i,4) * v(4 + nu * (j - 1) + iu)
 
 1160                ii = l + nv * (j - 1) + nvnv * (i - 1)
 
 1163                   jj = l + nv * (k - 1) + nvnu * (i - 1)
 
 1164                   tmp = tmp + work(jj) * bt(k,j)
 
 1173             jj = i + nvnv * (j - 1) + iv
 
 1174             v(jj) = work2(i + nvnv * (1 - 1)) * ct(1, j) &
 
 1175                   + work2(i + nvnv * (2 - 1)) * ct(2, j) &
 
 1176                   + work2(i + nvnv * (3 - 1)) * ct(3, j) &
 
 1177                   + work2(i + nvnv * (4 - 1)) * ct(4, j)
 
 
Wrapper for all matrix-matrix product implementations.
 
subroutine, public mxm(a, n1, b, n2, c, n3)
Compute matrix-matrix product  for contiguously packed matrices A,B, and C.
 
integer, parameter, public rp
Global precision used in computations.
 
subroutine tnsr3d_el_n5_cpu(v, u, a, bt, ct)
 
subroutine tnsr1_3d_nvnu_cpu(v, nv, nu, a, bt, ct, nelv)
 
subroutine tnsr3d_el_n13_cpu(v, u, a, bt, ct)
 
subroutine, public tnsr3d_cpu(v, nv, u, nu, a, bt, ct, nelv)
 
subroutine tnsr3d_el_n3_cpu(v, u, a, bt, ct)
 
subroutine tnsr3d_nu2nv4_cpu(v, u, a, bt, ct, nelv)
 
subroutine tnsr3d_nvnu_cpu(v, nv, u, nu, a, bt, ct, nelv)
 
subroutine tnsr3d_el_n7_cpu(v, u, a, bt, ct)
 
subroutine tnsr3d_el_n11_cpu(v, u, a, bt, ct)
 
subroutine tnsr3d_el_n9_cpu(v, u, a, bt, ct)
 
subroutine tnsr3d_el_n6_cpu(v, u, a, bt, ct)
 
subroutine tnsr3d_el_n2_cpu(v, u, a, bt, ct)
 
subroutine tnsr3d_el_n12_cpu(v, u, a, bt, ct)
 
subroutine tnsr3d_el_n4_cpu(v, u, a, bt, ct)
 
subroutine tnsr1_3d_nu4nv2_cpu(v, a, bt, ct, nelv)
 
subroutine, public tnsr2d_el_cpu(v, nv, u, nu, a, bt)
 
subroutine, public tnsr1_3d_cpu(v, nv, nu, a, bt, ct, nelv)
 
subroutine tnsr3d_nu4_cpu(v, nv, u, a, bt, ct, nelv)
 
subroutine, public tnsr3d_el_cpu(v, nv, u, nu, a, bt, ct)
 
subroutine tnsr3d_el_n_cpu(v, u, a, bt, ct, n)
 
subroutine tnsr3d_el_nvnu_cpu(v, nv, u, nu, a, bt, ct)
 
subroutine tnsr3d_el_n14_cpu(v, u, a, bt, ct)
 
subroutine tnsr3d_el_n10_cpu(v, u, a, bt, ct)
 
subroutine tnsr3d_el_n8_cpu(v, u, a, bt, ct)