Post on 08-Aug-2015
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