HC I Capitulo1 2010 II Final

UNMSM – UNIDAD DE POSTGRADO FCF Hidráulica Computacional I 1-1
Maestría en Ingeniería Hidráulica
Módulo A:
Algoritmia y Lenguajes de Programación
Capítulo 1: Preliminares
1.1 0RGANIZACIÓN DE LA COMPUTADORA

La siguiente figura 1.1, muestra el esquema básico de una computadora, cuyas
funciones principales son: la entrada de datos, el almacenamiento de los mismos, su
posterior proceso y la salida de los resultados.
Figura 1.1: Principales componentes de una computadora

(Fuente: GARCÍA, 1999, p, 3)
La memoria principal es denominada también memoria RAM. Este tipo de memoria es

volátil, por lo que la información contenida en la misma desaparece en caso de
producirse un corte de corriente eléctrica. Es decir, curiosamente, la memoria de la
computadora no recuerda nada cuando se interrumpe la corriente.
La memoria principal, por razones económicas, es limitada en cuanto a su capacidad.
Por ello se utiliza una memoria secundaria, externa o auxiliar, para almacenar datos y
programas. El disco duro, los discos flexibles, las cintas magnéticas, USBs, etc. son
ejemplos de este tipo de memoria.
Las memorias están constituidas por dispositivos electrónicos capaces de tomar uno de
dos estados binarios: ON para representar el 1 y OFF para representar el 0. Por ello se
dice que la memoria contiene bits ( bit = binary digit, dígito binario) de información. De
este modo, un bit representa un elemento de memoria que consta de posiciones de
encendido y apagado.
Ocho bits agrupados forman 1 byte, y un bloque de 210 bytes constituye 1 kilobyte de
memoria. Es decir:
8 bits = 1 byte
210 bytes = 1,024 bytes = 1KB.
Así, 1 kilobyte (KB) se utiliza para medir la capacidad de una memoria. Pero, a medida
que las capacidades de la memoria han ido aumentando, se ha hecho necesario buscar
múltiplos de KB. Se tiene entonces:
210 KB = 1,024 KB = 1MB (1 megabyte),

210 MB = 1,024 MB = 1GB (1 gigabyte),
210 GB = 1,024 GB = 1TB (1 terabyte),
210 TB = 1,024 TB = 1PB (1 Petabyte),
La memoria puede imaginarse como un conjunto de depósitos, celdas o posiciones.
Cada una de estas posiciones está formada por uno a varios bytes, recibiendo el
nombre de palabra esa agrupación. El tamaño de la palabra varía de una computadora
a otra dependiendo de su arquitectura. Es común encontrar:
1 Palabra = 1 byte = 8 bits,
1 Palabra = 2 bytes = 16 bits,
1 Palabra = 4 bytes = 32 bits, o
1 Palabra = 8 bytes = 64 bits.
En la figura 1.2 se esquematiza celdas de una memoria para guardar 1 bit y 1 palabra
de 1 á 8 bytes.
Figura 1.2
Las palabras de una memoria están numeradas desde el 0 correlativamente hasta la

última de ellas, por lo que es posible dirigirse a una determinada. El número asignado a
cada palabra recibe el nombre de dirección de esa palabra. La figura 1.3 representa el
esquema de una arquitectura de 32 bits por palabra.
Figura 1.3: Constitución y direccionamiento de una memoria

En cada byte se puede representar, utilizando el sistema binario, un carácter cualquiera,

es decir, un número, una letra o un signo determinado. Por eso es frecuente llamar al
byte, carácter.
Las computadoras personales (PCs) de última generación tienen memoria principal cuya
capacidad está del orden de GB (4 GB, en el año 2009)1. En cambio, los mainframes de
gran escala pueden tener centenares de GB de memoria principal y TB de
almacenamiento en disco2.
1
Las primeras PC XT (que aparecieron en 1983) disponían de 1 MB de RAM, de los cuales para los cálculos quedaban sólo
640 KB. La PC AT (ó 286, que aparecieron en 1984), y posteriormente las 386 y 486 disponían hasta 4 MB de RAM, que
podían ampliarse hasta 8 MB o incluso hasta 16 MB.
2
La supercomputadora CRAY XT6 de CPTEC/INPE, adquirida en oct-2010, y que entrará en funcionamiento en ene-2011,
tendría 40 TB de memoria principal; disco primario de 866 TB y almacenamiento secundario de 3.84 PB (Petabytes).
1.2 ARITMÉTICA DE LA COMPUTADORA3

1.2.1 SISTEMAS NUMÉRICOS
La mayor parte de de las computadoras de alta velocidad trabajan con números reales
en el sistema binario, en contraste con el sistema decimal que normalmente se utiliza.
Como sabemos, el sistema binario utiliza el 2 como base, de la misma manera que el
sistema decimal utiliza el 10. Así por ejemplo, cuando un número real como el 427.325
se escribe de una forma más explícita tenemos lo siguiente:
427.325 = 4 × 10 2 + 2 × 101 + 7 × 100 + 3 × 10 −1 + 2 × 10 −2 + 5 × 10 −3
La expresión del segundo miembro utiliza potencias de 10 junto con los dígitos 0, 1, 2,
3, 4, 5, 6, 7, 8, 9; por lo que se denomina sistema de base 10 o sistema decimal. Si se
admite la posibilidad de tener un número infinito de dígitos colocados a la derecha del
punto decimal, entonces, cualquier número real puede expresarse de la manera ya
mostrada, con un signo (+ o -) a su lado. Así, − π se escribe
− π = −3.14159265358979323846264338 ...
El último 8 en esta expresión representa a 8 × 10 −26 .
En el sistema binario se utilizan los dígitos 0 y 1. Un número típico en el sistema
binario también puede representarse en detalle como se ilustra a continuación:
1001.11101 = 1 × 2 3 + 0 × 2 2 + 0 × 21 + 1 × 2 0 + 1 × 2 −1 + 1 × 2 −2 + 1 × 2 −3 + 0 × 2 −4 + 1 × 2 −5
Efectuando las operaciones del lado derecho, se halla el valor decimal de este número,
es decir:
= 8 + 0 + 0 + 1 + 12 + 14 + 18 + 0 + 321 = 9 + 32
29
= 9.90625
En general, cualquier entero β > 1 puede utilizar como base para un sistema numérico.
Los números representados en base β incluirán los dígitos 0, 1, 2, 3, 4, … β − 1 . Si el
contexto no aclara cuál es la base numérica que se utiliza para el número N, se puede
utilizar la notación (N ) β . Así tenemos que, de lo anterior, (1001.11101) 2 = (9.90625)10
De las operaciones efectuadas líneas arriba, el valor decimal de un número de base
β , por ejemplo: (abcdef ⋅ hij ) β , se calcula como:
( N )10 = a × β 5 + b × β 4 + c × β 3 + d × β 2 + e × β 1 + f × β 0 + h × β −1 + i × β −2 + j × β −3
1.2.2 NOTACIÓN CIENTÍFICA NORMALIZADA

En el sistema decimal cualquier número real puede expresarse mediante la notación
científica normalizada. Esto significa que se desplaza el punto decimal y que las
potencias de 10 adecuadas se suministran de tal manera que todos los dígitos aparecen
a la derecha del punto decimal y que el primer dígito que aparece es distinto de cero.
Por ejemplo
732.5051 = .7325051 × 10 3
− 0.005612 = −.5612 × 10 −2
En general, un número real x distinto de cero puede representarse en la forma
x = ± r × 10 n
donde r es un número tal que 101 ≤ r < 1 , y n es un entero (positivo, negativo, o cero).
Resulta evidente que si x = 0 , entonces r = 0 ; en los casos restantes podemos ajustar
n de tal manera que r se encuentre en el intervalo dado.
3
KINCAID (1994, p, 29).
Por ejemplo: 25.801 = 0.25801 × 10 2 , siendo r = 0.25801 , que se encuentra en el intervalo

[0.1 , 1) , y n = 2
Exactamente de la misma manera se puede utilizar la notación científica en el sistema
binario. En este caso tenemos que
x = ±q × 2 m
donde 12 ≤ q < 1 (si x ≠ 0 ) y m un entero. El número q se llama mantisa y el entero m
exponente o característica. En una computadora binaria tanto q como m estarán
representados como números en base 2. Por ejemplo:
− 1111101.010100011110101 = −.1111101010100011110101 × 2 +7
= −.1111101010100011110101 × 2 +111
siendo q = 0.1111101010100011110101 , que se encuentra en el intervalo [0.1 , 1) {notar
que al aplicar la fórmula resulta el intervalo [0.5 , 1) , pero (0.5)10 = (0.1) 2 }4 y el entero
m = +111 {dado que (7)10 = (111) 2 }.
1.2.3 MANEJO DE NÚMEROS EN LA COMPUTADORA

Para realizar cálculos en ingeniería y ciencias, es deseable una longitud grande de bits
(palabra de varios bytes); por otro lado, una longitud pequeña de bits es más económica
y útil en una computadora empleada en cálculos y procesamientos administrativos.
Como ya se dijo, cada palabra, cualquiera sea su longitud, almacena un número, y en
ciertas circunstancias se usan varias palabras para contener un número. A seguir
veamos cómo se almacenan los números en la memoria de una computadora.
1.2.3.1 Números Enteros

Consideremos una palabra de 2 bytes (16 bits) para almacenar números enteros. De
los 16 bits, el primero representa el signo del número: 0 significa (+) y 1 significa (-).
Los 15 bits restantes pueden usarse para guardar números binarios desde
000000000000000 hasta 111111111111111. La siguiente figura esquematiza la forma
como se guarda un número entero:
Figura 1.3: Almacenamiento de números en una palabra de 2 bytes (16 bits)

(Fuente: YZOCUPE, 2002, p, 4)
Entonces, para guardar, por ejemplo, el entero decimal -173 en una palabra de 16 bits,
primero se convierte el número del sistema decimal al sistema binario, luego se guarda
éste tal como muestra el siguiente esquema:
− 173 = −(10101101) 2
1 0 0 0 0 0 0 0 1 0 1 0 1 1 0 1
↑signo
En general, en el sistema de numeración binario, la expresión matemática de un número
entero es
4
La conversión de números fraccionarios del sistema decimal a un sistema de base β ; y conversión de un número fraccio-
nario en sistema binario a sistema decimal; ver, por ejemplo, en ÑIEVES & DOMÍNGUEZ (1996, pp, 7-8).
± a k a k −1 a k − 2 K a 2 a1 a 0
donde a i es un bit con valor 0 ó 1. Su valor decimal de este número, tal como se
presentado en la sección 1.2.1, es
I = ±[a k 2 k + a k −1 2 k −1 + L a 2 2 2 + a1 21 + a 0 2 0 ]
Por ejemplo, el número binario dado por: ± 110101 , es igual a
I = ±[1 × 2 5 + 1 × 2 4 + 0 × 2 3 + 1 × 2 2 + 0 × 21 + 1 × 2 0 ]
= ±[32 + 16 + 0 + 4 + 0 + 1] = ±53
De acuerdo a la figura 1.3, el máximo entero positivo que se puede almacenar en una
palabra de 16 bits será
0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
↑signo
es decir, (111111111111111) 2 cuyo valor decimal es:
1 × 214 + 1 × 213 + 1 × 1212 + K + 1 × 2 2 + 1 × 21 + 1 × 2 0 = 32,767
Por lo tanto, como se muestra en la figura, los 15 bits restantes de una palabra de 16
bits pueden contener los números binarios de 0 á (111111111111111) 2 ; que en sistema
decimal equivale de 0 á 32,767.
Una forma de almacenar un número entero negativo es utilizar los mismos dígitos que el
número positivo de la misma magnitud, excepto que el primer bit se pone en 15. Así, el
entero negativo de menor magnitud que se puede almacenar en una palabra de 16
bits será
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
↑signo
o sea, − (111111111111111) 2 cuyo valor decimal es
− [1 × 214 + 1 × 213 + 1 × 1212 + K + 1 × 2 2 + 1 × 21 + 1 × 2 0 ] = −32,767
Así, una palabra de 16 bits puede guardar un entero de sistema decimal en el rango de
-32,767 á 32,767. Además, debido a que el cero (0) está ya definido como
0000000000000000, sería redundante usar el número 1000000000000000 para definir
“menos cero”. Por lo tanto, es usualmente empleado para representar un número
negativo adicional: − 32,768 , y e rango va de [−32 768 á + 32767] . (CHAPRA &CANALE,
2003, p, 61).
Ejemplos adicionales: (ver ÑIEVES & DOMÍNGUEZ, 1996, pp, 9-10)
a) Representar el número -26 en una palabra de 16 bits

(−26)10 = (−11010) 2
1 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0
↑signo
b) Representar el número 525 en una palabra de 16 bits
(525)10 = (1000001101) 2
5
Sin embargo, muchas computadoras usan el “complemento a dos” para almacenar números negativos; ver por ejemplo
NAKAMURA (1992), p, 8.
0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 1
↑signo
1.2.3.2 Números Reales

Cuando se desea almacenar un número real se emplea la notación científica
normalizada en binario, llamada de punto flotante. Entonces, si se introduce como dato
un número real en sistema decimal, primero se convierte al sistema binario más cercano
en el formato normalizado:
c
(±0 ⋅ mi ) 2 × 2 j
donde m1 es siempre 1, y el restante mi es un dígito binario 0 ó 1 y cada c j es también
un dígito binario.
El formato normalizado en binario para guardar un número real en una palabra de 16
bits, tendrá la siguiente extensión:
(±0 ⋅ m1 m 2 m3 m 4 m5 m6 m7 m8 ) 2 × 2 c1c2c3c4 c5c6 c7
y se guarda como muestra la siguiente figura. Es decir, el bit cero se usa para guardar
el signo del número. En los bits del 1 al 7 se almacena el exponente (o característica)
de la base 2 y los 8 bits restantes se usa para la mantisa. El exponente es un número
binario de seis dígitos, ya que el bit uno se emplea para su signo6.
Así, el número mayor que puede guardarse en una palabra de 16 bits usando la
notación de punto flotante es:
es decir: 0.11111111 × 2 +111111 . Pero, dado que (111111) 2 = (63)10 y

(11111111) 2 = (0.99)10 ; en sistema decimal resulta 0.99 × 2 +63
En consecuencia, los números que se pueden guardar en punto flotante binario van de
alrededor de 2 −64 (si la característica es negativa) a cerca de 2 63 . En el sistema
decimal, de 10 −19 a cerca de 1018 en magnitud (incluyendo números positivos, negativos
y cero). Nótese que primero se normaliza el número, después se almacenan los
primeros 8 bits y se truncan los restantes.
Ejemplos: (ver ÑIEVES & DOMÍNGUEZ, 1996, pp, 11-12)
a) Representar el numero decimal -125.32 en una palabra de 16 bits

Este número en binario es: -1111101.010100011110101
+111
y normalizado quedaría así: − .111110101010001111
144244 3×2
0101
bits truncados
6
En algunas computadoras el exponente se almacena en base 8 (octal) o base 16 (hexadecimal) en lugar de base 2 (ÑIEVES
& DOMÍNGUEZ, 1996, p, 10).
La palabra de memoria de 16 bits donde se almacena este valor quedaría así:

1 0 0 0 0 1 1 1 1 1 1 1 1 0 1 0
↑ ↑signo del exponente
signo del número
b) Representar el numero decimal +0.2 en una palabra de 16 bits

Este número en sistema binario es: + 0.0011001100110011...
y normalizado quedaría así: .1100110011001100

14243 ... × 2 −10
bits truncados
La palabra de memoria de 16 bits donde se almacena este valor quedaría así:

0 1 0 0 0 0 1 0 1 1 0 0 1 1 0 0
↑ ↑signo del exponente
signo del número
1.2.3.3 Doble Precisión

La doble precisión es un esfuerzo para aumentar la exactitud de los cálculos
adicionando más bits a la mantisa. Esto se logra utilizando dos palabras, la primera en
la forma expuesta anteriormente, y la segunda para aumentar la mantisa de la primera.
Entonces, con una palabra de 16 bits puede usarse en doble precisión una mantisa de
8 + 16 = 24 . Los 24 bits de la mantisa permiten expresar alrededor de 7 dígitos de
exactitud en un número decimal, en lugar de 3 dígitos de la precisión sencilla.
La desventaja del uso de la doble precisión es que se emplean más palabras, con lo
cual se consume más memoria para un programa.
1.2.3.4 Error de Redondeo

Como no es posible guardar un numero binario de longitud infinita o un numero de mas
dígitos de los que posee la mantisa de la computadora que se esta empleando, se
almacena solo un numero finito de estos dígitos; como consecuencia, se comete
automáticamente un pequeño error, conocido como error de redondeo, que a repetirse
muchas veces puede llegar a ser considerable. Por ejemplo, si se desea guardar la
fracción decimal 0.0001 que en binario es la fracción infinita:
+0.000000000000011010001101101110001011101011000...
quedaría, después de normalizado y truncado en una palabra de 16 bits como:
.11010001 × 2 −1101
Si se desea sumar el numero 0.0001 con el mismo diez mil veces, usando una
computadora, naturalmente que no se esperara obtener 1 como resultado, ya que los
números que se adicionen no seria realmente 0.0001 sino valores aproximados a él.
1.3 MANEJO DE ERRORES EN LA COMPUTADORA

Ver separata de V. Yzocupe, LFC, Julio 2002.
1.4 INSTRUCCIONES PARA LA COMPUTADORA

Las instrucciones a una computadora se proporcionan a través del software. Así, el
software incluye los programas que contienen las instrucciones para dirigir las
operaciones del equipo de cómputo o hardware.
Las instrucciones están organizadas en conjuntos denominados rutinas y programas.
Una rutina se refiere a un conjunto de instrucciones que dirige la realización de una
tarea específica, tal como calcular la raíz cuadrada de una cantidad o producir un
mensaje de error cuando se encuentra uno en los datos de entrada, por ejemplo.
Un programa consiste en una o más rutinas que dirigen la solución de un problema
completo.
También, se suele denominar algoritmo o procedimiento al conjunto de instrucciones
que describen completamente las distintas etapas de un método con el cual se consigue
resultados que se necesitan y a partir de los datos de que dispone. Si el algoritmo se
describe empleando un lenguaje de computadora, entonces ese conjunto de
instrucciones recibe el nombre de programa de computadora (GARCÍA, 1999, p. 5).
Existen varios tipos importantes de software. De ellos, 3 son especialmente importantes
para el estudio del lenguaje FORTRAN, objetivo de este capítulo:
• Los programas de aplicación,
• Los compiladores,
• Los sistemas operativos.
1.4.1 PROGRAMAS DE APLICACIÓN

Son programas que dirigen el procesamiento para una aplicación de las computadoras,
tales como el cálculo de tirante normal en un canal, el cálculo de esfuerzos para la
estructura de una construcción, etc. Estos programas pueden ser escritos por el
personal de la organización que los necesite o pueden adquirirse de vendedores de
software, quienes preparan y venden programas para aplicaciones que se presentan
con frecuencia.
1.4.2 COMPILADORES
Son programas que traducen instrucciones escritas en un lenguaje de alto nivel (como
FORTRAN) a un conjunto de instrucciones en lenguaje de máquina, específico para la
computadora que se esté utilizando.
El compilador juega un papel importante en el proceso de traducción de un código
escrito en un lenguaje de alto nivel a lenguaje de máquina. Entre sus funciones están:
1).- Traducir el código fuente (programa fuente) en código de máquina (código, o
programa objeto).
2).- Incluir en el programa objeto pequeños programas o rutinas con los que ejecutará
operaciones especiales, como la raíz cuadrada, cálculo de logaritmo, etc.
3).- Reservar ciertas áreas de memoria principal que son necesarias para la ejecución
posterior del programa.
4).- Producir el programa objeto y dejarlo almacenado en un medio físico.
5).- A petición del programador, hacer un informe o listado, tanto del código fuente
como del objeto.
6).- Hacer un listado con todos los errores que el programador haya podido cometer a la
hora de codificar su algoritmo con los mensajes de diagnóstico.
La obtención de los mensajes de diagnóstico supone que cada instrucción escrita

por el programador en un lenguaje de alto nivel, se analiza para comprobar si
cumple con las reglas de sintaxis que el propio lenguaje impone y, por lo tanto, si es
o no convertible en instrucción de máquina. Cuando no ocurre así, se producen
errores sintácticos que el programador debe corregir, procediendo después a una
nueva compilación.
Aunque no existan errores sintácticos, puede ocurrir que el programa contenga
errores lógicos en el propio diseño del programa. Esos errores no los detecta el
compilador; únicamente se descubren durante la ejecución del programa objeto al
producirse resultados inadecuados o impropios de un cálculo. En la figura 1.4 se
da una visión simplificada de la compilación.
Figura 1.4: Visión simplificada del proceso de compilación

Un nuevo compilador del FORTRAN es el HPF (High Performance Fortran), orientado a la

programación de aplicaciones técnicas y científicas en el entorno de los sistemas
paralelos de memoria distribuida y, por lo tanto, utilizando varios procesadores. Su
principal característica es el soporte del paralelismo dentro de los bucles,
proporcionando al programador un control total sobre la localidad de los datos, es decir,
qué procesador manejará qué dato. Este compilador está basado en Fortran 90 al que
añade ciertas herramientas o directivas para la comunicación entre procesadores
(GARCÍA, 1999, p, X).
1.4.3 SISTEMA OPERATIVO

El Sistema Operativo es un conjunto de rutinas que dirige y maneja las operaciones de
la computadora. El sistema operativo apoya y dirige la corrida de programas de
aplicación. Por ejemplo, si un programa de aplicación tiene una instrucción que indique
leer un [archivo de datos] pero ésta no se puede realizar, el sistema operativo envía un
mensaje adecuado al operador de la computadora.
UNMSM – UNIDAD DE POSTGRADO FCF Hidráulica Computacional I 1 - 10
1.5 LENGUAJE DE PROGRAMACIÓN

Un lenguaje de programación es una notación para escribir programas, a través del cual
podemos comunicarnos con el hardware y dar así las órdenes adecuadas para la
realización de un determinado proceso.
Un lenguaje de programación viene definido por una gramática, o conjunto de reglas,
que se aplican a un alfabeto constituido por el conjunto de símbolos utilizados. Esta
gramática se caracteriza por ser estricta, ya que para que una máquina entienda el
significado concreto de un mensaje necesita que se le comunique en un lenguaje que
esté rigurosamente definido con unas estrictas reglas gramaticales. De este modo, la
comunicación hombre-máquina se debe realizar a través de un lenguaje escrito que
impida la posibilidad de error en la interpretación de los mensajes.
1.5.1 EVOLUCIÓN DE LOS LENGUAJES DE PROGRAMACIÓN

Es posible distinguir, a la fecha, 4 generaciones de lenguajes de programación:
• Lenguaje de máquina (primera generación)
• Lenguaje ensamblador (segunda generación)
• Lenguaje de alto nivel (tercera generación)
• Lenguajes integrados (cuarta generación).
1.5.1.1 Lenguaje de de Máquina

La primera generación de lenguajes se inicia a fines de la década de 1940.
Un programa en la memoria principal de una computadora deberá estar expresado en
lenguaje de máquina para poder ejecutarse. Una instrucción en lenguaje de máquina
se representa como una cadena de dígitos binarios, los cuales identifican las
operaciones que han de realizarse y los datos, etc., que han de emplearse. Las
instrucciones a nivel de máquina son distintas para diferentes series de computadoras y
para diferentes fabricantes. Como ejemplo, una instrucción típica para una
computadora IBM grande tiene la siguiente forma:
01011010001100001011101001000000
Las instrucciones en una cadena de dígitos binarios, para uso del operador/
programador se imprime en notación condensada. Por ejemplo, la instrucción (1.1) se
imprimiría para que la inspeccionara el operador/programador como
5A30BA40
Otro ejemplo de lenguaje de máquina:
0000 0001 1010 0001 01 A1
1000 1001 1001 1010 89 9A
0011 1010 1001 1100 3A 9C
0111 0100 0111 0000 74 70
1110 1001 0010 0000 E9 20
El lenguaje de máquina fue el primer lenguaje utilizado en la programación de

computadoras, pero se dejó de utilizar por su dificultad y complicación, siendo sustituido
por otros tipos de lenguajes más fáciles de aprender y utilizar, que además reducen la
posibilidad de cometer errores.
1.5.1.2 Lenguaje Emsamblador

Comenzada la década de 1950 aparece la segunda generación de lenguajes, que
utilizaba una notación simbólica para representar los mandos de los lenguajes de
máquina.
Como puede observarse en (1.2), la notación condensada sigue siendo difícil de utilizar.
Por lo tanto, el programador usa un lenguaje simbólico de ensamblador, o simplemente
lenguaje ensamblador, menos complicado. Por ejemplo, la instrucción (1.2),
codificada en lenguaje ensamblador podría ser:
A 3, PAGA
donde, por ejemplo, A significa “sumar”.
Los lenguajes ensamblador, como grupo, a menudo se denominan LENGUAJES DE BAJO
NIVEL, por que estaban íntimamente relacionados con el lenguaje de máquina y con la
arquitectura interna de la computadora en la cual se usaban. Casi todas las marcas de
computadoras tienen un lenguaje ensamblador propio.
Los lenguajes ensamblador están orientados hacia la máquina debido a que cada
instrucción simbólica de ensamblador se convierte en una instrucción en lenguaje de
máquina a través de una traducción realizada por un programa denominado Sistema
Ensamblador Simbólico, o simplemente ENSAMBLADOR, el cual convierte cada
instrucción simbólica en una instrucción equivalente en código a nivel de máquina, es
decir,
SISTEMA ENSAMBLADOR
LENGUAJE ENSAMBLADOR CÓDIGO A NIVEL DE
SIMBÓLICO
(Lenguaje de Bajo Nivel) MÁQUINA
(Ensamblador)
Un programa en lenguaje de ensamblador es relativamente difícil de codificar, y es difícil

localizar los errores lógicos. También resulta difícil y toma mucho tiempo realizar
modificaciones. Un programa en un lenguaje de bajo nivel, orientado hacia la máquina,
tiene además una capacidad de transferencia (portabilidad) de una computadora a otra
que es limitada.
Otro ejemplo de programa ensamblador:
INICIO ADD B,1

MOV A,B
CMP A,E
JE FIN
JMP INICIO
FIN END
1.5.1.3 Lenguaje de Alto Nivel

Entre 1945 y 1947 John Backus trabajó en el primer lenguaje de alto nivel, el FORTRAN
que hizo su aparición en 1957. Hacia 1959, tanto la industria como las universidades ya
habían creado 200 lenguajes de programación.
Los lenguajes de alto nivel se idearon con el propósito de independizar al programador
de las características internas de la máquina y permitirla concentrarse en la lógica del
problema por resolver. Así, un lenguaje de alto nivel se orienta hacia la solución de
problemas o procedimientos de procesamiento, en vez de hacerlo hacia las
instrucciones a nivel de máquina de una computadora en particular. Las proposiciones
de instrucción emplean palabras, frases, y símbolos semejantes a los empleados
comúnmente para describir la solución o los procedimientos de procesamiento. Otra
diferencia importante entre una instrucción de alto nivel y una instrucción simbólica de
ensamblador es que la primera se traduce a muchas instrucciones en lenguaje de
máquina.
Para traducir un programa escrito en lenguaje de alto nivel (programa fuente) a
instrucciones a nivel de máquina (programa objeto) para la computadora en la cual se
correrá el programa, se emplea un programa denominado COMPILADOR, o sea,
PROGRAMA EN LENGUAJE INSTRUCCIONES A

DE ALTO NIVEL COMPILADOR NIVEL DE MÁQUINA
(Programa Fuente) (Programa Objeto)
Puesto que las instrucciones a nivel de máquina difieren entre las distintas series de
computadoras, debe existir un compilador para cada serie de computadoras.
Existen dos importantes ventajas de los lenguajes de alto nivel respecto a los lenguajes
simbólicos de ensamblador: son independientes de la máquina en el sentido de que los
programas escritos en un lenguaje de alto nivel pueden compilarse y correrse en
cualquier computadora (para la cual exista un compilador) con pocos o ningunos
cambios, que son relativamente fáciles de aprender. También es relativamente fácil
estandarizar los métodos de programación con lenguajes de alto nivel.
Los lenguajes de alto nivel más comunes adecuados para la computación científica y de
ingeniería son: FORTRAN, BASIC, PASCAL, C, C++, JAVA, etc. Estos lenguajes podrían
encuadrarse en la categoría de los lenguajes de programación tradicionales.
1.5.1.4 Lenguajes Integrados

Los lenguajes de cuarta generación son más informales, es decir menos rígidos y
obedece a un menú o a mandos. Esta categoría de lenguajes está constituida por
lenguajes de tipo interactivo, característica a la que hay que añadir herramientas para la
producción de gráficos y la programación de modelos. Estos lenguajes soportan, no
solo la programación de alto nivel, sino también la simbólica, las operaciones propias
del álgebra lineal y la visualización. Tales lenguajes reciben el nombre genérico de
lenguajes integrados, entre ellos Mathematica, Matlab, Maple, etc. En general, y por
el momento, la velocidad de ejecución de este tipo de lenguajes es más lenta que la
alcanzada por FORTRAN por la necesidad de utilizar como infraestructura un intérprete y
no un compilador, lo que produce demoras en la ejecución (GARCÍA, 1999, p. X).
1.5.2 COMPILADORES E INTÉRPRETES

Tal como se presenta en la Sección 1.4.2, los compiladores son programas traductores
encargados de transformar programas de usuario escrito en lenguaje simbólico de alto
nivel en programas objetos escritos en lenguaje de máquina. Una característica
fundamental de este tipo de traductores es que se realiza la traducción completa y en
caso de no existir errores se pasa a la creación del programa objeto.
Por su parte, un intérprete no crea un programa objeto. Los intérpretes leen, traducen y
ejecutan programas fuente una línea a la vez. De este modo el tradicional lenguaje de
máquina se realiza mientras el programa está siendo ejecutado.
Los intérpretes tienen ventajas y desventajas en relación con los compiladores. La
ventaja principal es que un intérprete requiere menos espacio de almacenamiento.
Asimismo, un intérprete no genera un programa objeto que tenga que ser almacenado.
La desventaja principal es que los intérpretes son más lentos y menos eficientes que los
compiladores. Además, el programa objeto de un programa compilado puede
almacenarse en disco, de modo que el programa fuente no tiene que volver a traducirse
cada vez que se ejecute el programa. Con un intérprete el programa tiene que ser
traducido cada vez que se ejecute.
1.6 CLASIFICACIÓN DE LOS LENGUAJES DE ALTO NIVEL

La clasificación de lenguajes de alto nivel es una tarea complicada debido al gran
número de ellos existente y a la gran variedad de áreas de aplicación de cada uno de
ellos. Sin embargo, se puede hacer el siguiente intento de clasificación:
• Lenguajes científicos: Pascal, Basic, FORTRAN,
• Lenguajes de gestión: FlowMatic, Cobol, RPG,
• Lenguajes polivalentes (aplicación general): FORTRAN, Pascal, Basic,
• Lenguajes especiales (lenguajes para algún propósito específico)
• Lenguajes de nivel intermedio (poseen características de alto y bajo nivel7): C, C++,
ADA,
• Lenguajes integrados: Mathematica, Matlab, Maple,
• Lenguajes aplicados hacia la inteligencia artificial: PROLOG, LISP, C, C++
• Lenguajes orientados a objetos: SMALTASK, C++, DELPHI, JAVA
1.7 ESTILO DISCIPLINADO Y ESTRUCTURADO EN PROGRAMACIÓN

La escritura de programas se recomienda realizar mediante un estilo disciplinado y
estructurado.
Los programas de computadora con frecuencia no cubren las necesidades del usuario,
no se producen a tiempo, cuestan bastante más de lo estimado, contienen errores, y
son difíciles de mantener (corregirlos o modificarlos para cubrir nuevas necesidades).
Estas dificultades se presentan con tal frecuencia que muchas organizaciones han
tratado de cambiar la práctica de la programación a fin de mejorar los resultados. El
enfoque revisado puede denominarse disciplina de programación: prácticas,
procedimientos y desarrollo de procesos de control bien definidos. Un estudiante no
debería simplemente aprender a codificar proposiciones FORTRAN, es igualmente
importante aprender a combinar estas proposiciones para obtener un programa de alta
7
Por lo cual se puede obtener velocidades de proceso muy similares al bajo nivel, control total del equipo y además facilidad
de programación.
calidad: programa que sea fácil de entender (y de modificar en caso necesario) y que
emplee en forma eficiente los recursos del computador.
Objetivos de un Enfoque Disciplinado en la Programación

Los objetivos de un enfoque disciplinado en la programación son:
1).- Cubrir las necesidades del usuario. Un enfoque disciplinado del diseño de
programas incluye un análisis cuidadoso de las necesidades del usuario, antes de
la programación. Un programa fracasa si no se emplea debido a que el usuario
potencial de la aplicación lo encuentra demasiado complicado o demasiado difícil.
2).- Desarrollo de programas a tiempo y dentro del presupuesto. Empleando un
enfoque más estructurado y disciplinado, se han logrado importantes mejoras en la
productividad y se ha aumentado la capacidad de estimar el tiempo que se tomará
completar un trabajo.
3).- Conjunto de instrucciones sin errores. Empleando un enfoque disciplinado y
estructurado, pueden diseñarse y desarrollarse programas de manera tal que los
errores se minimicen y se facilite la localización y corrección de los mismos en la
prueba. El resultado puede ser programación prácticamente sin errores.
4).- Operación con resistencia a errores. El programa deberá estar diseñado de
manera tal que los errores, siempre que sea posible, se detecten por el propio
programa durante la ejecución. Las características de diseño que ayudan en la
detección de errores son:
a).- Validación de la entrada. Éste es un proceso que consiste en probar todos los
elementos de entrada dato para comprobar si cumplen o no con los criterios
fijados para ellos. Por ejemplo, la entrada de datos puede probarse para
verificar:
• La existencia de los elementos dato de entrada necesarios.
• Valores de los elementos dato dentro del intervalo aceptable.
• Clases incorrectas de datos (por ejemplo, caracteres alfabéticos en un
elemento dato que debería ser numérico).
b).- Pruebas de corrección durante el procesamiento. Éstas generalmente toman la
forma de pruebas para resultados razonables y verificaciones de relaciones
lógicas entre resultados diferentes.
5).- Programas que pueden mantenerse. Los programas de computadora cambian
especialmente cuando se emplean por primera vez. Los programas deben
escribirse teniendo en cuenta la actividad de mantenimiento. La documentación del
programa y el estilo en el cual está escrito deberán permitir que otro programador
entienda la lógica del programa y pueda realizar un cambio en una parte del mismo
sin introducir inadvertidamente un error en otra parte.
6).- Programas portátiles. Un programa probado, escrito en FORTRAN, podrá transferirse
sin cambios sustanciales a otra computadora que tenga un compilador FORTRAN.
Esto significa que todas las instrucciones FORTRAN que no sean estándar deberán
evitarse. Las instrucciones directas, bien documentadas que siguen un enfoque
bien disciplinado y estructurado son portátiles con mínimas dificultades; los
programas con lógica intrincada o pobremente documentada no lo son.
1.7.1 DISEÑO MODULAR DE PROGRAMAS COMO PARTE DE LA APLICACIÓN

DE LA DISCIPLINA DE PROGRAMACIÓN
Uno de los conceptos claves en la aplicación de la disciplina de programación es el
diseño de un programa de aplicación como un conjunto de unidades a las que se
denomina bloques o módulos. Un módulo de programa se define como aquella parte
que realiza una función separada tal como entrada, validación de entrada,
procesamiento de un tipo de entrada, etc. Un módulo de entrada puede ser bastante
grande (en términos de lógica y de números de instrucciones necesarias), de manera
que puede subdividirse en submódulos lógicos. El proceso de subdivisión continúa
hasta que todos los módulos son de un tamaño manejable en términos de complejidad
de la lógica y del número de instrucciones. En la práctica, un módulo FORTRAN con más
de 60 proposiciones (que ocupa, enlistado, más de una página) es demasiado grande.
Aun cuando los programas de computadora difieren grandemente en cuanto a finalidad
y procesamiento, resulta posible identificar aquellos tipos de funciones que comúnmente
se necesitan en los programas. Los programas pueden clasificarse, desde el punto de
vista lógico, en los siguientes módulos funcionales:
MÓDULO FUNCIONAL DESCRIPCIÓN
Inicialización Establece valores iniciales para algunas variables, imprime encabezados,

mensajes, etc. Puede no ser necesario.
Entrada Realiza la entrada de los datos necesarios para el programa.
Validación de datos de Realiza la validación de los datos de entrada para detectar errores u
entrada omisiones.
Procesamiento Realiza cálculos o manejos con los datos.
Salida Realiza la salida de los datos que debe proporcionar el programa.
Manejo de errores Realiza análisis de condición de error y da salida a mensajes de error. En

programas pequeños, el mensaje de errores puede quedar incluido en otros
módulos.
Procedimiento de cierre Realiza procedimientos para finalizar la ejecución del programa.
Estos módulos reflejan el flujo de un programa de computadora. Después de la

inicialización, el procedimiento continúa, de manera lógica, con la entrada, la validación
de la entrada, con los diferentes módulos de procesamiento, y con la salida. El manejo
de errores puede necesitarse durante la ejecución de cualquiera de los módulos. Al
concluir el procesamiento, se realizan los procedimientos de cierre para completar el
programa. Aun cuando todas las funciones de todos los módulos lógicos normalmente
se encuentran en programas bien escritos, no siempre se definen como módulos
separados de programa; pueden combinarse o arreglarse en diferentes formas para
seguir el flujo de un programa en particular.
A seguir, un ejemplo de un programa que muestra algunos de los bloques referidos.
PROGRAM BINARIO
!
!**************** BLOQUE DE IDENTIFICACION DEL PROGRAMA ***********************
! Este programa convierte un numero decimal positivo menor de 1.0E+38 a un *
! numero binario en formato de punto flotante normalizado, con una mantisa de *
! 24 bits. Es decir, el numero real se almacena en una palabra de 32 bits. *
! El programa trabaja de manera interactiva. Al ejecutarlo, pide un valor deci- *
! mal que después se convierte en binario. *
! Nakamura (1992, p, 18); Revisado el O9/10/08 por B. S. Rojas *
!***************************************************************************************************
!*************************** IDENTIFICACION DE VARIABLES ***************************
! A(k) : bit k-ésimo en la mantisa normalizada *
! B : 2^I *
! I : parâmetro *
! L : mantisa *
!************************** DATOS DE ENTRADA/SALIDA ********************
! X : numero real (base decimal) de entrada. *
! MANTISA : mantisa normalizada de 24 bits. *
! EXPONENTE: exponente o "caracteristica" (en base decimal) *
! del numero binario normalizado. *
!***************************************************************************************************
!********************* BLOQUE DE DECLARACION DE TIPO ******************
IMPLICIT NONE
INTEGER :: A(255), I, K, L, M
REAL :: B, X
!
!***************************************************************************************************
!*********************** BLOQUE DE ENCABEZAMIENTO ******************
PRINT*, ' CONVERSION DE DECIMAL A BINARIO'
PRINT*
PRINT*, 'PROGRAMA DE PRUEBA, CORRIDO EL 11/10/08'
PRINT*
!
!***************************************************************************************************
!********************** BLOQUE DE LECTURA DE DATOS ********************
10 PRINT*, 'Introduzca el valor decimal, positivo menor de 1.0E+38:'
PRINT*
READ*, X
!
!****************************************************************************************************
!****************** BLOQUE DE INICIALIZACION ******************
L=0
K=1
!
!****************************************************************************************************
!*********************** BLOQUE DE CALCULO ***********************
I=LOG(X)/LOG(2.0)+2
70 I=I-1
IF (I.LT.-200) STOP
B=2.0**FLOAT(I-1)
IF (X.GE.B)THEN
A(K)=1
X=X-B
IF (L.EQ.0) M=I
IF (L.EQ.0) L=1
ELSE
IF (K.GT.1) A(K)=0
END IF
IF (L.GT.0) K=K+1
IF (K.LT.25) GOTO 70
!
!****************************************************************************************************
!*********************** BLOQUE DE SALIDA Y FINALIZACION ***************
PRINT*,'-------------------------------------------------------'
PRINT*, 'NUMERO BINARIO NORMALIZADO CON MANTISA DE 24 BITS:'
PRINT*
PRINT 30, (A(K), K=1,24)
30 FORMAT(1X,' MANTISA= ', 10(4I1,1X))
PRINT 40, M
40 FORMAT(' EXPONENTE=', I3)
PRINT*,'-------------------------------------------------------'
PRINT*
PRINT*, 'Digite 1 para continuar, o 0 para terminar'
READ*, K
IF (K.EQ.1) GOTO 10
END PROGRAM BINARIO
Programa 1.1: Programa para convertir decimal a binario
1.7.2 PROGRAMACIÓN ESTRUCTURADA

Un método para lograr el objetivo de programas exactos, a prueba de errores y de fácil
mantenimiento, es codificar (escribir) cada módulo en un formato sencillo y fácil de
entender. Un punto inicial útil para lograr la forma de codificar los módulos en un
formato claro, fácil de entender, es el hecho de que todo procesamiento de un programa
de computadora puede codificarse empleando solamente tres estructuras lógicas
(patrones) o combinación de estas estructuras: secuencia simple, selección y
repetición.
Es decir, la idea clave detrás de la programación estructurada es que cualquier
algoritmo numérico requiere tan sólo de estas tres precitadas estructuras de control
fundamentales. Limitándonos a dichas estructuras, que se presenta en detalle en la
Sección 1.10, el programa resultante será claro y fácil de entender.
1.8 PLANEACIÓN DE UN PROGRAMA

Un programa deberá planearse antes de escribir las instrucciones del programa. Antes
de planear el programa, debe realizarse una revisión de la necesidad para la existencia
del programa y definirse de alguna forma los objetivos que desean lograrse a través del
programa (requerimientos). El proceso de planeación de un programa tiene como
finalidad lograr el diseño de un programa que cumpla con los requerimientos.
Generalmente es conveniente diseñar primero la estructura general del programa y
trabajar después la lógica detallada. Las herramientas y técnicas que ayudan a
planear un programa y la lógica de un programa incluyen el pseudocódigo (lenguaje de
diseño de programas), diagramas de flujo, y diversas formas para entrada y salida de
datos.
1.8.1 PLANEACIÓN DE LA ESTRUCTURA GENERAL DEL PROGRAMA

La planeación de un programa es semejante a la planeación de un edificio o una casa.
Primero, se realizan un diagrama general en el que se muestran las diferentes
habitaciones (las diferentes funciones que deberán realizarse) y su relación entre ellos.
A continuación se realiza el diseño detallado de cada habitación. De manera similar, es
necesario que exista una estructura general para el programa de computadora. Ésta
consiste en los módulos para las diferentes funciones del programa. Cuando se definen
los módulos y se especifican las relaciones entre ellos, pueden diseñarse y codificarse
los módulos individuales. La necesidad de un enfoque sistemático en el diseño es más
evidente en programas grandes, pero la habilidad básica puede desarrollarse aplicando
las técnicas de planeación a programas pequeños.
Un enfoque ordenado hacia la planeación general puede seguirse una secuencia como
la siguiente:
1).- Definición de los requerimientos (o necesidades) en términos de las salidas.
a).- Definición de los requerimientos fundamentales en términos de salidas que se
entregarán a los usuarios de la aplicación. La salida deseada puede ser:
• Un solo número (valor), como por ejemplo la velocidad media en la sección
de un canal.
• Un conjunto de números, como por ejemplo, las velocidades puntuales en la
vertical de un canal.
• Un informe, como por ejemplo análisis de flujo en un tramo de un canal.
b).- Definición de las salidas adicionales necesarias para que los destinatarios de la
salida la entiendan y tengan la seguridad de que está correcta y completa.
Estos requerimientos incluyen:
• Fechas, números de versión, etc., que distinguen las variaciones de salida.
• Encabezados, títulos, y etiquetas en los elementos de la salida dato.
• Identificación de (o lista de) los datos empleados como entrada, de los
factores empleados en los cálculos, y de los totales (cuando éstos puedan
compararse con totales relacionados a fin de demostrar que los resultados
son completos). Éstos se incluyen, pues son necesarios para dar la
seguridad al usuario de que los resultados son correctos y completos.
c).- Definición de las salidas de mensajes de error para explicar los errores en la
entrada o procesamiento y explicar también a los receptores de la salida lo que
pueden (o deben) hacer para corregirlos.
2).- Con base en las salidas, definición de las entradas que necesita la aplicación.
3).- Definición del procedimiento de validación para verificar que los elementos dato que
se estén introduciendo sean correctos y completos. Definición de los
procedimientos para manejar los elementos dato identificados como erróneos.
4).- Definición de los procedimientos para transformar los datos de entrada en salida:
a).- Transformación de los datos de entrada válidos en la salida deseada.
b).- Conversión de datos no válidos en salidas indicadoras de error.
Si el procedimiento de transformación tiene muchos pasos, puede resultar
necesario fraccionarlo en varios procedimientos componentes.
5).- Definición de la estructura del programa en términos de los módulos principales. El
análisis de planeación debe ayudar a aclarar por qué, como se explicó
anteriormente, un programa tiene posibilidades de contener uno o más módulos

para:
• Entrada.
• Validación de datos de entrada.
• Procesamiento.
• Salida.
• Manejo de errores (y salidas indicando errores).
Los otros dos módulos, procedimiento de inicialización y cierre, con frecuencia
resultan necesarios para iniciar el procesamiento y asegurarse de la terminación
completa.
1.8.2 El SEUDOCÓDIGO EN LA PLANEACIÓN DE UN PROGRAMA

Un lenguaje de diseño de programas (program design language- PDL), o seudocódigo,
consiste en proposiciones abreviadas en inglés (o en otro lenguaje natural) que
especifican los procedimientos que el programa debe realizar. Las proposiciones son
independientes del lenguaje FORTRAN pero con tendencia a reconocer las
características del lenguaje. Por ejemplo, un programa para: “leer los datos de entrada
mediante un archivo, calcular la suma de dos valores de entrada, e imprimir los valores
de entrada y su suma”, podría escribirse de la siguiente forma:
LEER valores de x e y desde un archivo

Calcular suma = x + y
IMPRIMIR x, y, y suma
ALTO
En este caso sencillo, cada línea de PDL da como resultado una línea de FORTRAN, pero
en otros casos una sola línea de PDL puede requerir de muchas líneas en FORTRAN.
PDL es bastante útil en la planeación del flujo general de un programa.
No existen reglas estándar para un PDL; el objetivo principal es obtener una descripción
inteligible de la lógica del programa. Se debe caracterizar por ser:
• “Oraciones” simples, muy claras y bien definidas,
• Cercana al lenguaje natural pero sin ambigüedad,
• Más próximo a un lenguaje de programación que al lenguaje natural.
1.8.3 DIAGRAMA DE FLUJO EN LA PLANEACIÓN Y DOCUMENTACIÓN DE UN

PROGRAMA
Un diagrama de flujo es una representación visual de un algoritmo. FORTRAN es
adecuado para el empleo de diagramas de flujo en la planeación y documentación de
programas debido a que el lenguaje está orientado hacia la lógica de procedimiento.
Para algunos programadores los diagramas de flujo resultan muy útiles; otros no los
emplean. Los diagramas de flujo son menos útiles que el PDL para planear el flujo
general de un programa, pero que son más útiles en la programación y documentación
de la lógica detallada. En cualquier caso, los diagramas de flujo son tan frecuentes que
un programador FORTRAN debe estar familiarizado con ellos.
Los diagramas de flujo son medios para representar simbólicamente:
• La lógica y los procedimientos de los programas, y
• Los elementos y el flujo de los sistemas.
El American National Standar Institute (ANSI), ha definido símbolos estándar para la

realización de diagramas de flujo y para su empleo en el procesamiento de datos. En la
figura 1.4a, se presentan los símbolos más comunes empleados en la realización de
diagramas de flujo para programas FORTRAN:
ENTRADA/ Entrada o salida de datos hacia o proveniente de la computadora. No se

SALIDA especifica el medio de entrada o salida.
Entrada o salida empleando un documento como por ejemplo una salida

impresa.
Cualquier manipulación o procesamiento de datos dentro de la

computadora.
Realización de algún tipo de procesamiento empleando una unidad de

subprograma adicional.
Realización de acciones alternativas basadas en la presencia o ausencia

de alguna condición. A menudo se la denomina símbolo de decisión.
Anotación. Se emplea para agregar comentarios. Se conecta a un

diagrama de flujo en donde resulte útil para proporcionar información
adicional.
Inicio o final de un módulo de programa.
Conector. Se emplea para conectar las líneas de flujo yendo o viniendo

de otro punto en la misma o en otra página.
Figura 1.4a: Símbolos más comunes para diagrama de flujo

1.9 INTRODUCCIÓN A PROGRAMACIÓN ESTRUCTURADA

Los científicos de la computación han estudiado sistemáticamente los factores y los
procedimientos necesarios para desarrollar software de alta calidad que toman menos
tiempo desarrollar, probar y actualizar, basado en algoritmos bien estructurados. En
esencia la programación estructurada es un conjunto de reglas que desarrollan en el
programador hábitos para lograr un buen estilo. Aunque la programación estructurada
es bastante flexible para permitir considerable creatividad y expresión personal, sus
reglas imponen suficientes restricciones para hacer que los programas resultantes sean
muy superiores a sus versiones no estructuradas. En particular, el producto terminado
es mucho más elegante y fácil de entender (CHAPRA & CANALE, 2004, p, 27).
La idea clave detrás de la programación estructurada es que cualquier algoritmo
numérico requiere tan sólo de tres estructuras (patrones) de control fundamentales, o
combinaciones de estas estructuras: secuencia simple, selección y repetición.
Limitándonos a dichas estructuras el programa resultante será claro y fácil de seguir.
Deben entenderse estos tres patrones básicos, ya que estas estructuras tienen
aplicación general en la programación de computadoras.
1.9.1 ESTRUCTURA DE SECUENCIA SIMPLE

La estructura secuencial expresa la trivial idea de que, a menos que se indique otra
cosa, el programa debe realizarse instrucción por instrucción. En otras palabras,
realizar la operación A y realizar después la operación B, tal como muestra la siguiente
figura.
Operación A
Operación B
Figura 1.5: Estructura de programa Pseudocódigo

de secuencia simple
1.9.2 ESTRUCTURA DE SELECCIÓN

La estructura de selección nos ofrece un medio de dividir el flujo del programa en ramas
considerando el resultado de una condición lógica. Existen 2 principales maneras de
hacer esto, tal como se muestra a seguir:
La decisión ante una sola alternativa (figura 1.6), o estructura IF/THEN (si/entonces),
nos permite una desviación en el flujo del programa si una condición lógica es
verdadera. Si esta condición es falsa no ocurre nada y el programa continúa con la
indicación que se encuentra después deL ENDIF.
La decisión ante dos alternativas (figura 1.7), o estructura IF/THEN/ELSE (si/
entonces/de lo contrario), se comporta de la misma manera que el caso anterior si la
condición es verdadera; sin embargo, si la condición es falsa, el programa realiza las
instrucciones entre el ELSE y el ENDIF. Es decir, si la condición lógica es verdadera,
se ejecutará el bloque correspondiente al bloque verdadero, ignorándose el otro bloque
compuesto por bloque falso; en caso contrario (ELSE), se ejecutará el bloque falso
ignorándose el primero. En ambos casos la ejecución continúa en la instrucción
siguiente a la END IF.
Puede observarse que la estructura IF/THEN es un caso particular de la estructura de
decisión ante dos alternativas en el que falta la segunda secuencia de sentencias, así
como la sentencia ELSE que le precede.
Verdadera
Condición ?
(THEN)
Ejecución Bloque
Verdadero Falsa
(END IF)
Ejecución
Siguiente Sentencia
Figura 1.6: Estructura IF/THEN Pseudocódigo
Verdadera Falsa
Condición ?
(THEN) (ELSE)
Ejecución Ejecución
Bloque Verdadero Bloque Falso
(END IF)
Sentencia Común
Figura 1.7: Estructura de selección Pseudocódigo

(Bloque IF GENERAL)
(Las líneas discontinuas en los pseudocódigos de las figuras 1.6 y 1.7, se ha trazado sólo para indicar el
flujo del programa).
Aunque las estructuras IF/THEN e IF/THEN/ELSE son suficientes para construir

cualquier algoritmo numérico, por lo común también se usan otras dos variantes: la
estructura IF/THEN/ELSEIF y la estructura SELECT CASE.
Suponga que el ELSE de un IF/THEN/ELSE contiene otro IF/THEN. En tales casos el
ELSE y el IF se pueden combinar en la estructura IF/THEN/ELSEIF que se muestra en
la figura 1.8. Como se observa en la figura, hay una cadena o “cascada” de decisiones.
La primera es una instrucción IF y cada una de las decisiones sucesivas es un ELSEIF.
El pseudocódigo de esta estructura es:

IF (condición 1) THEN
Bloque sentencias S1
ELSEIF (condición 2)
Bloque sentencias S2
ELSEIF (condición N)
Bloque sentencias Sn
ELSE
Bloque otras sentencias
ENDIF
Falsa Verdadera
Condición 1?
Falsa Verdadera Bloque

Condición 2 ?
Sentencias S1
Falsa Verdadera Bloque

Condición N ? Sentencias S2
Bloque otras Bloque

Sentencias Sentencias Sn
Sentencia Común
Figura 1.8: Estructura con múltiples alternativas (IF/THEN/ELSEIF)
La otra variante de la estructura de selección es la estructura SELECT CASE (figura

1.9). En esta estructura, en lugar de probar condiciones individuales, las ramificaciones
dependen del valor de una sola expresión de prueba. Según sea su valor, se presentan
diferentes bloques de programa. Además, si la expresión no toma ninguno de los
valores previstos, se puede proponer un bloque opcional (CASE ELSE).
SELECT CASE (Expresión de prueba)

CASE Valor 1
Bloque 1
CASE Valor 2
Bloque 2
CASE Valor 3
Bloque 3
CASE ELSE
Bloque 4
END SELECT
Figura 1.9: Estructura SELECT CASE (Selecciona o desvía)
1.9.3 ESTRUCTURA DE REPETICIÓN

En general, en los lenguajes de programación a la estructura de repetición también se
suele denominar ciclo, loop o esquema bucle. En Fortran 90 es conocido como bucle
DO Esta estructura se presenta en dos formas distintas que se diferencian por la
manera como terminan.
• Repetición de una secuencia bajo control de una expresión lógica. En este
caso, la decisión de continuar o no repitiendo el bloque de sentencias depende del
resultado de una condición lógica.
• Repetición de una secuencia de instrucciones bajo control de un contador. En
este caso, el bloque de sentencias se ejecutan una vez por cada valor que tome el
contador, supuesto que esos valores pertenecen a un cierto rango.
1.9.3.1 Bucles Controlados por Expresión Lógica

El primer tipo, y el fundamental, se denomina también loop de decisión debido a que
termina basándose en el resultado de una condición lógica. La figura 1.10 muestra el
tipo general de loop de decisión, la construcción DO EXIT, llamada también loop de
interrupción (break loop). Esta estructura realiza repeticiones hasta que una condición
lógica resulte verdadera.
DO
Sentencias Bloque 1
IF (condición) EXIT
Sentencias Bloque 2
END DO
Figura 1.10: Estructura DO EXIT o Loop lógico Pseudocódigo

Al caso general, en el que se incluyen los dos bloques, se le llama loop de prueba
intermedia (midtest). Sin embargo, en esta estructura no es necesario tener dos
bloques:
Cuando se omite el primer bloque, a la estructura se le suele llamar loop de preprueba
porque la prueba lógica se realiza antes de que ocurra algo. En caso de que la
condición sea cierta, el bucle ni siquiera se realiza. El pseudocódigo de este caso es
DO
IF (condición lógica) EXIT
Sentencias Bloque 2
END DO
En cambio, si se omite el segundo bloque, se le llama loop posprueba. En este caso, la

comprobación se lleva a cabo al final de la iteración, es decir, después que el bucle se
haya ejecutado. El pseudocódigo es
DO
Sentencias Bloque 1
IF (condición lógica) EXIT
END DO
En todos los casos estudiados, y como puede observarse, la instrucción simple EXIT,
cuya ejecución obedece a que se cumpla una condición, permite salir del bucle en el
momento adecuado.
1.9.3.2 Bucles Controlados por Contador

Por otra lado, se tiene loop controlado por contador o loop DOFOR (figura 1.11) que
realiza un número determinado de repeticiones o iteraciones.
El loop controlado por contador funciona como sigue: El índice (representado por i en la
figura 1.11) es una variable a la que se da un valor inicial. El programa prueba si el
índice es menor o igual a valor final, fin. Si es así, entonces ejecuta el cuerpo del loop y
vuelve al DO. Cada vez que encuentra el END DO el índice se incrementa
automáticamente con un valor definido por el incremento. De manera que el índice
actúa como un contador. Cuando el índice es mayor que el valor final (fin), la
computadora sale automáticamente del loop y transfiere el control a la línea que sigue
después de END DO.
Figura 1.11: Estructura de DOFOR


DOFOR i = inicio, fin, incremento
Conjunto de Sentencias
END DO
Al flujo marcado por un bucle como el descrito, también podría indicarse mediante el
diagrama de flujo siguiente:
Figura 1.12: Diagrama equivalente de DOFOR
Es preciso notar que se puede cambiar los valores de las variables valor inicial, valor
final e incremento dentro del cuerpo del DO, y esos cambios no afectarán al proceso de
variación de la variable índice cuyo valor quedó establecido al principio de la
construcción. Por ejemplo, estaría permitido escribir:
DO i= n, j, 5
.
n = n+2
j = j*3
.
.
END DO
En este código en el que se modifican los valores de n y j dentro del cuerpo del bucle,
no afectará ni al valor que ya tuviera ni a su plan de variación, es decir, al total de
i
repeticiones que, en todo caso, puede conocerse mediante la expresión:

 valor final − valor inicial 
  +1
 incremento 
en la que el símbolo   indica la parte entera del resultado de la fracción que se

encuentra en su interior. Así, al escribir una secuencia como:
DO jota = 2, 12, 3
El total de veces que se repite el cuerpo de ese bucle sería de:
12 − 2 
 3  +1 = 3.33... + 1 = 3 + 1 = 4
 
Si el valor de la expresión anterior fuera nulo, el DO sería inactivo, es decir, no se
ejecutaría ninguna vez.
A la construcción repetitiva DO se le puede adjudicar un nombre, como ya ocurría en las
construcciones de toma de decisiones. En tal caso, ese nombre debe escribirse delante
de la palabra reservada DO y detrás de la sentencia final END DO, así:
nombre DO
.
.
END DO nombre
Esta construcción recibe la denominación de DO con nombre.
1.9.3.3 Bucles DO en Nido

Cuando se da la circunstancia de que dentro del cuerpo del DO, existen, a su vez, otro
u otros bucles DO con sus respectivos rangos, el conjunto de todos esos bucles se dice
que constituyen un conjunto de bucles DO en Nido.
Supongan que tenemos dos vectores de valores: el M con el contenido de los números
enteros: 1, 2, 3, 4, 5, 6, 7 y 8 y el N con el contenido: 1, 2 y 3.
Entonces, para construir una tabla con la suma de cada valor de M con cada valor de N,
podríamos hacerlo empleando dos bucles DO, asÍ:
DO M= 1, 8
DO N=1, 3
Suma = M + N
Print*, ‘La suma es: ‘, Suma
END DO
END DO
El bucle correspondiente a la variable M es el bucle exterior o de primer nivel; el bucle
cuya variable de control es la N es otro bucle dentro del primero o en nido con el
primero y, por lo tanto, de segundo nivel.
La ejecución se realiza así: para M=1, N toma sucesivamente los valores 1, 2 y 3,
dando lugar a los resultado impresos respectivos: 2 3 4
La variable M pasa entonces a valer 2, volviéndose a repetir el bucle interior tomando N
los valores sucesivos 1, 2 y 3, y obteniéndose: 3 4 5
y así sucesivamente hasta que se satisfagan ambos bucles, es decir, hasta que N haya
tomado sus tres valores para cada uno de los ocho valores que debe tomar M.
El total de veces que se ejecutan las sentencias de suma e impresión, será de 8x3 = 24
veces.
Obsérvese, y esto es importante, que todas las sentencias del segundo nivel
pertenecen a su vez, al primer nivel. Esquemáticamente, ese hecho podría
representarse así:
o bien
Otra configuración válida podría representarse así:
La utilización del DO con nombre resulta muy útil cuando e trata de varios bucles Do en
el nido. El ejemplo anterior de la construcción de una tabla con la suma de los
elementos de los vectores M y N, también se podría escribir como sigue:
Nível_1: DO M= 1, 8
Nível_2 DO N=1, 3
Suma = M + N
Print*, ‘La suma es: ‘, Suma
END DO Nivel_2
END DO Nivel_1
Como ya de dijo, uno de los objetivos al emplear las tres estructuras básicas (secuencia
simple, selección y repetición), es realizar programas más fáciles de entender para
aquellos preocupados por el diseño, revisión y mantenimiento.
Sin embargo, es posible combinar las tres estructuras simples para producir una
codificación más compleja conservando, al mismo tiempo, la simplicidad inherente a los
tres patrones. Por ejemplo, la lógica del programa puede involucrar una selección entre
dos rutas del programa. Si se selecciona una ruta, deberá realizarse un ciclo de
repetición; si se selecciona la otra, existe una secuencia simple a realizar. La
combinación de las estructuras se ilustra en la figura 1.13. Obsérvese que sigue
existiendo una sola entrada/salida para toda la estructura.
Esta corta explicación acerca de las tres estructuras proporciona cierta profundización
acerca de su valor en un enfoque disciplinado de programación. Las estructuras son
útiles debido a que:
• El programa se simplifica. Solamente se emplean los tres bloques constructivos.
Existe un solo punto de entrada a cada estructura, así como un solo punto de
salida.
• Las tres estructuras de codificación permiten leer de arriba hacia abajo un
programa, haciendo más visible la lógica del programa para verificación y
mantenimiento.
Figura 1.13: Anidado de estructuras de codificación
1.9.3.4 Construcción DO WHILE

El lenguaje FORTRAN 77 no contenía la construcción DO WHILE. Sin embargo, muchos
compiladores comerciales con extensiones al estándar 77 del FORTRAN, aparecieron
con esta sentencia, cuya forma general es:
DO WHILE (expresión lógica)
Secuencia de sentencias
END DO
en la que la secuencia de sentencias se ejecutará mientras la expresión lógica sea
cierta; se continuará a la instrucción siguiente a la END DO, cuando alcance un valor
falso. Sin embargo, se puede comprobar que esta forma de trabajar equivale a:
DO
IF (.NOT. expresión lógica) EXIT
Secuencia de sentencias
END DO
Un ejemplo de la construcción DO WHILE es:
DO WHILE (indice <= maximo)
indice = indice + 5
mayor = mayor + nuevo
END DO
El Fortran 90 contempla esta construcción para efectuar iteraciones. Pero debido a que
los bucles DO descritos en este capítulo son suficientes para la programación, (…) no
existe la necesidad de su utilización, por lo que no se recomienda su uso, sobre todo
cuando se trate de construir programas nuevos (GARCÍA, 1999, p, 85).

HC I Capitulo1 2010 II Final

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

HC I Capitulo1 2010 II Final

Cargado por

Copyright:

Formatos disponibles

UNMSM – UNIDAD DE POSTGRADO FCF Hidráulica Computacional I 1-1

Maestría en Ingeniería Hidráulica

1.1 0RGANIZACIÓN DE LA COMPUTADORA

Figura 1.1: Principales componentes de una computadora

La memoria principal es denominada también memoria RAM. Este tipo de memoria es

210 KB = 1,024 KB = 1MB (1 megabyte),

Las palabras de una memoria están numeradas desde el 0 correlativamente hasta la

Figura 1.3: Constitución y direccionamiento de una memoria

En cada byte se puede representar, utilizando el sistema binario, un carácter cualquiera,

1.2 ARITMÉTICA DE LA COMPUTADORA3

1.2.2 NOTACIÓN CIENTÍFICA NORMALIZADA

Por ejemplo: 25.801 = 0.25801 × 10 2 , siendo r = 0.25801 , que se encuentra en el intervalo

1.2.3 MANEJO DE NÚMEROS EN LA COMPUTADORA

1.2.3.1 Números Enteros

Figura 1.3: Almacenamiento de números en una palabra de 2 bytes (16 bits)

a) Representar el número -26 en una palabra de 16 bits

1.2.3.2 Números Reales

es decir: 0.11111111 × 2 +111111 . Pero, dado que (111111) 2 = (63)10 y

a) Representar el numero decimal -125.32 en una palabra de 16 bits

La palabra de memoria de 16 bits donde se almacena este valor quedaría así:

b) Representar el numero decimal +0.2 en una palabra de 16 bits

y normalizado quedaría así: .1100110011001100

La palabra de memoria de 16 bits donde se almacena este valor quedaría así:

1.2.3.3 Doble Precisión

1.2.3.4 Error de Redondeo

1.3 MANEJO DE ERRORES EN LA COMPUTADORA

1.4 INSTRUCCIONES PARA LA COMPUTADORA

1.4.1 PROGRAMAS DE APLICACIÓN

La obtención de los mensajes de diagnóstico supone que cada instrucción escrita

Figura 1.4: Visión simplificada del proceso de compilación

Un nuevo compilador del FORTRAN es el HPF (High Performance Fortran), orientado a la

1.4.3 SISTEMA OPERATIVO

1.5 LENGUAJE DE PROGRAMACIÓN

1.5.1 EVOLUCIÓN DE LOS LENGUAJES DE PROGRAMACIÓN

1.5.1.1 Lenguaje de de Máquina

El lenguaje de máquina fue el primer lenguaje utilizado en la programación de

1.5.1.2 Lenguaje Emsamblador

Un programa en lenguaje de ensamblador es relativamente difícil de codificar, y es difícil

Otro ejemplo de programa ensamblador:

INICIO ADD B,1

1.5.1.3 Lenguaje de Alto Nivel

PROGRAMA EN LENGUAJE INSTRUCCIONES A

1.5.1.4 Lenguajes Integrados

1.5.2 COMPILADORES E INTÉRPRETES

1.6 CLASIFICACIÓN DE LOS LENGUAJES DE ALTO NIVEL

1.7 ESTILO DISCIPLINADO Y ESTRUCTURADO EN PROGRAMACIÓN

Objetivos de un Enfoque Disciplinado en la Programación

1.7.1 DISEÑO MODULAR DE PROGRAMAS COMO PARTE DE LA APLICACIÓN

MÓDULO FUNCIONAL DESCRIPCIÓN

Inicialización Establece valores iniciales para algunas variables, imprime encabezados,

Entrada Realiza la entrada de los datos necesarios para el programa.

Procesamiento Realiza cálculos o manejos con los datos.

Salida Realiza la salida de los datos que debe proporcionar el programa.

Manejo de errores Realiza análisis de condición de error y da salida a mensajes de error. En

Procedimiento de cierre Realiza procedimientos para finalizar la ejecución del programa.

Estos módulos reflejan el flujo de un programa de computadora. Después de la

1.7.2 PROGRAMACIÓN ESTRUCTURADA

1.8 PLANEACIÓN DE UN PROGRAMA

1.8.1 PLANEACIÓN DE LA ESTRUCTURA GENERAL DEL PROGRAMA

anteriormente, un programa tiene posibilidades de contener uno o más módulos

1.8.2 El SEUDOCÓDIGO EN LA PLANEACIÓN DE UN PROGRAMA

LEER valores de x e y desde un archivo

1.8.3 DIAGRAMA DE FLUJO EN LA PLANEACIÓN Y DOCUMENTACIÓN DE UN