Pr‡ctica 1: Resoluci—n de Sistemas
Esta primera pr‡ctica ha consistido en el reconocimiento del lenguaje de programaci—n Fortran, as’ como su aprendizaje.
Este lenguaje, Fortran, ser‡ el lenguaje de programaci—n que utilizaremos para implementar los algoritmos que se describen en las pr‡cticas de esta asignatura. As’ ser‡ necesario el aprendizaje de este entorno de programaci—n.
TambiŽn vamos a usar en estas pr‡cticas una herramienta de apoyo gr‡fico, el entorno GnuPlot. Este programa servir‡ para representar gr‡ficamente resultados de algoritmos dados en ficheros de datos, de representaci—n de funciones,... . Por ello ser‡ una herramienta muy utilizada en estas pr‡cticas, y de gran interŽs.
Para introducir el lenguaje de programaci—n Fortran el profesor ha suministrado dos ficheros con el c—digo fuente del programa implementando el algoritmo de resoluci—n de sistemas de ecuaciones lineales de Gauss. Un fichero contendr‡ una subrutina que implementar‡ el algoritmo de Gauss y el otro fichero contendr‡ el programa principal donde ser‡n introducidos los datos iniciales del sistema y desde donde se compilar‡ y se crear‡ el fichero ejecutable correspondiente al programa del mŽtodo de Gauss.
Sobre este problema y sobre el fichero
ejecutable podemos observar varias cuestiones de interŽs. En el programa
principal introduciremos aleatoriamente un valor 
. Inicialmente tendr‡ un valor 100. Al
compilar y ejecutar el programa observamos que el tiempo de ejecuci—n es
inapreciable y que nos da como resultado un vector que ser‡ el resultado del
sistema. El tama–o de este vector ser‡ 100, es decir 
. El valor que contiene este vector segœn las condiciones
iniciales introducidas es 1.00000000000000.
De este modo observamos que usando un valor 
m‡s elevado,
como 1000, el tiempo de ejecuci—n es mucho mayor. Esto es debido al nœmero de
operaciones que se realizan en cada iteraci—n del algoritmo. Con el 
tan elevado
realizamos muchas operaciones. As’, la cantidad de operaciones por segundo que
realiza el ordenador es muy grande y tiene un coste elevado de tiempo.
Incluso con un algoritmo de este tipo, sabiendo el nœmero de iteraciones que realiza, podr’amos averiguar cuantas operaciones por segundo realiza el ordenador.
Prin1.for:
program gauss
implicit real*8 (a-h,o-z)
dimension c[allocatable] (:,:),x[allocatable] (:)
n=1000
allocate(c(n,n+1))
allocate(x(n))
do i=1,n
do j=1,n+1
c(i,j)=0.0d+00
enddo
enddo
do i=2,n-1
c(i,i)=7.0d+00
c(i,i+1)=-4.0d+00
c(i,i-1)=2.0d+00
c(i,n+1)=5.0d+00
enddo
c(1,1)=8.0d+00
c(1,2)=-4.0d+00
c(1,n+1)=4.0d+00
c(n,n-1)=2.0d+00
c(n,n)=7.0d+00
c(n,n+1)=9.0d+00
call gausspr(n,c,x)
print*, 'el vector solucion es:'
do i=1,n
print*,x(i)
end do
deallocate(c)
deallocate(x)
stop
end
include 'gausspr.for'
Gausspr.for:
subroutine gausspr(ng,c,x)
implicit real*8 (a-h,o-z)
real*8 s[allocatable](:),nrow[allocatable](:)
dimension c(ng,ng+1),x(ng)
allocate(s(ng),nrow(ng))
e1=0.1d-20
ichg=0
do i=1,ng
nrow(i)=i
end do
do i=1,ng
s(i)=dabs(c(i,1))
do j=1,ng
if(dabs(c(i,j)).gt.s(i)) s(i)=dabs(c(i,j))
end do
if(s(i).lt.e1) then
print*, 'el sistema no tiene solucion unica'
stop
end if
end do
nn=ng-1
do i=1,nn
imax=nrow(i)
amax=dabs(c(imax,i))/s(imax)
imax=i
jj=i+1
do ip=jj,ng
jp=nrow(ip)
if(dabs(c(jp,i))/s(jp).gt.amax) then
amax=dabs(c(jp,i))/s(jp)
imax=ip
end if
end do
if(amax.lt.e1) then
print*, 'el sistema no tiene solucion unica'
stop
end if
if(nrow(i).ne.nrow(imax)) then
ichg=ichg+1
ncopy=nrow(i)
nrow(i)=nrow(imax)
nrow(imax)=ncopy
end if
ik=nrow(i)
do j=jj,ng
j1=nrow(j)
xm=c(j1,i)/c(ik,i)
do k=jj,ng+1
c(j1,k)=c(j1,k)-xm*c(ik,k)
end do
c(j1,i)=xm
end do
end do
n1=nrow(ng)
if(dabs(c(n1,ng)).lt.e1) then
print*, 'el sistema no tiene solucion unica'
stop
end if
c(n1,ng+1)=c(n1,ng+1)/c(n1,ng)
do k=1,nn
i=nn-k+1
jj=i+1
n2=nrow(i)
sum=c(n2,ng+1)
do kk=jj,ng
ll=nrow(kk)
sum=sum-c(n2,kk)*c(ll,ng+1)
end do
c(n2,ng+1)=sum/c(n2,i)
end do
do i=1,ng
x(i)=c(nrow(i),ng+1)
end do
deallocate(nrow)
deallocate(s)
return
end