Encuentre programas que calculen valores propios y vectores propios
==================Fortran es. no distingue entre mayúsculas y minúsculas, ¡así que preste atención a los nombres de variables! ======================
===== ============ ===========IN== Módulo de declaración de variables====================== ============= =
módulo IN
implícito ninguno
entero, parámetro::dimen=5! Es necesario modificar cuando @@ cambia el tamaño de la matriz
real(kind=8):: A(dimen, dimen), A1(dimen, dimen)
real(kind=8 ) ::err=1E-6
contiene
! Establezca la matriz, @@ debe modificarse al cambiar la matriz
Subrutina inp()
A(:, 1)=(/4, 2, 2, 5, 8 /)
A(：2)=(/2,5,1,3,4/)
A(：,3)=(/2,1,6, 2, 6/)
A(：,4)=(/5,3,2,1,3/)
A(：,5)=(/8, 4, 6, 3, 3/)
Finalizar subrutina
! Formatear matriz de salida
Salida de subrutina(matriz)
implícita ninguna
entero::m, n
real(tipo =8) ::matriz(:,:)
entero::i
carácter(len=20)=(/8, 4, 6, 3, 3/)
finalizar subrutina
! p> carácter(len=20):: for='(?(1x, f13.8))'
m=tamaño (matriz, 1)
n=tamaño(matriz, 2)
escribir(for(2:3),'(I2)')n
hacer i= 1, m
escribir(*, fmt=for) matriz(:, i)
finalizar hacer
regresar
finalizar subrutina
finalizar módulo
! ==================================================== ============================
! ============== ==============OP== Módulo de operación de función=============================== ====
módulo OP
uso IN
implícito ninguno
! Encuentra el producto escalar de dos vectores
real(kind=8) function in_product(a,b)
implícito ninguno
real(kind=8): : a(dimen), b(dimen)
entero:
：i
in_product=0
hacer i=1, dimen
in_product=in_product a(i)*b(i)
finalizar hacer
regresar
finalizar función
! Encuentra el resultado de multiplicar dos matrices
Función Mult(a, b)
implícita ninguna
real(kind=8)::a(dimen, dimen ), b(dimen, dimen)
real(kind=8):: Mult(dimen, dimen)
entero::i, j
do i=1,dimen
hacer j=1,dimen
Mult(j,i)=in_product(a(:,i),b(j,:))< / p>
fin de hacer
fin de hacer
retorno
fin de función
! Función Get_t(s)
implícita ninguna
real(kind=8)::s
real(kind=8)::Get_t
Get_t = -s sqrt (s**2 1)
if(abs(Get_t)gt; abs(-s-sqrt(s**2 1)) entonces
Get_t = -s-sqrt(s**2 1)
finaliza si
regresa
finaliza la función
¡Función! pq(x)
implícito ninguno
real(kind=8)::x(dimen,dimen)
real(kind=8)::max
entero::pq(2)
entero::i,j
max=x(2,1)
pq (1)=1
pq(2)=2
hacer i=1, dimensión
hacer j=1, dimensión
si (i/=j)entonces
si (abs(x(j,i))gt; abs(max))entonces
max=x(j,i)
pq(1)=i
pq(2)=j
terminar si
terminar si
end do<
end do
return
end function
! Dado el método de generación de la matriz Q, m-gt; p, n-gt; q
Función Creat_Q(m, n, t)
implícito ninguno
¡Entero! p> co=1/sqrt(1 t**2)
si=t/sqrt(1 t**2)
! Inicializar Q
Creat_Q=0
do k=1, dimen
Creat_Q(k, k)=1
fin do
Creat_Q(m ,m)=co
Creat_Q(n, n)=co
Creat_Q(m, n)=si
Creat_Q(n, m)=-si
retorno
función final
! Método triple para generar matriz Q con m filas y n columnas
Función Tcreat_Q(X, m, n)
implícita ninguna
entero::m, n , k
real(kind=8)::X(dimen,dimen),Tcreat_Q(dimen,dimen)
real(kind=8)::co,si
! Definir cos, sin
co=X(m, m-1)/sqrt(X(n, m-1)**2 X(m, m-1)**2)
si=X(n,m-1)/sqrt(X(n,m-1)**2 X(m,m-1)**2)
! Inicializar Q
Tcreat_Q=0
do k=1, dimen
Tcreat_Q(k, k)=1
end do
Tcreat_Q(m, m)=co
Tcreat_Q(n, n)=co
Tcreat_Q(m, n)=si
Tcreat_Q(n, m)=-si
Finalizar función
! Encuentra la matriz transpuesta de una matriz
función Inver(x)
implícita ninguna
real(kind=8)::x(dimen,dimen)
p>entero：：i,j
real(kind=8):.Inver(dimen,dimen)
do i=1，dimen
hacer j=1，dimen
Inver(i,j)=x(j,i)
terminar hacer
terminar hacer
finalizar hacer
regresar
finalizar función
finalizar módulo
! ==================================================== ============================
! ============== ============== Módulo de valor característico de solicitud dado =============================== =
módulo GI
uso IN
uso OP
implícito ninguno
contiene
! Método dado de valores propios
Subrutina Dado()
implícito ninguno
real(kind=8):: s, t
real (kind=8)：： dimen)
entero：：pp，qq，k
entero：：w(2)
>
lógico: .jud=.true.
Llamar a inp()
R=A
! Inicialización de matriz característica
E(:,:)=0
do k=1, dimen
E(k, k)=1
fin de hacerlo
! Generar matrices diagonales y características
do while(jud)
w=pq(A)
pp=w(1)
qq=w(2)
if(abs(A(qq,pp))lt;err)entonces
jud=.false.
> A1 =A
E=Mult(E, Q)
else
s=A(pp, pp)
s =s-A (qq, qq)
s=s/(2*A(qq, pp))
t=Get_t(s)
Q= Creat_Q( pp, qq, t)
E=Mult(E, Q)
X=Inver(Q)
A1=Mult(X, A )
A1=Mult(A1, Q)
A=A1
fin si
fin hacer
escribir (*, "(A6,/)") "A1: "
Llamar a salida(A1)
escribir(*, "(A6,/)") "E : "
Llamar a salida(E)
escribir(*, "(A6,/)") "A*E"
Llamar a salida( Mult( R, E))
escribir(*, "(A6,/)") "E*A"
Llamar a salida(Mult(E, A1))
Finalizar subrutina
Finalizar módulo
! ==================================================== ============================
! ============== ======= Método de tridiagonalización============================
Módulo TD
Usar IN
Usar OP
Usar GI
implícito ninguno
contiene
! Método de diagnóstico triple para valores propios y matrices propias
Subrutina Tri()
implícita ninguna
entero:: m, n, k
real(tipo=8)：：s，t
real(tipo=8)：：X(dimen，dimen)，Q(dimen，dimen)
real (tipo =8):：E(dimen，dimen)，R(dimen，dimen)
real(kind=8)：：E(dimen，dimen)，R(dimen，dimen)
entero ：：pp, qq
entero：：w(2)
lógico：：jud=.true.
Llamar a inp()
R=A
! Utilice Q
Matrix inicializa A en una matriz de tipo TD
! Inicialización de matriz característica
E=0
do k=1, dimen
E(k, k)=1
end do
do m=2,dimen-1
do n=m 1,dimen
A1=Mult(Inver(Tcreat_ Q(A, m, n )), A)
A1=Mult(A1, Tcreat_Q(A, m, n))
E=Mult(E, Tcreat_Q(A, m, n))
A=A1
fin de hacer
fin de hacer
! Ángulo diagonal usando el método dado
do while(jud)
w=pq(A)
pp=w(1)
qq=w(2)
if(abs(A(qq,pp))lt;err)entonces
jud=.false.
! p> A1=A
Q=Creat_Q(pp, qq, t)
E=Mult(E, Q)
else
s=A(pp, pp)
s=s-A(qq, qq)
s=s/(2*A(qq, pp))
t= Obtener_t(s)
Q=Crear_Q(pp, qq, t)
E=Mult(E, Q)
X= Inver(Q)
A1=Mult(X, A)
A1=Mult(A1, Q)
A=A1
finalizar si
finalizar hacer
escribir(*, "(A6,/)") "A1:"
Llamar a salida(A1)
escribir(*, "(A6, /)") "E:"
Llamar a salida(E)
escribir(*, "(A6, /)" ) "A1:"
Llamar salida(E)
escribir(*, "(A6, /)") "A*E./)") "A*E"
llamar a salida(Mult(R,E))
escribir(*, "(A6,/)") "E*A"
llamar a salida (Mult(E,A1))
finalizar subrutina
finalizar módulo
================ ==================================================== ============
! ================================= Programa principal =============== ========================
programa principal
uso IN
uso GI
usa TD<
implícito ninguno
real::X(dimen,dimen)
! Para conservar los valores de codificación de pantalla, puede omitirlos
carácter(len=20): :ab
!
llamar a Dado()
!llamar a Tri()
escribir(*,*) "Ingrese un número"
leer(*,*)ab
parar
finalizar