Upload
yoleidacr
View
6
Download
0
Embed Size (px)
DESCRIPTION
Aplicación del programa Fortran
Citation preview
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
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
Programación en Fortran 90
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%)
Programación en Fortran 90
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
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Programación en Fortran 90
REFERENCIAS
CONTENIDO
INTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
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
Programación en Fortran 90
REFERENCIAS
CONTENIDO
IntroducciónINTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Forma de escritura del código fuente
7-72
FORMA LIBRE
FORMA FIJA
7-721-132
INTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
La forma de escritura fija es obsoleta
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Estructura de un programa FORTRAN
DECLARACIÓN
EJECUCIÓN
TERMINACIÓN
INTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
REGRESAR
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
REGRESAR
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Los cálculos son realizados en FORTRAN con instrucciones de asignación:
Variable_name=expression
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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))
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
teclado
Formato libre
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Se pueden escribir varias instrucciones en una sola línea separadas por ;
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Siempre se deben de inicializar las variables
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Inicialización de variables
PROGRAM inicializacion
INTEGER::i
i= 1
WRITE(*,*)i
END PROGRAM
PROGRAM inicializacion
INTEGER::i
READ(*,*) i
WRITE(*,*)i
END PROGRAM
PROGRAM inicializacion
INTEGER::i=1
WRITE(*,*)i
END PROGRAM
INTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Las estructuras de control controlan el orden en que se van a ejecutar las instrucciones
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
ESTRUCTURAS DE DEC. CON NOMBRE
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓNEJEMPLO
REGRESAR
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Instrucción IF – ELSE IF - ELSEINTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Estructuras de Repetición
CICLOS ITERATIVOS
CICLOS CONDICIONADOS
INTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
REGRESAR
EJEMPLO
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Ciclos condicionadosINTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
No deben usarse como índices variables reales
EJEMPLO
REGRESAR
CICLOS ANIDADOS
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Ciclos IterativosINTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Ciclos AnidadosINTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Ciclos con nombreINTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Descriptores de Formato
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Descriptores de Formato
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓNOPERACIONES
CONARREGLOS
ARREGLOSALLOCATABLE
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
REGRESAR
DOIMPLÍCITOS
EJEMPLOS
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
REGRESAR
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
REGRESAR
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
REGRESAR
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
REGRESAR
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Ciclos DO implícitosOperaciones con arreglosINTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Ciclos DO implícitosSecciones de arreglosINTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
REGRESAR
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Ciclos DO implícitosSecciones de arreglosINTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
REGRESAR
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Ciclos DO implícitosSecciones de arreglosINTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
REGRESAR
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Procedimientos
PROCEDIMIENTOS INTERNOS
PROCEDIMIENTOS EXTERNOS
MÓDULOS
INTERFACES
PROCEDIMIENTOS RECURSIVOS
INTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
ATRIBUTO INTENT
SAVE
ARREGLOS EN FUNCIONESY SUBRUTINAS
Programación en Fortran 90
REFERENCIAS
CONTENIDO
IntentINTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
REGRESAR
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Pasando arreglos a subrutinasINTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
REFERENCIAS
CONTENIDO
SAVEINTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Interfases
REGRESAR
INTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
REFERENCIAS
CONTENIDO
Interfaces
REGRESAR
INTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Programación en Fortran 90
REFERENCIAS
CONTENIDO
CompilaciónINTRODUCCIÓN
ELEMENTOS BÁSICOS
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
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
Programación en Fortran 90
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
DISEÑO DE PROGRAMAS
LECTURA / ESCRITURACON FORMATO
ESTRUCTURAS DE CONTROL
PROGRAMACIÓN
ESTRUCTURADA
ARREGLOS
LECTURA / ESCRITURADE UN ARCHIVO
COMPILACIÓN
Fortran 90/95 for Scientists and Engineers, Chapman, McGraw-Hill