curso fortran actualizado

INICIO

Recursos Computacionales

Instructor: Rogelio Torres Cabrera

M.I. Ruth Virginia Wilson

Torre de Ingeniería, 1er piso, ala sur, cubículo 10

5623-35-00 Ext. 1106

[email protected]

Programación en Fortran 90

REFERENCIAS

CONTENIDO

Coordinación de Ingeniería de procesos industriales y ambientales. Instituto de Ingeniería UNAM

Descripción: Diseñador de interfaces gráficas, programación de rutinas de cálculo, procesamiento y manejo de datos.

Colaborador en proyectos: Diseño de ductos e instalaciones de producción costa-afuera. IINGEN-PEMEX, duración 1 año.Generador de mapas de estabilidad para pozos con

bombeo neumático. IINGEN-PEMEX, duración 1 año.Generador de Tablas hidráulicas para pozos

petroleros. UNAM-PEMEX, duración 1 año.

Consultoría en el diseño de las bases de datos para AVL (Localización Automática de Vehículos). Empresa: GD&A Puesto: Consultor de Bases de datos Descripción: Diseño de las bases de datos y entidades para la localización de vehículos, y de la conexión con el proveedor de coordenadas


REFERENCIAS

CONTENIDO

Objetivos del curso:

El alumno programará aplicaciones de software empleando el lenguaje de programación FORTRAN aplicable a la ingeniería petrolera.

Evaluación• Tareas (30%)• Exámenes /Proyecto final (70%)


REFERENCIAS

CONTENIDO

Temario

ELEMENTOS BÁSICOS

DISEÑO DE PROGRAMAS

LECTURA / ESCRITURA CON FORMATO

ESTRUCTURAS DE CONTROL

PROGRAMACIÓN ESTRUCTURADA

ARREGLOS

LECTURA / ESCRITURA DE UN ARCHIVO

COMPILACIÓN


REFERENCIAS

CONTENIDO


REFERENCIAS

CONTENIDO

INTRODUCCIÓN

ELEMENTOS BÁSICOS


LECTURA / ESCRITURACON FORMATO


PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS

Contenido

•Diagramas de flujo

•Pseudocódigos

•Instrucción FORMAT

•Descriptores de Formatos

•Descriptores X y T

•Descriptor /

•Arreglos

•Vectores

•Matrices

•Ciclos DO implicítos

•Operaciones con arreglos

•Arreglos Allocatable

•Tipo de datos

•Forma de escritura del código fuente

•Estructura de un programa FORTRAN

•Constantes y variables

•Declaración de datos : Default y Explicíto

•Operadores aritméticos, lógicos y de comparación

•Jerarquía de operaciones

•Funciones intrínsecas

•Instrucciones de entrada y salida

•Inicialización de variables

LECTURA / ESCRITURADE UN ARCHIVO

COMPILACIÓN

•Estructuras de decisión

•Instrucción IF

•Instrucción IF –ELSE IF -ELSE

•Instrucción SELECT CASE

•Estructuras de repetición

•Ciclos condicionados

•Ciclos Iterativos

•Instrucción CYCLE y EXIT

•Instrucción Open

•Escritura de datos en un archivo

•Lectura de datos de un archivo

•Instrucción CLOSE

•Procedimientos

•Procedimientos externos

•Procedimientos internos

•Módulos

•Interfaces

•Procediimientos recursivos


REFERENCIAS

CONTENIDO

IntroducciónINTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

•FORTRAN (FORmula TRANslation) fue el primer lenguaje de alto nivel

•FORTRAN es el lenguaje que ofrece la mejor sintaxis, funciones intrínsecas (escalares y arreglos)

•FORTRAN es más flexible en el manejo de memoria


REFERENCIAS

CONTENIDO

Tipos de datos

REAL

INTEGER

LOGICAL

CHARACTER

intervalo: -2147483647 a 2147483647

Enteros válidos Enteros no válidos

0 1,000,000

-999 -100.

123456789

+17

Real válido Real no válido

10. 1,000,000.

-999.9 111E3

123.45E20 -12.0E1.5

0.12E+1

Válido No válido

‘Esta es una prueba’ Esta es una prueba

‘ ’ ‘Esta es una prueba”

‘{^}’ ‘’Esta es una prueba’

“3.1415”

Válido No válido

.TRUE. TRUE

.FALSE. .FALSE

• Letras:A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

a b c d e f g h i j k l m n o p q r s t u v w x y z

• Dígitos:

0 1 2 3 4 5 6 7 8 9

• Caractéres especiales:

= + - * / ( ) , . ' : ! " % & ; < > ? $ _ espacio

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Forma de escritura del código fuente

7-72

FORMA LIBRE

FORMA FIJA

7-721-132

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

La forma de escritura fija es obsoleta


REFERENCIAS

CONTENIDO

Estructura de un programa FORTRAN

DECLARACIÓN

EJECUCIÓN

TERMINACIÓN

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Sección de declaración

El tipo de variable debe de ser declarada en la sección de declaración al comienzo del programa, después de la instrucción no ejecutable PROGRAM, ejemplo:

REGRESAR

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Sección de Ejecución

La sección de ejecución consiste de una o más instrucciones ejecutables que describe las acciones que va a realizar el programa.

WRITE (*,*)

READ (*,*)

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR


REFERENCIAS

CONTENIDO

Sección de Terminación

La sección de terminación consiste de las instrucciones STOP y END PROGRAM

La instrucción STOP detiene el programa

La instrucción END PROGRAM indica que no hay más instrucciones.

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR


REFERENCIAS

CONTENIDO

• Pueden ser una combinación de dígitos, letras, _

• Los nombres de variables y constantes pueden tener hasta 31 caractéres de longitud

• No pueden empezar por un carácter numérico

Constantes y variables

Nombres validos Nombres no válidos

Tiempo este_nombre_es_muy_pero_muy_largo

Distancia 3_dias

Z234545654 a$

Presión_vapor

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Declaración de datos : Default y Explicíto

DEFAULT

EXPLÍCITO

Todas aquellas variables cuyo nombre comience con los caracteres alfabéticos I, J, K, L, M o N se dice que queda implícitamente definida como variable entera.

Todas aquellas variables cuyo primer carácter alfabético sea una letra distinta de las mencionadas anteriormente, se dice que son variables reales definidas de forma implícita.

El tipo de la variable debe de indicarse explícitamente al comienzo del programa:

INTEGER ::

REAL::

LOGICAL::

CHARACTER(len=<len>)::var1, var2

CHARACTER(len=10)::uno, dosCHARACTER::inicialCHARACTER(15)::id

IMPLICIT NONE

• La instrucción IMPLICIT NONE deshabilita la definición implícita de las variables

• Cuando se emplea IMPLICIT NONE se debe de declarar explícitamente todas las variables utilizadas dentro del programa

• La instrucción IMPLICIT NONE debe aparecer después de la instrucción PROGRAM y antes de cualquier instrucción de declaración

EJEMPLO

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Instrucción IMPLICIT NONE

PROGRAM prueba_1

REAL::tiempo=10.0

WRITE(*,*)’tiempo= ‘, time

END PROGRAM

PROGRAM prueba_1

IMPLICIT NONE

REAL::tiempo=10.0

WRITE(*,*)’tiempo= ‘, time

END PROGRAM

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Operadores aritméticos, lógicos y de comparación

+ suma- Resta

* multiplicación

/ división

** Exponenciación

OPERADORES LÓGICOS

OPERADORES ARITMÉTICOS

OPERADORES DE COMPARACIÓN

OPERADOR FUNCIóN DEFINICIÓN

A.AND.B Y RESULTADO .TRUE. SI A Y B SON VERDADERAS

A.OR.B O RESULTADO .TRUE. SI CUALQUIERA A O B ES

VERDADERA

.A.EQV.B EQUIVALENCIA RESULTADO .TRUE. SI A=B

.A.NEQV.B NO EQUIVALENCIA

.NOT.B NO

OPERADOR SIGNIFICADO

Nuevo estilo

Estilo anterior

.EQ. == igual

.NE. /= diferente

.LT. < menor que

.LE. <= menor o igual que

.GT. > mayor que

.GE. >= mayor o igual que

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

Los cálculos son realizados en FORTRAN con instrucciones de asignación:

Variable_name=expression


REFERENCIAS

CONTENIDO

Jerarquía de operaciones

• El contenido de los paréntesis es evaluado primero, de adentro hacia fuera

• Todos los exponenciales se evalúan de derecha a izquierda

• Las multiplicaciones y divisiones se evalúan de izquierda a derecha

• Las sumas y restas se evalúan de izquierda a derecha

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Funciones Intrínsecas

Una función FORTRAN calcula un valor de salida a partir de uno o más valores de entrada. Los valores de entrada a la función se conocen como el argumento:

y= SIN (alfa) //argumento en radianes

y= SIN (alfa*(3.141593/180.)) //factor de conversión de grados a radianes

REAL, PARAMETER::grados_a_radianes=3.141593/180.

y= SIN (alfa*grados_a_radianes)

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓNEl argumento de una función puede ser una constante, una variable, una expresión o el resultado de otra función, ejemplo:

y= SIN (3.141593)

y= SIN (x)

y= SIN (pi*x)

y= SIN (SQRT(x))


REFERENCIAS

CONTENIDO

Funciones Intrínsecas

Dependiendo del tipo de dato que sea requerido por una función, éstas pueden ser funciones genéricas o funciones específicas:

• Funciones genéricas: pueden usar uno o más tipos de datos, ejemplo: ABS(x)

• Funciones específicas: solo pueden usar un especifíco dato de entrada.

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Instrucciones de entrada y salida

INSTRUCCIÓN READ(*.*)Ejemplo:

PROGRAM ejemplo_datos_entradaINTEGER::i,jREAL::aCHARACTER(len=12)::charsREAD(*,*)i,j,a,charsEND PROGRAM

Los datos tienen que ser escritos en el orden que se pidan en el programa: 1,2,3.,’número’

Los datos pueden estar separados por comas o espacios, o por líneas

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

teclado

Formato libre


REFERENCIAS

CONTENIDO

INSTRUCCIÓN READ(*,*)Ejemplo:

PROGRAM ejemplo_datos_entradaINTEGER::i,j,k,l; READ(*,*)i,j; READ(*,*)k,l

END PROGRAMSi los datos de entrada del programa son1,2,3,45,6,7,8

Los valores que leerá el programa soni=1,j=2,k=5, j=6

Instrucciones de entrada y salidaINTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

Se pueden escribir varias instrucciones en una sola línea separadas por ;


REFERENCIAS

CONTENIDO

INSTRUCCIÓN WRITE(*.*)Ejemplo:

PROGRAM ejemplo_datos_salidaINTEGER::ixLOGICAL::pruebaREAL::betaIx=1Prueba=.TRUE.Beta=3.141593

WRITE(*,*) ‘ ix = ’ , ix WRITE(*,*) ‘ beta = ’ , beta WRITE(*,*) ‘ coseno beta = ’ , COS(beta)WRITE(*,*) ‘ prueba = ’ , pruebaWRITE(*,*) REAL(ix), NINT (beta)

END PROGRAM

Instrucciones de entrada y salidaINTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Inicialización de variables

PROGRAM inicializacion

INTEGER::i

WRITE(*,*)i

END PROGRAM

El valor de i varía según el compilador, En LF90 las variables se inicializan en cero.

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

Siempre se deben de inicializar las variables


REFERENCIAS

CONTENIDO

Inicialización de variables


INTEGER::i

i= 1

WRITE(*,*)i

END PROGRAM


INTEGER::i

READ(*,*) i

WRITE(*,*)i

END PROGRAM


INTEGER::i=1

WRITE(*,*)i

END PROGRAM

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Diagrama de flujo

Entender el problema que se trata de resolver

inicio

Definir entradas y salidas

Diseño del algoritmo

Convertir el algoritmo en

instrucciones F90

Probar el programa

Fin

Descomposición

Refinamiento

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Diagramas de flujo

Indica el comienzo o final de un algoritmo

Indica un cálculo, el resultado del cálculo se le asigna a una variable

Indica una operación de entrada o salida

Indica un punto donde se escoge que hacer entre dos alternativas

Indica una referencia a un procedimiento

Indica la dirección del programa

Indica procesos iterativos

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Pseudocódigo

Ejemplo:

El usuario introduce un valor de temperatura en grados Fahrenheit

Leer temperatura en grados Fahrenheit (temp_F)

Temp_K en kelvin (5./9.)*(temp_F-32)+273.15

Escribir temperatura en Kelvin

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Estructuras de control

• La finalidad de las estructuras de decisión es la toma de decisiones

• Las estructuras de repetición permiten ejecutar sentencias cierto número de veces

ESTRUCTURAS DE REPETICIÓN

ESTRUCTURAS DE DECISIÓN

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

Las estructuras de control controlan el orden en que se van a ejecutar las instrucciones


REFERENCIAS

CONTENIDO

Estructuras de decisión

Estas instrucciones nos permiten seleccionar y ejecutar secciones específicas de código (llamadas bloques)

INSTRUCCIÓN IF – ELSE IF - ELSE

INSTRUCCIÓN SELECT CASE

INSTRUCCIÓN IF

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

ESTRUCTURAS DE DEC. CON NOMBRE


REFERENCIAS

CONTENIDO

Instrucción IF

ESTRUCTURA

DIAGRAMA DE FLUJO

EJEMPLO

IF (expresión lógica) THEN

Intrucción 1

Instrucción 2

.

.

.

END IF

Expresión lógica

Instrucción 1Instrucción 2

.TRUE.

.FALSE.PROGRAM prueba_3REAL::a=3,b=2

IF (a>b) THENWRITE(*,*) aEND IF

END PROGRAM

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

BLOQUE

Cuando solo se va a ejecutar una sola instrucción se puede escribir:

IF (exp_log) instrucción

PROGRAM prueba_3REAL::a=3,b=2

IF (a>b) WRITE(*,*) a

END PROGRAM

REGRESAR


REFERENCIAS

CONTENIDO

Instrucción IF – ELSE IF - ELSE

ESTRUCTURA

DIAGRAMA DE FLUJO

IF (expresión lógica 1 ) THENInstrucción 1Instrucción 2

ELSE IF (expresión logica 2) THENInstrucción 1Instrucción 2

ELSE Instrucción 1Instrucción 2

END IF

Expresión lógica 1

BLOQUE 1

.TRUE.

.FALSE. Expresión lógica 2

BLOQUE 2

.TRUE.

BLOQUE 3

.FALSE.

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓNEJEMPLO

REGRESAR


REFERENCIAS

CONTENIDO

Instrucción IF – ELSE IF - ELSEINTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR

PROGRAM roots

! Purpose:! This program solves for the roots of a quadratic equation ! Of the form a*x**2 + b*x + c = 0.IMPLICIT NONE

! Declare the variables used in this programREAL :: aREAL :: b REAL :: c REAL :: discriminantREAL :: imag_part REAL :: real_part REAL :: x1 REAL :: x2

! Prompt the user for the coefficients of the equationWRITE (*,*) 'This program solves for the roots of a quadratic 'WRITE (*,*) 'equation of the form A * X**2 + B * X + C = 0. 'WRITE (*,*) 'Enter the coefficients A, B, and C: 'READ (*,*) a, b, c

! Echo back coefficientsWRITE (*,*) 'The coefficients A, B, and C are: ', a, b, c

! Calculate discriminantdiscriminant = b**2 - 4. * a * c

! Solve for the roots, depending upon the value of the discriminantIF ( discriminant > 0. ) THEN ! there are two real roots, so...

x1 = ( -b + sqrt(discriminant) ) / ( 2. * a ) x2 = ( -b - sqrt(discriminant) ) / ( 2. * a ) WRITE (*,*) 'This equation has two real roots:' WRITE (*,*) 'X1 = ', x1 WRITE (*,*) 'X2 = ', x2

ELSE IF ( discriminant == 0. ) THEN ! there is one repeated root, so...

x1 = ( -b ) / ( 2. * a ) WRITE (*,*) 'This equation has two identical real roots:' WRITE (*,*) 'X1 = X2 = ', x1

ELSE ! there are complex roots, so ...

real_part = ( -b ) / ( 2. * a ) imag_part = sqrt ( abs ( discriminant ) ) / ( 2. * a ) WRITE (*,*) 'This equation has complex roots:' WRITE (*,*) 'X1 = ', real_part, ' +i ', imag_part WRITE (*,*) 'X2 = ', real_part, ' -i ', imag_part

END IF

END PROGRAM


REFERENCIAS

CONTENIDO

Instrucción SELECT CASE

SELECT CASE (case expresión)CASE(case selector 1)Instrucción 1Instrucción 2..CASE(case selector 2)Instrucción 1Instrucción 2..CASE DEFAULTInstrucción 1Instrucción 2..END SELECT

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

INTEGER,LOGICAL,CHARACTER

REGRESAR

El case DEFAULT es opcional, si se utiliza se ejecutará el bloque de instrucciones que le corresponde solo si el el valor de case_expresion esta fuera del rango de todos los case_selector


REFERENCIAS

CONTENIDO

Estructuras de decisión con nombre

Name: SELECT CASE (case expresión)CASE(case selector 1)Instrucción 1Instrucción 2..CASE(case selector 2)Instrucción 1Instrucción 2..CASE DEFAULTInstrucción 1Instrucción 2..END SELECT name

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

Name: IF (expresión lógica) THEN

Intrucción 1

Instrucción 2

.

.

.

END IF name

El nombre asignado debe de cumplir las características de los nombres en FORTRAN

REGRESAR


REFERENCIAS

CONTENIDO

Estructuras de Repetición

CICLOS ITERATIVOS

CICLOS CONDICIONADOS

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

Los ciclos permiten ejecutar una conjunto de sentencias más de una vez. Hay dos formas básicas para construir ciclos, los ciclos condicionados y los ciclos iterativos.

CICLOS CON NOMBRE


REFERENCIAS

CONTENIDO

Ciclos condicionados

ESTRUCTURA

DIAGRAMA DE FLUJO

DO……

IF (expresión lógica) EXIT…….

END DO

Instrucciones

Instrucciones

……………..

Instrucciones

Expresiónlógica

Instrucciones

Instrucciones

……………..

Instrucciones

.TRUE.

.FALSE.

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR

EJEMPLO


REFERENCIAS

CONTENIDO

Ciclos condicionadosINTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR

PROGRAM stats_1!! Purpose:! To calculate mean and the standard deviation of an input! data set containing an arbitrary number of input values.IMPLICIT NONE

! Declare and initialize the variables used in this program.INTEGER :: n =0 ! The number of input samples.REAL :: std_dev = 0. ! The standard deviation of the input samples.REAL :: sum_x = 0. ! The sum of the input values. REAL :: sum_x2 = 0. ! The sum of the squares of the input values. REAL :: x = 0. ! An input data value.REAL :: x_bar ! The average of the input samples.

! While Loop to read input values.DO ! Read in next value WRITE (*,*) 'Enter number: ' READ (*,*) x WRITE (*,*) 'The number is ', x

! Test for loop exit IF ( x < 0 ) EXIT ! Otherwise, accumulate sums. n = n + 1 sum_x = sum_x + x sum_x2 = sum_x2 + x**2END DO

! Calculate the mean and standard deviationx_bar = sum_x / real(n)std_dev = sqrt( (real(n) * sum_x2 - sum_x**2) / (real(n) * real(n-1)) )

! Tell user.WRITE (*,*) 'The mean of this data set is:', x_barWRITE (*,*) 'The standard deviation is: ', std_devWRITE (*,*) 'The number of data points is:', n

END PROGRAM


REFERENCIAS

CONTENIDO

Ciclos Iterativos

DO índice=valor inicial,valor final,incremento

Instrucción 1Instrucción 2Instrucción n

END DO

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

No deben usarse como índices variables reales

EJEMPLO

REGRESAR

CICLOS ANIDADOS


REFERENCIAS

CONTENIDO

Ciclos IterativosINTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR

PROGRAM stats_3!! Purpose:! To calculate mean and the standard deviation of an input! data set, where each input value can be positive, negative,! or zero.IMPLICIT NONE

! Declare the variables used in this program.INTEGER :: i ! Loop indexINTEGER :: n = 0 ! The number of input samples.REAL :: std_dev ! The standard deviation of the input samples.REAL :: sum_x = 0. ! The sum of the input values. REAL :: sum_x2 = 0. ! The sum of the squares of the input values. REAL :: x = 0. ! An input data value.REAL :: x_bar ! The average of the input samples.

! Get the number of points to input.WRITE (*,*) 'Enter number of points: 'READ (*,*) n

! Check to see if we have enough input data.IF ( n < 2 ) THEN ! Insufficient data

WRITE (*,*) 'At least 2 values must be entered.'

ELSE ! we will have enough data, so let's get it.

! Now calculate statistics. x_bar = sum_x / real(n) std_dev = sqrt((real(n)*sum_x2 - sum_x**2) / (real(n)*real(n-1)))

! Tell user. WRITE (*,*) 'The mean of this data set is:', x_bar WRITE (*,*) 'The standard deviation is: ', std_dev WRITE (*,*) 'The number of data points is:', n

END IF

END PROGRAM

! Loop to read input values. DO i = 1, n

! Read values WRITE (*,*) 'Enter number: ' READ (*,*) x WRITE (*,*) 'The number is ', x

! Accumulate sums. sum_x = sum_x + x sum_x2 = sum_x2 + x**2

END DO


REFERENCIAS

CONTENIDO

Ciclos AnidadosINTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR

PROGRAM ciclosInteger::i,j,producto do i=1,3

do j=1,3 producto=i*j write (*,*) i,’*’,j,’=‘,productoEnd doEnd do

End program


REFERENCIAS

CONTENIDO

Ciclos con nombreINTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR

Name: DO índice=valor inicial,valor final,incremento

Instrucción 1Instrucción 2Instrucción n

If (exp_logica) CYCLE name

END DO name

Name: DO……

IF (expresión lógica) EXIT name…….

END DO


REFERENCIAS

CONTENIDO

Instrucciones CYCLE y EXIT

Estas instrucciones pueden utilizarse para detener la ejecución de las sentencias dentro de ciclos condicionados o iterativos

CYCLE

EXIT

PROGRAM

INTEGER::I

DO I=1,5

IF (I==3) CYCLE

WRITE (*,*) I

END DO

END PROGRAM

PROGRAM

INTEGER::I

DO I=1,5

IF (I==3) EXIT

WRITE (*,*) I

END DO

END PROGRAM

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

La instrucción EXIT detiene la ejecución del bloque de instrucciones dentro de un ciclo y el control es transferido a la primera instrucción después del ciclo

La instrucción CYCLE cuando es ejecutada transfiere el control al inicio del ciclo


REFERENCIAS

CONTENIDO

Instrucción Format

Esta instrucción específica la manera exacta en la que las variables van a ser impresas por el programa

WRITE (*,100) i, resultado

100 FORMAT (‘El resultado de la iteración’ ,I3, ‘es’, F7.3)

Ejemplo:

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

Forma adicional de dar formato:

WRITE (*,’(1X,I6,F10.2)’)i,x

Character (len=20)::cadenaCadena=‘(1X,I6,F10.2)’Write (*,cadena)i,x


REFERENCIAS

CONTENIDO

Descriptores de Formato

Enteros: se utiliza el descriptor de formato I

rIw rIw.m

Reales: se utiliza el descriptor de formato F

rFw.d

Exponenciales: se utiliza el descriptor de formato E

rEw.dCaracteres: se utiliza el descriptor de formato A

rA rAw

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO


Símbolo significado

c Numero de columna

d Número de dígitos a la derecha del decimal

m Número mínimo de dígitos que se muestran

n Número de espacios

r Número de veces que se utilizará el formato

w Número de caractéres que se usarán en la salida para la ubicación de un dato

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Descriptores de Formato......ejemplos

REAL

INTEGER

CHARACTER

EXPONENCIALES

INTEGER:: i=-12, j=4, num= -12345

WRITE(*,100) i, i+12,j, num

100 FORMAT (' ',2i5,i6,i10)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

- 1 2 0 4 - 1 2 3 4 5

REAL:: a=-12.3, b=.123, c= 123.456

WRITE(*,300) a,b,c

300 FORMAT (' ',2F6.3,F8.3)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

* * * * * * 0 . 1 2 3 1 2 3 . 4 5 6

REAL:: a=1.2346E6 b=0.001, c= -77.7E10 d=-77.7E10

WRITE(*,1000) a,b,c,d

1000 FORMAT (' ',2E14.4,E13.6, E11.6)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

0 . 1 2 3 5 E + 0 7 0 . 1 0 0 0 E - 0 2

- 0 . 7 7 7 0 0 0 E + 1 2 * * * * * * * * * * *

CHARACTER(len=19):: cadena=‘esto es una cadena.’

WRITE(*,300) cadena

300 FORMAT (' ',A)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

e s t o e s u n a c a d e n a .

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

e s t o e s u n a c a d e n a .

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Descriptores X y T

El descriptor X inserta espacios

nX

n es el número de espacios que va a insertar

El descriptor T indica el número de columna donde se va a escribirTc

c es el número de columna

EJEMPLO

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Descriptores X y T

CHARACTER (LEN=10):: nombre='Ruth'CHARACTER (LEN=16):: apellido='Wilson'INTEGER:: edad=27CHARACTER (LEN=16):: ocupacion='estudiante' WRITE (*,100)nombre, apellido, edad, ocupacion100 FORMAT (1X,A7,1X,A7,4X,I3,T40,A10)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

R u t h W i l s o n 2 7

29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

e s t u d i a n t e

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO


Repetición de grupos de descriptores de formato:

330 FORMAT(1X,I6,F10.2,A, F10.2,A,I6,F10.2,A, F10.2,A)

330 FORMAT(1X,2(I6,2(F10.2,A)))

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Descriptor /

integer::indice=10REAL::tiempo=330,profundidad=330., amplitud= 850.65, fase=30.WRITE (*,100)indice,tiempo, profundidad, amplitud, fase

100 FORMAT ('1', T20,'Resultado de la prueba numero ',I3,///,&1X,'Tiempo =', F6.0/,&

1X,'Profundidad =', F7.1, ' metros',/& 1X,'Amplitud =', F8.2/,& 1X,'Fase =', F7.1)

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Instrucción OPEN

OPEN (open_list)Open_list contiene información sobre:

• Número de unidad

• Nombre de archivo

• Información sobre como abrir al archivo

Esta información va separada por comas

FILE

UNIT

ACTION

STATUS

IOSTAT

indica un número asociado al archivo

UNIT=int_exp (entero no negativo)

nombre del archivo que va a ser abierto

FILE= char_exp (char_exp contiene el nombre del archivo)

especifica la condición del archivo

STATUS=char_exp

Char_exp puede ser ‘OLD’, ‘NEW’,’REPLACE’,’UNKNOWN’

especifica si el archivo es abierto para lectura, escritura, o ambas

ACTION=char_exp

Char_exp puede ser ‘READ’, ‘WRITE’,’READWRITE’

especifica el nombre de una variable entera en la cual se regresa el valor de la condición de la operación OPEN

IOSTAT=int_val

Si IOSTAT= 0 la operación OPEN se realizó satisfactoriamente, de lo contrario regresara un número entero positivo correspondiente a un mensaje de error

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Apertura de archivos

LECTURA

ESCRITURA

EJEMPLO

Integer::i

OPEN(UNIT=8,FILE=‘ejemplo.dat’,STATUS=‘OLD’,ACTION=‘READ’, IOSTAT=i)OPEN(UNIT=unidad,FILE=‘datos_salida.dat’,STATUS=‘NEW’,ACTION=‘WRITE’, IOSTAT=i)

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Instrucción CLOSE

Esta instrucción cierra un archivo usando el número asociado a el archivo.

CLOSE(close_list)

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Arreglos

MATRICES

VECTORES

Un arreglo es un grupo de variables o constantes todas del mismo tipo, que tienen el mismo nombre. Los valores en el grupo ocupan lugares consecutivos en la memoria de la computadora.

Los elementos de un arreglo se identifican con un subíndice de tipo entero que señala la posición de este dentro del arreglo

A(1)

A(2)

A(3)

A(4)

Arreglo A

Elemento del arreglo

Memoria de la

computadora

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓNOPERACIONES

CONARREGLOS

ARREGLOSALLOCATABLE


REFERENCIAS

CONTENIDO

Vectores

INICIALIZACIÓN

DECLARACIÓN

ARREGLOS CONSTANTES

Renglón 1

Renglón 2

Renglón 3

Renglón 4

A(renglones)

Se debe de indicar el número de elementos del arreglo:

REAL, DIMENSION (16)::presión

Rank del arreglo

extent

Rank = 1, extent=16

REAL, DIMENSION(10)::A

DO i=1,10

A(i)=0

END DO

A=(/0,0,0,0,0,0,0,0,0,0/)

A=0;

Los elementos de este tipo de arreglo son valores constantes

A=(/1,2,3,4,5/)

Constructores de arreglos

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR

DOIMPLÍCITOS

EJEMPLOS


REFERENCIAS

CONTENIDO

Ciclos DO implícitos

Estos ciclos permiten escribir o leer una lista de argumentos en función de un contador

WRITE (*,100) (A(i),i=1,5)

Ciclos anidados:

WRITE (*,100) ((i,j,j=1,3),i=i,2)

Inicialización:

integer, dimension(5)::arreglo1=(/(i,i=1,5)/)

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR


REFERENCIAS

CONTENIDO

Ciclos DO implícitosVectores …….ejemplos

PROGRAM squares

IMPLICIT NONE

INTEGER :: iINTEGER, DIMENSION(10) :: number, square ! Initialize number and calculate square.DO i = 1, 10 number(I) = i ! Initialize number square(i) = number(i)**2 ! Calculate square END DO ! Write out each number and its square.DO i = 1, 10 WRITE (*,100) number(i), square(i) 100 FORMAT (1X,'Number = ',I6,' Square = ',I6)END DO END PROGRAM

PROGRAM square_roots IMPLICIT NONE INTEGER :: iREAL, DIMENSION(10) :: value = (/ (i, i=1,10) /) REAL, DIMENSION(10) :: square_root

! Calculate the square roots of the numbers.DO i = 1, 10 square_root(i) = SQRT(value(i))END DO

! Write out each number and its square root.DO i = 1, 10 WRITE (*,100) value(i), square_root(i) 100 FORMAT (1X,'Value = ',F5.1,' Square Root = ',F10.4)END DO

END PROGRAM

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Ciclos DO implícitosVectores …….ejemplos

PROGRAM square_and_cube_roots!! Purpose:! To calculate a table of numbers, square roots, and cube roots! using an implied DO loop to output the table.!! Record of revisions:! Date Programmer Description of change! ==== ========== =====================! 08/22/95 S. J. Chapman Original code!IMPLICIT NONE

! List of parameters:INTEGER, PARAMETER :: max_size = 10

! List of variables:INTEGER :: j ! Loop indexREAL, DIMENSION(max_size) :: value ! Array of numbersREAL, DIMENSION(max_size) :: square_root ! Array of square rootsREAL, DIMENSION(max_size) :: cube_root ! Array of cube roots

! Calculate the square roots & cube roots of the numbers.DO j = 1, max_size value(j) = real(j) square_root(j) = sqrt(value(j)) cube_root(j) = value(j)**(1./3.)END DO

! Write out each number, its square root, and its cube root.WRITE (*,100) 100 FORMAT ('0',20X,'Table of Square and Cube Roots',/, & 4X,' Number Square Root Cube Root', & 3X,' Number Square Root Cube Root',/, & 4X,' ====== =========== =========', & 3X,' ====== =========== =========')WRITE (*,110) (value(j), square_root(j), cube_root(j), j = 1, max_size)110 FORMAT (2(4X,F6.0,9X,F6.4,6X,F6.4)) END PROGRAM

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR


REFERENCIAS

CONTENIDO

Ciclos DO implícitosMatrices

Renglón 1

Renglón 2

Renglón 3

Renglón 4

Col1 Col2 Col3 Col4

B(renglones, columnas)

Matriz

DECLARACIÓN

INICIALIZACIÓN

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR


REFERENCIAS

CONTENIDO

Ciclos DO implícitosDeclaración de arreglos

Se debe de indicar el número de elementos del arreglo:

REAL, DIMENSION (3,6)::presión

INTEGER, DIMENSION (0:100,0:20)::SAT

REGRESAR

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Ciclos DO implícitosInicialización de matrices

INSTRUCCIONES DE

ASIGNACIÓN

INSTRUCCIONESDE

DECLARACIÓN

INSTRUCCIONESDE

LECTURA

INTEGER, DIMENSION (4,3)::SAT

DO I=1,4

DO J=1,3

SAT (I,J)=J

END DO

END DO

INTEGER, DIMENSION (4,3)::SAT(4,3)=&

RESHAPE((/1,1,1,1,2,2,2,2,3,3,3,3/),(/4,3/)

La función RESHAPE cambia la forma de la matriz, su estructura es:

Matriz=RESHAPE (arreglo1,arreglo2)

INTEGER, DIMENSION (4,3)::SAT(4,3)

Integer:: i, j

OPEN (7,FILE=‘DATOS_INICIO.DAT’,STATUS=‘OLD’,ACTION=‘read’)

READ(7,*)((SAT(I,J),J=1,3),I=1,4)

REGRESAR

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Ciclos DO implícitosArreglos con asignación dinámica de memoria

Un arreglo que utiliza memoria dinámica se declara utilizando la instrucción ALLOCATABLE:

REAL, ALLOCATABLE,DIMENSION(:,:)::A

Para especificar el tamaño se utiliza la instrucción ALLOCATE:

ALLOCATE (a(100,100))

Para liberar la memoria que ocupa el arreglo se utiliza la instrucción DEALLOCATE:

DEALLOCATE(a)

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR


REFERENCIAS

CONTENIDO

Ciclos DO implícitosOperaciones con arreglos

El argumento de estas funciones es un escalar, estas funciones pueden aplicarse a los argumentos de los arreglos

Real, dimension::x=(/0.,3.14,1.,2./)Real, dimension (4)::yInteger::i

Y=sin(x)

Do i=1,4Y(i)=sin(x(i))End do

Funciones intrínsecas: ABS,SIN,COS,TAN,EXP,LOG,LOG10,MOD,SQRT

FUNCIONES INTRÍNSECAS (ELEMENTALES)

FUNCIONES INTRÍNSECAS (INDAGACIÓN)

FUNCIONESTRANSFORMACIONALES

El valor de este tipo de funciones depende de las propiedades del arreglo:

Funciones intrínsecas de indagación:

•ALLOCATE (ARREGLO)•LBOUND•SHAPE•SIZE•UBOUND

Una función de este tipo transforma un arreglo en un resultado escalar o en otro arreglo.

Funciones transformacionales:

•MAXVAL•MINLOC•MINVAL•PRODUCT•RESHAPE•SUM•TRANSPOSE

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR

OPERACIONES ENTODOS LOS ELEMENTOS

Si los arreglos tienen la misma forma se pueden hacer operaciones aritméticas:PROGRAM add_arrays

IMPLICIT NONE

INTEGER :: iREAL, DIMENSION(4) :: a = (/ 1., 2., 3., 4./) REAL, DIMENSION(4) :: b = (/ 5., 6., 7., 8./) REAL, DIMENSION(4) :: c, d

! Element by element additionDO i = 1, 4 c(i) = a(i) + b(i)END DO

! Whole array additiond = a + b

! Write out resultsWRITE (*,100) 'c', cWRITE (*,100) 'd', d100 FORMAT (' ',A,' = ',5(F6.1,1X))

END PROGRAM

Escalares con arreglos:RE.al, DIMENSION(4) :: a = (/ 1., 2., 3., 4./),creal ::b=10C=b*a

EJEMPLO


REFERENCIAS

CONTENIDO

Ciclos DO implícitosOperaciones con arreglosINTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR

PROGRAM check_array!! Purpose:! To illustrate the use of array inquiry functions. !!IMPLICIT NONE

! List of variables:REAL,DIMENSION(-5:5,0:3) :: a = 0. ! Array to examine

! Get the shape, size, and bounds of the array.WRITE (*,100) SHAPE(a)100 FORMAT (1X,'The shape of the array is: ',7I6)

WRITE (*,110) SIZE(a)110 FORMAT (1X,'The size of the array is: ',I6)

WRITE (*,120) LBOUND(a)120 FORMAT (1X,'The lower bounds of the array are: ',7I6)

WRITE (*,130) UBOUND(a)130 FORMAT (1X,'The upper bounds of the array are: ',7I6) END PROGRAM


REFERENCIAS

CONTENIDO

Ciclos DO implícitosSecciones de arreglosINTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR


REFERENCIAS

CONTENIDO

Procedimientos

PROCEDIMIENTOS INTERNOS

PROCEDIMIENTOS EXTERNOS

MÓDULOS

INTERFACES

PROCEDIMIENTOS RECURSIVOS

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Procedimiento interno y externo

FUNCIONES

SUBRUTINAS

Una subrutina es un programa FORTRAN que es solicitado con la instrucción CALL y que recibe valores de entrada y regresa resultados mediante el argumento. La forma general de una subrutina es:

SUBROUTINEsubroutine_name(argument_list)

Sección de declaración

Sección de ejecución

RETURN

END SUBROUTINE

Para llamar a una subrutina se utiliza la instrucción CALL:

CALL subroutine_name(argument_list)

EJEMPLO SUBRUTINA

REGRESAR

Las funciones son programas FORTRAN que toman un conjunto de variables de entradas y regresan un solo valor de algún tipo en una variable del mismo nombre de la función. El tipo de la función debe ser igual al tipo de dato de salida de la función:

La forma general de una función definida por el usuario es:

tipo FUNCTION function_name(argument_list)Sección de declaraciónSección de ejecuciónRETURNEND FUNCTION

EJEMPLO FUNCIÓN

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

ATRIBUTO INTENT

SAVE

ARREGLOS EN FUNCIONESY SUBRUTINAS


REFERENCIAS

CONTENIDO

IntentINTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

• INTENT (IN)

El argumento es dato de entrada• INTENT (OUT)

El argumento es dato de salida• INTENT (INOUT)

El argumento actúa como entrada y salida

REGRESAR


REFERENCIAS

CONTENIDO

Subrutinas

PROGRAM test_hypotenuseIMPLICIT NONE! Declare variables:REAL :: s1 ! Length of side 1REAL :: s2 ! Length of side 2REAL :: hypot ! Hypotenuse.WRITE (*,*) 'Program to test subroutine WRITE (*,*) 'Enter the length of side 1: 'READ (*,*) s1WRITE (*,*) 'Enter the length of side 2: 'READ (*,*) s2

CALL calc_hypotenuse ( s1, s2, hypot )

WRITE (*,1000) hypot1000 FORMAT (1X,'The length of the hypotenuse is: ', F10.4 ) END PROGRAM

SUBROUTINE calc_hypotenuse ( side_1, side_2, hypotenuse )

IMPLICIT NONE

! Declare calling parameters:REAL, INTENT(IN) :: side_1 ! Length of side 1.REAL, INTENT(IN) :: side_2 ! Length of side 2.REAL, INTENT(OUT) :: hypotenuse ! Length of hypotenuse

! Declare local variables:REAL :: temp ! Temporary variable

! Calculate hypotenusetemp = side_1**2 + side_2**2hypotenuse = SQRT ( temp )

END SUBROUTINE

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

REGRESAR


REFERENCIAS

CONTENIDO

Pasando arreglos a subrutinasINTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓNARREGLOS ALLOCATABLE

ARREGLOS AUTOMÁTICOS

Pasa la extensión de los arreglos como argumento a la subrutina

Subroutine proceso(x,y,n,m)

Integer, intent (in)::x,y

Real, intent (in), dimension(n,m)::d1

Real, intent (out), dimension(n,m)::d2

Real, dimension(n,m)::temp

Temp=0.

End subroutine

Subroutine proceso(x,y)

Real,dimension(:,:),allocatable::tempAllocate (temp(1000,1000))

REGRESAR


REFERENCIAS

CONTENIDO

SAVEINTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓNINSTRUCCIÓN SAVE

ATRIBUTO SAVE

Los valores de las variables locales son indefinidos al salir de una subrutina o función.

El atributo SAVE garantiza que las variables y arreglos locales conserven su valor. Este atributo aparece en la declaración del tipo de dato.

REAL, SAVE:: suma

La Instrucción no ejecutable SAVE conserva todos los valores de las variables locales, su formato es:

SAVE::var1, var2

o

SAVE

REGRESAR

No debe usarse el atributo SAVE en arreglos automáticos, ni en datos declarados con el atributo PARAMETER


REFERENCIAS

CONTENIDO

Funciones

PROGRAM test_quadfIMPLICIT NONE REAL :: quadf ! Declare functionREAL :: a, b, c, x ! Declare local variables

! Get input data.WRITE (*,*) 'Enter quadratic coefficients a, b, and c: 'READ (*,*) a, b, cWRITE (*,*) 'Enter location at which to evaluate equation: 'READ (*,*) x ! Write out result.WRITE (*,100) ' quadf(', x, ') = ', quadf(x,a,b,c)100 FORMAT (A,F10.4,A,F12.4)

END PROGRAM

REAL FUNCTION quadf ( x, a, b, c )

IMPLICIT NONE

! Declare calling arguments.REAL, INTENT(IN) :: x REAL, INTENT(IN) :: a REAL, INTENT(IN) :: b REAL, INTENT(IN) :: c

! Evaluate expression.quadf = a * x**2 + b * x + c

END FUNCTION

REGRESAR

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Procedimientos internos

Los procedimientos internos van dentro de una unidad de programa

Los procedimientos internos van dentro y al final de una unidad de programa precedidos por la instrucción CONTAINS

Tienen la misma forma que los procedimientos externos, excepto que la palabra SUBROUTINE/FUNCTION debe estar presente en la instrucción END

EJEMPLO

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Procedimiento interno y externo

program pruebaINTEGER:: i=3,j=25write (*,*) 'La divisison es', ratio(i,j)

contains

REAL function ratio (x,y)REAl,intent (IN)::x,yratio=x/yend function

end program

program pruebaINTEGER:: i=3,j=25write (*,*) 'La divisison es', ratio(i,j)

end program

REAL function ratio (x,y)REAl,intent (IN)::x,yratio=x/yend function

REGRESAR

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Módulos

Los módulos nos permiten:

• Inicializar datos• Compartir datos en ejecución (Instrucción USE

name_modulo ) en otras unidades de programas• Incluir subrutinas y funciones

Para usar los valores de los módulos , en el programa principal se debe de declarar el nombre del módulo con la instrucción USE, la forma de la instrucción USE es:

USE module_name

Esta instrucción debe aparecer antes de cualquier otra instrucción excepto PROGRAM o SUBROUTINE

MÓDULOS PARA DECLARACIÓN

DE DATOS

MÓDULOS CON

PROCEDIMIENTOS

REGRESAR

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Módulos

La forma general de un módulo para intercambiar datos es:

MODULE prueba

IMPLICIT NONE

SAVE

INTEGER, Parameter::num_vals=5

REAL, DIMENSION(num_vals)::valores

END MODULE

La instrucción SAVE garantiza que se mantendrán los valores de los datos declarados en el módulo.

EJEMPLO

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Módulos

REGRESAR

PROGRAM test_module!! Purpose:! To illustrate sharing data via a module.!USE test ! Make data in module "test" visibleIMPLICIT NONE

REAL, PARAMETER :: pi = 3.141592 ! Pi

values = pi * (/ 1., 2., 3., 4., 5. /)

CALL sub1 ! Call subroutine

END PROGRAMSUBROUTINE sub1!! Purpose:! To illustrate sharing data via a module.!USE test ! Make data in module "test" visibleIMPLICIT NONE

WRITE (*,*) values

END SUBROUTINE sub1• MODULE test• !• ! Purpose:• ! To declare data to share between two routines.

• IMPLICIT NONE• SAVE

• INTEGER, PARAMETER :: num_vals = 5 ! Max number of values in array• REAL, DIMENSION(num_vals) :: values ! Data values

END MODULE test

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Módulos

Son módulos que contienen subrutinas y funciones, los procedimientos que sean incluidos dentro de un modulo debe ser precedidos por la instrucción CONTAINS

La forma general de un módulo para intercambiar datos es:

MODULE prueba

IMPLICIT NONE

CONTAINSSUBROUTINE sub1

.

.

.

END SUBROUTINE sub_1

END MODULE

El nombre de la subrutina o función siempre debe de especificarse en el END SUBROUTINE o END FUNCTION

EJEMPLO

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Módulos

Ejemplo:

MODULE my_subsCONTAINS SUBROUTINE bad_argument ( i ) IMPLICIT NONE INTEGER, INTENT(IN) :: i ! Declare argument as integer. WRITE (*,*) ' I = ', i ! Write out i. END SUBROUTINEEND MODULE

PROGRAM bad_call!! Purpose:! To illustrate misinterpreted calling arguments.!USE my_subsIMPLICIT NONEREAL :: x = 1. ! Declare real variable x.CALL bad_argument ( x ) ! Call subroutine.END PROGRAM

REGRESAR

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Interfases

REGRESAR

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

IMPLÍCITAS

EXPLÍCITAS Una referencia a un módulo o subprograma interno se considera una interfase explícita, el compilador puede ver todos los detalles.

Una referencia a un procedimiento externo se realiza usualmente por una interface implícita, el compilador asume los detalles.

Se puede suministrar una interface explícita mediante un bloque de interface.

La forma general de una interface es:

INTERFACE

Interface_body_1

Interface_body_2

…….

END INTERFACE

EJEMPLO

INTERFACES EN MÓDULOS

MODULE name_module

INTERFACE

subroutine1 ….

…………

end subroutine1

subroutineN ….

…………

end subroutine n

END INTERFACE

END MODULE


REFERENCIAS

CONTENIDO

Interfaces

REGRESAR

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

SUBROUTINE sort (arr, n)IMPLICIT NONEREAL, DIMENSION(*), INTENT(INOUT) :: arr ! Array to be sortedINTEGER, INTENT(IN) :: n ! Number of values

INTEGER :: i ! Loop indexINTEGER :: iptr ! Pointer to smallest valueINTEGER :: j ! Loop indexREAL :: temp ! Temp variable for swaps ! Sort the arrayouter: DO i = 1, n-1 ! Find the minimum value in arr(I) through arr(N) iptr = i inner: DO j = i+1, n minval: IF ( arr(j) < arr(iptr) ) THEN iptr = j END IF minval END DO inner swap: IF ( i /= iptr ) THEN temp = arr(i) arr(i) = arr(iptr) arr(iptr) = temp END IF swap END DO outer END SUBROUTINE sort

PROGRAM interface_exampleIMPLICIT NONE

! Declare interface to subroutine "sort"INTERFACE SUBROUTINE sort(a,n) IMPLICIT NONE REAL, DIMENSION(:), INTENT(INOUT) :: a INTEGER, INTENT(IN) :: n END SUBROUTINE sortEND INTERFACE

! Declare local variablesREAL, DIMENSION(6) :: array = (/ 1., 5., 3., 2., 6., 4. /)INTEGER :: nvals = 6

! Call "sort" to sort data into ascending order.CALL sort ( N=nvals, A=array)

! Write out sorted array.WRITE (*,*) array

END PROGRAM


REFERENCIAS

CONTENIDO

Procedimientos Recursivos

EJEMPLO

Una procedimiento recursivo es aquel que se llama a si mismo directa o indirectamente, debe de declararse RECURSIVE. Una función recursiva requiere usar una variable de nombre RESULT

RESULT permite que una función devuelva el valor de una variable cuyo nombre es distinto de la función.

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

Procedimientos Recursivos

REGRESAR

program recIMPLICIT NONEINTEGER ::i=5,reswrite (*,*)'El factorial de ', i,'es', fact(i)pausecontains

RECURSIVE FUNCTION fact(n) RESULT(res)IMPLICIT NONEINTEGER, INTENT(IN) :: nINTEGER :: resIF (n == 1) THENres = 1ELSEres = n * fact(n - 1)END IFEND FUNCTION fact

end program

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN


REFERENCIAS

CONTENIDO

CompilaciónINTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

Los archivos creados al compilar un archivo de FORTRAN 90 son cinco -.map,.f90, .obj,.exe,.bak

Al guardar un programa se debe de Indicar el nombre del archivo y suExtensión (f90 o f95).

La compilación puede realizarse desdeMS-DOS desde el directorio donde se Encuentre el programa por medio delComando LF95:

C:/>LF95 nombre de archivo.ext

Después de la compilación se creaUn archivo ejecutable con el mismo Nombre que puede ser ejecutado con:

C:/> nombre de archivo


REFERENCIAS

CONTENIDO

R e f e r e n c i a s

Curso de FORTRAN – Politécnico

Apuntes de FORTRAN – FI

Apuntes de fortran – OSC

Apuntes de FORTRAN – UCM

Fortran_web1

Fortran _web2

Fortran _web3

Fortran _web4

Fortran _web5

INTRODUCCIÓN

ELEMENTOS BÁSICOS




PROGRAMACIÓN

ESTRUCTURADA

ARREGLOS


COMPILACIÓN

Fortran 90/95 for Scientists and Engineers, Chapman, McGraw-Hill

curso fortran actualizado

Documents