LENGUAJES IMPERATIVOS

Generalidades e Instrucciones

Nombre:

Armao, Katiana

Colmenarez, Sol

Lima, Sandra

Orellana, Rebeca

Pérez, Erika

Cátedra: Lenguajes de Programación.

Profesor: Luis Mathinson

Barquisimeto, Mayo 2005

CONTENIDO DE LA EXPOSICIÓN

1. Características Principales del Paradigma Imperativo

2. Generalidades del Lenguaje Imperativo

a. Cuerpo de un programa Imperativo.

b. Librerías de los lenguajes.

c. Declaración de Constantes y Tipos.

d. Declaración de Variables.

e. Declaración de Métodos.

Pase de argumentos por valor y por referencia

3. Instrucciones en Lenguaje Imperativo

a. Entrada y/o Salida.

Características importantes.

Ejemplo de Entrada y/o Salida

b. La Asignación.

Características importantes.

Semántica de la asignación.

Ejemplo con asignaciones.

c. Bifurcación

Características.

Ejemplo con Bifurcaciones.

Ciclos Repetitivos.

d. Decisión o Condicional.

Características.

Ejemplo con Condicionales.

4. Estados (de la ejecución de un programa).

5. Verificación de correctitud de los programas.

Correctitud doble.

Correctitud de Intercambiar.

6. Ventajas y Desventajas en el uso de Lenguajes Imperativos.

Introducción

Los estudiantes y profesionales de la computación deben estar capacitados para estudiar los fundamentos de su disciplina.

El núcleo central de las Ciencias de la Computación está constituido en buena parte por los estilos de programación y los paradigmas que estos arrojan.

Hoy en día, existen diversos paradigmas de programación, cada uno de ellos con lenguajes de programación específicos.

Entre estos paradigmas están los orientados a objeto, los funcionales, los declarativos,… y los imperativos.

Este trabajo tendrá un enfoque acerca de los lenguajes del paradigma imperativo, cuyo origen está ligado a la propia arquitectura de Von Neuman. La programación en el paradigma imperativo consiste en determinar qué datos son requeridos para el cálculo, asociar a esos datos unas direcciones de memoria, y efectuar paso a paso una secuencia de transformaciones en los datos almacenados, de forma que el estado final represente el resultado correcto.

En los lenguajes imperativos, las sentencias deben ser simples y el manejo de las mismas estrictamente secuencial.

También se explicará detalladamente las características principales de este tipo de lenguajes como los es: la declaración de variables, almacenamiento de las variables y sentencias simples que efectúan bifurcaciones condicionales e incondicionales (ciclos, procedimientos, funciones).

Los objetivos centrales que se persiguen con este trabajo, es resaltar que el origen de todo estos paradigmas de la programación se originó básicamente a raíz del paradigma imperativo y que aun, muchos lenguajes como PASCAL, FORTRAN,C, entre otros, Siguen utilizándolo; así como también, mostrar el estilo de programación de dichos lenguajes.

Para lograr estos objetivos, se tomará como ejemplo los lenguajes de programación Turbo Pascal y Fortran 90 para aprender a programar en paradigma imperativo. Con estos dos lenguajes, se resaltaran las características más importantes del paradigma imperativo, comparando declaración de variables y constantes del programa, tipos, declaración de funciones y procedimientos, librerías requeridas (unidades e invocación), paso de argumentos, asignación, bifurcación, decisión o condicional, y uso del Case.

Además se explicará que hoy en día existen algoritmos de correctitud, aplicados a diferentes procedimientos, cuyas sentencias cambian de estados durante su ejecución. Estos algoritmos definen que el procedimiento es correcto si ocurre que cuando los datos de entrada validan la precondición P, entonces las variables en el estado final del programa deben validar la postcondicion Q.

1. Características principales del Paradigma Imperativo.La programación en el paradigma imperativo consiste en determinar qué datos son

requeridos para el cálculo, asociar a esos datos unas direcciones de memoria, y efectuar paso a paso una secuencia de transformaciones en los datos almacenados, de forma que el estado final represente el resultado correcto.

1. Ejecuta las instrucciones de forma secuencial. Describe etapa a etapa el modo de construir la solución.

2. Referencia Variables a direcciones de memoria (Declaración de variables). Las variables están estrechamente relacionadas con direcciones de la memoria del ordenador.

3. Realiza Operaciones de Asignación de valores a Variables (Almacenamiento). El contenido de estas direcciones se actualiza repetidamente, pues las variables reciben múltiples asignaciones.

4. Soporta sentencias simples que efectúan bifurcaciones condicionales e incondicionales (ciclos, procedimientos, funciones). Incluso cuando se añade una forma simple de abstracción procedimental, el modelo permanece básicamente sin cambiar. Los parámetros de los procedimientos son "alias" de las zonas de memoria, por lo que pueden alterar su valor, y no retorna ningún tipo de cálculo (Parámetro por referencia). La memoria también se puede actualizar directamente mediante referencias globales o parámetros por valor.

2. Generalidades del Lenguaje Imperativo.

Los programas escritos en lenguajes imperativos, tienen sólo una semántica operacional, es decir pueden ser entendidos solo por referencia hacia los efectos que producen los estados (real o abstracto) de algunas máquinas. En este tipo de lenguajes, cuyo origen está ligado a la propia arquitectura de Von Neuman, la arquitectura consta de:

.- Memoria Principal: Una secuencia de celdas de memoria, en la cual se pueden guardar en forma codificada tanto datos como instrucciones.

.- Procesador: el cual es capaz de ejecutar de manera secuencial esa serie de operaciones, principalmente aritméticas y booleanas, con una serie de registros de almacenamiento, modificación de registros y acceso a la memoria Principal.

Algoritmos + Estructura de Datos = Programa Imperativo

Se tomará como ejemplo los lenguajes de programación Turbo Pascal y Fortran 90 para aprender a programar en paradigma imperativo.

a. Cuerpo de un programa Imperativo.1. Un nombre de programa.2. Declaración de variables y constantes del programa.3. Declaración de funciones y procedimientos.4. Cuerpo del programa: lista de instrucciones. Aquí se señala de manera secuencial, a

través de una lista de instrucciones, cómo se cambiarán las variables para obtener el resultado deseado:

PASCAL FORTRANCuerpo de un programa

PROGRAM Nombre_del_Programa;{DECLARACIONES}USES Lista_de_Unidades;CONST Lista_de_Constantes=Valor_de_las_Constantes;TYPE Lista_de_Tipos=Definición_de_Tipos;VAR Lista_de_Variables: Tipo_de_Variable;

{IMPLEMENTACION DE PROCEDIMIENTOS}PROCEDURE Nombre_Procedimiento(Lista_Parametros:Tipo_de_Variable);VAR Lista_de_Variables: Tipo_de_Variable;BEGIN {Lista de Sentencias}END;….FUNCTION Nombre_Funcion(Lista_Parametros:Tipo_de_Variable): Tipo_Funcion;VAR Lista_de_Variable:Tipo_de_Variable;BEGIN {Lista de Sentencias} Nombre_Funcion := Expresión;END;

....{CUERPO PRINCIPAL}BEGIN {Lista de Sentencias} Nombre_Procedimiento(Lista_Parametros:Tipo_de_Variable); {Lista de Sentencias} Variable:=Nombre_Funcion(Lista_Parametros:Tipo_de_Variable); {Lista de Sentencias}END.

PROGRAM nombre_programa! Sección de declaraciones de variables

USES Nombre_Modulo

!Declaración de Constantes:Tipo, parameter :: Nombre_Constante_1 = Valor_Constante_1,…, Nombre_Constante_n = Valor_Constante_n

!Declaración de Variables:Tipo :: Variable_1,…, Variable_n

! Sección de Ejecución

! Sentenciascall nombre_subrutina (lista de parámetros) ! Sentenciasnombre_variable = nombre_funcion (lista de parámetros)! SentenciasSTOP

! Sección de Métodos

CONTAINS

SUBROUTINE nombre_ subrutina (lista de parámetros)! Declaraciones! SentenciasRETURNEND SUBROUTINE nombre_ subrutina

Tipo FUNCTION nombre_funcion (lista de parámetros)! Declaraciones! SentenciasRETURNEND FUNCTION nombre_funcion

END PROGRAM nombre_programa

Fortran90 (Formula Translator) es un lenguaje de formato libre: sin posiciones ni columnas reservadas y permite la utilización de módulos. Es un lenguaje de programación desarrollado con el fin de crear un lenguaje simple en el que se pudiesen implementar fácilmente fórmulas matemáticas siguiendo el estilo de los propios matemáticos.

b. Librerías de los Lenguajes:Un módulo es un archivo que contiene definiciones que se acceden desde otros

programas. Estas definiciones pueden ser declaraciones de tipos, de métodos, etc. Un módulo puede ser usado para:

Reemplazar bloque comunes de código. Definir nuevos tipos de datos en bases a los existentes. Encapsular procedimientos y definiciones de datos. Compilación independiente.

Un módulo no puede tener instrucciones ejecutables solo declaraciones de datos, bloques de interfaz y definiciones de procedimientos. Tampoco su nombre puede coincidir con el nombre de otra unidad definida por el sistema. Además, pueden ser elaborados por el sistema o definidos por el usuario.

PASCALDeclarando unidades: Invocando unidades:Unit Nombre _ unidad;

INTERFACE

{Parte Pública}

USES…...

TYPE….

{cabecera de métodos públicos}

IMPLEMENTATION

{declaración de métodos públicos y/o privados}

End.

Si se desea utilizar un módulo (unidad) ya compilado en su programa, tendrá que declararlo detrás de la palabra reservada USES.

USES es opcional, pero si existe debe ser la primera sentencia a continuación de la cabecera del programa PROGRAM.

Módulos definidos por el Sistema en Pascal:crt, graphic,print, etc

FORTRANDeclarando unidades: Invocando unidades:MODULE Nombre _ unidad

! Declaraciones de las variables y llamadas a ! otras unidades. No contiene cabecera de los ! métodos.

CONTAINS

!Parte de declaraciones de procedimientos y !Funciones

END MODULE Nombre _ unidad

Luego del nombre del programa:

Use Nombre _ modulo En FORTRAN los métodos pueden ser accedidos a través de su nombre o a través de un alias declarado en la sentencia USE del programa principal:

USE Nombre_modulo, Nombre_alias=>Nombre_metodo

Esta sentencia accede al método llamado Nombre_metodo en la unidad Nombre_ modulo por el nombre Nombre_alias.

Si dos módulos tienen rutinas con nombre iguales un programa puede usar ambas simultáneamente utilizando la sentencia anterior.Módulos definidos por el Sistema en Fortran90:Ninguno.

Ejemplos:

Fortran Pascal

Modulo: Mod_Utilidades.f90 Modulo: MODULE Mod_Utilidades CONTAINS

SUBROUTINE Leer_String(Cadena)Character(len =20), intent(out) ::

Cadena

Read (*,*) Cadena END SUBROUTINE Leer_String

END MODULE Mod_Utilidades

Unit Mod_Utilidades;

Interface

Type

Str=String[20];

Procedure Leer_String(var Cadena:Str); Function Doble(a: integer): integer;

Implementation

Procedure Leer_String(var Cadena:Str);

Begin Readln(Cadena); End;

Function Doble(a: integer): integer;

Begin Doble := a*2; End;

end.Programa: Uso_Modulos.f90 Programa: PROGRAM Uso_Modulos!Nos explica la Estructura de un Programa y el !Uso de Modulos!USE Nombre_modulo, !Nombre_alias=>Nombre_metodoUse Mod_Utilidades, Datos_Entrada => Leer_String

character(len=20) ::Nombrecharacter(len=20) ::Apellido

print *, "Introduzca el Primer Nombre" CALL Datos_Entrada(Nombre) print *, "Introduzca el Primer Apellido" CALL Datos_Entrada(Apellido) WRITE (*,*) "Su nombre completo es: ",Nombre,Apellido STOP

END PROGRAM Uso_Modulos

PROGRAM Uso_Modulo;{Programa que nos explica la estrutura de un Programa y el Modulo} Uses crt, Mod_Utilidades;

Var Nombre:Str; Apellido:Str; Edad:integer;

Begin clrscr; Writeln('Introduzca el Nombre'); Leer_String (Nombre); Writeln('Introduzca el Apellido'); Leer_String (Apellido); Writeln('Introduzca la edad'); Readln(Edad); Writeln('Su nombre Completo es:',Nombre,' ',Apellido); Writeln('El Doble de su edad es:', Doble(Edad)); Readln; End.

c. Declaración de Constantes y Tipos

Las constantes son valores que no cambia durante la ejecución de un programa. FORTRAN acepta literales de cualquier tipo (“Barquisimeto”, 123.56, +44, etc) y solo acepta constantes simbólicas (constantes con nombre) luego de la declaración de las variables introduciendo la palabra PARAMETER a continuación del tipo, separados por una coma. En las constantes de tipo CHARACTER se puede definir la longitud implícitamente por medio del carácter (*). (Ver Ejemplo). Las constantes simbólicas se emplean luego en las expresiones aritméticas exactamente igual que las variables.

En PASCAL hay una sección para declarar dichas constantes: CONST. Allí se pueden declarar enteros, reales, cadenas, entre otros.

Por otra parte, los tipos de datos se clasifican en Primitivos y Derivados. Los tipos de datos primitivos son predefinidos por los lenguajes mientras los tipos de datos derivados son definidos por el usuario.

Los Tipos de datos primitivos en FORTRAN son: byte, integer, real, complex, character, logical, pointer, etc., mientras que en Pascal son: byte, integer, real, boolean, etc.

Tipos Derivados: Se pueden construir tipos derivados de tipos primitivos o de tipos derivados definidos previamente; a estos tipos se les asigna un nombre para posteriormente usarlos en la declaración de variables y/o referencia a parámetros. En FORTRAN no existe una sección de tipos (TYPE) como en pascal. Los tipos derivados de Fortran90 juegan un papel similar al de las struct de C o los record de Pascal: permiten definir tipos estructurados. La sentencia TYPE… END TYPE, define un tipo derivado para declarar arreglos y registros. Los Tipos derivados en PASCAL: Son arreglos, registros, objetos, conjuntos, entre otros, que son definidos con alias en la sección de TYPE.

Ejemplos (Ver Anexos):

PASCAL FORTRANDeclaración de constantes y tipos

{Declaraciciones tipos}

Type NOMBRE_EMPLEADO=Record Nombre:String; Apellido:String; end;

DIRECCION_EMPLEADO = Record Urbanizacion:String; Numero_calle:Integer; Numero_apto:Integer; Ciudad:String; end;

Datos_Empleados=Record Nombre_empleado:NOMBRE_EMPLEADO; Direccion_empleado:DIRECCION_EMPLEADO; Telefono:integer;

! Para declarar registrosTYPE Nombre_Empleado CHARACTER(25) :: Nombres CHARACTER(15) :: ApellidosEND TYPE

TYPE Direccion_Empleado CHARACTER(20) :: Urbanizacion INTEGER(2) :: Numero_Calle INTEGER(2) :: Numero_Apto CHARACTER(20) :: CiudadEND TYPE

! Para declarar un Registro de RegistrosTYPE Datos_Empleado TYPE (Nombre_Empleado) :: Nombre_Completo TYPE (Direccion_Empleado) :: Direccion_Completa INTEGER(4) :: Telefono INTEGER(2) :: Cod_Seg_Social(3) INTEGER(2) :: Nro_DependenciaEND TYPE

!Para declarar constantesINTEGER, PARAMETER :: nitMax=1000

Cod_seg_social:string; Nro_dependencia:integer; end;Arr_Empleado= Array[1..3] of Nombre_Empleado;

{Declaraciòn de constantes}

Const Nit_max=1000; Saludos='Hola'; Despedida='Adios';

CHARACTER (*), PARAMETER :: saludo="Hola", despedida="Adiós"

d. Declaración de Variables.Una variable es un nombre que en cada paso de la ejecución de un programa hace

referencia a un valor. Cada variable se asocia con una dirección de memoria y toma el valor de los símbolos guardados en esa posición.

En la sección de declaración deben aparecer cada una de las variables que van a ser utilizadas, asociándolas con un cierto tipo. Es decir, a cada variable se la debe asociar exclusivamente con un tipo disponible ya sea derivado o primitivo.

Toda variable que se utiliza en un programa debe estar declarada una sola vez. Cada variable tiene un identificador o nombre único.

Cada línea de declaración tiene la forma:

<tipo> <nombre de variable, ..,nombre de variable>

En el programa

Dirección de memoria

Contenidos de la memoria en cierto paso de la ejecución de un programa.

X E900031 43Y A367054 Algoritmo

En fortran: las variables se pueden declarar de forma definida, indefinida y redefinida. Una variable es definida cuando se le asigna un valor; es indefinida cuando su valor es impredecible y redefinida cuando cambia de valor. En Fortran no existe una sección de declaración de variables como VAR en pascal.En pascal: Las variables son declaradas de forma indefinida y con operaciones de asignación se le asigna un valor.

PASCAL FORTRANDeclaración de variables

Var S : Integer;

{Declaraciòn de variables de tipo arreglo} Empleado_A,Empleado_B, Empleado_C:NOMBRE_EMPLEADO;

REAL :: T=10.5 !Variable DefinidaINTEGER :: S !Variable Indefinida

! Para declarar un arreglo de registroTYPE (Nombre_Empleado):: Empleados_A(3), Empleados_B(3)TYPE (Nombre_Empleado), DIMENSION(20) :: Empleados_C

!...En el Cuerpo del Programa:S=10 !Para redefinir una Variable

e. Declaración de Métodos (Funciones, Procedimientos)La principal diferencia entre Funciones y Procedimientos es que las funciones tienen un

valor de retorno y pueden por tanto ser utilizadas en expresiones aritméticas o de otro tipo. Por el contrario, los procedimientos no devuelven ningún valor y todos sus resultados los transmiten a través de modificaciones de sus parámetros.

Estructura de las Funciones:En Fortran tienen la siguiente forma:

[tipo_retorno] FUNCTION nombre_funcion(lista_de_parametros)

donde tipo_retorno es un identificador de tipo opcional (REAL, INTEGER, …) nombre_funcion es un identificador válido de Fortran, y lista_de_parametros es una lista de variables que son utilizadas para pasar información a la función.

Las sentencias ejecutables son distintas sentencias de Fortran que realizarán diversas operaciones, pero que siempre deberán calcular el valor de retorno antes de devolver el control. Esto se hace asignando valor a una variable cuyo nombre y tipo es el de la función.

Para Pascal:FUNCTION nombre_funcion(lista_de_parametros) : tipo_retorno;

Estructura de los Procedimientos:En Fortran el nombre de los procedimientos se definen utilizando la palabra reservada SOBRUTINE:SUBROUTINE nombre_de_subrutina(lista_de_parametros_formales)

En Pascal se maneja la palabra reservada PROCEDURE:PROCEDURE Nombre_Procedimiento(Lista_Parametros:Tipo_de_Variable);

PASCALDeclarando Funciones y

Procedimientos:Invocando Funciones y Procedimientos:

FUNCTION Nombre_Funcion (Lista_Parametros:Tipo_de_Variable): Tipo_Funcion;VAR Lista_de_Variable:Tipo_de_Variable;BEGIN {Lista de Sentencias} Nombre_Funcion := Expresión;END;

PROCEDURE Nombre_Procedimiento (Lista_Parametros:Tipo_de_Variable);VAR Lista_de_Variables: Tipo_de_Variable;BEGIN {Lista de Sentencias}END;

…VAR X:Tipo_Funcion;….BEGIN…X:=Nombre_Funcion(Lista_Parametros);Nombre_Procedimiento(Lista_Parametros)…END

FORTRANDeclarando Funciones y Subrutinas: Invocando Funciones y Subrutinas:[tipo_retorno] nombre_funcion (lista de parámetros)! Declaraciones! SentenciasReturn !Opcional: Para devolver el control al programa sin !llegar al end functionend function nombre_funcion

subroutine nombre_ subrutina (lista de parámetros formales)! Declaraciones! Sentenciasreturnend subroutine nombre_ subrutina

La forma de llamar a la función en el programa principal es por medio del nombre seguido de los parámetros actuales entre paréntesis, en una expresión que sea compatible con el tipo del valor de retorno de la función.Las subrutinas se llaman siempre a través de una sentencia CALL:…! Sección de Ejecución…! Sentenciascall nombre_subrutina (lista de parámetros) ! Sentenciasnombre_variable = nombre_funcion (lista de parámetros)! Sentencias…STOP

Pase de argumentos por valor y por referencia.

Los argumentos por valor son los que conservan su valor de entrada, al finalizar la ejecución de un procedimiento o función. En cambio los argumentos por referencia son los que pueden sufrir cambios en su valor dentro del procedimiento o función en cuestión. Todo lo que el procedimiento haga con la variable “X” afectará directamente a la variable de la invocación.

En PASCAL en la Cabecera del método se define si un argumento es por valor o por referencia usando la sentencia VAR.

En FORTRAN90 se usa el atributo INTENT(), para declarar si un argumento es de entrada o valor (IN), de Salida(OUT) o de Entrada/Salida (IN OUT).

Ejemplos (Ver Anexos):

PASCAL FORTRANPase de argumentos por valor y por referencia

Procedure Leer_String(var Cadena:Str);

Begin Readln(Cadena); End;

Function Doble(a: integer): integer;

Begin Doble := a*2; End;

SUBROUTINE Leer_String(Cadena) Character(len =20), intent(out) :: Cadena

Read (*,*) Cadena END SUBROUTINE Leer_String

Integer FUNCTION Doble(a)Integer, intent(in) :: aDoble=a*2return

END Function Doble

3. Instrucciones en Lenguaje Imperativo

a. Entrada y/o Salida.Fortran permite utilizar sentencias de entrada/salida muy sencillas, en las que casi todas

las opciones son las de defecto aunque existen otras sentencias de entrada/salida más complejas. Las primeras están controladas por la lista de variables a leer o escribir. Las segundas tienen formatos específicos que controlan todos los detalles.

En Pascal las sentencias básicas de lectura/escritura son read/readln y write/writeln.

Ejemplos de Entrada y/o Salida (Ver Anexos):

PASCAL FORTRANEntrada y/o Salida

WRITE imprime variables sin hacer saltos de Línea, por consola o por Impresora. WRITELN es similar pero si hace saltos de Línea.

Write(‘Introduzca el Nombre’);Writeln’Introduzca el apellido’);Writeln('Su nombre Completo es:',Nombre,' ' , Apellido);

READ lee variables sin hacer saltos de Linea. READLN lee variables haciendo saltos de Linea.Read(Nombre);Readln(Apellido);Readln(Edad);

PRINT permite imprimir variables y constantes en la salida estándar (por ejemplo, una ventana MS-DOS)PRINT *, lista_de_variables_separadas_por_comas

print *, "Introduzca el Primer Nombre:"Print *, "El doble de su edad es: ",Doble(edad)PRINT * !Imprime una linea en blanco

WRITE es similar a PRINT, con la posibilidad adicional de elegir otras unidadesde salida tales como impresoras y ficheros.WRITE (*, *) lista_de_variables_a_imprimir

Write (*,*) "Introduzca el Primer Apellido:"WRITE (*,*) "Su nombre completo es: ",Nombre,ApellidoWRITE (*, *) ! imprime una línea en blanco

READ hace que se adquieran ciertos valores (normalmente desde teclado) desde una omás líneas de entrada y que se asignen a la lista de variables de la sentencia

READ (*,*) lista_de_variables_separadas_por_comas

Read *, edadRead (*,*) edadEl asterisco (*) indica que las variables deben adaptarse a un formato adecuado.

b. La Asignación.

Es la pieza fundamental para construir programas imperativos y es la única instrucción que permite modificar el valor de una variable. La asignación tiene esta sintaxis:

<nombre de variable> = <expresión que denota un valor> !FORTRAN

<nombre de variable> := <expresión que denota un valor> {PASCAL}

Características importantes:

El nombre de la variable debe ser uno de los declarados en el programa.

La expresión que denota un valor puede ser, o bien una constante, o bien otra variable, o bien el resultado de una función.

El valor asignado a la variable debe ser del mismo tipo, para que la asignación no de error de tipo.

Es Asimétrica: Es así, pues a la izquierda del operador de asignación tiene el nombre de la variable, y a la derecha tiene la expresión que denota un valor y para remarcar esta característica hay lenguajes imperativos que emplean el símbolo “:=” en vez del símbolo “=”. Lo que se busca es provocar que la parte izquierda tome el valor de la expresión de la derecha. Realmente, la asignación provoca que en las posiciones de memoria correspondientes a la variable de la izquierda se escriba la expresión de la derecha. Por lo tanto, el valor de la expresión de la derecha persiste luego de ejecutarse la asignación.

Semántica de la Asignación:

Formalmente, la instrucción de asignación transforma un estado, modificando exclusivamente el valor de una variable, dejando a las demás variables, del lado derecho de la asignación, intactas. La transformación e estados se explicará más adelante.

Ejemplo con asignaciones:

FORTRANprogram Asignaciones !Tipo PrimitivoReal :: Nota_Total Logical :: a,bInteger :: notaAux(3)

!Tipo DerivadoTYPE alumno CHARACTER (len=12) :: nombre Integer :: nota(3)END TYPE alumno !Un registro:TYPE (alumno) Un_Alumno,Otro_Alumno

!Cuerpo Principal:Write(*,*)"Asignacion de una variable de un tipo derivado:" !en el orden en que se definieronnotaAux=(/18,16,13/) Un_Alumno=alumno("Sandra",notaAux)Write (*,*) Un_Alumno.nombre, Un_Alumno.nota

Write (*,*) "Asignacion de Variables del mismo tipo:"Otro_Alumno=Un_AlumnoWrite(*,*) Otro_Alumno.nombre, Otro_Alumno.nota

Write (*,*) "Asignacion a un campo de un registro:"Otro_Alumno%nombre="Katiana"Write(*,*) Otro_Alumno.nombre, Otro_Alumno.nota

Write (*,*) "Asignacion a una celda de un vector: "notaAux(3)= ((notaAux(1)+notaAux(2))/2)WRITE (*,*) notaAux

Write (*,*) "Asignacion de una variable primitiva: " Nota_Total=(notaAux(1)+notaAux(2)+notaAux(3))write (*,*) Nota_Total

Write (*,*) "Asignacion de Variables Logicas: "a = .TRUE.b = a .AND. 3 .LT. 5/2write (*,*) "a: ",a," b: ",b

END program Asignaciones

c. Bifurcación

Las Bifurcaciones permiten ejecutar o no una parte del código, dependiendo de que cumpla una cierta condición, o bien permiten ejecutar repetidamente un conjunto de sentencias (bucles). El uso de GOTO no es aconsejable ya que destruye el modelo de la programación estructurada, además en los actuales lenguajes de programación, se cuenta con las estructuras de datos que hacen casi innecesario su uso.

Ejemplos con Bifurcaciones:

PASCAL FORTRANBifurcaciones

PROGRAM Uso_del_GOTO;LABELEtiqueta; {pueden ser Numéricas o Alfanuméricas}BEGINWriteLn('Esta linea si se escribirá');GOTO Etiqueta;WriteLn('Esta linea no se escribirá');

Etiqueta:WriteLn('Se efectuó el brinco');END.

Ejemplo: Program Bifurcacion;

Uses crt;LABEL 10;LABEL 100;

Var n: integer; Begin clrscr; Write('Solo se permiten etiquetas enteras'); n:=1; 10:if n<100 then begin n:= n*2; Writeln(n); goto 10; end;

Writeln('Termino el IF, ahora vamos a la etiqueta 100');

program Bifurcaciones INTEGER :: n

n = 1 !Solo se permiten Etiquetas Enteras!!!

10 if (n .lt. 100) then !Comienza la Etiqueta 10 n = 2*n write (*,*) n goto 10 !Salto a la Etiqueta 10 endif

WRITE (*,*) "Termino el IF!!! Vamos a la Etiqueta 100"

GOTO 100 !Salto a la Etiqueta 100 WRITE (*,*) "Esto no se muestra" 100 WRITE (*,*) "Despues de la

Etiqueta 100: **FIN DEL PROGRAMA**" STOP

END program Bifurcaciones

readln; goto 100;

100: Writeln('DespuŠs de la etiqueta 100, FIN DEL PROGRAMA'); READLN; end.

{Ejemplo del uso de GOTO}

program uso_del_goto;usescrt;

LABEL 10;

Begin clrscr; Write('Esta linea si se escribira');

Goto 10; Write('Esta linea no se escribira');

10: Write('Se efectuo el brinco') ; readln;end.

Ciclos Repetitivos (Ver Anexos):

PASCAL FORTRANCiclo controlado por contador

FOR Variable_Control=Valor_Inicial TO Valor_Final DOBEGINSentenciasEND

FOR Variable_Control= Valor_Final DOWNTO Valor_Inicial DOBEGINSentenciasEND

DO variable_de_control = valor_inicial, valor_final, incrementoSentenciasEND DO

la variable_de_control toma el valor_inicialy se compara con valor_final. Las Sentencias se ejecutan si dicha variable_de_control es menor oigual que valor_final si incremento es positivo, o si variable_de_control es mayor o igual que valor_final si incremento es negativo.

PASCAL FORTRAN

Ciclo controlado `por expresión lógicaWHILE Condicion DOBEGINSentenciasEND

El WHILE se repite mientras la condición sea verdadera.

REPEATSentenciasUNTIL Condición

El REPEAT se ejecuta mientras la condición es falsa.

El While y el Repeat se pueden implementar para trabajar con Ciclos controlados por Contador.

{While y Repeat}

DOSentencias1IF (expresión_lógica) EXITSentencias2END DO

La ejecución del bucle se termina cuando expresión_lógica se hace .TRUE.

Estos ciclos pueden ser simulados usando las sentencias if y goto:etiq if (expr lógica) then sentencias goto etiq endifEjemplos: integer n n = 1 10 if (n .lt. 100) then n = 2*n write (*,*) n goto 10 endif

Ciclo Until:etiq sentencias if (expr lógica) goto etiq

d. Decisión o Condicional

Fortran90 posee dos sentencias que permiten construir bloques de decisión: IF y CASE. Todas ellas pueden ser anidadas y puede dárseles nombres para incrementar la legibilidad de los programas. Pascal a su vez, tiene dos sentencias para construir dichos bloques: IF y CASE.

Ejemplos:

PASCAL FORTRANEstructura del IF

{IF Simple:}IF (expresión lógica) THEN sentencia;{IF Anidado:}IF (expresión lógica) THENBEGIN SentenciasENDELSEBEGIN sentencias : :END;

!IF Simple:if (expresión lógica) sentencia!IF Anidado:if (expresión lógica) then sentenciaselseif (expresión lógica) then sentencias::else sentenciasendif

Ejemplos de IF{IF Simple:} !IF Simple:

if p <= max+1 then p:=p-1;{IF Anidado:}IF k=j THEN fin:= TRUEELSE IF k<j THEN r:=jELSE m:=j+1;

if (p <= (max+1)) p=p-1!IF Anidado:IF (k==j) THEN fin=.true.ELSEIF (k<j) THEN r=jELSE m=j+1ENDIF

Estructura del CASECASE OF (Variable)Valor1: Sentencias;Valor2: Sentencias;...ValorN: Sentencias;

END;

Donde Variable debe ser un valor de tipo Ordinal(Char, Integer o Boolean)

La sentencia CASE equivale en cierta forma a una sentencia IF-ELSE IF compleja. Su forma generales la siguiente:SELECT CASE (selector)CASE (lista_de_valores1)Sentencias1CASE (lista_de_valores2)Sentencias2CASE DEFAULTSentencias3END SELECTselector es una expresión entera, de caracteres o lógica. Cada lista_de_valores esun conjunto de posibles valores para el selector, entre paréntesis y separados por comas. Estos valorespueden ser simples (valor) o representar rangos (valor1:valor2, :valor ó valor:).

Ejemplo con CASE en FORTRAN

PROGRAM pr_case

Character(2) :: dia_nomRead *,dia_nom

SELECT CASE (dia_nom)CASE ("LU","MA","MI","JU")

PRINT *,"Lunes a Jueves: 8AM 9PM"CASE ("VI")

PRINT *, "Viernes: 9AM 8PM"CASE ("SA","DO")

PRINT *,"Sabado y Domingo:Cerrado"CASE DEFAULT

PRINT *,"Codigo de Entrada erroneo" !Cuando se introduce minusculas por ejemploEND SELECT

END PROGRAM pr_case

4. Estados (de la ejecución de un programa)Un lenguaje de programación tiene dos componentes: Su sintaxis, su semántica

a.- Sintaxis: Es la forma de los elementos que componen el lenguaje.

b.- Semántica: La semántica de un lenguaje se define qué modificaciones se producen en los datos cuando se ejecutan las instrucciones.

En la programación imperativa, esto lo indicaremos mediante la noción de transformación de estados.

“Un estado es la unión de ecuaciones que indica cual es el valor para cada variable del programa, en cierto paso de la ejecución del programa.”

El estado inicial: indica los valores de las variables antes de ejecutarse la primera instrucción del programa.

El estado final: es el estado alcanzado luego de que se ejecuta la última instrucción del programa.

Entre el estado inicial y el final la ejecución de un programa pasa por estados intermedios. Entonces, la ejecución de un programa produce una transformación determinística de estados, desde el estado inicial hasta, un estado final: E0, E1, E2.

Transformación de Estados de Doble (FORTRAN)

Integer FUNCTION Doble(a)Integer, intent(in out) :: aa=(a*2)Doble=areturn

END Function Doble

Rotulamos el programa con estados así:

Integer FUNCTION Doble(a)

Integer, intent(in out) :: a

! E0 º { a= A0 y Doble=D0}

a=(a*2)

!E1 º { a = 2*A0 y Doble = D0}

Doble=a

!E2 º { a= 2*A0 ^ Doble = a}

return

END Function Doble

E0 es el estado inicial, donde “a” tiene el valor arbitrario A0.

E2 es el estado final con valor de a = 2*A0 y Doble =2*A0.

Un programa imperativo indica como cambian las variables (hasta que consigan el valor final buscado) a través de una lista de instrucciones, y al ejecutarse se transforman los contenidos (en las posiciones asociadas con las variables del programa), ejecutándose de forma secuencial cada una de las instrucciones del programa.

Aún cuando una variable de imperativo tome distintos valores durante la ejecución de un programa, una vez que toma un valor final, éste queda fijo.

5. Verificación de correctitud de los programas

Es indiscutible hoy la influencia que tiene en la industria y en casi todos los ámbitos el uso del software. La cantidad de aplicaciones reales y potenciales de la computación ha alcanzado cotas inimaginables apenas veinte años atrás.

A pesar de su uso extensivo, uno de los costos más alto no se da en la producción del software, sino en la corrección de errores que son detectados posteriormente al desarrollo del sistema.

En la actualidad, el método más usado para validar software es el “testing”, que consiste en la simulación sobre casos de prueba representativos. No obstante, este método no garantiza la corrección del software analizado, por ser incompleto en la mayoría de los casos.

Para que las variables reflejen el valor deseado, es necesario aplicar técnicas de verificación y depuración de errores para probar la correctitud del programa.

Para poder verificar programas imperativos, nos encontramos con un obstáculo y es que las variables de imperativo cambia durante la ejecución del programa, y se dice que es correcto si ocurre que cuando los datos de entrada validan la precondición P, entonces las variables en el estado final del programa deben validar la postcondicion Q.

Un programa es correcto respecto de su especificación si y solo si su estado inicial cumple la precondición P entonces su estado final implica la postcondición Q.

Esta implicación es una relación lógica entre formulas de Primer Orden, la relación de fuerza.

Es decir, un programa es correcto respecto de su especificación sii:

si {E_inicial } |= Precondición entonces {E_final } |= Postcondicón.

Correctitud de Doble

P º { a= A0 } Q º { Doble = 2* A0}

END Function Doble

Rotulamos con estados

END Function Doble

Tenemos que:

E_inicial º E0 y E_final º E2 E0|= P(a) porque { a= A0 ^ Doble = D 0} |= a= A0 E2|= Q(Doble) porque { a= 2*A0 ^ Doble = 2*A0} |= Doble = 2* A0

Correctitud de Intercambiar

P º { x= X0 ^ y=Y0 } Q º {y=X0 ^ x=Y0}

Integer FUNCTION Doble(a)Integer, intent(in out) :: aa=(a*2)Doble=areturn

Integer FUNCTION Doble(a)

Integer, intent(in out) :: a

! E0 º { a= A0 y Doble=D0}

a=(a*2)

!E1 º { a = 2*A0 y Doble = D0}

Doble=a

!E2 º { a= 2*A0 ^ Doble = a}

return

SUBROUTINE Intercambiar(x,y)

Integer, intent (in out) :: x,y !Entrada y Salida

Integer :: temporal !Local

temporal=x

x=y

y=temporal

END SUBROUTINE Intercambiar

Rotulamos con estados

SUBROUTINE Intercambiar(x,y)

Integer, intent (in out) :: x,y !Entrada y Salida

Integer :: temporal !Local

E0 º { x= X0 ^ y=Y0 ^ temporal=T0} temporal=x; E1 º { x=X0 ^ y= Y0 ^ temporal=X0} x=y; E2 º { x=Y0 ^ y=Y0 ^ temporal=X0} y=temporal;

E3 º { x=Y0 ^ y=X0 ^ temporal=X0}END SUBROUTINE Intercambiar

Dado que E0= P y E3= Q se concluye que Intercambiar es correctorespecto de (P,Q).

6. Ventajas y Desventajas en el uso de los Lenguajes Imperativos

Esta desventaja para nosotros, reflejada en la dificultad que tenemos al construir programas en un lenguaje imperativo, se vuelve una ventaja en el momento de la generación del código.

VENTAJAS DESVENTAJASEn general, un lenguaje imperativo

ofrece al programador conceptos que se traducen de forma natural al modelo de la

Con esta proximidad aparece, sin embargo, una dependencia entre el algoritmo y la arquitectura, que impide por ejemplo, utilizar

máquina. algoritmos programados para arquitecturas secuenciales en arquitecturas paralelas.

El programa está expresado en términos tan cercanos a la máquina, que el código generado es relativamente parecido al programa original, lo que permite cierta eficiencia en la ejecución.

El programador, al utilizar un lenguaje imperativo, por lo general tiene que traducir la solución abstracta del problema a términos muy primitivos, cercanos a la máquina. La distancia entre el nivel del razonamiento humano y lo expresable por los lenguajes imperativos causa que sus programas sean más "comprensibles" para la máquina que para el hombre.

Estos ejemplos ponen en evidencia que ciertas características de los lenguajes imperativos tales como la asignación pueden traer consigo efectos laterales inesperados que oscurecen la semántica del programa; en consecuencia se hace difícil demostrar que los programas cumplen con los requerimientos especificados y que estén libres de errores.

Ejemplo

Program prueba;

{En este punto es donde empiezan los problemas}

var flag:boolean;

function f (n: integer):integer;

begin

flag:=not flag;

if flag then f:=n;

else f:=2*n;

end;

........

--Programa principal

begin

flag:=true;

......

write(f(1)); {retorna 2}

write(f(1)); {retorna 1}

.......

write(f(1) + f(2)); {retorna 4}

write(f(2) + f(1)); {retorna 5}

En el primer caso la expresión f(1) retorna valores diferentes dependiendo de la secuencia de ejecución y en el segundo no se cumplen propiedades matemáticas simples tales como la conmutatividad.

Estos ejemplos ponen en evidencia que ciertas características de los lenguajes imperativos tales como la asignación pueden traer consigo efectos laterales inesperados que oscurecen la semántica del programa; en consecuencia se hace difícil demostrar que los programas cumplen con los requerimientos especificados y que estén libres de errores.

Este y otros problemas son inherentes al modelo computacional utilizado, por ende una solución factible de ser aplicada puede ser cambiar el modelo computacional. Entre otras alternativas se encuentran el modelo funcional o aplicativo.

Anexo 1. Programa de Constantes y Variables en FORTRAN

program Const_Variab

!DECLARACION DE CONSTANTES Y TIPOS! Para declarar registrosTYPE Nombre_Empleado

CHARACTER(len=25) :: Nombres ! Tipo PrimitivoCHARACTER(len=15) :: Apellidos

END TYPE

TYPE Direccion_EmpleadoCHARACTER(20) :: UrbanizacionINTEGER(2) :: Numero_Calle ! Tipo PrimitivoINTEGER(2) :: Numero_AptoCHARACTER(20) :: Ciudad

END TYPE

! Para declarar un Registro de RegistrosTYPE Datos_Empleado

TYPE (Nombre_Empleado) :: Nombre_Completo ! Tipo DerivadoTYPE (Direccion_Empleado) :: Direccion_Completa ! Tipo DerivadoINTEGER(4) :: TelefonoINTEGER(2) :: Cod_Seg_Social(3)INTEGER(2) :: Nro_Dependencia

END TYPE

!Para declarar constantes INTEGER, PARAMETER :: nitMax=1000 CHARACTER (*), PARAMETER :: saludo="Hola", despedida="Adios"

!DECLARACION DE VARIABLESREAL :: T=10.5 !Variable DefinidaINTEGER :: S !Variable Indefinida! Para declarar un arreglo de registroTYPE (Nombre_Empleado):: Empleados_A(3), Empleados_B(3)TYPE (Nombre_Empleado), DIMENSION(20) :: Empleados_C

!...En el Cuerpo del Programa: S=10 !Para redefinir una Variable

!Se imprimen las constantes y las Variables Primitivas:Write(*,*) "Saludo: ",saludoWrite(*,*) "Variable S: ",SWrite(*,*) "Las variables de tipo derivado se mostraran despues!!!"Write(*,*) "Despedida: ",despedidaRead *STOP

end program Const_Variab

Anexo 2. Programa Selección en FORTRAN

PROGRAM Leng_ImpINTEGER, PARAMETER :: valores_altos=1000INTEGER, PARAMETER :: max=7INTEGER :: A(8) INTEGER :: k

CALL INICIALIZAR_VARIABLES(A,K); CALL Seleccion(A,max,K); CALL IMPRIMIR_RESULTADO(A); Read *STOP

CONTAINS

SUBROUTINE Intercambiar(x,y) Integer, intent (in out) :: x,y !Entrada y Salida

Integer :: temporal !Local temporal=x x=y y=temporal

END SUBROUTINE Intercambiar

SUBROUTINE Partir(m,p) Integer, intent (in) :: m !Entrada

Integer, intent (in out) :: p !Entrada y SalidaInteger :: v,i !Locales

V=A(m) i=M DO

IF (i>p) EXIT DO

i=i+1 IF (A(i)>=v) EXIT

END DO DO

if (p <= (max+1)) p=p-1 IF (A(p)<=v) EXIT

END DO IF (i<p) CALL Intercambiar (A(i),A(p))

END DO A(M)=A(p) A(p)=vEND SUBROUTINE Partir

SUBROUTINE Seleccion(A,n,k) Integer, dimension(n), intent (in out) :: A !Entrada y Salida

Integer, intent (in) :: n !EntradaInteger, intent (out) :: k !SalidaInteger :: m,r,j !Locales Logical :: fin !Locales

fin=.False. m=1 r=n+1 A(n+1)=valores_altos

DO IF (fin) EXIT

j=r call Partir(m,j) IF (k==j) THEN !Las Sentencias deben aparecer en la linea siguiente para los nidos de if

fin=.true. ELSEIF (k<j) THEN

r=j ELSE

m=j+1 ENDIF

END DO END SUBROUTINE Seleccion

SUBROUTINE INICIALIZAR_VARIABLES(A,K) Integer, dimension(Max), intent (in out) :: A !Entrada y Salida

Integer, intent (out) :: k !SalidaInteger :: I !Locales

Write (*,*) "TIPEE LOS SIGUIENTES DATOS PARA LLENAR EL ARREGLO:" DO I = 1,Max

READ *,A(I) END DO Write (*,*) Write (*,*) "INTRODUZCA DESDE DONDE QUIERE ACOMODAR EL ARREGLO" READ *,K END SUBROUTINE INICIALIZAR_VARIABLES

SUBROUTINE IMPRIMIR_RESULTADO (A) Integer, dimension(Max), intent (in) :: A !Entrada Integer :: I !Locales

Write (*,*) Write (*,*) "lOS DATOS OBTENIDOS DESPUES DE APLICAR EL PROCEDIMIENTO SELCCION ES:" Write (*,*) DO I = 1,Max

Write (*,*) "A[",I,"]:",A(I) END DO END SUBROUTINE IMPRIMIR_RESULTADO

END PROGRAM Leng_Imp

Anexo 3. Programa de Constantes y Variables en PASCALProgram Cont_Variab;uses crt;

{Declaraciciones de constante y tipos}

Const Nit_max=1000; Saludos='Hola'; Despedida='Adios';

Type NOMBRE_EMPLEADO=Record Nombre:String; Apellido:String; end; DIRECCION_EMPLEADO = Record Urbanizacion:String; Numero_calle:Integer; Numero_apto:Integer; Ciudad:String; end; Datos_Empleados=Record Nombre_empleado:NOMBRE_EMPLEADO; Direccion_empleado:DIRECCION_EMPLEADO; Telefono:integer; Cod_seg_social:string; Nro_dependencia:integer; end; Arr_Empleados=Array[1..3] of NOMBRE_EMPLEADO;

{Declaracion de Variables}Var S : Integer; {Variable Indefinida}

Empleado_A,Empleado_B, Empleado_C:Arr_Empleados;

{***CUERPO PRINCIPAL***} Begin clrscr; s:=10; {Para redefinir las variables} Writeln('Saludos:', Saludos); Writeln('Las variables de tipo derivado se mostraran despues'); Writeln('Despedida:' ,Despedida); Readln;

End.

Anexo 4. Programa Selección en PASCALPROGRAM Leng_Imp;USES CRT;CONST max=5; valores_altos=1000;

TYPE ELEMENTO=INTEGER; Arreglo_de_Elementos=ARRAY [1..6] OF ELEMENTO;

VAR A:Arreglo_de_Elementos;k:INTEGER;

PROCEDURE Intercambiar(VAR x,y:ELEMENTO);VARtemp:ELEMENTO;BEGIN temp:=x; x:=y; y:=temp;END;

PROCEDURE Partir(m:INTEGER; VAR p:INTEGER);VAR v:ELEMENTO; i:INTEGER;BEGIN V:=A[m]; i:=M; WHILE i<=p DO BEGIN REPEAT i:=i+1; UNTIL A[i]>=v; REPEAT if p <= max+1 then p:=p-1; UNTIL A[p]<=v; IF i<p THEN Intercambiar (A[i],A[p]); END; A[M]:=A[p]; A[p]:=v;END;

PROCEDURE Seleccion(VAR A:arreglo_de_elementos;n:INTEGER;VAR k:INTEGER);VAR m,r,j:INTEGER; fin:BOOLEAN;BEGIN fin:=FALSE; m:=1; r:=n+1; A[n+1]:=valores_altos; WHILE NOT fin DO

BEGIN j:=r; Partir(m,j); IF k=j THEN fin:= TRUE ELSE IF k<j THEN r:=j ELSE m:=j+1; END;END;

PROCEDURE INICIALIZAR_VARIABLES(VAR A:Arreglo_de_Elementos; VAR K:INTEGER);VAR I:INTEGER;BEGIN {Se puede leer por pantalla} WRITELN; WRITELN('TIPEE LOS SIGUIENTES DATOS PARA LLENAR EL ARREGLO:'); FOR I:=1 TO MAX DO READLN(A[I]); WRITELN; WRITELN('INTRODUZCA DESDE DONDE QUIERE ACOMODAR EL ARREGLO'); READLN(K);END;

PROCEDURE IMPRIMIR_RESULTADO(A:Arreglo_de_Elementos);VARI:INTEGER;BEGIN WRITELN; WRITELN('lOS DATOS OBTENIDOS DESPUES DE APLICAR EL PROCEDIMIENTO SELCCION ES:'); WRITELN; FOR I:=1 TO MAX DO BEGIN WRITELN('A[',I,']: ',A[I]); END;END;

{cuerpo principal}BEGIN clrscr; INICIALIZAR_VARIABLES(A,K); Seleccion(A,max,K); IMPRIMIR_RESULTADO(A); READLN;END.

ConclusiónEn este trabajo se presenta un contenido esencial para la Ciencias de la Computación: como

lo son los lenguajes del paradigma imperativo.

El desarrollo de este trabajo le permitirá conocer a estudiantes y docentes del área de la computación como trabajar en la construcción y la verificación de aplicaciones bajo el paradigma imperativo.

La construcción de un lenguaje bajo el paradigma imperativo debe estar basada en sentencias simples y estrictamente secuenciales.

Existen diversos lenguajes imperativos como FORTRAN, PASCAL, C,….. , pero como se observa, nos hemos enfocado más en los dos primeros.

Gracias a las investigaciones realizadas y al estudio de muchos detalles, se ha aprendido como funcionan estos dos lenguajes imperativos, agregando a cada sección del trabajo su respectiva explicación y ejemplo correspondiente; permitiendo así una comparación directa de ambos lenguajes, los cuales a la final persiguen el mismo objetivo: dejar clara la forma de trabajar imperativamente.

Un programa imperativo indica como cambian las variables (hasta que consigan el valor final buscado), a través de una lista de instrucciones, y al ejecutarse se transforman los contenidos (en las posiciones asociadas con las variables del programa), ejecutándose de forma secuencial cada una de las instrucciones del programa.

Aún cuando una variable de imperativo tome distintos valores durante la ejecución de un programa, una vez que toma un valor final, éste queda fijo.

Junto con la construcción de los algoritmos existe la obligación de la verificación rigurosa de su corrección para que las variables reflejen el valor deseado; por lo tanto es necesario aplicar técnicas de verificación y depuración de errores para probar la correctitud del programa.

Bibliografía

http://www.man.ac.uk/hpctec/courses/Fortran90/JISCF90page.htmlMichel Olagnon's Fortran 90 List http://www.ifremer.fr/ditigo/molagnon/fortran90/engfaq.htmlThe F Programming Language Homepage http://www.fortran.com/F/The Fortran Company http://www.fortran.com/Free Fortran Software http://www.fortran.com/free.htmlhttp://www.linkses.com/manuales/index.asp?cat=FORTRANhttp://manuales.astalaweb.com/Manuales/Fortran.asphttp://manuales.astalaweb.com/Manuales/Fortran.asp