INTRODUCCION

Los programas escritos en Fortran realizados en captulos anteriores estn

estructurados en unidades programticas, en base a niveles jerrquicos. Existen
cuatro tipos de unidades programticas:

program que es la unidad programtica principal, sobre la cual hemos ido

trabajando en el transcurso de los anteriores captulos.

subroutine (subrutina) unidad programtica que contempla instrucciones

ejecutables.

function (funcin) unidad programtica que contempla instrucciones ejecutables

module unidad programtica que contempla instrucciones de declaracin de

variables, inicializacin de variables, interfaces entre funciones y subrutinas.
El programa principal, las subrutinas y funciones, son llamadas procedimientos. Un
procedimiento es interno si esta definida dentro de una unidad programtica, la
cual puede ser una unidad hospedante si se trata de un procedimiento que llama
al procedimiento interno, o bien un modulo. Un procedimiento puede ser externo,
si no esta contenida en ninguna otra unidad programtica.
Sin embargo, existe la posibilidad de tratar cada subproblema de un
problema ms grande de forma independiente. Consiste en codificar cada
subproblema en una unidad de programa5 separada llamada procedimiento
externo. Cada procedimiento externo puede ser compilado, testado y
depurado independientemente de los otros procedimientos del programa
antes de combinarlos entre s para dar lugar al programa final.

En Fortran, hay dos tipos de procedimientos externos: son los

subprogramas funciones o simplemente funciones y las subrutinas. Su
ejecucin se controla desde alguna otra unidad de programa (que puede ser
el programa principal u otro procedimiento externo). Ambos tipos de
procedimientos externos se estudian en este captulo
.
 Los beneficios del diseo descendente en los
programas son:
Es mucho ms fcil encontrar errores en el cdigo, sobre todo en
programas largos.

Permite usar procedimientos construidos por otros programadores.

Evita cambios indeseables en las variables del programa. Slo algunas

de ellas se transfieren entre las diferentes unidades de programa,
aquellas variables que son necesarias para realizar los clculos
previstos. Las dems variables slo son accesibles en la unidad de
programa donde se declaran quedando por lo tanto a salvo de cambios
imprevistos para el resto de las unidades de programa.

Unidad de programa es una porcin de un programa Fortran compilada

separadamente. Son unidades de programa los programas principales, las subrutinas y
los subprogramas funcin.
 SUBRUTINAS
Una subrutina es subprograma de orden jerrquico de nivel inferior
al subprograma principal, que tiene como objetivo llevar a cabo
instrucciones ejecutables, que sern ejecutadas por un
subprograma de nivel jerrquico superior, a travs de una
instruccin que llame a la subrutina. La estructura de una
subrutina es:

subroutine <nombre>[(<argumentos (ficticios)>)]

! instrucciones de declaracin de los argumentos (ficticios)
:
! instrucciones de declaracin de los objetos locales
:
! instrucciones ejecutables
:
end subroutine <nombre>
donde los <argumentos (ficticios)>, en el caso que sean utilizados,
son los objetos, sobre los cuales la subrutina trabajara
preferentemente, estn separados por comas y pueden ser variables,
funciones, subrutinas, tableros, punteros, procedimientos de modulo.
Los objetos locales son de uso exclusivo de la subrutina y no son
utilizados por subprogramas de nivel jerrquico superior.

Las subrutinas son llamadas mediante la sentencia CALL. Seguida

por el nombre de la subrutina y posiblemente por una lista de
argumentos entre parntesis
program poli
integer::n
real,dimension(0:100)::a
real::x,p,q
print*,"Introduzca un polinomio de grado menor o igual a 20"
print*,"Introduzca el grado del polinomio"
read*,n
print*,"Introduzca los coeficientes del polinomio"
print*,"con grado decreciente"
read*,(a(i),i=n,0,-1)
print*,"Introduzca el punto x donde desea ser evaluado"
read*,x
call horner(n,a,x,p,q)
print*,"El valor del polinomio es p(x)= ",p
print*,"El valor de la derivada es p(x)= ",q
end program poli
subroutine horner(n,a,x,p,q)
! n (entero) grado del polinomio a evaluar
! a (arreglo de a(0:n),
! coeficientes del polinomio
! x valor doble precision, donde se desea
! evaluar el polinomio
! p evaluacion del polinomio en x
! q evaluacion del polinomio derivada en x
integer::n,i
real::x,p,q
real,dimension(0:n)::a
p=a(n);
q=0.0
do i=n-1,0,-1
q=q*x+p;
p=p*x+a(i)
end do
return
end subroutine horner
Introduzca un polinomio de grado menor o igual a 20

Introduzca el grado del polinomio

4

Introduzca los coeficientes del polinomio con grado decreciente

5 -3 2 1 -1

Introduzca el punto x donde desea ser evaluado

2

El valor del polinomio es p(x)= 65.000000

El valor de la derivada es p(x)= 133.000000

Press any key to continue

 program poli
integer::n
real,dimension(0:100)::a
real::x,p,q
print*,"Introduzca un polinomio de grado menor o igual a 20"
print*,"Intrudzca el grado del polinomio"
read*,n
print*,"Introduzca los coeficientes del polinomio"
print*,"con grado decreciente"
read*,(a(i),i=n,0,-1)
print*,"Introduzca el punto x donde desea ser evaluado"
read*,x
USANDO LA call horner(n,a,x,p,q)
print*,"El valor del polinomio es p(x)= ",p
SENTENCIA print*,"El valor de la derivada es p(x)= ",q
contains
CONTAINS subroutine horner(n,a,x,p,q)
SE CONOCEN ! n (entero) grado del polinomio a evaluar
! a (arreglo de a(0:n),
COMO ! coeficientes del polinomio
! x valor doble precision, donde se desea
SUBRUTINAS ! evaluar el polinomio
INTERNAS ! p evaluacion del polinomio en x
! q evaluacion del polinomio derivada en x
integer::n,i
real::x,p,q
real,dimension(0:n)::a
p=a(n);
q=0.0
do i=n-1,0,-1
q=q*x+p;
p=p*x+a(i)
end do
return
end subroutine horner
end program poli
Remarcamos que los argumentos (de uso) al llamar una subrutina, no
necesariamente deben tener los mismos nombres, lo nico que se
exige es que coincidan en posicin, tipo y clase; por ejemplo, donde
corresponde una variable entera, debe ir una expresin entera. Esto
se explica porque fortran maneja los objetos por referencia y no por
valor, como lo hacen otros lenguajes de programacin. El manejo de
objetos por referencia significa que el programa, cuando se ejecuta,
trabaja nicamente con el argumento (de uso); as por ejemplo, si i es
la variable de uso y j es la variable ficticia de una subrutina, en cuyo
cdigo fuente, se tiene la instruccin
j=j+1
lo que el programa al ejecutarse, hace realmente es
i=i+1
PROGRAM principal
INTEGER :: G,M,S
REAL::n
PRINT*,"INGRESE GRADOS,MINUTOS Y SEGUNDOS A CONVERTIR"
READ*, G,M,S !30 45 2
CALL convierte (G,M,S,n) !
PRINT*,G," grados",M, " minutos",S," segundos equivalen a"
PRINT*, n," grados decimales"
END PROGRAM principal

SUBROUTINE convierte (grados, minutos, segundos, grads)

INTEGER, INTENT(IN) :: grados, minutos, segundos
REAL, INTENT(OUT) :: grads
grads= grados + minutos/60. + segundos/3600.
RETURN
END SUBROUTINE convierte
INGRESE GRADOS, MINUTOS Y SEGUNDOS A CONVERTIR
30 45 2

30 grados 45 minutos 2 segundos equivalen a

30.750560 grados decimales

Press any key to continue

 EJEMPLOS USANDO DATOS TIPO CHARACTER
PROGRAM CAMBIACARACTERES
CHARACTER(6)::VAR_CAR=" 1.2 "
INTEGER::NUM_CAR
PRINT "(2A)"," Antes de CALL, var_car = ",var_car
CALL CAMBIA_CAR(" ","0",var_car,num_car)
PRINT "(2A)"," Despues de CALL, var_car = ",var_car
PRINT "(A,I1)"," Numeros de caracteres cambiados= ",num_car
END PROGRAM CAMBIACARACTERES
SUBROUTINE
CAMBIA_CAR(si_car,nu_car,arg_car,num_car)
Character(1),intent(in)::si_car !entrada
Character(1),intent(in)::nu_car !entrada
Character(*),intent(inout)::arg_car !cambiado
integer,intent(out)::num_car !salida
Integer::I !local
Num_car=0
Do i=1,len(arg_car)
If (arg_car(i:i)==si_car) then
Arg_car(i:i)=nu_car
Num_car=num_car+1
Endif
End do
End subroutine cambia_car
Antes de CALL, var_car = 1.2

Despues de CALL, var_car = 001.20

Numeros de caracteres cambiados= 3

Press any key to continue

 SUBPROGRAMAS
FUNCTION
Hay dos tipos de funciones:

Intrnsecas: todas aquellas funciones que suministra el propio

lenguaje

Definidas por el propio programador o subprogramas funcin:

procedimientos que permiten responder a necesidades particulares
del usuario, no proporcionadas por las funciones intrnsecas.

funciones intrnsecas, pueden formar parte de expresiones,

y por lo tanto, pueden aparecer en todos aquellos lugares
donde se puede usar una expresin. Su resultado es un
valor numrico, lgico, cadena de caracteres o array.
PROGRAM AREA
REAL::RADIO
PRINT*,"INGRESE RADIO DEL CIRCULO"
READ*,RADIO
PRINT*
PRINT*,"AREA DEL CIRCULO= ",AREA_CIRCULO(RADIO)
END PROGRAM AREA

FUNCTION AREA_CIRCULO(R) RESULT(A)

REAL::R, A
REAL,PARAMETER::PI=3.1416
A=PI*R*R
RETURN
END FUNCTION AREA_CIRCULO

INGRESE RADIO DEL CIRCULO

1
AREA DEL CIRCULO= 3.141600
Press any key to continue
PROGRAM AREA
REAL::RADIO
PRINT*,"INGRESE RADIO DEL CIRCULO"
READ*,RADIO
PRINT*
PRINT*,"AREA DEL CIRCULO= ",AREA_CIRCULO(RADIO)

CONTAINS
FUNCTION AREA_CIRCULO(R) RESULT(A)
REAL::R,A
REAL,PARAMETER::PI=3.1416
A=PI*R*R PROGRAM AREA
REAL::RADIO,A1
RETURN PRINT*,"INGRESE RADIO DEL CIRCULO"
END FUNCTION AREA_CIRCULO READ*,RADIO
PRINT*
END PROGRAM AREA PRINT*,"AREA DEL CIRCULO= ",AREA_CIRCULO(RADIO, A )
END PROGRAM AREA

FUNCTION AREA_CIRCULO(R, AC)

REAL::R,AC
REAL,PARAMETER::PI=3.1416
AREA_CIRCULO=PI*R*R
RETURN
END FUNCTION AREA_CIRCULO
PROGRAM conversion
REAL:: cent,x,var1,var2
print*,"ingrese temperatura en grados F"
read*,x
var1 = cent (x)
print*, x," es= ",var1
print*,"ingrese otra temperatura en grados F"
read*,x
var2 = -2.0*cent(x)+4
print*, x," es= ",var2
end program conversion

FUNCTION cent(temperatura)
REAL:: cent !declaracion del nombre de la funcion
REAL,INTENT(IN):: temperatura !declaracion del argumento formal
REAL,PARAMETER:: CTE=5./9. !parametro local a la funcion
cent= CTE*(temperatura-32.)
END FUNCTION cent
ingrese temperatura en grados F
32
32.000000 es = 0.000000E+00

ingrese otra temperatura en grados F

10
10.000000 es = 28.444450

Press any key to continue

Autor: Ing. William Chauca Nolasco

2016-I
 METODO DE NEWTON RAPHSON

Algoritmo de Newton Raphson

Interpretacin grafica del mtodo de Newton Raphson
!Programa para obtener
!valor inicial para utilizarlo
!en newton raphson
!e^x-pix=0
program valor
real::x,y
real,parameter::pi=3.1416
integer::i
x=-3.0
print*," X Y"
Do i=1,20
y=exp(x)-pi*x
print 10,x,y
x=x+0.5
end do
10 format(1x,f12.6,1x,f12.6)
end program valor
! X Y
! -3.000000 9.474586
! -2.500000 7.936085
! -2.000000 6.418535
! -1.500000 4.935530
! -1.000000 3.509479
! -.500000 2.177330
! .000000 1.000000
! .500000 .077921
! 1.000000 -.423318
! 1.500000 -.230711
! 2.000000 1.105856
! 2.500000 4.328494
! 3.000000 10.660740
! 3.500000 22.119850
! 4.000000 42.031750
! 4.500000 75.879930
! 5.000000 132.705200
! 5.500000 227.413100
! 6.000000 384.579200
! 6.500000 644.721300
!Press any key to continue
!Programa para obtener
!valor inicial para utilizarlo
!en newton raphson
!e^x-pix=0
program valor_raiz
real::x0,x1
real::f,df !f =la funcion, df =derivada de la funcion
real::E,Error
integer::i
x0=0.5 !valor inicial
E=0.0001
Do i=1,100
x1=x0-f(x0)/df(x0) !algortimo newton raphson
Error=abs((x1-x0)/x1)*100
if (Error<E) then
print 10,x1
stop "Chauuuu"
end if
x0=x1
end do
10 format(1x,"Encontramos la raiz =",1x,f8.4)
end program valor_raiz

function f(x0)
real::x0
real,parameter::pi=3.1416
f=exp(x0)-pi*x0
return
end function f

function df(x0)
real::x0
real,parameter::pi=3.1416
df=exp(x0)-pi
return
end function df
program valor_raiz
real::x0,x1
real::f,df !f =la funcion, df =derivada de la funcion
real::E,Error
integer::i
x0=0.5 !valor inicial
E=0.0001
Do i=1,100
call newton(x0,f,df)
x1=x0-f/df !algortimo newton raphson
Error=abs((x1-x0)/x1)*100
if (Error<E) then
print 10,x1
stop "Chauuuu"
end if
x0=x1
end do
10 format(1x,"Encontramos la raiz =",1x,f8.4)
end program valor_raiz

!end function df
subroutine newton(x0,f,df)
real::x0
real,parameter::pi=3.1416
f=exp(x0)-pi*x0
df=exp(x0)-pi
return
end subroutine newton
!altura del vertedero
!f(h)=3.33(b-0.2h)(h^3)^(1/2)-Q
!df=3.33(b-0.2h)(1.5)(h^(1/2)+(h^(2))^(1/2)(3.33)(-0.2)
program valor_raiz
real::x0,x1
real::f,df !f =la funcion, df =derivada de la funcion
real::E,Error
real::Q,B
integer::i
x0=1.5 !valor inicial
E=0.0001
Q=12
B=3

Do i=1,100
x1=x0-f(x0,Q,B)/df(x0,B) !algortimo newton raphson
Error=abs((x1-x0)/x1)*100
if (Error<E) then
print 10,x1
stop "AL SUSTIII"
end if
x0=x1
end do
10 format(1x,"Encontramos la raiz =",1x,f8.4)
end program valor_raiz

function f(x0,Q,B)
real::x0,Q,B
f=3.33*(B-0.2*X0)*(X0**3)**(1./2)-Q
return
end function f

function df(x0,B)
real::x0,B
df=3.33*(b-0.2*X0)*(1.5)*(X0**(1./2))+((X0**2)**(1./2))*(3.33)*(-0.2)
return
end function df
MODULOS
La sintaxis general de un mdulo es:

MODULE nombre_modulo
[SAVE]
Declaracin e inicializacin datos
compartidos Cuerpo del mdulo
END MODULE nombre_modulo
PROGRAM principal
USE comparte_datos
IMPLICIT NONE
INTEGER :: j
PRINT*, 'v1', v1
PRINT*, 'v2',v2
v1=v1+v2
PRINT*, 'v1',v1
CALL sub
PRINT*, MATRIZ'
DO i=1,TM
PRINT*, (m(i,j),j=1,2)
END DO
END PROGRAM principal
 SUBROUTINE sub
USE comparte_datos
IMPLICIT NONE
m( : , 1 ) = v1
m( : , 2 ) = v2
END SUBROUTINE sub

MODULE comparte_datos
IMPLICIT NONE
SAVE
INTEGER, PARAMETER:: TM=5
INTEGER:: i
INTEGER, DIMENSION(TM) :: v1=1,v2=(/ (i, i=10,14) /)
INTEGER, DIMENSION(TM,2) :: m
END MODULE comparte_datos
EJEMPLO DE UN PROGRAMA EN LA QUE EXISTEN VARIAS UNIDADES
PROGRAMAS QUE UTILIZAN LAS CONSTANTES RAIZ CUADRADA DE 2 Y
RAIZ CUADRADA DE 3 CUYOS VALORES RESPECTIVOS SON 1.41421 Y
1.73205 Y COMPARTEN OTRAS VARIABLES ES COORD_X, COORD_U,
COORD_Z UTILIZAMOS PARA ELLO UN MODULO

PROGRAM PAQUETES
USE COMPARTIDAS
PRINT*,"VALOR DE COORD_X "
CALL SUB1
PRINT*,COORD_X
PRINT*,"VALOR DE COORD_Y"
CALL SUB2
PRINT*,COORD_Y
PRINT*
PRINT*,"RAIZ = ",SUB3(COORD_X,COORD_Y)
END PROGRAM PAQUETES
SUBROUTINE SUB1
USE COMPARTIDAS
IMPLICIT NONE
COORD_X=RAIZ2
RETURN
END SUBROUTINE SUB1

SUBROUTINE SUB2
USE COMPARTIDAS
IMPLICIT NONE
COORD_Y=RAIZ3
RETURN
END SUBROUTINE SUB2

FUNCTION SUB3(X,Y)
REAL::X,Y
SUB3=SQRT(X**2+Y**2)
RETURN
END FUNCTION SUB3
MODULE COMPARTIDAS
IMPLICIT NONE
SAVE
REAL,PARAMETER::RAIZ2=1.41421,RAIZ3=1.73205
REAL::COORD_X,COORD_Y,COORD_Z
END MODULE COMPARTIDAS
PROGRAM PAQUETES
USE COMPARTIDAS
PRINT*,"VALOR DE COORD_X "
CALL SUB1(raiz2,coord_x)
PRINT*,COORD_X
PRINT*,"VALOR DE COORD_Y"
CALL SUB2(raiz3,coord_y)
PRINT*,COORD_Y
PRINT*
PRINT*,"RAIZ =
",SUB3(COORD_X,COORD_Y)
END PROGRAM PAQUETES
MODULE COMPARTIDAS
real,parameter::RAIZ2=1.42421,RAIZ3=1.73205

contains
SUBROUTINE SUB1(raiz2,coord_x)
REAL::COORD_X,raiz2
COORD_X=RAIZ2
RETURN
END SUBROUTINE SUB1

SUBROUTINE SUB2(raiz3,coord_y)
real::COORD_Y,raiz3
COORD_Y=RAIZ3
RETURN
END SUBROUTINE SUB2

FUNCTION SUB3(X,Y)
REAL::X,Y
SUB3=SQRT(X**2+Y**2)
RETURN
END FUNCTION SUB3

END MODULE COMPARTIDAS