Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 3 vistas

    Sesion-12-Subrutinas-pptx (Okc)

    Cargado por

    Iván Quispe Aliaga

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd

    Sesion-12-Subrutinas-pptx (Okc)

    Cargado por

    Iván Quispe Aliaga
    3 vistas18 páginas

    Título original

    Sesion-12-Subrutinas-pptx (okC)

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Descargar como pdf o txt
    3 vistas18 páginas

    Sesion-12-Subrutinas-pptx (Okc)

    Cargado por

    Iván Quispe Aliaga

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Descargar como pdf o txt
    Está en la página 1de 18

    fortran.

    f90
    Subrutinas
    Subrutinas
    • Son procedimientos más generales que las funciones, aunque comparten
    casi todas sus características.
    • Pueden retornar más de un valor, o no retornar nada en absoluto.

    • Reciben los valores de entrada y devuelven los valores de salida a través


    de su lista de argumentos.

    La estructura general de una subrutina es idéntica a la de una función:

    • Cabecera de subrutina
    • Sección de especificaciones
    • Sección de ejecución
    • Terminación de la subrutina
    PROGRAM CARLOS
    Definición de variables
    ……
    ……
    CALL nombre_subrutina (a,b,c,d,e)
    ……
    ……
    END PROGRAM CARLOS

    SUBROUTINE nombre_subrutina(a,b,c,d,e)
    Definición de variables
    ……
    SENTENCIA1
    SENTENCIA2
    ……

    END SUBROUTINE nombre_subrutina


    Subrutinas (definición)
    Cabecera:
    SUBROUTINE nombre_subrutina ([Lista de argumentos formales])

    • identifica esa unidad de programa como un procedimiento subrutina.


    • nombre_subrutina identificador
    • Lista de argumentos formales

    Sección de especificaciones:
    • Debe incluir la declaración de los tipos de los argumentos formales con su atributo
    INTENT correspondiente a su intención de uso y la de las variables locales a la
    subrutina, si las hay.

    Sección de ejecución:
    • Debe incluir al menos las sentencia de asignación en la que se asignen valores a los
    argumentos de retorno.

    Terminación:
    END SUBROUTINE [nombre_subrutina]
    • Delimita el fin de la definición de la subrutina y produce el retorno al punto de llamada.
    El retorno también se puede forzar mediante instrucciones RETURN.
    Llamada a una subrutina
    Llamada a una subrutina desde cualquier unidad de programa:

    CALL nombre_subrutina ([Lista de argumentos actuales])

    • Se evalúan los argumentos actuales que son expresiones.


    • Se asocian los argumentos actuales con sus correspondientes argumentos
    formales. El paso de los argumentos se realiza por dirección.
    • Se ejecuta el cuerpo de la subrutina especificada.
    • Se devuelve el control a la unidad de programa que hizo la llamada, en concreto,
    a la sentencia siguiente a la sentencia CALL.

    La subrutina NO devuelve ningún valor a través de su nombre, sino que son los argumentos
    los encargados de realizar las transferencias de resultados.

    Debe haber concordancia en el número, tipo y orden de los argumentos actuales y sus
    correspondientes argumentos formales, al igual que en las funciones.
    Relación de variables en una subrutina

    No necesariamente el nombre de las variables del argumento de las


    variables de entrada debe coincidir con el nombre de las variables de la
    subrutina. Ver gráfico

    call trapzd(f,a,b,s,i)

    SUBROUTINE trapzd(func,a,b,s,n)
    Programa con el mismo resultado usando función y subrutina

    FUNCION SUBRUTINA

    PROGRAM principal PROGRAM principal


    REAL::A=2,B=3 REAL::A=2,B=3

    X=OPERACION(A,B) CALL OPERACION(A,B,X)

    WRITE(*,*)X WRITE(*,*)X

    END PROGRAM principal END PROGRAM principal

    !-------------------------------- !--------------------------------

    REAL FUNCTION OPERACION(A,B) SUBROUTINE OPERACION(A,B,X)


    REAL::A,B REAL::A,B

    OPERACION= A**2+B**2 X= A**2+B**2

    END FUNCTION OPERACION END SUBROUTINE OPERACION


    Subrutina sin argumentos
    PROGRAM UNAC

    CALL RAICES()

    END PROGRAM UNAC

    !-------------------------------------------

    SUBROUTINE RAICES()
    REAL::A=2,B=5,C=2,X1,X2

    X1=(-B+SQRT(B**2-4*A*C))/(2*A)

    X2=(-B-SQRT(B**2-4*A*C))/(2*A)

    WRITE(*,'(F5.1)')X1

    WRITE(*,'(F5.1)')X2

    END SUBROUTINE RAICES


    Subrutina y función sin argumentos

    PROGRAM EJEMPLO PROGRAM EJEMPLO

    CALL SALUDO() Y= SALUDO()

    END PROGRAM EJEMPLO END PROGRAM EJEMPLO

    !---------------------------- !----------------------------

    SUBROUTINE SALUDO() FUNCTION SALUDO()

    WRITE(*,*)'HOLA MUNDO' WRITE(*,*)'HOLA MUNDO'

    END SUBROUTINE SALUDO END FUNCTION SALUDO


    Transferencia de arrays a procedimientos
    Se transfiere la dirección de memoria del primer elemento del mismo. De esta
    manera, el procedimiento es capaz de acceder al arreglo, pues todos sus elementos
    ocupan direcciones de memoria consecutivas.
    El procedimiento debe conocer el tamaño del arreglo, en concreto, los límites de los
    índices de cada dimensión. Hay dos formas:

    • arreglo formal con perfil explícito.


    Se pasan las extensiones de cada dimensión del arreglo en la lista de argumentos
    y se usa en la declaración del arreglo formal en el procedimiento. Ejemplo:

    …
    CALL proced (matriz, d1, d2, resul) !llamada a subrutina
    …
    SUBROUTINE proced (matriz, d1, d2, resul)
    INTEGER, INTENT(IN):: d1,d2
    INTEGER, INTENT(IN), DIMENSION(d1,d2)::matriz ! perfil explícito
    INTEGER, INTENT(OUT):: resul
    Transferencia de arrays a procedimientos
    • arreglo formal con perfil asumido.
    La declaración de un array formal de este tipo usa dos puntos, : , para cada
    índice. Ejemplo:
    MODULE mod1

    CONTAINS

    SUBROUTINE sub1 (matriz)


    INTEGER, INTENT(IN OUT), DIMENSION(:,:)::matriz ! perfil asumido
    …
    END SUBROUTINE sub1

    END MODULE mod1

    Ambas formas permiten operaciones con arreglos completos y subconjuntos


    de arreglos.
    Procedimientos como argumentos

    Los argumentos actuales de un procedimiento pueden ser nombres de


    subrutinas o funciones definidas por el programador. Como el paso de
    argumentos se realiza por dirección, en este caso, se pasa la dirección de
    memoria de comienzo del procedimiento.

    Si el argumento actual es una función, necesita el atributo EXTERNAL en su


    sentencia de declaración de tipo, tanto en el procedimiento de llamada como
    en el procedimiento llamado.

    La sintaxis general es:

    TIPO, EXTERNAL:: nombre_funcion


    Uso de EXTERNAL
    PROGRAM principal SUBROUTINE sub(fun,a,b,c,res) REAL FUNCTION fun(a)
    IMPLICIT NONE IMPLICIT NONE INTEGER,INTENT(IN)::a
    REAL,EXTERNAL::fun REAL,EXTERNAL::fun fun=(3.*a**2+8)/(a+12)
    INTEGER::a=4, b=6,c=-3 INTEGER,INTENT(IN)::a,b,c END FUNCTION fun
    REAL, INTENT(OUT)::res
    REAL::res

    CALL sub(fun,a,b,c,res) res=fun(a)+sqrt(b**2+c**2)

    WRITE(*,*)res END SUBROUTINE sub

    END PROGRAM principal

    Si el argumento actual es una subrutina, es necesario escribir una sentencia


    EXTERNAL, tanto en el procedimiento de llamada como en el procedimiento
    llamado.
    Atributo y sentencia SAVE
    Cada vez que se sale de un procedimiento, los valores de sus variables locales se pierden, a
    menos que se guarden poniendo el atributo SAVE en las sentencias de declaración de tipo de
    aquellas variables que se quieren guardar.
    • La sintaxis general es: TIPO, SAVE:: variable_local1[, variable_local2]…

    Para guardar todas las variables locales a un procedimiento escribir simplemente SAVE en
    una sentencia ubicada en la sección de especificaciones del procedimiento.

    Automáticamente, toda variable local inicializada en su sentencia de declaración se guarda.

    • Ejemplo:
    INTEGER FUNCTION fun(N)
    INTEGER INTENT(IN):: N
    INTEGER, SAVE:: cuenta

    cuenta = cuenta + 1! Cuenta las veces que se llama la función


    ...
    END FUNCTION fun
    Procedimientos internos
    Existe un tercer tipo de procedimientos, los llamados procedimientos internos.
    • Un procedimiento interno es un procedimiento completamente contenido
    dentro de otra unidad de programa, llamada anfitrión o host.
    • El procedimiento interno se compila junto con su anfitrión, sólo es accesible
    desde él y debe escribirse a continuación de la última sentencia ejecutable del
    anfitrión, precedido por una sentencia CONTAINS.

    La estructura general es:


    Cabecero de unidad de programa
    Sección de especificaciones
    Sección ejecutable
    CONTAINS
    Procedimiento interno
    Fin de unidad de programa
    Un procedimiento interno tiene acceso a todos los datos definidos por su anfitrión, salvo
    aquellos datos que tengan el mismo nombre en ambos.
    Los procedimientos internos se usan para realizar manipulaciones de bajo nivel repetidamente
    como parte de una solución.
    Ejemplo CONTAINS
    PROGRAM ejemplo
    REAL, DIMENSION (2) :: k1,k2,k3,k4
    REAL, DIMENSION (2) :: y
    REAL :: t,h
    REAL, PARAMETER :: g=9.8
    REAL, PARAMETER :: m0=5000.0
    REAL, PARAMETER :: mb0=1000.0
    REAL, PARAMETER :: tb0=60.0
    REAL, PARAMETER :: isp=400.0
    REAL :: c,mdot

    ..... Usa F1, F2, etc... F1(y(2)) ...

    CONTAINS
    FUNCTION F1(y)
    REAL :: y
    F1=-y
    END FUNCTION F1

    FUNCTION F2(t)
    REAL :: t,m
    m=m0*(1.0 + mdot*t/m0)
    F2=c*mdot/m+g
    END FUNCTION F2

    END PROGRAM ejer2


    Resuelto
    Suma dos números enteros usando una subrutina para calcular la suma.
    Resuelto 2
    6.- Intercambiar los valores de dos variables enteras. Usar una subrutina para realizar
    el intercambio.

    También podría gustarte