Computes the transpose of a matrix.

Operator Return Value

Matrix containing the transpose of A.   (Output)

Required Operand

A — Matrix for which the transpose is to be computed. This is a real, double, complex, double complex, or one of the computational sparse matrix derived types, ?_hbc_sparse. (Input).

FORTRAN 90 Interface

.t. A

Description

Computes the transpose of  matrix A. The operation may be read transpose, and the results are the mathematical objects in a precision and data type that matches the operand.  Since this is a unary operation, it has higher Fortran 90 precedence than any other intrinsic unary array operation. 

.t. can be used with either dense or sparse matrices.

Examples

Dense Matrix Example  (operator_ex07.f90)

 

use linear_operators

 

      implicit none

 

! This is the equivalent of Example 3 (using operators) for LIN_SOL_SELF.

 

      integer tries

      integer, parameter :: m=8, n=4, k=2

      integer ipivots(n+1)

      real(kind(1d0)) :: one=1.0d0, err

      real(kind(1d0)) a(n,n), b(n,1), c(m,n), x(n,1), &

             e(n), ATEMP(n,n)

      type(d_options) :: iopti(4)

 

! Generate a random rectangular matrix.

      C = rand(C)

 

! Generate a random right hand side for use in the inverse 

! iteration.

      b = rand(b)

 

! Compute the positive definite matrix.

      A = C .tx. C; A = (A+.t.A)/2

 

! Obtain just the eigenvalues.

      E = EIG(A)

 

! Use packaged option to reset the value of a small diagonal.

      iopti(4) = 0

      iopti(1) = d_options(d_lin_sol_self_set_small,&

                 epsilon(one)*abs(E(1)))

 

! Use packaged option to save the factorization.

      iopti(2) = d_lin_sol_self_save_factors

 

! Suppress error messages and stopping due to singularity 

! of the matrix, which is expected.

      iopti(3) = d_lin_sol_self_no_sing_mess

 

      ATEMP = A

 

! Compute A-eigenvalue*I as the coefficient matrix.

! Use eigenvalue number k.

      A = A - e(k)*EYE(n)     

 

      do tries=1,2

         call lin_sol_self(A, b, x, &

                     pivots=ipivots, iopt=iopti)

! When code is re-entered, the already computed factorization 

! is used.

         iopti(4) = d_lin_sol_self_solve_A

 

! Reset right-hand side in the direction of the eigenvector.

         B = UNIT(x)

      end do

 

! Normalize the eigenvector.

      x = UNIT(x)

 

! Check the results.

      b=ATEMP .x. x

      err =  dot_product(x(1:n,1), b(1:n,1)) - e(k)

 

! If any result is not accurate, quit with no printing.

      if (abs(err) <= sqrt(epsilon(one))*E(1)) then

        write (*,*) 'Example 3 for LIN_SOL_SELF (operators) is correct.'

      end if

 

      end 

Sparse Matrix Example

 

 use wrrrn_int

 use linear_operators

 

 type (s_sparse) S

 type (s_hbc_sparse) H, HT

 integer, parameter :: N=3

 real (kind(1.e0)) X(3,3), XT(3,3)

 real (kind(1.e0)) err

 S = s_entry (1, 1, 2.0)

 S = s_entry (1, 3, 1.0)

 S = s_entry (2, 2, 4.0)

 S = s_entry (3, 3, 6.0)

 H = S   ! sparse

 X = H   ! dense equivalent of H

 HT = .t. H

 XT = HT ! dense equivalent of HT

  call wrrrn ( 'H', X)

  call wrrrn ( 'H Transpose', XT)

 

! Check the results.

     err =  norm(XT - (.t. X))

      if (err <= sqrt(epsilon(one))) then

         write (*,*) 'Sparse example for .t. operator is correct.'

      end if

 

 end

Output

 

             H

         1       2       3

 1   2.000   0.000   1.000

 2   0.000   4.000   0.000

 3   0.000   0.000   6.000

 

        H Transpose

         1       2       3

 1   2.000   0.000   0.000

 2   0.000   4.000   0.000

 3   1.000   0.000   6.000

 Sparse example for .t. operator is correct.

Visual Numerics, Inc. Visual Numerics - Developers of IMSL and PV-WAVE http://www.vni.com/ PHONE: 713.784.3131 FAX:713.781.9260