Fortran 90 Para Principiantes

ESCUELA SUPERIOR POLITECNICA DEL LITORAL FACULTAD DE INGENIERIA MARITIMA Y CIENCIAS DEL MAR PROGRAMACION PROGRAMACION APLICADA 1

Presenta Presentación ción............................... ................................................ .................................. ................................. .................................. ................................. ............... 5 1.0 Programación básica con FORTRAN ...................................................................... 6 1.1 Etapas para la la preparación de un programa programa ................... .......... ................... ................... .................. ................... ............ 6 1.2 Programa fuente .................................................................................................. 6 1.2.1 Formatos para código fuente fuente y límites del programa pro grama ................... ......... ................... .................. ......... 6 1.2.2 Esquema Esquema básico de un programa programa típico en Fortran .................. ......... ................... ................... ............ ... 7 1.2.3 Caracteres indicadores .................................................................................. 7 1.2.4 Variables y expresiones matemáticas ............................................................ 8 1.2.5 Formatos numéricos numéricos y alfanuméricos .................. ......... ................... ................... .................. ................... .............. .... 9 1.3 Declaraciones básicas .......................................................................................... 9 1.3.1 OPEN ................................. ................................................. ................................. ................................. .................................. ......................... ....... 9 1.3.2 CLOSE CLOSE .................................. .................................................. ................................. .................................. ................................. ................... ... 10 1.3.3 READ - WRITE ......................................................................................... 11 1.3.4 IF.......................... IF.......................................... ................................. .................................. ................................. ................................. .................... ... 11 1.3.5 DO ............................... ................................................ .................................. ................................. ................................. ............................ ........... 12 1.3.6 DO WHILE WHILE ............................... ................................................. ................................... ................................. .............................. .............. 12 1.3.7 SELECT CASE .......................................................................................... 12 1.3.8 WHERE WHERE ............................... ................................................ .................................. .................................. ................................. ................... ... 13 1.4 Funciones implícitas .......................................................................................... 13 2.0 Vectores y Matrices............................................................................................... 13 2.1 Declaración y disposiciones de memoria ........................................................... 14 2.1.1 Vectores Vectores ............................... ................................................ .................................. .................................. ................................. ................... ... 14 2.1.2 Matrices..... Matrices..................... ................................. .................................. .................................. ................................. .............................. .............. 16 2.2 Dimensionamiento dinámico ............................................................................. 20 2.2.1 Punteros Punteros................ ................................. ................................. ................................. .................................. ................................. ................... ... 20 2.2.2 Alojamiento de memoria............................................................................. 22 2.2.3 Arreglos Automáticos ................................................................................. 23 2.2.4 Ejercicios de aplicación .............................................................................. 23 2.3 Almacenamiento por defecto en FORTRAN...................................................... 24 3.0 Tipos derivados de datos ....................................................................................... 25 3.1 Generali Generalidades dades............................................... ............................................................... .................................. ................................... ..................... 25 3.2 Ejemplos Ejemplos ............................... ................................................. .................................. ................................. .................................. ......................... ........ 26 4.0 El ambiente de trabajo t rabajo “Developer Studio” ............................... ................................................ ............................ ........... 28 4.1 Iniciando un proyecto ........................................................................................ 29 4.2 Ejemplos Ejemplos ............................... ................................................. .................................. ................................. .................................. ......................... ........ 31 5.0 Subprogramas, creación y usos .............................................................................. 34

-1-


5.1 Subrutin Subrutinas as ................................. ................................................. ................................. ................................. .................................. ....................... ..... 34 5.1.1 Definici Definición.................. ón................................... .................................. .................................. ................................. .............................. .............. 34 5.1.2 Ejemplo Ejemplo ................................. ................................................. ................................. .................................. ................................. ................... ... 34 5.2 Módulos Módulos ................................. .................................................. ................................. ................................. .................................. ......................... ........ 35 5.2.1 Definici Definición.................. ón................................... .................................. .................................. ................................. .............................. .............. 35 5.2.2 Ejemplo Ejemplo ................................. ................................................. ................................. .................................. ................................. ................... ... 36 5.3 Funcione Funcioness .............................. ................................................ .................................. ................................. .................................. ......................... ........ 38 5.3.1 Definici Definición.................. ón................................... .................................. .................................. ................................. .............................. .............. 38 5.3.2 Ejemplo Ejemplo ................................. ................................................. ................................. .................................. ................................. ................... ... 38 5.4 Interfa Interfaces.......... ces.......................... ................................. .................................. ................................. ................................. ............................... .............. 39 5.4.1 Definici Definición.................. ón................................... .................................. .................................. ................................. .............................. .............. 39 6.0 Librerías, creación y usos ...................................................................................... 40 6.1 Librerías Estáticas (Static Libraries) .................................................................. 40 6.1.1 Definiciones ............................................................................................... 40 6.1.2 Forma de usar ............................................................................................. 40 6.2 Librerías dinámicas (Dynamic Link Libraries)................................................... 41 6.2.1 Definiciones ............................................................................................... 41 6.2.2 Forma de usar ............................................................................................. 41 6.2.3 Ejemplo Ejemplo ................................. ................................................. ................................. .................................. ................................. ................... ... 42 7.0 Personalización de programas ............................................................................... 44 7.1 Generali Generalidades dades............................................... ............................................................... .................................. ................................... ..................... 44 7.2 Propiedades de la ventana .................................................................................. 44 7.3 Creación de múltiples ventanas.......................................................................... 44 7.4 Graficación y escritura en la pantalla ................................................................. 45 7.5 Insertando imágenes .......................................................................................... 47 7.6 Mensajes de aviso ............................................................................................. 47 7.7 Personalizar el menú de opciones ...................................................................... 48 7.8 Iconos de programas .......................................................................................... 50 7.9 Eventos del ratón ............................................................................................... 51 7.9.1 Funciones basadas en eventos ..................................................................... 51 7.9.2 Ejemplo Ejemplo ................................. ................................................. ................................. .................................. ................................. ................... ... 52 7.9.3 Funciones Funciones de bloqueo de ejecución ejecución .................. ......... ................... ................... .................. ................... ............... ..... 53 7.9.4 Ejemplo Ejemplo ................................. ................................................. ................................. .................................. ................................. ................... ... 53 7.10 Cuadros de diálogo personalizados .................................................................. 54 7.10.1 Agregar Agregar controles al cuadro de diálogo: diálogo: .................. ......... ................... ................... .................. ............... ...... 55 8.0 Gráficos en Visual Fortran .................................................................................... 62 8.1 Array Visualizer ................................................................................................ 62

-2-


8.1.1 Generalidades ............................................................................................. 62 8.1.2 Descripción ................................................................................................ 62 8.1.3 Sintaxis........ Sintaxis......................... .................................. ................................. .................................. .................................. ........................... ........... 63 8.1.4 Ejemplo Ejemplo ................................. ................................................. ................................. .................................. ................................. ................... ... 64 8.2 Librería Plot88 .................................................................................................. 65 8.2.1 Generalidades ............................................................................................. 65 8.2.2 Etapas del proceso de graficación ............................................................... 66 8.2.3 Sintaxis de cada subrutina ........................................................................... 66 8.2.4 Ejemplo Ejemplo ................................. ................................................. ................................. .................................. ................................. ................... ... 68 8.3 CVFGraf CVFGraf ............................... ................................................. .................................. ................................. .................................. ......................... ........ 70 8.3.1 Generalidades ............................................................................................. 70 8.3.2 Codificación y subrutinas ........................................................................... 71 8.3.3 Ejemplo Ejemplo ................................. ................................................. ................................. .................................. ................................. ................... ... 72 8.4 DXFortran DXFortran............................................ ............................................................ ................................. ................................. ............................ ............ 73 8.4.1 Generalidades ............................................................................................. 73 8.4.2 Forma de uso .............................................................................................. 74 8.4.3 Descripción de subrutinas ........................................................................... 74 8.4.4 Ejemplo Ejemplo ................................. ................................................. ................................. .................................. ................................. ................... ... 76 9.0 Librerías IMSL en Fortran ..................................................................................... 78 9.1 Generali Generalidades dades............................................... ............................................................... .................................. ................................... ..................... 78 9.2 Uso de la Librería desde desde Visual Fortran .................. ......... ................... ................... .................. ................... ............... ..... 78 9.3 Ejemplo Ejemplo ............................... ................................................ .................................. ................................. ................................. ............................ ........... 78 10.0 Aplicaciones Utiles ............................................................................................. 80 10.1 Creación de archivos de ayuda......................................................................... 80 10.2 Abrir y guardar un archivo desde el menú ................... .......... ................... ................... .................. .................. ......... 81 10.3 Presentación de una tabla ................................................................................. 83 10.3 Rutina de intercambio CVFDif ........................................................................ 86 10.5 Ventanas virtuales amplias .............................................................................. 91 10.6 Resolución Resolución de sistemas de ecuaciones lineales ................... ......... ................... .................. ................... .............. 92 10.6.1 Resolución Numérica ................................................................................ 92 10.6.2 Métodos de resolución .............................................................................. 93 10.6.3 Ejercicio de aplicación .............................................................................. 98 11.0 Normas 11.0 Normas Europeas para escribir escribir y documentar documentar códigos fuente fuente en Fortran 90 90 ....... 100 11.1 Documentación ............................................................................................. 100 11.1.1 Documentación Externa .......................................................................... 100 11.1.2 Documentación Interna ........................................................................... 100 11.2 Obsolescencias de otras versiones.................................................................. 101

-3-

ESCUELA SUPERIOR POLITECNICA DEL LITORAL FACULTAD DE INGENIERIA MARITIMA Y CIENCIAS DEL MAR PROGRAMACION APLICADA 1

11.3 Reglas básicas de codificación ....................................................................... 101 11.4 Encabezados para programas y subprogramas................................................ 102 11.4.1 Programas principales ............................................................................. 102 11.4.2 Subrutinas ............................................................................................... 103 11.4.3 Funciones ............................................................................................... 104 11.4.4 Módulos ................................................................................................. 105 12.0 Ejercicios Propuestos ........................................................................................ 107 Referencias ............................................................................................................... 117

-4-


Presentación El presente texto guía, resume algunos aspectos fundamentales de la programación con Fortran 90, de manera que el estudiante estará en capacidad de implementar herramientas numéricas eficientes para resolver problemas de ingeniería. La organización del texto es la misma estructura del programa de la materia aprobado por el consejo de facultad para el año 2005, y abarca desde nociones generales hasta la creación de programas usando herramientas de Visual y librerías estadísticas y matemáticas (IMSL). El compilador Visual Fortran, se encuentra disponible en la facultad, en su versión 6.0, actualmente se encuentra en el mercado la versión 9.1; la actualización de la versión disponible a 6.5A puede ser obtenida de internet, en el sitio web de Compaq Co. http://www.compaq.com/fortran. La versión disponible es del antiguo propietario de los derechos del compilador, Digital Co., http://www.digital.com/fortran que los vendió a Compaq Co., se hace esta aclaración porque seguramente encontrará dentro de las opciones de instalación las siglas DVF (Digital Visual Fortran), y si obtiene información de internet o baja alguna librería o actualización, encontrará las siglas CVF (Compaq Visual Fortran), desde el año 1999. Desde la versión 8.0 a partir del año 2004, los derechos del compilador fueron comprados por el fabricante de microprocesadores Intel, por lo que se encontraran referencias con las siglas IVF (Intel Visual Fortran), http://www.intel.com Es necesario mencionar que las versiones más avanzadas de un compilador no son más que optimizadores respecto la anterior. Lo que quiere decir que su trabajo será más eficiente y talvez más amigable en el entorno de programación. FORTRAN tiene una ventaja realmente importante sobre otros lenguajes y es que se pueden generar algoritmos matemáticos altamente eficientes con él, es un lenguaje para desarrolladores y no para usuarios comerciales, el compilador genera programas útiles para cualquier plataforma. Lo que lo ubica entre los programas compilados y no evaluados (Visual Basic de aplicaciones, MatLab, etc.) La desventaja son los sistemas de graficación, sin embargo, existen interfaces amigables que hacen más fácil el manejo de gráficos y su exportación a formatos más conocidos, como BMP, JPG y DXF. Espero que disfruten aprendiendo de estas notas, como yo lo hice escribiéndolas.

Juan Fernando Moreno Garcìa Ingeniero Naval Mayo-Julio de 2006

-5-


1.0 Programación básica con FORTRAN 1.1 Etapas para la preparación de u n p rog rama Fortran es un lenguaje compilado, es decir, se obtiene un archivo ejecutable, extensión .EXE, que puede trabajar en cualquier plataforma o sistema operativo. Existen lenguajes de programación que son evaluados como Turbo Pascal, Visual Basic para aplicaciones, Basic y otros, estos programas necesitan tener instalado en la máquina el compilador, para poder ejecutarse ya que van ejecutando línea por línea, si existe un error detienen la ejecución en esa línea. Los programas compilados no tienen esta opción, es decir, trabajan o no trabajan. Fortran, cumple tres etapas en la preparación de un programa: 1. Codificación del programa fuente.- hecho por el programador en un editor de texto. El archivo final debe tener las extensiones de FORTRAN *.for, *.f90, *.f ó *.fpp 2. Compilación del programa fuente.- el producto de esta operación genera un archivo objeto, *.obj, que es del tipo intermedio, es decir transforma el código fuente en lenguaje de máquina. 3. Concatenación o enlace.- el programa objeto se enlaza con las librerías matemáticas o gráficas, según sea el caso, y generan el programa ejecutable, *.exe.

1.2 Program a fuente Está conformado por una unidad de programa, que es una secuencia de comandos que definen el ambiente de datos y los pasos necesarios para optimizar cálculos entre ellos, toda unidad de programa concluye con la declaración END. Las unidades de programas pueden ser: un programa principal, un subprograma externo o subrutina, un módulo (contiene definiciones de datos y tipos, definen un procedimiento o función, e incluye interfases), y un bloque de datos (valores para objetos de datos). Las líneas de programa son de dos clases 1. Ejecutables: definen una acción 2. No ejecutables: definen un atributo. 1.2.1 Formatos para código fuente y límites del programa El Compilador Visual Fortran, soporta dos formatos de edición del código fuente, formato fijo y formato libre.

1.

El formato fijo.- Fortran Fixed Format Source File, que es rígido y una herencia del Fortran 77, admite solo 72 columnas por línea y tiene una columna fija, la sexta, debiendo empezar la escritura en la séptima, las cinco primeras se las usa para numerar las líneas. El Compilador DVF 6.0, disponible en la facultad admite archivos fuente codificados en F77, a pesar que para la versión F90 este tipo de formato es considerada obsoleto. 2. El formato libre.- Fortran Free Format Source File, es más flexible en cuanto a la ubicación de comandos, admite 132 columnas por línea.

-6-


Los límites del tamaño y complejidad de una unidad de programa o declaración contenida en él se detallan en la tabla No. 1.[1] Elementos del lenguaje

Límite

Número de llamadas a subrutina Sin límite Argumentos para una subrutina Sin límite Dimensiones de matrices 7 Número de elementos por dimensión 9*10 Líneas de continuación total 511 Anidar DO e IF combinadas 128 Grupos de COMMON 250 Anidar con paréntesis 40 Número de caracteres del nombre 63 Tabla No. 1.- Límites del programa 1.2.2 Esquema básico de un programa típico en Fortran El esquema que se presenta en la figura No.1, es solo referencial y hace énfasis en los tipos de elementos de programas que se usarán en el curso, para obtener el cuadro completo, véase la referencia [2].

PROGRAM, FUNCTION, MODULE SUBROUTINE, BLOCK DATA

S O I R A T N E M O C

USE declaraciones

Declaración de variables S O T A M R O F

Declaración ejecutables

END

Figura No. 1.- Esquema básico de un programa típico 1.2.3 Caracteres indicadores En la tabla No. 2, se describen los indicadores comúnmente usados en programación con FORTRAN, se hace una comparación de los usados en el formato fijo y en el libre, hay que aclarar que el uso de éstos de manera indistinta genera errores en la compilación del programa fuente, por lo que debe respetarse la sintaxis en el tipo de formato que se esté usando.

-7-


Descripción

Símbolo

Formatos

Observaciones

En cualquier parte

C,c,*

Todos Libre Fijo

Comentario Línea de comentario

Al final y al inicio máximo 39 líneas seguidas En la 6ª. Columna máximo 19 Menos „0‟ Fijo líneas seguidas Separa declaraciones en la misma ; Todos línea Libre Al inicio de la línea 5 dígitos Fijo De la columna 1 a 5 / Todos Al final de la línea Tabla No. 2.- Caracteres Indicadores &

Continuación Separador de declaraciones Número de línea Separador de línea

Al inicio de la línea

Libre

1.2.4 Variables y expresiones matemáticas Los tipos de variables admitidos en FORTRAN son los descritos en la tabla 3, el valor que se encuentra entre paréntesis es el valor que asume el compilador por defecto. La tabla 4 muestra los operadores admitidos. Variable

Sintaxis

Observaciones

Enteros INTEGER(N) N = 1,2,4,8 (4) Real REAL(N) N = 4,8,16 (4) Complejos COMPLEX(N) N = 8,16 (8) Complejo doble precisión DOUBLE COMPLEX(N) N = 8,16 (8) Lógica LOGICAL(N) N = 1,2,4,8 (4) Alfanuméricos CHARACTER Máximo 256 Matrices DIMENSION Máximo 7 dimensiones Tabla No. 3.- Tipos de Variables principales Descripción

Suma y resta Multiplicación División Potencia Menor que Mayor que Igual Mayor o igual Menor o igual Diferente Y O No equivalente Equivalente No (negación)

Símbolo

Tipo

+,* Aritmético / ** .LT., < .GT., > .EQ., == Comparación .GE.,>= .LE., <= .NE.,/= .AND. .OR. .NEQV. ó .XOR. Lógicas .EQV. .NOT. Tabla No. 4.- Operadores admitidos

-8-

Resultado

Valor numérico

.TRUE. .FALSE.


1.2.5 Formatos numéricos y alfanuméricos Los descritos en la tabla No. 5 son los formatos numéricos para escritura o lectura de variables admitidos por el lenguaje. Variable

Enteros Lógica Binarios Hexadecimales Reales decimales Científica Complejos Alfanuméricos

Formato

Ejemplo

In Ln Bn Zn

I3 : 125 L1 : Y B4 : 1001 (9) Z3 : A94

Fn.m

F4.2 : 3.45

En.m

E6.1 : .2E+02

Observaciones „n‟ número de cifras „n‟ número de caracteres „n‟ número de cifras „n‟ número de cifras „n‟ número de cifras, „m‟ número de decimales „n‟ número de cifras, „m‟ número de decimales

Dn.m D8.2 : 0.53D+01 Científica de doble densidad „n‟ número de cifras, Fn.m,Fn.m (F5.2,F5.1) : „m‟ número de decimales 2Fn.m (23.56,125.7) En.m,En.m A5 : „varia‟ „n‟ número de caracteres An Tabla No. 5.- Formatos usados en Fortran

Los formatos por defecto en el programa, a menos que sean definidos previamente son los que se detallan en la tabla No. 6. Variable

Formato

Enteros I12 Lógica L2 Reales (1 a 10 ) F15.6 Reales (1 a -10 ) E15.6 Complejos F23.15,F23.15, 2F23.15 Alfanuméricos A1 Tabla No. 6.- Formatos por defecto

1.3 Dec lar aci o nes b ási c as 1.3.1 OPEN

Descripción Sirve para abrir un archivo o una variable para posteriormente leer o escribir en ella información producto de una ejecución o de una asignación directa de valores. Sintaxis OPEN unidad , file

nombre, status

estado, err

-9-

número, iostat


1. Unidad: es un número entero que se asigna al elemento con el que se realizará el trabajo. 2. File: el nombre de la variable o del archivo, si se utiliza directamente el nombre del archivo éste debe ser colocado entre comillas. 3. Status: Evalúa el estado del archivo al ser abierto y toma los siguientes valores: a. „new‟: el archivo es nuevo, el programa lo crea y su estado pasa a ser „old‟, si ya existe se produce un error y la ejecución se detiene. b. ‟old‟: es un archivo ya existente. c. ‟scratch‟: se trata de un archivo nuevo que no ha sido nombrado, cuando

se lo cierra o termina la ejecución del programa, este archivo se borra. d. ‟replace‟: el archivo que se crea reemplaza a uno ya existente, si lleva el mismo nombre, borra el anterior y se actualiza. e. ‟unknown‟: el archivo puede o no existir, si no existe se crea uno nuevo y su estado pasa a ser „old‟. Este estado se aplica por omisión.

4. Err: cuando se produce un error en la ejecución del comando, el programa pasa a la línea que se especifica, si se omite „err‟, la ejecución del programa se detiene. 5. Iostat: es una variable entera, que toma el valor de 1 se existe error, y 0 si no lo hay. 1.3.2 CLOSE

Descripción Sirve para cerrar un archivo o una variable que ha sido previamente abierta usando la declaración OPEN. Sintaxis CLOSE unidad , STATUS

1. 2.

3.

" estado", ERR

número, IOSTAT

Unidad: es el número asignado en la apertura del documento, tiene que ser un entero. Status: Evalúa el estado del archivo al ser cerrado y toma los siguientes valores: a. „Keep‟ o „Save‟: guarda el archivo después de cerrarlo. b. „Delete‟: borra el archivo después de cerrar lo c. „Submit‟: separa un proceso para ejecutar el archivo. d. „Submit/delete‟: separa un proceso para ejecutar el archivo, entonces borra el archivo una vez concluída la ejecución. Err: cuando se produce un error en la ejecución del comando, el programa pasa a la línea que se especifica, si se omite „err‟, la ejecución del programa se

4.

detiene. Iostat: es una variable entera, que toma el valor de 1 se existe error, y 0 si no lo hay.

- 10 -


1.3.3 READ - WRITE

Descripción Sirve para leer/escribir desde/en un archivo o una variable valores numéricos o alfanuméricos. Sintaxis READ unidad, format var WRITE unidad, format var

1. 2.

Unidad: es el número asignado en la apertura del documento, tiene que ser un entero. Format: formato de lectura, este formato se asigna a la variable que va a ser asignada para los datos leídos. Si no existe un formato especificado se coloca „*‟, para escribir en pantalla la unidad es „*‟.

3.

var: nombre de la variable donde se ejecuta la acción.

1.3.4 IF

Descripción Existen de tres tipos: 1. El IF aritmético: este comando ejecuta tres acciones definidas por la línea que se designe de acuerdo al valor que toma la variable: negativa, cero o positiva. 2. El IF lógico: este comando ejecuta una declaración si el valor de la variable es verdadero, caso contrario la ignora 3. El IF condicional: esta declaración condiciona la ejecución de un conjunto de acciones a una pregunta lógica: si la respuesta es verdadera entonces ejecuta la acción después del comando THEN, caso contrario ejecuta la acción colocada después del comando ELSE. Siempre se cierra con la declaración ENDIF. Puede obviarse la declaración ELSE, pero no el ENDIF. Sintaxis IF (aritmético) IF(expr)label1,label2,label3

1. expr: es una expresión numérica del tipo entero o real, encerrado en paréntesis. 2. Label1: es una línea del programa, la ejecución pasa a esta línea si la expresión es menor que cero. 3. Label2: es una línea del programa, la ejecución pasa a esta línea si la expresión es igual a cero. 4. Label3: es una línea de programa, la ejecución pasa a esta línea si la expresión es mayor que cero. IF (lógico) IF (expr)stmt 1. Expr: es una expresión lógica, entre paréntesis.

- 11 -


2. Stmt: es una declaración ejecutable, cuando IF es ejecutado, la expresión lógica es evaluada primero, si su resultado es verdadero, se ejecuta, caso contrario no. IF (condicional) IF (expr) THEN Bloque de ejecución ELSE Bloque de ejecución ENDIF 1.3.5 DO

Descripción Ejecuta una acción definida controlando el número de veces que se ejecuta un bloque. Sintaxis DO [Variable = (valor entero)] Bloque de ejecución ENDDO 1.3.6 DO WHILE

Descripción Ejecuta una acción definida si la declaración entre el paréntesis es verdadera, caso contrario la ignora Sintaxis DO [WHILE] (expr) Bloque de ejecución ENDDO 1.3.7 SELECT CASE

Descripción Selecciona dentro de varias opciones las acciones a seguir de acuerdo al valor que toma una variable entera, lógica o alfanumérica. Esta declaración reemplaza al GOTO de Fortran 77. Sintáxis [nombre] SELECT CASE (variable) CASE (valor) Bloque de ejecución CASE (valor) Bloque de ejecución…..

CASE DEFAULT Bloque de ejecución END SELECT [nombre] - 12 -


1.3.8 WHERE

Descripción Realiza una prueba lógica a los elementos de un arreglo o matriz, o a una matriz completa, ocasionalmente se le asigna un nombre, que debe ser conservado. Lo que se encuentra entre los signos de agrupación [] es opcional en la construcción del bloque. Sintaxis [nombre] WHERE (expr 1) Bloque de ejecución [ELSEWHERE (expr2) [nombre] [Bloque de ejecución] ...] [ELSEWHERE [nombre] [Bloque de ejecución] ...] END WHERE [nombre]

1.4 Fun cio nes im plícit as Fortran tiene incluidas funciones matemáticas que pueden ser usadas e n cualquier lugar del bloque de ejecución, siempre tienen la siguiente sintaxis general. Var = FUNCION(argumento) En la tabla No. 7 se citan algunas funciones nótese el tipo de argumento que tiene cada función y el tipo de variable que resulta de su ejecución. Nombre

ABS ACOS LOG LOG10 CHAR CMPLX EXP FLOAT LEN SQRT

Definición

Tipo de Argumento

Tipo de Función

Valor absoluto Entero, real, complejo Entero, real, complejo Arco Coseno Real Real Logaritmo natural Real Real Logaritmo base 10 Real Real Convierte a caracter Entero Alfanumérico Convierte a complejo Entero, real, complejo Complejo Exponencial Real Real Convierte en real Entero Real Longitud de cadenas Alfanumérico Entero Raíz cuadrada Real o complejo Real o complejo Tabla No. 7.- Ejemplo de funciones matemáticas

2.0 Vectores y Matrices En FORTRAN existen dos tipos de datos no escalares conocidos como „arreglos‟

(ARRAYS), de los cuales existen dos tipos los vectores y las matrices, siendo el vector una matriz de dimensión uno. En general los arreglos están formados por conjuntos de valores que son los elementos del conjunto, por ejemplo cuando nos referimos al elemento A5, nos referimos al quinto elemento contenido en el vector A, de igual manera cuando operamos matrices el elemento A 2,5, se refiere al elemento de la fila 2,

- 13 -


columna 5 de la matriz A. En FORTRAN la nomenclatura es A(5) y A(2,5) respectivamente. Todo elemento de un arreglo, es decir, una variable con sus subíndices en FORTRAN recibe el nombre de „variable subindicada‟.

La estructura de un arreglo en FORTRAN, queda definida con los siguientes parámetros: 1. Rango: total de dimensiones del arreglo, el máximo 7. 2. Extensión: Componentes que posee un arreglo en cada una de sus dimensiones, máximo 9*1018. 3. Tamaño: total de elementos de un arreglo 4. Perfil: vector cuyos elementos son las respectivas extensiones de cada dimensión. 5. Conformidad: igualdad de perfil, entre dos o más arreglos. 6. SubArreglo: arreglo formado por sólo algunos elementos de un arreglo dado.

2.1 Declaración y d ispo sicion es de mem oria 2.1.1 Vectores Son arreglos de una sola dimensión, que permiten almacenar información del tipo real, entera, compleja y alfanumérica.

Forma de declarar vectores Se los puede definir de las siguientes maneras: Tipo, DIMENSION (n) :: lista de vectores

Donde „tipo‟ puede ser „REAL, INTEGER, COMPLEX, CHARACTER‟, „n‟

corresponde al número de elementos que contiene el arreglo, y la lista de vectores son las variables que se han asignado a cada vector. Tipo :: variable(i:s), variable2(i:s),…… Tipo :: variable(i:s:p), variable2(i:s:p)

Donde el tipo es el mismo del anterior esquema y la lista de arreglos se la hace determinando su tamaño entre paréntesis. El primer número entero „i‟ indica la posición menor del arreglo y „s‟ la posición mayor del arreglo. Si la posición menor es 1, se la

puede omitir. Cuando se hacen declaraciones con triple especificación, el último elemento indica las posiciones: inferior, inferior + paso, inferior + 2*paso, etc. Sin sobrepasar el límite superior si el paso es mayor que cero y si el paso es menor que cero sin llegar a valores bajo el límite superior. Si „i „ es omitido se toma el valor de 1, „s‟ no puede ser omitido y si el paso es omitido se asume el valor de 1. Tipo, DIMENSION (:), ALLOCATABLE :: lista de arreglos

- 14 -


En esta forma se ha usado la declaración ALLOCATABLE, que nos permite determinar el tamaño del arreglo durante la ejecución, una forma alterna de este método es el siguiente: Tipo, DIMENSION (:) :: lista de arreglos ALLOCATABLE :: lista de arreglos

Luego cuando se conoce el tamaño del arreglo se hace la siguiente declaración: ALLOCATE(lista de arreglos, STAT = variable entera) ALLOCATE(lista de arreglos)

Donde la lista de arreglos se definen como VAR(N) y la función STAT indica si la asignación ha sido realizada con éxito. Por lo que se debe colocar a continuación, un IF para verificar el paso y evitar errores de ejecución. IF (Variable entera /= 0) STOP “No hay memoria suficiente”

Para liberar la memoria se usa la sentencia DEALLOCATE ( lista). Otra forma de asignar valores al vector de manera constante y desde el programa fuente es escribiendo los valores directamente en el vector previamente definido y declarado como tal. A = (/valor 1, valor 2, valor 3, ….. , valor n/) A = (/(declaración, i=1,n)/) A = (/valor 1, valor 2, (i, i=3,n,m), valor n+1/)

Usando la función WHERE también se puede asignar valores a los vectores, conocido los elementos de otro. Ejemplos Declaraciones de vectores COMPLEX, DIMENSION (10) :: A,B,C COMPLEX :: A(10), B(10), C(10) COMPLEX, DIMENSION (0:9) :: A,B,C COMPLEX, DIMENSION (0:18:2) :: A,B,C COMPLEX A(0:9), B(2:18:2), C(::), D(:20:)

Declaraciones de vectores con tamaño desconocido REAL, DIMENSION (:), ALLOCATABLE :: A,B,C

Otra forma: REAL, DIMENSION (:) :: A,B,C ALLOCATABLE :: A,B,C Luego de un bloque de ejecución se obtiene ‘n’

ALLOCATE(A(n),B(n),C(n), STAT = StatusValor) IF (statusValor /= 0) STOP “No hay memoria suficiente”

Asignación de valores a un vector mediante elementos conocidos. A = (/-2.2, 5.14, 4.0, 2.58/) A = (/(1.25*I,i=1,10)/) A = (/7, 1, (i, i=3,18,3), 4/)

- 15 -


Funciones para operar vectores ALLOCATED (A) DOT_PRODUCT (A,B) MAXVAL(A) MAXLOC(A) MINVAL(A) MINLOC(A) PRODUCT(A) SIZE(A) SUM(A)

Devuelve verdadero si se ha dimensionado el vector Producto punto entre A y B Máximo valor en el arreglo Posición del primer máximo valor Mínimo valor del arreglo Posición del primer mínimo valor Producto de los elementos del arreglo Número de elementos del arreglo Suma de los elementos del arreglo

Ejercicios de aplicación 1. Declarar un vector de cantidades enteras con las siguientes características: a. La sucesión de índices comienza en el -1 y finaliza en el 9, con un escalón, entre subíndices de 2 unidades 2. Se desea asignar al vector Z de números enteros los valores pares comprendidos entre 2 y 12. Usando una función para definir los elementos. 3. Haciendo uso de un lazo DO implícito asignar al vector compuesto por 100 números enteros, los siguientes valores: -4 y 8 para el primero y el último elemento y 0 para los 98 restantes. 4. Escribir un programa que tome una lista de números y los ordene. El usuario deberá introducir primero cuantos números quiere ordenar y a continuación la lista de números. El programa devolverá por pantalla la lista ordenada. 5. Realizar un programa usando FORALL, que convierta todos los caracteres de una frase introducida por teclado en mayúsculas. 2.1.2 Matrices Son arreglos de datos con más de una dimensión, Fortran soporta hasta 7 dimensiones. Igual que los vectores son del tipo ENTERO, REAL, COMPLEJO o ALFANUMERICO.

Forma de declarar matrices Se los puede definir de las siguientes maneras: Tipo, DIMENSION (n,n2,n3, …., nn) :: lista de matrices

Donde „tipo‟ puede ser „REAL, INTEGER, COMPLEX, CHARACTER‟, „n‟

corresponde al número de elementos que contiene el arreglo, y la lista de matrices son las variables que se han asignado a cada una. Tipo :: var1(i:s,i:s,i:s,…), var2(i:s,i:s,i:s,…),…… Tipo :: var1(i:s:p,i:s:p,…), var2(i:s:p,i:s:p,…)

Donde el tipo es el mismo del anterior esquema y la lista de arreglos se la hace determinando su tamaño entre paréntesis. El primer número entero „i‟ indica la posición menor del arreglo y „s‟ la posición mayor del arreglo. Si la posición menor es 1, se la

puede omitir.

- 16 -


Cuando se hacen declaraciones con triple especificación, el último elemento indica las posiciones: inferior, inferior + paso, inferior + 2*paso, etc. Sin sobrepasar el límite superior si el paso es mayor que cero, si el paso es menor que cero sin llegar a valores bajo el límite superior. Si „i „ es omitido se toma el límite inferior del arreglo, si „s‟ es omitido se toma el límite superior del arreglo, y, si el paso es omitido se asume el valor de 1. Tipo, DIMENSION (:,:,:,…), ALLOCATABLE :: lista de arreglos

La declaración ALLOCATABLE, nos permite determinar el tamaño del arreglo durante la ejecución, una forma alterna de este método es el siguiente: Tipo, DIMENSION (:,:,:,…) :: lista de arreglos ALLOCATABLE :: lista de arreglos

Luego cuando se conoce el tamaño del arreglo se hace la siguiente declaración: ALLOCATE(lista de arreglos, STAT = variable entera) ALLOCATE(lista de arreglos)

Donde la lista de arreglos se definen como VAR(n1,n2,…) y la función STAT indica si

la asignación ha sido realizada con éxito, por lo que se debe colocar a continuación, un IF para verificar el paso y evitar errores de ejecución. IF (Variable entera /= 0) STOP “No hay memoria suficiente”

Para liberar la memoria se usa la sentencia DEALLOCATE ( lista). Asignación de valores 1. Lectura usando DO implícito: READ *,((TABLA(FILA,COL), COL = a,b), FILA = c,d) READ *,(TABLA(I,J,K), I = a,b), J = c,d), K = e,f)

2. Sub arreglos de una matriz. Sea una matriz A declarada como: INTEGER, DIMENSION (2,3) :: A

Con valores: A

11 22 33 44 55 66

El subarreglo definido por: A(1:2:1, 2:3:1) o simplemente A(:, matriz de 2x2 que contiene las dos últimas columnas de la matriz A. A

22

33

55

66

2:3) es una

El valor del subarreglo definido como A(2, 1:3:1) o simplemente un vector que contiene la última fila de la matriz A

44 55 66

- 17 -

A(2,:)

es


El valor del subarreglo definido por. A((/2,1/), 2:3), en el cual el primer término está definido por el vector (/2,1/), el que indica que la segunda fila se considerará primero y luego la primera, es decir indica el orden de asignación de las filas, y el segundo término está definido por la declaración (2:3), con paso de 1, el resultado es un arreglo 2x2 A

55 66 22 33

3. Asignación de un arreglo a otro. Sean dos matrices declaradas como: INTEGER, DIMENSION (2,3) :: A INTEGER, DIMENSION (3,2) :: B

Se asigna a la matriz A el valor de 0, el resultado es una matriz 2x3 conteniendo como elementos ceros. A = 0

A

0 0 0 0 0 0

La declaración: de A

B = RESHAPE (A, (/3,2/)),

asigna a la matriz B el contenido

0 0 B

0 0 0 0

También se pueden asignar valores a manera de subarreglos dentro de una matriz, por ejemplo en la matriz original A con elementos igual a cero, la declaración: A(:, 2:3) = RESHAPE((/I**2, I = 1,4)/), (/2,3/))

Cambia los valores de A: A

0 1 0

9

4 16

4. Asignación mediante la sentencia WHERE Sean dos matrices A y B declaradas como: REAL, DIMENSION (2,3) :: A, B Donde la matriz A tiene los valores: A

1.0

2.0

0.0

0.0 10.0 5.0

La sentencia WHERE usada como: WHERE ( A /= 0.) B = 1.0/REAL(A) ELSEWHERE B = 0.0 END WHERE

Los valores asignados a B son:

- 18 -


B

1.0

0.5 0.0

0.0

0.1 0.2

Ejemplos Declaraciones de matrices COMPLEX, DIMENSION (10,20,10) :: A,B,C COMPLEX :: A(10,10), B(10,5), C(10,30) COMPLEX, DIMENSION (0:9,1:4) :: A,B,C COMPLEX, DIMENSION (0:18:2,1:12:4,0:9:1) :: A,B,C COMPLEX A(0:9,:13:,1:6), B(2:18:2,12)

Declaraciones de matrices con tamaño desconocido REAL, DIMENSION (:,:,:), ALLOCATABLE :: A,B,C

Otra forma: REAL, DIMENSION (:,:,:) :: A,B,C ALLOCATABLE :: A,B,C Luego de un bloque de ejecución se obtiene ‘n’ y ‘m’

ALLOCATE(A(n,m),B(n,m),C(n,m), STAT = StatusValor) IF (statusValor /= 0) STOP “No hay memoria suficiente”

Funciones para operar matrices MATMUL(A,B) MAXVAL(A,D) MAXLOC(A) MINVAL(A,D) MINLOC(A,D) PRODUCT(A,D) RESHAPE(A,S,P,Q)

SHAPE(A) SUM(A,D) SPREAD(A,D,N) TRANSPOSE(A)

Producto de matriz A por B Arreglo con los máximos valores de A en la dimensión D, si se omite D un valor máximo de todo el arreglo Vector con la posición del primer máximo valor Arreglo con el mínimo valor de A en la dimensión D, si D se omite, un mínimo valor de todo el arreglo Vector con la posición del primer mínimo valor Arreglo de una dimensión menor que contiene el producto de A con los elementos de la dimensión D Arreglo que contiene los valores de A con la forma S, seguidos por elementos del arreglo P y un vector Q especificando el orden en que los subscriptores se varían cuando se llena la matriz. P y Q son opcionales. Vector con las extensiones del arreglo A Arreglo con la suma de los elementos de A en la dimensión D, si D se omite suma los elementos de toda la matriz Arreglo de dimensión mayor que A obtenida por proyectar A, n veces a lo largo de la dimensión D Transpuesta de A

Ejercicios de aplicación 1. Declarar una matriz de números enteros, de dos filas y tres columnas. Rellenarla en sus primeros elementos con los valores 11, 12, 13, 14 y los dos restantes con 0, rellenarlas por filas e indicar la matriz obtenida. 2. En un programa se declara una matriz mediante la sentencia: REAL, DIMENSION (-4:0:1,1:7:1):: A

- 19 -


En el mismo programa se escriben las asignaciones vector conteniendo los subíndices que se indican: u = (/-4,-2,-3/) y v = (/2,1,1,3/)

Contestar las siguientes preguntas: a. Total de filas y columnas que posee la matriz declarada b. Subarreglos obtenidos, respectivamente, con el uso de las variables A = (-2,v), A(u,2) y A(u,v) c. Subarreglo obtenido con: A(0,(/1,3,5/)).

3. Escribir un programa que use una matriz de rango 2, donde las extensiones de cada dimensión son variables. El programa leerá las extensiones por teclado, dimensionará la matriz en memoria en función de los valores leídos y por último llenará de valores e imprimirá su contenido. 4. Escribir un programa que lea por teclado el listado de notas de hasta 100 alumnos, para cinco ejercicios. Se deberán introducir todas las notas para el primer ejercicio, a continuación las del segundo, y así sucesivamente hasta completar los cinco ejercicios. Si la nota introducida es 999, el programa considerará que ya no hay más alumnos en dicho ejercicio y pasará al siguiente ejercicio. El programa deberá resolver el número de alumnos presentados a cada ejercicio, la nota media para dicho ejercicio y el listado de notas con la desviación con respecto a la media. 5. Escribir un programa que transponga la matriz de dimensión 3x3 de valores reales de doble densidad, leída por teclado. Se empleará la construcción FORALL sin hacer uso de matrices auxiliares.

2.2 Dimen sio nam iento din ám ico Los datos pueden ser estáticos o dinámicos, en el caso de datos estáticos el valor de memoria asignada a la variable se mantiene constante durante toda la ejecución del programa y únicamente se libera cuando termina la ejecución. En este tipo de datos es previamente definido el tamaño de memoria que se reserva. Cuando un dato es dinámico la cantidad de memoria puede ser creada, alterada o liberada conforme avanza la ejecución del programa y de acuerdo a las necesidades del usuario. En FORTRAN 90/95 existen 3 tipos de dimensionamiento dinámico: punteros (POINTERS), arreglos alojados (ALLOCATE) y arreglos automáticos. 2.2.1 Punteros El objetivo de su uso es el de almacenar los arreglos consecutivamente dejando posiciones de memoria sin uso al final del espacio reservado. Considérese la siguiente declaración de matrices y vectores: PARAMETER (NA_MAX = 100) REAL(KIND = 8), DIMENSION (NA_MAX, NA_MAX) :: A REAL(KIND = 8), DIMENSION (NA_MAX) :: V, W

Se observa claramente que para no tener que compilar y enlazar el programa cada vez que se desea trabajar con matrices de tamaños de distintos tamaños se ha definido un parámetro, este parámetro indica el máximo tamaño admisible sin necesidad de modificar el programa. En este caso se suponen que no existirán matrices de orden mayor a 100, por lo que se reserva espacio suficiente para matrices 100x100 coeficientes reales de doble densidad, luego un vector de 100 espacios y luego otro vector de 100 posiciones. Una vez asignado el espacio el programa mediante una

- 20 -


sentencia de lectura o escritura obtiene el orden real de la matriz con la que se va a trabajar. Por ejemplo: WRITE (*,*)‟ INGRESE EL ORDEN DE LA MATRIZ‟ READ(*,*)NDIM

Si por ejemplo se ingresa para NDIM el valor de 4, el programa solo usa las primeras 16 posiciones de memoria para la matriz A, el vector V de 4 elementos se encuentra almacenado detrás de la matriz A, es decir, hay 100 2-16 números reales de doble densidad que no van a ser usados.

Figura No.- 1 Dimensionamiento no consecutivo Para el mismo ejemplo se reservarán espacios consecutivos de memoria, pero en un único vector denominado DD, que debe contener la matriz A y los vectores V y W, la matriz A ocupará las primeras NDIMxNDIM posiciones del vector DD, el vector V las siguientes NDIM posiciones y el vector W las siguientes NDIM, quedan libres por tanto, las últimas NA_MAX – NDIM2- NDIM – NDIM posiciones del vector DD, si NDIM es 4 quedan libres 10177 posiciones consecutivas al final del vector DD, con esto se ha conseguido que toda la información se encuentre próxima independiente de la dimensión de las matrices. Queda por lo tanto únicamente indicar al programa donde inicia y donde termina la matriz y los vectores en el vector DD, a esta instrucción se denomina definición de punteros, para lo cual se definen las siguientes instrucciones: NA NV NW NEND

= = = =

1 NA + NDIM*NDIM NV + NDIM NW + NDIM

¡ ¡ ¡ ¡

Matriz A Vector V después de A Vector W después de V Fin del espacio ocupado

Seguidamente se verifica si el espacio reservado es suficiente IF (NEND > NA_MAX) THEN WRITE(*,*)‟ ERROR, Dimensionamiento insuficiente‟ WRITE(*,*)‟ SE REQUIEREN‟, NEND, „ POSICIONES‟ STOP ENDIF

- 21 -


Cuando se hace la asignación en una subrutina simplemente en reemplazo del nombre del vector o matriz se pasa la posición del puntero, en el mismo orden.

Figura No.- 2 Reserva consecutiva de memoria Por ejemplo para el caso visto anteriormente, supongamos que debemos enviar la información de la matriz A y los vectores V y W en una subrutina1, la secuencia convencional sería: CALL SUBRUTINA1(NDIM, A, V, W)

Usando los punteros definidos, la asignación sería: CALL SUBRUTINA1(NDIM, DD(NA), DD(NV), DD(NW))

En la subrutina se mantiene la sintaxis convencional. 2.2.2 Alojamiento de memoria Los límites y la forma de un arreglo no son conocidos sino hasta que se ha ejecutado el programa, mediante el ingreso o determinación de la dimensión. Estos arreglos se los declara como sigue: Tipo, DIMENSION (:,:,:,…), ALLOCATABLE :: lista de arreglos

O su equivalente Tipo, DIMENSION (:,:,:,…) :: lista de arreglos ALLOCATABLE :: lista de arreglos

Una vez conocido el valor de la dimensión que se define se asigna la dimensión usando la sentencia: ALLOCATE(lista de arreglos, STAT = variable entera) ALLOCATE(lista de arreglos)

Donde la lista de arreglos se definen como VAR(n1,n2,…) y la función STAT indica si la asignación a sido realizada con éxito. Por lo que se debe colocar a continuación, un IF para verificar el paso y evitar errores de ejecución, este paso es opcional, pero cuando se

- 22 -


encuentra ejecutando varios programas a la vez en el computador, se debe considerar la verificación de memoria virtual, evidentemente esto no es necesario si estamos seguros de trabajar con matrices relativamente pequeñas y memoria RAM relativamente alta. IF (Variable entera /= 0) STOP “No hay memoria suficiente”

Para liberar la memoria se usa la sentencia. DEALLOCATE (lista de arreglos)

Siempre que sea necesario reasignar valores al arreglo es necesario liberar la memoria, de igual forma antes de finalizar la ejecución se recomienda liberar la memoria. 2.2.3 Arreglos Automáticos Este tipo de dimensionamiento se encuentra aplicado únicamente a los subprogramas, ya que en ellos se define un parámetro de dimensión N y la asignación se la hace conocido este parámetro. Por ejemplo considérese el siguiente código fuente: FUNCTION SUMA(A, M, N) REAL, DIMENSION (M,N) :: A SUMX = 0.0 DO J = 1, N DO I = 1, M SUMX = SUMX + A(I, J) END DO END DO SUMA = SUMX END FUNCTION

En el ejemplo propuesto la matriz A tiene dimensión MxN que no se conoce y sin embargo son argumentos de la función, una vez conocidos se puede conocer la dimensión de la matriz. 2.2.4 Ejercicios de aplicación 1. Escribir un programa que cree un vector dinámico y lo vaya rellenando con los valores enteros proporcionados por el usuario, el vector comenzará dimensionado a uno y duplicará su capacidad cada vez que se llene completamente. El proceso se detiene cuando el usuario ingresa el número -987. 2. Escribir un programa que lea dos valores N y M y ubique dinámicamente en memoria una matriz A(n,m) y dos vectores B(m) y C(n) y a continuación lea por teclado los valores de cada elemento de la matriz A y el vector B, obtenga el producto matriz por vector usando la función MATMUL. Mostrar la matriz y los vectores en pantalla. 3. Escribir un programa que genere una matriz de Vandermonde, la definición de los términos de la matriz Vandermonde es: ai , j

xi

j 1

i, j

1,...n

Donde x ,…,x i n son números reales distintos entre sí, en particular considere: a. Tomar xi = 10-i+1, con i = 1,…,n y presentar los resultados para n = 4 b. Tomar xi = i, con i = 1,…,n y presentar los resultados para n = 4

- 23 -


Generar un vector que se define como la suma de las columnas y realice el producto matriz vector, calcule el módulo del vector y presente en pantalla la matriz de entrada, el vector de entrada, el vector producto y el módulo del vector producto.

2.3 Almacenam iento por defecto en FORTRAN En FORTRAN las variables con 2 subíndices se almacenan por columnas, por ejemplo, considere la matriz:

A

a11

a12

a13

a21

a22

a23

a31

a32

a33

Se almacenan los coeficientes siguiendo el orden que imponen las columnas, es decir: a11

a21

a31

a12

a22

a32

a13

a23

a33

En caso de que la variable tenga más subíndices la filosofía se mantiene. La importancia de conocer la forma de almacenamiento radica en la eficiencia de los algoritmos, para ilustrar esto vamos a analizar un ejemplo clásico de resolución de sistemas lineales con matrices triangulares.

L

l 11

0

0

0

l 21

l 22

0

0

l 31

l 32

l 33

0

l 41

l 42

l 43

l 44

Por consiguiente para esta matriz el computador la almacena como: l 11

l 21

l 31

l 41

0 l 22

l 32

l 42

0

0 l 33

l 43

0

0

0 l 44

Para este ejemplo se ha seleccionado una matriz triangular inferior de dimensión N = 4, se declaran previamente la matriz A donde se almacenan los coeficientes de la variable, y el vector B que contiene los términos independientes, el vector X contiene la solución del sistema. El siguiente código muestra el acceso a los elementos de la matriz de manera natural, filas y luego columnas. X(1) = B(1)/A(1,1) DO I = 1, N X(I) = B(I) DO J = 1, I-1 X(I) = X(I) – A(I,J)*X(J) END DO X(I) = X(I)/A(I,I) END DO

- 24 -


En este algoritmo la secuencia de acceso a los datos es la siguiente: 1 2

4

l 11

l 31

l 21

7 l 41

3 0

5 l 22

8 l 32

l 42

6 0

0

9 l 33

10 l 43

0

0

0

l 44

Evidentemente el acceso es en desorden y no se accede de forma secuencial, este efecto de saltar entre posiciones lejanas de memoria se va acentuando a medida que el orden de la matriz crece. El código que sigue muestra el acceso a los elementos de la matriz primero por columnas y luego por filas. DO I = 1,N X(I) = B(I) END DO DO J = 1, N-1 X(J) = X(J)/A(J,J) DO I = J+1, N X(I) = X(I) – A(I,J)*X(J) END DO END DO X(N) = X(N)/A(N,N)

En este algoritmo la secuencia de acceso a los elementos de la matriz es la siguiente: 1 2

3

l 11

l 31

l 21

4 l 41

5 0

6 l 22

7 l 32

l 42

8 0

0

9 l 33

10 l 43

0

0

0

l 44

Evidentemente la segunda forma es la más eficiente para acceder a la información. A pesar que el almacenamiento de ceros sigue siendo un despilfarro de memoria.

3.0 Tipos derivados de datos 3.1 Generalidades Se puede declarar con una serie de sentencias agrupadas en una declaración TYPE, tienen la sintaxis siguiente: TYPE nombre_tipo Declaración Declaración END TYPE nombre_tipo

En esta definición pueden incluirse tantas sentencias como se quiera, el identificador nombre_tipo es un nombre válido y será la denominación adjudicada al tipo derivado. Luego éstas se las usa en un programa principal usando la siguientes sintaxis TYPE (nombre_tipo)

:: estructura1, estructura2, ….

También es posible declarar un arreglo usando la siguiente sintaxis TYPE (nombre_tipo), DIMENSION (A,B,…) :: estructura1, estructura2, ….

- 25 -


Cuando se adjudica valores se escribe una serie de constantes, valores lista componentes del mismo tipo y en el mismo orden que las componentes del tipo derivado de datos, en forma general se escribe: nombre_tipo (valores de lista componentes)

Esta forma de definir un valor constante para un tipo derivado de datos, se conoce con el nombre de constructor de estructura, además es posible referirse directamente a una determinada componente de una estructura escribiendo el nombre de esa estructura seguido del símbolo % y del nombre de la componente: Nombre_estructura%nombre_componente

Con los tipos derivados de datos así como con sus componentes pueden hacerse ciertas operaciones. 1. Encapsular un tipo dentro de otro tipo: en la definición de tipo derivado se puede usar a su vez otro. 2. Asignar valores a las variables de un tipo derivado: dado que cada componente de una estructura posee cierto tipo declarado, tal componente se puede utilizar de la misma forma que se hace con cualquier otro dato del mismo tipo. 3. Entrada y salida de componentes de un tipo derivado. READ *, elemento%nombre PRINT *, elemento%nombre

En cuanto a la entrada o salida de una estructura, ésta debe hacerse leyendo o visualizando elemento a elemento, es decir el valor de cada una de las componentes de forma individual.

3.2 Ejem plo s 1. Escribir un programa que lee las coordenadas de dos puntos en el plano, p1(x1,y1), p2(x2,y2) y calcule los tres coeficientes a,b,c de la recta que los une, sabiendo que esa ecuación tiene la forma: ax + by +c = 0, los tres coeficientes de la recta, en función de las coordenadas de los dos puntos son: a = y2 – y1, b = x1 – x2, c = y1.x2 – y2.x1 2. La distancia entre dos puntos de coordenadas (x1,y1) y (x2,y2) está dada por

La pendiente de la ecuación de la recta „m‟ se define como: Donde „b‟ es la intersección de la recta en el eje „y‟, usando la pendiente „b‟

puede calcularse como Si x1 = x 2 entonces no existe intersección de la recta con el eje „y‟ y la pendiente no está definida y la recta que pasa por estos dos puntos es una vertical de ecuación Escriba un programa que calcule la distancia entre dos puntos dados y determine la ecuación de la recta que pasa por ellos.

- 26 -


3.

Leer de un archivo de datos la información de los usuarios de una red siguiendo el formato que sigue: apellido, nombre, Número id, contraseña, total de recursos asignados y total de recursos empleados, la primera cantidad está en dólares tres cifras enteras y dos decimales, sin embargo debe ser procesado como número real. Organizando esta información en estructura de tipos derivados de datos. Se ingresa el identificador y el programa busca de la lista y se detiene, extrae toda la información pertinente y la imprime en pantalla, de ser necesario el programa debe poder ingresar información adicional en el archivo de datos. Un ejemplo de ingreso de información es el que sigue: ESCOBAR MEZA YUNGAN

PAUL 10101ADA 75038081 PABLO 10102APLIC 65059884 GEOVANNY 10103CALC 25019374

- 27 -


4.0 El ambiente de trabajo “Developer Studio” La ruta de acceso al ambiente es: Inicio/Programas/Visual Fortran 6.0/Developer Studio. Esta ruta ejecuta el escritorio de trabajo de Visual, éste a su vez muestra una pantalla dividida en cuatro partes, la superior es la sección de comandos y menús, que pueden ser personalizadas desde la opción CUSTOMIZE, del menú TOOLS; a la izquierda aparece la sección del espacio de trabajo, la mayor parte de la pantalla la ocupa el escritorio, editor de texto; en la parte inferior se encuentra la pantalla de salida, donde se indican las observaciones durante la ejecución o compilación del programa. Véase la figura No. 2

Explorador del espacio de trabajo

Escritorio de trabajo

Resultado de los procesos

Figura No. 2.- Pantalla inicial En este ambiente, los programas se organizan de la siguiente forma: 1. Cada archivo que contiene un código fuente debe corresponder a un proyecto de trabajo; varios archivos con código fuente pueden ser parte de un proyecto de trabajo, pero solo uno puede tener el título de PROGRAM. 2. Los proyectos se almacenan en espacios de trabajo, luego varios proyectos pueden estar contenidos en un espacio de trabajo. 3. Cada Espacio de trabajo se guarda en una carpeta independiente del mismo nombre del espacio de trabajo. El archivo que resulta de la compilación del programa lleva el nombre del Proyecto de trabajo. - 28 -


4. Dentro de la carpeta que contiene el espacio de trabajo se crea una carpeta de nombre DEBUG, que puede ser personalizada y cambiada de nombre desde la opción SETTINGS del menú PROJECT. En dicha carpeta se almacenan los archivos intermedios y el ejecutable producto de la compilación.

4.1 Iniciando un p royecto El procedimiento para iniciar un proyecto se lo hace siguiendo la ruta: FILE/NEW; se abre un cuadro de diálogo con varias pestañas, pero por haber optado la opción de nuevo, aparece la pestaña de „PROJECT‟, por defecto. Visual Fortran reconoce cinco

tipos de proyectos y dos tipos de herramientas de construcción. Los proyectos van relacionados con la aplicación final de la compilación y enlace. Las herramientas con accesorios extras para facilitar la construcción de programas. Véase la figura No. 3.

Figura No.3.- Tipos de proyectos Los cinco tipos de proyectos que soporta Visual Fortran son: 1. Fortran Console Aplication: Genera un programa con extensión *.EXE, este tipo de proyecto no requiere pantalla gráfica para mostrar sus datos de salida; luce parecida a un programa corriendo bajo UNIX o a una Terminal conectada a un servidor. Opera con una sola ventana y la interacción se resume a leer y escribir, es mejor usarla cuando el problema requiere salidas numéricas y no gráficas, es el proyecto más fácil de hacer correr en otras plataformas. 2. Fortran Standard Graphics o QuickWin Aplication: Genera un programa con extensión *.EXE. Existen dos tipos de este proyecto: el que contiene una sola ventana y el que contiene múltiples ventanas, el primero luce igual que una aplicación basada en DOS, en ambas es posible usar opciones gráficas o - 29 -


representar gráficos como salida de la información. El tamaño de la ventana virtual puede ser seleccionada. En este tipo de proyecto se pueden usar rutinas QUICKWIN, con varias opciones para hacer de las aplicaciones más amigables, el módulo DFLIB trabaja con este tipo de proyectos. 3. Fortran Windows Aplication: Genera un programa con extensión *.EXE, son proyectos que pueden usar todas las opciones API, dando a la aplicación mucha más interactividad con el usuario. También se pueden llamar a funciones de otras aplicaciones como las de C++. El módulo DFWIN contiene todas estas opciones. 4. Fortran Dynamic Link Libraries: Genera un archivo con extensión *.DLL, es un conjunto de código fuente compilada, que contiene solo subprogramas con funciones o utilidades que son usadas desde el programa principal, se caracteriza por ser independientes de éste, pero deben encontrarse en el mismo directorio de la aplicación principal para que pueda ser usada. 5. Fortran Static Library: Genera un archivo con extensión *.LIB, es un conjunto de código fuente compilado, que contiene subprogramas que serán usados por la aplicación principal y necesariamente son vinculados o enlazados en el programa principal para que puedan ser usados. Una vez seleccionado y definido el tipo de proyecto que se quiere realizar, se crean los archivos de código fuente, usando la misma ruta de comandos FILE/NEW, pero esta vez como ya está definido el proyecto se abre la pestaña de FILE. Véase la figura No. 4.

Figura No. 4.- Tipos de archivos Note que para ahorrarnos un paso posterior debemos verificar que la casilla „ADD TO PROJECT‟ esté marcada, de esta forma el archivo que se crea queda almacenado como

parte del proyecto. Como inicialmente se va a comenzar con un archivo de código

- 30 -


fuente, se selecciona entre el tipo de archivo FORTRAN FIXED FORMAT o el FORTRAN FREE FORMAT, de acuerdo a nuestras exigencias. Los nombres que se den a los archivos deben ser solo letras y números, sin espacios ni caracteres especiales, salvo la barra baja ( _ ). Creado el archivo, éste se guarda en la carpeta denominada SOURCE, del proyecto activo. Cuando un proyecto es definido se crean por defecto 3 carpetas: 1.

„Source Files‟: donde se alma cenan los programas fuente, con extensión *.FOR

o *.F90. 2.

„Header Files‟: donde se almacenan los archivos de interface con extensión

*.FD o *.FI, entre el programa fuente y los recursos de visual. 3.

„Resource Files‟: donde se almacenan los recursos de visual (cuadros de

diálogo, íconos, menú, etc.), archivos con extensión *.RC.

Figura No. 5.- Carpetas del proyecto

4.2 Ejem plo s 1. Escriba un programa que permita realizar operaciones con números complejos, es necesario ingresar la información desde pantalla y el resultado debe mostrarse en la pantalla. Solución

De acuerdo al esquema mostrado en la figura No. 1, la codificación de este programa en formato libre es la siguiente: ! Iniciamos con el titulo del programa program complejos ! Se evita que el programa adopte la variables por defecto implicit none ! Definición de variables complex a,b,c integer n ! Bloque de ejecución ! Ingresa el primer número complejo write(*,*)'Ingrese un número complejo, como par ordenado' read(*,*)a

- 31 -

ESCUELA SUPERIOR POLITECNICA DEL LITORAL FACULTAD DE INGENIERIA MARITIMA Y CIENCIAS DEL MAR PROGRAMACION APLICADA 1 ! Ingresa y se lee desde pantalla el segundo número complejo write(*,*)'Ingrese un número complejo, como par ordenado' read(*,*)b ! Pregunta que tipo de operación desea ! note que se usa formato de escritura write(*,10) read(*,*)n ! Ejecución de las operaciones select case(n) case(1) c=a+b case(2) c=a-b case(3) c=a*b case(4) c=a/b case(5) c=a**b end select ! Presentación de resultados en pantalla write(*,20)c ! Presenta las opciones para operar con complejos 10 format(/' Seleccione la operación que desea realizar',/,& &' 1 Suma',/,' 2 Resta',/,' 3 Producto',/,' 4 Cociente',/,' 5 Potencia') 20 format(' El resultado de la operación es: ','('f10.4,',',f10.4,')') End

Figura No. 6.- Ejecución del programa 2. Escriba un programa que permita guardar la información del ejemplo anterior en un archivo con nombre proporcionado por el usuario. Solución Al código fuente anterior, antes de la declaración „ end’ podemos adicionar las

siguientes líneas:

- 32 -

ESCUELA SUPERIOR POLITECNICA DEL LITORAL FACULTAD DE INGENIERIA MARITIMA Y CIENCIAS DEL MAR PROGRAMACION APLICADA 1 ! Impresión en un archivo de toda esta información write(*,*)'Ingrese el nombre del archivo' read(*,*)archivo ! Abrimos el archivo y le asignamos un número y un status ! Note la condición 'err=100' para evitar que el programa ! termine de manera inesperada, en caso de que el archivo ! no sea nuevo, la ejecución del programa pasa a la línea 100 open(1,file=archivo,status='new',err=100) ! Se escribe la información en el archivo, usando formatos write(1,30) write(1,40)a,b write(1,50)texto,c ! Cerramos el archivo close (1,status='keep') write(*,*)' Se ha generado un archivo de resultados' ! Definimos los formatos de escritura 30 format(/,' ARCHIVO DE RESULTADOS',/,' Calculadora de complejos') 40 format(' Los números imaginarios ingresados son: ',/,'(',f6.3,',',f6.3,')',/,& &' (',f6.3,',',f6.3,')') 50 format(' El resultado de la operación ',a8,' es:', '(',f6.3,',',f6.3,')') 100 end

Previamente deben haberse definido dos variables del tipo alfanuméricas, „archivo‟, para almacenar el nombre del archivo de resultados y „texto‟, para

nombrar el tipo de operación que se realizó con los números. El archivo de resultados se mostraría como se indica en la figura No. 7.

Figura No. 7.- Archivo de resultados.

- 33 -


5.0 Subprogramas, creación y usos Son codificaciones que definen acciones y no tienen las características de un programa principal; de acuerdo a su uso pueden ser: 1. Subrutinas 2. Módulos 3. Funciones 4. Interfaces 5. Bloques de datos

5.1 Subru tinas 5.1.1 Definición Son subprogramas con igual estructura que un programa, salvo por su título, inicia con la línea especificando la expresión SUBROUTINE y depende del tipo de subrutina los argumentos necesarios. Una subrutina se invoca con la declaración CALL desde el programa principal y retorna un valor o varios de la ejecución de la misma.

Existen 3 tipos de subrutinas: 1. Recursiva: permite incidencia de lo ocurrido sobre sí misma 2. Pura: los procedimientos que se ejecuten no pueden incidir sobre sí misma 3. Elemental: los procedimientos están restringidos al hecho de que no se pueden usar los arreglos de manera simultánea. La sintaxis de la línea inicial es la siguiente [prefijo] SUBROUTINE nombre (lista de argumentos) El prefijo es opcional y tiene que ver con el tipo de subrutina descrito en el párrafo anterior: RECURSIVE, PURE, ELEMENTAL, por omisión es pura (PURE). El nombre de la subrutina sigue las mismas reglas que el de un programa principal, es decir, es una cadena alfanumérica que inicia con una letra y no puede contener caracteres especiales, salvo barra baja. La lista de argumentos es opcional, si es que los tiene van separados por comas. Las reglas de su uso: 1. Los argumentos de llamada, si los hay, deben ser del mismo tipo que los usados en la ejecución de la subrutina. 2. La ejecución de la subrutina empieza con la primera línea después del título SUBROUTINE, y retorna el control al programa principal cuando se ha invocado la declaración END o RETURN. 3. Una subrutina no puede contener declaraciones de otros subprogramas. 5.1.2 Ejemplo El siguiente código muestra el llamado a una subrutina PURE, con y sin argumentos para ilustrar su uso. El resultado de la ejecución se muestra en la figura No. 8. program ejemplo implicit none ! Definición de variables real x,y,z

- 34 -

ESCUELA SUPERIOR POLITECNICA DEL LITORAL FACULTAD DE INGENIERIA MARITIMA Y CIENCIAS DEL MAR PROGRAMACION APLICADA 1 ! Bloque de ejecución ! Llamado a subrutina call caratula call calculos(x,y,z) call impresion(x) ! fin de llamado a subrutinas end

! Subrutina Caràtula, para la pantalla ! inicial de presentación subroutine caratula implicit none write(*,10) 10 format(/,' PROGRAMA QUE SUMA DOS NUMEROS REALES',/,& &' Dados Y y Z, obtiene la operación X = Y+Z',/) end subroutine ! Subrutina calculos, solicita la informacion por ! pantalla y calcula el valor subroutine calculos (x,y,z) implicit none real x,y,z write(*,*)' Ingrese el valor de Y' read(*,*)y write(*,*)' Ingrese el valor de Z' read(*,*)z ! realiza el cálculo x=y+z end subroutine ! Subrutina impresion subroutine impresion(x) implicit none real x write(*,10)x 10 format(/,' El resultado es: ',e10.4) End subroutine

Figura No. 8.- Resultado de la ejecución

5.2 Módul os 5.2.1 Definición Es un subprograma que contiene especificaciones y definiciones que pueden ser usadas por otros subprogramas o por un programa principal. El nombre del módulo es

- 35 -


considerado global y único, no puede repetirse en ningún subprograma, función o procedimiento del programa al que pertenece. El módulo no puede hacer referencia a sí mismo y sus subprogramas son independientes entre sí, toda acción ejecutable debe especificarse en éstos. La sintaxis usada para definir un módulo es la siguiente: MODULE nombre

[especificaciones] [CONTAINS subprograma [ subprograma] ...] END [MODULE [nombre ]]

El nombre del módulo debe cumplir las mismas reglas de asignación de nombres que se usan para subrutinas, en la sección de especificaciones se pueden definir variables o definir tipos de información que va a contener, si se usa esta parte de especificaciones es mandatario colocar al final la declaración CONTAINS y luego describir todos los subprogramas que contiene el módulo, sean éstos: subrutinas, funciones, bloques de datos, etc. El módulo finaliza con la declaración END. Para usar un módulo en el programa principal, la declaración USE después del t ítulo del programa es colocada y a continuación el nombre del módulo, el módulo debe compilarse previamente al archivo que contiene el programa principal. El producto de la compilación de un módulo es un archivo con extensión *.MOD que se aloja en la carpeta DEBUG (por defecto) es decir, en el mismo lugar donde se creará el ejecutable. Si no queremos compilar en futuras ocasiones el módulo y lo necesitamos en otro programa, basta con llevar este archivo *.mod, copiado a la carpeta DEBUG del nuevo proyecto. 5.2.2 Ejemplo El ejemplo muestra el uso de módulos para definir variables que serán usadas en el programa principal y las subrutinas que son llamadas desde éste, aunque el programa es sencillo y realiza operación entre complejos, la aplicación en problemas más elaborados es similar.

El código del programa principal es el siguiente: program usomodulo ! Declaración para usar el módulo use ejemplo use variables ! Bloque de ejecución write(*,10) ! Llamada a subrutinas del módulo call primera(a,b) call segunda(a,b,c) call tercera(c) ! Definición de formatos 10 format(/,'PROGRAMA USANDO MODULOS',/) ! Fin del programa principal end

- 36 -


El código del módulo Variables, que hace la declaración de variables usadas en el programa principal, es: module variables real a complex b,c end module variables

El código fuente para el módulo de ejecución de las subrutinas, llamado ejemplo en el programa principal es el siguiente: module ejemplo implicit none contains subroutine primera(x,y) real x complex y write(*,*)'Ingrese un real' read(*,*)x write(*,*)'Ingrese un complejo como par ordenado' read(*,*)y end subroutine subroutine segunda(x,y,z) real x complex y,z z=y*x end subroutine subroutine tercera(z) complex z write(*,*)' La respuesta es' write(*,*)z end subroutine end module ejemplo

El resultado de la ejecución se muestra en la figura No. 9.

Figura No. 9.- Resultado de la ejecución

- 37 -


5.3 Funcio nes 5.3.1 Definición Es un subprograma que evalúa una expresión y retorna un valor, que se almacena en la variable que se usa. Dentro de su bloque de ejecución no puede tener ningún otro tipo de subprograma o hacer referencia a ellos.

La sintaxis que usa una función es la siguiente: [ prefijo] FUNCTION nombre ([lista de argumentos ]) [RESULT (variable)] Bloque que ejecución END FUNCTION [nombre ]

El prefijo es el mismo que se usa para las subrutinas o define el tipo de función que es: entera, real, alfanumérica o compleja; el nombre cumple con las mismas reglas para nombrar subprogramas, la lista de argumentos son las variables de entrada y si es el caso se especifica la variable de salida que resultará de la ejecución de la función. Cuando la función es invocada desde el programa principal simplemente se lo hace con el nombre de la función y el listado de argumentos, de la misma manera que se llama una función implícita del lenguaje. 5.3.2 Ejemplo El siguiente ejemplo ilustra el uso de funciones en un programa principal, la función es del tipo real y obtiene la semisuma de dos números complejos, al final el resultado es mostrado por pantalla.

El código fuente del programa principal es el que sigue: program usofuncion implicit none ! Definición de variables complex x,y,z,semisuma ! bloque de ejecución ! Ingreso de la información write(*,*)'Ingrese un complejo como par ordenado' read(*,*)x write(*,*)'Ingrese un complejo como par ordenado' read(*,*)y ! Cálculo de la función z=semisuma(x,y) ! Escritura de resultados write(*,*)'el resultado es: ' write(*,*)z ! fin del bloque de ejecución end

La función SEMISUMA, se define de la siguiente manera complex function semisuma(x,y) complex x,y semisuma=(x+y)/2.0 end function semisuma

El resultado de la ejecución del programa se muestra en la figura No. 10.

- 38 -


Figura No. 10.- Ejecución del programa

5.4 Interfaces 5.4.1 Definición Es un subprograma que define interfaces explícitas para subprogramas externos o procedimientos. También pueden ser usados para definir un nombre genérico para procedimientos, un nuevo operador para funciones o una nueva asignación para subrutinas. Puede contener subrutinas o funciones.

Una interface va ubicada en el cuerpo del programa y no puede contener la declaración FORMAT, pero si puede hacer referencia a módulos usando la declaración USE. La sintaxis de las interfaces es la siguiente: INTERFACE [ nombre o especificación ] [declaraciones] ... [ MODULE PROCEDURE nombres o lista de nombres ] ... END INTERFACE [ nombre o especificación ]

- 39 -


6.0 Librerías, creación y usos 6.1 Li br erías Es táti cas (Static Li br ari es) 6.1.1 Definiciones Son bloques de codificación compilados que se mantienen separados del programa principal, y corresponden a uno de los tipos de proyecto del Estudio de desarrollo (Developer Studio).

Las librerías estáticas ofrecen ventajas de organización de programas grandes y para compartir rutinas entre varios programas; estas librerías contienen solo subprogramas y el resultado de su compilación es un archivo con extensión *.LIB. Cuando asociamos estas librerías al programa, solamente las rutinas necesarias son enlazadas para la obtención del programa ejecutable, optimizando de esta manera el tamaño de la aplicación. Normalmente estos archivos *.LIB se mantienen en sus propios directorios. 6.1.2 Forma de usar Para crear una Librería Estática, se elije como tipo de proyecto el denominado: FORTRAN STATIC LIBRARY, del cuadro de diálogo, posteriormente se codifica cualquier tipo de subprograma, se compila y obtenemos el archivo .LIB. Cuando queramos usarlo en otro programa o hacer referencia a los subprogramas que contiene, desde otro proyecto, simplemente lo adicionamos al proyecto desde el menú PROJECT/ADD TO PROJECT/FILES, se busca la localización del archivo y se adjunta el archivo. Una vez adicionada en el panel de vistas, localizado a la izquierda del editor debe aparecer a continuación de las carpetas creadas por defecto, con el nombre y la extensión, como muestra la figura No. 11.

Figura No. 11.- Librería adicionada al proyecto Luego se modifica la configuración de enlace usando el cuadro de diálogo SETTINGS/LINK, del menú PROJECT. En este cuadro de diálogo, en el casillero final PROJECT OPTIONS, se escribe la siguiente línea: /nodefaultlib: “libc.lib” para evitar conflictos con las librerías que se asociaron a nuestro archivo LIB, durante su compilación, como se muestra en la figura No. 12. Una vez realizados estos pasos, se compila y construye el ejecutable del proyecto que estamos realizando.

- 40 -


Figura No. 12.- Configuración para adicionar archivos LIB

6.2 Lib rerías d in ám ic as (Dynam ic Li nk Li br aries) 6.2.1 Definiciones Son bloques de codificación compilados que se mantienen separados del programa principal, enlazados independientemente de la aplicación que las usa, y corresponde a uno de los tipos de proyecto del Estudio de desarrollo (Developer Studio). No puede contener un programa principal, solo subprogramas.

Una DLL ofrece ventajas de organización de proyectos superiores a las de una librería estática, generando un ejecutable de menor tamaño, la codificación no está incluida en el programa pero está asociada a él mientras se ejecuta, otra ventaja es que varios programas pueden usar la misma DLL sin que se hayan compilado con ella. En Visual Fortran se pueden generar DLL de dos formas: 1. Eligiendo como tipo de proyecto un DLL, con rutinas propias e independientes. 2. Construir aplicaciones con la opción RUN-TIME LIBRARY almacenada en un lugar dentro del proyecto del programa principal, siguiendo estos pasos: a. En el menú PROJECT seleccionar SETTINGS. b. En la pestaña FORTRAN seleccionar la categoría LIBRARY. c. En el cuadro USE FORTRAN RUN-TIME LIBRARIES, seleccionar DLL. 6.2.2 Forma de usar 1. Codificación de un archivo DLL: se requiere incluir en las directivas de compilación: cDEC$ ATTRIBUTES DLLIMPORT o DLLEXPORT , las variables deben ser declaradas en el programa principal y en la DLL.

- 41 -


2. Si en un programa o subprograma se usa la declaración DLLEXPORT, declara que el subprograma proviene de una DLL, que será usado por otra programa o subprograma exterior a la DLL. Si se usa la declaración DLLIMPORT, declara que el subprograma necesario para alguna ejecución proviene de una DLL. 3. Para construir una DLL se siguen los siguientes pasos: a. Seleccionar el tipo de proyecto como DLL b. Codificar el subprograma con las opciones de directivas de compilación y crear el archivo DLL. c. Importar al proyecto principal que usará la DLL, con la opción Add to Project el archivo LIB que se genera en la creación de la DLL. d. Compilar el Proyecto principal, copiar el archivo DLL al directorio que contiene el ejecutable del proyecto principal. 4. Las DLL solo pueden usarse en proyectos del tipo Standard Console, para leer y escribir, y en cualquier tipo de proyecto solo para realizar cálculos, no ingreso de datos ni lectura desde pantalla o archivos, no pueden usarse en Quick Win Application, con el módulo DFLIB. 6.2.3 Ejemplo Se va a realizar la codificación del proyecto DLL y luego la del programa principal, para ilustrar el uso de las librerías DLL.

Se crearán 4 subrutinas divididas en 2 archivos DLL, uno para realizar sumas y restas y otro para división y multiplicación. Las variantes que se hacen es que en el de sumas y restas se generan un archivo para cada subrutina, contenidos en el mismo proyecto. Y para el caso de producto en el mismo archivo se generan las dos subrutinas. El código del programa principal es el siguiente: program main !DEC$ ATTRIBUTES !DEC$ ATTRIBUTES !DEC$ ATTRIBUTES !DEC$ ATTRIBUTES implicit none real :: x,y,z

DLLIMPORT::LIBRERIAS DLLEXPORT::PRODUCTOS DLLEXPORT::CASOS DLLEXPORT::COCIENTES

write(*,*)'Ingrese x' read(*,*)x write(*,*)'Ingrese Y' read(*,*)y call librerias(x,y,z) write(*,*)'la suma es: ',z call casos(x,y,z) write(*,*)'La resta es: ',z call productos(x,y,z) write(*,*)'El producto es: ',z call cocientes(x,y,z) write(*,*)'El cociente es: ',z end

- 42 -


En este código podemos observar que la declaración de atributos se hace para cada subrutina, no para cada archivo, las cuatro líneas se pueden simplificar usando comas para separar el nombre de las subrutinas. Las subrutinas del para sumar y restar son las siguientes, una en cada archivo. ! LIBRERIAS.f90 ! FUNCTIONS/SUBROUTINES exportadas desde LIBRERIAS.dll: ! LIBRERIAS - subroutine ! subroutine LIBRERIAS(X,Y,Z) !DEC$ ATTRIBUTES DLLEXPORT::LIBRERIAS implicit none real :: x,y,z z = x+y end subroutine LIBRERIAS ! Fin del archivo ! LIBRERIAS.f90 ! FUNCTIONS/SUBROUTINES exportadas desde LIBRERIAS.dll: ! LIBRERIAS - subroutine ! subroutine CASOS(X,Y,Z) !DEC$ ATTRIBUTES DLLEXPORT::CASOS implicit none real :: x,y,z z = x-y end subroutine CASOS ! Fin del archivo

La codificación de las subrutinas para productos en el mismo archivo es la siguiente: ! PRODUCTOS.f90 ! FUNCTIONS/SUBROUTINES exported from PRODUCTOS.dll: ! PRODUCTOS - subroutine ! subroutine PRODUCTOS(x,y,z) !DEC$ ATTRIBUTES DLLEXPORT::PRODUCTOS implicit none real :: x,y,z z = x*y end subroutine PRODUCTOS !---------------------------------------------------! PRODUCTOS.f90 ! FUNCTIONS/SUBROUTINES exported from PRODUCTOS.dll: ! PRODUCTOS - subroutine ! subroutine cocientes(x,y,z) !DEC$ ATTRIBUTES DLLEXPORT::COCIENTES implicit none real :: x,y,z z = x/y end subroutine cocientes ! Fin del archivo

- 43 -


7.0 Personalización de programas 7.1 Generalidades Para acceder a las librerías de QUICK WIN GRAPHICS, se debe usar la declaración USE DFLIB, ubicada después del nombre del programa. Si se va a usar otras opciones de Visual es necesario adicionar sentencias adicionales. Estas librerías son de interfase, almacenadas en el módulo DFLIB.MOD 7.2 Prop iedades d e la ventana Las funciones que controlan el tamaño de la ventana virtual y la ventana visible y tamaños de letra y resolución son SETWINDOWCONFIG y GETWINDOWCONFIG, para la ventana virtual y SETWSIZEQQ para la ventana visible, normalmente más pequeña que la virtual. Las configuraciones posibles son: TYPE windowconfig INTEGER(2) numxpixels INTEGER(2) numypixels INTEGER(2) numtextcols INTEGER(2) numtextrows INTEGER(2) numcolors INTEGER(4) fontsize CHARACTER(80) title INTEGER(2) bitsperpixel

! ! ! ! ! ! ! ! ! ! !

Número de pixels eje X Número de pixels eje Y Número de columnas para texto Number de filas de texto Indice del color Tamaño de la fuente. Título de la ventana (caracteres) Números de bits por pixel. Este valor es calculado por el sistema y es parámetro de salida.

END TYPE windowconfig

Ejemplo de codificación para personalizar las propiedades de la ventana: USE DFLIB TYPE (windowconfig) wc LOGICAL status ! Configura x & y pixels a 800X600 y el tamaño de la fuente en 8x12. wc.numxpixels = 800 wc.numypixels = -1 wc.numtextcols = -1 wc.numtextrows = 302 wc.numcolors = -1 wc.title = " "C wc.fontsize = #0008000C status = SETWINDOWCONFIG(wc)

7.3 Creación d e m últipl es ven tanas Para crear varias ventanas se debe usar la opción FILE=‟USER‟ de la sentencia OPEN.

Por defecto la ventana hija tiene un tamaño de 30 filas y 80 columnas y se puede abrir hasta 40 ventanas. OPEN(UNIT=10, FILE=‟USER‟,TITLE=‟Ventana adicional‟)

- 44 -


Para que esta ventana sea activa debe recibir salidas de texto o gràficos pero no por eso al estar abierta con otras ventanas ésta es la superior o la primera que se presenta, para que esto ocurra se debe usar la sentencia IOFOCUS, en las opciones de la sentencia OPEN o como una función INQFOCUSQQ del tipo entero. OPEN(UNIT=10,FILE=‟USER‟,TITLE=‟Ventana Adicional‟, IOFOCUS=.TRUE.) USE DFLIB INTEGER(4) status, focusunit OPEN(UNIT = 10, FILE = 'USER', TITLE = 'Child Window 1') OPEN(UNIT = 11, FILE = 'USER', TITLE = 'Child Window 2') ! Convierte en ventana active a la ventana 2 WRITE (11, *) 'Giving focus to Child 2.' ! Convierte en ventana activa a la 1 con la función FOCUSQQ status = FOCUSQQ(10) ... ! Determina que ventana está activa y la almacena en la variable status = INQFOCUSQQ(focusunit)

El tamaño y ubicación de la ventana secundaria se la controla con la función SETWSIZEQQ como se indica en el ejemplo USE DFLIB INTEGER(4) status TYPE (QWINFO) winfo OPEN (4, FILE='USER') winfo.H = 30 winfo.W = 80 winfo.TYPE = QWIN$SET status = SETWSIZEQQ(4, winfo)

o si se quiere simplemente maximizar la ventana se adiciona en el programa la siguiente línea: status = GETWSIZEQQ(QWIN$FRAMEWINDOW, QWIN$SIZEMAX, winfo)

El control de colores del fondo de las ventanas va de acuerdo al monitor que se disponga, para los VGA usa 256 colores. Lla variable que controla el color del fondo es del tipo entera, la sintaxis es la siguiente: la función SETBKCOLOR usa 16 colores I = SETBKCOLOR (14) call clearscreen($gclearscreen)

Si se usa la función SETBKCOLORRGB, el número debe ser escrito en hexadecimal, la opción es de usar 256 colores.

7.4 Graficación y escri tur a en la pant alla Fortran considera la pantalla en pixeles, donde el origen se encuentra en la esquina superior izquierda, siendo X positivo hacia la derecha y Y positivo hacia abajo. Sin embargo el origen puede reubicarse usando la subrutina SETVIEWORG, la sintaxis empleada es la siguiente: TYPE (xycoord) origen CALL SETVIEWORG(INT2(x), INT2(y), origen)

- 45 -


Y a partir de esta llamada la convención se signos se mantiene. Para colocarnos en cualquier lugar de la pantalla se usa la subrutina MOVETO, con la siguiente sintaxis: TYPE (xycoord)xy CALL MOVETO(INT2(x), INT2(y), XY)

Finalmente podemos definir la ventana de trabajo con la subrutina SETVIEWPORT, e ingresando las coordenadas que definen el rectángulo de la ventana, el origen de esta ventana se encuentra en la parte superior izquierda. CALL SETVIEWPORT (x1, y1, x2, y2)

Para escribir texto en pantalla se debe definir primero el color del texto y luego otras configuraciones usando la subrutina OUTGTEXT y el texto que debe mostrarse, las líneas de código para hacerlo son: TYPE (xycoord) xys ! Inicio de la configuración del texto a escribirse I = INITIALIZEFONTS() ! Características de la fuente: tipo, tamaño, etc… I = SETFONT('t''Arial''h18w10pvib') ! Color de la fuente un número del 1 al 16 I = SETCOLOR(INT2(5)) ! Ubicación del texto en pixels dentro de la ventana active, nótese ! que se necesita definer un tipo de objeto coordenadas CALL MOVETO(INT2(0),INT2(30),xys) ! Texto que se escribirá CALL OUTGTEXT('he escrito este texto')

Para dibujar figuras, la secuencia es la misma solo que en lugar de llamar a la subrutina OUTGTEXT, se usa la función de la figura que se desea dibujar. Esta función es del tipo entera, las funciones que soporta FORTRAN son líneas, rectángulos, elipses y polígonos. Además de relleno de estas figuras y opciones de estilo de línea, siempre usando como coordenadas los píxeles. ! Dibuja un rectángulo/elipse, el parámetro control puede tener dos valores: ! $GFILLINTERIOR que indica que el rectángulo será coloreado ¡ totalmente y no se podrá definir la línea de contorno, y $GBORDER ¡ dibuja el contorno del rectángulo/elipse y el interior transparente. ¡ x1,y1,x2,y2 son las coordenadas en pixeles de la esquina superior ¡ izquierda y la esquina inferior derecha. i = RECTANGLE (control, x1, y1, x2, y2) i = ELLIPSE(control, x1,y1,x2,y2) ! Dibuja una línea desde la posición actual hasta las coordenadas en ! pixels x,y. i = LINETO(x,y) ! ! ¡ ¡ ¡ ¡ i

Dibuja un polígono de n lados, el parámetro control puede tener dos valores: $GFILLINTERIOR que indica que el rectángulo será coloreado totalmente y no se podrá definir la línea de contorno, y $GBORDER dibuja el contorno del polígono y el interior transparente. ppoints es un arreglo que contiene las coordenadas de los vértices del polígono, en pixeles. Cpoints es el número de vértices. = POLYGON (control, ppoints, cpoints)

- 46 -


7.5 Ins ertan do im ágen es Para insertar imágenes en la pantalla se usa la función entera LOADIMAGE, que tiene 3 argumentos: el nombre del archivo, formato *.BMP y las coordenadas en pixeles observando las normas descritas. i = LOADIMAGE ('name.bmp', ixcoord, iycoord)

Es importante tomar en cuenta que el formato de mapa de bits no comprime las imágenes por lo que los archivos suelen ser demasiado grandes. Si el archivo que se intenta insertar en pantalla es más grande en pixeles que el tamaño de la ventana virtual, FORTRAN ignora la imagen. Si se inserta alguna imagen comprimida la ignora, ya sea de formato *.JPG, *.GIF, *.PNG

7.6 Mensajes de aviso La función que controla los cuadros de mensajes es MESSAGEBOXQQ, del tipo entera y usa los siguientes argumentos: mensaje, título y objetos (botones y/o íconos) I4 = messageboxqq(„mensaje‟C,‟titulo‟C,objeto.or.objeto.or.objeto)

1. MB$ABORTRETRYIGNORE: Botón de aborta, reintentar o ignorar. 2. MB$DEFBUTTON1: Primer botón activado por defecto. 3. MB$DEFBUTTON2: Segundo botón activado por defecto. 4. MB$DEFBUTTON3: Tercer botón activado por defecto. 5. MB$ICONASTERISK: Icono de globo con letra I en azul. 6. MB$ICONEXCLAMATION: Triángulo amarillo con el símbolo admiración. 7. MB$ICONHAND: Círculo rojo con X blanca. 8. MB$ICONINFORMATION: Icono de globo con letra I en azul. 9. MB$ICONQUESTION: Icono de globo con ¿ en azul. 10. MB$ICONSTOP: Icono de error. 11. MB$OK: OK. 12. MB$OKCANCEL: OK y Cancelar. 13. MB$RETRYCANCEL: Reintentar y cancelar. 14. MB$SYSTEMMODAL: El cuadro es del tipo modal, toda ejecución se suspende hasta que el usuario ejecute el cuadro. 15. MB$YESNO: Si y NO. 16. MB$YESNOCANCEL: Si, No y Cancelar

Figura No. 13.- Ejemplo de Mensaje de aviso El resultado de esta función es un entero del tipo que se presenta cuando el botón respectivo ha sido presionado: 1. MB$IDABORT. - 47 -


2. 3. 4. 5. 6. 7.

MB$IDCANCEL. MB$IDIGNORE MB$IDNO. MB$IDOK. MB$IDRETRY MB$IDYES

Para evaluar las opciones se puede usar SELECT CASE y especificar las acciones para cada botón que se presione. El cuadro de diálogo ABOUT (Acerca de…), de los menús de Ayuda de la barra de menús de los programas típicos pueden personalizarse, por defectos se muestran como se grafica en la figura No. 14.

Figura No. 14.- Cuadro ABOÜT La función entera: i = ABOUTBOXQQ („Ejemplo 1.0\r(c) 2006‟C), personaliza este cuadro .

de personalización\rVersión

Figura No. 15.- Personalización del cuadro ABOUT

7.7 Perso nalizar el m enú de op cio nes La función que controla el menú es una del tipo lógica que no es necesario llamarla desde el programa principal, basta con incluirla en alguna parte del código fuente y se actualizará el menú. Cuando se omite esta función el menú que aparece es el de defecto. LOGICAL(4) FUNCTION INITIALSETTINGS( ) USE DFLIB EXTERNAL Subrutina1, subrutina2 LOGICAL(4) result ! Crea el primer menu llamado GAMES. result = APPENDMENUQQ(1, $MENUENABLED, '&Games'C, NUL ) ! Adiciona un item al menú llamado TicTacToe.

- 48 -


result = APPENDMENUQQ(1, $MENUENABLED, '&TicTacToe'C, WINPRINT) ! Dibuja una línea de separación. result = APPENDMENUQQ(1, $MENUSEPARATOR, ''C, NUL ) ! Adiciona un item llamado Salir. result = APPENDMENUQQ(1, $MENUENABLED, 'S&alir'C, WINEXIT ) ! Crea un Segundo menu llamado Ayuda. result = APPENDMENUQQ(2, $MENUENABLED, '&Ayuda'C, NUL ) result = APPENDMENUQQ(2, $MENUENABLED, '&QuickWin Help'C, WININDEX) INITIALSETTINGS= .true. END FUNCTION INITIALSETTINGS

Del código anterior se observa que la función que controla las variaciones del menú es la función lógica APPENDMENUQQ que tiene 4 argumentos: el número de secuencia en la que se creará el menú, el primer menú y sus submenús tienen el número 1, el segundo 2 y así en adelante, FLAGS corresponde a las opciones que se listan a continuación; TEXT el texto que aparecerá en el menú o submenú: ROUTINE, es la rutina que se ejecuta cuando se selecciona este menú, puede ser una rutina por defecto del sistema o rutinas creadas por el usuario. log = APPENDMENUQQ (menuID, flags, text, routine)

La opciones del parámetro de estado FLAGS de menú son: 1. 2. 3. 4. 5. 6.

$MENUGRAYED - Disables and grays out the menu item. $MENUDISABLED - Disables but does not gray out the menu item. $MENUENABLED - Enables the menu item. $MENUSEPARATOR - Draws a separator bar. $MENUCHECKED - Puts a check by the menu item. $MENUUNCHECKED - Removes the check by the menu item.

Si queremos activar una tecla de acceso rápido para usar un menú o submenú con ALT+LETRA, se coloca un & delante de la letra del nombre que aparecerá como menú o submenú que queremos activar y ésta aparecerá en la ventana de ejecución del programa subrayada. El parámetro ROUTINE corresponde al paso del comando a una subrutina, propia de FORTRAN o una creada por el usuario, en caso de que el usuario las haya creado se usa la sentencia EXTERNAL luego de USE DFLIB, para declarar estas subrutinas. Las rutinas de FORTRAN son: 1. 2. 3. 4. 5. 6. 7.

WINPRINT - Prints the program. WINSAVE - Saves the program. WINEXIT - Terminates the program. WINSELTEXT - Selects text from the current window. WINSELGRAPH - Selects graphics from the current window. WINSELALL - Selects the entire contents of the current window. WINCOPY - Copies the selected text and/or graphics from the current window to the Clipboard. 8. WINPASTE - Allows the user to paste Clipboard contents (text only) to the current text window of the active window during a READ. 9. WINCLEARPASTE - Clears the paste buffer. 10. WINSIZETOFIT - Sizes output to fit window. 11. WINFULLSCREEN - Displays output in full screen. 12. WINSTATE - Toggles between pause and resume states of text output.

- 49 -


13. WINCASCADE - Cascades active windows. 14. WINTILE - Tiles active windows. 15. WINARRANGE - Arranges icons. 16. WINSTATUS - Enables a status bar. 17. WININDEX - Displays the index for QuickWin help. 18. WINUSING - Displays information on how to use Help. 19. WINABOUT - Displays information about the current QuickWin application. 20. NUL - No callback routine. Cuando se desea simular selecciones de menú se usa la función entera CLICKMENUQQ, con una de estas opciones: 1. 2. 3. 4.

QWIN$STATUS: Status command QWIN$TILE: Tile command QWIN$CASCADE: Cascade command QWIN$ARRANGE: Arrange Icons command

i = CLICKMENUQQ (item)

7.8 Iconos de progr amas La generación de íconos personalizados que aparecen cuando se minimiza la ventana principal y como íconos de las aplicaciones finales, se lo hace mediante los siguientes pasos: 1. Seleccione desde el menú INSERT, de la barra principal la opción RESOURCE; de la lista que aparece, seleccione ICON. La ventana de herramientas de dibujo aparece. 2. Dibuje el ícono. 3. Ponga nombre al ícono, en la ventana principal debe llamarse “frameicon” y si se quiere colocar en la ventana hija, se crea un o con el nombre de “childicon”, para abrir el cuadro de propiedades de objeto presione ALT+ENTER, y en el campo destinado para el ID (identificador del recurso) coloque el nombre. Ver figura No. 16 4. Guarde el ícono, seleccionando del menú FILE la opción SAVE AS, en un archivo del tipo “*.rc”, por defecto el programa le asigna e l nombre “script.rc”.

5. Adicione este archivo al proyecto, siguiendo la siguiente línea de comandos: Project/add to project/files. 6. Al compilar, el programa, el o los íconos se ubicarán en los sitios designados.

Figura No. 16.- Designación de ícono de programa

- 50 -


7.9 Eventos del ratón En la ventana de trabajo de Fortran, el programa puede detectar y responder a los eventos que se ejecutan con el ratón. Dentro de Visual Fortran se provee dos tipos de funciones para este control: las funciones basadas en eventos y las funciones de bloqueo de ejecución. 7.9.1 Funciones basadas en eventos Existen dos funciones enteras basadas en eventos: REGISTERMOUSEEVENT y UNREGISTERMOUSEEVENT, normalmente el evento es el movimiento o click con alguno de los botones, el primero ejecuta una acción al dar click o mover el ratón, el segundo libera la memoria del programa de esta acción. La sintaxis que usa la función es la siguiente: I = REGISTERMOUSEEVENT (UNIT,EVENTO,RUTINA) I = UNREGISTERMOUSEEVENT (UNIT,EVENTO)

„UNIT‟ corresponde a la unidad asignada a la ventana de trabajo. En caso de ser la ventana abierta por defecto la unidad es „0‟ ; EVENTO corresponde a uno de los eventos

del ratón detallados en la tabla No. 10 y RUTINA corresponde a una subrutina declarada como EXTERNAL que es la que ejecuta una acción cuando ocurre el evento. EVENTO DEL RATON

DESCRIPCION

MOUSE$LBUTTONDOWN Click con el botón izquierdo MOUSE$LBUTTONUP Soltar el botón izquierdo MOUSE$LBUTTONDBLCLK Doble click con el botón izquierdo MOUSE$RBUTTONDOWN Click con el botón derecho MOUSE$RBUTTONUP Soltar el botón derecho MOUSE$RBUTTONDBLCLK Doble click con el botón derecho MOUSE$MOVE Movimiento del ratón Tabla No. 10.- Eventos del Ratón Estas subrutinas cuando se las codifica deben constar en su línea inicial con los siguientes argumentos enteros: SUBROUTINE RUTINA(UNIT,EVENTO,ESTADO,X,Y)

Donde UNIT es la unidad asignada a la ventana de trabajo, EVENTO es cualquiera de los eventos descritos en la tabla No. 10, ESTADO es la consecuencia de ejecutar un evento, éstos se encuentran detallados en la tabla No. 11, X y Y es la posición en pixeles de la ventana de trabajo donde ocurre el evento. ESTADO

DESCRIPCION

MOUSE$KS_LBUTTON Click en el botón izquierdo durante el evento MOUSE$KS_RBUTTON Click en el botón derecho durante el evento MOUSE$KS_SHIFT La tecla SHIFT aplastada durante el evento MOUSE$KS_CONTROL La tecla CONTROL aplastada durante el evento Tabla No. 11.- Estado de los eventos del ratón

- 51 -


7.9.2 Ejemplo El siguiente código ejemplariza el uso de las funciones basadas en eventos; las acciones de escribir en pantalla algo específico pueden ser reemplazados por cualquier acción. En este caso se ha escrito la acción realizada y la posición en pixeles dentro de la pantalla además dibuja una línea gris con el botón izquierdo y coloca un punto amarillo con el derecho, en la posición X,Y. program principal use dflib external rutina, rutina2 integer :: i open(1,file='user', title='Ventana 1') write(1,*)'Eventos del Ratón' i = registermouseevent(1,mouse$lbuttondown,rutina) i = registermouseevent(1,mouse$rbuttondown,rutina2) do while(.true.) enddo end subroutine rutina(unidad,evento,estado,x,y) use dflib integer :: i,evento,estado,x,y,unidad write(unidad,*)'click izquierdo' write(unidad,*)x,y i = setcolor(8) i = lineto(x,y) end subroutine rutina2(unidad,evento,estado,x,y) use dflib integer :: i,evento,estado,x,y,unidad write(unidad,*)'click derecho' write(unidad,*)x,y i = setcolor(14) i = RECTANGLE($GBORDER, x, y, x+2, y+2 ) end

El resultado de la ejecución de la subrutina se presenta en la figura No. 17


- 52 -


7.9.3 Funciones de bloqueo de ejecución La función entera WAITONMOUSEEVENT es una función que detiene la ejecución del programa hasta que se ejecute alguna acción con el ratón. La sintaxis y argumento de esta función son los siguientes: I = WAITONMOUSEEVENT (EVENTO,ESTADO,X,Y)

Donde EVENTO son los mismos descritos en la tabla No. 10, ESTADO son los enunciados en la tabla No. 11, y, X y Y es la posición en pixeles de la ventana donde ocurre el evento. Como la función bloquea la ejecución del programa, debe primero definirse un evento para esperar su ejecución. El esquema general de codificación de esta función se ilustra en el siguiente ejemplo: event=mouse$lbuttondown event=ior(event,mouse$move) i=registermouseevent(unit,event,rutina) do while (.true.) i=waitonmouseevent(mouse$move,estado,x,y) enddo

7.9.4 Ejemplo El siguiente ejemplo ilustra como se codifica una aplicación para dibujar a mano alzada, con el botón derecho con líneas color verde y con el botón izquierdo con rectángulos blancos de aspecto sólido. program subrutina use dflib external boceto integer i,event,unit,estado,x,y unit=0 event=mouse$lbuttondown event=ior(event,mouse$move) i=registermouseevent(unit,event,boceto) do while (.true.) i=waitonmouseevent(mouse$move,estado,x,y) enddo end subroutine boceto(unit,event,estado,x,y) use dflib integer i,x,y,event,estado,unit type(xycoord)xys selectcase(estado) case(mouse$ks_lbutton) i = SETCOLOR(15) I = rectangle($gfillinterior,x-2,y-2,x+2,y+2) case(mouse$ks_rbutton) I = SETCOLOR(10) i = lineto(x,y) case default I = SETCOLOR(0) i = lineto(x,y)

- 53 -


endselect end subroutine

El resultado de la ejecución de esta aplicación se ilustra en la figura No. 18

Figura No. 18.- Resultado de la ejecución de la aplicación

7.10 Cuadro s de d iálog o pers on alizados La creación de cuadros de diálogos sigue esta línea de comandos: Insert/Resource/dialog, aparece el ambiente y las herramientas para crear los cuadros. Presionando ALT+ENTER, o haciendo doble click sobre el cuadro se abren las opciones y propiedades del recurso; es importante tener en cuenta el identificador, por defecto el identificador el IDD_DIALOG1, pero el nombre puede cambiarse, manteniendo el prefijo IDD_*, de igual forma se hace con todos los recursos que se utilicen, cuadros de texto fijo, texto variable, menús desplegables, etc.

Figura No. 19.- Cuadro de propiedades del cuadro de diálogo

- 54 -


Para que el programa principal muestre el cuadro de diálogo, se procede de la siguiente forma: 1. Se declara el módulo DFLOGM. 2. Si existen rutinas externas se las declara con la sentencia EXTERNAL. 3. En la definición de variables se considera una variable entera y dos variables lógicas. Además se define un objeto tipo: TYPE(Dialog)dlg. (dlg corresponde al nombre de una variable asignada) 4. Al final de la declaración de variables se incluye la sentencia: INCLUDE „RESOURCE.FD‟ . Esta sentencia es una adaptación de Fortran para permitir usar elementos de Visual C++. 5. Un cuadro de diálogo, una vez creado como objeto, se lo inicializa con la función lógica: log = DLGINIT(IDD_DIALOG,dlg) 6. Para asignar tareas al botón Aceptar o cualquier botón se usa la función lógica: log = DLGSETSUB(dlg,ID*,), donde el ID corresponde al identificador del botón colocado cuando se crea; el nombre de la subrutina corresponde a la declarada con la sentencia EXTERNAL. 7. Finalmente para presentar el cuadro en la ventana se usa la función entera i = DLGMODAL (dlg), esto indica que la ejecución del programa se detiene hasta que se ejecute una acción en el cuadro de diálogo. El tipo de proyectos QUICK WIN solo soporta este tipo de cuadros. 8. La subrutina a la cual se le pasa el comando a través del botón OK o de cualquier botón debe tener en su encabezado el siguiente formato: subroutine adquirir(dlg,IDOK,dlg_clicked) program introduccion ! Definición de módulos use dflib use dflogm use dfnls ! Definición de subrutinas que ejecutarán la acción external adquirir ! Definición de de variables logical l4,l, integer i type(dialog)dlg include 'resource.fd' ! Inicialización del cuadro de diálogos l = dlginit(idd_dialog1,dlg) l4 = dlgsetsub(dlg,idok, adquirir) i = dlgmodal(dlg) end

7.10.1 Agregar controles al cuadro de diálogo:

Edit box y Static Text Los „editores de texto‟ y „membretes‟ de Visual, no leen ni escriben valores numéricos,

sino solamente lo hacen del tipo alfanumérico, por lo que es necesario realizar una transformación del texto en valores numéricos. La sintaxis, que se sigue, se muestra en el ejemplo a continuación.

- 55 -


La variable que define la función „dlgget‟ (adquirir) es del tipo lógica; „dlg‟, es la definición del tipo de cuadro, IDC_INT es el identificador del cuadro de texto en el cuadro de diálogo, „texto‟ es una variable del tipo alfanumérica, „xint‟ es una variable

del tipo real o la que se haya definido. log = dlgget(dlg,IDC_INT,texto) read(texto,*)xint

Si se desea que lea con algún formato la sintaxis es la siguiente: log = dlgget(dlg,IDC_INT,texto) read(texto,‟(f6.8)‟)xint

El caso inverso, es decir, cuando se quiere escribir en un editor de texto el resultado de una operación, hay que hacer la transformación de la cifra numérica en caracteres de texto, siguiendo la sintaxis que se presenta a continuación: Write(texto,*)xint Log = dlgset(dlg,IDC_RES,texto).

Radio Buttons y Check Box Estos controles operan con una variable lógica, y la función que almacena la información del control es: log = dlgget(dlg,id_control,Variable_logica)

La función para asignar el valor lógico a la variable de cada control es DLGSET con iguales argumentos que el caso anterior. List Boxes y Combo Boxes Usados cuando el usuario necesita seleccionar un valor desde una lista de varias opciones desplegables; inclusive el número de entradas de las listas puede ser alterado durante la ejecución del programa. La diferencia entre los dos radica en que un LIST BOX es una simple lista de ítems, mientras que el COMBO BOX es una combinación de un LIST BOX y EDIT BOX, es decir mientras en la primera solo puede elegirse una de las opciones escritas, en la segunda se puede editar la entrada. Para ambos casos el índice de control es: DLG_NUMITEMS que determina cuántos ítems se colocarán en la lista. Una vez asignado este valor, se colocan los ítems que serán listados en el control, la secuencia comienza en 1 y termina en el número que ha sido asignado con el control: DLG_NUMITEMS. La función que controla estas características es del tipo lógica y es DLGSET. Ejemplo: log log log log

= = = =

DlgSet DlgSet DlgSet DlgSet

( ( ( (

dlg, dlg, dlg, dlg,

IDC_LISTBOX1, IDC_LISTBOX1, IDC_LISTBOX1, IDC_LISTBOX1,

3, DLG_NUMITEMS ) "Proa",1 ) "Popa", 2 ) "Sección Media", 3 )

Se puede cambiar en cualquier momento la lista o los valores de la lista, el nuevo ítem, simplemente se define en una línea de código como sigue: log = DLGSET ( dlg, IDC_LISTBOX1, 4) log = DLGSET ( dlg, IDC_LISTBOX1, "Cubierta", 4)

- 56 -


Para leer desde un LIST BOX, se usa la función lógica DLGGET. Hay que aclarar que solamente se leen caracteres, por lo que si existe un valor numérico en la lista, es necesario hacer una reasignación de variables, como se detalló en la sección de los EDIT BOX. La sintaxis empleada es la siguiente: log = DLGGET (dlg, id_control, Variable_texto)

Progress Bar, Scroll Bar y Slider En el código fuente se coloca el rango mínimo y máximo del progreso de la barra usando las funciones lógicas DLG_RANGEMIN y DLG_RANGEMAX, y la posición actual usando la función DLG_POSITION. Para ambos casos el valor debe ser entero y está considerado entre 0 y 65535. Los valores que se asumen por defecto son 1 y 100. Con la siguiente función se coloca el rango máximo, en lugar de la declaración DLG_RANGEMAX, se coloca cualquiera de las anteriores funciones, y tendríamos una actualización de la barra de progreso, scroll o slider. log = DLGSET (dlg, id_control, valor_entero,DLG_RANGEMAX)

Otros controles pueden encontrarse en la ayuda de DVF Ejemplo El siguiente código adiciona elementos a un cuadro de diálogo, el resultado de la ejecución se presenta en la figura No. 20. ! TAMBIEN SE PUEDE CODIFICAR EN FORMATO FIJO ! El programa muestra un cuadro de diálogo de donde se lee texto ! y opciones lógicas, luego escribe en pantalla y en el mismo cuadro ! de diálogo, con lo que se completan las funciones básicas de operación ! de un cuadro en Fortran. Antes de escribir una secuencia o línea de ! comando se explica brevemente el porqué. ! ! El proceso de creación de un cuadro de diálogos es el siguiente ! del menú INSERT - RESOURCE - DIALOG - NEW. Con esta secuencia se abre el ! editor de cuadro de diálogos. ! ! Desde la barra de controles se insertan los objetos, en este ejemplo se han ! insertado 2 EditBox, 1 StaticText, 2 RadioButton, 1 CheckBox y se conservaron los ! botones OK,Cancel. Con doble click en cada objeto se abre el cuadro de ! propiedades donde se pueden cambiar algunas opciones. En el identificador ! se puede cambiar a partir del _ para personalizar los nombres. ! una vez terminado el diseño en el cuadro de diálogos se graba, por defecto ! se abre la última ventana de grabación, así que es prudente colocar este ! nuevo archivo en el mismo directorio del Espacio de Trabajo y del Proyecto ! por defecto el nombre es 'Script1.RC', si se desea se puede cambiar caso ! contrario da igual, el siguiente paso es adicionar al proyecto este archivo ! siguiendo la secuencia: PROJECT - ADD TO PROJECT - FILES - Seleccionar el ! archivo *.rc ! ! Finalmente compilar, concatenar y ejecutar ! ! El archivo 'resource.fd' es producto de la compilación del archivo ! 'Script1.rc', así que no es creado, el único que debe ser codificado ! es este archivo ! ! Demasiado fácil como para no hacerlo. program dialogos

- 57 -


use dflogm ! módulo necesario para usar cuadros de diálogos use dflib integer(4) i4 logical result type (qwinfo) winfo winfo%TYPE = QWIN$MAX ! Maximiza la ventana principal result = SETWSIZEQQ(QWIN$FRAMEWINDOW, winfo) ! Maximiza la ventana hija result = SETWSIZEQQ(0, winfo) ! Color del fondo de la ventana gris i4 = setbkcolorrgb(#C0C0C0) call clearscreen($gclearscreen) write(*,*)' ' do while (.true.) enddo end ! Función que controla la barra de menús LOGICAL(4) FUNCTION INITIALSETTINGS( ) USE DFLIB ! Subrutinas a las que se pasa el mando cuando se selecciona un menú external acerca,nuevo LOGICAL(4) result result = APPENDMENUQQ(1, $MENUENABLED, '&Archivo'C, NUL ) result = APPENDMENUQQ(1, $MENUENABLED, '&Nuevo'C,nuevo) result = APPENDMENUQQ(1, $MENUENABLED, '&Guardar'C, WINSAVE) result = APPENDMENUQQ(1, $MENUSEPARATOR, ''C, NUL ) result = APPENDMENUQQ(1, $MENUENABLED, '&Salir'C, WINEXIT ) result = APPENDMENUQQ(2, $MENUENABLED, '&Ayuda'C, NUL ) result = APPENDMENUQQ(2, $MENUENABLED, '&A&cerca'C, acerca) INITIALSETTINGS= .true. END FUNCTION INITIALSETTINGS ! Subrutinas que ejecutan los menús seleccionados como nuevo o acerca subroutine nuevo ! Librería necesaria para trabajar con cuadros de diálogos, viene ! instalada con el compilador DVF, pero es necesario expresarla use dflogm ! Nombre de la subrutina que es llamada cuando se ejecuta una acción ! en el cuadro, para este caso click en OK external subrutina logical log integer i4 ! Declaración del tipo de objeto a usarse. 'dlg' es una variable ! puede tener cualquier nombre type(dialog)dlg ! Producto de la compilación del cuadro de diálogos, no puede cambiarse ! el nombre. include 'resource.fd' ! ! ! !

Función lógica que inicializa el cuadro de diálogo, la función tiene dos argumentos: 1. Identificador del cuadro IDD_NOMBRE (NOMBRE puede ser personalizado) 2. La variable definida en TYPE

- 58 -


log = DlgInit(IDD_DIALOG1,dlg) ! Acciòn que se ejecuta al hacer click en el botón OK ! Función lógica que pasa la ejecución del programa a la subrutina ! Tiene tres argumentos ! 1. La variable que define al cuadro (TYPE) ! 2. El identificador del botón que se ejecuta para pasar el mando ! 3. Nombre de la subrutina que continua con la ejecución del programa log = DlgSetSub (dlg,IDOK,Subrutina) ! Función entera que muestra al cuadro de diálogo en pantalla ! requiere un argumento, la variable que define al cuadro (TYPE) i4 = DlgModal(dlg) ! ! ! ! !

Para cerrar el cuadro de diálogos se llama a la subrutina DLGEXIT debe hacerse el llamado despùés de ejecutar la subrutina llamada con el botón OK, Sintáxis call DlgExit (dlg)

end subroutine ! Subrutina que es llamada cuando se da click en el botón aceptar OK ! Requiere tres argumentos: ! 1. Variable que define al cuadro (TYPE) ! 2. Identificador del botón que pasa el comando ! 3. Acción que se ejecuta sobre el botón subroutine subrutina(dlg,IDOK,dlg_clicked) ! Librería necesaria para trabajar con cuadros de diálogos, viene ! instalada con el compilador DVF, pero es necesario expresarla use dflogm logical log,retlog1,retlog2 integer i4 real x,y character*25 texto,numero,texty ! Declaración del tipo de objeto a usarse. 'dlg' es una variable ! puede tener cualquier nombre type(dialog)dlg ! Producto de la compilación del cuadro de diálogos, no puede cambiarse ! el nombre. include 'resource.fd' ! Función lógica que lee la información de un cuadro de edición ! y asigna el valor de lo que lee a la variable alfanumérica 'texto' ! **Desde un cuadro solo se lee y escribe caracteres, NO VALORES** ! La función requiere tres argumentos ! 1. Variable que define al cuadro (TYPE) ! 2. Identificador del cuadro de texto ! 3. Variable alfanumérica a la que se le asigna la información leída log = DlgGet(dlg,IDC_EDIT1,texto) ! Condición que evita error cuando se ha dejado en blanco esta casilla if (texto.eq.' ') then texto='nada' endif ! Cuando se necesitan ingresar valores numéricos, éstos inicialmente se ! les asigna una variable alfanumérica y luego se hace la transformación ! como sigue. log = DlgGet(dlg,IDC_EDIT2,numero) ! Condición que evita que error cuando no se llena esta casilla if (numero.eq.' ') then

- 59 -


numero='0.0' endif read(numero,*)x ! Asigna lo leído en 'numero' a la variable real 'X' con cualquier formato ! Función lógica que lee la información lógica de los botones de ! selección RADIO BUTTONS, su resultado se almacena en la variable ! lógica 'retlog' log = DlgGet(dlg,IDC_RADIO1,retlog1) ! Función lógica que lee la información lógica del cuadro de verificación ! CHECK, su resultado se almacena en la variable 'retlog2' log = DlgGet(dlg,IDC_CHECK1,retlog2) ! Acciones que se ejecutan cuando las variables 'texto','retlog1' y ! 'retlog2' tienen un valor ya definido, este párrafo ya se lo hace ! de acuerdo a las exigencias que desee cada uno. ! Ejecución para la variable 'retlog1' del botón de selección select case (retlog1) ! Cuando se selecciona toma el valor de verdadero y se ejecuta ! lo que sigue case (.true.) ! Función lógica que escribe en la etiqueta lo que se leyò en el ! cuadro de edición de texto. La función requiere los mismos argumentos ! que la función DLGGET. log = DlgSet(dlg,IDC_STATIC,texto) write(*,*)'Se ha seleccionado la opción 1' ! Cuando no ha sido seleccionado toma el valor de falso case (.false.) texto = '' ! Función lógica que escribe en la etiqueta el contenido de la variable texto log = DlgSet(dlg,IDC_STATIC,texto) write(*,*)'Se ha seleccionado la opción 2' end select ! Ejecución para la variable 'retlog2' de la casilla de verificación ! ! ! y

Acciones de ejemplo para generar un valor 'Y' y escribirlo en una variable de texto que pueda ser colocada en el cuadro de diálogo o en pantalla pero como caracteres. = 10.*x

write(texty,'(f10.4)')y !Asigna el valor de 'Y' (real) a la variable de texto 'texty' ! con el formato f6.3 Select case (retlog2) ! Cuando se ha chequeado la casilla toma el valor de verdadero case (.true.) write(*,*)'Casilla de verificación chequeada' write(*,*)texty ! Cuando no se la chequea, toma el valor de falso case (.false.) write(*,*)'Casilla de verificación ignorada' write(*,'(e10.4)')x end select end subroutine ! subrutina que abre el cuadro de diálogo acerca de y lo cierra al dar click en aceptar subroutine acerca

- 60 -


use dflogm logical l4,retlog integer i4 type(dialog)dlg include 'resource.fd' l = dlginit(IDD_ACERCA,dlg) i4 = dlgmodal(dlg) call dlgexit(dlg) end subroutine

Figura No. 20.- Cuadro ejecutando el código

- 61 -


8.0 Gráficos en Visual Fortran Existen en el mercado algunas aplicaciones útiles para graficar o plotear pares ordenados en Fortran, entre los más usados por nuestra facultad se encuentra el desarrollado por Microsoft denominado Array Visualizar, que se provee como adicional al compilador de Fortran, el desarrollado por PlotWorks, denominado Plot88; el desarrollado por el autor de estos apuntes denominado CVFGraf y el desarrollado por el profesor Santos de la Universidad de Algarbe (Portugal) denominado DXFortran. En este capítulo se revisarán algunas de las potencialidades de cada una de las rutinas de graficación disponibles.

8.1 Array Vis ualizer 8.1.1 Generalidades Digital Visual Fortran adiciona una rutina para la visualización o análisis gráfico de los resultados, usando subrutinas que realizan una interface con el programa Array Visualizer. El uso de esta herramienta es permitido por cualquier tipo de proyecto.

Las subrutinas de trabajo son las denominadas rutinas FAGLXXX, y mediante éstas se pueden crear interfaces para incorporar esta herramienta en aplicaciones personalizadas. Existen otras rutinas como las denominadas FAVXXX, que controlan la configuración del programa, pero en la versión 1.0, que se dispone, no se tiene estas subrutinas. El módulo que contiene estas subrutinas es AVDEF, por lo que es importante hacer la declaración con la sentencia USE AVDEF, antes de usarlas. 8.1.2 Descripción El módulo contiene 10 subrutinas. 1. FAGLCLOSE 2. FAGLENDWATCH 3. FAGLGETSHARENAME 4. FAGLHIDE 5. FAGLLBOUND 6. FAGLNAME 7. FAGLSAVEASFILE 8. FAGLSHOW 9. FAGLSTARTWATCH 10. FAGLUPDATE

Estas rutinas son llamadas en la siguiente secuencia La primera rutina que debe llamarse es faglStartWatch con el arreglo como argumento. Si se desea presentar un arreglo en diferentes escalas, se llama a faglLBound con el arreglo como argumento y el otro arreglo donde se encuentran los límites inferiores. Para colocar un título en la barra de la ventana se llama a faglName con el arreglo a presentar y el título personal.

- 62 -


Para iniciar la presentación se usa faglShow con el arreglo como argumento y permanece abierto hasta que el usuario lo cierre con los controles de la ventana o llame a faglClose Si la información que se está presentando ha variado mientras se presenta un gráfico, se llama a faglUpdate con el arreglo como argumento, y la información presentada se actualiza. Para guardar el arreglo como archivo Array Graphing Language (.AGL), para poder ser presentado independiente y directamente de Array Visualizer, se llama a faglSaveAsFile con el arreglo como argumento; no se necesita tener abierta la ventana para guardar un archivo. Cuando se ha finalizado se llama a faglEndWatch con el arreglo como argumento. Una presentación puede esconderse momentáneamente antes de cerrarla, usando la rutina faglHide. 8.1.3 Sintaxis A continuación se describen las principales rutinas del programa Array Visualizer, describiendo sus argumentos y sintaxis. CALL FAGLSTARTWATCH (array,status)

Array Status

nombre del arreglo que contiene la información a ser presentada es del tipo real, dimension NxMxP Variable entera de uso interno del programa, toma el valor de 0 cuando se ha ejecutado correctamente la rutina y el valor de – 1 cuando no lo ha hecho.

CALL FAGLLBOUND (array,lbnd,status)

Array Lbnd Status

nombre del arreglo que contiene la información a ser presentada es del tipo real, dimension NxMxP Un arreglo del tipo entero que tiene la misma dimension de Array, con la información en escala 1. Variable entera de uso interno del programa, toma el valor de 0 cuando se ha ejecutado correctamente la rutina y el valor de – 1 cuando no lo ha hecho.

CALL FAGLNAME (array,Title,status)

Array Title Status

nombre del arreglo que contiene la información a ser presentada es del tipo real, dimension NxMxP Una variable de carácter que contiene el título del gráfico. Variable entera de uso interno del programa, toma el valor de 0 cuando se ha ejecutado correctamente la rutina y el valor de – 1 cuando no lo ha hecho.

CALL FAGLSHOW (array,,status)

Array Status


CALL FAGLCLOSE (array,,status)

Array

nombre del arreglo que contiene la información a ser presentada es del tipo real, dimension NxMxP

- 63 -


Status

Variable entera de uso interno del programa, toma el valor de 0 cuando se ha ejecutado correctamente la rutina y el valor de – 1 cuando no lo ha hecho.

CALL FAGLUPDATE (array,,status)

Array Status


CALL FAGLSAVEASFILE (array,filename,status)

Array Filename Status

nombre del arreglo que contiene la información a ser presentada es del tipo real, dimension NxMxP Variable alfanumérica con el nombre del archivo incluyendo la extensión *.AGL. Variable entera de uso interno del programa, toma el valor de 0 cuando se ha ejecutado correctamente la rutina, y, el valor de – 1 cuando no lo ha hecho.

CALL FAGLENDWATCH (array,,status)

Array Status

nombre del arreglo que ha sido usado en la rutina FaglStartWatch Variable entera de uso interno del programa, toma el valor de 0 cuando se ha ejecutado correctamente la rutina, y, el valor de – 1 cuando no lo ha hecho.

CALL FAGLHIDE (array,,status)

Array Status

nombre del arreglo que ha sido usado en la rutina FaglStartWatch Variable entera de uso interno del programa, toma el valor de 0 cuando se ha ejecutado correctamente la rutina y el valor de – 1 cuando no lo ha hecho.

8.1.4 Ejemplo La siguiente codificación produce la curva de la función coseno. El resultado de la ejecución del programa se observa en la figura No. 21. program array use avdef real, dimension(0:360) :: x,y real :: angulo,pi integer :: i,status character(len=25) :: titulo titulo='Funciones Seno y Coseno' pi=3.14159 do i=0,360 angulo = float(i)*pi/180. x(i) = cos(angulo) write(*,*)angulo,x(i),y(i) enddo CALL FAGLSTARTWATCH (x,status) CALL FAGLNAME (x,titulo,status) CALL FAGLSHOW (x,status) pause CALL FAGLENDWATCH (x,status)

- 64 -


end

Figura No. 21.- Resultado de una graficación usando Array Visualizer

8.2 L ib rer ía P lo t88 8.2.1 Generalidades La librería de graficación Plot88, es un conjunto de librerías de graficación desarrollado por PlotWorks, y contiene 61 subrutinas para configurar la presentación y el ploteo de gráficos en 2D y 3D, sin rotación libre, y no viene incluído en el paquete de instalación de DVF 6.0; así que debe ser instalada por separado y los dos archivos que contienen las subrutinas de graficación son Plot88.lib y Drive88.lib, deben ser copiados en la carpeta: Microsoft Visual Estudio/DF98/LIB, donde se encuentran las librerías disponibles del compilador. Para poder usar esta librería en el cuadro de configuración del proyecto deben ser incluidas las sentencias: PLOT88.LIB, DRIVE88.LIB, WINSPOOL.LIB, para que en el momento de enlazar con las librerías éstas sean encontradas. Ver figura No. 22.

Para la graficación en dos dimensiones, Plot88 usa el plano cartesiano de 8 pulgadas de largo por 6 pulgadas de alto. Esta librería incluye subrutinas para generar el eje, para personalizar la presentación de los ejes y para graficar personalizando las líneas, etc.

- 65 -


8.2.2 Etapas del proceso de graficación La secuencia normal para graficar en esta subrutina, se describe brevemente en la tabla No. 11, y puede cambiar salvo los ítems con negrita que deben necesariamente declararse para poder ejecutar la graficación.

Figura No. 22.- Configuración del proyecto ETAPA

SUBRUTINA

SINTAXIS

PLOTS (idef,ioport,model) FACTOR (fact) PLOT (x,y,ipen) Origen SCALE (array,axlen,npts,inc) Escala y valores STAXIS (annhgt,tihgt,xphgt,ticlug,ndeca) Ejes coordenados AXIS (x,y,ctext,nchar,axlen,angle,first,delta) Graficación de datos LINE (xarray,yarray,npts,inc,lintyp,inteq) CURVE (xarray,yarray,npts,seglen) Caracteres del gráfico SYMBOL (x,y,height,ctext,angle,nc) NUMBER (x,y,height,fpn,angle,ndec) (x,y,ipen) Ejecución del gráfico PLOT Tabla No. 11.- Secuencia de una graficación con Plot 88 Inicio

8.2.3 Sintaxis de cada subrutina 1. Subrutina PLOTS.- inicializa el programa de graficación, debe ser llamada antes que cualquier otra subrutina de graficación, requiere el ingreso de tres valores: a. Idef: es un entero y puede ser 0, dibuja el gráfico; si toma el valor de 1 dibuja y graba, si el valor es 2 graba y no dibuja, 3 muestra directamente en pantalla. b. Ioport: es un entero, que indica el tipo de interface; para mostrar directamente en pantalla 90, 91,ó 92. Para generar archivo *.DXF para editarlo en AutoCad se asigna el valor de 11.

- 66 -


2. 3.

4.

5.

6.

c. Model: es un entero que indica el modelo de la interface; para pantalla 90, 91 ó 92. Para generar un archivo *.DXF editable en AutoCad se asigna el valor de 120. Subrutina FACTOR.- aumenta o disminuye el tamaño del dibujo completo. Requiere de un valor real positivo diferente de cero, que es el factor escala. Subrutina PLOT.- mueve la punta del lápiz de graficación de la posición actual hacia la nueva, con la opción de mover el puntero levantado o dibujando. Requiere del ingreso de tres parámetros: a. (x,y).- nueva posición a la que el puntero será llevado. Son dos reales, coordenadas. b. Ipen.- es del tipo entero: 2 dibuja, 3 mueve el origen sin dibujar, 999 pone fin al uso del graficador. Subrutina SCALE.- esta subrutina busca en un arreglo de valores, el mínimo o máximo valor y lo almacena en la variable FIRST, luego escala el rango de valores del arreglo en el eje y este factor de escala lo almacena en la variable DELTA, estas dos variables serán usadas por la subrutina AXIS. Requiere el ingreso de 4 valores: a. Array.- el nombre de un arreglo, debe dimensionarse con n+2 elementos de longitud. b. Axlen.- es un valor real positivo, longitud del eje en pulgadas. c. Npts.- entero positivo, número de datos del arreglo. d. Inc.- es un entero que determina cuantos datos se toman como incremento para la graficación. Subrutina STAXIS.- usada para configurar las características de los ejes de coordenadas. Requiere el ingreso de cinco parámetros: a. Annght.- es un real y denota el alto en pulgadas de las etiquetas de cada marca de anotación. Si se ingresa 0, no se escriben los valores. b. Tihgt.- es un real positivo y denota el alto en pulgadas de la etiqueta de los ejes. c. Exphgt.- es un real positivo y denota el alto en pulgadas del exponente de base 10, cuando se requiera. d. Ticlng.- es un real positivo y denota el longitud en pulgadas de las marcas, cualquier otro valor indica que no se dibujen las marcas. e. Ndeca.- es un entero e indica el número de cifras decimales que se desean incluir en los valores del eje. Subrutina AXIS.- dibuja un eje en dos dimensiones completo, con valores y etiquetas, la distancia entre marcas siempre es de 1.0 pulgadas, pero puede ser cambiada con el factor de escala FACTOR, requiere el ingreso de 8 parámetros: a. X,y.- son reales e indican el origen del eje en pulgadas, respecto del extremo de la pantalla. b. Ctext.- Texto de título del eje. c. Nchar.- es un entero e indica el número de caracteres en el título del eje, igual a 0, no dibuja caracteres, menor que 0 dibuja los caracteres bajo el eje, y si es mayor que 0, los dibuja sobre el eje. d. Axlen.- es un real y denota la longitud del eje en pulgadas. e. Angle.- ángulo de rotación del eje, el eje x se dibuja con 0° y el eje Y con 90°. f. First.- es un real, valor obtenido en la subrutina SCALE e indica el valor de la primera marca del eje.

- 67 -


g. Delta.- es un real, número de datos por pulgada de ejes, obtenido en la subrutina SCALE. 7. Subrutina LINE: dibuja una línea basándose en los puntos x,y que se ingresen en el arreglo, requiere de 6 parámetros. a. Xarray.- arreglo que contiene los valores que serán graficados en el eje X. b. Yarray.- arreglo que contiene los valores que serán graficados en el eje Y. c. Npts.- es un entero que indica el número de puntos del arreglo. d. Inc.- entero, incremento de lectura de datos del arreglo. e. Lintyp.- entero, describe el tipo de línea que será dibujada. f. Inteq.- entero de 0 a 15, es el tipo de símbolo que será dibujado para plotear cada número. 8. Subrutina CURVE: une los puntos del arreglo por medio de una curva suavizada y requiere de 4 parámetros de entrada: a. Xarray.- arreglo que contiene los valores que serán graficados en el eje X. b. Yarray.- arreglo que contiene los valores que serán graficados en el eje Y. c. Npts.- es un entero que indica el número de puntos del arreglo. d. Seglen.- es un real, magnitud del segmento de recta que conforma la forma suavizada, en pulgadas. 9. Subrutina SYMBOL: Dibuja caracteres y símbolos especiales, y requiere de 6 parámetros de entrada. a. (x,y).- son reales, posición en la que será dibujado el carácter. b. Height.- real, alto de cada carácter en pulgadas c. Ctext.- carácter alfanumérico a dibujarse d. Angle.- real, ángulo en grados de orientación del texto. e. Nc.- entero, número de caracteres de CTEXT. 10. Subrutina NUMBER: convierte un número en carácter alfanumérico, para poder dibujarlo en la pantalla. Requiere de 6 parámetros de entrada. a. (x,y).- son reales, posición en la que será dibujado el carácter. b. Height.- real, alto de cada carácter en pulgadas c. fpn.- número a ser dibujado d. Angle.- real, ángulo en grados de orientación del número dibujado. e. Ndec.- entero, número de decimales que se dibujarán en el número. 8.2.4 Ejemplo La siguiente codificación produce el ejemplo clásico de Plot88, la curva Gaussiana. Correspondiente al ejemplo EXA 42; nótese el orden en el que se hacen las llamadas a subrutinas. PROGRAM EXA42 CHARACTER*1 TITC(20),NAM1(20),NAM2(20) CHARACTER*20 TITLE,NAME1,NAME2 CHARACTER*27 FILENAME REAL XDATA(202),YDATA(202) INTEGER*2 IC CHARACTER*1 ANS EQUIVALENCE (TITC(1),TITLE),(NAM1(1),NAME1),(NAM2(1),NAME2) DATA IC/0/ open(4,file="exa42.inp")

- 68 -


WRITE(*,*) 'Enter IOPORT, MODEL and FACT > ' ioport = 91 model = 91 fact = 1 WRITE(*,*) 'Enter text file name> ' filename = 'exa42.dat' WRITE(*,*) 'Enter the PLOT title [20 chars. max]> ' title = 'BELL' DO 806 KK=1,20 KI=21-KK IF(NAM2(KI).NE.' ') GO TO 706 806 CONTINUE 706 NT=KI WRITE(*,*) 'Enter the X-AXIS title [20 chars. max]> ' name2 = 'X' DO 805 KK=1,20 KI=21-KK IF(NAM2(KI).NE.' ') GO TO 705 805 CONTINUE 705 N2=KI WRITE(*,*) 'Enter the Y-AXIS title [20 chars. max]> ' name1 = 'F(X)' C READ(4,61) NAME1 DO 804 KK=1,20 KI=21-KK IF(NAM1(KI).NE.' ') GO TO 704 804 CONTINUE 704 N1=KI LT = 0 WRITE(*,*) 'Do you wish to plot a centered symbol [Y/(N)]?' ans = 'y' 807 FORMAT(A) IF(ANS.EQ.'Y' .OR. ANS.EQ.'y') LT = 1 OPEN(9,FILE=FILENAME,STATUS='OLD') DO 3 LENG = 1,201 READ(9,*,ERR=31) XDATA(LENG),YDATA(LENG) 3 CONTINUE 31 CONTINUE CLOSE(9,STATUS='KEEP') IF(LENG.GT.200) WRITE(0,*) 1 ' WARNING - ONLY 200 DATA POINTS WILL BE PLOTTED' LENG = LENG - 1 if( ioport.ge.90.and.ioport.le.99) then CALL PLOTS(3,IOPORT,MODEL)

else CALL PLOTS(0,IOPORT,MODEL)

endif if( ioport.eq.11) open(90,file='disk.dat') call jobtitle88("EXA42 Bell Curve")

if( ioport.ge.90.and.ioport.le.99) then call color(15,IERR)

endif CALL FACTOR( FACT )

IF(N2.EQ.0) THEN N2=+1 NAME2= ' ' ENDIF X = 4.5 -.12*(NT) CALL SYMBOL(X,4.75,.38,TITLE,0.,NT)

- 69 -


CALL CALL CALL CALL CALL CALL

PLOT(1.00,1.00,-3) SCALE(XDATA,6.00,LENG,1) SCALE(YDATA,3.00,LENG,1) STAXIS(.25,.25,.111,.112,1) AXIS(0.,0.,NAME2,-N2,6.00,00.,XDATA(LENG+1),XDATA(LENG+2)) AXIS(0.,0.,NAME1, N1,3.00,90.,YDATA(LENG+1),YDATA(LENG+2))

WRITE(0,*) 'Begin drawing output.' CALL PLOT(0.0,0.0,999)

60 FORMAT(A27) 61 FORMAT(A20) 1000 FORMAT(A) END

Figura No. 23.- Grafico ejecutando Plot88

8.3 CVFGraf 8.3.1 Generalidades Esta rutina de graficación fue creada entre abril de 2002 y Junio de 2004, cuando se hizo la última corrección a la presente versión, no por esto quiere decir que no habrá versiones posteriores mejoradas que con la ayuda de retroalimentación que proporcionarán ustedes los usuarios de esta rutina. La rutina está escrita en Fortran 90, formato libre y para ser usada en un proyecto del tipo FORTRAN STANDARD GRAPHICS. No tiene la estructura de módulo así que bastará con adicionar al proyecto el archivo que la contiene y llamar a sus subrutinas desde el programa principal. No soporta graficación en tres dimensiones, ni funciones cuyo resultado sean valores

- 70 -


infinitos, los arreglos no tienen límites, están declarados con 500 valores pero el usuario puede cambiarlos a voluntad. 8.3.2 Codificación y subrutinas Se ha usado la graficación en Fortran 90, basado en una pantalla de 640x480 pixeles, las subrutinas leen los valores a graficarse y obtienen el máximo y mínimo valor para saber si existen valores negativos en los pares ordenados y de esta forma ubicar el origen de coordenadas nuevo en un lugar de la pantalla de tal forma que el gráfico pueda ser visto completamente en la pantalla.

Está compuesta de dos subrutinas una grafica los ejes y otra plotea los puntos en un plano cartesiano. Si se desea graficar más de un grupo de pares ordenados en el plano se llama a la subrutina de PLOTEO tantas veces como se requiera, sin embargo para definir los ejes es necesario escoger el grupo de pares que puedan contener a los demás para que se puedan apreciar todos los puntos en el gráfico resultante 1. CVFaxis ( ) 1.1 Descripción: Esta subrutina define los ejes de coordenadas del gráfico, requiere de los siguientes parámetros 1.2 Sintaxis CVFAXIS(x,y,n,titulo,titx,tity,escalas,grilla,fondo,scalx,scaly)

1.3 Argumentos: 1.3.1 X: es el arreglo que desea graficarse en el eje de las abcisas; debe declararse como un vector de números reales 1.3.2 Y: es el arreglo que desea graficarse en el eje de las ordenadas; debe declararse como un vector de números reales 1.3.3 N: es el número de puntos que van a graficarse, definido por un entero 1.3.4 Titulo: es el título del gráfico, que se colocará como título de la ventana que contiene el gráfico. Se la define como carácter, si no ingresa como variable a la rutina debe colocarse apóstrofes con el nombre. 1.3.5 Titx: es el título del eje X, que se colocará a la derecha del eje de abcisas 1.3.6 Tity: es el título del eje Y, que se colocará sobre el eje de las ordenadas 1.3.7 Escalas: es un número entero que puede tomar dos valores CERO (0) para que cada eje tenga escalas independientes, y, UNO (1) para que los ejes tengan la misma escala, cualquier otro valor resulta en error. 1.3.8 Grilla: es un número entero que puede tomar dos valores CERO(0) para no graficar una grilla en el plano cartesiano, y, UNO (1) para graficar una grilla en el plano, cualquier otro valor resulta en error. 1.3.9 Fondo: es un número entero que puede tomar tres valores CERO (0) coloca el fondo negro ejes y textos en blanco, UNO (1) fondo gris, ejes y textos en negro, DOS (2) fondo blanco, ejes y textos en negro, y, TRES (3) no grafica ejes pero el fondo siempre será negro. Las curvas ploteadas no se ven afectadas en el color. 1.3.10 ScalX: es el valor de la escala para graficar el eje X, resultado que se obtiene de la subrutina, sirve para ingresar a la subrutina CVFGRAFICA. 1.3.11 ScalY: es el valor de la escala para graficar el eje Y, resultado que se obtiene de la subrutina, sirve para ingresar a la subrutina CVFGRAFICA. - 71 -


2. CVFGrafica () 2.1 Descripción: Esta subrutina plotea los puntos en el plano previa graficación de los ejes, si no se ha llamado previamente a la subrutina CVFAXIS no es posible graficar los puntos. 2.2 Sintáxis: CALL CVFGRAFICA(x,y,n,marca,color,scalx,scaly) 2.3 Argumentos: Requiere de los siguientes argumentos de entrada: 2..3.1 X: es el arreglo que desea graficarse en el eje de las abcisas debe declararse como un vector de números reales 2.3.2 Y: es el arreglo que desea graficarse en el eje de las ordenadas, debe declararse como un vector de números reales 2.3.3 N: es el número de puntos que van a graficarse, definido por un entero. 2.3.4 Marca: es un número entero, dibuja una marca para indicar la posición del par graficado y toma los siguientes valores: 0 Dibuja una línea sin marcas 1 Dibuja una línea con marcas cuadradas 2 Dibuja marcas redondas sin línea 3 Dibuja marcas cuadradas sin línea 4 Dibuja una línea con marcas redondas 5 Dibuja sercha cúbica sin marcas 6 Dibuja sercha cúbica con marca cuadrada 7 Dibuja sercha cúbica con marca redonda Cualquier otro valor el resultado es error 2.3.5 Color: es un número entero que define el color de la curva, y toma los siguientes valores: 1 rojo 2 blanco 3 verde 4 amarillo 5 azul 6 magneta 7 turquesa 8 gris 2.3.6 ScalX y ScalY: son el resultado de la subrutina anterior. 8.3.3 Ejemplo La codificación siguiente genera la curva de las funciones Seno y Coseno. program principal real, dimension(500) :: x,y,z integer i,n,color,marca,escalas,grilla character(25) titulo,titx,tity titulo='Funciones Seno y Coseno' titx='Grados' tity='Seno/Coseno' pi=3.14159 do i=0,360 angulo=float(i)*pi/180 y(i)=cos(angulo) x(i)=float(i) z(i)=sin(angulo) write(*,*)angulo,y(i),x(i) enddo escalas=0 ! usará escalas independientes

- 72 -


grilla=1 ! graficará grilla fondo = 0 ! fondo negro, ejes y textos blanco n=360 call cvfaxis(x,y,n,titulo,titx,tity,escalas,grilla,fondo,scalx,scaly) ! grafica el eje basado en la función seno color=4 ! amarillo marca=0 ! no graficará marcas call cvfgrafica(x,y,n,marca,color,scalx,scaly) color=5 ! azul call cvfgrafica(x,z,n,marca,color,scalx,scaly) do while (.true.) enddo end

Figura No. 24.- Grafica obtenida con CVFGraf

8.4 DXFortran 8.4.1 Generalidades El proyecto DXFortran, fue desarrollado por los profesores Carlos Otero y Davide Santos de la Universidad de Algarve de Lisboa, Portugal, y tiene por objeto el desarrollo de una Librería Vectorial de Graficación en formato DXF (Drawing Interchange Format) para Fortran 90. El autor de estas notas, adaptó esta librería para ser usada como herramienta de ploteo de coordenadas en un plano y el espacio, de tal forma que este nuevo arreglo sea usado directamente sin necesidad de conocer a fondo las rutinas principales del proyecto. Las subrutinas adapatadas fueron adicionadas al módulo del proyecto, para evitar errores y está constituido por dos secciones:

- 73 -


1. Un grupo de subrutinas de graficación en 2D y 3D que permiten realizar ploteos de arreglos de datos y de funciones matemáticas directamente en formato DXF y en las cuales los parámetros de ingreso son los arreglos y títulos de los ejes. 2. Un grupo de subrutinas que permite personalizar de mejor forma el ploteo en 2D y 3D de funciones y arreglos de datos. 8.4.2 Forma de uso El uso de la librería está definido de DOS maneras: 1. El ploteo rápido de puntos en 2D y 3D Esta opción nos permite realizar un ploteo en 2D o 3D sin tener que configurar el archivo ni ejecutar ningún comando de AutoCAD. Las subrutinas definen los parámetros iniciales y ejecutan los comandos necesarios para realizar el ploteo de los puntos. La secuencia que se requiere es llamarlas directamente CALL dfGraph2D (…..), si se quiere plotear en 2 dimensiones CALL dfGraph3D (…..) si se quiere plotear en 3 dimensiones

2. Ploteo en 2D y 3D, configurando opciones Esta opción nos permite plotear varias veces sobre el mismo eje de coordenadas, la limitación que existe es que la definición de ejes la hace con los arreglos que se ingresen en el llamado a la subrutina dfAxis. La secuencia que debe usarse para realizar la graficación es la siguiente: CALL dfStart (……) CALL dfAxis (…..) CALL dfGraph (….) las veces que se requieran CALL dfEnded (…)

8.4.3 Descripción de subrutinas La primera sección es de ploteo rápido de funciones en 2D y 3D y para la graficación solo es necesario invocar cualquiera de estas dos subrutinas con los argumentos adecuados y el gráfico se realiza sin necesidad de llamar otra subrutina. La limitación que existe al usar estas dos subrutinas es que si necesitamos plotear dos curvas en el mismo eje coordenado no sería posible ya que cada subrutina da inicio y finaliza el dibujo independientemente. 1. dfGraph2D ( )

1.1 Descripción: realiza el ploteo de una función matemática o de un arreglo de pares ordenados en dos dimensiones, define 3 capas denominadas Ejes (rojo), Textos (azul) y Grafico (blanco), y todas con el tipo de línea continua. El ploteo lo realiza uniendo los pares de coordenadas con un segmento recto. La longitud de los ejes se define en la subrutina buscando el máximo valor del arreglo en cada eje y el tamaño de los textos son definidos en base a una fracción del mínimo de los máximos valores de los arreglos para de esta forma guardar proporcionalidad entre los textos y el gráfico. 1.2 Sintáxis: CALL dfGraph2D (Archdxf,Texto,TextX,TextY,x,y,n,L) 1.3 Argumentos: 1.3.1 Archdxf: nombre del archivo con extensión DXF, argumento alfanumérico 1.3.2 Texto: título del gráfico, argumento alfanumérico 1.3.3 TextX: título del eje X, argumento alfanumérico 1.3.4 TextY: Título del eje Y, argumento alfanumérco 1.3.5 x: arreglo que contiene los datos de las abcisas, argumento real - 74 -


1.3.6 y: arreglo que contiene los datos de las ordenadas, argumento real 1.3.7 n: número de puntos en los arreglos, la subrutina soporta hasta 999 puntos, argumento Entero 1.3.8 L: Parámetro Entero que indica si se desea graficar una marca que indique la posición de los pares ordenados, los valores que puede tomar son: 0 Dibuja líneas y no las marcas 1 Dibuja líneas y marcas 2 Dibuja marcas y no líneas 2. dfGraph3D ( )

2.1 Descripción: realiza el ploteo de una función matemática o de un arreglo de pares ordenados en tres dimensiones, define 3 capas denominadas Ejes (rojo), Textos (azul) y Gráfico (blanco), y todas con el tipo de línea continua. El ploteo lo realiza uniendo los pares de coordenadas con una línea recta. La longitud de los ejes se define en la subrutina buscando el máximo valor del arreglo en cada eje y el tamaño de los textos son definidos en base a una fracción del mínimo de los máximos valores de los arreglos para de esta forma guardar proporcionalidad entre los textos y el gráfico. 2.2 Sintaxis: CALL dfGraph3D (Archdxf,Texto,TextX,TextY,x,y,z,n,L) 2.3 Argumentos: 2.3.1 Archdxf: nombre del archivo con extensión DXF, argumento alfanumérico 2.3.2 Texto: título del gráfico, argumento alfanumérico. 2.3.3 TextX: título del eje X, argumento alfanumérico. 2.3.4 TextY: Título del eje Y, argumento alfanumérico. 2.3.5 x: arreglo que contiene los datos de las abcisas, argumento real. 2.3.6 y: arreglo que contiene los datos de las ordenadas, argumento real. 2.3.7 z: arreglo que contiene los datos de los valores de Z, argumento real. 2.3.8 n: número de puntos en los arreglos, la subrutina soporta hasta 999 puntos. Argumento Entero. 2.3.9 L: Parámetro Entero que indica si se desea graficar una marca que indique la posición de los pares ordenados, los valores que puede tomar son: 0 Dibuja líneas y no las marcas 1 Dibuja líneas y marcas 2 Dibuja marcas y no líneas La segunda sección nos permite realizar varios ploteos en el mismo dibujo, para lo cual es necesario seguir la siguiente secuencia: todo dibujo se inicia con el llamado a dfStart y los argumentos respectivos, luego si se desea graficar ejes se invoca a la subrutina dfAxis, la parte del ploteo la realiza la subrutina dfGraph, que puede ser invocada las veces que sean necesarias para realizar todas los ploteos que se deseen, finalmente debe terminarse el ploteo con dfEnded (de la primera sección). 3. dfStart ()

3.1 Descripción: Inicia el dibujo para ploteo y define 3 capas denominadas Ejes (rojo), Textos (azul) y Grafico (blanco), y todas con el tipo de línea continua. 3.2 Sintaxis: CALL dfStart (archdxf,FileNum) 3.3 Argumentos:

- 75 -


3.3.1 Achdxf: nombre del archivo con extensión DXF, argumento alfanumérico 3.3.2 FileNum: resultado de la aplicación de la subrutina, por defecto (1), a menos que se inicie una graficación independiente, este valor es el que sirve para posteriormente cerrar la graficación con dfEnd. Argumento Entero. En el modo Ploteo configurando opciones. 4. dfAxis ()

4.1 Descripción: dibuja los ejes, coloca divisiones y rotula en el archivo DXF definido en dfStart, en la capa “Ejes” y con el color Rojo, los

valores referenciales para definir la longitud de los ejes lo toma de los arreglos, usando el mismo criterio al empleado en dfGraph. 4.2 Sintáxis: CALL dfAxis (texto,textX,textY,x,y,z,n) 4.3 Argumentos: 4.3.1 Texto: título del gráfico, argumento alfanumérico 4.3.2 TextX: título del eje X, argumento alfanumérico 4.3.3 TextY: título del eje Y, argumento alfanumérico 4.3.4 ex,ey,ez: arreglos que contienen los datos a plotearse, argumento real 4.3.5 n: número de puntos a plotearse, argumento Entero 5. dfGraph ()

5.1 Descripción: plotea los datos contenidos en los arreglos x,y,z sobre los ejes definidos en dfAxis. 5.2 Sintaxis: CALL dfGraph (ex,ey,ez,n,L) 5.3 Argumentos: 5.3.1 x,y,z: arreglos que contienen los datos a plotearse, argumento Real 5.3.2 n: número de puntos a plotearse, argumento Entero 5.3.3 L: Parámetro Entero que indica si se desea graficar una marca que indique la posición de los pares ordenados, los valores que puede tomar son: 0 Dibuja líneas y no las marcas 1 Dibuja líneas y marcas 2 Dibuja marcas y no líneas 6. dfEnded()

6.1 Descripción: ¨Finaliza la graficación en el archivo DXF 6.2 Sintaxis: CALL dfEnded(FileNum) 6.3 Argumentos: 6.3.1 FileNum: es un número entero que indica el número asignado al archivo, que por defecto es 1, y debe ingresarse como una variable entera. 8.4.4 Ejemplo El siguiente código grafica las curvas de las funciones Seno y Coseno en un archivo DXF. program grafico use dflib integer i4,j4 character(25) archdata, texto,ARCHDXF real, dimension (500)::x,y,z,w pi=3.14159 do i=0,360,1 x(i+1)=pi*float(i)/180. y(i+1)=sin(pi*float(i)/180.)

- 76 -


z(i+1)=cos(pi*float(i)/180.) w(i+1)=0.0 enddo archdxf='grafico.dxf' CALL dfStart (archdxf,i4) CALL dfAxis ('SENO Y COSENO','ANGULO','F(X)',x,y,W,360) CALL dfGraph (x,y,W,360,0) CALL dfGraph (x,Z,W,360,0) CALL dfEnded (i4) end

El resultado de la ejecución del programa se muestra en la figura No. 25. Un ploteo en 3D es el que se presenta en la figura No. 26, que representa el casco de una lancha de semiplaneo.

Figura No. 25.- Resultado de la ejecución de programa.

Figura No. 26.- Casco de una lancha graficado con DXFortran

- 77 -


9.0 Librerías IMSL en Fortran 9.1 Generalidades La versión de Visual Fortran disponible incluye en su paquete de instalación, las librerías IMSL (Integrate Mathematical and Statical Libraries) , una colección de cerca de 1000 funciones matemáticas y estadísticas de fácil acceso y uso desde el Estudio de Desarrollo está divididas en 4 capítulos que son: 1. IMSL Subrutinas Matemáticas 2. IMSL Funciones especiales matemáticas 3. IMSL Subrutinas Estadística Vol 1 y 2. 4. IMSL Fortran 90 Subrutinas Cada subrutina o función tiene un esquema de explicación de fácil comprensión e incluye: 1. Una breve descripción de la subrutina. 2. Muestra la sintaxis de llamada desde el código fuente. 3. Declara todas las variables usadas como argumento en la subrutina, da una descripción de lo que hacen y de qué tipo son. 4. Comentarios y aclaraciones del uso de la subrutina o de las variables que deben usarse en la misma. 5. Define y explica el algoritmo usado para la solución. 6. Propone un ejemplo de aplicación para la subrutina o función.

9.2 Uso de la L ibr ería des de Vis ual Fo rtr an Para usar las IMSL se necesita: 1. Que esté instalada la librería, por defecto en la instalación de Digital Visual Fortran, ocurre esto, sin embargo si se realizó una instalación personalizada se puede verificar si ha sido instalada, en el Visual Studio, selección del menú TOOLS (Herramientas), OPTIONS (Opciones), luego la pestaña DIRECTORY (Directorios), en el cuadro desplegable de DIRECTORIES, seleccionar LIBRARIES y se verifica que la ruta para las IMSL se encuentre allí. Si no es así se la puede incluir con el botón Nueva Ruta. 2. Cuando se usa una rutina o función de la librería se debe declarar el módulo: numerical_libraries, usando la declaración USE, sin embargo existen funciones o rutinas que se usan como argumentos dentro de otras y que el manual explícitamente lo menciona que deben declararse como EXTERNAL. 9.3 Ejemplo Se usó la rutina BCONG, que minimiza una función de N variables, sujeta a límites de las variables, usando el método de Newton y una gradiente proporcionada por el usuario. program LibreriasIMSL use numerical_libraries INTEGER N PARAMETER (N=2) INTEGER IPARAM(7), ITP, L, NOUT REAL F, FSCALE, RPARAM(7), X(N), XGUESS(N),XLB(N), XSCALE(N), XUB(N)

- 78 -


EXTERNAL ROSBRK DATA XGUESS/-1.2E0, 1.0E0/, XSCALE/2*1.0E0/, FSCALE/1.0E0/ DATA XLB/-2.0E0, -1.0E0/, XUB/0.5E0, 2.0E0/ ! All the bounds are provided ITP = 0 ! Default parameters are used IPARAM(1) = 0 ! Minimize Rosenbrock function using ! initial guesses of -1.2 and 1.0 CALL BCONF ( rosbrk,N, XGUESS, ITP, XLB, XUB, XSCALE, FSCALE,IPARAM, RPARAM, X, F) ! Print results CALL UMACH (2, NOUT) WRITE (NOUT,10) X, F, (IPARAM(L),L=3,5) ! 10 FORMAT (' The solution is ', 6X, 2F8.3, //, ' The function ',& &'value is ', F8.3, //, ' The number of iterations is ',& & 10X, I3, /, ' The number of function evaluations is ',& & I3, /, ' The number of gradient evaluations is ', I3) ! END ! SUBROUTINE ROSBRK (N, X, F) INTEGER N REAL X(N), F ! F = 1.0E2*(X(2)-X(1)*X(1))**2 + (1.0E0-X(1))**2 ! RETURN END

El resultado de ejecutar este código se muestra en la figura No. 27.


- 79 -


10.0 Aplicaciones Utiles Con el propósito de hacer más amigables las interfaces y los programas resultantes, a continuación detallamos algunas aplicaciones del código que pueden ser útiles.

10.1 Creación de archiv os de ayuda 1. Para crear menús de ayuda, debemos primero crear el archivo, de preferencia una página web con vínculos de tal forma que podamos llamarla desde el programa para ejecución. 2. Para llamarlo debemos usar el módulo DFWIN, que controla las opciones para abrir programas desde la ejecución del programa. La función WINEXEC, es del tipo entera y se usa de la siguiente manera: i = winexec(„Explorer.exe ayuda.htm‟C,sw_maximize) i = winexec(„winhlp32.exe ayuda.htm‟C,sw_maximize) i = winexec(„winhelp.exe ayuda.htm‟C,sw_maximize)

3. Otra forma de crear archivos de ayuda se la hace usando la aplicación HELPWORKSHOP, que se provee con el compilador de Visual Fortran. 4. Para compilar un proyecto se escribe un archivo en formato *.RTF, se lo adiciona al proyecto y se compila. 5. En la actualidad existe en la página de MICROSOFT la aplicación HTMLHELP, que compila archivos de ayuda mucho más vistosos, como el mostrado en la figura No. 28.

Figura No. 28.- Archivo de ayuda realizado usando HTMLHELP

- 80 -


10.2 Abr ir y g uardar un archivo desd e el m enú Para realizar esta operación hay que definir un objeto del tipo T_OPENFILENAME, y luego configurar las opciones para que se presente el cuadro por defecto del sistema operativo instalado en la máquina. Este comando es una implementación del tipo de proyecto Win32, por lo que es necesario definir el modulo DFWIN, la estructura del código fuente se detalla al final, para el caso de guardar todas las definiciones son las mismas a excepción de la función que verifica que el cuadro de diálogo se abre o cierra. Para abrir un archivo la función es entera con la siguiente sintaxis: I = getopenfilename(ofn)

Donde la variable „ofn‟ ha sido definida en la declarac ión TYPE.

En el caso de guardar un archivo la función y su sintaxis es la siguiente: I = GetSaveFileName(ofn)

Manteniendo las mismas observaciones. Las especificaciones que deben definirse obligatoriamente para el objeto TYPE son las siguientes: 1. Presenta el cuadro de diálogo cuando se lo llama: ofn%lStr uctSize = SIZEOF(ofn) 2. Define las extenciones que debe presentar: ofn%lpstrFilter = loc(filter_spec) 3. Define el tamaño, el nombre y la ubicación del archivo que se escoge: ofn%lpstrFile = loc(file_spec) ofn%nMaxFile = sizeof(file_spec) ofn%nMaxFileTitle = 0 4. Coloca el título en el cuadro de diálogos: ofn%lpstrTitle = loc("Archivo de datos"C) 5. Verifica la existencia de la ruta: ofn%Flags = OFN_PATHMUSTEXIST 6. Coloca la extensión por defecto que debe presentarse: ofn%lpstrDefExt = loc("txt"C) Ejemplo: Se supone que en el menú de ventana se ha hecho un llamado a la subrutina ABRIRARCHIVO, que es la que se describe a continuación. El resultado se muestra en la figura No. 29. subroutine ABRIRARCHIVO use dfwin use dflib implicit none ! Usa la declaración del módulo DFWIN ! type(T_OPENFILENAME) ofn ! Se declara la especificación del filtro, que tipo de archivo quiere abrirse. ! Esta es la concatenación y siempre termina con una doble comilla vacía ! El primer caracter es el tipo de archivo, el segundo es una lista separada ! por punto y coma, del tipo de extensiones de los archivos, la lista termina ! con espacio en blanco. ! character*(*),parameter :: filter_spec = & "Archivos de texto"C//"*.txt"C// & "Códigos fuente"C//"*.f90;*.f"C//""C

- 81 -

ESCUELA SUPERIOR POLITECNICA DEL LITORAL FACULTAD DE INGENIERIA MARITIMA Y CIENCIAS DEL MAR PROGRAMACION APLICADA 1 ! Declaración de la variable para el archivo que se selecciona ! El esquema es rígido character*512 :: file_spec = ""C ! Declaración de otras variables integer status,ilen,i,n,i4 character(512):: archdat ! Especificaciones del cuadro de diálogo de abrir, basado en Windows ! en la carpeta en la que se está trabajando. ofn%lStructSize = SIZEOF(ofn) ofn%hwndOwner = NULL ofn%hInstance = NULL ofn%lpstrFilter = loc(filter_spec) ofn%lpstrCustomFilter = NULL ofn%nMaxCustFilter = 0 ofn%nFilterIndex = 1 ofn%lpstrFile = loc(file_spec) ofn%nMaxFile = sizeof(file_spec) ofn%nMaxFileTitle = 0 ofn%lpstrInitialDir = NULL ofn%lpstrTitle = loc(""C) ofn%Flags = OFN_PATHMUSTEXIST ofn%lpstrDefExt = loc("txt"C) ofn%lpfnHook = NULL ofn%lpTemplateName = NULL ! Se verifica si la función encontró el archivo status = GetOpenFileName(ofn) select case(status) case(0) i4 = messageboxqq('El archivo no ha sido en contrado‟C,‟Abrir‟C,mb$ok) return case(1) ilen = INDEX(file_spec,CHAR(0)) ! Reasigna la variable vector a una de caracter simple, el archivo se almacena ¡ con toda la ruta ARCHDAT=FILE_SPEC(1:ILEN-1) end select ! la subrutina accion ejecutara algo cuando se abra el archivo call accion(archdat) end subroutine

Figura No. 29.- Ejecución de la subrutina anterior

- 82 -


10.3 Presentación de u na tabla La subrutina TABLA fue desarrollada con el propósito de hacer más amigable la presentación de la información por pantalla cuando se trabaja con proyectos del tipo FORTRAN STANDARD GRAPHICS or QUICKWIN APPLICATION. No hace nada más que dibujar la tabla, de tal forma que se vea como si estuviese una tabla de MS Excel. Si se desea exportar la tabla a MS Excel, la rutina escribe un archivo de intercambio de datos *.DIF, con extensión XLS, para que pueda ser abierto directamente con la aplicación MS Excel. La subrutina tiene una sola llamada con la siguiente sintaxis: CALL TABLA(array,titulo,ncols,nfilas,fmt,excel)

Array:

Es una variable real del tipo arreglo de NCOLSxNFILAS, no como normalmente se hace de filas por columnas.

Titulo:

Es un vector del tipo alfanumérico con dimension NCOLS, que contiene los títulos de cada columna, si no se va a incluir títulos, se declara el vector y no se le asigna valores. Número entero, indica el número de columnas del arreglo. Número entero, indica el número de filas del arreglo. Variable alfanumérica, que indica el Formato con el que desea escribir en las celdas, se ingresa entre paréntesis, el máximo número de espacios posibles es 7. Es una variable entera que indica si se desea exportar la tabla a MS Excel o no, se ingresa el valor de 1 si desea exportar la tabla o 0 si no desea exportarla.

Ncols: Nfilas: fmt Excel

El código abajo expuesto dará como resultado una tabla como la presentada en la figura 30. program main use dflib real, dimension(1000,1000)::array CHARACTER(6) TITULO(1000) character(25)fmt NROWS=10 NCOLS=2 do i=1,nrows array(1,i)=0.2*i enddo do i=1,nrows array(2,i)=30.*9.*array(1,i)*0.65/1.025 enddo titulo(1)='H' titulo(2)='DESP' ! Uno para generar el archivo, Cero para no generarlo i4=1 fmt='(f7.1)' CALL TABLA(array,titulo,ncols,nrows,fmt,i4) end

- 83 -


Figura 30.- Resultado de la rutina El código de la rutina tabla se detalla a continuación. ! Subrutina que escribe la tabla con el arreglo ARRAY(COLUMNAXFILA) ! y lo presenta en pantalla, en una ventana secundaria. subroutine tabla(array,titulo,NCOLS,NROWS,FMT,EXCEL) USE DFLIB REAL,DIMENSION(1000,1000)::array CHARACTER(6) TITULO(1000) TYPE (windowconfig) wc TYPE (xycoord)xy TYPE (qwinfo)winfo LOGICAL status CHARACTER(25) Texto,fmt INTEGER(2) dummy, x1, y1, x2, y2,result,style INTEGER(2) fx(1000),fy(1000),tx(1000),ty(1000) INTEGER(4) i4,EXCEL IXPIXEL=50*(NCOLS+1) IYPIXEL=20*(NROWS+1)+20 open(25,file='user') ! Muestra la ventana en la posicion que yo quiero de la ventana ! wc%numxpixels = IXPIXEL ! pixels en X ancho de la ventana wc%numypixels = IYPIXEL ! pixels en Y alto de la ventana wc%numtextcols = -1 ! -1 valores de defecto del sistema wc%numtextrows = -1 wc%numcolors = -1 wc%title = "PARAMETROS CALCULADOS"C wc%fontsize = #0008000C ! Rquerido 8x12 pixeles de la fuente status = SETWINDOWCONFIG (wc) i4 = SETBKCOLOR(8) CALL CLEARSCREEN($GCLEARSCREEN) i4 = clickmenuqq(qwin$tile)

- 84 -

ESCUELA SUPERIOR POLITECNICA DEL LITORAL FACULTAD DE INGENIERIA MARITIMA Y CIENCIAS DEL MAR PROGRAMACION PROGRAMACION APLICADA 1 ! Dibujo del fondo blanco de la tabla i4 = setcolor(15) dummy = rectangle( $GFILLINTERIOR, 25,20,NCOLS*50+25,NROWS*20+20) i4 = setcolorRGB(#C0C0C0) x1 = 0; y1 = 0 x2 = IXPIXEL-25; y2 = 20 dummy = rectangle( $GFILLINTERIOR, x1, y1, x2, y2 ) dummy = rectangle( $GFILLINTERIOR, x1, y1, 25,IYPIXEL-20) i4 = setcolor(0) ! Dibujo de filas y columnas de tìtulos ! Cuadrados para fila del título dummy = rectangle( $GBORDER, x1, y1, 25, y2 ) ! Generación de cuadros para fila de títulos N cuadros do i=1,NCOLS dummy = rectangle( $GBORDER, x1+50*i-25, y1, 50*i+25, y2 ) enddo ! Cuadrados para columna de títulos dummy = rectangle( $GBORDER,x1,y1,25,20) ! Generación de cuadros de columna para títulos N cuadros do i=1,NROWS dummy = rectangle( $GBORDER, x1, (1+i)*20, 25, y1+i*20 ) enddo ! Fila de títulos result = INITIALIZEFONTS() result = SETFONT('t''Arial''h15w6') do i=1,NCOLS call moveto(25+(i-1)*50+7,2,xy) texto=titulo(i) call outgtext(texto) enddo ! Columna de títulos do i = 1,NROWS call moveto(5,20*i+2,xy) itexto = i write(texto,'(i3)')itexto call outgtext(texto) enddo ! Cálculo de celdas verticales fx(1) = 75 fy(1) = 20 tx(1) = 75 ty(1) = NROWS*20+20 do i = 2,NCOLS !desde aquí fx(i) =50*i-25 fy(i) =20 !hasta aquí tx(i) =50*i-25 ty(i) =NROWS*20+20 enddo

! Dibuja todas las líneas a la vez ! líneas grises verticales i4 = setcolor(8) style = #AAAA CALL SETLINESTYLE(style) result = LINETOAR(loc(fx),loc(fy),loc(tx),loc(ty), ncols) ! Dibujo de celdas horizontales fx(1) = 25 fy(1) = 40 tx(1) = NCOLS*50+25 ty(1) = 40 do i = 2,NROWS-1 ! desde aquí fx(i) = 25 fy(i) = 20*(i+1) ! hasta aquí tx(i) = NCOLS*50+25 ty(i) = 20*(i+1) enddo

- 85 -

ESCUELA SUPERIOR POLITECNICA DEL LITORAL FACULTAD DE INGENIERIA MARITIMA Y CIENCIAS DEL MAR PROGRAMACION PROGRAMACION APLICADA 1 ! Dibuja todas las líneas a la vez ! líneas grises horizonales i4 = setcolor(8) style = #AAAA CALL SETLINESTYLE(style) result = LINETOAR(loc(fx),loc(fy),loc(tx),loc(ty), NROWS-1) ! Dibuja rectangulo exterior negro i4 = setcolor(0) style = #FFFF CALL SETLINESTYLE(style) dummy = rectangle( $GBORDER, 0,0,NCOLS*50+25,NROWS*20+20) ! Llenado de la tabla con el arreglo array(j,i) (COLUMNASXFILAS) ! Y siempre es 20*i+2, X siempre es 25+50*i+5 el formato es ingresado como parámetro result = INITIALIZEFONTS() result = SETFONT('t''Arial''h14w5') ! Se escriben los vectores por columnas do j=1,NCOLS do i=1,NROWS call moveto(25+50*(j-1)+5,20*i+2,xy) ! Colocar el formato adecuado write(texto,fmt)array(j,i) call outgtext(texto) enddo enddo select case(excel) case(1) TEXTO=TITULO(1) call CVFxlsEsc(TEXTO,NCOLS,NROWS,ARRAY) case(0) excel=0 end select END

10.3 10.3 Rutin Rutin a de in tercambio CVFDif CVFDif Esta rutina está creada para poder leer y escribir desde y hacia un archivo con formato de intercambio de datos (DIF), desde un programa escrito en Fortran y capaz de ser leído como hoja electrónica por MS Excel. Para que la subrutina pueda leer el archivo con formato DIF, debe crearse en MS Excel una hoja electrónica y guardarse como archivo DIF, sin colocar títulos en las columnas y empezando en la casilla A1, la escritura se hará manteniendo manteniendo el mismo esquema, esquema, esto es sin títulos y empezando en la casilla A1. La rutina está escrita en Fortran 90, formato libre, para ser usado en un proyecto del tipo FORTRAN STANDARD GRAPHICS. GRAPHICS. No tiene la la estructura de módulo así así que bastará con adicionar adicionar al proyecto el archivo arc hivo que la contiene y llamar a sus subrutinas desde el programa principal. Esta rutina es de distribución GRATUITA y no puede ser comercializada total o parcialmente. Está compuesta compuesta de dos subrutinas subrutinas una para para la lectura desde el archivo con formato DIF y almacenada almacenada en un arreglo arreglo de dimensión dimensión FILAxCOLUMNA, de hasta hasta 99999x99999, aunque esta propiedad es flexible, bastará con cambiar el tamaño del arreglo en la declaración de la variable que almacenará la información en la subrutina que se esté usando. La segunda segunda subrutina escribe un archivo con formato DIF de los datos guardados en un arreglo de dimensión d imensión FILAxCOLUMNA, de hasta 99999x99999,

- 86 -


aunque al igual que la subrutina anterior esta dimensión puede variar de acuerdo a las necesidades del usuario. 1. CVFxlsEsc () 1.1 Descripción: Esta subrutina escribe un archivo de datos en formato DIF, capaz de ser leído por MS Excel, con la información almacenada en un arreglo x(fila,columna) 1.2 Sintaxis: CALL CVFxlsEsc (archdata,col,n,x) 1.3 Argumentos: 1.3.1 Archdata: es una variable alfanumérica que contiene el nombre del archivo en el que se escribirá la información, el programa coloca la extensión DIF, si el nombre no la tiene y cambia cualquier extensión que se ingrese a la de DIF. 1.3.2 Col: es el número de columnas del arreglo 1.3.3 N: es el número de filas del arreglo 1.3.4 X: es el arreglo donde se almacena la información que desea escribirse en el archivo, tiene dimensión (n,col) 2. CVFxlsLee() 2.1 Descripción: Esta subrutina lee desde un archivo de datos en formato DIF, información numérica y la almacenada en un arreglo x(fila,columna). 2.2 Sintáxis: CALL CVFxlsLee (archdata,col,n,x) 2.3 Argumentos: Requiere de los siguientes argumentos de entrada: 2.3.1 Archdata: es una variable alfanumérica que contiene el nombre del archivo en el que se escribirá la información, el programa coloca la extensión DIF, si el nombre no la tiene y cambia cualquier extensión que se ingrese a la de DIF. 2.3.1 Col: es el número de columnas del arreglo, esta variable es el resultado de llamar a la subrutina. 2.3.1 N: es el número de filas del arreglo, variable resultante de llamar a la subrutina. 2.3.1 X: es el arreglo donde se almacena la información que se lee desde el l archivo, tiene dimensión (n,col). El código fuente que ejecuta esta subrutina se detalla a continuación: ! INICIO DE RUTINA DE ESCRITURA EN EXCEL ! Esta subrutina escribe en un archivo de intercambio de datos, para ! abrirlo en Excel, por defecto se crea una sola hoja electónica. subroutine CVFxlsEsc(archdat,col,n,x) ! Nota: la declaración del arreglo x(n,col) debe ser la misma que en ! el arreglo del archivo principal ! la variable con la que se llama a la subrutina debe tener la ! misma dimensión para que sea compatible. ! ! Argumentos ! ! archdat Nombre del archivo de datos, el programa cambia la ! extensión a DIF ! col Número de columnas del arreglo de datos, entero ! n Número de filas del arreglo de datos, entero ! x Arreglo que contiene la información que desea guardarse d ! aunque es mandatorio que debe tener la misma dimensión de ! la variable que llama a la subrutina.

- 87 -


use dflib use dfwin integer i,n,col real, dimension(10,10):: x character*25 archdat,archdif,arch character*1 resul(29) equivalence (resul(1),archdif) ! Cambio o coloca la extensión al nombre del archivo de datos archdif=archdat do i=1,25 k=26-i if((resul(k).ne.' ')) goto 7 end do 7 nt=k if (nt.ge.5) then if (resul(nt-3).eq.'.') then resul(nt-2)='d' resul(nt-1)='i' resul(nt) ='f' endif else resul(nt+1)='.' resul(nt+2)='d' resul(nt+3)='i' resul(nt+4)='f' endif ! Fin del cambio de extensión ! Abrir el archivo DIF open(2,file=archdif,status='new',err=1969) ! Escribe el encabezado write(2,10)n,col ! Fin del encabezado ! Escritura de resultados do i=1,n write(2,13) do j=1,col write(2,14)x(i,j) end do end do ! Fin de escritura de información ! Cerrar el archivo de resultados write(2,15) close(2,status='keep') i4=messageboxqq('El programa ha terminado, se ha generado un & & archivo, \rescrito en formato de intercambio de & & datos'c,'Fin de la aplicación'c,& & mb$iconexclamation.or.mb$ok) ! ! para poder ver el archivo de resultados debe cambiarse el nombre del ! archivo LEE.DIF por el nombre que se uso en el programa !

- 88 -


!if (i4.eq.mb$idyes) then ! i4=winexec('explorer.exe lee.dif 'c,sw_maximize) !end if ! Fin del cierre del archivo de resultados return 1969 i4=messageboxqq('El archivo ya existe, desea reemplazarlo?'c,& & 'Error'c,mb$iconstop.or.mb$yesno) if (i4.eq.mb$idyes) then ! Escribe el encabezado write(2,10)n,col ! Fin del encabezado ! Escritura de resultados do i=1,n write(2,13) do j=1,col write(2,14)x(i,j) end do end do ! Fin de escritura de información ! Cerrar el archivo de resultados write(2,15) close(2,status='keep') i4=messageboxqq('El programa ha terminado, se ha generado un archivo\r & escrito en formato de intercambio de datos'c, 'Fin de& & la aplicación'c, mb$iconexclamation.or.mb$ok) !i4=messageboxqq('El programa ha terminado, desea ver el\rarchivo& ! & escrito en formato dif?'c, 'Fin de la aplicación'c,& ! & mb$iconquestion.or.mb$yesno) ! !if (i4.eq.mb$idyes) then ! i4=winexec('explorer.exe lee.dif'c,sw_maximize) !end if ! Fin del cierre del archivo de resultados return endif ! Listado de formatos para escribir en el archivo DIF 10

format('TABLE',/,'0,1',/,'"EXCEL"',/,'VECTORS',/,'0,',I5,/'""',/& &,'TUPLES',/,'0,',I5,/,'""',/,'DATA',/'0,0',/,'""') 13 format('-1,0',/,'BOT') 14 format('0,',e12.6,/,'v') 15 format('-1,0',/,'EOF') end subroutine ! ! ! ! ! !

INICIO DE RUTINA DE LECTURA DESDE EXCEL Esta subrutina lee un archivo de intercambio de datos, que ha sido creado en Excel y grabado con la extensión DIF, para crear un archivo de datos es necesario comenzar en la celda A1, el archivo debe contener titulos en la fila 1 y los datos numéricos a partir de la fila 2, escritos en formato E10.4

- 89 -


subroutine CVFxlsLee(archdat,col,n,x) ! Nota: la declaración del arreglo x(n,col) debe ser la misma que en ! el arreglo del archivo principal, la variable con la que se llama a ! la subrutina debe tener la misma dimensión para que sea compatible. ! ! Argumentos ! ! archdat Nombre del archivo de datos siempre con extensión DIF ! col Número de columnas del arreglo de datos, esta variable es ! el resultado de llamar a la subrutina. INTENT (OUT) ! n Número de filas del arreglo de datos. INTENT (OUT) ! x Arreglo que resulta de leer la información desde un archivo ! de datos DIF, es de dos dimensiones (NxCOL)

use dflib integer i integer, intent(out):: n,col real, intent(out), dimension (200,200):: x character*25 archdat character*2 alfa,bravo ! Abrir el archivo para lectura y ! Obtención del número de filas (n) y columnas (col) open(2,file=archdat,status='old',err=1969) read(2,10)n read(2,11)col 10 format(////,2x,i4) 11 format(//,2x,i4) ! Fin de lectura inicial Filas y columnas ! Inicio de lectura por filas read(2,12)alfa do i=1,n read(2,13) do j=1,col read(2,14)x(i,j) end do end do 12 format(///,a2) 13 format(/,a2) 14 format(2x,e12.6,/) ! Fin de la lectura de datos ! Cerrar el archivo de datos close (2,status='keep') ! Fin return 1969 i4 = messageboxqq('El archivo no ha sido encontrado'c, 'Error'c,& & mb$iconstop.or.mb$ok) end subroutine

- 90 -


10.5 Ventanas virt uales ampl ias Esta rutina es una adaptación de un ejemplo de Visual Fortran codificado con lenguaje mixto, C++ & Fortran, la idea es que cuando listamos gran cantidad de ítems en la ventana virtual, ésta es muy pequeña para ver todos los elementos que hemos listado, con la rutina que se explica a continuación podemos ir desplazando la ventana de presentación hacia abajo conforme se listan los resultados o simplemente vamos directamente al final, sin perder la presentación de los primeros datos de la lista. La rutina incluye comentarios para ir guiando al usuario. program VENTANA_SCROLL use dflib use dfwin TYPE (windowconfig) wc TYPE(qwinfo) wci TYPE(rccoord) rc integer*4 i, j, status, irow, rowmoves, pagesize character*1 ch I=0 open(unit=6,file="user") !HAY QUE COLOCAR UN GRAN NUMERO DE FILAS DE TEXTO, !MUCHO MAYOR QUE LA VENTANA VISIBLE wc%numtextrows = 1501 ! NUMERO QUE BAJARA CON SCROLL wc%numtextcols = 80 wc.numxpixels = -1 wc.numypixels = -1 wc.numcolors = -1 wc.title = "Unit 6"C wc.fontsize = #00080010 ! ACTIVAMOS LA CONFIGURACION DE LA VENTANA status = setwindowconfig(wc) IROW=1 DO I=1,1000 WRITE(6,*)'DATO No. ',I ENDDO !POSICION AL FINALIZAR LA ESCRITURA call gettextposition(rc) rowmoves = rc.row - irow !AJUSTAMOS LA VENTANA VISIBLE pagesize = 20 rowmoves = rowmoves - pagesize+1 !call tobottom(6) ! LO MAS SIMPLE call scrolldown(6, rowmoves) ! EL SCROLL VIAJA CON LA ESCRITURA END subroutine tobottom(unit) use dflib use dfwin integer unit, hwnd, res hwnd = GetHwndQQ(unit) res = SendMessage(hwnd,WM_VSCROLL,SB_BOTTOM,0) end subroutine tobottom subroutine scrolldown(unit,rows) use dflib

- 91 -


use dfwin integer unit, hwnd, res, rows, i hwnd = GetHwndQQ(unit) do i = 1, rows res = SendMessage(hwnd,WM_VSCROLL,SB_LINEDOWN,0) enddo end subroutine scrolldown

Un ejemplo de aplicación se muestra en la figura No. 31.

Figura No. 31.- Ejecución de la rutina ScrollDown, a la izquierda el inicio y a la derecha el fin, nótese que con una ejecución normal no podríamos ver el inicio del archivo

10.6 Resolución de si stemas d e ecuaciones lin eales 10.6.1 Resolución Numérica El método numérico de resolución de ecuaciones lineales no evalúa previamente el determinante de la matriz para determinar la regularidad de la matriz de coeficientes, aunque se puede evaluar la matriz teniendo en cuenta la diagonal principal y el origen del sistema para de esta forma determinar el tipo de matriz. La generación de algoritmos implica optimización y eficacia, existen tres criterios fundamentales para analizar los algoritmos. 1. Número de operaciones necesarias: este criterio tiene que ver con el tiempo que demora el computador en resolver el sistema, si bien no es exactamente el valor obtenido de multiplicar el tipo de operaciones básicas por el número de veces que s er realiza, debido a que existen operaciones lógicas, lazos anidados, etc. Sin embargo es un buen indicador de la tendencia, ya que depende normalmente de „n‟, dimensión de la matriz,

- 92 -


por lo que podríamos ver como varía si alteramos o cambiamos el orden „n‟ de la

matriz. 2. Necesidades de almacenamiento: este criterio tienen que ver con la capacidad del computador en lo que respecta a memoria física, el tipo de almacenamiento vendrá dado por el tipo de sistema que tengamos. 3. Rango de aplicación: no todos los métodos resuelven todos los sistemas no singulares de ecuaciones lineales, pequeños errores de redondeo pueden acarrear grandes errores en la solución numérica, luego en un sistema de ecuaciones medio-grande el análisis de errores por redondeo no es trivial.

Los algoritmos deben cumplir simultáneamente los tres criterios planteados. Desde el punto de vista general las matrices más usuales en ingeniería pueden englobarse en dos categorías: 1. Matrices llenas pero no muy grandes: llenas entendemos que tienen pocos elementos nulos, y no muy grandes de sistemas de hasta algunos miles de ecuaciones, son típicos de problemas estadísticos, matemáticos y físicos. 2. Matrices vacías pero muy grandes: vacías entendemos que tienen pocos elementos no nulos y ubicados con cierta simetría, y muy grandes indica que superan los miles, incluso llegan a los millones. Son típicas de problemas de ingeniería.

En términos generales los métodos de resolución se ajustan a los tipos de matrices, los primeros se resuelven con métodos directos y los segundos con métodos iterativos. 10.6.2 Métodos de resolución

Métodos directos Los métodos directos de resolución son aquellos que permiten obtener la solución del sistema después de un número finito de operaciones. Debido a que las computadoras tienen un número finito de cifras decimales, los errores de redondeo se propagan, de manera que se pretende desarrollar métodos con un número mínimo de operaciones, la clasificación de los métodos directos son:

Sistemas con solución inmediata 1. Matriz diagonal: en este caso se escribe A como:

- 93 -


Y la solución se obtiene directamente como:

Existe solución si los elementos de la diagonal son no nulos y el determinante de A es igual al producto de todos los términos de la diagonal, el número de operaciones que deben realizarse es „n‟.

2. Matriz triangular superior y triangular inferior: en este caso se definen como L (lower) a la matriz triangular inferior, y U (upper) a la matriz triangular superior. Y se las define como:

La solución se expresa como sustitución hacia delante o hacia atrás, según se esté resolviendo un sistema triangular superior o inferior respectivamente. Los algoritmos para resolver estas matrices son:

El número de operaciones que deben realizarse en cada caso es: n 2 para ambos casos

Métodos de eliminación 1. Método de Gauss, eliminación simple: este método se basa en transformar la matriz original A, mediante permutaciones y combinaciones lineales de las ecuaciones en una matriz triangular superior, este nuevo sistema equivalente se resuelve de manera inmediata, aplicando el algoritmo del apartado anterior. Las ecuaciones que transforman la matriz original en una triangular superior y modifican al término independiente son:

- 94 -


El número total de operaciones que se realizan en el algoritmo son: Este método supone que los elementos de la diagonal principal modificada son no nulos, así que la obtención de un elemento nulo haría que el sistema falle. Si el elemento nulo existe en la diagonal, se permuta entre filas hasta obtener el elemento no nulo mayor en valor absoluto, esta permutación de filas no solo tiene interés cuando el pivote es exactamente cero, es obvio que para valores pequeños del pivote los errores de redondeo ocasionan grandes errores, ya que siempre se divide para el valor del pivote; existen dos técnicas para escoger el valor absoluto mayor: a. En el k-ésimo sistema se toma como pivote el coeficiente de mayor valor absoluto de la columna k situado por debajo de la fila k inclusive. Para esto es necesario permutar las filas k y la correspondiente al pivote escogido en la matriz y su término independiente. A este método se conoce como Método de Gauss con pivotamiento parcial b. En el k-ésimo sistema, se toma como pivote el coeficiente mayor en valor absoluto de la submatriz de orden n-k, definida por los coeficientes que quedan or debajo de la fila k y a la derecha de la columna k. Para ello, se permuta la fila k y la columna k con las correspondientes al coeficiente que cumple con la condición citada. Al final del proceso deben ponerse en el orden inicial las componentes del vector solución puesto que su posición ha sido modificada al realizar las permutaciones de columnas. A este método se conoce como Método de Gauss con pivotamiento total. 2. Método de Gauss-Jordan: Es una modificación del método de Gauss, cuyo objetivo además de transformar la matriz, sigue realizando operaciones para convertir la matriz en la matriz identidad, luego la solución del sistema es el término independiente resultante. Se puede definir esta matriz como

Las ecuaciones que definen el algoritmo son las siguientes:

El número de operaciones que se realizan con este algoritmo son:

Métodos de descomposición Los métodos de factorización se fundamentan en el concepto de que toda matriz A puede descomponerse en matrices triangulares superiores e inferiores o en el producto - 95 -


de ambas luego el sistema original A x = b se transforma en dos sistemas de solución inmediata, de la forma: 1. Método de Crout: este método de factorización transforma la matriz A en dos matrices triangulares donde una de ellas, la superior tiene la diagonal llena de unos. El algoritmo que transforma la matriz es el siguiente.

Finalmente el sistema se resume a resolver dos sistemas de solución inmediata de manera sucesiva. El método de Doolitle es similar a este algoritmo ya que consigue el mismo resultado, sin embargo este es más eficiente. 2. Método de Cholesky: la factorización de Cholesky se aplica únicamente a matrices simétricas y definidas como positivas, aprovecha el concepto de que una matriz A puede transformarse en una triangular inferior, y la superior corresponde a la transpuesta de esta matriz triangular. Simbólicamente se representa como: A = LL

T

El algoritmo que factoriza la matriz A es el siguiente:

- 96 -


3. Métodos de descomposición generalizada: Al igual que en el método de Crout, si se desea se puede conseguir que las dos matrices triangulares de la descomposición tengan unos en la diagonal, agregando una matriz D a la factorización de la matriz A, obteniéndose como resultado: A = LDU, de igual forma para el método de Cholesky puede generalizarse como A = LLT. El algoritmo para realizar esta transformación es para el caso del Método de Crout:

El algoritmo para realizar la transformación para el caso del Método de Cholesky es el siguiente:

- 97 -


4. Método de Thomas: matrices tridiagonales, este método se obtiene particularizando el método de Crout al caso de u = l = 1, el algoritmo que resuelve esta matriz es:

10.6.3 Ejercicio de aplicación En la resolución numérica de una ecuación diferencial ordinaria que modela la deformación de una viga de longitud la unidad, sometida a una carga distribuida de valor la unidad se ha obtenido un sistema lineal de ecuaciones Ax = b, donde A es una matriz de orden „n‟, simétrica y en banda, cuyos coeficientes se determinan como:

Y b es un vector con coeficientes: Donde los valores de E, I, a, b, p a, p b son constantes del problema y

. Se pide

1. Escribir un programa en FORTRAN usando dimensionamiento dinámico para generar la matriz A y el vector b 2. Resolver el sistema de ecuaciones por un método de los revisados en el curso para los siguientes datos: a = 0, b = 1, p a = 1, p b = 1, E = 105, I = 10 -5 y para n con valores 5, 19 y 99. 3. Importar los resultados a EXCEL y generar para cada valor de N una lista de pares ordenados con i = 0, …., n+1, según las siguientes relaciones:

- 98 -


Y xi con i = 1, …., n, iguales a los resultados obtenidos a partir del programa. Presentar un solo gráfico con las tres series de pares ordenados.

Nota: Toda la teoría, algoritmos y ejemplo han sido extraídos del texto de la referencia: [8]

- 99 -


11.0 Normas Europeas para escribir y documentar códigos fuente en Fortran 90 El siguiente es un extracto de los aspectos más importantes de las normas europeas de codificación en Fortran 90 obtenida del sitio de Internet: www.met-office.gov.uk , los comentarios o puntos de vista del autor, van en cursiva.

11.1 Docum entación La documentación de una aplicación puede ser agrupada en dos categorías, la documentación externa, es decir la que se genera fuera del código y la interna que viene incluida dentro del código. Para fines de modificaciones, éstas deben hacerse en los dos tipos de documentación y en lo posible si el código va a ser colocado en Internet o para intercambio con otros centros de investigación deben escribirse en inglés. 11.1.1 Documentación Externa Debe ser provista a manera de libretín impreso, es opcional el formato digital conocido en el medio: DOC, PDF, HTML, TXT, etc. Y en términos generales debe contener los siguientes apartados: 1. Documentación científica: aquí se describe el problema que se está resolviendo, el motivo y el método adoptado para su solución, esta información es independiente y no debe hacer referencia al código. 2. Documentación de la implementación: es la descripción de la implementación del método de solución enunciado en la parte 1, Todas los subprogramas (subrutinas, módulos, funciones, etc.) deben listarse por orden alfabético y hacer un pequeño resumen en el que se describa que hacen. Además debe incluirse un árbol de llamadas a los subprogramas. 3. Guía de uso del programa: se describe en detalle todas las variables de entrada y salida de información, incluido los argumentos de los subprogramas y cualquier otra variable que ingrese información ya sea desde pantalla o archivo, se indica también el tipo de variable y los límites que pueden tener los valores ingresados, la lista de archivos que son leídos o escritos por el programa. La documentación externa es obligatoria a cada aplicación o paquete de aplicaciones que se presenten. 11.1.2 Documentación Interna Esta información es aplicada para cada nivel de subprograma y programa principal, existen 4 tipos de documentación interna y todos deben estar presentes en el código.

1. Encabezados: todo programa principal o subprograma debe contener el encabezado donde se describe brevemente el subprograma o programa y se declaran todas las variables usadas con una descripción de lo que hacen. Puede hacerse referencia a la documentación externa pero no se puede omitir los encabezados ni su estructura. Al final de este capítulo, se encuentran las formas de los encabezados de programas principales y subprogramas. 2. Inicios de sección dentro de un programa o subprograma: dividen el código en secciones lógicas de operaciones, se escriben dentro del código y al inicio de cada sección. El formato que debe seguirse es el siguiente:

- 100 -


!----------------------------------------------! ! [Número de sección] [Título de sección] ! !-----------------------------------------------------------------------

3. Otros comentarios, están orientados a simplificar el entendimiento de los que se está haciendo en cada paso, se incluye dentro de las líneas y en cualquier lugar del código. El formato recomendado es el siguiente ! [Comentario]

4. Nombres de significados fáciles de entender: va orientado a que cualquier persona identifique rápidamente el tipo de variable o lo que almacena. Por ejemplo una variable que almacena la información de distancia puede llamarse: longitud ó distancia, que se entendería mejor que si se llama X o D.

11.2 Obso lescencias de otras version es Algunas de las siguientes sentencias se recomiendan no usarlas en la codificación de Fortran 90, debido a que causan redundancia y hacen poco eficientes los programas, se incluye al lado de cada declaración obsoleta la declaración aplicable a la Versión F90. 1. COMMON blocks – Use MODULES 2. EQUIVALENCE – Use POINTERS o sus derivados 3. GOTO – Use SELECT CASE 4. IF aritmético – Use IF THEN 5. DO seguido de un número – Use DO ENDDO 6. Línea de FORMAT – Use formatos específicos dentro de READ o WRITE; otra opción es declarar el parámetro „fmt‟.

7. PAUSE

11.3 Reglas b ásic as de c od ific ación 1. Siempre use sintaxis de formato libre (free format) 2. La línea de código debe tener máximo 80 caracteres, si bien Fortran 90 admite 132 columnas, esto puede causar problemas de visualización y errores en la impresión de hojas A4. 3. Siempre debe usarse la sentencia IMPLICIT NONE, de tal forma que puedan detectarse los errores en declaración o uso de variables. 4. Los nombres de las variables deben ser términos que indiquen el valor que se almacena o se pide, se aceptan abreviaciones de estas palabras cuando son demasiado largas. Lo importante es que sean fácilmente identificadas. 5. Las sentencias y declaraciones deben escribirse con mayúsculas solo la primera letra y el resto con minúsculas, se admiten esquemas mixtos cuando se unen dos palabras. 6. Los cortes de líneas de código deben hacerse en lugares que sean fáciles de interpretar y entender. 7. Usar espacios en blanco vertical y horizontal, para dar facilidad de lectura, en el sentido vertical, luego de un comentario o para separar bloques de ejecución, y horizontal antes y después de un signo de operación para separar las variables de otras sentencias o declaraciones. 8. Borre todo código o comentario que no sirva en la ejecución final de la aplicación. - 101 -


9. No coloque múltiples declaraciones en una sola línea, reduce la facilidad de lectura del código. 10. Cuando se declaran variables observar las siguientes normas: a. Para arreglos no use la declaración DIMENSION sola, use la sintaxis para declarar arreglos de la siguiente forma: Real, dimension (:,:) ::

NombreArreglo

b. Use siempre después de definir el tipo de variable los signos :: c. Declare la longitud de las variables de carácter usando la siguiente sintaxis: character (len = 25) ArchData

11.4 Encabezados para programas y su bpr ogr amas Todo lo que se encuentre entre [ ] debe ser llenado por el usuario con la información correspondiente a cada caso 11.4.1 Programas principales ! ! Program

[ProgramName]

! Description: ! [Say what this program does] ! ! Method: ! [Say how it does it: include references to external documentation] ! [If this routine is divided into sections, be brief here, ! and put Method comments at the start of each section] ! ! Input files: ! [Describe these, and say in which routine they are read] ! Output files: ! [Describe these, and say in which routine they are written] ! Current Code Owner: [Name of person responsible for this code] ! ! ! !

History: Version Date ---------[version] [date]

Comment ------Original code. [Your name]

! Code Description: ! Language: Fortran 90. ! Software Standards: "European Standards for Writing and ! Documenting Exchangeable Fortran 90 Code". ! Declarations: ! Modules used: Use, Only : & ! Imported Type Definitions: ! Imported Parameters: ! Imported Scalar Variables with intent (in):

- 102 -


! Imported Scalar Variables with intent (out): ! Imported Array Variables with intent (in): ! Imported Array Variables with intent (out): ! Imported Routines: ! Implicit None ! Include statements ! Declarations must be of the form: ! [type] [VariableName] ! Description/ purpose of variable ! Local parameters: ! Local scalars: ! Local arrays:

!- End of header ------------------------------------------------------11.4.2 Subrutinas ! [A one line description of this subroutine] ! Subroutine [SubroutineName] & ! ! ([InputArguments, inoutArguments, OutputArguments]) ! Description: ! [Say what this routine does] ! ! Method: ! [Say how it does it: include references to external documentation] ! [If this routine is divided into sections, be brief here, !and put Method comments at the start of each section] ! ! Current Code Owner: [Name of person responsible for this code] ! ! History: ! Version Date Comment ! ---------------! [version] [date] Original code. [Your name] ! ! Code Description: ! Language: Fortran 90. ! Software Standards: "European Standards for Writing and ! Documenting Exchangeable Fortran 90 Code". ! ! Declarations: ! Modules used: Use, Only : & ! Imported Type Definitions: ! Imported Parameters:

- 103 -


! Imported Scalar Variables with intent (in): ! Imported Scalar Variables with intent (out): ! Imported Array Variables with intent (in): ! Imported Array Variables with intent (out): ! Imported Routines: ! [Repeat from Use for each module...] Implicit None ! Include statements: ! Declarations must be of the form: ! [type] [VariableName] ! Description/ purpose of variable ! Subroutine arguments ! Scalar arguments with intent(in): ! Array

arguments with intent(in):

! Scalar arguments with intent(inout): ! Array

arguments with intent(inout):

! Scalar arguments with intent(out): ! Array

arguments with intent(out):

! Local parameters: ! Local scalars: ! Local arrays: !- End of header ------------------------------------------------

11.4.3 Funciones ! [A one line description of this function] ! Function [FunctionName]]& ([InputArguments]) & Result ([ResultName]) ! The use of result is recommended ! but is not compulsory. ! ! ! ! ! ! ! ! ! ! ! !

Description: [Say what this function does] Method: [Say how it does it: include references to external documentation] [If this routine is divided into sections, be brief here, and put Method comments at the start of each section] Current Code Owner: [Name of person responsible for this code] History: Version

Date

Comment

- 104 -


! ! ! ! ! ! ! ! ! !

---------[version] [date]

------Original code. [Your name]

Code Description: Language: Fortran 90. Software Standards: "European Standards for Writing and Documenting Exchangeable Fortran 90 Code". Declarations: Modules used:

Use, Only : & ! Imported Type Definitions: ! Imported Parameters: ! Imported Scalar Variables with intent (in): ! Imported Scalar Variables with intent (out): ! Imported Array Variables with intent (in): ! Imported Array Variables with intent (out): ! Imported Routines: ! [Repeat from Use for each module...] Implicit None ! Declarations must be of the form: ! [type] [VariableName] ! Description/ purpose of variable ! Include statements: ! Function arguments ! Scalar arguments with intent(in): ! Array

arguments with intent(in):

! Local parameters: ! Local scalars: ! Local arrays: !- End of header ----------------------------------------------------

11.4.4 Módulos ! [A one line description of this module] ! Module [ModuleName] ! ! Description: ! [Say what this module is for] ! ! Current Code Owner: [Name of person responsible for this code] !

- 105 -


! History: ! ! Version Date Comment ! ---------------! [version] [date] Original code. [Your name] ! ! Code Description: ! Language: Fortran 90. ! Software Standards: "European Standards for Writing and ! Documenting Exchangeable Fortran 90 Code". ! ! Modules used: ! Use, only : & ! Imported Type Definitions: ! Imported Parameters: ! Imported Scalar Variables with intent (in): ! Imported Scalar Variables with intent (out): ! Imported Array Variables with intent (in): ! Imported Array Variables with intent (out): ! Imported Routines: ! Declarations must be of the form: ! [type] [VariableName] ! Description/ purpose of variable Implicit none ! Global (i.e. public) Declarations: ! Global Type Definitions: ! Global Parameters: ! Global Scalars: ! Global Arrays: ! Local (i.e. private) Declarations: ! Local Type Definitions: ! Local Parameters: ! Local Scalars: ! Local Arrays: ! Operator definitions: ! Define new operators or overload existing ones. Contains ! Define procedures contained in this module. End module [ModuleName] !- End of module header

- 106 -


12.0 Ejercicios Propuestos 1. Escribir un programa que obtenga el número factorial de un entero ingresado por pantalla, el resultado debe mostrarse por pantalla 2. Escribir un programa para resolver la ecuación de 2do. Grado ingresando los coeficientes de la ecuación de la forma Ax 2+Bx+C=0. Incluir las opciones con respuestas imaginarias. 3. Escribir un programa para realizar la integración de un conjunto de ordenadas, leídas desde un archivo, usando el método de Simpson 1/3. Los resultados deben mostrarse en pantalla y en un archivo de resultados. 4. Escriba un programa que ordene los valores de un vector de mayor a menor y viceversa, el vector se lee desde un archivo. 5. Escriba un programa que dada una matriz nxm sume filas, columnas y general, halle promedios entre filas y columnas y general, la matriz se lee desde un archivo y los resultados deben ser impresos por pantalla y en un archivo. 6. Escriba un programa que realice operaciones con vectores en 3 dimensiones, suma, resta, producto escalar y vectorial y determinación del módulo del vector. 7. El arqueo bruto de un barco puede aproximarse usando formulación sencilla, y considera al volumen TRB desglosado en las siguientes capacidades, todas en m3: a. Volumen del casco por debajo de la cubierta de Arqueo, hasta el nivel del puntal. VDB LPP B D CBD CBD

CB

0.35

D T T

1 CB

b. Volumen debido a la brusca de la cubierta VBR

0.012LPP B 2

c. Volumen de superestructuras y casetas VSUP

41LPP 755

Escriba un programa para determinar de manera aproximada el TRB de un barco dados LPP, B, D, T y CB. La información y el resultado final, deben mostrarse en pantalla, los resultados intermedios deben guardarse en un archivo de resultados con el nombre del barco. 8. La selección de un coeficiente de bloque adecuado está relacionado con el número de Froude, elegido de esta forma nos permite posteriormente optimizar las formas. Existen varias formulaciones para determinar el CB a partir del número de Froude, a continuación se listan 4, con estas formulaciones escribir un programa que muestre los valores que se obtienen de CB para un rango del número de Froude entre 0.14 y 0.32 para el mismo buque: LPP de 115 m y Manga de 11 m., la información debe presentarse en forma de tabla y la columna final debe obtener un promedio de cada caso.

- 107 -


V

CB

0.5V

3.28 LPP LPP 0.7 0.125ATAN 25

CB

0.14

CB

FN 0.23

CB

3

LPP

0.23 FN

20B

26B LPP 20B 26B

FN 2

9. El efecto de superficie libre sobre la estabilidad del buque, en el caso de los tanques de carga de un tanquero tiene un tratamiento diferente al clásico, el momento escorante debido al movimiento del líquido se calcula con la fórmula: M IT WPVOL C , donde WPVOL es el peso específico del líquido en TON/m3, IT el momento de inercia transversal del tanque en m 4, C es una corrección en función de la geometría del tanque, grado de llenado y ángulo de escora. La corrección del brazo adrizante se calcula como: GZ

M

Se pueden presentar 3 casos: a. La superficie libre no toca el techo ni el fondo del tanque C

SEN

1

1 2

TAN 2

Esta relación es válida para ángulos menores al definido por: TAN

2 N H B

b. La superficie libre está limitada por el techo y una pared del tanque C

2 N S 3COS

3 N S SEN

4COS2

N S SEN 2

Esta relación es válida para ángulos menores al definido por: TAN

H 2 N B

c. La superficie libre está limitada por el techo y el fondo del tanque, la corrección en el intervalo - 90 grados se define como C

S 6 N 1 N COS

S SEN

1 2

S 2 COS

2

COS 2

Donde N es la fracción vacía del tanque, H la altura del tanque, B manga del tanque y S la relación H/B. Escribir un programa asumiendo un tanque de sección rectangular en toda su eslora, para determinar el brazo de adrizamiento de un barco tanquero de 2000 TON de desplazamiento con tanques de 17 m de largo por 12 de ancho y 10 de alto, para fracciones de llenado desde 10% a 90% para los 3 casos. El resultado debe mostrarse como una tabla en pantalla y en un archivo de resultados. 10. Escriba un programa en Fortran que almacene en una matriz de dimensión NxN, la función que se describe, entre los valores de -2.0 y 2.0, para X y Y.

- 108 -


z

e

x 2 y2

11. Las características de maniobrabilidad de un buque reguladas por IMO, se definen en cuatro parámetros: diámetro de giro, diámetro táctico, avance y caída o transferencia. En el año 1979 se propusieron fórmulas para estimar estos parámetros, deducidas del análisis de una muestra de buques de esloras entre 50 y 350 m. Diámetro de giro (turning diameter) Buques de una hélice:

DG

Lpp 4.19

203Cb

47.4TRIM

13B

Lpp

Lpp

194

35.8APala

7.79ABulbo

Lpp H

Lpp H

Esta fórmula se refiere a codastes abiertos, sin considerar diferencias entre los giros de estribor o babor, si el codaste es cerrado, el sexto término se reemplaza el coeficiente de -35.8 por +3.82. Buques de dos hélices

DG

Lpp 0.727

197Cb

41TRIM

4.65B

Lpp

Lpp

188

218APala Lpp H

N 1

25.66ABulbo Lpp H

Diámetro táctico o de evolución (tactical diameter)

IMO requiere que el diámetro táctico no exceda de 5 veces la eslora entre perpendiculares Buques de una hélice:

DT

Lpp

0.91DG

0.234V

Lpp

Lpp

0.675

Buques de dos hélices

DT

Lpp

DG Lpp

0.14

Avance (advance)

IMO requiere que el avance no exceda de 4.5 veces la eslora entre perpendiculares Buques de una hélice: 0.519DT ADVC Lpp Lpp

1.33


ADVC

Lpp

0.514DT Lpp

1.10

Caída o Transferencia (transfer) Buques de una hélice: 0.497DT TRANS Lpp 0.065 Lpp

- 109 -

1.77V Lpp



TRANS

Lpp

0.531DT Lpp

0.357

En general IMO requiere que, tras haber metido el timón 10°, el buque no recorra más de 2.5 veces su eslora cuando su rumbo haya cambiado 10°. Escriba un programa en FORTRAN, que permita obtener los parámetros de maniobrabilidad del buque. El programa debe reunir obligatoriamente los siguientes aspectos: 1. Usar el formato de codificación de las Normas Europeas para Fortran 90 2. Debe usarse al menos un tipo de subprograma para realizar los cálculos 3. Debe usar DLL para los subprogramas. 4. Los resultados y los parámetros de ingreso deben almacenarse en un archivo 5. La matriz de resultados debe imprimirse por pantalla como una tabla que permita verificar la información de manera fácil, se considera la dimensión X como los parámetros de maniobrabilidad y la dimensión Y los ángulos de caña. 12. En cierto tipo de material metálico de prueba, se sabe que la resistencia a la tracción sobre un metal está relacionada funcionalmente con la resistencia al corte. La tabla siguiente es un conjunto de datos experimentales codificados sobre las dos variables. Resistencia a la tracción

Resistencia al corte

26.8 25.4 28.9 23.6 27.7 23.9 24.7 28.1 26.9 27.4 22.6 25.6

26.5 27.3 24.2 27.1 23.6 25.9 26.3 22.5 21.7 21.4 25.8 24.9

1. Escribir un programa en FORTRAN 90, para estimar la línea de regresión simple de estos datos, usando el método de los mínimos cuadrados. 2. El programa debe permitir obtener cualquier valor intermedio usando la fórmula de la regresión, este valor se ingresa por pantalla. 3. En un archivo de datos debe leerse la información y en un archivo de resultados escribir los cálculos intermedios y resultados finales. El programa termina cuando el usuario decide no realizar más cálculos. 4. Deben usarse subprogramas en la creación del programa. 5. Debe codificarse observando las normas Europeas para escribir y documentar un código fuente. 6. Debe enviarse por correo electrónico solo los archivos *.F90. - 110 -


Relaciones útiles: X Ecuación de la línea de regresión simple: Y X Coeficientes a y b usando método de mínimos cuadrados n

n

n

x i yi

n

xi

i 1

yi

i 1 n

i 1 2

n

n

x

2 i

xi

i 1 n

i 1 n

yi

xi

i 1

i 1

n

13. Escribir un programa en FORTRAN, que calcule el momento de inercia I zz y el máximo momento flexionante de un perfil estructural L,T,I,H y C, el programa debe tener las siguientes características: a. Mensajes para continuar con otra figura hasta que el usuario desee salir b. Mensajes de advertencia y error cuando se ingresa un dato erróneo c. Todas las subrutinas deben realizarse usando DLL d. Debe mostrar una tabla en pantalla con los valores intermedios y el resultado e. Debe guardar en un archivo los valores intermedios y el resultado f. Debe haber opciones para vigas de varios materiales. Fórmulas útiles yA

y

A

I zz

Io

(Distancia del eje neutro respecto la línea base)

Ad

2

Io

bh 3 12

(Donde „b‟ es la base, „h‟ la altura)

Mc máx

I zz

Valores de esfuerzos máximos: MATERIAL Aluminio de aleación Hierro colado gris Magnesio de aleación Acero al níquel y carbono

- 111 -

ESFUERZO A TENSION (Kg/cm2) 4200 2100 2800 14000


14. El sistema EAN es un conjunto de normas que homogeneizan la numeración de todos los productos de gran consumo y tiene tres características principales: 1. Puede ser utilizado por fabricantes y distribuidores en el intercambio y en la mejora de las informaciones. 2. Identifica la unidad del producto de forma biunívoca (un código, un producto). 3. No es explicativo o significativo: toda la información está contenida en el registro de la base de datos al que se accede con el código. La representación del código EAN se efectúa mediante la visualización de 13 dígitos que identifican el producto: 1. Los dos primeros dígitos/caracteres corresponden al país. Para el caso que nos ocupa decir que el código numérico asociado a nuestro país es el 84 2. Los cinco caracteres siguientes identifican la empresa fabricante del artículo. 3. Los cinco siguientes caracteres será un número que identificará cada uno de los productos que la empresa produzca. La empresa podrá poner su propia numeración de productos. 4. Por último, el dígito 13, es un dígito de control y se calcula mediante un sencillo algoritmo matemático. Este algoritmo elimina cualquier posibilidad de error en la lectura. Características del símbolo

La representación del código se ha de efectuar mediante la simbolización de los dígitos de forma que puedan leerse y traducirse directamente del decodificador, que a través de la interface se comunica con el computador. El símbolo estándar está formado por una serie de barras paralelas, de diferente grosor. En la parte inferior del símbolo se representa el mismo código en cifras para que sea legible. El símbolo es de tamaño variable. Su tamaño estándar es de 37,29*26,26 mm., pero este tamaño puede variar en función de las medidas del envase o de la etiqueta. En estos casos la variación está entre el 0,8 y 2 veces el tamaño del estándar. El dígito de control

La utilización del dígito de control tiene por objetivo el establecer un mecanismo que evite errores en el tratamiento automático de los códigos EAN. El dígito de control es la última cifra del código EAN de un producto. Su cálculo se realiza automáticamente en función del valor de las posiciones que le preceden en el código, mediante un sencillo algoritmo. Algoritmo para calcular el dígito de control

Los pasos a seguir a la hora de calcular el dígito de control (para este tipo de simbolización EAN-13) son 1. Multiplicamos por 1 las posiciones impares y por 3 las posiciones pares del código empezando de derecha a izquierda. 2. Tomemos como ejemplo el siguiente código: 841234567890 sabiendo que el 84 corresponde con el país, los siguientes 5 dígitos con la empresa y los últimos 5 dígitos con el artículo/producto. Sumamos los valores resultantes. 8+12+1+6+3+12+5+18+7+24+9+0 = 105

- 112 -


3. Restamos de la decena superior el valor de la suma de los valores resultantes. El resultado de esta operación es el valor del código de control (primera posición del código de barras desde la derecha). 110 - 105 = 5 ==> valor del código de control. 4. Otra posibilidad es dividir la suma resultante (105) para 10 siendo el residuo de ésta división el valor del dígito de control: 105 / 10 = 10 Cociente y 5 de residuo. El resultado final del código es: 84 12345 67890 5 (EAN-13). Representación gráfica del código

Cada carácter numérico debe tener obligatoriamente dos barras y dos espacios. Para conformar un carácter es necesaria la unión de 7 módulos. Un módulo es la unidad mínima o básica del código. Visualmente, un carácter podría representarse como lo indica la figura 1.

Figura No. 1.- Carácter del código Este carácter se compone de 7 módulos, 2 barras y 2 espacios de diferente grosor (casualmente el grosor de los espacios es el mismo). Por norma estándar la anchura de un módulo es de 0,33 mm. De t al forma que si un carácter dispone de 7 módulos la anchura total de un carácter será: 0,33 mm X 7 = 2,31 mm. Los juegos de símbolos

Para poder identificar simbólicamente los caracteres numéricos usando los siete módulos se definen 3 juegos de caracteres llamados A, B y C. Cada uno de ellos tiene 10 valores (del 0 al 9), que combinan dos barras y dos espacios para los siete módulos que componen cada carácter numérico. Los juegos de caracteres se simbolizan de cómo lo indica la figura 2. El juego A tiene un número impar de módulos oscuros. Por esta razón se dice que el juego de simbolización A tiene paridad impar. Los juegos B y C son juegos de simbolización con paridad par (el número de módulos oscuros es par). Los caracteres auxiliares

Los caracteres auxiliares se componen de la siguiente forma: Separador lateral

3 módulos

Separador Central

5 módulos

- 113 -


Como su nombre indica, el separador central está en el centro del símbolo, separando los doce caracteres simbolizados, en dos grupos de seis. Los módulos del principio y del final son claros, con lo que de ésta forma, los caracteres situados a la izquierda y a la derecha de este separador central, cambian la alineación. Los separadores laterales indican principio y fin de las barras del símbolo. El separador lateral izquierdo se representará con los 3 módulos laterales más 11 módulos claros a la izquierda El separador lateral derecho se representará con los tres módulos laterales más 7 módulos claros a la derecha. Estos módulos claros deben de existir de tal forma que la omisión de estos, no garantizaría la correcta lectura. El formato del símbolo EAN-13

Volviendo a nuestro código de ejemplo (84 12345 67890 5) veamos qué formato y qué simbolización tendría cada uno de los caracteres dependiendo de la posición de estos. El formato, de izquierda izquierda a derecha y de mayor a menor posición, posición, es el siguiente: siguiente: Según nuestro código el carácter décimo tercero es el 8, como comentábamos antes, el prefijo del país es el 84. Este carácter no será representado mediante códigos de barras barras quedando quedando a la izquierda del código de barras. barras. Según la tabla 1 utilizaremos la simbolización A o B para las posiciones del 7 al 12 según convenga y del 1 al 6 utilizaremos la tabla C. La parte del código que es representada mediante barras tiene el siguiente formato: 1. El separador lateral izquierdo incluyendo los 11 módulos claros a la izquierda. 2. 6 caracteres numéricos, simbolizados por medio de los juegos A y B, que corresponde a los caracteres de la izquierda del símbolo. 3. El separador central 4. 6 caracteres numéricos, simbolizados por medio del juego de caracteres C, correspondientes a los caracteres de la derecha del símbolo. 5. El separador lateral derecho incluyendo los 7 módulos claros por la derecha.

- 114 -


Figura No. 2.- Juego de caracteres 13 0 1 2 3 4 5 6 7 8 9

12

11

10

9

8

7

A A A A A A A A A A

A A A A B B B B B B

A B B B A B B A A B

A A B B A A B B B A

A B A B B A A A B B

A B B A B B A B A A

6

5

4

3

2

1

C

Tabla No. 1.- Juego de caracteres de simbolización simbolización EAN-13 1. Escribir un programa en FORTRAN 90, para codificar un número con el sistema de simbolización EAN-13, usando la norma Europea de codificación y documentación del lenguaje. 2. El programa permite el ingreso de información desde pantalla y almacena el resultado en un archivo de resultados, haciendo constar el número ingresado y el código de barras.

- 115 -


15. Escriba un programa en Fortran que permita escoger una figura para graficar entre la siguientes opciones: rectángulo, polígono de N lados, elipse o círculo, el usuario debe seleccionar el tipo e ingresar la información referente a dimensiones o número de lados, el gráfico se lo hace en pantalla y en un archivo. 16. Haga un programa en Fortran para dibujar un boceto a mano alzada sobre la ventana.

- 116 -

Fortran 90 Para Principiantes

Recommend Documents