.t.

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, c_hbc_sparse or z_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.