1

Materia:

Programacion (6Ñ7A)

Trabajo de Desarrollo de:

Unidad I, II, III, IV.

Alumno:

E10020484 - Ortega Siles Horacio Rafael

Profesor:

Ing. Margarito Espinoza Lara

Horario:

10:00 – 11:00 hrs

Especialidad:

Ing. Mecánica

Fecha de entrega:

Lunes 14 de Diciembre del 2015.

2

Contenido1. PROGRAMACIÓN VISUAL (POO).................................................................................................4

1.1 Introducción a la Programación Orientada a eventos..............................................................4

1.2 Programas Secuenciales, Interactivos Y Orientados A Eventos................................................5

1.3 Eventos.....................................................................................................................................5

1.4 Propiedades y Métodos............................................................................................................6

1.5 Visual Significa Visual...............................................................................................................7

1.6 Formularios Y Controles...........................................................................................................8

1.7 Objetos Y Propiedades.............................................................................................................8

1.8 Nombres De Objetos................................................................................................................9

1.9 Orden De Disparo De Eventos................................................................................................10

1.10 Eventos Generales: Carga Y Descarga De Formularios.........................................................11

1.11 KeyPress, KeyUp y KeyDown................................................................................................14

1.12 DragOver y DragDrop...........................................................................................................16

1.13 Agregando Código Al Formulario Y Controlar Eventos.........................................................16

1.14 Conclusión............................................................................................................................17

2. Diseño de Interfaces visuales...................................................................................................17

2.1 Introducción...........................................................................................................................17

2.2 Análisis centrado en el usuario...............................................................................................18

2.3 El escenario............................................................................................................................20

2.4 Aproximaciones al diseño.......................................................................................................22

2.5 Modelo de procesador humano.............................................................................................24

2.6 Modelo de desarrollo de tareas.............................................................................................24

2.7 Modelo objeto–acción sintáctico–semántico (SSOA).............................................................24

2.8 Estructura del modelo conceptual.........................................................................................25

2.9 Análisis de tareas....................................................................................................................26

2.10 Conclusiones........................................................................................................................64

3. Algoritmos para programación en tiempo real......................................................................113

3.1 Introducción...................................................................................................................113

3.2 Justificación....................................................................................................................113

3.3 Motivación.....................................................................................................................113

3.4 Objetivos........................................................................................................................113

3.5 Características de los Algoritmos:...................................................................................116

3

3.6 Ejemplo de Algoritmo:....................................................................................................116

3.7 SISTEMAS DE PROCESAMIENTO DE LA INFORMACIÓN:.................................................117

3.8 CONCEPTO DE ALGORITMO:..........................................................................................118

3.9 Tipos de instrucciones:...................................................................................................119

3.10 Tipos de lenguajes:.........................................................................................................119

3.11 DATOS, TIPOS DE DATOS Y OPERACIONES PRIMITIVAS:.................................................121

3.12 CONSTANTES Y VARIABLES:............................................................................................122

3.13 EXPRESIONES: TIPOS Y OPERADORES:............................................................................123

3.14 FUNCIONES INTERNAS:...................................................................................................127

4

1. PROGRAMACIÓN VISUAL (POO)

El trabajo identificará conceptos de programación orientada al evento confrontándola con lenguajes visuales y orientados a objetos, asimismo, y manejará el ambiente de desarrollo de Visual Basic en la construcción de interfaces gráficas para demostraciones de eventos.

Introducción a la Programación Orientada a eventos.

Los lenguajes visuales orientados al evento y con manejo de componentes dan al usuario que no cuenta con mucha experiencia en desarrollo, la posibilidad de construir sus propias aplicaciones utilizando interfaces gráficas sobre la base de ocurrencia de eventos.

Para soportar este tipo de desarrollo interactúan dos tipos de herramientas, una que permite realizar diseños gráficos y, un lenguaje de alto nivel que permite codificar los eventos. Con dichas herramientas es posible desarrollar cualquier tipo de aplicaciones basadas en el entorno.

Visual Basic es uno de los lenguajes de programación que más entusiasmo despiertan entre los programadores de computadoras, tanto expertos como novatos. En el caso de los programadores expertos por la facilidad con la que desarrollan aplicaciones complejas en poquísimo tiempo (comparado con lo que cuesta programar en Visual C++, por ejemplo). En el caso de los programadores novatos por el hecho de ver de lo que son capaces a los pocos minutos de empezar su aprendizaje. El precio que hay que pagar por utilizar Visual Basic es una menor velocidad o eficiencia en las aplicaciones.

Visual Basic es un lenguaje de programación visual, también llamado lenguaje de 4ta. Generación. Esto quiere decir que un gran número de tareas se realizan sin escribir código, simplemente con operaciones gráficas realizadas con el ratón sobre la pantalla.

Visual Basic es también un programa basado en objetos, aunque no orientado a objetos como Visual C++. La diferencia está en que Visual Basic utiliza objetos con propiedades y métodos, pero carece de los mecanismos de herencia y polimorfismo propios de los verdaderos lenguajes orientados a objetos como Java y C++. En este trabajo se presentará las características generales de Visual Basic, junto con algunos ejemplos sencillos que den idea de la potencia del lenguaje orientado a eventos, y del modo en que se utiliza.

5

Programas Secuenciales, Interactivos Y Orientados A Eventos 

Existen distintos tipos de programas. En los primeros tiempos de los ordenadores los programas eran de tipo secuencial (también llamados tipo batch). Un programa secuencial es un programa que se arranca, lee los datos que necesita, realiza los cálculos e imprime o guarda en el disco los resultados. De ordinario, mientras un programa secuencial está ejecutándose no necesita ninguna intervención del usuario. A este tipo de programas se les llama también programas basados u orientados a procedimientos o a algoritmos (procedural languages). Este tipo de programas siguen utilizándose ampliamente en la actualidad, pero la difusión de los PC’s ha puesto de actualidad otros tipos de programación.

Los programas interactivos exigen la intervención del usuario en tiempo de ejecución, bien

para suministrar datos, bien para indicar al programa lo que debe hacer por medio de menús. Los programas interactivos limitan y orientan la acción del usuario.

Por su parte los programas orientados a eventos son los programas típicos de Windows, tales como Netscape, Word, Excel, PowerPoint y otros. Cuando uno de estos programas ha arrancado, lo único que hace es quedarse a la espera de las acciones del usuario, que en este caso son llamadas eventos.

El usuario dice si quiere abrir y modificar un fichero existente, o bien comenzar a crear un fichero desde el principio. Estos programas pasan la mayor parte de su tiempo esperando las acciones del usuario (eventos) y respondiendo a ellas. Las acciones que el usuario puede realizar en un momento determinado son variadísimas, y exigen un tipo especial de programación: la programación orientada a eventos. Este tipo de programación es sensiblemente más complicada que la secuencial y la interactiva, pero con los lenguajes visuales de hoy, se hace sencilla y agradable.

Antes de continuar es necesario definir algunos conceptos de los elementos de Programación Orientada a Eventos.

Eventos.

Ya se ha dicho que las acciones del usuario sobre el programa se llaman eventos. Son eventos típicos el click sobre un botón, el hacer doble click sobre el nombre de un fichero para abrirlo, el arrastrar un icono, el pulsar una tecla o combinación de teclas, el elegir una opción de un menú, el escribir en una caja de texto, o simplemente mover el ratón. Más adelante se verán los distintos tipos de eventos reconocidos por Windows 95 y por Visual Basic. Cada vez que

6

se produce un evento sobre un determinado tipo de control, Visual Basic arranca una determinada función o procedimiento que realiza la acción programada por el usuario para ese evento concreto. Estos procedimientos se llaman con un nombre que se forma a partir del nombre del objeto y el nombre del evento, separados por el carácter (_), como por ejemplo txtBox_click, que es el nombre del procedimiento que se ocupará de responder al evento click en el objeto txtBox.

 Propiedades y Métodos.

Además de los eventos, la mayor parte de los objetos, como los formularios y los controles, son suministrados con propiedades y métodos. Son conceptos fundamentales e importantes.

Propiedades.

Una propiedad es una asignación que describe algo sobre un objeto como un formulario. Dependiendo de la propiedad, se la puede asignar en tiempo de diseño usando la ventana Propiedades y/o en tiempo de ejecución al programar.

A continuación se describen dos ejemplos de las propiedades del formulario de Visual Basic:

MinButton. Esta propiedad puede asignarse como TRUE (verdadero) o FALSE (falso). Dependiendo de la asignación, el formulario tendrá o no tendrá un botón minimizar.

BackColor. Asignando esta propiedad a un valor expresado como hexadecimal RGB (Rojo Verde Azul) o como una constante se cambia el color del fondo del formulario. Se pueden consultar las constantes usando el examinador de objetos (Seleccione VER, EXAMINADOR DE OBJETOS) y en la Biblioteca VBRUN (Columna clase) bajo "ColorConstants" y "SystemColorConstants".

Métodos.Los métodos son funciones que también son llamadas desde programa, pero a diferencia de los procedimientos no son programadas por el usuario, sino que vienen ya pre-programadas con el lenguaje. Los métodos realizan tareas típicas, previsibles y comunes para todas las aplicaciones. de ahí que vengan con el lenguaje y que se libere al usuario de la tarea de programarlos. Cada tipo de objeto o de control tiene sus propios métodos.En general solo pueden ser ejecutados en tiempos de ejecución no en tiempo de diseño. Algunos ejemplos de métodos de formularios son el método MOVE,

7

que mueve un formulario en un espacio de dos dimensiones en la pantalla, y el método ZORDER que sitúa el formulario delante o detrás de otras ventanas.

Los métodos son invocados dando nombres al objeto y cuyo método se está llamando, listando el operador punto (.), y después listando el nombre del método. Como cualquier rutina los métodos pueden incorporar argumentos por ejemplo:

Form1.Show 1

Este método Show carga y muestra un formulario, dos acciones distintas que forman ambas partes del proceso de nacimiento o inicio a un formulario (al ejecutar el formulario de inicio se carga también primero el formulario y después se muestra). El método Show puede ser invocado como no modal o modal. Modal significa que no se ejecuta ningún código posterior hasta que el formulario se oculte o se descargue. Cuando se muestra un formulario modal no se puede producir ninguna entrada de usuario (de teclado o click del ratón) excepto para los objetos del formulario modal. Si se activa el estilo 1 (uno) es modal y 0 (cero) es no modal.  

Visual Significa Visual.Como el nombre lo indica, una gran parte de la programación con Visual Basic se realiza visualmente. Esto significa que durante el tiempo de diseño usted tiene la capacidad de ver la forma en el programa se vera al ejecutarse Esta es una gran ventaja sobre otros lenguajes de programación debido a que se tiene la capacidad de cambiar y experimentas con el diseño hasta que se esté satisfecho con los colores, proporciones e imágenes que incluya en su programa.Programas Para El Entorno Windows.

Visual Basic está orientado a la realización de programas para Windows, pudiendo incorporar todos los elementos de este entorno informático: ventanas, botones, cajas de diálogo y de texto, botones de opción y de selección, barras de desplazamiento, gráficos, menús, etc. Prácticamente todos los elementos de interacción con el usuario de los que dispone Windows 95 pueden ser programados en Visual Basic de un modo extraordinariamente sencillo. En ocasiones bastan unas pocas operaciones con el ratón y la introducción a través del teclado de algunas sentencias para disponer de aplicaciones con todas las características de Windows 95. Modo De Diseño Y Modo De Ejecución.La aplicación Visual Basic de Microsoft puede trabajar de dos modos distintos: en modo de diseño y en modo de ejecución. En modo de diseño el usuario construye interactivamente la aplicación, colocando controles en el formulario,

8

definiendo sus propiedades, desarrollando funciones para gestionar los eventos. La aplicación se prueba en modo de ejecución. En ese caso el usuario actúa sobre el programa (introduce eventos) y prueba cómo responde el programa. Hay algunas propiedades de los controles que deben establecerse en modo de diseño, pero muchas otras pueden cambiarse en tiempo de ejecución desde el programa escrito en Visual Basic, en la forma en que más adelante se verá. También hay propiedades que sólo pueden establecerse en modo de ejecución y que no son visibles en modo de diseño.

Formularios Y Controles

Cada uno de los elementos gráficos que pueden formar parte de una aplicación típica de Windows 95 es un tipo de control: los botones, las cajas de diálogo y de texto, las cajas de selección desplegables, los botones de opción y de selección, las barras de desplazamiento horizontales y verticales, los gráficos, los menús, y muchos otros tipos de elementos son controles para Visual Basic. Cada control debe tener un nombre a través del cual se puede hacer referencia a él en el programa. Visual Basic proporciona nombres por defecto que el usuario puede modificar.

En la terminología de Visual Basic se llama formulario (form) a una ventana. Un formulario puede ser considerado como una especie de contenedor para los controles. Una aplicación puede tener varios formularios, pero un único formulario puede ser suficiente para las aplicaciones más sencillas. Los formularios deben también tener un nombre, que puede crearse siguiendo las mismas reglas que para los controles.

Objetos Y Propiedades.Los formularios y los distintos tipos de controles son entidades genéricas de las que puede haber varios ejemplares concretos en cada programa. En programación orientada a objetos (más bien basada en objetos, habría que decir) se llama clase a estas entidades genéricas, mientras que se llama objeto a cada ejemplar de una clase determinada. Por ejemplo, en un programa puede varios botones, cada uno de los cuales es un objeto del tipo de control command button, que sería la clase.

Cada formulario y cada tipo de control tienen un conjunto de propiedades que definen su aspecto gráfico (tamaño, color, posición en la ventana, tipo y tamaño de letra, etc.) y su forma de responder a las acciones del usuario (si está activo o no, por ejemplo). Cada propiedad tiene un nombre que viene ya definido por el lenguaje.

9

Por lo general, las propiedades de un objeto son datos que tienen valores lógicos (true, false) o numéricos concretos, propios de ese objeto y distintos de las de otros objetos de su clase. Así pues, cada clase, tipo de objeto o control tiene su conjunto de propiedades, y cada objeto o control concreto tiene unos valores determinados para las propiedades de su clase.

Casi todas las propiedades de los objetos pueden establecerse en tiempo de diseño y también -casi siempre- en tiempo de ejecución. En este segundo caso se accede a sus valores por medio de las sentencias del programa, en forma análoga a como se accede a cualquier variable en un lenguaje de programación. Para ciertas propiedades ésta es la única forma de acceder a ellas. Por supuesto Visual Basic permite crear distintos tipos de variables, como más adelante se verá.

Se puede acceder a una propiedad de un objeto por medio del nombre del objeto a que pertenece, seguido de un punto y el nombre de la propiedad, como por ejemplo optColor.objName.

Nombres De ObjetosEn principio cada objeto de Visual Basic debe tener un nombre, por medio del cual se hace referencia a dicho objeto. El nombre puede ser el que el usuario desee, e incluso Visual Basic proporciona nombres por defecto para los diversos controles. Estos nombres por defecto hacen referencia al tipo de control y van seguidos de un número que se incrementa a medida que se van introduciendo más controles de ese tipo en el formulario (por ejemplo VScroll1, para una barra de desplazamiento -ScrollBar- vertical, HScroll1, para una barra horizontal, etc.).Los nombres por defecto no son adecuados porque hacen referencia al tipo de control, pero no al uso que de dicho control está haciendo el programador. Por ejemplo, si se utiliza una barra de desplazamiento para introducir una temperatura, conviene que su nombre haga referencia a la palabra temperatura, y así cuando haya que utilizar ese nombre se sabrá exactamente a qué control corresponde. Un nombre adecuado sería por ejemplo hsbTemp, donde las tres primeras letras indican que se trata de una horizontal scroll bar, y las restantes (empezando por una mayúscula) que servirá para definir una temperatura.Existe una convención ampliamente aceptada que es la siguiente: se utilizan siempre tres letras minúsculas que indican el tipo de control, seguidas por otras letras (la primera mayúscula, a modo de separación) libremente escogidas por el usuario, que tienen que hacer referencia al uso que se va a dar a ese control. La Tabla 1.1 muestra las abreviaturas de los controles más usuales, junto con la nomenclatura inglesa de la que derivan.  

10

Abrebiatura Control Abrebiatura Control

chk check box cbo combo y drop-list box

Cmd command button

dir dir list box

drv drive list box fil file list box

frm form fra Frame

hsb horizontal scroll bar

img Image

lbl label lin Line

lst list mnu Menu

opt option button pic Picture

shp shape txt text edit box

tmr timer vsb vertical scroll barTabla 1.1. Abreviaturas para los controles más usuales  

Orden De Disparo De Eventos.Para controlar con éxito la aparición y el comportamiento de los formularios (y también de los controles) en tiempos de ejecución, debe comprenderse en que orden se disparan los eventos. Las consideraciones del orden de disparo de los eventos deciden generalmente por el usuario donde debe ser colocada una parte determinada de código de respuesta de un evento. Los eventos de formularios pueden ser divididos en los grupos siguientes:

Inicio. Respuesta a una acción (de usuario). Vinculación. Cierre.

Es importante también comprender que un evento inicia automáticamente con frecuencia a otro evento, produciendo un efecto en cascada. Por ejemplo un evento KeyPress no puede ser disparada sin disparar también lo eventos KeyUp y KeyDown. El secreto para trabajar con esta clase de situaciones es una comprensión clara de que es lo que dispara cada evento en la secuencia; el peligro de la codificación es iniciar un cadena sin fin de llamada a eventos circulares recursivos.

11

Eventos Generales: Carga Y Descarga De FormulariosCuando se arranca una aplicación, o más en concreto cuando se visualiza por primera vez un formulario se producen varios eventos consecutivos: Initialize, Load, Activate y Paint. Cada uno de estos eventos se puede aprovechar para realizar ciertas operaciones por medio de la función correspondiente.

Para inicializar las variables definidas a nivel de módulo se suele utilizar el evento Initialize, que tiene lugar antes que el Load. El evento Load se activa al cargar un formulario. Con el formulario principal esto sucede al arrancar la ejecución de un programa; con el resto de los formularios al mandarlos cargar desde cualquier procedimiento o al hacer referencia a alguna propiedad o control de un formulario que no esté cargado. Al descargar un formulario se produce el evento Unload. Si se detiene el programa desde el botón Stop de Visual Basic (o del menú correspondiente) o con un End, no se pasa por el evento Unload. Para pasar por el evento Unload es necesario cerrar la ventana con el botón de cerrar o llamarlo explícitamente. El evento QueryUnload se produce antes del evento Unload y permite por ejemplo enviar un mensaje de confirmación.

QueryUnload. Se dispara por un evento Unload de formulario, antes de que se ejecute ningún código del evento Unload. QueryUnload da la oportunidad de detener la descarga del formulario de la memoria cuando sea apropiado, por ejemplo, cuando el usuario haya cambiado valores del formulario sin guardar los cambios. El formulario no será descargado si la variable Cancel está asignada como True en el procedimiento del evento QueryUnload. Es una práctica común asignar esta variable como True a continuación de una consulta del usuario a lo largo de las líneas de "¿Guardar los cambios? Sí, No, Cancelar" cuando el usuario responde cancelando. La función MsgBox puede usarse fácilmente para dar al usuario una oportunidad de cancelar una descarga.Unload. Se dispara cuando un usuario cierra el formulario usando el comando Cerrar en el menú Control o cuando se ejecuta en código un método Unload. Unload dispara inmediatamente un evento QueryUnload como acabamos de describir. Se pude usar el evento Unload (así como QueryUnload) para realizar tareas de cierre como guardar y convalidar datos. Terminate. Se produce cuando se eliminan de la memoria todas las referencia a una instancia de un formulario.

El evento Load de un formulario se suele utilizar para ejecutar una función que dé valor a sus propiedades y a las de los controles que dependen de dicho formulario. No se puede utilizar para dibujar o imprimir sobre el formulario, pues en el momento en que se produce este evento el formulario todavía no está disponible para dichas operaciones. Por ejemplo, si en el formulario debe aparecer la salida del método Print o de los métodos gráficos Pset, Line y

12

Circle puede utilizarse el evento Paint u otro posterior (por ejemplo, el evento GotFocus del primer control) pero no puede utilizarse el evento Load. Se puede ocultar un formulario sin descargarlo con el método Hide o haciendo la propiedad Visible = False. Esto hace que el formulario desaparezca de la ventana, aunque sus variables y propiedades sigan estando accesibles y conservando sus valores. Para hacer visible un formulario oculto pero ya cargado se utiliza el método Show, que equivale a hacer la propiedad Visible = True, y que genera los eventos Activate y Paint. Si el formulario no había sido cargado previamente, el método Show genera los cuatro eventos mencionados.

Cuando un formulario pasa a ser la ventana activa se produce el evento Activate y al dejar de serlo el evento Deactivate. En el caso de que el formulario que va a ser activo no estuviera cargado ya, primero sucederían los eventos Initialize, Load y luego los eventos Activate y Paint. Se han de crear dos formularios (frmPrincipal y frmSecundario). El primero de ellos contendrá dos botones (cmdVerSec y cmdSalir) y el segundo tres (cmdHide, cmdUnload y cmdTerminate). El formulario principal será el primero que aparece, y sólo se verá el segundo si se clica en el botón Cargar Formulario. Cuando así se haga, a medida que los eventos antes mencionados se vayan sucediendo, irán apareciendo en pantalla unas cajas de mensajes que tendrán como texto el nombredel evento que se acaba de producir. Según con cual de los tres botones se haga desaparecer el segundo formulario, al volverlo a ver se producirán unos eventos u otros, según se puede ver por los mensajes que van apareciendo con cada evento. ' código del form. principalPrivate Sub cmdCargar_Click()frmSecundario.ShowEnd Sub' código del form. secundarioPrivate Sub cmdHide_Click()HideEnd SubPrivate Sub cmdUnload_Click()Unload MeEnd Sub  Private Sub cmdTerminate_Click()HideSet Form2 = NothingEnd SubPrivate Sub Form_Activate()MsgBox ("Evento Activate")End Sub

13

Private Sub Form_Deactivate()MsgBox ("Evento Deactivate")End SubPrivate Sub Form_Initialize()MsgBox ("Evento Initialize")End SubPrivate Sub Form_Load()MsgBox ("Evento Load")End SubPrivate Sub Form_Paint()MsgBox ("Evento Paint")End SubPrivate Sub Form_QueryUnload(Cancel As Integer, UnloadMode As Integer)MsgBox ("Evento QueryUnload")End SubPrivate Sub Form_Terminate()MsgBox ("Evento Terminate")End SubPrivate Sub Form_Unload(Cancel As Integer)MsgBox ("Evento Unload")End Sub Es muy interesante realizar este ejemplo y seguir la secuencia de eventos que se producen al hacer aparecer y desaparecer los formularios.Paint.

El evento Paint sucede cuando hay que redibujar un formulario o PictureBox. Esto sucede cuando esos objetos se hacen visibles después de haber estado tapados por otros, tras haber sido movidos otras haber sido modificados de tamaño.El foco (focus)En todas las aplicaciones de Windows, en cualquiera de sus versiones, siempre hay un único control, formulario o ventana que puede recibir clicks del ratón o entradas desde teclado. En cada momento ese control, ventana o formulario es el que dispone del "foco" (focus). El objeto que posee el foco está caracterizado por estar resaltado con letra negrita, con un contorno más vivo o teniendo parpadeando el cursor en él. Este foco puede ser trasladado de un objeto a otro por código o por interacciones del usuario, como por ejemplo clicando con el ratón en distintos puntos de la pantalla o pulsando la tecla Tab. Cada vez que un objeto pierde el foco se produce su evento LostFocus y, posteriormente, el evento GotFocus del objeto que ha recibido el foco.Dos propiedades de muchos controles relacionadas con el foco son TabIndex y TabStop.

14

TabStop determina si el foco se va o no a posar en el objeto al pulsar la tecla Tab (si TabStop está a False no se puede obtener el foco mediante el tabulador) y TabIndex determina el orden en el que esto va a suceder. Así al cargar un formulario, el foco estará en aquel objeto cuyo TabIndex sea 0.Al pulsar la tecla Tab el foco irá al objeto que tenga TabIndex = 1 y así sucesivamente. Para retroceder en esta lista se pulsa Mayúsculas+Tab. La propiedad TabIndex se puede determinar en tiempo de diseño por medio de la caja de propiedades, del modo habitual. Cuando a un control se le asigna un determinado valor de TabIndex, Visual Basic ajusta automáticamente los valores de los demás controles (si tiene que desplazarlos hacia arriba o hacia abajo, lo hace de modo que siempre tengan números consecutivos). Para que un formulario reciba el foco es necesario que no haya en él ningún control que sea capaz de recibirlo. Un grupo de botones de opción tiene un único TabIndex, es decir, se comporta como un único control. Para elegir una u otra de las opciones se pueden utilizar las .yflechas del teclado  

KeyPress, KeyUp y KeyDown.El evento KeyPress sucede cuando el usuario pulsa y suelta determinada tecla. En este evento el único argumento KeyAscii es necesario para conocer cuál es el código ASCII de la tecla pulsada. El evento KeyDown se produce cuando el usuario pulsa determinada tecla y el evento KeyUp al soltar una tecla.Los eventos KeyUp y KeyDown tienen un segundo argumento llamado Shift que permiten determinar si esa tecla se ha pulsado estando pulsadas a la vez cualquier combinación de las teclas Shift, Alt y Ctrl. En un apartado próximo se explica cómo se identifican las teclas pulsadas a partir del argumento Shift.Eventos Relacionados Con El Ratón. Click y DblClick.El evento Click se activa cuando el usuario pulsa y suelta rápidamente uno de los botones del ratón. También puede activarse desde código (sin tocar el ratón) variando la propiedad Value de uno de los controles. En el caso de un formulario este evento se activa cuando el usuario clica sobre una zona del formulario en la que no haya ningún control o sobre un control que en ese momento esté inhabilitado (propiedad Enabled = False). En el caso de un control, el evento se activa cuando el usuario realiza una de las siguientes operaciones:

Clicar sobre un control con el botón derecho o izquierdo del ratón. En el caso de un botón de comando, de un botón de selección o de un botón de opción, el evento sucede solamente al darle un click con el botón izquierdo.

Seleccionar un registro de alguno de los varios tipos listas desplegables que dispone Visual Basic.

Pulsar la barra espaciadora cuando el foco está en un botón de comando, en un botón de selección o en un botón de opción.

15

Pulsar la tecla Return cuando en un formulario hay un botón que tiene su propiedad Default = True.

Pulsar la tecla Esc cuando en un formulario hay un botón que tiene su propiedad Cancel = True.

Pulsar una combinación de teclas aceleradoras (Alt + otra tecla, como por ejemplo cuando de despliega el menú File de Word con Alt+F) definidas para activar un determinado control de un formulario.

También se puede activar el evento Click desde código realizando una de las siguientes operaciones:

Hacer que la propiedad Value de un botón de comando valga True. Hacer que la propiedad Value de un botón de opción valga True Modificar la propiedad Value de un botón de selección.

El evento DblClick sucede al clicar dos veces seguidas sobre un control o formulario con el botón izquierdo del ratón.MouseDown, MouseUp y MouseMove.

El evento MouseDown sucede cuando el usuario pulsa cualquiera de los botones del ratón, mientras que el evento MouseUp sucede al soltar un botón que había sido pulsado. El evento MouseMove sucede al mover el ratón sobre un control o formulario.

Los eventos MouseUp y MouseDown tienen algunos argumentos que merecen ser comentados. El argumento Button indica cuál de los botones del ratón ha sido pulsado o soltado, y el argumento Shift indica si además alguna de las teclas alt, shift o ctrl está también pulsada. La lista con todos los posibles valores de estos argumentos se muestra abajo.

Cte simbólica Valor Acción Cte simbólica Valor AcciónvbLeftButton 1 Botón izdo pulsado o soltado vbShiftMask 1 Tecla SHIFT pulsadavbRightButton 2 Botón dcho pulsado o soltado vbCtrlMask 2 Tecla CTRL pulsadavbMiddleButton 4 Botón central pulsado o soltado vbAltMask 4 Tecla ALT pulsadaValores de los argumentos de los eventos MouseUp y MouseDownCon estos valores se aplica la aritmética booleana, lo cual quiere decir que si se pulsan simultáneamente los botones izquierdo y derecho del ratón el argumento Button valdrá 3 (1+2) y si se pulsan las tres teclas shift, ctrl y alt simultáneamente el argumento Shift valdrá 7 (1+2+4).

16

DragOver y DragDrop.El evento DragOver sucede mientras se está arrastrando un objeto sobre un control. Suele utilizarse para variar la forma del cursor que se mueve con el ratón dependiendo de si el objeto sobre el que se encuentra el cursor en ese momento es válido para soltar o no. El evento DragDrop sucede al concluir una operación de arrastrar y soltar. El evento DragOver requiere de los argumentos que se muestran a continuación:Private Sub Text1_DragOver(Source As Control, _X As Single, Y As Single, State As Integer)...End SubLos argumentos de este evento son Source que contiene el objeto que está siendo arrastrado, X e Y que indican la posición del objeto arrastrado dentro del sistema de coordenadas del objeto sobre el que se está arrastrando y State (que es propio del DragOver, pero no aparece en el DragDrop) que vale 0, 1 ó 2 según se esté entrando, saliendo o permaneciendo dentro del mismo objeto, respectivamente. Es importante señalar que el evento DragOver es propio del objeto sobre el que se arrastra, no del objeto que es arrastrado. 

Agregando Código Al Formulario Y Controlar Eventos.Se han mostrados ya las formas generales en las que se agrega código ejecutable a los procesos que controlan eventos. Es importante, sin embargo, revisar explícitamente cómo acceder al marco propio de los eventos en el cual se sitúa ese código. Esto le permitirá escoger la forma más rápida y fácil de acceder al marco de control de los eventos que necesita para agregar su código. Una vez que aceda al procedimiento adecuado para el manejo de los eventos, puede agregar código con sólo teclearlo en la ventana Código, como hemos mostrado en los ejemplos anteriormente. Las prácticas herramientas del lenguaje le ayudan a encontrar la sintaxis real en cualquier situación.Es importante tener en cuenta, como hemos señalado antes, que el código realcionado con un procedimiento de control de eventos consistirá con frecuencia simplemente en llamadas a procedimientos. En este caso los procedimientos llamados contendrán el código real ejecutable. Una razón para diseñar un programa de esta forma es que el mismo procedimiento puede ser llamado desde diferentes controladores de eventos, simplificando así, abreviando y aclarando la arquitectura del programa. Una técnica común es pasar a un procedimiento llamado desde un controlador de eventos un parámetro que indique qué controlador lo ha llamado. La ejecución en el procedimiento le ha llamado (determinado por el parámetro).A continuación se indican las tres formas de "alcanzar" un marco de procedimiento para el manejo de eventos:

17

Asegúrese de que esté abierta la ventana Proyecto ( si es necesario, seleccione el Explorador de proyectos en el menú Ver). Seleccione el formulario al que desee agregar código de eventos. (Si está agregando un evento a un control que ha sido situado en un formulario, seleccione al formulario que se encuentre en el "padre" del control.) Haga click en el botón Ver código. (También puede hacer click con el botón derecho en el icono del formulario y seleccionar Ver Código en el menú de contexto.) En el cuadro de lista Objeto, seleccione el formulario o bien otro objeto (por ejemplo, un control) al cual desee agregar código de evento. A continuación, desde el cuadro de lista Procedimiento, seleccione el controlador del procedimiento al que va a agregar código. Observe que los procedimientos controladores de código con código adjunto están en negrita en el cuadro de lista Procedimiento, mientras que los que no tienen código adjunto no lo están.

Conclusión.La Programación Orientada a Eventos facilita el proceso de programación visual por su practicidad al generar rápidamente algunas aplicaciones basadas en objetos visuales. Ayuda al programador novato en el rápido aprendizaje de desarrollo de nuevos programas con alta calidad en muy poco tiempo. 

2. Diseño de Interfaces visuales

IntroducciónLos sistemas interactivos se caracterizan por la importancia del diálogo con el usuario. La interfaz de usuario es por tanto, una parte fundamental en el proceso de desarrollo de cualquier aplicación y por tanto se tiene que tener en cuenta su diseño desde el principio. La interfaz es la parte (hardware y software) del sistema informático que facilita al usuario el acceso a los recursos del ordenador. En este sentido, THIMBLEBY [THI90] sugiere que la interfaz determinará en gran medida la percepción e impresión que el usuario poseerá de la aplicación. El usuario no está interesado en la estructura interna de la aplicación, sino en cómo usarla. No se puede realizar la especificación, diseñar las funciones y estructuras de datos y es-cribir el código y una vez casi terminado el proceso de desarrollo de la aplicación plantearse el diseño de la interfaz de usuario. Siguiendo esta forma de trabajo lo mas seguro es que se obtengan diseños de interfaces muy dependientes de los diseños que se han

18

realizado de las datos y de las funciones, sin tener en cuenta que esos datos han de ser obtenidos y representados por y para el usuario.

Una vez tenemos hecha la especificación, propuesto un diseño y el código está im-plantado, es muy difícil cambiar las características de la interacción y presentación de la información, excepto pequeñas cosas. Por tanto, deberemos empezar con un idea clara de cómo queremos la interfaz y como serán las interacciones con el usua-rio para después, desarrollar las especificaciones funcionales que sirvan de guía al diseño posterior.

En el desarrollo de aplicaciones interactivas se podrán aplicar las técnicas de la in-geniería de software, pero teniendo en cuenta que hemos de modificar algunos as-pectos de los métodos de diseño clásico para adaptarlos a las peculiaridades de es-tos sistemas. Hay que tener en cuenta que un aspecto fundamental es el análisis y diseño de la parte interactiva, y que para realizarlo, necesitaremos aplicar de técni-cas de análisis y diseño específicas.

El desarrollo de un sistema interactivo deberá tener en cuenta a los participantes que van a intervenir en el mismo: el usuario, que posee la capacidad de elección y actuación, la computadora, que ofrece un programa y mecanismos para su acceso, y el diseñador, el encargado de anticipar las posibles acciones del usuario y codificarlas en el programa. Todo ello se articula a través de la interfaz de Usuario de la aplicación.

La tendencia hacia interfaces de usuarios fáciles de usar provoca que su diseño sea cada vez más complejo. La interfaz de usuario, como medio de comunicación entre el humano y la computadora se caracteriza por su apariencia (presentación) y su capacidad de gestión del diálogo. Podemos encontrar multitud de productos que permiten la descripción y generación automática de la apariencia externa de una aplicación mediante la utilización de paletas de recursos (botones, menús, etc.) herramientas visuales, toolkits, etc. Sin embargo, estas herramientas no suministran suficiente ayuda en el análisis del comportamiento dinámico de la interfaz, en su descripción y sobre todo, no aseguran su corrección. A continuación introduciremos una aproximación de ingeniería para el diseño de sistemas interacti-vos.

Análisis centrado en el usuarioEl diseño de un sistema interactivo debe satisfacer las demandas de los usuarios que lo van a utilizar. El ordenador es una herramienta para realizar un determinado trabajo o actividad, y para que sea una buena herramienta, deberá ser adecuada, cómoda y eficiente para realizar estos cometidos. Para lograr un buen diseño, deberemos partir de un análisis profundo del contexto donde se desarrolla el trabajo [HAC98]. Para ello deberemos analizar las características del usuario, las actividades que realiza y el escenario donde se desempeña su actividad. Todos estos factores permitirán conocer los requisitos que se deben satisfacer en el diseño del sistema.

19

Los usuarios

En primer lugar, a la hora de diseñar el sistema, deberemos tener en cuenta las peculiaridades de los usuarios potenciales del mismo. Esta necesidad de incorporar el factor humano en el diseño viene dada por el reconocimiento del mal diseño que se ha hecho en gran cantidad de aplicaciones y el deseo de crear productos que ayuden de forma efectiva al usuario. Además, la características de los usuarios pueden afectar al modo de trabajo y condicionar el proceso de comunicación con el sistema. Por ejemplo, los factores humanos pueden condicionar el tiempo de aprendizaje, el rendimiento (tiempo para realizar una tarea), la frecuencia de errores cometidos, grado de retención (memoria de uso) o de satisfacción del usuario. A la hora de di-señar la aplicación, se puede realizar por encargo directo (por lo que existe un clien-te), o bien, dirigirlo a un colectivo más o menos amplio de potenciales usuarios (ni-ños, profesionales, estudiantes, etc.).

El análisis del usuario implica conocer aspectos tales como:

• Habilidades físicas y sensoriales. Estas habilidades determinarán en gran medida la adaptación del entorno de trabajo a las características del usuario (tamaño de los botones, tipo de dispositivos, etc.). Podemos encontrar ca-sos en los que el diseño debe ser preferentemente ergonómico por las limi-taciones en movilidad de los usuarios, como por ejemplo, la discapacidad por parálisis cerebral, o tener en cuenta pequeñas alteraciones como por ejemplo el daltonismo (ver capítulo ‘Accesibilidad’).

• Habilidades cognitivas. Estas diferencias en la capacidad de razonamiento y conocimiento están motivadas por el grado de experiencia que posee el usuario tanto de su propio trabajo como del uso del ordenador como herra-mienta. Podemos tener una gran variedad de usuarios desde los expertos a los noveles, usuarios cotidianos u ocasionales, motivados o no, etc.

• Diferencias de personalidad. Las diferencias en la personalidad puede provocar alteraciones en la propia comunicación. Así, personas tímidas ten-drán un comportamiento más cauto y prudente ante el ordenador que una persona extrovertida y nerviosa.

• Diferenciación cultural. También podemos encontrar diferencias moti-vadas por el entorno socio–cultural donde se encuentra el usuario, que puede afectar al lenguaje utilizado, expresiones y terminología, modo de trabajar, etc. (ver capítulo ‘Internacionalización’)

Este conjunto de características relevantes de los usuarios serán de gran ayuda en las etapas posteriores de diseño. Para ello, podemos partir de una tabla en la cual se recoja los distintos tipos de usuarios (secretaria, director,

20

técnico..) y sus caracte-rísticas relevantes (grado de utilización del sistema, nivel de experiencia, etc.).

Las tareas

Otro factor importante a tener en cuenta en el diseño son las tareas que realizan los usuarios. Nuestra forma de actuar está dirigida por objetivos (goals) como se recoge en el modelo de NORMAN (ver capítulo ‘El factor humano’). Para lograr ese objetivo (por ejemplo comer), debemos llevar a cabo una serie de actividades (encender, coger, poner...) sobre unos objetos (microondas, pizza, temporizador...) encaminadas a lograr ese objetivo. A la hora de realizar estas tareas mediante un sistema interactivo deberemos tener en cuenta que sigan siendo familiares al usuario, es decir, la forma de llevarlas a cabo, su representación así como la se-cuencia de acciones debe ser similar a la que realiza en el entorno real. Si esto no se satisface, el usuario requerirá un esfuerzo adicional para comprender las tareas que realiza cotidianamente.

El escenarioLas personas no realizan su trabajo de forma aislada, sino que se ven condicionadas por el escenario donde se desempeña esta labor. Los aspectos más relevante a te-ner en cuenta son:

• Entorno físico. El entorno es fundamental para poder trabajar. Deberemos prestar atención a las características ergonómicas del mismo (tipo de ubica-ción, iluminación, espacio, etc.) así como las peculiaridades del entorno (rui-do, polución, calor, etc.). Puede haber casos de especial importancia como sitios de alto riesgo (central nuclear) o condiciones extremas (submarino, aeronave..)

• Entorno social. El entorno social implica el trabajo dentro de un grupo don-de existen unas normas de comportamiento. Podemos encontrar situaciones en las cuales pueda haber cooperación para el trabajo (ayuda), compartir datos o recursos, dependencias jerárquicas, etc.

Algunas de estas características pueden condicionar el diseño, ya que un trabajo en equipo fuertemente acoplado (con alto nivel de cooperación y compartición de datos) requerirá de una aplicación groupware para trabajo en grupo (ver capítulo ‘Trabajo cooperativo con ordenador’).

2 Ciclo de vida de la interfaz de usuario

La construcción de un sistema interactivo implica un proceso cíclico de diseño, desa-rrollo y evaluación. La realimentación que proporciona la evaluación sobre el diseño es fundamental para refinar y pulir aspectos que son muy dependientes de los usua-rios finales (el factor humano) una vez que el sistema se ha puesto en marcha. En la siguiente figura se muestran algunas de las peculiaridades de ciclo de vida como son la importancia del usuario (tanto en la

21

fase de análisis como de evaluación) y la naturaleza cíclica del diseño (con continua realimentación a partir de la evaluación).

Las primeras interfaces las realizaban los propios programadores para los progra-mas que ellos mismos utilizaban. Sin embargo, los diseños deben ir dirigidos a usuarios con diferentes habilidades, y no necesariamente tienen que ser expertos en informática. Los ordenadores son herramientas con las cuales las personas pueden realizar sus tareas, por lo que deberemos tener esto en cuenta a la hora del diseño, ya que si el usuario percibe que algo es difícil de usar, cometerá errores, o bien no realizará la tarea adecuadamente. Para que esto no suceda, es muy importante basar el diseño del sistema sobre aquellos conceptos que maneja el usuario y fundamentarse sobre criterios consistentes y fundamentos teóricos y no en meros juicios intuitivos.

Un buen diseño depende del conocimiento (fundamentos) y experiencia de los dise-ñadores. Esta información se puede organizar y estructurar para que pueda servir a otros diseñadores. Podemos disponer de varias fuentes de información con diferente grado de rigor y normativa, entre las que podemos destacar:

• Principios. Son objetivos generales que pueden ser útiles para organizar el diseño. Aconsejan al diseñador cómo debe proceder. Sin embargo, no se especifican métodos para obtener esos objetivos, y está limitado al uso práctico (por ejemplo: conocer al usuario, minimizar el esfuerzo para rea-lizar una tarea, mantener la consistencia, etc.).

• Guías (guidelines). Conjunto de recomendaciones que deben ser aplicados a la interfaz y que son cuantificables. Deben ser generales para que puedan ser aplicadas en diferentes contextos. Pueden deducirse de teorías cogniti-vas, ergonomía, sociología, de la experiencia etc. (por ejemplo, no disponer mas de siete ítems en un menú).

• Estándares. Son principios y guías que se deben seguir por imposición in-dustrial. Existen estándares de facto (Macintosh Toolbook, MS Windows, IBM SAA/CUA). Estos estándares se diseñan para proteger la uniformidad y la línea de productos desarrollados. Con ello, mejoran la eficiencia del usua-rio (beneficio de una interfaz común para muchos programas). Existen otros estándares en otros ámbitos: ANSI, ISO, DIN, MIL–STD, NASA–STD.

Este conocimiento puede ayudar en el diseño, aunque sin embargo no es suficiente, por lo que deberemos partir de los requisitos del sistema, conocimiento del usuario y aplicar una metodología para un desarrollo efectivo del sistema. Deberemos aplicar técnicas de análisis y especificación para la descripción de aquellos aspectos que sean relevantes dentro del sistema.

22

Un diseño centrado en el usuario requiere de una continua evaluación del producto a desarrollar. Por este motivo, cobran gran importancia los siguientes aspectos:

• Métodos formales. Permiten una especificación precisa y sin ambigüedad del diseño a generar. Permite una verificación formal de propiedades y en algunos casos se puede generar la implementación automáticamente.

• Herramientas de desarrollo de interfaces modelados (MB–UID). Estas herramientas obtienen el interfaz a partir del análisis de los requisitos de usuario. Su labor fundamental es la generación de aplicaciones a partir del diseño aunque también se pueden considerar como herramientas de prototi-pado. Actualmente los lenguajes de programación visuales también disponen de librerías (ej. AWT en Java) que permiten implementar las técnicas de in-teracción y presentación de la información. (ver capítulo ‘Herramientas’).

• Prototipado. Los prototipos son documentos, diseños o sistemas que simu-lan o tienen implementadas partes del sistema final. El prototipo es una he-rramienta muy útil para hacer participar al usuario en el desarrollo y poder evaluar el producto ya en las primeras fases del diseño (modelo del ciclo de vida basado en prototipos).

No obstante, el desarrollo de sistemas interactivos sigue siendo una labor difícil y con un alto coste en tiempo y esfuerzo. Un motivo de esta complejidad es por la necesidad de adaptar el diseño a una gran variedad de usuarios, a diferentes come-tidos y sobre diferentes contextos.

Aproximaciones al diseñoEl desarrollo de Sistemas Interactivos es una tarea compleja para la cual necesita-remos de herramientas y metodologías que nos permitan realizar un diseño satisfac-torio centrado en el usuario. Existen dos aproximaciones para realizar el diseño:

• Aproximación empírica. El diseño se basa en la propia experiencia del di-señador o bien en la de otros diseñadores que se recoge mediante compen-dios de recomendaciones (guías, reglas de oro, estándares, etc.) más o menos relevantes para la construcción de un interfaz con éxito. Estos resul-tados generalmente están avalados por unos estudios de evaluación por el usuario (tests de usabilidad).

• Aproximación metodológica. Se basa en unos fundamentos teóricos y en la aplicación de una serie de pasos para la realización del diseño.

La aproximación metodológica posee bastantes aportaciones de otras disciplinas, sobre todo de las teorías cognitivas ya que aportan mecanismos para la descripción del conocimiento que el usuario posee del sistema. De

23

hecho, la aproximación empírica se basa en las aportaciones más relevantes (enunciadas como reglas de diseño) de las aportaciones teóricas (ver capítulo ‘Estándares y guías’). En este capítulo nos centraremos en una aproximación metodológica para el desarrollo de sistemas interactivos, analizando las peculiaridades de este tipo de sistemas y los mecanismos existentes para su análisis y diseño.

En el ámbito del los sistemas interactivos se ha utilizado el término diseño con mu-chas connotaciones. De hecho, el concepto de diseño abarca desde aspectos de análisis (de usuarios, tareas, del entorno, propiedades), aspectos de modelado (ar-quitectura) hasta cuestiones relativas propiamente de diseño (apariencia, codifica-ción, etc.).

Modelo mental y modelo conceptual

Un aspecto muy importante en el diseño de sistemas interactivos es el factor hu-mano (ver capítulo ‘El factor humano’), por lo que deberemos partir de modelos cognitivos que nos permita estudiar y representar cómo es asimilada y procesada la información por una persona. La obtención del conocimiento acerca de una aplicación basada en ordenadores se realiza mediante un aprendizaje. Para ello, se introducen dos términos para identificar el grado de asimilación y comprensión del usuario del entorno:

• Modelo conceptual: Es una abstracción externa que describe, mediante diagramas y notaciones más o menos formales, el conocimiento que debe poseer una persona acerca de un sistema. Este modelo es realizado por el analista y debe ser completo, consistente y exacto (sin ambigüedad).

• Modelo mental (o modelo de usuario): Es la abstracción del conocimiento interno que posee el usuario. Este modelo nos da una medida real de lo que el usuario piensa/conoce acerca del sistema informático. Este modelo guía las intenciones del usuario para realizar una tarea en el sistema. Además, este modelo mental se puede ir modificando conforme se interacciona con el sistema.

El modelo conceptual está basado en un conjunto de elementos y de relaciones que se pueden observar en un determinado sistema, representando el conocimiento que cualquier usuario debería adquirir sobre el sistema. Este modelo se deberá definir mediante una notación formal y comprensible que evite la ambigüedad del lenguaje.

El modelo conceptual debe suministrar información al usuario acerca de qué hace el sistema y los mecanismos para llevarlo a cabo. Su importancia radica en que debe favorecer el aprendizaje del sistema, es una guía para predecir el comportamiento del sistema, y además, el usuario utilizará este modelo para establecer estrategias encaminada a resolver sus problemas. Los principios en

24

los que debe estar basado el modelo conceptual serán por tanto que sea asimilable (mediante el uso de concep-tos familiares), consistente (coherente y bien formulado) y simple (uso de descripciones comprensibles por un usuario medio).

Figura 4 Modelo conceptual (con notación formal)

Para poder realizar el modelo conceptual de un sistema, deberemos conocer y apli-car modelos teóricos cognitivos que están fundamentados en el mecanismo de razonamiento humano. Los más relevantes son:

Modelo de procesador humanoCARD y MORAN [CAR83] presentan este modelo en el que se expone la forma de percibir, procesar y manipular la información. Este modelo identifica diferentes procesadores y sistemas de memoria, donde cada uno de ellos tiene asignado pa-rámetros cuantitativos importantes como ciclos de tiempo o capacidades. El modelo del procesador humano está compuesto de tres sistemas: el sistema perceptual, que maneja los estímulos sensoriales externos, el sistema motor, que controla las acciones y por último, el sistema cognitivo, que suministra el conocimiento suficiente para conectar ambos.

Modelo de desarrollo de tareasNorman, en 1986, propone un modelo de desarrollo de tareas que identifica siete etapas de ejecución y evaluación de acciones de usuario. El modelo representa las etapas de actividad mental que implica que el usuario alcance un objetivo y que son:

1) establecer el objetivo que se quiere alcanzar,

2) formalizar la intención para la acción que alcanzará el objetivo,

3) especificar la secuencia de acción correspondiente a la intención,

4) ejecutar la acción,

5) percibir el estado del sistema,

6) interpretar el estado, y por último

7) evaluar la interpretación del estado con respecto al objetivo inicial.

Este modelo proporciona una base para representar y entender las consecuencias cognitivas de diseños particulares.

Modelo objeto–acción sintáctico–semántico (SSOA)Este modelo descrito originalmente por SHNEIDERMAN en 1980 [SHN92], propone que los usuarios poseen un conocimiento sintáctico y semántico del

25

dominio del problema y de los mecanismos de interacción. En este conocimiento se almacenan detalles de los dispositivos (tipos, modo de uso), conocimientos semánticos sobre las actividades y conceptos del ordenador. Este conocimiento se estructura mediante una colección de objetos que componen el sistema (cursor, icono, ventana..) y de las acciones que se pueden llevar a cabo sobre cada uno de esos objetos (mover, cambiar, redimensionar, etc.).

Estructura del modelo conceptualEl modelo conceptual es muy importante, ya que permiten identificar, organizar y realizar razonamientos sobre los componentes y comportamiento de un sistema in-teractivo, será la guía para el proceso de diseño del software y puede usarse poste-riormente como una referencia para evaluar un diseño particular, razonar sobre la solución realizada y el posible espacio de soluciones existente. Por tanto, la correcta especificación del modelo conceptual será crucial en toda la etapa del proceso de diseño. Algunas de estas notaciones del modelo conceptual están basadas en méto-dos formales (con un fundamento basado en lógica matemática), lo que permitirá una descripción precisa y sin ambigüedad.

Partiendo de las teorías cognitivas presentadas anteriormente, se podría realizar la descripción conceptual del sistema mediante uno de estos modelos:

• Modelo de caja negra: El usuario no tiene idea del funcionamiento interno, y simplemente conoce que ciertas entradas producen una serie de resulta-dos. Este es una visión “mágica” del sistema, en la cual el usuario no tiene bases para predecir nuevos comportamientos ni causas que provocan los errores. El usuario se ve forzado a considerar los resultados verdaderos, y no sabe cómo juzgar su validez.

• Modelo funcional jerárquico: Las funciones suministradas por el sistema se agrupan en jerarquías, permitiendo reducir la complejidad del sistema mediante la aplicación de técnicas de partición en el dominio del problema (método de divide y vencerás).

• Modelo basado en estados: El sistema se define como un conjunto de es-tados. Las transiciones son provocadas por eventos claramente definidos. El usuario puede observar los cambios en el estado del sistema. Un ejemplo es el sistema de comunicación por teléfono (diferentes pitidos para estados del sistema: ocupado, llamada, etc.)

• Modelo basado en objetos y acciones: Se trabaja directamente sobre entidades (físicas o abstractas), sobre las cuales podemos realizar acciones. El usuario debe conocer la existencia de objetos, de sus posibles atributos y acciones aplicables. Por ejemplo, los iconos (acciones asociadas y atribu-tos).

26

Con estas posibles estructuraciones de la información que residen en el modelo con-ceptual, podríamos optar por centrarnos en la descripción del conocimiento que el usuario debe tener del sistema (siendo irrelevante la arquitectura del sistema) o vi-ceversa (dando más importancia al modelo del sistema respecto al conocimiento del usuario). A menudo, estas son dos alternativas (en algunos casos complementarias) para el diseño de sistemas interactivos. Una descripción basada en el conocimiento del usuario nos llevará a un modelo de tareas, mientras que una descripción del sistema nos conducirá a un modelo arquitectónico.

Los modelos de tareas analizan y describen el conocimiento que el usuario debe poseer acerca del sistema para su correcta utilización. En ese sentido, se ha traba-jado en dos vertientes. Por un lado, se debe caracterizar el proceso de adquisición de la información por parte del usuario, y por otro, se busca un mecanismo para expresar el rendimiento humano para la ejecución de unas determinadas activida-des. Estos métodos se basan en el análisis de tareas y generalmente usan una descripción funcional jerárquica.

Los modelos arquitectónicos representan la estructura interna del sistema. Se describe la composición del sistema en base a una descripción modular que facilita la composición de componentes simples para la definición de elementos mas com-plejos. Estos modelos se basan en el concepto de interador, objeto activo o agente interactivo como un objeto especializado que va a formar parte del sistema inter-activo y que posee un estado y reacciona ante eventos (estímulos externos al Objeto). Normalmente se usa una descripción basada en estados o bien en objetos y acciones (aproximación que se adapta bien a las metodologías orientadas a objetos existentes).

Otra alternativa diferente son los modelos abstractos (basados en un modelo de caja negra), los cuales se utilizan para describir las propiedades más relevantes del sistema (consistencia, visibilidad, etc.) en base a las entradas y salidas que se pro-ducen en el sistema, y sin tener en cuenta su estructura interna. El modelo PIE pro-puesto por A. DIX [DIX91] es el más conocido.

Estos tres modelos no tienen por qué ser excluyentes entre sí, ya que básicamente se diferencian los aspectos relevantes del estudio y en el nivel de abstracción con el que se analiza el sistema.

Análisis de tareasEl análisis de tareas es un término que cubre diferentes técnicas orientadas a des-cribir las interacciones entre las personas y los entornos de una manera sistemática. El análisis de tareas se puede definir como el estudio de lo que un usuario tiene que realizar en términos de acciones y/o procesos cognitivos para conseguir un objeti-vo. Es por tanto una metodología que esta soportada por un conjunto de técnicas para ayudar en el proceso analítico de recogida de

27

información, organizarlo y usarlo para realizar valoraciones o decisiones de diseño.

Conceptos iniciales:

• Una de las premisas de cualquier aproximación con la que abordemos el di-seño es la de conocer el usuario y las actividades que realiza.

• Esta información se recoge en la fase de análisis de las tareas con una notación que permita su formalización y estudio.

• Para ello, consideraremos una tarea como una unidad significativa de tra-bajo en la actividad de una persona.

El análisis de tareas nos proporciona información muy relevante acerca del sistema a diseñar que a menudo no se recoge con las técnicas de requisitos tradicionales de la ingeniería del software. Dentro del proceso de análisis de tareas, hay dos fases muy importantes:

• Obtención de la información necesaria para comprender las actividades que realiza el usuario (fase de análisis)

• Representación de esta información sobre un modelo adecuado (fase de modelado)

Mediante estos pasos, se obtiene una descripción formal del conjunto de acciones que debe realizar el usuario para la consecución de un determinado objetivo o finali-dad. Estos métodos parten de las teorías cognitivas para realizar una representación del usuario y su interacción con la interfaz. Se modela su comprensión, conocimien-to, intenciones y mecanismo de procesamiento. El nivel de representación depende del modelo concreto (desde tareas y objetivos hasta el análisis de la actividades motoras). En concreto, esta información puede ser muy útil para:

• Comprender el dominio de la aplicación: identificación de las actividades más importantes y sus relaciones.

• Facilitar discusiones interdisciplinares: el conocimiento de las tareas puede ser útil al diseñador, usuarios, analistas, psicólogos, sociólogos, etc.

• Diseño de la nueva aplicación de forma consistente con el actual modelo conceptual, preservando las características más relevantes del funciona-miento lógico.

• Análisis y evaluación de usabilidad. Se puede predecir el rendimiento hu-mano e para identificar problemas de uso.

Definiciones básicas:

28

• Objetivo: Es el estado o logro que el usuario quiere alcanzar dentro de una aplicación

• Tarea: Es la actividad necesaria para conseguir un objetivo. Pueden ser tanto actividades mentales como físicas.

• Acción: Es cada uno de los pasos a seguir para cumplimentar una tarea. Podemos considerar una acción como una tarea que no implica una solución de un problema o una estructura de control.

Proceso de obtención y análisis

En el análisis de tareas deberemos identificar las tareas más relevantes del sistema. La obtención de esta información se puede realizar mediante las siguientes técnicas:

• Entrevistas y reuniones

• Cuestionarios

• Observación del usuario en su trabajo

• Identificación de actividades en el contexto del entorno

• Estudio de la documentación actual, programas de formación, etc.

Mediante esta técnicas, obtendremos información relevante para identificar las ta-reas. En concreto, nos deberemos centrar en:

• Información que necesita el usuario para realizar la tarea (qué hacer)

• Terminología y símbolos del dominio del problema (elementos).

• Descripción de cómo esas tareas se realizan actualmente (cómo).

• Casos de uso (situaciones)

• Tipos de usuarios

El resultado de este análisis es una lista de tareas relevantes con algún tipo de in-formación adicional (atributos, restricciones, preferencias, etc.). De esta infor-mación deberemos abstraer aquellos conceptos que son relevantes para el diseño de la aplicación como son:

• El modelo de diálogo: cómo se va a realizar la comunicación persona–ordenador, bajo qué paradigma y estilo.

• Modelo de tareas: Especificación de las tareas en el sistema nuevo.

• Dominio de sistema: Descripción de los componentes y arquitectura del sis-tema.

29

• Modelo de usuarios: Identificación del tipo de usuarios, papel que desempe-ñan en el sistema y sus interrelaciones.

• Propiedades del sistema. Estudio de las características del sistema y de los requisitos que satisface (seguridad, robustez, etc.).

Métodos de análisis de tareas

Para llevar a cabo el análisis de tareas, podemos utilizar diferentes métodos que se diferencian en el grado de formalismo de su notación, poder de expresividad y finali-dad. Si bien todos ellos representan las tareas del sistema, la finalidad del estudio puede ser diferente:

• Métodos de competencia o cognitivos. Estos métodos identifican se-cuencias de comportamiento correctas, representando el tipo de conoci-miento que debe poseer un usuario acerca del uso del sistema. Partiendo de la descripción de tareas generan una especificación del conocimiento del usuario.

• Métodos predictivos para la evaluación del rendimiento humano. Descri-ben secuencias de comportamiento y el conocimiento que necesita el usuario para su ejecución. Análisis centrado en rutinas de comportamiento.

• Métodos descriptivos. Permiten obtener una descripción más o menos completa del sistema a partir de la información obtenida de las tareas.

En la siguiente tabla se detallan algunos de estos métodos con sus características más relevantes.

Método Tipo Notación Especificación Comentarios

HTA Cognitivo Gráfico Semi–Informal Modelo de descomposición del conocimiento

GOMS Cognitivo Textual Semi–Informal Familia de lenguajes para describir el conocimiento

UAN Cognitivo Gráfico Semi–Informal Notación para el estilo de manipulación directa

KLM Predictivo Textual Tiempo Medición del rendimiento humano

TAG Predictivo Textual Esquemas Medida de la consistencia

CTT Descriptivo Gráfico Lógica temporal Herramientas de soporte al análisis y verificación.

Análisis jerárquico de tareas (HTA)

30

El análisis jerárquico de tareas (HTA Hierarchical Task Analysis) desarrollado por ANNETT y DUNCAN [ANN67], es la técnica de análisis de tareas más conocido y más antiguo.

En HTA se realiza una descripción de tareas en términos de operaciones y planes. Las operaciones (descomposición en subtareas) son actividades que realizan las per-sonas para alcanzar un objetivo, y los planes son una descripción de las condiciones que se tienen que dar cuando se realiza cada una de las actividades. Las operacio-nes se pueden descomponer de forma jerárquica y se asigna un plan a cada una de las subtareas que aparecen. Se define un objetivo como un estado determinado del sistema que puede quiere alcanzar el usuario. Aunque se habla de objetivos y tareas, la representación que se realiza describe únicamente la descomposición jerárquica en subtareas de las tareas que aparecen en el sistema.

El formato gráfico se parece a un árbol con ramas y subramas en función de las necesidades [SHE89]. A la hora describir la descomposición de una tareas en sub-tareas podemos representar cuatro tipos de descomposiciones:

• Secuencia. Descomposición en un conjunto ordenado temporalmente de una secuencia de tareas.

• Selección. Conjunto de tareas de las que se tendrá que elegir una de ellas.

• Iteración. Repetición de un subconjunto de tareas.

• Tarea unitaria. Actividad indivisible (según el nivel de detalle dado)

El análisis de tarea implica tres etapas enlazadas: recogida de información, diagra-mación y análisis. Los procedimientos de recogida de información incluyen la revisión de la documentación existente (por ejemplo, manuales de funcionamiento, procedi-mientos, informes de seguridad, estudios de análisis de tareas previos, diseños, imágenes, prototipos, etc.), que permitan establecer qué hacen las personas en cir-cunstancias especificas (normales y anormales), entrevistas y cuestionarios (des-cripciones por parte de personas experimentadas como hacen las cosas, que infor-maciones necesitan y como determinan si la tarea se puede realizar satisfactoria-mente).

Algunas tareas se pueden desglosar con mayor detalle en secuencias. Un plan des-cribe el conjunto de operaciones necesarias para llevar a cabo una actividad, o bien, muestra las circunstancias por las que una operación es realizada antes que otra. Estos planes se añaden a la tabla jerárquica.

La descripción de la información se realiza en forma de tabla o en forma de dia-grama de árbol que describa las relaciones entre tareas y subtareas.

31

0. Hacer té

1. Calentar el agua

1.1 Llenar cazo

1.2 Encender fuego

1.3 Poner cazo en fuego

1.4 Esperar

1.5 Apagar fuego

2. Vaciar tetera

3. Poner hojas de té en tetera

4. Verter el agua

5. Esperar

6. Servir el té

Plan 0: hacer 1.

si tetera está llena,

entonces hacer 2 al mismo tiempo

hacer 3-4-5

Cuando el té ha reposado, hacer 6

Plan 1: hacer 1.1-1.2-1.3-1.4

Cuando el agua está hirviendo, hacer 1.5

El análisis de la información es la fase final. Usaremos esta información como base para decisiones de diseño y puede servir como guía para las actividades de diseño. La metodología para utilizar HTA como análisis de tareas sería la siguiente:

• Etapa inicial. Definición de las tarea principal, que puede ser dividida entre cuatro y ocho subtareas.

• Etapa intermedia. Decidir el nivel de detalle que se requiere y en que punto acabar la descomposición

• Parte final. Revisión y evaluación del trabajo realizado para comprobar su consistencia

32

GOMS

GOMS (propuesto por CARD/MORAN [CAR83]) comprende a una familia de lenguajes (que incluye a NGOMSL, KLM) que se basan en la visión del usuario como un sistema procesador de información (modelo de procesador humano) [EBE94]. El modelo GOMS se basa en el mecanismo de razonamiento humano para la resolución de problemas y realiza la formalización de aquellas actividades (físicas y mentales) que intervienen en esa labor. Para cada tarea se describe el objetivo a satisfacer (Goal), el conjunto de operaciones (Operations) que el sistema pone a disposición del usuario para la interacción, los métodos disponibles para llevar a cabo esas operaciones (Methods) y por último, un conjunto de reglas de selección (Selection) para determinar la alternativa más conveniente en cada caso (descritas mediante estructuras de control if–then). Cada tarea se podría descomponer en otras tareas primitivas formando un árbol jerárquico.

Los objetivos son las metas que se propone el usuario (lo que desea obtener). Los objetivos pueden servir como un punto de referencia en caso de un error. Un objeti-vo contiene información de la intención del usuario. Para ello, debe realizar una serie de operaciones básicas. Las operaciones son unidades elementales de percepción, motoras o actos cognitivos cuya ejecución es necesaria para cambiar algún aspecto del modelo mental del usuario, o bien, para modificar el entorno. Este tipo de accio-nes puede afectar al sistema (pulsar una tecla) o bien, sólo al estado mental del usuario (leer el cuadro de diálogo). Existe un grado de flexibilidad acerca de la granularidad de las operaciones (amplitud de cada operación). Para llevar a cabo estas operaciones, existen varias posibilidades de descomposición de una tarea en subtareas. Por ejemplo, en un gestor de ventanas, se puede cerrar la ventana mediante ratón en un menú o teclado (atajo). Cada una de estas posibilidades será un método.

GOAL: CERRAR-VENTANA

[select GOAL: USAR-METODO-RATON

MOVER-RATON-A-MENU-VENTANA

ABRIR- MENU

CLICK-SOBRE-OPCION-CERRAR

GOAL: USAR-METODO-TECLADO

PULSAR-TECLAS-ALT-F4]

Cuando hay más de una alternativa, podemos indicar una serie de condiciones y re-glas para tomar la mejor alternativa (método):

33

METHODS: IF (USUARIO-EXPERTO)USAR-METODO-TECLADO

ELSE USAR-METODO-RATON]

Podemos descomponer los objetivos en subobjetivos.

GOAL: EDITAR-DOCUMENTO

GOAL: ABRIR-DOCUMENTO

La descomposición de tareas nos suministra una comprensión de estrategias para resolver problemas del dominio de la aplicación. El objetivo del análisis jerárquico de tareas es la de producir una descomposición de tareas, de modo que se pueda seguir paso a paso el método de resolución.

GOMS puede servir también para medir rendimientos. La profundidad de subtareas se puede usar para estimar los requerimientos de la memoria de corto plazo (MCP) (ver capítulo ‘El factor humano’) e incluso para estimar tiempo de respuesta (asu-miendo tiempos constantes para cada operación).

En este ejemplo tenemos una descripción de la tarea de mover una pieza en una partida de ajedrez.

GOAL: MOVER-PIEZA

. GOAL: DETERMINAR-TURNO

. . [select GOAL: CONOCER-ULTIMO-MOVIMIENTO

. . . MOVER-A-LA-HISTORIA-DE-MOVIMIENTOS

. . . DETERMINAR-ULTIMO-MOVIMIENTO

. . . COMPROBAR-SI-NO-ERES-TU

. . GOAL: CONOCER-MOVIMIENTO-SIGUIENTE

. . . MOVERSE-AL-TABLERO

. . . IDENTIFICAR-POSICION-DEL-RELOJ

. . . COMPROBAR-SI-RELOJ-ESTA-EN-TU-POSICION]

. GOAL: ELEGIR-MEJOR-ESTRATEGIA

. GOAL: REALIZAR-MOVIMIENTO

. . GOAL: SELECCIONAR-PIEZA-ADECUADA

. . . [select GOAL: IDENTIFICAR-PIEZA

. . . . SELECCIONAR-TECLADO

34

. . . . ESCRIBIR-IDENTIFICACION-PIEZA

. . . . CONFIRMAR

. . . GOAL: COGER-PIEZA

. . . . MOVER-CURSOR-A-PIEZA

. . . . PULSAR-BOTON-RATON]

. . GOAL: ELEGIR-DESTINO

. . . [select GOAL: IDENTIFICAR-DESTINO

. . . . MOVER-CURSO-ARRASTRANDO-PIEZA

. . . . ESCRIBIR-IDENTIFICACION-POSICION

. . . . CONFIRMAR

. . . GOAL: SOLTAR-PIEZA

. . . . MOVER-CURSOR-ARRASTRANDO-PIEZA

. . . . SOLTAR-BOTON-RATON]

. GOAL: CONFIRMAR-MOVIMIENTO

. . . [select GOAL: TECLA-CONFIRMACION

. . . . PULSAR-ENTER

. . . GOAL: PARAR-RELOJ

. . . . MOVER-CURSOR-RELOJ

. . . . PULSAR-BOTON-RATON]

Selection Rule for GOAL: DETERMINAR-TURNO

Si es una visualización gráfica, usar el método CONOCER-MOVIMIENTO-SIGUIENTE

en otro caso usar el CONOCER-ULTIMO-MOVIMIENTO

Selection Rule for GOAL: SELECCIONAR-PIEZA-APROPIADA

Si no tienes ratón usar el método IDENTIFICAR-PIEZA,

en otro caso usar el método COGER-PIEZA

Selection Rule for GOAL: ELGIR-DESTINO

35

Si no tienes ratón usar el método IDENTIFICAR-DESTINO,

en otro caso usar SOLTAR-PIEZA

Selection Rule for GOAL: CONFIRMAR-MOVIMIENTO

Si estas usando el teclado usar el método TECLA-CONFIRMACION,

en otro caso usar el método PARAR-RELOJ

El modelo GOMS fue uno de los primeros métodos utilizados para el diseño de interfaces de usuario, teniendo gran repercusión en investigaciones posteriores. Permite describir cómo un experto realiza tareas y las descompone en subtareas. Sin embargo, una de sus puntos débiles es que sólo considera comportamientos sin errores y tareas secuenciales.

KLM

Uno de los modelo GOMS más simple es el KLM (KeyStroke Level Mode), que simplifica el conjunto de operaciones disponibles a la pulsación de teclas y movimiento de ratón. Esta simplificación permite obtener predicciones del tiempo que una persona empleará para la realización de una tarea.

Estas mediciones parten de unos valores experimentales que determinan mediciones concretas para la realización de actividades elementales. A partir de estos resultados experimentales, se puede deducir que por término medio:

• El tiempo de planificación de una tarea se puede estimar que dura 2-3 seg. si ya está definida, y de 5 a 30 seg. si hay que pensarla.

• El tiempo de respuesta del usuario para una acción varía notablemente se-gún el tipo de dispositivo y de la destreza del usuario. Podríamos crear una tabla donde aparecen las operaciones más usuales sobre los dispositivos (pulsar tecla, mover ratón, etc.) y su tiempo en función de las habilidades del usuario.

Operador Descripción Segundos

K Pulsación de teclado:

Buen mecanógrafo (135 ppm)

Habilidoso (90ppm)

Normal (40ppm)

Malo

0.08

36

0.12

0.28

1.20

P Apuntar con el ratón 1.10

H Ubicar las manos en teclado 0.40

D(ND,ID) Dibujar un trazo

(N: nº segmentos, I: longitud) 0.9ND+.016ID

M Preparación mental 1.35

Por ejemplo, podemos comparar el tiempo de respuesta entre el diseño de dos menús con mucha profundidad o con mucha ramificación. En un menú basado en ordenes numeradas (16 opciones). Partiendo de las siguientes hipótesis:

• Opciones con igual probabilidad

• Usuario experto mecanógrafo

Podríamos concluir con la siguiente medición. Una selección de un menú por su posi-ción (1-16) necesitaría de los siguientes operadores:

• Operador M para buscar y visualizar el menú

• Uno o dos operadores K para introducir el número de ítem + 1K (pulsación de tecla ENTER)

M + K (1er dígito) + 0.44K* (2º dígito) + K (Enter)

1.35 + 0.20 + 0.44(0.20) + 0.20 = 1.84 seg.

* Usado para las opciones de la 10-16. Probabilidad 7/16 = 0.44

Se puede comparar con la utilización del ratón para la elección del menú. Para ello bastarán los siguientes operadores:

M + P + K (click ratón)

1,35 + 1.10 + 0.20 = 2.65 seg.

Como vemos, KLM para este caso podría predecir que la selección por teclado sería más rápida (efectiva) que la selección por menú.

Se puede utilizar para analizar igualmente el balanceo de los menús (profundidad), selecciones de elementos por identificador o apuntando, etc. Otra utilidad que posee este método es la de hacer explícito el conocimiento implícito que debe poseer el usuario acerca del sistema.

37

TAG

Este es otro tipo de formalismo para representar el conocimiento del usuario. TAG (Task Action Grammar) describe el conocimiento del usuario para realizar una deter-minada tarea en base a una gramática con características [HAR90]. El conocimiento que posee el usuario del tipo "como puedo hacer..." se puede expresar mediante un esquema que engloba a un conjunto de reglas individuales. Un esquema estará for-mado por una estructura sintáctica definida a partir de un conjunto de característi-cas. Las características (features) son atributos que definen la semántica de la ta-rea. La tareas que tenga estructuras sintácticas diferentes tendrá un esquema dife-rente. A partir de esta aproximación, se podrá medir la complejidad del interfaz me-diante la identificación de características en la acción de tareas y de su agrupamien-to en esquemas. El número de esquemas puede dar una orientación de la consisten-cia del lenguaje de la interfaz; a menos esquemas, el usuario puede inferir el comportamiento esperado del sistema a partir de un conocimiento parcial. Se parte del hecho que la simplificación del esquema es comprensible por el usuario. De este modo, la consistencia ayuda al aprendizaje, ya que podemos inferir nuevas tareas a partir de las conocidas.

Para abordar la especificación de un interfaz mediante TAG se deben seguir los si-guientes pasos:

• Identificar tareas simples que el usuario puede realizar sin resolución de problemas (sin incluir estructuras de control)

• Describir las tareas simples en un diccionario (como conjuntos de compo-nentes semánticos), reflejando la categorización de las tareas.

• Definición de reglas de reescritura que trasladan tareas simples en una es-pecificación de acciones, donde los tokens son etiquetados con caracterís-ticas semánticas procedentes del diccionario de tareas simples. Las etique-tas permiten la generalización.

Por ejemplo, podemos utilizar TAG para estudiar la consistencia del conjunto de ór-denes de un Sistema Operativo (copy, rename, delete). Para ello, partimos de las descripción gramatical de estas tareas, y analizaremos cómo se pueden agrupar en esquemas:

Tareas simples

Copiar fichero nombre_fichero nombre_fichero

Copiar disco nombre_disco nombre_disco

Renombrar fichero nombre_fichero nombre_fichero

Borrar fichero nombre_fichero

38

Primeramente, deberemos identificar las características que aparecen en estas ta-reas y sus posibles valores. En este caso, las características corresponden con el tipo de atributo y sus posibles valores. También deberemos tener en cuenta cuando el objeto fuente y destino es el mismo, ya que en tal caso, se produce un cambio en el objeto (y es una característica a tener en cuenta):

Objeto_antiguo [fichero disco, vacio]

Objeto_nuevo [fichero, disco, vacio]

Produce_cambio [si, no]

Una vez obtenidas las características y sus valores, se deberán reescribir las tareas simples mediante estas características, de modo que definan unívocamente su signi-ficado:

Copiar fichero [Obj_antiguo=fichero, Obj_nuevo=fichero, cambio= no]

Copiar disco [Obj_antiguo=disco, Obj_nuevo=disco, cambio= no]

Renombrar fich [Obj_antiguo=fichero, Obj_nuevo=fichero, cambio= si]

Borrar fichero [Obj_antiguo=fichero, Obj_nuevo=vacio, cambio= no]

A partir de estas tareas podríamos obtener un único esquema a partir de tres carac-terísticas que lo definen.

Task [obj_ant, obj_nuevo, cambio] :=

Orden[obj_ant, obj_nuevo, cambio]+param1[Obj_ant]+param2[obj_nuevo]

Cada orden vendría dada por un nombre (de la tarea a realizar) y dos parámetros. Los valores para estos argumentos vendrían dados unívocamente por el valor de las características:

tarea[obj_ant=fichero, obj_nuevo=fichero, cambio=si] := "ren"

tarea[obj_ant=fichero, obj_nuevo=fichero, cambio=no] := "copy"

tarea[obj_ant=disco, obj_nuevo=disco, cambio=no] := "diskcopy"

tarea[obj_ant=fichero, obj_nuevo=vacio, cambio=no] := "delete"

param1[obj_ant=vacio] := NULL

param1[obj_ant =fichero] := drive-id + "nombre_fichero"

param1[obj_ant=disco] := drive-id

param2[obj_nuevo=vacio] := NULL

param2[obj_nuevo =fichero] := drive-id + "nombre_fichero"

39

param2[obj_nuevo=disco] := drive-id

drive-id := NULL | "A:" | " "B:" | "C:" | ...

TAG no realiza predicciones absolutas de rendimiento. Mas bien, se puede utilizar para generar hipótesis que deben ser probadas experimentalmente.

TAG se ha utilizado para medir la consistencia de lenguajes de órdenes (UNIX, MSDOS), aunque también se puede generalizar para acciones de manipulación direc-ta, ubicación de órdenes en menús, etc.

Consistente Inconsistente

copy src_file target_file copy src_file target_file

rename src_file target_file rename target_file in src_file

delete src_file make src_file deleted

La evaluación de la consistencia del lenguaje del interfaz de usuario puede ser muy sencillo de estimar con TAG. Así por ejemplo, podríamos detectar rápidamente inconsistencias en el lenguaje de órdenes como en este ejemplo, donde las órdenes no poseen la misma estructura. El esquema tiende a ser menos consistente conforme aumenten los esquemas. Como consecuencia, el número total de reglas no es importante, sólo el numero de esquemas.

La consistencia está muy relacionada con la facilidad de aprendizaje. Podríamos estimar que existe una relación directa entre el tiempo de aprendizaje necesario y el número de esquemas que aparecen del lenguaje.

UAN

Las técnicas basadas en gramáticas no resultan adecuadas para la descripción de la interacción en interfaces gráficas de usuario basadas en el paradigma de manipula-ción directa ya que no permiten describir la realimentación visual (feedback) del sistema. A esto se une la dificultad de especificar tareas basadas en el arrastre de iconos ya que su semántica depende del lugar donde se suelte. En este sentido, UAN (User Action Notation) es una notación centrada en el usuario para descripción de tareas. Su principal característica es la descripción física de las acciones a realizar en el proceso de interacción [HAR95].

Una especificación en UAN se realiza mediante una tabla dividida en 3 columnas des-cribiendo las acciones de usuario, la realimentación de la interfaz y el estado del sis-tema tras la acción. Las acciones de usuario y la realimentación poseen una notación donde explícitamente se designa la manipulación que se realiza sobre los objetos de la interfaz. Así por ejemplo, las acciones Mv y M^ denotan el efecto de pulsar y soltar el botón del ratón,

40

~[fichero] representa el movimiento del ratón en el con-texto del objeto fichero mientras que fichero > ~ significa que el objeto fichero se está arrastrando. Del mismo modo podemos especificar la respuesta del sistema (feedback) para cada acción tales como la una selección en vídeo inverso de un icono (fichero!), vídeo normal (fichero-!), o un parpadeo (fichero!!). La siguiente descripción especifica la tarea de borrar un fichero mediante técnicas de arrastre.

UAN Realimentación Estado

1) ~[fich] Mv fich!, forall(fich!): fich-! Selección = fich

2) ~[x,y]* outline(fich) > ~

3) ~[papelera] outline(fich) > ~, palelera!

4) M^ Borrar(fich), papelera!! Selección = null

Esta especificación nos permite especificar la tarea de arrastrar un fichero a la pa-pelera mediante el proceso que se muestra gráficamente en la Figura 7.

Figura 7 Manipulación directa descrita mediante UAN

ConcurTaskTrees (CTT)

CTT es una notación desarrollada por FABIO PATERNÒ [PAT00] cuyo principal finalidad es la de poder representar las relaciones temporales existentes entre las actividades y usuarios que son necesarios para llevar a cabo en las tareas. En concreto, esta notación es especialmente útil para aplicaciones CSCW (ver capítulo ‘Trabajo coope-rativo con ordenador’).

Una de las principales ventajas de esta notación es su facilidad de uso, lo que hace que sea aplicable a proyectos reales con aplicaciones de un tamaño medio–largo y que con llevan especificaciones de cierta complejidad. La notación genera una repre-sentación gráfica en forma de árbol de la descomposición jerárquica de las tareas existentes en el sistema. Se permite la utilización de un conjunto de operadores, sacados de la notación de LOTOS, para describir las relaciones temporales entre ta-reas (secuencialidad, concurrencia, recursión, iteración...)

Podemos reutilizar partes de especificación para la creación de “árboles de tareas concurrentes” e identificarlo como un patrón de tarea. Podemos identificar 4 catego-rías de tareas en función del actor que la llevará a cabo.

41

Tareas del usuario. Tareas realizadas completamente por el usuario, son tareas cognitivas o físicas que no interactúan con el sistema. Describen procesos realizados por el usuario usando la información que recibe del entorno (por ejemplo seleccionar dentro de un conjunto de información la que se necesita en un instante determinado para la realización de otra tarea).

Tareas de la aplicación. Tareas realizadas por la aplicación y activadas realizadas por la propia aplicación. Pueden obtener información interna del sistema o producir información hacia el usuario. Como ejemplo podemos ver una tarea que presente los resultados obtenidos de una consulta a una base de datos.

Tareas de interacción. Son tareas que realiza el usuario interactuando con la aplicación por medio de alguna técnica de interacción. Un ejemplo puede ser seleccionar un elemento de una lista desplegable.

Tareas Abstractas . Tareas que requieren acciones complejas y que por ello no es fácil decidir donde se van a realizar exactamente. Son tareas que van a ser descompuestas en un conjunto de nuevas subtareas.

Para la descripción se utilizan además una serie de operadores temporales que facili-tan la descripción de las relaciones temporales existentes entre tareas. Estos opera-dores se han obtenido como una extensión de los operadores existentes en LOTOS [EIJ89]. El uso de estos operadores facilita la descripción de comportamientos com-plejos. Los operadores temporales que podemos usar son:

T1 ||| T2. Entrelazado (Concurrencia independiente). Las acciones de las dos tareas pueden realizarse en cualquier orden.

T1 |[]| T2. Sincronización (Concurrencia con intercambio de Información). Las dos tareas tiene que sincronizarse en alguna de sus acciones para intercambiar informa-ción.

T1 >> T2. Activar (enabling). Cuando termina la T1 se activa la T2. Las dos tareas se realizan deforma secuencial.

T1 []>> T2. Activar con paso de información. Cuando termina T1 genera algún valor que se pasa a T2 antes de ser activada.

42

T1 [] T2. Elección. Selección alternativa entre dos tareas. Una vez que se esta reali-zando una de ellas la otra no esta disponible al menos hasta que termine la que esta activa.

T1 [> T2. Desactivación. Cuando se da la primera acción de T2, la tarea T1 se des-activa.

T1 [][> T2. Desactivación con paso de información. Igual que la anterior pero pa-sando información de una tarea a la otra.

T1*. Iteración. La tarea T1 se realiza de forma repetitiva. Se estará realizando hasta que otra tarea la desactive.

T1(n). Iteración finita. La tarea T1 puede darse n veces. Se utiliza cuando el dise-ñador conoce cuantas veces tiene que realizarse la tarea.

[T1]. Tarea opcional. No es obligatorio que se realice la tarea. Cuando describimos las subtareas existente en la tarea de rellenar un formulario algunas de las subta-reas pueden ser opcionales (las de los campos que sean opcionales).

A la descripción jerárquica de las tareas se le añade la descripción de los objetos que son manipulados por las distintas tareas. Estos objetos pueden clasificarse en dos grupos:

• Objetos perceptibles. Son objetos gráficos que sirven para presentar in-formación al usuario (ventanas, tablas, gráficos...) o elementos sobre los que el usuario puede interactuar (menús, iconos...).

• Objetos de aplicación. Elementos que pertenecen al dominio de la aplica-ción. La información que almacenan estos objetos tiene que ser mapeada a alguno de los otros para poder ser percibida por el usuario.

Cada objeto puede ser manipulado por mas de una tarea. Como ejemplo de especificación utilizando los ConcurTaskTrees podemos ver una parte de una aplicación para acceder a información sobre un museo. En la Figura 8 se muestra el modo de introducir la información por parte del usuario sobre el tipo de artista que está buscando y el sistema le presenta la información asociada a el.

Figura 8 Tarea de acceso a un museo mediante CTT

Se comienza con la tarea “Acceso_Museo_Virtual” que puede ser interrumpida en cualquier momento ([>) por la tarea “Cerrar”. En un siguiente nivel podemos ver la tarea de interacción “Selecc_Tipo_Arte” con la que se describe la selección del tipo de arte sobre el que se requiere información, seguido (>>)

43

por la selección del periodo histórico en el que esta encuadrada la obra del artista. La siguiente tarea a realizar es el acceso a la información del artista para ello se ha obtenido información de las tareas anteriores ( []>> operador activación con paso de información). Algunas de estas tareas se van a descomponer en nuevas tareas de manera jerárquica. Así la tarea “Selecc_adicional” permite seleccionar un artista mediante una lista alfabética o mediante una lista ordenada por periodos históricos.

La descripción de tareas cooperativas consiste en tareas que requieren de la partici-pación de más de un usuario para poder llevarla a cabo. Esta descripción se puede realizar creando un árbol donde aparecerán las tareas cooperativas, que se denota-rán con un identificador especial. Por ejemplo, una solicitud de información se podría modelar del siguiente modo:

Figura 9 Tarea cooperativa con CTT

5 Modelos arquitectónicos

Los modelos arquitectónicos son una alternativa (en algunos casos complementaria) para la representación de sistemas interactivos. En este caso, se pretende obtener un modelo del sistema a desarrollar, centrándose en los aspectos computacionales básicos en los que debe estar basado.

Los primeros modelos que se proponen en este sentido son para describir el sistema interactivo en su conjunto recogiendo sus características esenciales. Si bien los pri-meros modelos como Seeheim o ARCH se centraban en aspectos funcionales, las últimas propuestas definen una arquitectura modular basada en componentes como MVC o PAC. También podemos encontrar propuestas encaminadas hacia un diseño basado en modelos concretos del sistema con herramientas para su obtención auto-mática como puede ser MOBI–D, HUMANOID, etc. (ver capítulo ‘Herramientas’).

Los aspectos más relevantes de estas propuestas se centran en la modelización de los componentes interactivos (estructura) y mecanismo de interacción (diálogo).

Modelos de componentes interactivos

Los modelos basados en componentes realizan la descripción del sistema como una colección de interadores, elementos básicos que encapsulan interacciones elementa-les con las que se pueden construir interacciones más complejas.Estos modelos defi-nen las características de los objetos con los que interactúa el usuario (como listas, deslizadores, ventanas, etc.). El modelo conceptual debe reflejar los aspectos rele-vantes del cualquier componente interactivo (apariencia, eventos, comunicación, etc.). Normalmente esta

44

arquitectura es modular por lo que permite la composición de componentes para crear sistemas más complejos.

Uno de los modelos que más se ha utilizado para la especificación de sistemas inter-activos es el denominado interador (de York) [DUK95]. Un interador (interactor) consiste en un estado y un conjunto de acciones que puede percibir e invocar el entorno a través de una interfaz bien definido. Esta definición recoge los elementos esenciales de cualquier elemento interactivo (su estado actual, visualización y even-tos para su manipulación. Una parte importante de esta interfaz es la representación gráfica del componente (presentación), que es perceptible por el usuario del sistema. Bajo este modelo, podemos describir elementos interadores abstractos, que posteriormente se plasmará en los lenguajes de especifi¬cación.

El concepto de interador ha sido utilizado ampliamente para construir metodologías de diseño de sistema interactivos. La mayor diferencia entre ellas es el lenguaje de especificación utilizado, Z, Lotos, álgebra de procesos, etc.

Figura 10 Modelo de interador de York

Podemos realizar una descripción más detallada de un interador utilizando para ello conceptos que aparecen en los sistemas concurrentes. Así, un interador es un mo-delo abstracto basado en procesos, canales de comunica¬ción y señales de control que definen un componente interactivo con capacidad de representación gráfica y modificación dinámica. Su estructura favorece la interconexión de interadores para realizar modelos de interacción complejos.

En el siguiente esquema se detallan los procesos que definen su funcionalidad, así como las comunicaciones entre los mismos. La idea que se recoge bajo el paradigma del interador es la de representar un componente activo que posee una apariencia gráfica y una medida que representa el valor actual del interador (o estado). Este valor puede modificar la apariencia del interador, así como externamente podemos variar la forma de obtención de la medida. Podemos sincronizar los distintos procesos mediante señales de control.

Un interador se puede describir mediante cuatro procesos. Collection proporciona una descripción de alto nivel de la apariencia gráfica del objeto. Feedback se encar-ga de producir la apariencia externa del objeto. Measure obtiene un dato de un nivel inferior, y Control, se encarga de generar una nueva medida para el nivel superior. Las entradas y salidas del interador se definen por medio de canales de comunica-ción: im, oc, od y eo. La sincroniza¬ción se realiza mediante dos señales de control: it y ot.

45

Figura 11 Esquema de un interador

Podemos trasladar el concepto de interador a diferentes lenguajes de especificación. La definición formal de un interador mediante LOTOS [EIJ89, FAC92] es la siguiente:

Specification Interactor [ot, oc, od, eo, im, it] : noexit

Behaviour

Hide me, oc, cf, md, in

((COLLECTION [ot, oc, cf, cm] | [cf]) |

(FEEDBACK [cf, me, eo]) | [cm, me]) |

(MEASURE [im, it, cm, me, md] | [md]) |

(CONTROL [od ,md]))

Where

Process COLLECTION [ot,oc,cf,cm] : noexit :=

oc; COLLECTION [ot, oc, cf, cm]

[] oc; cm; cf; COLLECTION [ot, oc, cf, cm]

endproc

Process FEEDBACK [cf, me, eo] : noexit :=

cf; me; eo; FEEDBACK [cf, me, eo]

[] me; eo; FEEDBACK [cf, me, eo]

endproc

Process MEASURE [im, it, cm, me, md] : noexit :=

cm; me; MEASURE [im, it, cm, me, md]

[] im; me; MEASURE [im, it, cm, me, md]

[] it; md; MEASURE [im, it, cm, me, md]

endproc

Process CONTROL [od, md] : noexit :=

md; od; CONTROL [od, md]

endproc

46

endspec

En la especificación se describen las distintas sincronizaciones que se deben garanti-zar sobre los procesos que conforman la estructura del interador. Así, por ejemplo, el proceso feedback se encarga de producir su apariencia gráfica producto de una modificación de la medida (me) o bien de un cambio de apariencia (cf). Podemos asociar a cada canal de comunicación información acerca del tipo de dato que transporta. Por ejemplo el canal de comunicación eo definirá sus datos de tipo gráfico: eo?p : Picture, especificado en ACT ONE. Una de las ventajas que tiene LOTOS (y en general todos los métodos basados en álgebra de procesos) es que explicitan todas las sincronizaciones que aparecen en un sistema interactivo.

Se han desarrollado metodologías para diseñar sistemas interactivos utilizando los interadores en las que se describen las posibles formas de interconectarlos para describir interacciones complejas.

En la siguiente imagen podemos ver como se interconectarían tres interadores para describir parte de un sistema en el que se van a utilizan iconos para representar objetos como ficheros, directorios y unidades de disco. El usuario puede manipular los iconos por medio del ratón y puede modificar el estado de los iconos usando también entradas de un menú.

Se pueden utilizar otros formalismos para la descripción de interadores como por ejemplo la lógica temporal. En [DUK95] se realiza una combinación de un modelo de interador con lógica. Los axiomas se especifican en lógica modal de acciones (MAL), de forma que, junto a los predicados basados en lógica de primer orden, se extiende con un conjunto de operadores modales, que controlan las acciones que se pueden provocar en el sistema. MAL incluye el concepto de agentes (humanos y ordenador) y las responsabilidades mutuas entre ellos. Los operadores usuales son el permiso (per) y la obligación (obl) bajo un paradigma deontológico.

Figura 12 Red de interadores para controlar iconos

En la Figura 13 se observa cómo se pueden especificar mediante lógica modal el modelo de interador. El concepto de estado se recoge en la colección de atributos, mientras que la interacción se refleja en la sección de acciones disponibles en el en-torno para su manipulación. Cada acción o componente del estado posee calificado-res, indicando si posee apariencia gráfica (vis: visual), o limitación en cuanto a su utilización por el usuario (any: cualquier modali¬dad).

interactor button

47

attributes

vis

selected : B // botón seleccionado o no

vis

enabled : B // botón habilitado o no

actions

any

select

any

toggle

axioms

[1] enable selected = B [select] selected = B

[2] enabled = B [toggle] enabled = B

[3] per(select) enabled

Figura 13 Especificación de un botón

Podemos encontrarnos axiomas con predicados de la forma "P [A] Q" , de modo que si se satisface P, cuando se realice la acción A, Q será cierto. Otro operador, per(A) denota permiso para que la acción A pueda ocurrir, mientras que obl(A) indi-ca que esa acción obligatoriamente debe ocurrir.

Modelos del diálogo

En el diseño de sistemas interactivos, existen muchos aspectos a considerar, el con-texto organizacional, los tipos de usuarios, los dispositivos de comunicación, los esti-los de interacción, la influencia de la aplicación subyacente, etc. Sin embargo, un aspecto fundamental en estos sistemas es la estructura del diálogo, la descripción de la comunicación de cada participante. Uno de los componentes cruciales en los sistemas interactivos es la descripción del diálogo. Su complejidad y naturaleza di-námica hace aconsejable la utilización de un modelo que permita su correcta especi-ficación.

Gramáticas

Las gramáticas nos permiten describir secuencias, elección e iteracción como ele-mentos básicos del proceso del diálogo. Se puede utilizar herramientas tales como lex&yacc para obtener un prototipo de la comunicación. Las

48

gramáticas describen el diálogo como reglas de producción. BNF enfatiza la relación entre sintaxis y las ac-ciones necesarias para realizar una orden. Una gramática basada en producciones describe un lenguaje como un conjunto de reglas que especifican los literales correc-tos en el lenguaje. La gramática consiste en:

• Símbolos terminales (palabras reservadas del lenguaje). Representan ac-ciones que el usuario tienen que aprender y recordar.

• Símbolos no terminales. Representan conjuntos de acciones agrupadas para realizar una actividad/tarea.

• Metasímbolos. ::= (definición), | alternancia, () agrupacion, [ ] opcional

Este método es muy adecuado para estilos de diálogo basados en órdenes. Una ex-tensión de este modelo (las gramáticas multi–party) permite identificar al participan-te que actúa en la interacción (U: usuario, C: computadora):

<Sesión> ::= <U: Open> <C:Respuesta>

<U:Open> ::= LOGIN <U: Name>

<C: Respuesta> ::= HELLO [<U: Name>]

Sin embargo, uno de los mayores inconvenientes que posee es que no permite representar conceptos sensibles al contexto, junto a su dificultad para su com-prensión con especificaciones largas.

Diagramas de transición de estados (STN)

Ha sido uno de los primeros métodos utilizado para la descripción del diálogo. Con diagramas STN podemos expresar los posibles estados del sistema así como las transiciones entre ellos. El diagrama de transiciones está formado por nodos y en-laces. Los nodos representan los posibles estados del sistema. Los enlaces repre-sentan las posibles transiciones entre estados. Podríamos incluso identificar el actor que ha provocado la acción. Las acciones del usuario será aquellas transiciones realizadas directamente por la participación directa del usuario.

U: Usuario

S: Sistema

T: transición temporal

Figura 14 STN de una lámpara

49

Este tipo de especificación muestra el flujo de acciones y determina el estado tras una acción. Con el mismo, podemos describir las posibles acciones de usuario, así como los estados críticos del sistema. Por ejemplo, la descripción del mecanismo de encendido de una lámpara se puede describir del siguiente modo.

Se puede utilizar para la descripción de mecanismos de interacción más complejos, como por ejemplo, para la especificación de un portapapeles.

Sin embargo, un problema asociado a este tipo de descripción es la explosión combi-natoria de estados en cuanto existan diálogos concurrentes. Por ejemplo, las dife-rentes opciones para el estilo del texto (itálica, negrita, subrayado, etc.) provocan una explosión combinatoria de 2n estados, con n siendo el número de opciones.

Figura 15 Descripción de un portapapeles

Redes de Petri

Si consideramos los sistemas interactivos como un caso particular de sistemas reac-tivos, podríamos utilizar todas las técnicas y herramientas que se disponen para la especificación y diseño de sistemas concurrentes. Existen abundantes referencias de la utilización de Redes de Petri, CSP o LOTOS para la descripción de procesos, sin-cronizaciones, eventos y no determinismo. Dentro de todos estos formalismos uno de los mas usados a la hora de especificar la naturaleza concurrente de un sistema interactivo son las Redes de Petri.

Figura 16 Red de Petri para las opciones del texto

Es uno de los formalismos más antiguos en computación para una representación gráfica de actividades concurrentes. En un STN, el sistema se encuentra en un es-tado en cualquier instante y se puede simular el comportamiento siguiendo los arcos. La red de Petri es similar, pero con la diferencia que puede tener varios estados al mismo tiempo. Una red de Petri se compone de lugares (círculos) transiciones (rec-tángulos) y marcas (que pueden cambiar de lugar mediante una transición). Por ejemplo, para especificar la concurrencia de opciones (negrita, cursiva) para el texto se puede realizar de forma sencilla con redes. Las acciones del usuario están explíci-tamente recogidas así como el estado del sistema (mediante las Marcas).

Los lugares elípticos representan las acciones del usuario. La regla de las redes de Petri es que si todos los lugares de una transición poseen Marca (están Marcados), la transición se puede disparar. En este ejemplo, la acción

50

del usuario “pulsar negri-ta” provocará la transición T1 que desactiva la negrita. La siguiente pulsación del usuario “pulsar negrita” provocaría que en este caso, se disparase la transición T2. Se puede describir arcos inhibitorios, como por ejemplo, no puede suceder T3 mien-tras que esté el contador en Negrita (on).

Diseño orientado a objetos

Los interfaces de usuario son muy adecuados para un desarrollo basado en el para-digma de objetos [COX93], ya que el sistema está formado por componentes de naturaleza manipuladora (interactiva) con representación gráfica y en la que existe una gran vinculación (mediante herencia) de unos componentes con otros.

Una estructura típica del modelo conceptual es un conjunto de objetos capaces de realizar una serie de acciones (modelo objeto–acción).

• Objetos: Un objeto es un elemento de información sobre el que el usuario tiene algún control. El conjunto de objetos posee usualmente alguna estruc-tura. Dicho conjunto es una visión abstracta de la información gestionada por el sistema (modelo).

• Acciones: Una acción es una operación que el usuario puede realizar con un objeto. El conjunto de acciones define la capacidad funcional del sistema. El conjunto de acciones no tiene que ser necesariamente ortogonal al de los objetos. Estas acciones serán las tareas que debe realizar el usuario para manipular los objetos del dominio de la aplicación.

Ejemplo: Flexo. Un flexo dispone de una bombilla, un interruptor y una clavija de enchufe. El interruptor puede estar en una de dos posiciones (encendido o apagado), la clavija se puede conectar y desconectar a una base de enchufe. Cuando la clavija está conectada a una base en buen estado y el interruptor esta en la posición de encendido, la bombilla se ilumina.

Podemos identificar dos tipos de objetos: a) aquellos que aparecen en la comunica-ción entre el usuario y el sistema y que típicamente pertenecen a la interfaz (obje-tos de control), y b) los que son propios de la aplicación (objetos intrínsecos). Por ejemplo, una barra de iconos, una regla o una ventana son objetos intrínsecos con acciones propias (mover, ocultar, redimensionar, etc.) mientras que el registro de una persona es un objeto de control susceptible de aplicarle acciones del dominio de la aplicación (insertar, modificar, ver DNI, etc.). Para la descripción de los objetos y de las acciones podemos usar metáforas que ayuden a comprender su significado y utilización (ver capítulo ‘Metáforas, estilos y paradigmas’).

Para la especificación del sistema deberemos identificar tanto a los objetos como a sus acciones asociadas. Los objetos se describen identificando sus atributos más relevantes. Uno de los más importantes es su representación

51

gráfica. Para describir las acciones se puede utilizar una notación de diálogo basada en diagramas de esta-do y lenguaje de órdenes (secuencia). El lenguaje de órdenes nos daría información necesaria acerca del protocolo (qué acción se realiza), mientras que el diagrama de estado indicaría cómo cambia el estado de los objetos con las modificaciones (cómo implementarlo).

Lenguaje de órdenes

En un sistema interactivo basado en objetos, podemos identificar un conjunto de órdenes que deben aparecer en el modelo para poder representar y manipular los objetos del interfaz de modo gráfico e interactivo. Alguna de ellas son:

• Selección/deselección de un objeto

• Búsqueda/Identificación de un objeto

• Creación/eliminación de objetos

• Mover/copiar objetos

• Obtener/cambiar valores de los atributos del objeto

• Visualización del objeto

Además podemos encontrarnos con objetos complejos que poseen acciones específi-cas:

• Agrupación. Es un objeto formado por otros objetos. Se pueden ubicar y eliminar componentes así como conocer sus valores.

• Colección. Es un objeto que contiene un número variable de objetos. Se pueden añadir nuevos objetos, eliminar, ordenar/clasificar, etc.

Lenguaje modal

Un modo es un estado (o conjunto de estados) en cual se puede realizar un conjunto de posibles tareas de interacción por el usuario [FOL90]. Ejemplos de diálogos modales son:

• Estado en el cual se permite que un conjunto de órdenes se pueda aplicar únicamente al objeto/s seleccionado/s (modos sobre selecciones).

• Estado en el cual se debe completar un cuadro de diálogo antes de hacer otra operación (ventana modal).

• Estado en el cual se usa un programa externo para modificar un objeto (gráfico, diagrama, etc.).

52

Los modos pueden aparecer por la estructura que posea el lenguaje de órdenes. Las sintaxis del lenguaje puede tener las siguientes estructuras:

1) Acción–Objeto. En primer lugar se identifica la acción a realizar y a continua-ción se aplica sobre el/los objeto/s. A nivel de sintaxis esto está asociado a la posibilidad de que existan producciones del tipo

O ::= c c

en las que el significado de ambas opciones sea diferente (=copiar, =borrar). En tal caso el lenguaje es modal, ya que la interpretación de una entrada depende del estado (previo) de la aplicación.

2) Objeto–Acción. En este caso, primeramente se selecciona el objeto de inte-rés al que se va a aplicar la acción. Se puede utilizar la selección múltiple. Esta sintaxis es especialmente adecuada para paradigmas basados en la manipula-ción directa, ya que primeramente se identifica el objeto sobre el que se quiere actuar.

Los modos pueden ser beneficiosos o perjudiciales según el uso que se haga de ellos. Los diálogos modales que no son perceptibles (visibles por el usuario) y que no tienen un significado coherente aumentan la probabilidad de error por parte del usuario y su dificultad de aprendizaje. Un dialogo modal bien diseñado deberá indicar claramente el modo actual (por ejemplo inserción/sobreescritura en un editor), suministrar información acerca de las órdenes disponibles y disponer de significados intuitivos para las acciones asociadas.

6 Modelos abstractos

El estudio de los sistemas interactivos como sistemas reactivos permite estudiar pro-piedades relacionadas con estos sistemas tales como la ausencia de interbloqueos o inanición. Sin embargo, desde el punto de vista de la interacción con el usuario, las propiedades deseables del sistema están relacionadas con la parte de interacción con el humano, tales como: las propiedad de comenzar nuevamente (Restartability), deshacer la última acción en cualquier momento (Undo), utilizar toda la funcionalidad de la aplicación (completitud), capacidad para cancelar en cualquier momento la ejecución de una tarea, observación en todo momento del estado del sistema (Ob-servabilidad), etc.. Básicamente este tipo de propiedades de interés se pueden re-sumir en los siguientes casos:

1) Predecibilidad. Se trata de reconocer y predecir cual será el efecto futuro del sistema ante una nueva interacción. Esta propiedad permite medir la consistencia del sistema.

53

2) Alcanzabilidad. Esta propiedad permite razonar y determinar si el usuario tie-ne acceso en todo momento a la funcionalidad del sistema. Esta propiedad permite medir la completitud del sistema.

En este sentido, los métodos que se utilizan son meramente descriptivos. La nota-ción y el fundamento matemático en el cual están basados permiten expresar propiedades y por tanto, se podrán utilizar para razonar y verificar ese tipo de propiedades.

El Modelo PIE

El modelo PIE [DIX91] ofrece una visión externa del sistema, donde se recoge el comportamien¬to visible por parte del usuario. Bajo este modelo de caja negra, PIE describe el sistema en base al efecto perceptible que produce la interacción (entra-das de usuario) sobre el sistema. Las entradas son un conjunto de órdenes (P) que forman parte de un programa. El efecto (E) observado por el usuario es resultado de un proceso de interpretación (I), de modo que para cada entrada posible, podemos obtener su interpreta¬ción como una función de transformación del dominio de las entradas al dominio de los efectos:

Figura 17 Red–PIE

En este modelo abstracto, P representa las entradas de usuario, E representa el efecto producido, mientras que I es la función de interpretación.

Un problema de predecibilidad se podría expresar formalmente mediante la pro-piedad de monotonía, del siguiente modo:

p1,p2 P: I(p1) = I(p2) p P : I(p1·p) = I(p2·p)

es decir, en el caso que dos tipos de entradas de usuario posean la misma interpre-tación, esto significa que el efecto será siempre equivalente, cualquiera que sea el estado del sistema (dado por acciones previas). En caso de no satisfacerse esta propiedad, tendríamos un sistema ambiguo en donde no podríamos predecir el resul-tado de las acciones a partir de la interacción del usuario, el sistema no es determi-nista.

Desde este punto de vista, el concepto de efecto es muy amplio, por lo que usual-mente se utilizará el modelo red–PIE que extiende el modelo anterior para diferenciar el efecto que es percibido por el usuario (D) del resultado que es alcan-zado por el sistema (R).

Figura 18 Red–PIE

54

Mediante esta aproximación, se podría establecer relaciones entre el estado del sis-tema (R) y la observación del usuario (D). El problema de los sistemas no pre-decibles puede estar ocasionado porque existan efectos que modifican el estado del sistema y que no sean percibidos por el usuario (no son observados). Por tanto, se deberá enunciar la predecibilidad desde el punto de vista de la percepción del usua-rio, es decir:

p1,p2 P: d(I(p1)) = d(I(p2)) p P : I(p1·p) = I(p2·p)

La propiedad de alcanzabilidad garantiza que se puede realizar cualquier tarea so-bre la interfaz de usuario, independientemente del estado actual del sistema, es de-cir:

p,q Pr P : I(p·r) = I(q)

La opción de deshacer una orden (undo) será un caso particular de alcanzabili¬dad.

Este mecanismo es simple pero potente para hablar de propiedades. Sin embargo, el modelo es demasiado abstracto como para su utilización para el diseño y desarrollo de sistemas interactivos, y no permite la descripción de sistemas asíncronos debido a su carácter determinista.

7 Estrategia de diseño

Con los modelos que se disponen de las tareas y de la arquitectura del sistema, de-beremos guiar el diseño para obtener una implementación correcta. Este proceso en algunos casos puede ser automático, pero en la mayoría de los casos, requerirá de un profundo reconocimiento de los aspectos más delicados del proceso de diseño y que está directamente relacionados con el diálogo con la máquina y la presentación de la información. Nos centraremos en los mecanismos básicos de interacción y el diálogo con la aplicación y la capa de presentación.

Tareas de interacción

Cuando el usuario realiza una interacción con el ordenador, introduce una unidad de información que posee significado en el contexto de la aplicación. EL tipo de interac-ciones que se pueden realizar en el sistema son [FOL90]:

• Posicionamiento. Obtención de una posición u orientación. La posición puede ser en cualquier dimensión (2D, 3D). Se puede usar para dibujo, si-tuar ventanas, arrastrar elementos, etc.

• Valor. Obtención de un dato cuantificable, ya sea numérico (por ejemplo, el número de página, nº de copias, etc.) o porcentual (p.e. barra de progre-sión).

55

• Texto. Introducción de un texto o identificador (nombre de fichero, apelli-dos, etc.).

• Selección. Obtención de una alternativa (de entre varias posibles). Se pue-de distinguir entre la selección sobre un conjunto finito o bien de tamaño variable, en el cual la opciones pueden ser alternativas disyuntivas o no.

• Arrastre. Secuencia de posiciones entre una posición inicial y otra final (por ejemplo movimiento de una carpeta con el ratón).

A cada una de estas interacciones podemos aplicarles un conjunto de técnicas que nos permitan facilitar y flexibilizar el modo de obtención de la información.

Tarea de posicionamiento

Esta tarea consiste en la obtención de una coordenada 2D o 3D. La acción que se realiza es la de mover un cursor por pantalla para introducir un valor, o introducir la coordenada directamente. Algunos de los aspectos a tener en cuenta son:

• Sistema de coordenadas. El movimiento del objeto puede ser en función de un sistema de coordenadas del propio objeto, de la pantalla o del mundo. Este factor es muy importante en los sistemas de modelado de posiciona-miento 3D (Realidad Virtual).

• Resolución: En caso de movimiento con un dispositivo (cursor) las posiciones pueden ser discretas o continuas. Habrá que tener en cuenta la relación Control/Display (C/D) para mecanismos de posicionamiento indirecto, es de-cir, la distancia que hay que mover el puntero (ratón) en la mesa para obtener una nueva posición diferente en pantalla.

• Restricciones. Se puede utilizar elementos que ayudan al posicionamiento como la rejilla (grid) que facilitan la introducción de los puntos ajustados a valores. Esta rejilla puede ser direccional (sobre una única dirección) modu-lar (restringido a una retícula) o gravitacional (a unos puntos sensitivos).

• Realimentación. La realimentación puede ser espacial (visualización gráfica del cursor en pantalla), relacionada con otros elementos), o lingüística (re-presentando el valor numérico en coordenadas cartesianas).

Figura 19 Diferentes técnicas de ayuda en el posicionamiento

Tarea de selección

Esta tarea básica consiste en la selección de un elemento de entre un conjunto (de órdenes, atributos, objetos..). El conjunto puede ser:

56

• Tamaño fijo: Elementos invariables (órdenes, etc.)

• Tamaño variable: Elementos de la aplicación (objetos)

La tarea de selección se puede realizar de los siguientes modos:

• Mediante identificador: La selección se realiza introduciendo el identificador del objeto (nombre)

• Apuntando: Búsqueda espacial del objeto mediante un dispositivo apuntador (ratón)

Figura 20 Selección en lista variable de objetos (gráficos)

La selección sobre conjunto de objetos de tamaño variable se organiza sobre listas dinámicas o bien en ventanas (que actúan como contenedores) donde se disponen los elementos con diferentes alternativas de presentación (gráfica, textual, icónica, etc.) y modo de ordenación.

La selección sobre conjuntos de tamaño fijo utiliza otros mecanismos de representa-ción. Uno de los más utilizados es la presentación mediante menús y se usa para la selección de órdenes. Cada orden es un ítem dentro del menú, y se pueden utilizar diferentes técnicas para estructurar el conjunto de elementos (jerarquías, separa-ciones, atajos, etc.).

Figura 21 Organización de un menú

Otras posibles representaciones para la selección son los botones (o conjuntos de botones agrupados en barras de iconos). Los botones pueden tener una representa-ción gráfica icónica o bien estar basado en el texto. Se pueden inhabilitar botones (representados en un tono claro) en caso que la orden no esté activa en ese mo-mento.

Figura 22 Barra de botones (icónica)

Otras estructuras para la selección son la listas en sus diferentes representaciones (desplegables) o fijas.

Para el caso de selección sobre valores lógicos, se utilizan elementos que represen-ten dos posibles estados (seleccionado o no). Generalmente se utiliza la casilla de verificación como elemento gráfico que representa un valor lógico (si no aparece pulsada equivale a falso/no). En caso de seleccionarse la casilla, aparece un símbolo () que recuerda a una marca hecha con bolígrafo.

57

En caso de casillas de verificación, podemos encontrarnos conjuntos de cuestiones donde las opciones son mutuamente excluyentes (sólo se puede seleccionar una de las casillas). Para diferenciar estos dos tipos de casillas gráficamente, tradicional-mente se ha utilizado una representación circular para las selecciones excluyentes y cuadrada para las casillas de comprobación. Estas casillas pueden estar incluidas en los menús.

Figura 23 Casillas de verificación

En ambos casos de selección, ya sea de tamaño fijo o variable, un factor muy importante es la ubicación espacial de los ítems (órdenes, objetos) para su rápida selección, el texto del identificador (para su reconocimiento) y la organización se-mántica (para recordar su posición).

Tarea de introducción de texto

Esta tarea consiste en la introducción de información textual. Existen alternativas a la introducción de texto por teclado como son los reconocedores de caracteres (OCR) y de gestos. Un aspecto importante relacionado con el texto es su resolución (tamaño en pantalla), que se mide en puntos o píxels. Se deben utilizar tamaños y tipos de letra que sean legibles y proporcionales a la resolución de pantalla que po-sea en ese momento el usuario. El texto puede ser longitud variable y ocupar más de una línea, por lo que se consideran dos tipos de presentación, una entrada de tamaño fijo (con posible control del formato) o un área de texto (con uso de deslizadores).

Tarea de introducción de valor

Esta tarea consiste en la introducción de un dato cuantificable. En caso de identificar un número, la forma habitual es mediante el teclado numérico, aunque en deter-minados casos, se utilizan representaciones gráficas (diales, deslizadores, etc.) que ayudan a una introducción mediante ratón.

Figura 24 Deslizador

En caso de valores porcentuales (sobre un valor de tamaño variable o de tiempo para completar una acción) también se pueden utilizar representaciones, pero en este caso, no son directamente manipulables por el usuario (son informativas).

Figura 25 Barra de progresión y de posición

Tarea de arrastre

58

Esta tarea consiste en la introducción de una secuencia de posiciones que denotan un movimiento. Esta tarea típicamente se ha utilizado para describir explícitamente manipulaciones de objetos gráficos (mover, rotar, escalar), y que ha sido utilizada para dar significado a las operaciones de un sistema de escritorio (drag and drop) y en operaciones de diseño gráfico. Esta tarea requiere de una realimentación continua del objeto desplazado (puede ser una instancia, una línea/caja elástica, un punto de una curva, etc.).

Gestión de entradas del usuario

La gestión de entradas se puede hacer mediante distintas técnicas de interacción entre aplicación–dispositivo [OLS98]. Esta interacción se puede realizar en diferentes modos: pregunta–respuesta, ordenes, etc. Los eventos es el principal mecanismo para la comunicación entre el usuario y el sistema interactivo. Cuando el usuario interacciona con los dispositivos, estas acciones se trasladan a eventos software que se distribuyen a la ventana apropiada (en un sistema de ventanas). Todos los even-tos están identificados (mediante un tipo de evento) que permite al software que los recibe distinguir la información que se pretende comunicar.

Se puede establecer tres mecanismos de comunicación entre usuario y aplicación:

• Petición (request). El programa espera hasta que se produzca una entra-da. Los Dispositivos están en espera. Es un diálogo dirigido por la aplicación.

• Muestreo (sample). Ambos trabajan concurrentemente. Consulta del es-tado del dispositivo al realizar una petición. Los datos no son almacenados, por lo que se consulta el estado actual.

• Evento (event). Se provee de una cola de sucesos por parte del dispositi-vo. La aplicación está dirigida por los datos, y permite entradas asíncronas.

Los sistemas interactivos son programas dirigidos por eventos, y su estructura difiere de las aplicaciones tradicionales de procesamiento y de cálculo. El cuerpo principal del programa es simplemente un ciclo de obtención de eventos.

Inicialización

While(not salir) {

Obtener siguiente evento E

Gestionar evento E

}

59

Cola de eventos. Existen diferentes modelos para distribuir los eventos a los obje-tos. Al manipular el sistema interactivo, los eventos se ponen en una cola de even-tos. Todos los sistemas de ventanas poseen rutinas para obtener el siguiente evento de la cola. A menudo, los eventos no poseen suficiente información como para ser procesados o son irrelevantes (movimiento continuado del ratón, pulsación de teclas no habilitadas), por lo que se deben proveer mecanismos de filtrado para eliminar aquellos eventos que no son significativos.

Algunos de los tipos de eventos que podemos encontrar son:

• Eventos de entrada. Son los generados por el usuario. Clasificación: even-tos del ratón. El evento del ratón siempre posee la posición actual del ratón. Teclado: Se puede considerar un array de botones de ratón (uso de modifi-cadores)

• Eventos de las ventanas. Se reciben de la propia ventana. La mayoría de los sistemas de ventanas envían un evento de creación/destrucción de la ventana, que permite al código de la aplicación gestionar la acción pertinen-te. Tipos de eventos: crear/destruir, abrir/cerrar, iconificar/deiconificar, re-dimensionar, mover, etc.

• Eventos definidos por el usuario. Eventos de alto nivel creados por soft-ware.

Comunicación entre objetos

Un punto importante de la gestión de eventos es la comunicación con otros objetos interactivos. Un ejemplo de ello es el movimiento de la barra de deslizamiento, que provoca el cambio del texto presentado (relación entre dos componentes interacti-vos). Esta comunicación se realiza mediante pseudo–eventos (eventos que han sido creados por la comunicación entre objetos, y no son realmente eventos de entrada).

En sistemas de ventanas no orientados a objetos, un evento consiste en un registro de un tipo (entero), información estándar y otra adicional suministrada por el objeto que origina el evento. Existen tres modelos básicos para este tipo de comunicación:

• Modelo de llamadas (callbacks). Permite asociar un procedimiento (có-digo C) a un widget en tiempo de ejecución. Por ejemplo, se utiliza en sistemas de ventanas como Motif, y primeras versiones de Xwindows y lenguajes como Xtk, TK.

• Modelo de notificación. Cada componente interactivo notifica a su ventana padre (de la que depende jerárquicamente) la ocurrencia de un evento significativo. Este modelo se utiliza en las primeras versiones de MS Win-dows.

60

• Modelo de conexión o delegación. Permite a un objeto comunicarse con cualquier otro objeto (u objetos) mediante registro de los objetos recepto-res para un determinado evento. Modelo utilizado en NexTStep o Java.

1) Modelo callbacks. Un callback es un procedimiento que se ejecuta inmediata-mente después que se produce el evento. En Tcl/Tk, la conexión entre objetos (interactivos) evento y procedimiento se realiza mediante la siguiente orden

bind .boton1 <Left-Button> { puts "Boton %b situado en %x,%y" }

Con esta orden se asocia al objeto interactivo “.boton1” cuando sucede el evento <Left-Button> (pulsación del botón izquierdo del ratón) una secuencia de órdenes entre llaves.

2) Modelo de notificación. Suministra un mecanismo interactivo más estructurado. Los componentes notifican a la ventana de nivel superior el evento sucedido. La ventana padre posee todo el código para decidir qué realizar con los eventos recibidos. Se puede prestar atención a eventos específicos (por ejemplo a eventos de aceptar–rechazar dentro de una ventana de opciones), que dirigen el modo de consulta y obtención del resto de eventos.

3) Modelo de conexión de objetos. Permite a los objetos comunicarse directa-mente entre ellos. Por ejemplo: comunicación entre la barra de desplaza-miento con el editor de textos, invocando un método del objeto editor de tex-tos.

La organización de la información afecta a la impresión general del interfaz. Debe incluir los siguientes elementos:

• Diseño (formato de pantalla, organización general)

• Representación de la información (métodos de codificación)

• Realimentación (seguimiento)

• Comunicación con el usuario (errores, mensajes de estado, etc.)

En el nivel de presentación se debe mostrar la información de forma que sea com-prensible y asimilable por el usuario. Se puede pecar de exceso de información (pro-vocando fatiga y desbordamiento al usuario) o demasiado sobria (la falta de información puede causar incertidumbre). Hay que tener en cuenta que el espacio donde se presenta la información es escaso, por lo que deberemos hacer un uso racional de este recurso. La distribución (no oclusiva) de la información es un factor muy importante, y podemos jugar con diferentes tipos de diseño: uso de zonas fijas o que se puedan ocultar (de forma dinámica), disposición del área trabajo: menús, mensajes, información de estado, etc.

61

Para la representación de objetos deberemos utilizar una simbología y codificación para que sea fácilmente identificable, económica en recursos (tamaño en pantalla) y consistente (iconografía, colores, texto, etc.) (ver capítulo ‘El diseño gráfico’).

Diseño de la presentación

El significado de una imagen puede ser más fácilmente percibido por el observador si posee claridad visual. Deberemos por tanto enfatizar la organización lógica de la información. Para conseguir una buena organización se puede utilizar las reglas de Gestalt, que permiten mejorar la claridad visual de la información. Estas reglas se basan en cómo organiza el observador los estímulos visuales (de forma global) y que se pueden resumir en los siguientes principios:

• Similitud. Objetos similares próximos se interpretan como una representa-ción conjunta/agrupada

• Proximidad. Elementos visuales con propiedad común se interpretan como agrupados

• Cierre (clausura). Elementos visuales que tienden a cerrar un área se in-terpreta como cerrada

• Continuidad (determinación de formas). Discriminación de elementos di-ferentes según la continuidad natural

Figura 26 Reglas de claridad visual (Gestalt)

Estas reglas se aplican frecuentemente al diseño visual de los sistemas gráficos, como por ejemplo en la colocación de los botones, elementos de menú, organización general del interfaz, etc.

La claridad visual afecta a la impresión general de la interfaz. Al reforzar la claridad visual, promovemos las relaciones lógicas entre elementos (por ejemplo, mi-nimizando el movimiento ocular para obtener información).

Figura 27 Aplicación de reglas a ventana de diálogo

Podemos organizar la pantalla de la interfaz siguiendo algunas reglas efectivas de diseño.

• Balanceado. Consiste en el ajuste de la visión con el área de visualización. El balanceado es la búsqueda de equilibrio entre los ejes horizontal y vertical en el diseño. Si se asigna un peso a cada elemento visual,

62

se debe conse-guir que la suma en cada eje sea similar. Se debe buscar un centro de gra-vedad en sentido horizontal y vertical, ya que de lo contrario, se crearía una inestabilidad.

Figura 28 Pantalla balanceada (izda.) e inestable (dcha.)

• Simetría. Consiste en duplicar la imagen visual a lo largo de un eje de simetría. Esta técnica automáticamente asegura el balance.

Figura 29 Pantallas con diferentes simetrías

• Regularidad. Técnica visual para establecer uniformidad ubicando los ele-mentos de acuerdo con una distribución regular en filas–columnas.

• Alineamiento. Puntos de alineación que existen en el diseño. Se debería minimizar.

• Enrejillado. Separación y acentuación la organización entre áreas.

Figura 30 Pantalla con enrejillado y alineamiento (izda.)

Para obtener estas distribuciones de contenedores y componentes dentro de la pan-talla, deberemos utilizar los controladores geométricos (layout manager) que nos facilitan las librerías de diseño de interfaces. Podemos utilizar desde los más simples (posiciones absolutas, ordenación de izda. a dcha.) a los más complejos, que asignas proporciones relativas para cada elemento, tamaño de expansión, offset, etc.

Figura 31 Controlador geométrico reticular con restricciones

Realimentación

La realimentación es de gran importancia en los sistemas interactivos, ya que el usuario debe estar informado en cada momento de las acciones que realiza. Cuando por ejemplo una tarea tarda más tiempo del razonable, se deberá informar me-diante algún tipo de mensaje de ese proceso para no provocar incertidumbre. Sin embargo, un problema que deberemos tener en cuenta es que tenga una gestión rápida, ya que en tal caso puede no coincidir el estímulo con la respuesta del sis-tema. Algunos ejemplos de realimentación son:

• Sobre las órdenes. Mostrar efectos, errores, confirmación, indicadores

63

• Sobre la selección. Resaltar de forma no ambigua la orden activa

Esta realimentación debe ser fácil de leer y entender. Para ello se debe fomentar la consistencia, y en algunos casos puede condicionar la estructura de datos del mo-delo, ya que sea necesario almacenar información adicional para realizar el feedback.

Para su diseño, se debe estudiar las acciones de cada tarea y ver como es la inter-acción (realimentación del propio gesto), confirmación (selección, mensajes, ilumina-ción) y posibles errores (pantalla de aviso) La realimentación informa al usuario acerca de su interacción con el sistema. Indica qué está haciendo y le ayuda a realizarlo correctamente. Se puede utilizar cualquier combinación de canales sensoriales (sonoro, visual, táctil, etc. ).

Se puede clasificar la realimentación por su dimensión temporal:

• Futura. Realimentación de una acción antes de llevarla a cabo. Indica qué sucederá si se realiza una acción (por ejemplo, etiqueta informativa de los botones).

• Presente. Realimentación durante la interacción. Indica qué esta sucedien-do actualmente (p. e. borrado de ficheros, formateando, mover cursor..).

• Pasada. Información de lo que ha sucedido, y cómo ha cambiado el sis-tema (p. e. información de finalización de tareas).

Gestión de errores

Sobre un sistema, un factor crítico desde el punto de vista del usuario, es cómo se organizan los mensajes de error y su explicación. Normalmente ocurren por un des-conocimiento por parte del usuario que puede ser motivado por diferentes causas:

• Errores por acciones del usuario. Error en la traslación entre la intención del usuario y su acción (intención correcta, pero realización incorrecta). La solución es mejorar el diseño ergonómico, mejorar los aspectos físicos del diseño (ubicación de menús, tamaño, posición, visibilidad, color, etc.)

• Errores por las intenciones del usuario. El usuario realiza una acción equivocada. El modelo de usuario no es correcto. La solución es mejorar el modelo mental. Es importante buscar posibles causas ya que el usuario está asumiendo un modelo mental incorrecto.

El usuario, ante un error, debe reconocer qué ha sucedido, para evitar confusión. Algunas técnicas que se deben evitar en los mensajes de error son:

64

• Tono imperativo. Aumenta la ansiedad del usuario. Dificulta la corrección del error ("Acción ilegal", "error fatal", “terminación anormal del progra-ma”).

• Mensajes genéricos o confusos. Ofrecen poca información ("error sintác-tico", “run time error n. XXXX”).

Un estudio de la distribución y frecuencia de errores puede ayudar al diseñador, al mantenimiento del producto y al posible usuario mediante una conveniente documen-tación.

ConclusionesEn este capítulo hemos visto las características más relevantes de los sistemas in-teractivos y las dificultades que se plantean a la hora de realizar un diseño efectivo. Si bien para el diseño de sistemas interactivos existe abundante bibliografía, la ma-yoría está basada en recomendaciones, consejos y guías de estilo para el diseño que están recogidas de la experiencia de los autores. Sin embargo, raramente aportan una metodología clara para llevar a cabo de forma sistemática el proceso de diseño. En este capítulo hemos incluido diferentes propuestas metodológicas basadas en teorías cognitivas para el diseño defectivo de aplicaciones interactivas.

Para ello, deberemos aplicar notaciones que permitan analizar las tareas que el usuario realiza en su entorno de trabajo, y utilizar técnicas para su traducción a conceptos de diseño. Posteriormente, hemos visto modelos arquitectónicos que proponen la arquitectura básica (sobre la base de componentes interactivos) que debe poseer el sistema, y por último, hemos aplicado una serie de técnicas que nos permitan trasladar de forma efectiva el modelo conceptual del sistema a un modelo computacional basado en eventos y componentes gráficos.

Se llama mecanización a la incorporación de má-

quinas en la realización de determinadas tareas. Así,

se habla de la mecanización del campo, cuando a las

tareas agrícolas se han incorporado máquinas por todos

conocidas como el tractor, el arado o la cosechadora.

65

También se habla del mecanizado de piezas en

un taller, cuando para su fabricación se utilizan máquinas

como tornos o fresadoras, es decir, cuando se

abandona la fabricación manual y se sustituye por procesos

mecanizados que permiten mejores acabados y

mayor rapidez en la confección de elementos.

Un paso más allá es la automatización, considerada

como la supresión parcial o total de la intervención

de las personas en la realización de tareas productivas,

como las tareas agrícolas, industriales o administrativas.

Los autómatas son un caso muy conocido de control,

ya tradicional, que se ha venido aplicando a aquella

clase de máquinas en las que una fuente de energía

acciona un mecanismo, que permite imitar los movimientos

de los seres animados. Se conocen autómatas

que fueron construidos por los griegos en el templo de

Dédalo; sin embargo, uno de los casos más difundidos

es el del Pato de Vaucanson (Grenoble 1709-París

1782) construido en 1738, que era un pato artificial

capaz de batir las alas, zambullirse, nadar, tragar grano

e incluso expeler una sustancia parecida al excremento.

Otro caso de autómatas célebres aunque más

próximo a nuestro tiempo es el del jugador de ajedrez

de Torres Quevedo, construido en 1912, capaz de jugar

finales de partida (rey contra rey y torre). Pero debe

ponerse de manifiesto que los autómatas siempre repiten

el mismo modelo de actuación, no son reprogramables

66

y tampoco son capaces de variar sus acciones

en función del entorno o la situación.

El control numérico es la supervisión y regulación

de determinadas tareas mecánicas de precisión, realizadas

por una máquina herramienta. El control de estas

tareas se realiza de forma automática para evitar,

de este modo, que el control se lleve a cabo por un operario

que, en ocasiones, podría verse sometido a ciertos

riesgos en un proceso donde es imposible erradicar

los errores humanos. De esta forma, se ajusta al máximo

la precisión en la confección de piezas estandarizadas

y se libera al operario de su control, mejorando la

calidad y la cantidad del trabajo realizado. Un ejemplo

de control automático es el control de la velocidad

de giro de un taladro o la velocidad y control de avance

de un torno o fresadora. Otro sistema de control automático

es el servocontrol. Consiste en controlar, de

forma automática, las acciones de una máquina en función

de unos parámetros definidos y sus variaciones.

Por ejemplo, el servocontrol se puede utilizar para controlar

la velocidad de giro de un torno, de forma que

se mantenga fija dentro de unos límites. Otro ejemplo

de servocontrol podría ser el del freno de algunos vehí-

culos en los que la fuerza transmitida a las ruedas es

proporcional a la fuerza aplicada por el conductor sobre

el pedal del freno; de esta función se encarga un

mecanismo servocontrolado que se llama servofreno.

67

La robotización es también una automatización de

procesos sin la intervención humana, pero en este caso

se da un paso más; hay desplazamiento de cargas, manipulación

de objetos y un fuerte componente de realimentación.

Es decir, este tipo de automatización permite

la manipulación automática y programable de acciones

y objetos. La realimentación es un proceso imprescindible

en la robotización, ya que dota a un proceso

de capacidad para captar información que, una vez

procesada por la máquina, permite modificar su comportamiento

(sus acciones). Una máquina que posea la

capacidad de realimentación, es capaz de modificar

sus respuestas en función de las variaciones de su entorno.

Centrando el análisis en las diferencias que existen

entre automatización y robotización, puede decirse

que una máquina automatizada (autómata) responde

siempre de igual manera ante sucesos de idéntica naturaleza.

Mientras que por el contrario un robot, es decir,

una máquina robotizada, se caracteriza porque puede

manejar objetos y, lo más interesante, es un dispositivo

multifuncional y reprogramable. Una máquina robotizada

es capaz de hacer trabajos totalmente diferentes y

adaptarse al medio, ya que puede tomar decisiones en

función de las condiciones exteriores.

La totalidad de los procesos de mejora y control de

la producción pueden sintetizarse en tres fundamentales:

Procesos de mecanización, procesos de automatización

68

y procesos de robotización. Las principales características

de cada uno de estos tres grupos se exponen

en el cuadro de la figura 1.

La Computadora

Como Sistema de Control

La aparición del computador en la década de los

40, acelera vertiginosamente el desarrollo de autómatas

y robots. La cuestión es: ¿podemos hacer servir lal

PC como un autómata o un robot?. Para poder respon-

53

der es preciso verificar si se cumplen las siguientes

condiciones:

¿Podemos conectarle sensores?

¿Podemos conectarle actuadores?

¿Podemos programarlo (y reprogramarlo) para

que tome decisiones en función de los sensores y de

instrucciones previas para que los actuadores operen

en consecuencia?

La respuesta a las tres cuestiones es afirmativa ya

que:

“La PC cuenta para comunicarse con sus periféricos,

incluso en su versión más básica, con diversos dispositivos

de entrada: puertos paralelo y serie, USB,

joystick, micrófono... Además,

es posible agregarle

tarjetas especializadas

que añaden otras muy diversas

69

clases de entradas”

También cuenta con

varios dispositivos de salida:

puertos paralelo y serie,

USB, sonido, video...

Asimismo, se pueden añadir

tarjetas especializadas

que expanden el número y

tipo de entradas.

Por otras parte, son

muchos los lenguajes de

programación utilizables

en la PC que permiten leer

las entradas y modificar

las salidas: BASIC, LOGO,

Pascal, C, Ensamblador,

etc. (figura 2).

El Puerto de la PC Introducción

Hace años, IBM diseñó el puerto paralelo para

manejar impresoras desde su gama de microcomputadores

PC/XT/AT. Un conector estándar macho de 25

pines aparecía en la parte trasera de la PC con el solo

propósito de servir de interfaz con la impresora. El

sistema operativo DOS cargado en dichas PCs soporta

hasta tres puertos paralelos asignados a los identificadores

LPT1, LPT2 y LPT3, y cada puerto requiere tres

direcciones consecutivas del espacio de E/S (entradasalida)

70

del procesador para seleccionar todas sus posibilidades.

Desde el punto de vista del hardware, el puerto

consta de un conector hembra DB25 con doce salidas

Figura 1

Figura 2

54

latch (poseen memoria-

/buffer intermedio) y

cinco entradas, con

ocho líneas de tierra.

Desde el punto de

vista del software, el

puerto paralelo consta

de tres registros (datos,

estado y control) de 8

bits cada uno, que

ocupan tres direcciones

de E/S (I/O) consecutivas

de la arquitectura

x86 (figura 3).

La función normal del

puerto consiste en

transferir datos a una

impresora mediante 8

líneas de salida de datos,

usando las señales

restantes como control

71

de flujo. Sin embargo,

puede ser usado como

un puerto E/S de propósito

general por

cualquier dispositivo o

aplicación que se ajuste

a sus posibilidades

de entrada/salida.

Descripción del

Conector Físico

La conexión del

puerto paralelo al mundo

exterior se realiza

mediante un conector

hembra DB25. Observando

el conector de

frente y con la parte

que tiene mayor número

de pines hacia arriba

(figura 4), se numera

de derecha a izquierda

y de arriba a

abajo, del 1 al 13

(arriba) y del 14 al 25

(abajo).

Figura 3

Figura 4

72

55

En este conector tenemos:

8 líneas (pines) son para salida de datos (bits de

DATOS). Sus valores son únicamente modificables a

través de software, y van del pin 2 (dato 0, D0) al pin

9 (dato 7, D7).

5 líneas son de entrada de datos (bits de ESTADO),

únicamente modificables a través del hardware

externo. Estos pines son: 11, 10, 12, 13 y 15, del más

al menos significativo.

4 líneas son de control (bits de CONTROL), numerados

del más significativo al menos: 17, 16, 14 y 1.

Habitualmente son salidas, aunque se pueden utilizar

también como entradas y, por tanto, se pueden modificar

tanto por software como por hardware.

Las líneas de la 18 a la 25 son la tierra.

En la tabla de la figura 5 se detallan la nomenclatura

y descripción de cada línea.

La columna “Centronics pin” se refiere a las líneas

del conector tipo Centronics usado en las impresoras.

La columna E/S se refiere al dato visto desde el lado

del PC. El nombre de cada señal corresponde a la misión

que cumple cada línea con relación a la impresora,

el periférico para el que fue diseñado el puerto paralelo.

Las señales activas a nivel bajo aparecen con

la barra de negación (por ejemplo, Strobe). Cuando

se indica alto o bajo se refiere a la tensión en el pin

73

del conector. Alto equivale a ~5V en TTL y bajo a ~0V

en TTL..

Figura 5

56

Acceso al puerto

El puerto paralelo se identifica por su dirección de

E/S (entrada/salida, I/O) base y se reconoce en sistemas

MS-DOS por el número LPT (lp en Unix/Linux).

Cuando arranca la máquina, la BIOS (Basic Input Output

System) chequea direcciones específicas de E/S en

busca de puertos paralelos y construye una tabla de las

direcciones halladas en la posición de memoria 40h:8h

(o 0h:0408h).

Esta tabla contiene hasta tres palabras de 16 bits,

cada palabra con el byte bajo primero seguido por el

byte alto. Cada palabra es la dirección de E/S base

del puerto paralelo (que denominaremos LPT_BASE en

lo sucesivo). La primera corresponde a LPT1, la segunda

a LPT2 y la tercera a LPT3. Hay que agregar que,

en MS-DOS tenemos el dispositivo PRN que es un alias

a uno de los dispositivos LPT (generalmente es LPT1, pero

se puede cambiar con la orden MODE).

Las direcciones base estándar para los puertos paralelos

son:

03BCh

0378h

0278h

74

Las direcciones son chequeadas en este orden.

La tabla de la figura 6 muestra, como ejemplo, la

memoria en un PC con dos puertos paralelo instalados

en las direcciones hexadecimales 378 y 278.

Registros

El puerto paralelo estándar (SPP) consta, como se

mencionó antes, de tres registros de 8 bits localizados

en direcciones adyacentes del espacio de E/S del PC

(vea la tabla de la figura 7). Los registros se definen relativos

a la dirección de E/S base (LPT_BASE) y son:

LPT_BASE + 0: registro de DATOS

LPT_BASE + 1: registro de ESTADO

LPT_BASE + 2: registro de CONTROL

Se hará referencia a cada bit de los registros como

una inicial que identifica el registro seguido de un nú-

mero que identifica el número de bit, siendo 0 el LSB

(bit menos significativo) y 7 el MSB (bit más significativo).

Por ejemplo, D0 es el bit 0 del reg. de datos, S7

es el bit 7 del reg. de estado y C2 es el bit 2 del reg.

de control.

Se indican con una barra de negación los bits que

utilizan lógica negativa.

En lógica positiva, un 1 lógico equivale a alto (~5V

TTL) y un 0 lógico a bajo (~0V TTL). En lógica negativa

1 equivale a bajo (~0V) y 0 equivale a alto (~5V). Lo

expresado lo podemos observar en el diagrama del

conector de la figura 8.

75

Es preciso no confundir la lógica que sigue el puerto

con la lógica que mantiene la impresora. Por ejemplo,

la impresora pone a alto Busy (pin 11) para indicar

que está ocupada. Pero en realidad, al leer el registro

de estado, Busy la interpretamos como 0 (puesto

que el pin 11 se corresponde con S7). Es decir, es como

si fuera activa en bajo (Busy).

Registro de datos (D): El registro de estado se haFigura

7

Figura 6

57

lla en LPT_BASE. Se

puede leer y escribir.

Escribir un dato en el

registro causa que dicho

dato aparezca en

los pines 2 a 9 del conector

del puerto. Al

leer el registro, se lee

el último dato escrito

(NO lee el estado de

los pines; para ello

hay que usar un puerto

bidireccional). En la figura

9 se describe el

nombre que toma cada

bit de este registro.

76

El estándar es que las salidas sean LS TTL (low

schottky TTL), aunque las hay que son de tipo OC (colector

abierto). La corriente que pueden entregar (modo

source) es de 2,6mA máximo y pueden absorber

(modo sink) un máximo de 24mA. En el puerto original

de IBM hay condensadores de 2,2nF a masa. Las

tensiones para el nivel bajo son entre 0 y 0,8V y el nivel

alto entre 2,4V y 5V.

Registro de estado (S): El registro de estado está

en LPT_BASE+1. Es

de sólo lectura (las

escrituras serán ignoradas).

La lectura dá

el estado de los cinco

pines de entrada

al momento de la lectura.

En la figura 10

los nombres de los

pines se dejaron en

inglés porque es como

generalmente se

identifican. La línea

Busy tiene, generalmente,

una resistencia

de pull-up interna.

El estándar es

que sean entradas tipo

77

LS TTL.

Registro de control

(C): El registro

de control (figura 11) se encuentra en LPT_BASE+2. Es

de lectura/escritura.

Los cuatro bits inferiores son salidas. La lectura devuelve

lo último que se escribió a dichos bits. Son TTL

a colector abierto con resistencias de pull-up de

4.7kW, por lo que un dispositivo externo puede forzar

el estado de los pines sin dañar el driver. Esto permite

utilizar estas cuatro líneas como entradas. Para ello, se

ponen en alto las cuatro salidas (escribiendo 0100b,

es decir, 4h, en LPT_BASE+2) lo que hace que las saFigura

8

Figura 9

Figura 10

58

lidas “floten”. Ahora, un dispositivo externo puede forzar

a bajo alguna de las salidas con lo que, leyendo el

puerto, sabemos si esto sucedió o no.

Es posible realizar esta técnica en salidas totem-pole

(como D0-D7) pero no se recomienda su uso porque

habría que tener un conocimiento preciso de la corriente,

ya que se puede sobrecargar los transistores de salida

y dañar el driver (especialmente en puertos integrados

LSI).

Bit de puerto bidireccional (compatible PS/2): El bit

78

C5, está disponible sólo si se trata de un puerto bidireccional;

en los puertos comunes no se utiliza, al igual

que los bits C6 y C7. Si C5=1, el buffer de los datos

de salida se pone en alta impedancia, “desconectando”

dicho buffer de los pines 2 a 9 del conector del

puerto (D0 a D7). Si se escribe al registro de datos, se

escribe al buffer pero no a la salida. Esto permite que

al leer el puerto, se lea el estado de las entradas y no

lo que hay en buffer. Cuando C5=0 el puerto retorna al

modo salida, su estado por defecto.

En las computadoras IBM PS/2, para habilitar el

puerto paralelo bidireccional, además de lo antes descrito,

se debe poner a 1 el bit 7 del registro del puerto

102h (opciones de configuración).

En computadoras que no tengan puerto paralelo bidireccional

compatible PS/2, hay que modificar uno o

más bits de algún puerto específico correspondiente al

chipset de la placa. A veces se habilita por el Setup o

por jumper en la placa del puerto.

Bit de interrupción: En trabajos normales de impresión,

ni el BIOS ni el DOS hacen uso de la interrupción.

El hecho de poseer una línea de interrupción que está

conectada directamente al PIC (Programmable Interrupt

Controller), lo hace muy útil para experimentación en

data-loggers por ejemplo. El bit de interrupción está conectado

al control de un buffer de tres estados. Cuando

C4=1, se activa el

79

buffer y su entrada,

S6, se conecta a la lí-

nea IRQ (en general es

IRQ7 o IRQ5). La lectura

del bit, nos devuelve

el estado del mismo

(es decir si el buffer está

en alta impedancia

o no).

Se producirá una

interrupción, cuando haya un flanco descendente en el

pin correspondiente a S6. A continuación, se describen

los pasos para poder utilizar interrupciones. Finalmente,

en la figura 12 se muestra una tabla que reúne las

características hardware y software del puerto paralelo.

Protocolo del Puerto de Impresora

El handshaking (“apretón de manos” o protocolo) es

un conjunto de reglas que ambos extremos de un sistema

de comunicación tienen que seguir para que la comunicación

sea correcta. El puerto paralelo, usado con una

impresora, transmite datos y transmite/recibe las señales

de protocolo. Las principales son Strobe, Ack y Busy. La

secuencia a seguir para enviar datos sería:

Colocar el byte a enviar en el registro de datos.

Verificar que la impresora no esté ocupada (Busy =

bajo, S7 = 1).

Indicarle a la impresora que acepte los datos (Strobe

80

= bajo , C0 = 1, pulso >5us).

En ese instante la impresora indica que está ocupada

recibiendo los datos (Busy = alto, S7 = 0).

Finalmente, la impresora envía un pulso de aceptación

indicando que se recibieron los datos y que se

puede volver al paso 1 (Ack = bajo, S6 = 0, pulso de

entre 5 ms y 15 ms según impresora).

Las otras señales sirven para verificar el estado de

la impresora (Error, PaperEnd), para reiniciarla (Init) y

para configurarla (AutoFeed, Select).

En los nuevos puertos, estas señales adquieren otra

función, a veces parecida y otras totalmente distintas.

Interrupciones con el Puerto Paralelo

En primer lugar, se debe habilitar el buffer que conecta

la línea ACK con la línea IRQ. Esto lo hacemos

poniendo a 1 el bit 4 del registro de control (LPT_BAFigura

11

59

Figura 12

60

SE+2). Luego se debe preparar una ISR (Interrupt Service

Routine) que atienda la interrupción recordando enviar

la señal EOI (20h) al registro de control del PIC

(puerto 20h) al salir de la rutina. La interrupción software

corresponde a la número 0Dh para IRQ5 y 0Fh para

IRQ7. Finalmente se habilita con 0 la interrupción

IRQ5 (o IRQ7) escribiendo al bit 5 (o 7) del registro de

81

interrupciones del PIC (puerto 21h). Para desinstalar la

ISR, se deshabilita la IRQ5 (o IRQ7) escribiendo un 1

al bit 5 (o 7) del registro de interrupciones del PIC

(puerto 21h). Luego se hace que C4=0.

Velocidad

Un puerto paralelo ISA normal toma un ciclo-ISA

para leer o escribir. En un sistema cuya velocidad de

bus sea 1,3MHz, se puede decir que la lectura se puede

hacer cada 1 ms (idealmente, ya que siempre existen

otras instrucciones software, etc; en la práctica pueden

ser desde 1.2 ms a 2 ms). Algunos puertos soportan

un modo “turbo” que elimina los 3 estados de espera

de la CPU, con lo que la velocidad de lectura/escritura

del puerto se duplica (2,7MHz).

Acceso Básico al Puerto Paralelo

Programación básica de la E/S en Basic: Para realizar

el control de dispositivos mediante el puerto paralelo

debemos hacer uso de las funciones de QBasic que

permiten acceder a los puertos hardware. Daremos

unos ejemplos básicos de la programación de la E/S

por el puerto paralelo. Estos ejemplos se presentan con

un grado de estructuración creciente en el estilo de programación.

En el primer ejemplo se supone que la PC

está equipada con un puerto paralelo de tipo estándar

localizado en la dirección 0x378, como suele ser habitual

en Windows 98, de modo que el registro de datos

se localiza en esa misma dirección y el de estado en

82

0x378+1. En el ejemplo (al que llamamos CTRL.BAS)

se envía un byte a las líneas de datos y se recibe un byte

de las líneas de estado con las funciones OUT e INP

utilizando un estilo de programación muy básico, tal

como se sugiere en la tabla 1.

En el siguiente ejemplo se supone que la PC está

equipada con un puerto paralelo de tipo bidireccional

localizado en la dirección 0x378 de modo que el registro

de datos se localiza en esa misma dirección y el de

control en 0x378+2. El bit C5 del registro de control se

utiliza como conmutador del modo salida (escritura en

las líneas de datos) al modo entrada (lectura de las lí-

neas de datos). En el ejemplo, mostrado en la tabla 2

y al que llamamos CTRL_0.BAS, se envía y se recibe un

byte de las líneas de datos del puerto aprovechando su

capacidad bidireccional utilizando las funciones OUT e

INP sin mayores complicaciones en la programación.

El siguiente ejemplo es funcionalmente idéntico al

anterior, aunque se hace uso de las constantes de BASIC

para dotar al programa de mayor elegancia y claTabla

1

61

Tabla 2

Tabla 3

62

ridad. También, facilita la reprogramación en caso de

que, por ejemplo, el puerto no se halle en la dirección

83

supuesta.

Obsérvese en la tabla 3 que la constante 0x378 só-

lo aparece ahora una vez en el código fuente, frente a

las cuatro veces que lo hacía en CTRL_0.BAS. Se ha

hecho uso asimismo de la notación hexadecimal para

los valores que activan y desactivan el bit C5 del registro

de control.

En el siguiente ejemplo, esta vez no es sólo maquillaje.

Cuando en los casos anteriores hemos activado y

desactivado el bit C5, pudimos también modificar el estado

del resto de los bits del registro de control. Normalmente,

es de buen gusto respetar el estado original

del puerto cuando uno finaliza la ejecución de su programa.

Así pues, en el siguiente ejemplo se lee (tabla 4,

CTRL_2.BAS) en primer lugar el estado del registro de

control y se almacena en un byte (que llamamos ctrl%).

Cuando utilizamos OUT, lo hacemos de modo que únicamente

modificamos individualmente el bit deseado, y

no todos. Finalmente escribimos el byte ctrl% al registro

de control para recuperar el estado original. Obsérvese

que se usa el operador ~ para realizar el complemento

a 1 de C5ON, de modo que nos ahorramos el

definir otra constante simbólica para la condición de bit

apagado.

Ahora un cambio significativo: vamos a determinar,

y no a suponer, dónde se halla situado el puerto paralelo

84

(consúltese la sección correspondiente de El Puerto

Paralelo del PC para conocer los detalles acerca de

cómo determinar cuántos puertos se hallan instalados y

qué direcciones de E/S ocupan).

Para ello accedemos a la zona de memoria donde

se registran las direcciones de los puertos paralelos presentes

en el PC (en la zona de las variables de la

BIOS), por mediación de la función PEEK. Una vez detectados

los puertos presentes, nos quedamos con el

primero y programamos la entrada-salida exactamente

igual que en CTRL_2.BAS. Vea la programación de esTabla

4

63

te ejemplo (CTRL_3.BAS) en la tabla 5. Por último, integraremos

el código que localiza la dirección del

puerto en ua función que devuelve dicha dirección. Para

ello definimos la función PuertoDir%, sin argumentos

y de tipo entero.

Si dicha función no localiza ningún puerto devuelve

un 0, lo que brinda al programa una posibilidad de

terminar la ejecución cuando en un PC no existe puerto

paralelo disponible (tabla 6).

Actividades

Es recomendable que ponga en práctica lo dictado

hasta aquí y para ello le sugerimos realizar algunos

ejemplos básicos.

Encendiendo un LED

85

Realícese el montaje elemental esquematizado en

la figura13. Puesto que se trata de un montaje inicial,

Tabla 5

64

en el que se es posible “sacrificar” el orden respecto de

la sencillez, se puede llevar a cabo uniendo directamente

con regletas los componentes a los cables, e introduciendo

éstos en las hembras del conector de la PC.

Por supuesto, es preferible realizar montajes más estables,

pero de ello nos ocuparemos más adelante.

Nota: no es preciso puentear exteriormente entre sí

las líneas 18-25 puesto que cada una de ellas es ya la

tierra del puerto. En este montaje se ha conectado un

LED (salida digital) en el pin 2 del puerto (bit D0 del

registro de datos) y un interruptor (entrada digital) en el

pin 15 (bit S3 del registro de estado).

A los fines prácticos, intente realizar un programa

en QBasic para la iluminación del LED y para la detecTabla

6

Figura 13

65

ción del estado del interruptor (véase el programa

CTRL.BAS de la tabla 1 de la pághina

60).

Ahora haga un montaje como el de la figura

14, donde se supone que el puerto paralelo

tiene capacidad bidireccional y se ha

86

conectado el interruptor (entrada digital) en

el pin 3 del puerto (bit D1 del registro de datos).

Haga un programa en QBasic para la

iluminación del LED y para la detección del

estado del interruptor (véase el programa

CTRL_0.BAS).

Interfaces Básicos de E/S

con el Puerto Paralelo

Circuito sin Alimentación Externa

Se trata de un circuito muy sencillo que usa un mí-

nimo de componentes y proporciona un test funcional

de 8 bits. Cada bit de la entrada puede ser individualmente

controlado y visualizado en los LED de salida.

Los diodos LED que actúan de display se alimentan únicamente

con la corriente proporcionada por las propias

salidas del puerto. Sería preferible alimentar los

LED y utilizar la corriente absorbida para iluminarlos,

pero el conector no

proporciona una se-

ñal de alimentación

(Vcc), de modo que se

necesitaría una fuente

externa. Eléctricamente,

el puerto paralelo

entrega señales TTL y

como tal, teóricamente,

se le puede conectar

87

cualquier dispositivo

que cumpla con los

niveles de voltaje específicos

de la lógica

TTL, sin embargo el

hardware del puerto

paralelo está muy limitado

en cuanto a su

capacidad de manejo

de corriente, por ésta

razón se debe ser

muy cuidadoso con el

manejo de las señales del puerto: un cortocircuito puede

dañar permanentemente la tarjeta madre del PC.

Sin embargo, experimentalmente se comprueba que

en la mayoría de los PC el puerto proporciona corriente

suficiente para una clara indicación visual de los

LED. El circuito se muestra en la figura 15.

Las líneas de datos (D0-D7, pines 2-9) se utilizan

como líneas de salida, e iluminan los LED cuando en

ellas se fija por software un 1 lógico (+5V). Cuando se

fija un 0 lógico, los LED se apagan. Como entradas se

utilizan, como nibble (semibyte) bajo, las cuatro líneas

Figura 14

Figura 15

66

asociados al registro de

88

control (C0,C1,C2 y C3,

pines 1, 14, 16 y 17) y,

como nibble alto, cuatro

de las líneas asociadas

al registro de estado

(S4,S5,S6 y S7, pines

13, 12, 10 y 11).

Obsérvese que las lí-

neas de control se utilizan

normalmente como

salidas. Sin embargo,

aquí deben ser configuradas

como entradas.

Obsérvese, asimismo,

que cuatro de las líneas

de entrada se corresponden

con bits que utilizan

lógica negativa (C0, C1,

C3 y S7). Esto habrá de

tenerse en cuenta cuando

se realice el programa

de control de esta interfaz.

Los detalles sobre el

montaje de éste y los

posteriores circuitos se

pueden consultar en la

página web: http://cfievalladolid2.net-

89

/tecno/cyr_01

Circuito con

Alimentación

Externa

Fijémonos ahora solamente

en una de las lí-

neas de entrada y en

una de las líneas de salida.

Un circuito como el

de la figura 16 utiliza

una fuente externa de

+5V para alimentar los

diodos LED y las señales

de entrada.

Un 1 lógico en D7

(bit 7 del puerto de DATOS)

produce que el LED Figura 17

Figura 16

67

se apague. Un 0 lógico produce la iluminación del

LED. El interruptor normalmente abierto S produce que

aparezca un 1 lógico (+5V) en la entrada Busy (registro

de ESTADO, S7). Cuando se cierra S un 0 lógico

(GND) se aplica a la entrada Busy.

Un circuito como el precedente para las 8 líneas

de entrada y salida es un alternativa al propuesto en

la sección anterior. Las aplicaciones y programas

90

prácticos para este circuito no son objeto der esta

obra, pero las puede bajar de: http://cfievalladolid2.net/tecno/cyr_01

Circuito con Alimentación

Externa y Etapa Separadora

Para disminuir lo más posible el riesgo de daños

al puerto, se puede utilizar un circuito integrado

74LS244 como etapa separadora en las líneas de salida.

Al mismo tiempo se mejora la capacidad de manejo

de corriente, de forma que se pueden conectar

sin riesgo la serie de diodos LED que indican la actividad

en las líneas de datos del puerto paralelo. El circuito

se detalla en la figura 17.

Por cada línea de entrada que tomamos directamente

del puerto paralelo existe una etapa amplificadora-separadora

dentro del circuito integrado

74LS244 que nos permite trabajar con una tasa de entrega

de corriente suficiente para desplegar en los diodos

emisores de luz la información escrita en las líneas

de datos del puerto. Además es posible habilitar ó deshabilitar

el despliegue del nibble de orden inferior ó

superior del byte escrito en el puerto.

Colocando en un nivel lógico alto el pin 1 del CI

74LS244 inhabilitamos el despliegue del nibble de orden

bajo y un nivel lógico alto en la patita 19 evita el

despliegue del nibble de orden alto. Por comodidad,

se conectan las patitas 1 y 19 permanentemente

a tierra de tal manera que sea posible visualizar

91

la actividad en los diodos LED.

Este circuito, al igual que otros presentados

en este texto, necesita de alimentación externa.

Se puede alimentar directamente mediante una

fuente de +5V, o construir ésta usando una pila

de 9V o un adaptador universal, y un regulador

de voltaje 7805.

El 7805 puede regular cualquier voltaje de

entre 7 y 25V c.c. hasta los 5V que precisa el

circuito (vea el diagrama de conexión del regulador

en la figura 18.

Circuito Bidireccional

con Alimentación Externa

El circuito de la figura 19 aprovecha la capacidad

bidireccional del puerto paralelo de la práctica totalidad

de los PCs actuales. Así, las 8 líneas de datos del

puerto (D0-D8) se pueden utilizar a modo de un bus de

datos que, en ocasiones contiene los valores que serán

leídos por la computadora y, otras veces, transporta

los datos que ésta envía a la salida digital. No es preciso

ahora utilizar las líneas de estado y de control del

puerto a modo de entradas, como se hacía en el circuito

sin alimentación externa (figura 15).

Este circuito utiliza los siguientes CI:

74LS573: un registro octal latch D transparente

usado como puerto de salida para iluminar los diodos

LED, o cualquier dispositivo al que se le quieran enviar

92

señales digitales.

74LS245: un transceptor octal bidireccional que

proporciona un puerto de entrada de 8 líneas; toma datos

de entrada de 8 interruptores o de cualquier dispositivo

desde el cual se quiera leer información digital.

Ambos integrados se controlan mediante el bit C0

del registro de control. Cuando el pin 1 se halla en alto,

los datos escritos por el puerto se transfieren a los

LED mediante el 74573, mientras que el 74245 está

aislado del bus de datos. Cuando el pin 1 está bajando,

los datos a su entrada se conservan en la salida.

Cuando el pin 1 está bajo el 74245 se habilita y los

datos presentes en su entrada se transfieren a su salida

y pueden ser leídos por el programa.

El bit C5 se utiliza como control de las operaciones

de lectura/escritura del puerto bidireccional. El

programa debe fijar tanto C0 como C5 a 0 para realizar

una escritura (es decir, debe escribir un valor deFigura

18

68

cimal 0 el el registro de control). Para llevar a cabo una

lectura ambos bits deben ser establecidos a 1 (es decir,

debe escribir un valor hexadecimal 0x21, o decimal

33, en el registro de control).

Display de 7 Segmentos

Una posibilidad es sustituir, en los montajes anteriores,

el sistema de visualización mediante 8 diodos LED

93

por un display numérico de 7 segmentos (figura 20)

más un punto decimal. El circuito resulta así más compacto.

Si se trata de un display de ánodo común hay que

alimentar con Vcc= +5V las dos líneas señaladas como

comunes en la figura, y es preciso poner a tierra la lí-

nea correspondiente al segmento que se quiere iluminar.

Si se trata de un display de cátodo común, hay que

alimentar con +5V el segmento que se desea iluminar y

poner a tierra las dos líneas comunes.

Así, en un display de cátodo común, las líneas 1-8

se pueden conectar directamente a las líneas de datos

del puerto (pines 2-9 del conector DB25), y las dos lí-

neas comunes se pueden conectar a cualquiera de las

patillas de tierra del conector, por ejemplo, la 25.

Reiteramos que si Ud. desea realizar los montajes

Figura 19

69

de los circuitos propuestos, o si quiere analizar con

mayor profundidad lo que aquí se expone, puede visitar

la página de Internet:

http://cfievalladolid2.net/tecno/cyr_01.

Cabe aclarar que los circuitos se pueden montar

sobre una placa tipo "protoboard" y utilizar cable rí-

gido para realizar las conexiones necesarias entre los

componentes.

Las entradas/salidas del circuito hacia el PC se

pueden reunir en un conector DB25 macho unido a la

94

placa por líneas de cable rígido o de cable plano. A

su vez, el conector macho se puede unir directamente

al conector hembra de la PC mediante un cable de extensión

paralelo, lo que normalmente resulta más có-

modo para acceder a la parte trasera de la PC donde

se sitúa el conector hembra.

Para simplificar los circuitos que utilizan interruptores

a modo de entradas digitales, éstos se pueden reunir

en un único DIP switch de ocho posiciones.

Lógicamente, para cada circuito podemos realizar

diferentes actividades, pero ese tema, desarrollado

por el autor en la web, será objeto de otras publicaciones.

Distinguiendo los Sistemas Operativos

Sin hilar muy fino, podemos decir que un sistema

operativo debe fijar reglas claras para todo fabricante

de software que desee ejecutar programas en él, ya

que al utilizar una PC, estamos abiertos a ejecutar

aplicaciones de distintos orígenes. Por lo tanto, se debe

asegurar “derechos y obligaciones” para que los

programas dentro de un sistema no se interfieran (y

perjudiquen) entre ellos.

Como conclusión y grandes rasgos podremos decir

que el Sistema Operativo sirve de intermediario entre

los programas y el hardware. (Figura 21)

No hay dudas que en el mercado y en la comunidad

de usuarios podemos hallar 3 Sistemas Operativos

que se destacan, o al menos hemos oído hablar de

95

la mayoría.

• Windows: sin dudas, es el sistema operativo mejor

afianzado en el mercado (más que por elección de

los usuarios, por costumbre). Casi todo usuario que ingresa

al mundo de las PCs, lo hace a través de Windows,

lo asumimos casi de manera natural porque no

importa dónde vayamos, siempre hay una máquina

con Windows cerca.

• Linux: considerado como “el sistema de los

nerds”, ha ido evolucionando hasta convertirse en un

sistema operativo amigable que puede llegar a superar

en estabilidad a la plataforma Windows. Está dise-

ñado y probado sobre la base de las contribuciones

de miles de usuarios y programadores independientes

en distintas partes del mundo que aportan su granito

de arena para que el sistema crezca y progrese. Sin

embargo, tiene en contra la “tendencia cultural” impuesta

por Windows que le impide difundirse ampliamente.

Figura 20

Figura 21

70

• DOS: si bien ese trata de un sistema operativo en

desuso, podría considerarse como el más veloz y sencillo

de los tres (incluso podría considerarse ideal para

tareas dedicadas. Sus comandos todavía pueden utilizarse

cuando utilizamos el “símbolo de sistema” de

Windows XP o la “terminal” de Linux. No existe una definición

96

clara de driver para esta arquitectura, ya que

teóricamente cualquier aplicación puede hacer E/S en

forma directa.

Los Drivers, Comunicando Hard&Soft

Definiremos como drivers o controladores a las herramientas

o rutinas necesarias para que el sistema

operativo interactúe con el hardware. Tendremos drivers

de sonido, puertos, unidades de disco, etc.

El driver por sí mismo no es un programa accesible

por el usuario. Las aplicaciones interactúan indirectamente

con el dispositivo a través de llamadas del sistema,

las cuales luego se traducen por el SO en instrucciones

de entrada salida.

Los sistemas operativos actuales no tienen por qué

saber de fábrica, como funciona todo el hardware existente

en el mercado. Si esto fuera posible, acarrearía

cantidades enormes y mayormente innecesarias de información.

Lo que suele hacerse es armar un paquete

que recopile versiones estables (libres de errores) de los

drivers de dispositivos comerciales de uso común.

Soporte de Programación

Refiriéndonos a los drivers o controladores, no existe

un driver genérico multiuso que sirva para todos los

tipos de sistemas operativos. Es más, generalmente se

programa un driver para varias versiones de un sistema

determinado. Por lo tanto, si desarrollamos un proyecto

de hardware, deberemos considerar en qué sistemas

97

y/o PCs lo vamos a conectar. Sobre los sistemas anteriores

podemos decir:

• Microsoft ofrece para sus sistemas Windows un

set de librerías llamado DDK (Driver Development Kit).

Consiste en numerosas ayudas, ejemplos y herramientas

destinadas a programas de un nivel avanzado. Este

paquete tiene un costo, y se entrega para la última

versión de Windows disponible en el momento de su

compra.

• Respecto al soporte de drivers de Linux, con un

poco de paciencia podemos encontrar mucha información

gratuita en Internet, con una muy buena documentación.

Pero nuevamente se exige un alto conocimiento

de programación.

• Molestando un poco más con DOS, podemos decir

que existe mucha bibliografía escrita, y aún puede

encontrarse información en la red sobre E/S con este

sistema, sigue siendo la alternativa más simple.

Simple vs Complicado

DOS es más simple, ya que se trata de un sistema

monotarea (trabaja con una aplicación a la vez). Linux

y Windows son sistemas multitarea (más de una aplicación

a la vez...) por lo que necesitan controlar estrictamente

que es lo que maneja cada aplicación para que

en ningún momento se produzcan situaciones conflictivas

(por ejemplo, dos aplicaciones queriendo imprimir

a la vez). Para lograr su cometido, los sistemas multitareas

98

han tenido que perfeccionar niveles y permisos

que les permitan decidir en qué momento una aplicación

accede a un dispositivo.

Niveles de Trabajo

Para explicar este concepto necesitaremos aclarar

la idea de proceso: un programa puede estar constituido

por varios procesos simultáneos que realizan distintas

tareas. Cada proceso tiene asignado para sí recursos

determinados (direcciones E/S disponibles, servicios

disponibles, cantidad de memoria asignada, prioridad

frente a otros procesos)

Con la aparición de los procesadores 386, se empezó

a hablar de niveles de privilegio o de ejecución,

estos se clasificaban en:

• El nivel 0, nivel Kernel o Monitor: aquí un proceso

tiene acceso irrestricto al hardware tiene acceso al

hardware. En este nivel se ejecuta el núcleo del sistema

operativo. Evidentemente el fallo de un programa en nivel

cero, tiene por consecuencia la caída inexorable de

la máquina.

• Los niveles 1 y 2 estaban destinados a ejecutar

los drivers del sistema. En el caso de Microsoft, se optó

por ejecutarlos a nivel Kernel (nivel 0), Linux siguió

la misma tendencia.

71

• El nivel 3 o nivel Usuario: Allí se ejecutan los

programas de usuario, los cuales sólo pueden acceder

99

al hardware o a los recursos del sistema, a través de

los niveles anteriores.

Un sistema operativo en si tiene numerosos procesos,

que se ejecutan en diferentes niveles, según las necesidades

y operaciones a cumplir por cada uno. Podríamos

hacer una analogía con una estructura de una

empresa, los gerentes (nivel 3) pueden decidir sobre el

destino de una planta de procesamiento, pero los operarios

(nivel 0) son los que trabajan directamente con

las máquinas y herramientas. Con esto podemos decir

que una instrucción desde el nivel de usuario puede

desencadenar varias operaciones a nivel de kernel sobre

el hardware.

A la vez, el nivel de usuario nos permite generalizar

ciertas operaciones. De esta manera, si un desarrollador

de software deseara reproducir un sonido,

no necesita aprender el funcionamiento interno de cada

placa de sonido existente, sino entregarle al sistema

operativo la orden de “reproducir” y éste, a través

de drivers provistos por el fabricante del hardware instalado,

realizará la operación.

Las transiciones de nivel (desde que se pide una

acción, hasta que se ejecuta una operación E/S), sólo

pueden hacerse a través de puertas de tarea asignadas

por el núcleo (coordinador

supremo) del sistema. Ningún

proceso tiene acceso directo al

100

hardware con lo cual se evitan

caídas del sistema por errores

de programación (al producirse

un error de programa en el

nivel 3, el sistema operativo toma

control, informa del error y

limpia totalmente la tarea y

restos de ella)

Un ejemplo: en la Figura

22 podemos ver el recorrido

de acciones que se van sucediendo

cuando una aplicación

requiere acceder a un dispositivo

de almacenamiento externo

(por ejemplo, un disco rígido).

El acceso directo al dispositivo

se produce solamente

desde los procesos dentro del

núcleo.

Adquisición de Datos Placa Interna

Cuando hablamos de adquisición de datos, nos

referimos a tomar un valor analógico o digital (proveniente

de sensores, interruptores, etc.), convertirlo a

dato manipulable por la PC y almacenarlo en una dirección

de memoria determinada. Si bien los sensores

son externos, el dispositivo adquisidor puede ser interno

(en forma de placa de expansión con entradas analógicas

101

o digitales). Empezaremos mencionando los

distintos métodos de comunicación entre el elemento

adquisidor interno y la PC:

• Por interrupciones: en este caso, un módulo o

dispositivo (ya sea un puerto externo o elemento interno)

posee cierta inteligencia que le permite informar al

sistema acerca de nuevos datos entrantes. El módulo

en cuestión produce una señal, el sistema operativo

“interrumpe” momentáneamente sus operaciones en

respuesta a esa señal ejecutando una rutina, que puede

servir tanto para tomar datos de entrada como para

producir una salida.

• A través de Encuesta: en este caso, el sistema

“consulta” al dispositivo acerca del estado de los datos,

o toma directamente una lectura sin ninguna verificación.

El dispositivo adquisidor adopta una actitud

más bien pasiva, no reacciona a menos que el sistema

Figura 22

72

provoque una operación de entrada o salida. A su vez,

los métodos de encuesta se pueden distribuir en dos clasificaciones

fundamentales:

• Utilizando de DMA: en este caso, el sistema informa

al dispositivo que se prepare a entregar o recibir

una cantidad determinada de datos con no más de 3

instrucciones. A partir de ese momento, el dispositivo

mismo toma control del sistema, escribe o lee los datos

102

directamente de la RAM sin intervención del microprocesador,

y al terminar el volcado de memoria devuelve

el control al sistema operativo.

• A través de operaciones directas de E/S: este es

un método más lento. A diferencia del DMA, el microprocesador

tiene que realizar registro por registro las

operaciones de E/S entre la memoria y el dispositivo

adquisidor. Por ejemplo, supongamos que tenemos que

volcar en memoria 256kbytes alojados en los registros

de un dispositivo adquisidor: por cada byte transferido,

el procesador primero tendría que leer cada dato del

registro del dispositivo adquisidor, procesarlo y luego

escribirlo en la memoria. Todo esto llevaría varias instrucciones

de programa y de proceso, muchas más que

con DMA, pero nos permitiría ir evaluando dato por

dato antes de escribirlo a memoria (con DMA primero

volcamos a memoria, luego trabajamos con los datos

transferidos)

Instantáneamente surge una duda, ¿como hacemos

para implementarlo?. Hemos visto lo simple que es programar

microcontroladores (el assembler de PIC pinta

feo de lejos, pero al aprenderlo nos damos cuenta que

con unas pocas líneas podemos armar una buena secuencia

de automatismo).

En este caso, es un poco más complicado: cualquier

proyecto de E/S utilizando los sistemas operativos

Linux o Windows no es tarea fácil... demanda conocimientos

103

de programación que exceden el básico y

requiere conocimientos de drivers y programación.

Adquisidor Externo

Según la aplicación, los dispositivos adquisidores

pueden considerarse como “cajas negras” externas, conectadas

a los sensores e interruptores pon un lado, y

a un puerto externo de la PC por el otro. Este tipo de

elementos nos da gran portabilidad, ya que no necesitamos

desarmar la PC para trasladar el elemento adquisidor.

Los sistemas operativos actuales ofrecen librerías

o al menos nos dan la posibilidad de trabajar con los

puertos a través de drivers provistos por el sistema. Uno

de los protocolos más definidos por la diversidad de

aplicaciones es el RS-232 (o puerto serie), presente en

muchos PLCs y Dataloggers.

Como vimos, las Aplicaciones entran dentro del

modo Usuario y se comunican con el hardware a través

de drivers y llamadas al sistema, los cuales se regulan

por restricciones y prioridades. Cada uno de los sistemas

vistos tiene sus peculiaridades con respecto a la

E/S directa.

• Si bien DOS es el único sistema de los mencionados

que soporta E/S directa, se considera obsoleto por

la comunidad informática en Gral.

• Windows en forma nativa no soporta E/S directa

desde una aplicación.

• Linux soporta E/S directa desde una aplicación,

104

pero solamente si el que ejecuta esa aplicación tiene

privilegios de root (administrador de sistema).

También vimos que hay distintas maneras de comunicarse

con una placa conectada a la PC usando Interrupciones,

DMA y E/S. Pero lo que no aclaramos fue

que todos estos tipos de transferencia requieren en algún

momento E/S directa, tanto para programar el controlador

de DMA, como el de Interrupciones.

E/S en DOS

Las PCs recién adoptaron las características de seguridad

y enfoques de capa de usuario y de Kernel a

partir de la década del 90, con el surgimiento de Linux

y las versiones de Windows NT (que requerían una mayor

estabilidad que las versiones hogareñas de Windows).

Por este motivo, cualquier lenguaje de programación

de alto nivel que corra en DOS soporta E/S directa.

La industria nos ha llevado a ir escalando los sistemas

operativos y entornos más amigables, más tareas

simultáneas, desechando lo anterior. De todas maneras,

este tipo de lenguajes y plataformas. puede ser

bastante útil para tareas didácticas, ya que con pocos

conocimientos de programación y con computadoras

73

de bajas prestaciones, se pueden realizar numerosos

proyectos que pueden llegar a ser vistosos, no tanto

por los colores de ventanas vistas en pantalla, sino por

los elementos controlados. Esto puede posibilitar que

105

muchas escuelas con escasos recursos puedan aprovechar

equipos antiguos para diseño de proyectos de

E/S.

Si poseemos una versión de DOS viejita, podemos

llegar a encontrar BASICA y GW-BASIC, variantes del

lenguaje de programación BASIC. A partir de MSDOS

5.0 y hasta Windows 95 inclusive se incluyó el

QBASIC (basado en el QuickBasic 4.5, pero sin compilador).

Tanto QBASIC como BASICA y GW-BASIC

son sólo intérpretes (son siempre necesarios para ejecutar

los programas). Microsoft dejó de proveer el

QBASIC en las versiones siguientes de Windows.

QBASIC nos provee dos simples instrucciones:

• INP(Puerto): devuelve un byte (8 bits) desde un

puerto de E/S

• OUT Puerto, dato:. envía un byte a un puerto de

E/S.

Recuadro 1

DEFINT A-Z

Cuenta=5000

CLS

PRINT “Secuencia de Luces”

PRINT “Pulse una tecla para terminar...”

DO

FOR I = 0 TO 7

Salida = 2 ^ I

OUT &h378,Salida

106

Retrasa Cuenta

NEXT

FOR I = 6 TO 0 STEP -1

Salida = 2 ^ I

OUT &h378,Salida

Retrasa Cuenta

NEXT

LOOP UNTIL INKEY$<>””

END

SUB Retraso (Ciclos%)

FOR P% = 0 TO Ciclos

NEXT P%

END SUB

Figura 23

74

Dentro del Recuadro 1 podemos ver un simple

ejemplo donde a través de un programa en QBASIC

ya través del puerto paralelo hacemos una secuencia

de luces tipo “Auto Fantástico”.

En este ejemplo definimos una variable Cuenta, ésta

nos permite acomodar la velocidad en que se desplazan

los leds a través de la subrutina Retraso, cuya única

función es hacer que el programa pierda tiempo de

la misma manera que podríamos poner varias instrucciones

NOP en un programa de un PIC.

Se incluyen dos bucles FOR que determinan el desplazamiento

del bit que enciende cada led desde un

107

extremo hacia el otro y un bucle exterior que finaliza

cuando se presiona una tecla, terminando el programa.

Se debe aclarar que se ha tomado

la dirección &H378 (correspondiente al

LPT1). Según la configuración de su sistema,

puede ser que el puerto paralelo

donde se conectan los led responda a

la citada dirección o que deba cambiarse

por &h278 o &h3BC (esta última

dirección era muy utilizada en las PCs

que tenían placa de video con puerto

paralelo incluido). En caso de no saber

cuál es la dirección que corresponde a

nuestro puerto, no rompemos nada con

intentar ver cuál de las tres funciona, ya

que son direcciones destinadas especí-

ficamente a estos puertos. Escribir en ellas no provocará

ningún conflicto con ningún otro elemento de hardware

conectado.

En la figura 23 vemos una de tantas implementaciones

circuitales que puede utilizarse para demostrar este

ejemplo, en este caso colocamos un buffer 74LS244

para protección del puerto.

Los 5V que alimentan este circuito integrado pueden

obtenerse de la misma fuente de alimentación de

la PC a través de cualquiera de los cables rojos que alimentan

a los discos rígidos, disqueteras o lectoras de

108

CD-ROM.

Algo muy importante: para evitar daños, no olvide

verificar el circuito antes de conectarlo al puerto.

Tabla 1 - Instrucciones provistas por IO.DLL

Instrucción Uso

PortOut Escribe un byte al puerto especificado

PortWordOut Escribe una palabra (de 16 bits) al puerto especificado

PortDWordOut Escribe una palabra doble (de 32 bits) al puerto especificado

PortIn Lee un byte del puerto especificado.

PortWordIn Lee una palabra (16 bits) del puerto especificado

PortDWordIn Lee un palabra doble (32 bits) del puerto especificado

SetPortBit Setea en 1 el bit especificado del puerto indicado

ClrPortBit Setea en 0 el bit especificado del puerto indicado

NotPortBit Invierte el estado del bit especificado del puerto indicado

GetPortBit Lee el estado del bit especificado

RightPortShift Provoca una rotación a la derecha del contenido del puerto haciendo que LSB pase a MSB

LeftPortShift Provoca una rotación a la izquierda el contenido del puerto haciendo que MSB pase a LSB

IsDriverInstalled Devuelve un valor distinto de 0 si la DLL está cargada en memoria

NOTA: LSB=Least Significative Bit (Bit Menos Significativo)

MSB=Most Significative Bit (Bit Más Significativo)

Recuadro 2

Licencia y Código Fuente

IO.DLL es completamente gratis! Sin embargo, usted no podrá:

• Cobrar esta librería de ninguna manera. Por ejemplo, usted no puede

venderla como un producto individual.

109

• Esconder la IO.DLL detrás de un control OCX (utilizado por los lenguajes

de Microsoft) o control Delphi. Esto tambien se considera como “trabajo

derivado” y también debe proveerse gratuitamente.

• Asumir la propiedad intelectual.

El autor no se hace responsable de las consecuencias de usar IO.DLL.

No se ofrecen garantías.

El código fuente está disponible por u$s1000 (sí, mil!) dólares. El autor

ofrece también la posibilidad de hacer una adaptación “a medida” en el caso

de que algún usuario la requiera (con su tarifa, claro).

75

E/S directa con Windows

Windows 95/98 tiene una cierta permisividad sobre

las operaciones de E/S directas desde aplicaciones,

aunque esto es aplicable sólo en algunas versiones

de lenguajes de programación. (por ejemplo se

puede hacer un “artilugio” para tener E/S desde una

aplicación realizada en Delphi 1.0, pero no se puede

con la versión 2.0). Además, este tipo de operaciones

E/S requiere un poco de conocimientos de assembler

de 80x86, complicando más la tarea de programación.

A partir de Windows NT y sus sucesores (2000

y XP) el criterio de E/S es mucho más estricto, implementaciones

de E/S que funcionan en Windows

95/98 probablemente no funcionen en Windows

2000/XP, salvo que sean implementadas a través de

drivers (programables a través del Microsoft DDK, que

junta 2 características problemáticas: caro y difícil para

110

el programador principiante)

IO.DLL: un recurso más que útil

Aplicaremos una librería externa(IO.DLL) diseñada

por Fred Bulback, un programador independiente, totalmente

ajeno a Microsoft (podemos ver su página

http://www.geekhideout.com). Esta librería permite

desarrollar aplicaciones que funcionen desde Windows

95 hasta Windows XP, pasando por todas las

versiones intermedias. Es muy versátil y provee varias

funciones que facilitan la tarea de Entrada-Salida, no

se necesitan conocimientos de assembler. Sólo se requieren

conocimientos mínimos de algún lenguaje de

alto nivel como Visual Basic, C, o Delphi. El autor especifica

claramente en su página cuales son los límites

de utilización, los conceptos básicos legales se pueden

observar en el Recuadro 2. En la tabla 1 vemos

las instrucciones provistas por IO.DLL

Un Ejemplo en Visual Basic

A modo de ejemplo, veremos cómo realizar E/S en

Visual Basic a través de IO.DLL. Para poder utilizar esta

librería basta con copiar el archivo IO.DLL en la carpeta

donde está el programa en desarrollo y agregar en

un módulo BAS las siguientes declaraciones: vea el cuadro

3. Si bien es un ejemplo que puede parecer bastante

tonto, se quiere mostrar que con pocas líneas de programa

podemos lograr respuestas por parte del hardware

a través de eventos ocurridos en la PC. De la misma

111

manera, a través de las funciones de entrada PortIN y

PortWordIN, podríamos guardar el contenido del puerto

en una variable para su manipulación y posible emisión

de una nueva salida.

Con conocimientos mínimos de cualquier lenguaje

de programación podríamos adaptar el ejemplo en

DOS para utilizarlo en Windows, ya que existe la instrucción

OUT de Qbasic y el PortOut de IO.DLL son similares,

así como también hay similitud entre la función

INP de Qbasic y su correspondiente PortIN de la libreRecuadro

3

Private Declare Sub PortOut Lib "IO.DLL" (ByVal Port As Integer, ByVal Data As Byte)

Private Declare Sub PortWordOut Lib "IO.DLL" (ByVal Port As Integer, ByVal Data As Integer)

Private Declare Sub PortDWordOut Lib "IO.DLL" (ByVal Port As Integer, ByVal Data As Long)

Private Declare Function PortIn Lib "IO.DLL" (ByVal Port As Integer) As Byte

Private Declare Function PortWordIn Lib "IO.DLL" (ByVal Port As Integer) As Integer

Private Declare Function PortDWordIn Lib "IO.DLL" (ByVal Port As Integer) As Long

Private Declare Sub SetPortBit Lib "IO.DLL" (ByVal Port As Integer, ByVal Bit As Byte)

Private Declare Sub ClrPortBit Lib "IO.DLL" (ByVal Port As Integer, ByVal Bit As Byte)

Private Declare Sub NotPortBit Lib "IO.DLL" (ByVal Port As Integer, ByVal Bit As Byte)

Private Declare Function GetPortBit Lib "IO.DLL" (ByVal Port As Integer, ByVal Bit As Byte) As Boolean

112

Private Declare Function RightPortShift Lib "IO.DLL" (ByVal Port As Integer, ByVal Val As Boolean) As Boolean

Private Declare Function LeftPortShift Lib "IO.DLL" (ByVal Port As Integer, ByVal Val As Boolean) As Boolean

Private Declare Function IsDriverInstalled Lib "IO.DLL" As Boolean

76

ría de Fred Bulback. Si hablamos del puerto paralelo, podremos

encontrar mucha información en la web referida

al tema con proyectos relacionados al control desde PC

de montajes electrónicos.

En el Recuadro 3 encontraremos varias direcciones

útiles con implementaciones interesantes a través del

puerto paralelo en otros lenguajes de programación.

Ojalá que este tema sea disparador de grandes ideas,

De esta manera damos por finalizada esta obra aclarando

que al momento de escribir erstas líneas estamos

preparando otro tomo de la colección del C lub Saber

Electrónica destinado a explicar diferentes sistemas de

adquisición de datos y manejo de circuitos a través de los

diferentes puertos de la PC.

113

3. Algoritmos para programación en tiempo real

3.1 IntroducciónEn el siguiente trabajo pretendemos presentar una serie de concepto y definiciones propios del estudio de los Algoritmos, su análisis y diseño.

En el mismo podremos encontrar los conceptos de algoritmo y algunos de sus componentes, análisis y diseño. También veremos los diferentes tipos de formas y tamaños o medidas en que se pueden almacenar y representar los datos y estructuras en un algoritmo o programa. En ese mismo orden encontraremos las diferentes técnicas para diseñarlos como son el método de la fuerza bruta, el voraz, divide y vencerás, programación dinámica, de vuelta atrás, entre otros.

De igual forma podremos ver las definiciones y algunas características, reglas, normas, tipos de algoritmos de búsqueda y ordenación así como sus aplicaciones.

Finalmente veremos los que es la verificación y derivación de programas, donde daremos los conceptos básicos de semántica y sus tipos haciendo mayor énfasis en la semántica axiomática, la recursividad e iteración, los diseños de estos últimos, así como los típicos ciclos utilizados en algoritmos y programas y los paso a tener en cuenta al momento de desarrollar un algoritmo iterativo o recursivo.

3.2 JustificaciónEs importante el estudio y conocimiento de lo que hoy conocemos como Algoritmos Computacionales, que desde su aparición hasta nuestros días es, y seguirá siendo; vital para el desarrollo de aplicaciones para computadoras y el manejo y dominio de la lógica de programación para resolver problemas.

3.3 MotivaciónComo estudiantes de la Facultad de Ciencias y Tecnología “ Escuela de Informática y Computación “ de la Universidad Dominicana Organización y Métodos O&M con aspiraciones de iniciarnos como Ingeniero en Sistemas y Computación. Con el objetivo inmediato de aprobar con los mejores meritos la asignatura de Algoritmos Computacionales.

3.4 ObjetivosPosibilitar la estudiante alcanzar una visión sistemática de lo que conocemos sobre Los Algoritmos Computacionales.

1.4.2 Específicos :

114

Introducir los conceptos propios sobre Algoritmo, su importancia en el mundo de las aplicaciones para computadoras y el manejo de lógica de programación.

• Proporcionar una idea de su uso.

• Visualizar sus ventajas e importancia.

• Definir sus tipos y variantes.

• Proporcionar conceptos sobre su análisis y diseño.

• Proporcionar concepto sobre las técnicas de diseño.

• Desglosar sus variantes (ordenación, búsqueda, etc. ).

1.2 Marco Historico

Un algoritmo es un conjunto de operaciones y procedimientos que deben seguirse para resolver un problema. La palabra algoritmo se deriva del nombre latinizado del gran Matemático Árabe Mohamed Ibn Al Kow Rizmi, el cual escribió sobre los años 800 y 825 su obra Quitad Al Mugabala, donde se recogía el sistema de numeración hindú y el concepto del cero. Fue Fibinacci, el que tradujo la obra al latín y el inicio con la palabra: Algoritmi Dicit.

El lenguaje algorítmico es aquel por medio al cual se realiza un análisis previo del problema a resolver y encontrar un método que permita resolverlo. El conjunto de todas las operaciones a realizar y e orden en que se deben efectuarse, se le denomina algoritmo.

Es un método para resolver un problema mediante una serie de datos precisos, definidos y finitos.

1.3 Generalidades

El programador de computadoras es ante que nada una persona que resuelve problemas, por lo que para llegar a ser un programador eficaz se necesita aprender a resolver problemas de un modo riguroso y sistemático. A la metodología necesaria para resolver problemas mediante programas se denomina Metodología de la Programación. El eje central de esta metodología es el concepto, ya tratado, de algoritmo.

Un algoritmo es un método para resolver un problema. Aunque la popularización del término ha llegado con el advenimiento de la era informática, algoritmo proviene de Mohammed al-Khowarizmi, matemático persa que vivió durante el siglo IX y alcanzo gran reputación por el enunciado de las reglas para sumar, restar, multiplicar y dividir números decimales; la traducción al latín del apellido de la palabra algorismus derivo posteriormente en algoritmo. Euclides, el gran matemático griego (del siglo IV antes de Cristo) que invento un método para encontrar el máximo común divisor de dos números, se considera con Al-Khowarizmi el otro gran padre de la algoritmia (ciencia que trata de los algoritmos).

115

El profesor Niklaus Wirth, inventor de Pascal, Modula-2 y Oberon, titulo uno de sus mas famosos libros, Algoritmos + Estructuras de Datos = Programas, significándonos que solo se puede llegar a realizar un buen programa con el diseño de un algoritmo y una correcta estructura de datos. Esta ecuación será de una de las hipótesis fundamentales consideradas en esta obra.

La resolución de un problema exige el diseño de un algoritmo que resuelva el problema propuesto.

Los pasos para la resolución de un problema son:

1. Diseño de algoritmo, que describe la secuencia ordenada de pasos que conducen a la solución de un problema dado. (Análisis del problema y desarrollo del algoritmo).

2. Expresar el algoritmo como un programa de lenguaje de programación adecuado. (Fase de codificación.)

3. Ejecución y validación del programa por la computadora.

Para llegar a la realización de un programa es necesario el diseño previo de algoritmo, de modo que sin algoritmo no puede existir un programa.

Los algoritmos son independientes tanto del lenguaje de programación en que se expresan como de la computadora que lo ejecuta. En cada problema el algoritmo se puede expresar en un lenguaje diferente de programación y ejecutarse en una computadora distinta; sin embargo, el algoritmo será siempre el mismo. Así, por ejemplo, en una analogía con la vida diaria, una receta de un plato de cocina se puede expresar en español, ingles o francés, pero cualquiera que sea el lenguaje, los pasos para la elaboración del plato se realizaran sin importar el idioma del cocinero.

En la ciencia de la computación y en la programación, los algoritmos son más importantes que los lenguajes de programación o las computadoras. Un lenguaje de programación es tan solo un medio para expresar un algoritmo y una computadora es solo un procesador para ejecutarlo. Tanto el lenguaje de programación como la computadora son los medios para obtener un fin: conseguir que el algoritmo se ejecute y se efectúe el proceso correspondiente.

116

Dada la importancia del algoritmo en la ciencia de la computación, un aspecto muy importante será el diseño de algoritmos. El diseño de la mayoría de los algoritmos requiere creatividad y conocimientos profundos de la técnica de la programación. En esencia, la solución de un problema se puede expresar mediante un algoritmo.

3.5 Características de los Algoritmos:Las características fundamentales que debe cumplir todo algoritmo son:

• Un algoritmo debe ser preciso e indicar el orden de realización de cada paso.

• Un algoritmo debe estar definido. Si se sigue un algoritmo dos veces, se debe obtener el mismo resultado cada vez.

• Un algoritmo debe ser finito. Si se sigue un algoritmo se debe terminar en algún momento; o sea, debe tener un numero finito de pasos.

La definición de un algoritmo debe definir tres partes: Entrada, Proceso y Salida. En el algoritmo de receta de cocina citado anteriormente se tendrá:

Entrada: ingrediente y utensilios empleados.

Proceso: elaboración de la receta en la cocina.

Salida: terminación del plato (por ejemplo, cordero).

3.6 Ejemplo de Algoritmo:Un cliente ejecuta un pedido a una fábrica. Esta examina en su banco de datos la ficha del cliente; si el cliente es solvente entonces la empresa acepta el pedido; en caso contrario rechazara el pedido. Redactar el algoritmo correspondiente.

Los pasos del algoritmo son:

1. inicio

2. leer el pedido

3. examinar la ficha del cliente

4. si el cliente es solvente aceptar pedido; en caso contrario, rechazar pedido

5. fin

1.6 Diseño del Algoritmo:

En la etapa de análisis del proceso de programación se determina que hace el programa. En la etapa de diseño se determina como hace el programa la tarea solicitada. Los métodos mas eficaces para el proceso de diseño se basan en el conocido por Divide y Vencerás, es decir, la

117

resolución de un problema complejo se realiza dividiendo el problema en sub problemas y a continuación dividir estos sub problemas en otros de nivel mas bajo, hasta que pueda ser implementada una solución en la computadora. Este método se conoce técnicamente como diseño descendente (Top Down) o modular. El proceso de romper el problema en cada etapa y expresar cada paso en forma más detallada se denomina refinamiento sucesivo.

Cada sub programa es resuelto mediante un modulo (sub programa) que tiene un solo punto de entrada y un solo punto de salida.

Cualquier programa bien diseñado consta de un programa principal (el modulo de nivel mas alto) que llama a sub programas (módulos de nivel mas bajo) que a su vez pueden llamar a otros sub programas. Los programas estructurados de esta forma se dice que tienen un diseño modular y el método de romper el programa en módulos más pequeño se llama Programación Modular. Los módulos pueden ser planeados, codificados, comprobados y depurados independientemente (incluso por diferentes programadores) y a continuación combinarlos entre si. El proceso implica la ejecución de los siguientes pasos hasta que el programa se termina:

• programar modulo.

• Comprobar el modulo.

• Si es necesario, depurar el modulo.

• Combinar el modulo con los módulos anteriores.

El proceso que convierte los resultados del análisis del problema en un diseño modular con refinamiento sucesivo que permitan una posterior traducción al lenguaje se denomina diseño de algoritmo.

El diseño del algoritmo es independiente del lenguaje de programación en el que se vaya a codificar posteriormente.

3.7 SISTEMAS DE PROCESAMIENTO DE LA INFORMACIÓN:Un ordenador es una máquina de procesamiento de información. Es una máquina

porque tiene cables, chips,... , procesa porque es capaz de procesar cosas, e información porque maneja conjuntos ordenados de datos).

118

Para procesar la información está el hardware (microprocesador, RAM,...), y el software (que sirve para manejar el hardware).

3.8 CONCEPTO DE ALGORITMO:El algoritmo trata de resolver problemas mediante programas.

Fases:

- Análisis preliminar o evaluación del problema: Estudiar el problema en general y ver que parte nos interesa.

- Definición o análisis del problema: Ver que es lo que entra y que es lo que sale, las posibles condiciones o restricciones, ...

- Diseño del algoritmo: Diseñar la solución.

- El programa: Codificación del algoritmo en un lenguaje de programación.

- Ejecución del programa y las pruebas: Ver si el programa hace lo que queríamos.

¿Qué es un algoritmo?:

Es una formula para resolver un problema. Es un conjunto de acciones o secuencia de operaciones que ejecutadas en un determinado orden resuelven el problema. Existen n algoritmos, hay que coger el más efectivo.

Características:

- Tiene que ser preciso.

- Tiene que estar bien definido.

- Tiene que ser finito.

La programación es adaptar el algoritmo al ordenador.

El algoritmo es independiente según donde lo implemente.

1.9. EL LENGUAJE DE PROGRAMACIÓN:

Existen diferentes tipos, de bajo nivel y de alto nivel.

Instrucciones en una computadora y sus tipos:

Una instrucción es cada paso de un algoritmo, pero que lo ejecuta el ordenador. Un programa es un conjunto de instrucciones que ejecutadas ordenadamente resuelven un problema.

119

3.9 Tipos de instrucciones:- E/S: Pasar información del exterior al interior del ordenador y al revés.

- Aritmético-lógicas: Aritméticas: +,-,*,... ; Lógicas: or, and, <, >, ...

- Selectivas: Permiten la selección de una alternativa en función de una condición.

- Repetitivas: Repetición de un número de instrucciones un número finito de veces.

3.10 Tipos de lenguajes:- Lenguaje máquina: Todo se programa con 1 y 0, que es lo único que entiende el ordenador.

Ventaja: No necesita ser traducido.

Inconveniente: La dificultad, la confusión, para corregir errores, es propia de cada máquina.

- De bajo nivel o ensamblador: Se utilizan mnemotécnicos (abreviaturas).

Ventaja: No es tan difícil como el lenguaje máquina.

Inconvenientes: Cada máquina tiene su propio lenguaje, necesitamos un proceso de traducción.

• El programa escrito en ensamblador se llama programa fuente y el programa que se obtiene al ensamblarlo se llama programa objeto.

- Lenguajes de alto nivel: Los más cercanos al lenguaje humano.

Ventaja: Son independientes de cada maquina (los compiladores aceptan las instrucciones estándar, pero también tienen instrucciones propias).

Inconveniente: El proceso de traducción es muy largo y ocupa más recursos. Aprovecha menos los recursos internos.

1.9.3 Proceso de traducción y ejecución de un programa escrito en un lenguaje a alto nivel:

Usamos un editor y obtenemos el programa fuente, y el compilador es el que traduce el programa al lenguaje máquina. El compilador internamente ha sido diseñado para traducir.

El compilador obtiene el programa o el fichero objeto. El compilador tiene que buscar los errores.

Normalmente no sale un ejecutable, sino que necesita elementos, librerías, ...

120

Mediante un linkador juntamos el programa objeto y las librerías, y se forma un programa ejecutable.

Cuando se ejecuta el programa, el cargador lleva al programa a memoria para que éste pueda ser ejecutable.

Debbuger: Depura el programa ejecutándolo paso a paso, viendo la memoria paso a paso para encontrar el error.

Programa fuente (Editor)

Compilador

Error

Programa objeto Librerias

Linkador

Ejecutables

121

Para traducir puedo utilizar el compilador o un interprete, con el compilador cojo todo el programa al completo y el interprete lee cada instrucción y lo va ejecutando.

El interprete es más rápido, pero menos eficiente.

Todos los lenguajes tienen compiladores, pero no todos tienen interpretes.

LISP (Lenguaje de inteligencia artificial) : Sólo tiene interpretes.

3.11 DATOS, TIPOS DE DATOS Y OPERACIONES PRIMITIVAS:- Dato: Es un objeto o elemento que tratamos a lo largo de diversas operaciones.

Tienen 3 caracteristicas:

- Un nombre que los diferencia del resto.

- Un tipo que nos determina las operaciones que podemos hacer con ese dato.

- Un valor que puede variar o no a lo largo de la operación.

Existen diferentes tipos de datos.

1.10.1 Caracteristicas de los tipos:

- Cada tipo se representa o almacena de forma diferente en la computadora.

Bit:1/0; Byte=8 bits.

- Un tipo agrupa a los valores que hacen las mismas operaciones.

- Si tiene definida una relación de orden es un tipo escalar.

- Cardinalidad de un tipo: Número de valores distintos que puede tomar un tipo.

Pueden ser finitos (caracteres), y si son infinitos el ordenador los toma como finitos porque esta limitado por el tamaño de los bytes en el que la cifra es almacenada.

1.10.2 Los datos pueden ser:

- Simples: Un elemento.

- Compuestos: Varios elementos.

1.10.3 Los tipos pueden ser:

- Estandar: Que vienen en el sistema por defecto.

- No estandar: Son los que crea el usuario.

122

1.10.4 Los tipos simples más importantes son:

- Numéricos.

- Lógicos.

- Caracteres.

• Numéricos:

- Entero: Subconjunto finito del conjunto matemático de los numéros enteros. No tiene parte decimal. El rango de los valores depende del tamaño que se les da en memoria.

- Real: Subconjunto finito del conjunto matemático de los números reales. Llevan signo y parte decimal. Se almacenan en 4 Bytes (dependiendo de los modificadores). Si se utilizan números reales muy grandes, se puede usar notación científica que se divide en mantisa, base y exponente; tal que el valor se obtiene multiplicando la mantisa por la base elevada al exponente.

• Lógicos o booleanos:

- Aquel que sólo puede tomar uno de los dos valores, verdadero o falso (1/0).

• Carácter:

- Abarca al conjunto finito y ordenado de caracteres que reconoce la computadora (letras, digitos, caracteres especiales, ASCII).

Tipo de cadena o String: Conjunto de caracteres, que van a estar entre “”.

El propio lenguaje puede añadir más tipos, o se pueden añadir modificadores.

Entero : Int Long int

En algunos lenguajes se definen tipos especiales de fecha y hora, sobre todo en los más modernos.

3.12 CONSTANTES Y VARIABLES:- Constantes: Tienen un valor fijo que se le da cuando se define la constante y que ya no puede ser modificado durante la ejecución.

- Variables: El valor puede cambiar durante la ejecución del algoritmo, pero nunca varia su nombre y su tipo.

Antes de usar una variable hay que definirla o declararla, al hacerlo hay que dar su nombre y su tipo. El nombre que le damos tiene que ser un nombre significativo, va a ser un conjunto de caracteres que dependiendo del lenguaje hay restricciones. Tiene que empezar por una letra, y el tamaño depende del lenguaje.

Identificador: Palabra que no es propia del lenguaje.

123

El valor de la variable si al declararla no se la inicializa, en algunos lenguajes toma una por defecto. En cualquier caso el valor de la variable podemos darle uno incial o podemos ir variandolo a lo largo de la ejecución.

Las constantes pueden llevar asociados un nombre o no, si no lo llevan, se llaman literales. Su valor hay que darlo al definir la constante y ya no puede cambiar a lo largo de la ejecución, y en cuanto al tipo, dependiendo de los lenguajes en algunos hay que ponerlo, y en otros no hace falta ponerlo porque toma el tipo del dato que se le asigna. Const PI=3,1416.

Hay que inicializar todas las variables.

< > Hay que poner algo obligatoriamente.

[ ] Puede llevar algo o no llevarlo.

La ventaja de usar constantes con nombre es que en cualquier lugar donde quiera que vaya la constante, basta con poner su nombre y luego el compilador lo sustituira por su valor.

Las constantes sin nombres son de valor constante: 5, 6, ‘a’, “hola”.

Cuando una cadena es de tipo carácter, se encierra entre ‘’ ‘a’.

Relación entre variables y constantes en memoria:

Al detectar una variable o una constante con nombre, automaticamente se reserva en memoria espacio para guardar esa variable o constante. El espacio reservado depende del tipo de la variable.

En esa zona de memoria es en la que se guarda el valor asociado a la variable o constante y cuando el programa use esa variable, ira a esa zona de memoria a buscar su valor.

3.13 EXPRESIONES: TIPOS Y OPERADORES:Una expresión es una combinación de constantes, variables, signos de operación,

paréntesis y nombres especiales (nombres de funciones estandar), con un sentido unívoco y definido y de cuya evaluación resulta un único valor.

Toda expresion tiene asociada un tipo que se corresponde con el tipo del valor que devuelve la expresion cuando se evalua, por lo que habrá tantos tipos de expresiones como tipos de datos. Habra expresiones numéricas y lógicas.

Numéricas: Operadores aritméticos.

Son los que se utilizan en las expresiones numéricas (una combinación de variables y/o constantes numéricas con operadores aritméticos y que al evaluarla devuelve un valor numérico.

124

+, -, *, /.

Operación resto: Lo que devuelve es el resto de una división entera.

Mod: Pascal. 5 mod 3 = 2

%: C.

División entera: Nos devuelve el cociente de una división entera (en la que no se sacan decimales).

Div: Pascal. 5 div 3 = 1

\: C.

Potencia: ^ 5^2.

Todos estos operadores son binarios (el operador se situa en medio), el menos tambien puede ser unario (lleva un único operando) y significa signo negativo.

Reglas de precedencia:

El problema es cuando una expresión entera según como la evalue pueda dar diferentes valores.

7*3+4 25

49

La solución es aplicar prioridad entre los operadores, de modo que ante la posibilidad de usar varios siempre aplicaremos primero el de mayor prioridad.

Cada lenguaje puede establecer sus propias reglas de prioridad o precedencia de operadores. Si no nos acordamos, siempre podemos poner ( ).

1ª) ^

2ª) * / div mod

3ª) + -

Entre dos operaciones que tienen la misma precedencia para resolver la ambigüedad, hay que usar la regla de la asociatividad. La más normal es la de la asociatividad a izquierdas (primero lo de la izquieda).

1.13 Expresiones lógicas: Operadores relacionales y lógicos.

Una expresión lógica es aquella que sólo puede devolver dos valores (Verdadero o Falso). Los valores que pueden aparecer en una expresión lógica son de 2 tipos: lógicos y relacionales.

125

La particularidad de las expresiones lógicas es que mientras en una expresión numérica por devolver un valor numérico los operandos solo pueden ser números, en una expresión lógica los operandos no tienen porque ser booleanos aunque se devuelva un valor booleano. Esto es lo que ocurre cuando en la expresión lógica utilizamos operadores relacionales con lo cual se obtienen valores lógicos o booleanos a partir de otros que no lo son.

En cambio cuando los operadores son lógicos los operandos obligatoriamente tambien tienen que ser lógicos.

Operadores relacionales:

<

>

=

<> en C: !=

< Operando1> operador < Operando2>

5 > 3 Verdadero

¿Cómo se evalua una expresión relacional?:

- Primero se evalua el primer operando y se sustituye por su valor.

- Luego se evalua el seguno operando y se sustituye por su valor.

- Finalmente se aplica el operador relacional y se devuelve el valor booleano correspondiente.

((3*2)+1-5^2) < (2-1)

-18 < 1 Verdadero.

El problema del tipo real:

Desde la informática, los numeros reales son finitos, ya que tenemos un máximo de cifras decimales. Cuando trabajamos con un =, matematicamente da un valor exacto, pero informaticamente no es exacto.

1/5 * 5 =1

1.0/5.0 *5.0 <>1.0

Soluciones:

- La que nos aporte el propio lenguaje de programación. Se considera un valor de error.

126

- Trabajar con números enteros siempre que sea posible.

- Utilizar las comparaciones <> en vez de si es posible.

- Si hay que preguntar por igual, cambiar la condición utilizando valores absolutos y un valor mínimo de error.

Si la diferencia < 0.00000001 y ABS (A-B)< min ; son iguales.

Operadores lógicos:

El problema es que a veces queremos preguntar o evaluar por más de una condición al mismo tiempo y para esto estan los operadores lógicos.

Y and &&

O or !!

No not ~!

Y, O, son operadores binarios (necesitan 2 operandos de tipo logico).

Operando 1 Operador Operando 2

El No es unario y se coloca primero el No, y despues el operando.

El resultado es lógico y depende de:

Operando 1 Operando 2 AND OR

V V V V

V F F V

F V F V

F F F F

El No niega :

NOT 1/0

V F

F V

127

Prioridades de los operadores:

- Lo más prioritario es el NOT

- Luego el Y y el O.

- <, > =,...

Tabla de prioridades:

^ NO

/ div mod y

+ - O

<, >, =, <>,...

3.14 FUNCIONES INTERNAS:Son funciones matemáticas diferentes de las operaciones básicas pero que se

incorporan al lenguaje y que se consideran estandar. Dependen del lenguaje. Normalmente se encuentran en la librería de matemáticas del lenguaje de programación.

Fórmulas:

Abs (x)

Arctan (x)

Cos (x)

Sen (x)

Exp (x)

Ln (x)

Log 10 (x)

Redondeo (x)

Trunc (x)

Cuadrado (x)

Raiz (x)

1.15 . OPERACIÓN DE ASIGNACIÓN:

128

Consiste en atribuir un valor a una variable. El valor sera una expresión (constante, variable,...).

Otros lenguajes = , :=

Variable a la que se le asigna el valor el valor que le vamos a asignar.

A 5

En C A = = B Comparación

A = B Asignación

En Pascal A:=B Asignación

A=B Comparación

El proceso de asignacion se realiza en 2 fases:

- Se evalúa la expresión de la parte derecha de la asignación obteniendose un único valor.

- Se asigna ese valor a la variable de la parte izquierda.

¿Qué es lo que hay que tener en cuenta?:

- En la parte izquierda sólo puede haber una variable.

- La variable a la que se le asigna el valor pierde su valor anterior.

- La variable que aparece en la derecha ya que como se evalua primero la de la derecha cuando se tenga que evaluar el valor de esa variable se tomara su valor antiguo.

- EL TIPO DEL VALOR QUE SE OBTIENE AL EVALUAR LA PARTE DERECHA TIENE QUE SER EL MISMO QUE EL TIPO DE LA VARIABLE DE LA PARTE IZQUIERDA, ES DECIR A UNA VARIABLE SOLO SE LE PUEDEN DAR VALORES DE SU MISMO TIPO.

- En Pascal da un error.

- En C, no da error porque el compilador trunca el numero.

A: entero

A 2

A 3*A + A = 8

129

1.15 . ENTRADA Y SALIDA DE LA INFORMACIÓN:

Las dos operaciones básicas de cada salida son las de lectura y de escritura. La lectura es equivalente a la asignación en cuanto que va a haber una variable que recibe un valor, pero este valor no resulta de evaluar ninguna expresión, sino que el valor lo vamos a leer de un dispositivo externo de entrada.

Leer (nombre de la variable)

El valor introducido por el dispositivo externo, tiene que ser del mismo tipo del que la variable que se le asigne.

La operación de escritura lo que hace es mostrar el valor de una variable en un dispositivo externo de salida.

Escribir (variable)

La operación de escritura no es una operación destructivo en memoria.

Al pedir un valor al usuario hay que decirle que es lo que se le quiere pedir escribiendo un mensaje.

2. ANALISIS DE ALGORITMOS

Recursos De Computadores Y Complejidad

Algoritmo: Conjunto de reglas para resolver un problema. Su ejecución requiere unos recursos.

Un algoritmo es mejor cuantos menos recursos consuma, su facilidad de programarlo, corto, fácil de entender, robusto, etc.

Criterio empresarial: Maximizar la eficiencia.

Eficiencia: Relación entre los recursos consumidos y los productos conseguidos.

Recursos consumidos: Tiempo de ejecución.

Memoria principal: Entradas/salidas a disco.

Comunicaciones, procesadores, etc.

Lo que se consigue: Resolver un problema de forma exacta, forma aproximada o algunos casos.

Recursos consumidos:

130

Ejemplo. ¿Cuántos recursos de tiempo y memoria consume el siguiente algoritmo sencillo?

i:= 0

a[n+1]:= x

repetir

i:= i + 1

hasta a[i] = x

Respuesta: Depende.

¿De qué depende? De lo que valga n y x, de lo que haya en a, de los tipos de datos, de la máquina...

En general los recursos dependen de:Factores externos.

El ordenador donde lo ejecutemos: 286, Pentium III, Cray,...

El lenguaje de programación y el compilador usado.

La implementación que haga el programador del algoritmo. En particular, de las estructuras de datos utilizadas.

Tamaño de los datos de entrada.

Ejemplo. Calcular la media de una matriz de NxM.

Contenido de los datos de entrada.Mejor caso. El contenido favorece una rápida ejecución.

Peor caso. La ejecución más lenta posible.

Caso promedio. Media de todos los posibles contenidos.

Los factores externos no aportan información sobre el algoritmo.

Conclusión: Estudiar la variación del tiempo y la memoria necesitada por un algoritmo respecto al tamaño de la entrada y a los posibles casos, de forma aproximada (y parametrizada).

externos no aportan información sobre el algoritmo.

Normalmente usaremos la notación T(N)=..., pero ¿qué significa T(N)?

Tiempo de ejecución en segundos. T(N) = bN + c.

Suponiendo que b y c son constantes, con los segundos que tardan las operaciones básicas correspondientes.

Instrucciones ejecutadas por el algoritmo. T(N) = 2N + 4.

131

¿Tardarán todas lo mismo?

Ejecuciones del bucle principal. T(N) = N+1.

¿Cuánto tiempo, cuántas instrucciones,...?

Sabemos que cada ejecución lleva un tiempo constante, luego se diferencia en una constante con los anteriores.

Asignación de tiempos, para el conteo de instrucciones. Algunas reglas básicas.

Operaciones básicas (+, -, *, :=,...): Una unidad de tiempo, o alguna constante.

Operaciones de entrada salida: Otra unidad de tiempo, o una constante diferente.

Bucles FOR: Se pueden expresar como una sumatoria, con los límites del FOR.

IF y CASE: Estudiar lo que puede ocurrir. Mejor caso y peor caso según la condición. ¿Se puede predecir cuándo se cumplirán las condiciones?

Llamadas a procedimientos: Calcular primero los procedimientos que no llaman a otros.

Bucles WHILE y REPEAT: Estudiar lo que puede ocurrir. ¿Existe una cota inferior y superior del número de ejecuciones? ¿Se puede convertir en un FOR?

El análisis de algoritmos también puede ser a posteriori: implementar el algoritmo y contar lo que tarda para distintas entradas.

Ejemplo. Programa “cifras.exe”:

N= 4, T(4)= 0.1 ms

N= 5, T(5)= 5 ms

N= 6, T(6)= 0.2 s

N= 7, T(7)= 10 s

N= 8, T(8)= 3.5 min

¿Qué conclusiones podemos extraer?

Análisis a priori: Evitamos la implementación, si el algoritmo es poco eficiente. Podemos hacer previsiones. Podemos comparar con otros algoritmos.

Medidas Asintoticas

Notación asintótica:

132

El tiempo de ejecución T(n) está dado en base a unas constantes que dependen de factores externos.

Nos interesa un análisis que sea independiente de esos factores.

Notaciones asintóticas: Indican como crece T, para valores suficientemente grandes (asintóticamente) sin considerar constantes.

O(T): Orden de complejidad de T.

W(T): Orden inferior de T, u omega de T.

Q(T): Orden exacto de T.

Orden de complejidad de f(n): O(f)

Dada una función f: N ® R+, llamamos orden de f al conjunto de todas las funciones de N en R+ acotadas superiormente por un múltiplo real positivo de f, para valores de n suficientemente grandes.

O(f)= { t: N ® R+ / $ c Î R+, $ n0 Î N, " n ³ n0: t(n) £ c·f(n) }

Nota:

O(f) es un conjunto de funciones, no una función.

“Valores de n sufic. Grandes...”: no nos importa lo que pase para valores pequeños.

“Funciones acotadas superiormente por un múltiplo de f...”: nos quitamos las constantes.

La definición es aplicable a cualquier función de N en R, no sólo tiempos de ejec.

Propiedades

P1. Si f Î O(g) y g Î O(h) entonces f Î O(h).

Si f Î W(g) y g Î W(h) entonces f Î W(h)

Ej. 2n+1 Î O(n), n Î O(n2) Þ 2n+1 Î O(n2)

P2. Si f Î O(g) entonces O(f) Í O(g).

¿Cómo es la relación para los W?

P3. Dadas f y g de N en R+, se cumple:

i) O(f) = O(g) Û f Î O(g) y g Î O(f)

ii) O(f) Í O(g) Û f Î O(g)

¿La relación de orden entre O(..) es completa? Dadas f y g, ¿se cumple O(f)ÍO(g) ó O(g)ÍO(f)?

133

P4. Dadas f y g, de N en R+, O(f+g) = O(max(f, g)).

W(f+g) = W(max(f+g))

¿Y para los Q(f+g)?

¿Es cierto que O(f - g) = O(max(f, -g))?

P5. Dadas f y g de N en R+, se cumple:

i) limn¥® f(n) Î R+ Þ O(f)=O(g), W(f)=W(g), Q(f)=Q(g)

g(n)

ii) limn¥® f(n) = 0 Þ O(f) Í O(g), W(g) Í W(f)

g(n)

P5. Ej. ¿Qué relación hay entre O(log2 n) y O(log10 n)?

P6. Dadas f y g de N en R+, O(f)=O(g) Û Q(f)=Q(g) Û f Î Q(g) Û W(f)=W(g)

P7. Dadas f y g de N en R+, se cumple:

i) limn¥® f(n) Î R+ Þ O(f) = O(g)

g(n)

ii) limn¥® f(n) = 0 Þ O(f) Ì O(g)

g(n)

iii) limn¥® f(n) = +¥ Þ O(f) É O(g)

g(n)

Notación con varios parámetros:

En general, el tiempo y la memoria consumidos pueden depender de muchos parámetros.

f: Nm ® R+ (f: Nx...m..xN ® R+)

Ej. Memoria en una tabla hash. M(B,n, l, k) = kB+l+n+2kn

Orden de complejidad de f(n1, n2, ..., nm): O(f)

Dada una función f: Nm ® R+, llamamos orden de f al conjunto de todas las funciones de Nm en R+ acotadas superiormente por un múltiplo real positivo de f, para valores de (n1, ..., nm) suficientemente grandes.

O(f)= { t: Nm ® R+ / $ c Î R+, $ n1, n2, .., nm Î N, " k1 ³ n1 ,

134

k2 ³ n2 ,..," km ³ nm : t(k1, k2, ..., km) £ c·f(k1, k2, ..., km) }

De la misma forma, podemos extender los conceptos de W(f) y Q(f), para funciones con varios parámetros.

Las propiedades se siguen cumpliendo ® Demostrarlo.

Ejemplo. T(N) = T(N, a, b) = a·N + b

El tiempo depende del tamaño del problema N, y del tiempo de inicialización b y de ejecución de un paso a.

Podemos suponerlos constantes T(N), o variables T(N,a,b).

¿Qué relación hay entre los siguientes órdenes?

O(n+m), O(nm) O(n2), O(n+2m)

Notaciones condicionales:

En algunos casos interesa estudiar el tiempo sólo para ciertos tamaños de entrada.

Ejemplo. Algoritmo de búsqueda binaria: Si N es potencia de 2 el estudio se simplifica.

Orden condicionado de f(n): O(f | P)

Dada una función f: N ® R+, y P: N ® B, llamamos orden de f según P (o condicionado a P) al conjunto:

O(f | P)= { t: N ® R+ / $ c Î R+, $ n0 Î N, " n ³ n0:

P(n) Þ t(n) £ c·f(n) }

De igual forma, tenemos W(f | P) y Q(f | P).

O(f) = O(f | true). Para cualquier f y g, f Î O(g | false).

¿O(f) « O(f | P)?

Ordenes De Complejidad

Uso de los órdenes de complejidad:

Dado un tiempo t(n), encontrar la función f más simple tal que t Î O(f), y que más se aproxime asintóticamente.

Ejemplo. t(n) = 2n2/5 + 3p/2; t(n) Î O(n2).••Relación de orden entre O(..) = Relación de inclusión entre conjuntos.–O(f) £ O(g) Û O(f) Í O(g) Û Para toda t Î O(f), t Î O(g)•Se cumple que:

135

O(c) = O(d), siendo c y d constantes positivas.

O(c) Ì O(n)

O(cn + b) = O(dn + e)

O(p) = O(q), si p y q son polinomios del mismo grado.

O(p) Ì O(q), si p es un polinomio de menor grado que q.

Orden inferior u omega de f(n): W(f):

Dada una función f: N ® R+, llamamos omega de f al conjunto de todas las funciones de N en R+ acotadas inferiormente por un múltiplo real positivo de f, para valores de n suficientemente grandes.

W(f)= { t: N ® R+ / $ c Î R+, $ n0 Î N, " n ³ n0: t(n) ³ c·f(n) }

La notación omega se usa para establecer cotas inferiores del tiempo de ejecución.

Relación de orden: igual que antes.

Orden exacto de f(n): Q(f):

Dada una función f: N ® R+, llamamos orden exacto de f al conjunto de todas las funciones de N en R+ que crecen igual que f, asintóticamente y salvo constantes.

Q(f) = O(f) Ç W(f) == { t: N ® R+ / $ c, d Î R+, $ n0 Î N, " n ³ n0: c·f(n) ³ t(n) ³ d·f(n) }

Notación o pequeña de f(n): o(f):

Dada una función f: N ® R+, llamamos o pequeña de f al conjunto de todas las funciones de N en R+ que crecen igual que f asintóticamente:

o(f)= { t: N ® R+ / lim t(n)/f(n) = 1}n¥®

Esta notación conserva las constantes multiplicativas para el término de mayor orden.

Ejemplo. t(n) = amnm + am-1nm-1 + ... +a1n + a0t(n) Î o(amnm) ¹ o(nm)

¿o(amnm) Í O(amnm)? ¿o(t) Í O(t)?

Costa de complejidad con frecuencia

Algunas relaciones entre órdenes frecuentes:

O(1) Ì O(log n) Ì O(n) Ì O(n·log n) Ì O(n·(log n)2) Ì O(n1.001...) Ì O(n2) Ì O(n3) Ì ... Ì O(2n) Ì O(n!) Ì O(nn)

136

¿Qué pasa con las omegas? ¿Y con los órdenes exactos?

El orden de un polinomio anxn+...+a1x+a0 es O(xn).

n n n

å1 = n Î O(n); åi = n(n+1)/2 Î O(n2); åim Î O(nm+1)

i=1 i=1 i=1

Si hacemos una operación para n, otra para n/2, n/4, ..., aparecerá un orden logarítmico O(log2 n). Los logaritmos son del mismo orden, independientemente de la base.

2.2 RESOLUCIÓN DE PROBLEMAS CON COMPUTADORA Y HERRAMIENTAS DE PROGRAMACIÓN:

2.2.1. RESOLUCIÓN DE PROBLEMAS:

La resolución de un problema desde el punto de vista algorítmico tiene 3 fases:

- Análisis del problema: Comprensión.

- Diseño del algoritmo: Resolución algorítmica.

- Resolución en computadora: Implantación del algoritmo en un lenguaje de programación.

2.2.2. ANÁLISIS DEL PROBLEMA:

El objetivo de ésta fase es comprender el problema para lo cual como resultado tenemos que obtener la especificación de las entradas y salidas del problema. Tiene que quedar claro que entra y que sale.

2.2.3. DISEÑO DEL ALGORITMO:

Una vez comprendido el problema se trata de determinar que pasos o acciones tenemos que realizar para resolverlo.

137

Como criterios a seguir a la hora de dar la solución algorítmica hay que tener en cuenta:

1. Si el problema es bastante complicado lo mejor es dividirlo en partes más pequeñas e intentar dividirlo en partes más pequeñas e intentar resolverlas por separado. Esta metodología de “divide y vencerás” también se conoce con el nombre de diseño descendente.

2. Las ventajas de aplicar esto son:

- Al dividir el problema en módulos o partes se comprende más fácilmente.

- Al hacer modificaciones es más fácil sobre un módulo en particular que en todo el algoritmo.

- En cuanto a los resultados, se probarán mucho mejor comprobando si cada módulo da el resultado correcto que si intentamos probar de un golpe todo el programa porque si se produce un error sabemos en que módulo ha sido.

Una segunda filosofía a la hora de diseñar algoritmos es el refinamiento por pasos, y es partir de una idea general e ir concretando cada vez más esa descripción hasta que tengamos algo tan concreto para resolver. Pasamos de lo más complejo a lo más simple.

La representación de los algoritmos:

Una vez que tenemos la solución hay que implementarla con alguna representación. Las representaciones más usadas son los flujogramas, los diagramas NS y el pseudocódigo.

También la solución se puede escribir en algunos casos en lenguaje natural pero no se hace porque es muy ambiguo, e incluso otras formas de expresión como fórmulas matemáticas.

Escritura del algoritmo:

Al escribir el algoritmo hay que tener en cuenta:

- Las acciones o pasos a realizar tienen que tener un determinado orden.

- En cada momento solo se puede ejecutar una acción.

- Dentro de las sentencias del algoritmo pueden existir palabras reservadas (palabras propias del lenguaje de programación que tienen para el compilador un determinado significado).

- Si estamos utilizando pseudocódigo tenemos también que usar la identación (aumenta la legibilidad del problema para que se pueda leer mejor).

2.2.4. RESOLUCIÓN EN LA COMPUTADORA:

138

Es hacer entender nuestro algoritmo a la computadora para que lo pueda hacer.

1. Codificamos el algoritmo en un leguaje de programación.

2. Ejecutar el programa antes compilado.

3. Comprobar los resultados y si no funciona, corregirlo.

2.2.5. FLUJOGRAMAS:

Es una notación gráfica para implementar algoritmos. Se basa en la utilización de unos símbolos gráficos que denominamos cajas, en las que escribimos las acciones que tiene que realizar el algoritmo.

Las cajas están conectadas entre sí por líneas y eso nos indica el orden en el que tenemos que ejecutar las acciones.

En todo algoritmo siempre habrá una caja de inicio y otra de fin, para el principio y final del algoritmo.

Los símbolos:

Líneas de flujo: Una línea con una flecha que sirve para conectar los símbolos del diagrama y la flecha indica la secuencia en la que se van a ejecutar las acciones.

Símbolo de proceso: Indica la acción que tiene que realizar la computadora. Dentro escribimos la acción.

Representa las acciones de entrada y salida. Dentro colocaremos las acciones de lectura y escritura.

Condición: Dentro se va a colocar una condición. Sirve para representar estructuras selectivas y repetitivas y lo que se hace al encontrar ese signo es evaluar la condición que hay dentro tal que según la condición sea verdadera o falsa iremos por caminos distintos.

139

Principio y fin: Dentro del símbolo ira la palabra inicio o fin del algoritmo.

Subprograma: Dentro se coloca el nombre del subprograma al que se llama.

Conectores: Nos sirven cuando un flujograma no me cabe en una columna de la hoja y hay que seguir en otra columna:

- Si es en la misma hoja:

- Si es en hoja distinta:

Los conectores se ponen uno donde termina la columna y otra donde empieza.

Es una aclaración para entender mejor el código, pero no es parte del código, no se ejecuta.

Otros símbolos:

- Pantalla: Cuando una salida es por pantalla.

140

- Teclado: Para representar una entrada por teclado.

- Impresora:

- Entrada/Salida por disco:

*Problema:

Queremos hallar el producto de varios números positivos introducidos por teclado y el proceso termina cuando se meta un número negativo.

1. Iniciar la variable del producto.

2. Leer el primer número.

3. Preguntar si es negativo o positivo.

4. Si es negativo nos salimos y escribimos el producto.

5. Si es positivo, multiplicamos el número leído y luego leemos un nuevo número, y se vuelve al paso 3.

Inicio

141

P 1

Leer num

Num >= 0 Escribir P

P P * num Fin

Leer num

3 TECNICA DE DISENO DE ALGORITMOS

Diseño de Algoritmos:

Hasta ahora se han realizado algunos comentarios respecto a la necesidad de diseñar algoritmos correctos y eficientes utilizando los elementos de un lenguaje de programación .Es necesario en este momento mencionar algo sobre como hacerlo. El acto de diseñar un algoritmo puede considerarse como una tarea que difícilmente podrá ser del todo automatizada.

142

Todo problema algorítmico es un reto para su diseñador, algunos resultan inmediatos de resolver, otros son bastante complejos. La investigación en esta área ha permitido descubrir un conjunto de métodos o esquemas de diseño hacia los cuales puede orientarse la realización de muchos algoritmos.

No obstante, y a pesar de que resulta mas adecuado en bastantes casos utilizar alguno de estos esquemas que realizar un diseño desde cero, idear un algoritmo continua siendo una labor bastante creativa donde los conocimientos y la experiencia del propio diseñador tiene un papel fundamental.

El diseño de un algoritmo que resuelva un problema es, en general, una tarea difícil. Una forma de facilitar esta labor consiste en recurrir a técnicas conocidas de diseño de algoritmos, se decir, a esquemas muy generales que pueden adaptarse a un problema particular al detallar las partes generales del esquema.

Muchos problemas pueden resolverse buscando una solución fácil y directa pero, a la vez bastante ineficiente. Este método, llamado de fuerza bruta, puede ser muy directo, pero con un poco de análisis puede encontrarse algoritmos más eficientes. El esquema mas sencillo quizás sea el llamado divide y vencerás, basado en la descomposición de un problema en subproblemas. Otros esquemas requieren un análisis minucioso del problema de forma que la solución se vaya construyendo en etapas. Si puede preverse que decisión conviene en cada etapa para producir cierto tipo de mejor resultado, tenemos una solución voraz, si la decisión en una etapa, solo puede tomarse tras considerar varias soluciones de otras etapas mas simples, la solución es dinámica. Aun así, hay problemas cuya solución no puede hallarse sino mediante un proceso de búsqueda, a pesar de lo complejas que son las operaciones de búsqueda, su uso adecuado mediante el esquema de búsqueda con retroceso (o backtracking) permite ganar gran eficiencia respecto a soluciones de fuerza bruta. Por ultimo, conviene conocer otros métodos de diseño de algoritmos que también resultan de utilidad práctica.

Nos estamos refiriendo a métodos basados en la mejora de la eficiencia (por ejemplo, el uso de parámetros de acumulación al resolver problemas utilizando divide y vencerás, y el empleo de tablas como estructura auxiliar para la resolución eficiente de problemas donde se aplica programación dinámica), y a métodos basados en transformaciones del dominio para encontrar una solución mas fácilmente a un problema en un dominio transformado, siendo dicha solución finalmente adaptada al dominio original.

Consideraciones generales

Si el hábil programador dispone de un recetario de algoritmos de donde poder seleccionar el más adecuado para cada problema, su tarea se simplifica.

Supongamos que disponemos de una especificación precisa, completa y consistente del problema a resolver y queremos obtener un algoritmo en el que, dados uno datos de entrada valido, se produzca cierto resultado. Si no nos importa la eficiencia del algoritmo, podríamos utilizar un algoritmo general llamado algoritmo del museo británico. Se programa un

143

computador de manera que parta de un conjunto de axioma matemáticos y los que use para reducir aleatoriamente teoremas validos.

Aprender los principios básicos del diseño de algoritmos podemos preguntarnos por un método aceptable. El mas entendido, y quizás el mejor, es organizar el diseño sobre un esquema de algoritmo o una técnica de diseño que haya demostrado su utilidad para otros problemas. Este método de trabajo es practicable, puesto que existe un número reducido de esquema y técnicas de diseño.

El conocimiento de técnicas de diseño es solo un primer paso para el diseñador, que debe completarse con otros conocimientos y, sobre todo, con la experiencia.

Método de fuerza bruta

Comenzamos el estudio de esquemas algorítmicos con un método sencillo, pero que debe evitarse siempre que se pueda, dad su ineficacia; la fuerza bruta. En realidad, no es un esquema algorítmico, si no mas bien calificativo

Para una forma de diseñar algoritmos: tomar una solución directa, poco reflexionada. En principio, esto no es malo, pero dado que no se ha analizado apenas el problema, es muy probable que no se hayan aprovechado propiedades deducibles del problema y que la solución sea terriblemente ineficiente.

Una solución por fuerza bruta también puede resultar adecuada como primera aproximación a la solución final, porque su desarrollo puede permitir profundizar más sobre el problema y conocer propiedades que sean utilizadas para obtener otra versión más eficiente.

Por ejemplos:

Algunos algoritmos de búsqueda de un elemento en un vector. Uno de ellos realizaba una búsqueda secuencial con complejidad lineal sobre el tamaño del vector y podía usarse con cualquier vector. Otro algoritmo realizaba un búsqueda dicotomica o binaria, con complejidad logarítmica, y solo se podía usar cuando el vector estuviese ordenado. El algoritmo primero responde a un razonamiento más sencillo, por lo que uno puede sentirse tentado a usar siempre. Esta es la solución de fuerza bruta: una solución directa, pero poco reflexionada. Lo más razonable es comprobar si el vector esta ordenado y, en caso positivo, aprovechar esta circunstancia para usar el algoritmo más eficiente: el de búsqueda binaria.

Técnicas de los Parámetros Acumuladores y de Tabulacion

La recurcion es un mecanismo que permite obtener, en combinación con otras contrucciones, una solución funcional a muchos problemas. Muchos algoritmos recursivos resultan eficientes, pero no todos: hay algunos fácilmente formulables, pero muy ineficientes. En estos casos,

144

dichos algoritmos pueden servir como una primera aproximación al algoritmo definitivo, pero debe mejorar su rendimiento para que sea práctico.

Veremos dos parámetros para la mejora de eficiencia de algoritmos recursivos: el uso de parámetros acumuladores y el uso de tablas. Cada una se ilustra con un ejemplo distinto.

Parámetros Acumuladores

Veamos primero una solución ineficiente que intentaremos mejorar.

Ejemplo: Números de Fibonacci

Los números de fibonacci suele especificarse como:

Fib(0)=1

Fib(1)1

Fib(n+2)=fib(n)+fib(n+1)

Esta especificación de los números de fibonacci tienen una formulación recursiva inmediata en estilo funcional.

Un modo de evitar problema lo proporciona la técnica de los parámetros acumuladores, cuya idea básica se expone a continuación. La función principal usa una función auxiliar que tiene los parámetros de aquellas más algunos adicionales. La función principal simplemente realiza una llamada a esta función auxiliar en los que los parámetros de aquellas se modifican y los parámetros nuevos toman un valor inicial adecuado .

Los parámetros adicionales tienen como misión ir acumulando resultados principales durante el proceso recursivo.

Tabulacion

No todos los algoritmos recursivos ineficientes pueden optimizarse con la técnica de los parámetros acumuladores.

Otra técnica útil es el uso de tablas.

La intención es que la primera vez que se realiza un cálculo, se almacena en una tabla, donde puede consultarse otras veces que se necesite. Esta técnica también se suele emplear con la programación dinámica.

Ejemplo:

Sea el problema de la competición. Hay dos participantes (deportistas o equipos, no importa que), A,B, que juegan una competición que es ganada por el primero que venza en n partidos, siendo ( n ) mayor que( 0 ).

145

Por sencillez , se supone que ambos participantes tienen cualidades y preparación similar . De forma que cada uno tiene un 50% de posibilidades de ganar cada partido. De todas formas, la modificación para incorporar probabilidades diferentes es evidente y no complica el problema.

Divide y vencerás:

Consiste en descomponer un problema en un subproblema, resolver independientemente los subproblemas para luego combinar sus soluciones y obtener la solución del problema original. Esta técnica se puede aplicar con éxito a problemas como la multiplicación de matrices, la ordenación de vectores, la búsqueda en estructuras ordenadas,etc.

Ejemplo. Búsqueda de una palabra en un diccionario

Como ejemplo sencillo de aplicación de esta estrategia puede considerarse la búsqueda de una palabra en un diccionario de acuerdo con el siguiente criterio.

Se abre el diccionario por la pagina centrar(quedando dividido en dos mitades) y se comprueba si la palabra aparece allí o si es léxico gráficamente anterior o posterior. Si no ha encontrado y es anterior se procede a buscarla en la primera mitad., si es posterior, se buscara en la segunda mitad. El procedimiento se repite sucesivamente hasta encontrar la palabra o decidir que no aparece.

Método voraz:

Este método trata de producir tipo de mejor resultado a partir de conjunto de opciones candidatas .Para ello, se va procedimiento paso a paso realizándose la mejor elección (usando una función objetivo que respeta un conjunto de restricciones ) de entre las posibles. Puede emplearse en problemas de optimización, como el conocido de la mochila, en la búsqueda de caminos mínimos sobre grafos, la planificación en el orden de la ejecución de unos programas en un computador,etc.

Ejemplo. Dar un cambio utilizando el menor número de monedas

Considérese ahora el problema de la devolución del cambio al realizar una compra (por ejemplo, en una maquina expendedora de tabaco). Suponiendo que se disponga de cantidad suficiente de ciertos tipos diferentes de monedas de curso legal, se trata de dar como cambio la menor cantidad posible usando estos tipos de monedas. La estrategia voraz aplicada comienza devolviendo, cuando se pueda, la moneda de mayor valor ( es decir, mientras el valor de dicha moneda sea mayor o igual al cambio que resta por dar), continua aplicándose el mismo criterio para la segunda moneda mas valiosa, y así sucesivamente. El proceso finaliza cuando se ha devuelto todo el cambio.

Consideraciones y Criterios para Diseñar Algoritmos

146

Algunas consideraciones estilísticas pueden contribuir a mejor la calidad de los algoritmos (y programas ) mediante la reducción del numero de errores que aparecen al desarrollar los. También influyen haciendo que nuestro algoritmo resulten más fáciles de leer y entender para otras personas.

Los criterios de estilo pueden reflejarse en un conjunto de normas de estilo de codificación. Ello asegura que tanto algoritmos como programa resulten legibles y puedan modificarse fácilmente en caso de necesidad. Generalmente, estas normas de estilo se dirigen hacia aspectos como la forma de construir los nombres de variables o tipo de datos que aparezcan., la tipografía seguida ala hora de escribir nombres de variables, subprogramas, palabras claves, etc. El modo de encolumnar las distintas partes de un algoritmo para facilitar su lectura y comprensión, y la normas sobre como y donde deben de introducirse los comentarios.

Estilo y calidad de los programas van fuertemente unidos. Ante la pregunta ¿Cuáles son las característica de un buen algoritmo?, las siguientes respuestas reflejan, cierta medida, los factores que identifican la calidad en ellos .

1. Corrección, el algoritmo debe funcionar.

2. Nunca se debe olvidar que la característica más simple e importante de un algoritmo es que funcione. Pude aparecer obvio, pero resulta difícil de asegurar en algoritmos complejos.

3. Eficiencia, el algoritmo no debe desaprovechar recursos. La eficiencia de un algoritmo se mide por los recursos que este consume. En particular, se habla de la memoria y del tiempo de ejecución . A pesar de que con la reducción de los costes del hardware es posible diseñar computadores más rápidos y con más memoria, no hay que desperdiciar estos recursos y tratar de desarrollar algoritmos más eficientes.

4. Claridad, el algoritmo debe estar bien documentación. La documentación ayuda a comprender el funcionamiento de los algoritmos. Ciertos detalles o algunas partes especiales de los mismos pueden olvidarse fácilmente o quedar oscura si no están adecuadamente comentadas.

En realidad, y de acuerdo con los puntos de vista anteriores, la calidad de un algoritmo tiene muchas facetas y todas ellas importantes. Resumiendo, lo ideal es que nuestro algoritmo resulte correcto, eficiente, claro, fiable y fácil de mantener.

Algoritmos voraces

Esquema voraz

Hay muchos problemas en los que se pretende obtener un subconjunto de n elementos que satisfaga ciertas restricciones y que optimice alguna medida. Se supone que un problema de esta clase tiene al menos una solución. Puede haber varias soluciones optimas, en cuyo caso no importa cual se elija. Por ejemplo, sea el problema de encontrar un subconjunto de los arcos de un grafo. Otro ejemplo se da cuando, dados unos ficheros almacenados en una cinta de que el tiempo de recuperación de un fichero cualquiera sea el mínimo en promedio. A

147

menudo, el problema incluye restricciones adicionales que limitan el número posible de soluciones.

Normalmente, estos problemas no se intentan resolver “de golpe “, encontrando de una sola vez la solución completa y óptima. Es más frecuente que el subconjunto de la solución se vaya formando paso a paso, analizando durante cada etapa que elemento conviene añadir a la solución parcial ya existente. La dificultad principal para resolver esta clase de problemas estriba en el análisis necesario para poder formular un algoritmo que halle la solución en varios pasos.

Un algoritmo voraz sigue el esquema anterior, pero con la fortuna de que cada vez que añade un elemento a la solución se tiene la certeza de haber realizado la mejor elección posible. Esta característica hace que aunque el análisis del problema sea arduo, la solución voraz siempre resulte sencilla. La única complicación es comprobar que se siguen satisfaciendo las restricciones del problema.

Por lo que se ha descrito del esquema voraz, éste es un proceso repetitivo sencillo que trata sucesivamente los diferentes elementos del problema. Para facilitar la descripción de este proceso, puede llamarse candidato al elemento tratado en cada paso. Inicialmente, el conjunto de candidatos que forman la solución está vacío. En cada paso se intenta añadir el mejor de los candidatos restantes a dicha solución parcial. Si este conjunto ampliado sigue siendo válido, es decir, si satisface las restricciones del problema y, por tanto, permite formar una solución del problema, el candidato se incorpora definitivamente. Al contrario, si dicho conjunto no es válido, se desecha el candidato. Si el algoritmo voraz se ha diseñado correctamente, la primera solución encontrada es óptima. Por tanto, la dificultad principal al diseñar un algoritmo voraz reside en encontrar un criterio en encontrar un criterio de selección que garantice la optimalidad de la solución.

Según esta descripción, el problema parte de:

• Una función objetivo que da el valor de una solución. Obviamente, ésta es la función por optimizar.

• Un conjunto de restricciones sobre el valor de los datos de entrada y sobre la solución final del problema.

A su vez, la solución consta de:

• Un conjunto de candidatos

• Una función de selección que en cada momento determine que candidato de los aún no usados parece ser el mejor.

• Una función que determine si cierto conjunto de candidatos es válido; es decir, si permite formar alguna solución del problema.

Obsérvese que las funciones de validez y completitud no se preocupan de la optimalidad del la solución, pero si la función de selección es la adecuada, cada solución válida y completa es optima.

148

3.1 . PSEUDOCÓDIGO:

Es un lenguaje de especificación de algoritmos, pero muy parecido a cualquier lenguaje de programación, por lo que luego su traducción al lenguaje es muy sencillo, pero con la ventaja de que no se rige por las normas de un lenguaje en particular. Nos centramos más en la lógica del problema.

El pseudocódigo también va a utilizar una serie de palabras clave o palabras especiales que va indicando lo que significa el algoritmo.

1. Inicio y Fin: Por donde empieza y acaba el algoritmo.

Begin /end : Pacal.

{ } : En C.

2. Sí <cond>

Entonces <acc1> If then else

Sino <acc2>

3.Mientras <cond> /hacer while do

4. Repetir / hasta repeat until

5. Desde /hasta for .. to

6. Según sea Case

Swith

• Los comentarios van encerrados entre llaves.

• Hay que utilizar la identación.

Algoritmo <nombre alg>

Var

<nombre>: <tipo>

Inicio

<Instrucciones>

Fin

Algoritmo Producto

149

Var

P, num: entero

Inicio

P 1

Leer num

Mientras num >=0 hacer

P p*num

Leer num

Fin mientras

Escribir p

Fin

1. Realizar un programa que convierta los grados a radianes.

Algoritmo convertir

Var

Grados, rad: real

Inicio

Escribir “Introduce los grados”

Leer grados

Si grados >= 360

Entonces grados grados mod 360

Fin si

Rad grados / 180

Escribir rad “ radiantes”

150

Fin

2. Realizar un algoritmo que pida un valor entero que equivale a un número de duros y me calcule a cuantos billetes de 5000, 1000, monedas de 200, 25, 1.

Algoritmo cambio

Var

Duros: real

Inicio

Escribir “Introduce los duros”

Leer duros

Duros duros * 5

Escribir duros div 5000 “billetes de 5000”

Duros duros mod 5000

Escribir duros div 1000 “billetes de 1000”

Duros duros mod 1000

Escribir duros div 200 “monedas de 200”

Duros duros mod 200

Escribir duros div 25 “monedas de 25”

Duros duros mod 25

Escribir duros “monedas de 1”

Fin

3. Realizar un programa que pida al usuario la velocidad en m/s y el radio de la circunferencia de la pista, y resultada el programa devuelve el tiempo que tarda el atleta en dar 2 vueltas a la pista, sabiendo que el atleta descansa 1 minuto cada 1000 metros.

Algoritmo recorrido

Var

151

Velocidad,radio,tiempo,longitud: entero

Inicio

Escribir “Introduce la velocidad”

Leer velocidad

Escribir “Introduce el radio”

Leer radio

Longitud 4 * 3.1416 * radio

Descanso longitud div 1000

Tiempo longitud div velocidad + descanso * 60

Escribir tiempo

Fin

3.2 ESTRUCTURA GENERAL DE UN PROGRAMA

3.2.1 CONCEPTO DE PROGRAMA:

Un programa es un conjunto de instrucciones que al ser ejecutadas resuelven un problema.

Un programa tiene 3 partes:

1. Entrada de datos: Normalmente se va a ejecutar a través de instrucciones de lectura, y en lo que se le pide al usuario la información que el programa va a necesitar para ejecutarse y se hace a través de lecturas.

2. Acciones de un algoritmo: Parte en la que se resuelve el problema usando los datos de entrada.

3. Salida: Mostrar en un dispositivo de salida los resultados de las acciones anteriormente realizadas. Son acciones de escritura.

En la parte de las acciones a ejecutar se distinguirán dos partes:

- Declaración de variables.

- Instrucciones del programa.

152

3.2.2. INSTRUCCIONES Y TIPOS:

Para que una instrucción se ejecute tiene que ser llevada a memoria. En cuanto al orden de ejecución de las instrucciones, el programa puede ser de dos tipos:

- Programas lineales: Se va ejecutando una instrucción más otra y el orden de ejecución es igual al orden de escritura.

- Programas no lineales: Las instrucciones no se ejecutan en el mismo orden en el que aparecen escritas, sino que se realizan saltos que nos mandan de unas instrucciones a otras.

• Nunca se deben hacer saltos no lineales.

Tipos de instrucciones:

1. Inicio y fin.

2. Asignación: Dar un valor a una variable.

3. Lectura / escritura: Introducir o sacar información por dispositivos E/S.

4. Instrucciones de bifurcación: Alternan el orden de ejecución del programa. Salto a otra instrucción que no es la siguiente.

4.1. Bifurcación incondicional: El salto se produce siempre que el programa vaya a esa instrucción: Goto Ir a.

4.2. Bifurcación condicional: Se ejecutan un conjunto de instrucciones u otras dependiendo del valor devuelto al evaluar una condición.

Es la que vamos a usar.

3.2.3. ELEMENTOS BÁSICOS DE UN PROGRAMA:

¿Qué es la sintaxis de un lenguaje?:

Conjunto de reglas que tenemos que seguir a la hora de escribir un programa en ese lenguaje tal que si no seguimos esas reglas de sintaxis el compilador da errores.

Elementos del lenguaje de programación:

1. Palabras reservadas: Son un conjunto de palabras especiales que nos sirven para definir la estructura del programa, y solo se pueden usar para el fin para el que están reservadas.

153

2. Identificadores: Son los nombres que aparecen en el programa dados por el usuario. Son por tanto los nombres de variables, de constantes, de subprogramas y nombres de tipos creados por el usuario.

3. Caracteres especiales: Sirven como separadores entre sentencias, por ejemplo el ;.

4. Instrucciones: De 3 tipos, secuenciales, repetitivas y selectivas, y pueden aparecer elementos especiales (bucles, contadores, interruptores y acumuladores).

• Bucle: Un conjunto de instrucciones que se repiten un número finito de veces. Lleva asociado aparte de las instrucciones una condición que es la que determina cuando se termina un bucle. Ejecución de un bucle (iteración). Los bucles se pueden anidar unos dentro de otros, y puede haber varios bucles al mismo nivel, pero nunca se entrelazan.

• Contador: Un elemento cuyo valor se incrementa o decrementa en un valor constante en cada iteración de un bucle, y se utiliza para controlar la condición del bucle.

• Acumulador: Es una variable que también se suele usar en los bucles y que se incrementa o decrementa en cada iteración del bucle, pero no en una cantidad constante.

Algoritmo ejemplo

Var cont, num, sum: entero

Inicio

Cont 0

Sum 0

Mientras cont <> 3

Leer num

Sum sum + num

Cont cont +1

Fin mientras

Escribir suma

End

• Interruptor (marca, bandera o flag): Es una variable que sirve como indicador de una determinada información y que solo puede tomar uno de dos valores. El valor de la variable tiene asociado un signo y puede variar a lo largo de la ejecución.

Algoritmo ejemplo

154

Var cont, num, suma: entero

Neg: boolean

Inicio

Cont 0

Sum 0

Neg falso

Mientras cont <>3

Leer num

Si num < 0

Entonces neg verdadero

Fin si

Sum sum + num

Cont cont + 1

Fin mientras

Si neg=verdadero

Entonces escribir (“Se ha leído negativos”)

Sino escribir (“No negativos”)

Fin si

Fin

Si es leer un número negativo o hasta 3 números:

Mientras (cont <> 3) y (neg = verdadero)

3.2.4. ESCRITURA DE ALGORITMOS Y PROGRAMAS:

En pseudocódigo el programa tiene dos partes, la cabecera y el cuerpo. La cabecera contiene el nombre del algoritmo, y el cuerpo contiene 2 partes.

La primera es la zona de declaraciones de var y const, y la segunda es la zona de las instrucciones del programa.

En la zona de instrucciones para que quede más legible hay que usar la identación y si es necesario hay que usar comentarios entre llaves.

155

5. INTRODUCCIÓN A LA PROGRAMACIÓN ESTRUCTURADA:

5.1. TÉCNICAS DE PROGRAMACIÓN:

El programar con flujogramas o diagramas NS resulta muy lioso en el momento en que el programa se complica, por eso vamos a utilizar siempre el pseudocódigo, en el que vamos a utilizar dos técnicas de programación que no se usan por separado, sino que son complementarios.

Estas técnicas son:

• Programación modular: Consiste en dividir el programa en partes llamadas módulos, e implementar cada uno de esos módulos por separado.

• Programación estructurada: Cuyo objetivo es hacer más legible y lógico la estructura del programa utilizando para ello solamente tres tipos de estructuras: selectivas, secuenciales (condicionales) y repetitivas.

5.2. PROGRAMACIÓN MODULAR:

Se basa en dividir el programa en partes llamadas módulos, que se analizan y codifican de forma independiente y que realizan una determinada tarea que será en realidad una parte del problema total a resolver.

En todo algoritmo o programa existirá un módulo o programa principal que es al que transfiere el control cuando comienza la ejecución del programa, y luego desde él, se va llamando al resto de los subprogramas.

Llamar a un subprograma quiere decir transferirle el control, es decir que se comienza a ejecutar y lo hará desde el comienzo del subprograma hasta que se termine y al terminar devuelve el control al subprograma que lo llamó. Dentro del subprograma a su vez también puedo llamar a otros pero en cualquier caso al final se devuelve el control al módulo que hace la llamada. El control al programa llamado se devuelve a la instrucción siguiente a la que se hizo la llamada.

Un módulo solo tiene acceso a los módulos a los que llama y a los submódulos a los que a su vez llaman éstos. Los resultados producidos por un módulo pueden ser utilizados por otros.

156

No existe un criterio fijo para determinar el tamaño, ni muy grandes ni muy pequeños, la idea fundamental es que realicen una única cosa y muy concreta.

Los módulos o subprogramas reciben diferentes nombres según el lenguaje de programación y según su tipo. Se llaman procedimientos y funciones (Pascal, C), subrutinas (basic, fortran), secciones (cobol),...

5.3. PROGRAMACIÓN ESTRUCTURADA:

La característica fundamental es que se va a basar en el uso únicamente de tres estructuras de control. Para ello se apoya en las siguientes filosofías:

1. Recursos abstractos: Son los recursos con los que no contamos a la hora de programar, pero en los que nos apoyamos a la hora de solucionarlos. Estos recursos se tienen que ir transformando en recursos concretos.

2. Diseño descendente (top down): Se trata de ir descomponiendo el problema en niveles o pasos cada vez más sencillos, tal que la salida de una etapa va a servir como entrada de la siguiente. En las primeras etapas tomamos el punto de vista externo, es decir, que entradas hay y que salidas hay, y a medida que vamos bajando de nivel, lo vamos viendo de modo interno (como lo hace por dentro).

3. Estructuras básicas de control: Para hacer cualquier programa siguiendo los anteriores pasos de razonamiento, al final codificamos el programa usando tres tipos de secuencias (repetitivas, alternativas y secuenciales).

Al final todo programa va a tener una única entrada y una única salida.

Desde la entrada tienen que existir caminos que nos permiten pasar por todas las partes del programa y llevarnos a la salida, y finalmente no se van a permitir los bucles infinitos.

5.4. ESTRUCTURA SECUENCIAL:

Es cuando una instrucción sigue a otra en secuencia, es decir, la salida de una instrucción es la entrada de la siguiente.

FLUJOGRAMA: DIAGRAMAS NS: PSEUDOCÓDIGO:

Leer num

Num num*2

157

Escribir num

5.5. ESTRUCTURAS SELECTIVAS:

Se evalúa la condición y en función del resultado se ejecuta un conjunto de instrucciones u otro. Hay tres tipos de selectivas (simple, doble o múltiple):

* Simple: Es la estructura : Sí <cond>

entonces <acciones>

fin sí

Evaluamos la condición y si es verdadera ejecutamos el conjunto de condiciones asociadas al entonces, y si es falso, no hacemos nada.

FLUJOGRAMA: DIAGRAMA NS:

<Cond1> Condición

SI NO

<acciones>

<acciones> <acciones>

* Doble: Se evalúa la condición y si es verdad se ejecutan el conjunto de acciones asociadas a la parte entonces, y si es falso se ejecutan el conjunto de acciones asociadas a la parte sino.

FLUJOGRAMA: DIAGRAMAS NS: PSEUDOCÓDIGO:

Si No

Cond Sí <cond>

158

Si Cond No Entonces <acciones>

Acc1 Acc2 Sino <acciones>

Acc1 Acc2 Fin si

Una condición se ejecuta una única vez.

* Alternativa múltiple: Se evalúa una condición o expresión que puede tomar n valores. Según el valor que la expresión tenga en cada momento se ejecutan las acciones correspondientes al valor. En realidad equivale a un conjunto de condiciones anidadas. En cualquier lenguaje, es Case o Swith.

PSEUDOCÓDIGO:

Según sea <expresión>

<Valor1>: <acción1>

<valor2>: <acción2>

.................................

[<otro>: <acciones>]

fin según

- Otro: Las acciones asociadas al valor otro se ejecutan cuando la expresión no toma ninguno de los valores que aparecen antes. Otherwise, Else.

El valor con el que se compara la expresión, va a depender de los lenguajes, de lo que sea ese valor. En general ese valor puede ser un valor constante, un rango de valores o incluso otra condición

FLUJOGRAMA: DIGRAMAS NS:

Expr Expresión

V1 V2 V3 V4 ... Otro

159

V1 V2 V3 V4 V5 V6

Hacer un programa que pueda dibujar una recta, un punto o un rectángulo.

Algoritmo dibujo

Var op: carácter

Escribir (“Introduce una opción”

1. Punto

2. Recta

3. Rectángulo”)

Leer op

Según sea op

“1”: leer x

.........

“2”: leer x

..........

“3”: leer x

..........

“otro”: escribir “opción errónea”

fin según

Para un rango de valores:

Leer una nota y escribir en pantalla la calificación:

160

Var nota: entero

Leer nota

Según sea nota

1..4: escribir “suspenso”

5..6: escribir “aprobado”

7..8: escribir “Notable”

9: escribir “Sobresaliente”

10: escribir “Matricula de honor”

fin según

En algunos lenguajes se permite poner una condición:

Según sea nota

Nota >=1 y nota <=4: escribir “suspenso”

En pseudocódigo no se pueden poner condiciones.

5.6. ESTRUCTURAS REPETITIVAS:

En aquella que contiene un bucle (conjunto de instrucciones que se repiten un número finito de veces). Cada repetición del bucle se llama iteración. Todo bucle tiene que llevar asociada una condición, que es la que va a determinar cuando se repite el bucle.

Hay cuatro tipos de bucles, aunque solo se pueden usar tres:

1. Mientras hacer While do

2. Repetir hasta repeat until

3. Desde for

4. Iterar loop : No se usa.

Mientras hacer:

Sintaxis:

161

PSEUDOCÓDIGO: FLUJOGRAMA: DIAGRAMAS NS:

Mientras <cond> hacer No

<acciones> Cond mientras cond

fin mientras Si

<acc1>

acciones

Funcionamiento:

La condición del bucle se evalúa al principio, antes de entrar en él. Si la condición es verdadera, comenzamos a ejecutar las acciones del bucle y después de la ultima volvemos a preguntar pro la condición. En el momento en el que la condición sea falsa nos salimos del bucle y ejecutamos la siguiente condición al bucle.

Al evaluarse la condición antes de entrar en el bucle al principio, si la condición al ser evaluada la primera vez es falsa, no entraremos nunca en el bucle, el bucle puede que se ejecute 0 veces, por tanto usaremos obligatoriamente este tipo de bucle en el caso de que exista la posibilidad de que el bucle pueda ejecutarse 0 veces.

Repetir hasta:

Sintaxis:

FLUJOGRAMA: DIAGRAMAS NS: FLUJOGRAMA:

acciones Repetir

<acc> <acciones>

hasta <condición>

No Si Repetir <cond> hasta

Cond

162

Función:

Se repite el bucle hasta que la condición sea verdadera. Se repite mientras la condición sea falsa. La condición se evalúa siempre al final del bucle, si es falsa volvemos a ejecutar las acciones, si es verdad se sale del bucle.

Como la condición se evalúa al final, incluso aunque la primera vez ya sea verdadera, habremos pasado al menos una vez por el bucle.

Es decir que cuando un bucle se tenga que ejecutar como mínimo una vez, podremos usar una estructura repetir o mientras, la única diferencia que habrá entre las dos, es que para hacer lo mismo, las condiciones tienen que ser contrarias.

Leer 3 números y dar su suma:

Cont 0 Cont 0

Suma 0 suma 0

Mientras cont <> 3 repetir

Suma suma + num leer num

Leer num suma suma + num

Cont cont + 1 cont cont + 1

Fin mientras hasta cont = 3

Desde:

Este tipo de bucles se utiliza cuando se sabe ya antes de ejecutar el bucle el número exacto de veces que hay que ejecutarlo. Para ello el bucle llevara asociado una variable que denominamos variable índice, a la que le asignamos un valor inicial y determinamos cual va a ser su valor final y además se va a incrementar o decrementar en cada iteración de bucle en un valor constante, pero esto se va a hacer de manera automática, el programador no se tiene que ocupar de incrementar o decrementar esta variable en cada iteración, sino que va a ser una operación implícita (lo hace por defecto).

Por tanto en cada iteración del bucle, la variable índice se actualiza automáticamente y cuando alcanza el valor que hemos puesto como final se termina la ejecución del bucle.

Sintaxis:

PSEUDOCÓDIGO:

Desde <var índice>=<valor inicial> hasta <valor final>

163

<acciones>

fin desde

FLUJOGRAMAS: DIAGRAMAS NS:

V Vi

Desde v=vi hasta v1

V <> V1 <sentencias>

sentencias

v v + 1

Bucle con salida interna: loop iterar.

Permite la salida del bucle desde un punto intermedio del mismo siempre que se cumpla la condicion que aparece, entonces nos salimos a la siguiente instrucción del bucle.

Iterar

<sent1>

salir si <cond> NUNCA SE USA

<sent2>

fin iterar

164

5.7. ESTRUCTURAS ANIDADAS:

Tanto las estructuras selectivas como los bucles se pueden anidar unos dentro de otros.

Anidación de condicionales:

La ventaja de anidar sentencias condicionales, es que cuando una se cumple no hay por que mirar a las que estan debajo. Tenemos que tratar anidar la condicion en la parte sino (else) en vez que en la parte entonces.

Si <condicion1>

Entonces <sentencia1>

Sino si <condicion2>

Entonces <sentencia2>

Sino si <condicion2>

Entonces <sentencia3>

Fin si

Fin si

Fin si

El case siempre equivale a una anidación de condicionales, pero no al reves.

Bucles anidados:

Al igual que podemos colocar unas expresiones dentro de otras, unos bucles pueden estar dentro de otros, pero nunca pueden cruzarse. Al anidar bucles hay que tener en cuenta que el bucle mas interno funciona como una sentencia mas del bloque mas externo y por tanto en cada iteración del bucle mas externo se van a ejecutar todas las iteraciones del bucle mas interno por cada iteración del mas externo.

165

Si el bucle mas externo se repite n veces y el mas interno se repite m veces, si por cada iteración del mas externo se repite el mas interno, el número total de iteraciones será m*n.

Los bucles que se anidan pueden se de igual o distinto tipo.

Desde i=1 hasta 8

Desde j=1 hasta 5

Escribir “Profesor”i”introduzca su asignatura nº”j

Leer asignatura

Fin desde

Fin desde

5.8. CONTROL DE DATOS DE ENTRADA:

1. Cuando existe un valor centinela que determina el fin del bucle:

El bucle se va a repetir mientras no se lea un determinado valor. La primera lectura se va a realizar fuera del bucle, y si la primera vez que lo leo ya encuentro ese valor centinela no podemos entrar en el bucle y seguirá a continuación, sino entramos en el bucle.

Se va utilizar una estructura Mientras.

2. Lectura secuencial de un fichero:

Tendremos que leer del primero al último registro del fichero. Habrá que usar un Mientras, aunque hay dos posibilidades: Leer fuera del bucle y al final de bucle, o leer dentro al principio del bucle. Se usa una u otra dependiendo del lenguaje.

3. Cuando en un bucle sabemos el número exacto de veces que se repite el bucle:

Usamos el Desde...Hasta.

4. Control de datos para no permitir datos erroneos:

No dejar seguir al usuario hasta que no introduzca datos correctos. Hay que usar un Repetir...Hasta.

Repetir Repetir

166

Leer datos leer op

Hasta (datos correctos) hasta (op>=1) y (op<=3)

1. ¿Cuáles y cuántos son los números primos comprendidos entre 1 y 1000?

Algoritmo n_primos

Const

Primero=1

Limite=1000

Var

cont, i, j: entero

primo: boolean

Inicio

Cont 0

Desde i= primero hasta limite

primo verdadero

j 2

mientras (i>j) y (primo =verdadero)

Si i mod j = 0

Entonces primo falso

Sino j j + 1

Fin si

Fin mientras

Si primo = verdadero

Entonces escribir i” “

Cont cont + 1

Fin si

Fin desde

Escribir “Entre “primero” y “limite” hay “cont” nº primos”

167

Fin

2. Calcular el máximo de números positivos introducidos por teclado, sabiendo que metemos números hasta que introduzcamos uno negativo. El negativo no cuenta.

Algoritmo maximo

Var

Num, max: entero

Inicio

Max 0

Escribir “Introduzca nº positivos y para acabar introduzca uno negativo”

Leer num

Mientras num >=0

Si num >max

Entonces max num

Fin si

Leer num

Fin mientras

Escribir “El mayor número es” max

Fin

3. Determinar cuales son los múltiplos de 5 comprendidos entre 1 y N.

Algoritmo multiplos

Var

i: entero

Inicio

168

Desde i=1 hasta n

Si i mod 5 =0

Entonces escribir i

Fin si

Fin desde

Fin

1. Al final de curso deseamos saber cual ha sido el alumno de primero con mejor nota media. Se sabe que este año entraron 150 alumnos y que en primero todos tienen 5 asignaturas. Dar el nombre y la nota media.

Algoritmo nota_media

Const

Alumnos=150

Asignaturas=5

Var

Nombre, mejor_alum: cadena

Nota, suma, media, acum: real

I, j: entero

Inicio

Acum 0

Desde i=1 hasta alumnos hacer

Suma 0

Escribir “Introduzca el nombre del alumno”

Leer nombre

Desde j=1 hasta asignaturas hacer

Escribir “Introduzca la nota de la asignatura”

Leer nota

169

Suma suma + nota

Fin desde

Media suma / asignaturas

Si media > acum

Entonces acum media

Mejor_alum nombre

Fin si

Fin desde

Escribir “El mejor alumno es “mejor_alum

Escribir “Su nota media es “acum

Fin

2. Calcular la suma de los divisores de cada número introducido por teclado. Terminaremos cuando el número sea negativo o 0.

Algoritmo divisores

Var

Numero, i, suma :entero

Inicio

Escribir “Introduce un número, y para acabar uno negativo”

Leer número

Mientras numero > 0

Suma 0

Desde i=1 hasta numero /2

Si numero mod i =0

Entonces suma suma + i

Fin si

Fin desde

170

Suma suma + numero

Escribir “La suma de los divisores del número es “suma

Leer numero

Fin mientras

Fin

3. Se coloca un cápital C, a un interes I, durante M años y se desea saber en cuanto se habrá convertido ese capital en m años, sabiendo que es acumulativo.

Algoritmo interes

Var

I, j, m: entero

C, temporal: real

Inicio

repetir

Escribir “Introduce el capital, el interes y el tiempo”

Leer c, i, m

Hasta (c>0) y ((i<=0)y(i<=100)) y (m >=0)

Desde j=1 hasta m

C c * (1+I/100)

Fin desde

Escribir “Tienes “c” pts”

Fin

4. Dada una fecha en formato dia/mes/año determinar el número de días y el nombre del mes de dicha fecha, y sacar por pantalla la fecha convertida a formato de dia “de” mes “de” año.

Algoritmo fecha

Var

171

Dia, mes, año, n_dias: entero

N_mes: cadena

Inicio

Repetir

Escribir “Introduce la fecha en formato dia mes año”

Leer dia, mes, año

Según sea mes

1,01: n_mes “enero”

n_dias 31

2,02: n_mes “febrero”

si año mod 4=0

entonces n_dias 29

entonces n_dias 28

3,03: n_mes “marzo”

n_dias 31

4,04: n_mes “abril”

n_dias 30

5,05: n_mes “mayo”

n_dias 31

6,06: n_mes “junio”

n_dias 30

7,07: n_mes “julio”

n_dias 31

8,08: n_mes “agosto”

n_dias 31

9,09: n_mes “septiembre”

n_dias 30

172

10: n_mes “octubre”

n_dias 31

11: n_mes “noviembre”

n_dias 30

12: n_mes “diciembre”

n_dias 31

fin según sea

hasta (dia <=n_dias) y ((mes >=1)y(mes <=12)) y (año >=0)

escribir “El mes de “n_mes”tiene “n_dias” dias”

escribir “La fecha es: “n_dias” de “n_mes” de “año

fin

5. Dada la siguiente fórmula:

Averiguar el valor de x pidiendo al usuario los valores de n, a, b.

Algoritmo ecuacion

Var

N, a, b, primer, según, i, j: entero

X: real

Inicio

Primer 0

Según 1

Repetir

Escribir “Introduce el valor de n, a, b”

Leer n, a, b

Hasta n>=0

173

Desde i=1 hasta n

Primer (((a-b)^i –3)+n)+primer

Fin desde

Desde j=2 hasta n-1

Según ((2*a*(i-1))*según)

Fin desde

X primer / según

Escribir x

Fin

6. Dada la siguiente serie matemática:

a1=0

a2=0

an=an-1 + (2*an-2) para n>=3

Determinar cual es el valor y el rango del primer término cuyo valor sea mayor o igual a 2000.

Algoritmo serie

Var

A1, a2, an, cont: entero

Inicio

A1 1

A2 0

An a1 + (2*a2)

N 3

Mientras an < 2000

A2 a1

174

A1 an

An a1 + (2*a2)

Cont cont + 1

Fin mientras

Escribir “El rango es “cont” y el resultado es”an

fin

6 Algoritmos secuenciales:

1. Diseñe un algoritmo que calcule el área de un triángulo en función de las longitudes de sus lados.

2. Elaborar un algoritmo que permita calcular el volumen de un cilindro (radio y altura se ingresan desde el teclado).

3. Haga un algoritmo que calcule

a. Área de un circulo => Área = r 2

b. Área de un triángulo => Área =(b*h) / 2

4. Diseñar un algoritmo a través del cual se pueda calcular la siguiente expresión algebraica :

5.

6. Diseñe un algoritmo para la conversión una medida de metros a pies y pulgadas.

7. Elabore un algoritmo que convierta una temperatura dada en centígrados a fahrenheit.

8. Dado un carácter alfabético en mayúsculas, elabore un algoritmo que imprima en pantalla su equivalente en minúscula (consulte el código ASCII).

9. Hacer un algoritmo para calcular el IVA de un valor digitado por el teclado, mostrar este resultado y el de sumar el IVA al valor digitado.

175

10. Ejemplo: valor digitado => 1000 Mostrar en pantalla IVA = 150 y valor mas IVA = 1150

11. Elabore un algoritmo para mostrar la cantidad de miles, centenas, decenas y unidades de un número entero digitado por teclado.

12. Ejemplo: Sea 1483 el número digitado el algoritmo debe mostrar en pantalla

13. Miles = 1 Centenas = 4 Decenas = 8 Unidades = 3

14. Las funciones trigonométricas en lenguaje C calculan sus valores para ángulos dados en unidades de radianes, haga un algoritmo que pase ángulos de grados a radianes, y calcule la tangente del ángulo convertido a radianes usando las funciones seno y coseno del C.

15. 1 Radian = ; = 3.141516

16. Haga un algoritmo que convierta una medida de longitud en kilómetros a metros, centímetros, milímetros, pulgadas, yardas, millas y pies.

17. Elabore un algoritmo que convierta una medida de masa en toneladas a kilogramos, quintales, gramos, libras.

18. Elabore un algoritmo que convierta una unidad de presión en pascales a bares.

19. Haga un algoritmo que calcule el área de una cara de un cubo y su volumen.

20. Elabore un algoritmo que convierta una unidad de volumen en metros cúbicos m3 a litros y centímetros cúbicos.

21. Lea dos puntos (x, y) y calcule la distancia entre ellos.

22. Los siguientes son los múltiplos y submúltiplos decimales (ver tabla), elabore un algoritmo que lea un número dado en unidades y lo muestre en cada uno de sus múltiplos y submúltiplos por pantalla.

a. Símbolo Unidades

tera T 1.000.000.000.000

giga G 1.000.000.000

mega M 1.000.000

kilo K 1.000

hecto H 100

deca Da 10

deci D 0.1

176

centi C 0.01

mili M 0.001

micro 0.000.001

nano N 0.000.000.001

pico P 0.000.000.000.001

23. Elabore un algoritmo que convierta una medición de tiempo en segundos a horas, minutos y segundos.

1 hora = 60 minutos 1 minuto = 60 segundos

Ejemplo: sea 34505 la cantidad digitada en segundos se debe mostrar en pantalla

Horas = 9 Minutos = 35 Segundos = 5

7 Algoritmos condicionales:

1. Lea de un mismo registro el nombre y la edad de cualquier persona e imprima, sólo si la persona es mayor de edad, el nombre de la persona.

2. Lea de un mismo registro el nombre y la edad de cualquier persona e imprima sólo si la persona es mayor de edad, el nombre de la persona, de lo contrario, imprima un mensaje que diga "no puede votar".

3. Lea de un mismo registro el nombre, la edad y el sexo de cualquier persona e imprima, sólo si la persona desde sexo masculino y mayor de edad, el nombre de la persona.

Nota: suponga que el registro que se le tiene grabado, en el campo denominado "sexo" el número 1 en vez de la palabra "masculino" o el número 2 en vez de la palabra "femenino".

4. Lea de un mismo registro el nombre, la edad, el sexo (1 o 2) y el estado civil de cualquier persona e imprima sólo si la persona es un hombre soltero mayor de edad, el nombre de la persona.

177

Nota: en el campo de "estado civil" aparece grabado el número 1 en vez de "soltero", el número 2 en vez de "casado" o el número 3 en vez de "otro".

5. Lea de un registro el nombre, la edad, el sexo y el estado civil de cualquier persona e imprima, sólo si la persona es hombre o mujer menor de edad o es hombre casado de cualquier edad, en nombre de la persona y un mensaje que diga "usted no se manda". En los demás casos imprima el nombre de la persona solamente.

6. Lea un número e imprima el número y el valor absoluto del mismo.

7. Lea un número y calcule e imprima su raíz cuadrada. Si el número es negativo imprima el número y un mensaje que diga "tiene raíz imaginaria".

8. Lea dos número de un mismo registro e imprima sólo los positivos.

9. Lea dos números de un mismo registro e imprima ambos números sólo si son positivos.

10. Lea dos números de un mismo registro e imprima ambos números si por lo menos uno de ellos es positivo.

11. Lea dos números de un mismo registro e imprima ambos números sólo si son deferente signo y distintos de cero.

12. Lea dos números de un mismo registro. Calcule la suma e imprima los números leídos y la suma.

13. Lea dos números de un mismo registro. Calcule la suma de los números. Imprima los números leídos y sólo si su suma es negativa imprima la también.

14. Lea dos números de un mismo registro y calcule el consciente de dividir el primero por el segundo. Imprima el cociente. Si el segundo número es cero no ejecute el cálculo e imprima mensaje que diga: "la división no es posible".

15. Leer de un mismo registro el nombre de un empleado, su salario básico por hora y el número de horas trabajadas en el mes. Calcular su salario mensual e imprima tanto el nombre como su salario mensual.

16. Leer un número y calcular el 5% del número leído. Obtener tanto el número como el porcentaje calculado.

17. Leer de un registro el nombre de un empleado, su salario básico por hora, el número de horas trabajadas en el período y el porcentaje de retención en la fuente. Calcular el salario bruto, el valor de la retención y el salario neto e imprimir el nombre del empleado, su salario bruto, el valor de la retención y el salario neto.

18. Para un salario bruto hasta de $1500, no hay retención. Para un salario bruto de $1500 a $3000 el porcentaje retención desde 5%. Para un salario bruto mayor de $3000 el porcentaje

178

de retención es de 8%. Obtener el nombre del empleado, el salario bruto, el valor de la retención y el salario neto. Su debe leer el nombre y el salario.

19. Leer de un registro el nombre de un empleado, el salario básico por hora y el número de horas trabajadas durante una semana. Calcular el salario neto, teniendo en cuenta que si el número es trabajadas durante la semana es mayor de 48, esas horas demás se consideran horas extras y tienen un 35% de su encargo de. Imprima el nombre del empleado y el salario neto.

20. Elabore un algoritmo que lea tres valores diferentes y determine el mayor, el menor y el promedio.

21. Elabore un programa que valide mediante un mensaje si una pareja (x, y) pertenece o no a la siguiente función: y = 3x - 4.

Ejemplo: la pareja (2,2) si pertenece a esta función.

22. Diseñe un algoritmo que determine e imprima la hora correspondiente al segundo después de una hora digitada por el usuario ( hh, mm, ss ).

23. La siguiente ecuación corresponde a la ecuación general de segundo grado en la incógnita X o ecuación cuadrática

aX2 + bX + c = 0 con a,b y c constantes

La formula general para hallar su solución es:

Elabore un algoritmo para hallar las soluciones reales. Tenga en cuenta que:

X1 y X2 se pueden calcular sólo si:

B2-4.A.C >= 0 A<>0

24. Escribir un algoritmo que permita determinar cuál es el ganador de la matricula de honor de entre 4 estudiantes . El algoritmo deberá hallar la nota definitiva de c/u de ellos (4 materias.) Si es mayor que 4.5 el alumno podrá aspirar a la matricula de honor, de lo contrario no.

25. Diseñe un algoritmo que determine si un año leído por el teclado es o no bisiesto.

26. Escribir un algoritmo para calcular la fecha del siguiente día a partir de una fecha digitada desde el teclado por el usuario ( dd, mm, aaaa ) e imprimirla. (tenga en cuenta los años bisiestos.)

27. Diseñar un algoritmo que permita descomponer un número ( 10 <= x <= 999 ) en sus dígitos e imprimirlos.

179

28. Elabore un algoritmo que descomponga un número entero (máximo de tres cifras) en sus dígitos y luego imprima cada uno de ellos en letras.

29. Diseñe un algoritmo que tome un valor entero positivo (máximo cuatro cifras), lo descomponga y lo imprima invertido pero como un único número entero.

Ejemplo: sea 3845 el número digitado se debe mostrar en pantalla el número 5483

Nota: para la prueba de escritorio escriba cualquier número de cifras decrecientes en uno como 8765, 6543, 3421, etc. y réstele su inverso y vera que siempre dará 3087

30. Escriba un algoritmo para la resolución de una ecuación de primer grado (ax + b = 0).

31. Diseñe un algoritmo que lea una fecha como un número entero de ocho dígitos (ddmmaaaa), y luego la imprima en letras (ejemplo: si se digita el número 02011999 entonces imprime "dos de enero de 1999.")

32. Lea dos números por teclado y determine si uno es divisor del otro.

33. Se lee un número de máximo tres dígitos (verifique que efectivamente sea de máximo tres dígitos) y se debe determinar si es un número capicúa, es decir, que leído de izquierda a derecha es igual que leído de derecha a izquierda. Por ejemplo: 727, 343, etc.

34. Usted debe realizar un algoritmo para un cajero automático, que dispone de billetes de todas las denominaciones existentes (2000, 5000, 10000, 20000), de forma que se le indique una cantidad a pagar y determine cual es la combinación apropiada de billetes para formarla. Las cantidades que no se puedan lograr con estos billetes deben aproximarse adecuadamente.

35. En un colegio se ha variado el sistema de calificaciones, por tanto se requiere un algoritmo que indique la valoración en letras cuando se tiene la nota en números, siguiendo la tabla mostrada a continuación

Nota Numérica Valoración en letras

0.0 – 5.9 E

6.0 – 6.9 D

7.0 – 7.9 C

8.0 – 8.9 B

9.0 – 10.0 A

180

36. Se digita un número entero en el rango de 1 al 999 y el algoritmo debe imprimir el número en letras. (ejemplo: 120 se imprime ciento veinte)

37. En una multinacional se cuenta con tres departamentos de ventas, en los cuales los empleados devengan el mismo salario, sin embargo se tiene un incentivo de acuerdo al cual, si un departamento vende más del 50% del total de ventas se da una bonificación del 20% del salario a los empleados. Considerando el total de ventas como la suma de las ventas de los tres departamentos, indique cuánto devengarán los empleados de cada uno de los tres departamentos este mes.

38. Realice un algoritmo que indique el valor de la función f(x) para un valor de x determinado por el usuario. La función ha sido definida de la siguiente forma:

39. En una organización se tiene a los empleados agrupados por categoría, los de categoría 1 ganan $20.000, los de categoría 2, $15.000, los de categoría 3, $10.000 y los de categoría 4, $7.500. Se quiere un algoritmo que permita determinar cuanto debe pagarse a un empleado si se conoce el número de horas que trabajó durante el mes y la categoría a la que pertenece. Se sabe que a todos se les descuenta un 7.2% por concepto de salud, y si el salario total devengado (mensual) es menos de 1´000.000, se le da un subsidio del 15% sobre su salario mensual (sin descuentos).

40. Se debe leer un número y determinar en que categoría se encuentra; se sabe que la categoría A, son los números entre 0 y 2 inclusive, la categoría B son los números entre 3 y 6 inclusive, la categoría C, los números 7 y 8, y la categoría D el número 9. (Adivinó, los números validos son entre 0 y 9).

41. Se quiere determinar el valor de depreciación de un artículo en una empresa, se sabe que el valor de depreciación anual se determina dividiendo el valor de compra del mismo, entre el número de años de vida útil; la vida útil se determina de acuerdo a la clase de artículo, los edificios tienen 20 años, la maquinaria, muebles y enseres, 10 años, los vehículos 5 años y los computadores 3.

42. En un concesionario de vehículos, se pagan las comisiones a los vendedores según el valor de la venta (ver tabla). Al final del mes se desea saber ¿Cuánto ganó un vendedor en total por todas las comisiones, si se sabe que hizo 4 ventas?

Valor de Venta Comisión para el Vendedor

Hasta 10.000.000 2%

Más de 10 y Menos de 15 millones 4%

Mas de 15 millones 10%

43. En una empresa comercializadora, cada vendedor debe realizar 5 ventas al mes, por cada venta ganará una comisión de acuerdo a la tabla de comisiones. Cada vendedor tiene un salario básico (que usted debe leer) y de acuerdo a la suma del básico y las comisiones, se le genera un descuento para salud, pensiones y otros como señala la tabla de descuentos. Usted debe imprimir el código del vendedor, el total de sus ventas, el total ganado por comisiones, el

181

total devengado (básico + comisiones), el total de descuentos, y el salario a pagar por cada empleado.

Valor Venta Comisión Devengado (salario+comisiones) Descuentos

0-1.000.000 5% 0-500.000 5%

1.000.001-1.500.000 7% 500.001-1.000.000 6%

1.500.01 más 10% 1.00.01 más 8%

44. El teniente encargado del planetario desea que se diseñe un algoritmo para que al digitar el nombre del día indique el astro que dio origen a ese nombre. Recuerde los astros:

Nombre del día Astro

Domingo Sol

Sábado Saturno

Viernes Venus

Jueves Júpiter

Miércoles Mercurio

Martes Marte

Lunes Luna

45. Realice el algoritmo para que calcule si un triángulo es isósceles, equilátero o escaleno dados sus tres lados A, B y C

Isósceles => dos lados iguales

Escaleno => A > B > C

Equilátero => A = B = C

46. Haga un algoritmo que muestre en pantalla si un ángulo es: recto, obtuso o agudo

Recto = 90 grados

Agudo < 90 grados

Obtuso > 90 grados

Con relación a sus ángulos un triángulo puede ser:

Rectángulo => Un ángulo recto

Acutángulo => 3 ángulos agudos

182

Obtusángulo => 1 ángulo obtuso

47. Elabore un algoritmo que calcule si un triángulo es rectángulo, acutángulo u obtusángulo.

48. Elabore un algoritmo que seleccione personal para un empleo con las siguientes características: mujeres adultas, solteras y que practiquen algún deporte.

49. Para el cálculo con interés compuesto se utilizan las siguientes fórmulas:

Hallar una cuota mensual conociendo el interés efectivo mensual (i), número de meses (n), y el precio del articulo

Cuota = Precio x

50. Hallar el precio de un articulo conociendo el valor de la cuota mensual, el interés efectivo mensual (i), y el número de meses (n)

Precio = Cuota x

51. Hallar el valor futuro de una precio actual conociendo el interés efectivo mensual (i), y el número de meses (n)

Valor Futuro = Precio x (1 + i)n

52. Elabore un algoritmo que permita de un menú de opciones calcular el valor deseado. (cuota, precio o valor futuro)

Nota: si i = 30% se debe usar i como: i = = 0.3

53. Elabore un algoritmo que muestre el dígito que más se repite en un número de 5 cifras, en caso de no repetirse ninguno imprimir un mensaje que diga "no hay dígitos repetidos".

54. El recargo por trabajar horas nocturnas en una empresa es del 70%, el recargo por trabajar festivos es del 100%, haga un algoritmo que lea los días laboradas por un empleado, las horas nocturnas el valor de la hora normal laborada y calcule e imprima el sueldo a pagar junto con el nombre del empleado.

55. Elabore un algoritmo que tenga cuatro niveles de seguridad para un programa, si el usuario logra ingresar imprimir el mensaje "Bienvenido", en caso contrario imprimir "Error clave" y el nivel del error.

56. Realice un algoritmo que lea cuatro números y los muestre ordenados de mayor a menor. Ejemplo: sean los números 5, 3, 7 y 9, debe mostrar 9, 7, 5 y 3.

183

57. En un club deportivo se cancela la matricula según sea la categoría del deportista, elabore un algoritmo que calcule el valor de la matricula si los precios por categoría son:

Infantil 5-8 años = $38.000

Juvenil 9-17 años = $40.100

Adultos mayores a 18 años = $45.800

Se debe hacer un recargo a la matricula del 10% para la liga. Los niños menores a 5 años no pueden ser matriculados

58. A los profesores de cierta universidad se les paga por horas cátedra dictadas de 50 minutos, elabore un algoritmo que lea el número de horas dictadas en un semestre siendo estas horas de 60 minutos y calcule el pago del semestre para el profesor teniendo en cuenta que a los profesores se les cancela según su categoría:

A= $12.400 B =$11.200 C= $10.000 D= $ 8.500

Al final al profesor se le resta el 10% de retención en la fuente. El pago debe tomar en cuenta las fracciones de hora.

8 algoritmos repetitivos (ciclos):

1. Escriba un algoritmo que muestre el cuadrado de los números del 1 a N.

2. Diseñar un algoritmo para determinar la cantidad de mujeres y de hombres que hay en un grupo de N estudiantes (máximo 45). Además se debe hallar el promedio de edad y de estatura del grupo. (el usuario digitará para cada integrante del grupo, su sexo, edad y estatura).

3. Desarrolle un algoritmo que permita seleccionar personal para un empleo de un total de N aspirantes. Los aspirantes deben cumplir las siguientes condiciones para ser aceptados:

Mayores de edad

Ser ingeniero titulado

Tener experiencia laboral

Al final el algoritmo debe mostrar el total de aspirantes aceptados.

4. Diseñe un algoritmo que calcule e imprima la suma de los números pares e impares comprendidos entre 1 y N. (1)

5. Leer N números y calcular el mayor sin importar que se repita.

184

6. Leer una serie de M números y mostrar al final cuantos son positivos.

7. Calcular la suma de los cuadrados de los números comprendidos entre 1 y N.

8. Elaborar un algoritmo que convierta un número entero positivo, menor a 257 a sistema binario

Se deben leer números hasta que se digite 99 (el 99 no se debe contar), y determinar cuantos primos hay, y cuantos pares. (recuerde que estas dos condiciones no son exclusivas).

9. Elabore un algoritmo que lea cinco notas de (n) números de estudiantes, y que calcule e imprima el promedio de cada alumno y el promedio del grupo además de la nota del estudiante de mayor y menor promedio. (2)

10. Realice un algoritmo que calcule la suma de (n) números, el producto de estos y cuantos de estos son negativos y cuantos positivos. Estos datos deben ser mostrados por pantalla. (3)

11. Haga un algoritmo que lea las notas de (n) estudiantes, que indique el número de estudiantes que ganaron la materia (mayor o igual a 3.0), el numero de los que la perdieron (menor o igual a 3), además de indicar cuantos deben habilitar la materia (notas entre 2.5 y menores a 3.0) (4)

12. Elabore un algoritmo para calcular de (n) números leídos cuantos son primos.

13. Desarrolle algoritmos que impriman la suma de los términos de las siguientes series:

Suma = -1 +2 -3 +4 -5, ... hasta N términos.

Suma =+1 +4 -8 +12 +16 -20 +24 +28, -... hasta N términos.

(no son exactamente n términos)

(no son exactamente n términos)

14. Determine el valor del combinatorio C(m,n), definido como

15. Implemente un algoritmo que lea un número entero y lo muestre invertido.

185

16. En un curso hay 20 alumnos, cada alumno tiene diferente número de notas, se quiere determinar el promedio de cada estudiante, y el número de estudiantes que perdieron la materia (menos de 3.0). NOTA: La nota definitiva de un estudiante corresponde al promedio simple de sus notas. (5)

17. Un número es perfecto si la suma de sus divisores excepto él mismo es igual al propio número. Ejemplos:

Número: 6 28 36

Divisores---> 1 1 1

2 2 2

3 4 3

7 4

a. 14 6

b. c. 9

d. e. 12

f. g. 18

Suma 6 28 55

18. Elabore un algoritmo que lea las ventas de (n) número de vendedores, para los productos (A, B, C, D y C), si los precios de los productos son ($1000, $2345, $3876, $1235 y $550) respectivamente, calcule el número individual y total de productos vendidos, las ventas totales por producto, el promedio total de ventas, el producto mas vendido, el menos vendido, el vendedor que más ventas realizó.

19. Realice un algoritmo que calcule la suma de (n) números, el producto de estos y cuantos de estos son negativos y cuantos positivos. Estos datos deben ser mostrados por pantalla.

20. Haga un algoritmo que lea las notas de (n) estudiantes, que indique el número de estudiantes que ganaron la materia (mayor o igual a 3.0), el numero de los que la perdieron (menor o igual a 3), además de indicar cuantos deben habilitar la materia (notas entre 2.5 y menores a 3.0). Todos los datos deben ser mostrados por pantalla.

21. Realice un algoritmo que lea (n) números y halle el mayor número par, el mayor impar, y el producto de estos dos números. Estos datos deben ser mostrados por pantalla.

22. Haga un algoritmo que lea un número entero de 4 cifras (base 10) y que lo convierta a un binario (base 2) y un octal (base 8). Utilice instrucciones repetitivas (use el operador residuo).

186

23. Un profesor necesita calcular las notas finales de su curso, para ello dispone de 7 notas, las 3 primeras componen la nota definitiva de quices y talleres con un valor de 25%, la 4 nota corresponde al primer examen parcial con un 25%, la 5 al segundo examen parcial con un 25%, las dos ultimas (6 examen escrito y 7 trabajo opcional) al examen final con un valor de 25%. (6)

24. El profesor desea obtener los siguientes resultados para cada estudiante: La nota definitiva de quices y talleres (promedio de las 3 primeras notas). La nota definitiva del examen final (en el caso de haber presentado opcional). La nota final del estudiante. Estos datos deben ser mostrados en pantalla junto con las demás notas.

Desea conocer también cuantos aprobaron el curso (notas superiores a 3.0) y cuantos no cumplieron con los objetivos de este (notas menores a 3.0) y también obtener la mejor nota para promover este estudiante como monitor de la materia para el próximo semestre. (estos últimos datos se deben mostrar por pantalla al final del calculo de las notas finales de todo el curso).

25. Elabore un algoritmo que imprima cual es el vendedor del mes de una empresa.

26. Tabla de Precios

Producto Precio

A $1750

B $3500

C $7000

Para lograr el cálculo se leen las cantidades de productos vendidos por cada uno de los M vendedores de la empresa y siguiendo la tabla de precios se determina el mejor como aquel que mayores ventas haya tenido.

27. Use la siguiente fórmula para calcular la raíz cuadrada de un número entero positivo:

Raíz = 0.5*

Donde N es el número del que se desea conocer la raíz y X1 es una variable que se le asigna un valor inicial de 1.

Con estos dos valores iniciales se obtiene el primer valor de la variable Raíz. Si el valor absoluto de |Raíz - X1| es mayor a 0.0000001 se le reasignará a X1 el contenido de la variable Raíz y se hará un nuevo calculo hasta que el valor absoluto sea menor, que es cuando se obtiene el valor real de la raíz.

28. Escriba un programa que calcule el resultado de la siguiente serie para N términos.

187

29. Algunos pueblos de Rusia emplean el siguiente método para multiplicar: escriben los dos factores uno al lado del otro y se forman con ellos dos columnas: debajo del factor que está a la izquierda se toma la mitad en números enteros, es decir despreciando fracciones, y de esta mitad se toma la mitad, y así sucesivamente hasta llegar a 1; debajo del factor que está a la derecha, y paralelamente, se escribe su duplo, y así sucesivamente hasta emparejar con el ultimo número de la columna de la izquierda, como puede verse en el ejemplo, se tachan de la columna de la derecha todos los números colocados enfrente de los número pares de la otra columna y se suman todos los números no tachados de esta columna; esta suma será el resultado de la multiplicación.

Elabore un algoritmo que emplee este método para multiplicar dos números.

Ejemplo: Multiplicar 22 x 6 = 132

22 X 6

11 12

5 24

2 48

1 96

132

30. Imprimir cuatro columnas. En la primera columnas, los números del 1 al 50. En las otras columnas, la segunda, la tercera y la cuarta potencia de los entero de la primera columna.

31. Encuentre la calificación promedio para un gran número, aunque desconocido, de calificación de exámenes. Estas vienen grabadas en registros. La calificación más alta posible es 10.

32. Leer una serie de pares de números y obtener de cada par el número mayor. Imprima un mensaje especial si los números son de igual valor.

33. Leer una serie de grupos de 3 números y obtener el número mayor y el menor de cada terna.

188

34. El dané esta interesado en saber el número de personas mayores de 18 años, tanto hombres como mujeres en la ciudad de Medellín. Calcule e imprima el resultado de esta investigación se deben leer registros que contienen cada uno el sexo y el número de años. La cantidad de personas es desconocido, pero se sabe que la ultima cedula digitada es cero (esto como control de salida del ciclo).

35. un vendedor desea calcular su comisión total sobre la venta de varios artículos. Al vendedor le corresponde el 5% de comisión sobre artículos cuyo precio es menor de $100.000 y el 7.5% de comisión sobre aquello artículos cuyo precio es de 100.000 o más suponga que el vendedor hizo N ventas

36. Se tiene un archivo con los datos de los estudiantes de un universidad, así: código del estudiante, nombre del estudiante, valor crédito del estudiante, número de créditos tomados, valor del recargo en la matrícula

Se requiere de los registros imprimir un estado con la siguiente información por estudiante:

Código, nombre del estudiante, valor crédito, nombre de créditos, valor del recargo y valor total pagado estudiante (valor crédito por número de créditos más valor del recargo), también se debe calcular que imprimieron al final del listado el total pagado por todos los estudiantes y el promedio por estudiante.

37. Se tiene un archivo de los empleados de una compañía, cada registro contiene los siguientes datos: número del empleado, nombre del empleado, salario básico hora, horas trabajadas en el mes, deducciones.

Se requiere leer los registros que imprimir un listado con la siguiente información por empleado:

Número del empleado, nombre del empleado, salario básico hora, horas trabajadas, deducciones, salario mensual (salario básico hora por número de horas trabajadas menos deducciones)

También se debe calcular el imprimir al final del listado el total de salarios pagados a todos los empleados y el promedio salarial por empleado. El ultimo registro a ingresar es un numero de empleado igual a 11111 (Este no se tiene en cuenta ya que es un registro centinela o punto de parada

189

38. Se requiere calcular imprimir la información necesaria para una nómina. Los datos de entrada se encuentran en un archivo donde cada registro contiene: nombre del empleado, número del empleado, rata por hora, horas trabajadas y número de exención

Del listado de salida de demostrar: nombre del empleado, número horas trabajadas, salario bruto, salario neto, FICA retenido e impuestos retenidos. Los cálculos para las deducciones se hacen de la siguiente forma:

Salario bruto = rata horaria (1.5 *(horas -40) +40)

FICA= 5.2% del salario bruto.

Impuestos 15% de (salario bruto-$13*numero de exención)

Salario Neto = Salario bruto – impuestos – FICA.

39. Leer un registro de los números enteros positivos (M y N). Calcular el imprimir la suma de los múltiplos de M. comprendidos entre M. y N.

40. Se tiene un archivo donde cada uno de los registros contiene los siguientes campos:

Código del articulo, Valor unitario, Clase de articulo (1 articulo de importación y 2 suministro local), Unidades consumidas en junio, Unidades consumidas en julio, Unidades consumidas en agosto, Unidades consumidas en septiembre,

Calcular el promedio de las unidades consumidas en los cuatro meses

Calcular el consumo esperado de acuerdo a la siguiente formula

c.e= (1+a)*promedio de unidades consumidas, donde a es 0.10 para artículos de importación y 0.15 para artículos de consumo local

Calcule el valor de consumo esperado, el cual es el consumo esperado * valor unitario

190

41. El código y las calificaciones obtenidas por los estudiantes en una clase numerosa se graban en registros. Al final del periodo de estudios estas calificaciones, cuatro por cada estudiante se suman para saber el rendimiento total, contando doble la cuarta calificación puesto que ella corresponde al examen final del periodo que fue dos veces mas largo que los otros. Realizar un programa para mostrar las calificaciones definitivas de la clase y el promedio del grupo

42. Realice un algoritmo que imprima en pantalla el conjunto de los (n) múltiplos de un número entero (x) digitado por el usuario.

43. Haga un algoritmo que imprima en pantalla el conjunto de los divisores de un número entero (x) digitado por el usuario.

44. Elabore un algoritmo que calcule el mínimo común múltiplo (m.c.m) de dos números A y B, recuerde el m.c.m. como su nombre lo indica es el menor múltiplo común de dos o mas números. Ejemplo: sean los números 8 y 6.

m.c.m. (8, 6) = 24

45. Dos números son amigos, si cada uno de ellos es igual a la suma de los divisores del otro. Ejemplo: 220 y 284 son amigos por que,

284 220

1 1

2 2

4 4

71 5

142 10

11

20

22

44

55

110

191

220 284

Elabore un algoritmo que calcule si dos número son amigos o no.

46. Elabore un algoritmo que calcule el número de días que existen entre dos fechas. Tenga en cuenta que existen meses de 30 y 31 días y los años bisiestos.

47. Calcule e imprima las tablas de multiplicar del 1 al 9 usando el ciclo mientras().

48. Desarrolle un algoritmo que impriman las siguientes series:

1, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44.

1, 4, 9, 16, 25, 36, 49, 64, 81.

2, 4, 6, 8, 10, .....100.

-2, +4, -6, +10, ....100.

49. Obtenga los 100 primeros números naturales.

50. Obtener los números padres comprendidos entre 1 y 1000.

51. Leer de un registro un número entero positivo y obtener los múltiplos de 3 comprendidos entre uno y el número leído.

52. Lea los primeros 20 registro de un archivo, cada uno de los cuales tienen nombre imprima los nombre uno.

53. Leer varios registros cada uno de ellos, con teniendo un nombre. El número de estos registros se encuentra grabado en un registro que precede los anteriores, imprimir cada uno de los nombres leídos.

54. Leer un conjunto de registros cada uno de ellos con teniendo el código y el nombre de cada uno los estudiantes del universidad. El último registro del conjunto (registro centinela) contiene el código 99999999 y es utilizado sólo para chequear el final de los registros. Imprima cada uno de los códigos y nombres leídos. Lógicamente la información del registro centinela no se imprime porque no pertenece a ningún estudiante.

55. Imprimir cuatro columnas. En la primera columnas, los números del 1 al 50. En las otras columnas, la segunda, la tercera y la cuarta potencia de los entero de la primera columna.

56. Calcule la suma de los 100 primeros número natural.

192

57. Obtener la suma de los números pares comprendidos entre uno y 100

58. Encuentre la calificación promedio para un gran número, aunque desconocido, de calificación de exámenes. Estas vienen grabadas en registros. La calificación más alta posible es 10.

59. Leer una serie números. Encontrar el valor absoluto (magnitud) de cada número, imprimir tanto los números como sus valores absolutos.

60. Leer una serie números. Obtener el cuadrado y el cubo de cada número de imprimir tanto los números como sus cuadrados y sus cubos.

61. Leer una serie de pares de números y obtener de cada par el número mayor. Imprima un mensaje especial si los números son de igual valor.

62. Leer una serie de grupos de 3 números y obtener el número mayor y el menor de cada terna. Escriba un mensaje especial si por lo menos dos de cada tres números son iguales.

63. Identifique y obtenga el número medio de un conjunto de tres números únicos. El número medio es aquel que no es el mayor ni el menor.

64. El dané esta interesado en saber el número de personas mayores de 18 años, tanto hombres como mujeres en la ciudad de Medellín. Calcule e imprima el resultado de esta investigación se deben leer registros que contienen cada uno el sexo y el número de años

65. Una tienda de libros y géneros diversos al menudeo ofrece un descuento de cortesía del 10% para profesores. Muestre como la computadora puede calcular que imprimir el 10% de 1, 1.1, 1. 2 etc. hasta $25

66. un vendedor desea calcular su comisión total sobre la venta de varios artículos. Al vendedor le corresponde el 5% de comisión sobre artículos cuyo precio es menor de $100.000 y el 7.5% de comisión sobre aquello artículos cuyo precio es de 100.000 o más suponga que el vendedor hizo N ventas

67. Coldeportes de Antioquia esté interesado en promover el básquetbol y para ello desea conocer personas que tengan las siguientes características: edad mínima 18 años, estatura mínima 180 cm. y peso máximo 80 kilos. Lea identificación, edad, estatura y peso de varios deportistas, verifique si cada uno de ellos cumplen las condiciones impuestas por si es así, imprima identificación edad estatura y peso.

68. Se tiene un archivo con los datos de los estudiantes de un universidad, así: código del estudiante, nombre del estudiante, valor crédito del estudiante, número de créditos tomados, valor del recargo en la matrícula

69. Se requiere de los registros imprimir un estado con la siguiente información por estudiante:

193

Código, nombre del estudiante, valor crédito, nombre de créditos, valor del recargo y valor total pagado estudiante (valor crédito por número de créditos más valor del recargo) en también se debe calcular que imprimieron al final del listado el total pagado por todos los estudiantes y el promedio por estudiante.

70. Se tiene un archivo de los empleados de una compañía, cada registro contiene los siguientes datos: número del empleado, nombre del empleado, salario básico hora, horas trabajadas en el mes, deducciones.

Se requiere leer los registros que imprimir un listado con la siguiente información por empleado:

Número del empleado, nombre del empleado, salario básico hora, horas trabajadas, deducciones, salario mensual (salario básico hora por número de horas trabajadas menos deducciones)

También se debe calcular el imprimir al final del listado el total de salarios pagados a todos los empleados y el promedio salarial por empleado.

71. Calcular el imprimir los salarios que se adeudan a los trabajadores, basados en tasas por hora y en tiempo trabajado, leyendo los datos de un archivo. Tome en cuenta pagos a 1 .5 veces la tasa regular, cuando las horas trabajadas excedan de 40 por semana.

72. Dado que un peso de mañana tiene menos valor que un peso de hoy (fenómeno económico que llamamos inflación) las empresas cuando calculan en los futuros ingresos transformados a otros pesos de hoy superan el monto de la inversión hecha

Formula general para él calculó del valor actual es:

VA= C / (1+i)N

Donde :C es la cantidad del ingreso.

i: Es la taza de inflación

N: son los años en consideración.

73. Calcular la cantidad a pagar de matrícula por cada estudiante de la siguiente forma:

194

El total a pagar es igual a los cargos fijos más los cargos variables. Los cargos fijos son un valor leído, y los cargos variables se calculan sumando el 10% del patrimonio y el 15% de la renta. Cada registro contiene: código del estudiante, patrimonio y renta. Se debe imprimir por estudiante: código, renta, patrimonio, cargo fijo, cargo variable y total matrícula.

74. Se requiere calcular imprimir la información necesaria para una nómina. Los datos de entrada se encuentran en un archivo donde cada registro contiene: nombre del empleado, número del empleado, rata por hora, horas trabajadas y número de exención

Del listado de salida de demostrar: nombre del empleado, número horas trabajadas, salario bruto, salario neto, FICA retenido e impuestos retenidos. Los cálculos para los deducciones se hacen de la siguiente forma:

Salario bruto = rata horaria (1.5 *(horas -40) +40)

FICA= 5.2% del salario bruto.

Impuestos 15% de (salario bruto-$13*numero de exención)

Salario Neto = Salario bruto – impuestos – FICA.

75. Leer un registro de los números enteros positivos (M y N). Calcular el imprimir la suma de los múltiplos de M. comprendidos entre M. y N.

76. leer varios registros cada uno de ellos, conteniendo un nombre, el número de estos se encuentra grabado en un registro que precede a los anteriores, imprimir cada uno de los nombres leídos.

Salario base hora

Producción minima dia

Producción dia

Calcular el pago por día para cada empleado. Se debe tener en cuenta al obrero que no cubre la producción mínima, en cuyo caso el jornal es equivalente al salario hora multiplicado por 8 horas de trabajo por día.

195

77. Calcule e imprima las tablas de multiplicar del 17 al 30. Se debe imprimir el multiplicando, el multiplicador y el producto.

78. El gerente de la empresa de transportes "Restringida" desea saber el valor del cheque que ha de elaborar cada semana por concepto de daños de vehículos. El taller "Arregla Todo" envía a la empresa las facturas cada una con la siguiente información: la placa del vehículo reparado, el tipo de daño y el costo del mismo. En la empresa proceden a crear un archivo.

El daño puede ser de tres tipos:

1 - el gerente paga solamente hasta $50O.

2 - el gerente paga solamente hasta $700.

3 - el gerente paga solamente hasta $800.

Si el valor del daño es mayor que el reconocido por la gerencia se tomará el máximo de la gerencia.

Calcule el monto del cheque que la gerencia pagará y el monto en el caso de que la gerencia no tenga en cuenta las restricciones

9 Algoritmos de arreglos unidimensionales (vectores):

1. Diseñe un algoritmo que lea un vector de N posiciones y luego calcule e imprima su suma.

2. Diseñe un algoritmo que lea un vector de N posiciones y calcule e imprima cuantos números pares y cuantos impares hay en él.

3. Diseñe un algoritmo que lea un vector de N posiciones y calcule e imprima cuantos números positivos y negativos hay en él, si existen ceros debe indicar su cantidad.

4. Elabore un algoritmo que lea un vector de N posiciones (enteras o reales) y luego lo copie en otro. Finalmente debe imprima el contenido de ambos vectores.

196

5. Elabore un algoritmo que lea un vector de N posiciones (enteras o reales) luego y lo copie en otro pero invirtiendo las posiciones. Al final se deben imprimir los contenido de ambos vectores.

6. Haga un algoritmo que genere los primeros 20 números primos y los almacene dentro de un vector. Al final debe imprimir el contenido del vector.

7. Diseñe un algoritmo que lea un vector de N posiciones y luego imprima cuantos números primos hay dentro del vector.

8. Diseñe un algoritmo que lea un vector de N posiciones enteras y lo ordene por cinco métodos diferentes.

9. Elabore un algoritmo que lea N notas y las almacene en un vector y luego calcule e imprima la nota mayor y la menor.

10. Haga un algoritmo que lea un vector de N posiciones y luego lea un número M y calcule e imprima cuantos veces se repite M dentro del vector.

11. Escriba un algoritmo para verificar si una palabra de 8 letras digitada por el usuario es palíndromo.

12. Diseñar un algoritmo que llene un vector con diez números digitados por el usuario desde el teclado, halle los múltiplos de siete y de dos. Imprima los números hallados y realice la sumatoria de los números.

13. Diseñe un algoritmo que llene un vector con 15 números aleatorios, determine el mayor y el menor. Verifique si hay en el arreglo un número que sea igual a la raíz cuadrada de la suma de los dos números ( mayor y menor ).

Para un grupo de 10 números enteros calcule y muestre:

El menor y su posición en el arreglo.(función menor).

El mayor y su posición en el arreglo.(función mayor).

El promedio. (función promedio)

14. Para un grupo de 20 caracteres haga:

Ordene los caracteres ascendentemente. (Vea tabla de códigos ASCII). (función ordena).

El algoritmo deberá mostrar el contenido de todas las posiciones del arreglo. (función imprima).

15. Se desea calcular la raíz cuadrada de un grupo de 30 números enteros positivos y el algoritmo deberá:

197

16. Mostrar la lista de todos los números con su correspondiente raíz pero ya calculada y almacenada en un arreglo. (función imprima).

Modificar alguno de los números al cual se le desea calcular la raíz y guardar el resultado correcto en el arreglo que corresponda. (función modifica).

17. Desarrolle un programa que permita calcular la nota definitiva de N estudiantes de un curso de informática I. Además debe mostrar el nombre del estudiante de mayor nota, la nota promedio del curso y cuantos aprobaron la materia.

Los porcentajes de las notas son los siguientes:

Primer parcial => 30%

Segundo parcial => 30%

Talleres y quices => 20%

Parcial final => 20%

La nota de talleres y quices se toma de promediar cuatro notas (2 talleres y 2 quices) que deben ser leídas por el programa.

18. Elabore un algoritmo para leer las notas de N estudiantes e imprimir por pantalla el promedio de estas y la nota mayor. Use un vector entero para leer las notas.

19. Haga un algoritmo que lea dos vectores A y B de un tamaño N y después por medio de una variable auxiliar intercambiar los contenidos de los dos vectores y luego los muestre por pantalla.

20. Leer un vector A de N elementos (todos diferentes) y un vector B de M elementos (pueden ser repetidos). Calcular cuantas veces se encuentra presente en B cada elemento de A.

21. Leer un vector de tamaño M, y luego invertirlo sobre el mismo. ( el que estaba de primero quedará de ultimo y viceversa).

10 Algoritmos de arreglos bidimensionales (matrices):

1. Diseñe un algoritmo que lea una matriz de NxM posiciones y luego calcule e imprima la suma de todos sus elementos (posiciones).

2. Implemente un algoritmo para llenar una matriz cuadrada de NxN posiciones con un valor X. El valor de N y de X se leen por teclado.

198

3. Elabore un algoritmo que lea una matriz cuadrada de NxN posiciones y luego imprima los elementos de su diagonal principal.

4. Diseñe un algoritmo que lea dos matrices A y B de NxM posiciones y luego calcule e imprima su suma.

5. Diseñe un algoritmo que lea dos matrices A, B y luego calcule e imprima su multiplicación si se puede.

6. Haga un algoritmo que lea una matriz de NxM posiciones y luego lea un número e imprima si este se encuentra dentro de la matriz.

7. Haga un algoritmo que lea una matriz de NxM posiciones y luego genere la transpuesta de esta matriz.

8. Elabore un algoritmo que lea una matriz cuadrada de NxN posiciones y luego imprima si es triangular superior o inferior.

9. Elabore un algoritmo que lea una matriz cuadrada de NxN posiciones y luego imprima si la matriz es igual a la matriz identidad.

10. Elabore un algoritmo que llene una matriz de 4x4 con datos digitados por el usuario desde el teclado y verifique si es una matriz simétrica. ( Aij = Aji )

11. Desarrolle un algoritmo que lea una serie de N números y los almacene en la primera columna de una matriz, en la siguiente columna debe almacenar el cuadrado de cada número, y en la tercera columna la raíz cuadrada. Al final se debe mostrar fila por fila los elementos de la matriz.

12. Se tiene la siguiente información sobre el inventario en un almacén:

Código producto Inv. Inicial Inv. Final Dados de baja Ventas Compras

Se desea saber a través de un algoritmo para 5 productos:

Permitir ver toda la información para los cinco productos.

Cual es el inventario final, el inicial , las compras, ventas y dados de baja para un código de producto que sea leído.

Permitir modificar cualquiera de los datos de la tabla a excepción del código del producto y el inventario final. Este último es calculado, luego nunca podrá ser leído o modificado y no podrán existir productos con un mismo código.

13. Diseñe un algoritmo que resuelva un sistema de n ecuaciones lineales usando matrices.

14. Suponga que tenemos tres tipos de productos. A cada uno de ellos se les aplicará un porcentaje de descuento sobre la venta, dependiendo de la cantidad vendida según la siguiente tabla:

199

Cantidades Vendidas

Tipo <=5 >5 y <=20 >20 Precio

Teclados (T) 0% 5% 8% 12000

Mouse (S) 1% 3% 5% 5500

Parlantes (P) 2% 8% 9% 9000

Cada venta puede tener solo un producto. Asuma que se registraron 10 ventas es un día.

Se desea saber para ese día :

¿Cuál fue el descuento total por cada venta?

¿Cuál fue el descuento total por producto?

¿Cuál fue el producto con mayor número de ventas?

¿Cuál fue el producto que dio mayor ingreso a la empresa?

Muestre el listado de todas las ventas con la siguiente información: número de la venta, el tipo de producto que se vendió, cantidad, precio, valor bruto de la venta, descuento y valor neto (bruto – descuento).

Adicionalmente se debe poder modificar la información de cualquiera de las ventas en caso de errores.

11. SUBPROGRAMAS: PROCEDIMIENTOS Y FUNCIONES.

11.1. INTRODUCCIÓN A LOS SUBPROGRAMAS O SUBALGORITMOS:

La programación modular es una de las técnicas fundamentales de la programación. Se apoya en el diseño descendente y en la filosofía de “divide y vencerás”, es decir se trata de dividir el problema dado, en problemas más simples en que cada uno de los cuales lo implementaremos en un módulo independiente. A cada uno de estos módulos es a lo que llamamos subalgoritmos o subprogramas.

Siempre existirá un módulo o programa principal que es con el que comienza la ejecución de todo el programa, y a partir de él iremos llamando al resto.

200

Cada vez que se llama a un subprograma se le pasa la información que necesita en la llamada, a continuación comienza a ejecutarse el subprograma llamado, y cuando termine su ejecución, devuelve el control a la siguiente instrucción a la de llamada en el programa que lo llamó.

En cuanto a la estructura de un subprograma es igual a la estructura de un programa, va a tener una información de entrada que es la que le pasamos al hacer la llamada y que se coloca junto al nombre del subprograma. Después va a tener un conjunto de acciones, declarar otras variables propias del subprograma, y al terminar la ejecución puede que devuelva o no resultados al programa que lo llamó.

Hay dos tipos fundamentales de subprogramas: Funciones y procedimientos.

11.2. FUNCIONES:

Desde el punto de vista matemático, una función es una operación que toma uno o varios operandos, y devuelve un resultado. Y desde el punto de vista algorítmico, es un subprograma que toma uno o varios parámetros como entrada y devuelve a la salida un único resultado.

Pascal: En las funciones se puede devolver más de un único resultado mediante parámetros.

C: Se devuelve todo por parámetros.

Este único resultado irá asociado al nombre de la función. Hay dos tipos de funciones:

- Internas: Son las que vienen definidas por defecto en el lenguaje.

- Externas: Las define el usuario y les da un nombre o identificador.

Para llamar a una función se da su nombre, y entre paréntesis van los argumentos o parámetros que se quieren pasar.

Declaración de una función:

La estructura de una función es semejante a la de cualquier subprograma. Tendrá una cabecera (con el nombre y los parámetros) y un cuerpo(con la declaración de los parámetros de la función y las instrucciones).

Sintaxis:

Funcion <nombre_funcion> (n_parametro: tipo, n_parametro: tipo): tipo funcion

Var <variables locales funcion>

Inicio

201

<acciones>

retorno <valor>

fin <nombre_funcion>

La lista de parámetros es la información que se le tiene que pasar a la función. Los parámetros luego dentro de la función los podemos utilizar igual que si fueran variables locales definidas en la función y para cada parámetro hay que poner su nombre y tipo.

El nombre de la función lo da al usuario y tiene que ser significativo.

En las variables locales se declaran las variables que se pueden usar dentro de la función.

Entre las acciones tendrá que existir entre ellas una del tipo retorno <valor>. Esta sentencia pondrá fin a la ejecución de la función y devolverá el valor de la función, es decir, como valor asociado al nombre de mismo tipo que el tipo de datos que devuelve a la función, este valor por tanto tiene que ser del mismo tipo que el tipo de datos que devuelve la función, que es el que habremos indicado al declarar la función en la parte final de la cabecera.

No se permiten funciones que no devuelvan nada.

Los parámetros que aparecen en la declaración de la función se denominan parámetros formales, y los parámetros que yo utilizo cuando llamo a la función se denominan parámetros actuales o reales.

Invocación de una función:

Para llamar a una función se pone el nombre de la función, y entre paréntesis los parámetros reales, que podrán ser variables, expresiones, constantes,... pero siempre del mismo tipo que los parámetros normales asociados

<nombre_funcion> (parámetros reales)

La función puede ser llamada desde el programa principal o desde cualquier otro subprograma.

Para llamar a la función desde cualquier parte, implica el conocimiento previo de que ésta función existe.

A través de los parámetros reales de la llamada se proporciona a la función la información que necesita, para ello, al hacer la llamada lo que se produce es una asociación automática entre parámetros reales y parámetros formales. Esta asociación se realiza según el orden de la aparición y de izquierda y derecha.

Si el parámetro formal y real no son del mismo tipo, en Pascal se produce un error, y en C se transforman los tipos si es posible.

202

La llamada a una función, siempre va a formar parte de una expresión, de cualquier expresión en la que en el punto en la que se llama a la función, pudiera ir colocado cualquier valor del tipo de datos que devuelve la función, esto se debe a que el valor que devuelve una función esta asociado a su nombre.

Pasos para hacer la llamada a una función:

1. Al hacer la llamada y ceder el control a la función, se asocia (asigna el valor) de cada parámetro real a cada parámetro formal asociado, siempre por orden de aparición y de izquierda a derecha, por lo que siempre que no coincidan los tipos y el número de parámetros formales y reales, se produce un error.

2. Si todo ha ido bien, se ejecutan las acciones de la función hasta que lleguemos a una de tipo retorno <valor> que pondrá fin a la ejecución. Pueden existir varias sentencias de retorno en la misma función, pero en cada llamada solo se podrá ejecutar uno.

3. Se le asocia al nombre de la función el valor retornado y se devuelve el control al subprograma que hizo la llamada pero sustituyendo el nombre de la función por el valor devuelto.

Otra forma de especificar el retorno de una función:

Se le asigna el valor devuelto al nombre de la función.

N_funcion valor

Ejemplo de función:

Una función que calcule la mitad del valor que le paso parámetro. Suponemos que es un valor entero.

Funcion mitad (n: entero): real

Var m: real

Inicio

M n/2

Retorno m

Fin mitad

Algoritmo calc_mitad

Var num: entero

203

Inicio

Escribir “Introduce un número para hallar su mitad”

Leer num

Escribir “La mitad de “num” es “mitad(num)

Fin

* La función solo puede ser llamada desde una expresión.

11.3. PROCEDIMIENTOS:

El inconveniente de una función es que solo puede devolver un único valor, por lo que sí nos interesa devolver 0 o N valores, aunque puedo usarlo para devolver un solo valor, debo usar un procedimiento.

Un procedimiento es un subprograma o un subalgoritmo que ejecuta una determinada tarea, pero que tras ejecutar esa tarea no tienen ningún valor asociado a su nombre como en las funciones, sino que si devuelve información, lo hace a través de parámetros.

Al llamar a un procedimiento, se le cede el control, comienza a ejecutarse y cuando termina devuelve el control a la siguiente instrucción a la de llamada.

Diferencias entre funciones y procedimientos:

1. Una función devuelve un único valor y un procedimiento puede devolver 0,1 o N.

2. Ninguno de los resultados devueltos por el procedimiento se asocian a su nombre como ocurría con la función.

3. Mientras que la llamada a una función forma siempre parte de una expresión, la llamada a un procedimiento es una instrucción que por sí sola no necesita instrucciones.

Esta llamada consiste en el nombre del procedimiento y va entre paréntesis van los parámetros que se le pasan. En algunos lenguajes (como el C), se pone delante la palabra Llamar a (Call) procedimiento (parámetro).

Sintaxis:

Procedimiento <nombre_proc> (<tipo_paso_par> <nombre_par>: tipo_par,...)

Var <variables locales>: tipo

Inicio

<sentencias>

204

fin <nombre_proc>

La cabecera va a estar formada por el nombre del procedimiento que será un identificador y que debe de ser significativo, y luego entre paréntesis los parámetros o la información que se le pasa al procedimiento. Para cada parámetro hay que indicar el tipo de paso de parámetro. Hay dos tipos fundamentales de paso de parámetros, por valor y por referencia, si no ponemos tipo de paso de parámetros, se toma el tipo de paso de parámetros por valor.

En el cuerpo del procedimiento donde van las sentencias ya no habrá ninguna de tipo <retorno valor>, ahora bien, si el procedimiento devuelve resultados a través de sus parámetros, cosa que solo podrá hacer a través de los parámetros que se pasan por referencia, tendrán que existir sentencias de asignación de valores a estos parámetros pasados por referencia, a través de los cuales se van a devolver los resultados.

Como se llama a un procedimiento:

[llamar a (Call)] nombre_proc (par_reales)

Pasos para hacer la llamada a un procedimiento:

1. Se cede el control al procedimiento al que se llama y lo primero que se hace al cederle el control es sustituir cada parámetro formal de la definición por el parámetro actual o real de la llamada asociado a él. Esta asociación entre parámetros formales y reales se hace de izquierda a derecha por orden de colocación y para que se pueda producir esta asociación tienen que existir el mismo número de parámetros formales que reales, y además el tipo tiene que coincidir con el del parámetro formal asociado, sino se cumple alguna de estas condiciones hay un error.

2. Si la asociación ha sido correcta comienzan a ejecutarse las instrucciones del procedimiento hasta llegar a la última instrucción. Al llegar a la instrucción se vuelven a asociar los parámetros formales que devuelven los resultados a los parámetros formales asociados en la llamada, es decir, de esta manera algunos de los parámetros reales de la llamada ya contendrán los resultados del procedimiento.

3. Finalmente se cede el control a la siguiente instrucción a la que se hace la llamada, pero teniendo en cuenta que en esta instrucción y en las siguientes puedo usar ya los parámetros reales en los que se devolvieron los resultados del procedimiento para trabajar con ellos.

205

Procedimiento mitad (num:entero,ent-sal M:real)

Inicio

M num/2

Fin mitad

Algoritmo calc_mitad

Var

N: entero

Mit: real

Inicio

Escribir “Introduce un número”

Leer n

Mitad (n,mit)

Escribir “La mitad es”mit

fin

11.4. ÁMBITOS: VARIABLES LOCALES Y GLOBALES:

¿Qué es el ámbito de un identificador?:

El ámbito de un identificador (variables, constantes, funciones,...) es la parte del programa en la que se conoce y por tanto se puede usar un identificador.

Según el ámbito hay 2 tipos de variables, locales y globales:

1. Local: Aquella que está declarada y definida dentro de un subprograma luego su ámbito coincidirá con el ámbito del subprograma en la que este definida.

Esto quiere decir que la variable no tiene ningún significado, no se conoce y no se puede acceder a ella desde fuera del subprograma y que tiene una posición de memoria distinta a la de cualquier otra, incluso si es de una variable que tiene el mismo nombre pero que está definida fuera del subprograma.

206

Las variables locales a un subprograma se definen en la parte de la definición de variables del mismo. Los parámetros formales que se le ponen a un subprograma se comportan dentro de él como si fueran también variables locales a él.

2. Globales: Son las que están definidas a nivel del programa, es decir, su ámbito es el programa o algoritmo principal y todos los subprogramas que van junto con él.

A esta variable podemos acceder desde cualquiera de los subprogramas y el programa principal, salvo que alguno de esos subprogramas tenga definida una variable local con el mismo nombre que la variable global, en este caso si utilizo el nombre de esa variable me referiré a la local, nunca a la global(ya que tienen 2 zonas de memoria distintas).

Lugar en el que se definen las variables globales:

En algunos lenguajes se define en el programa principal, y esa variable será global, en otros lenguajes se definen fuera del programa principal y fuera de cualquier otro subprograma(antes de empezar el programa principal). Método que vamos a usar.

El problema de usar variables globales es que como todos los subprogramas las pueden modificar, puede ser posible que haya usos indebidos cuando un subprograma utiliza una variable global sin saber que otro la ha modificado, por esa razón nunca usaremos para pasar información entre los subprogramas variables globales, sino que usaremos variables de entrada-salida, salvo que no nos quede más remedio.

Procedimientos anidados:

La anidación de procedimientos no se permite en todos los lenguajes y consiste en que dentro de un procedimiento podamos definir o meter el código de otros.

Si la anidación de procedimientos está permitida, se plantean más problemas en cuanto al ámbito, desde este punto de vista, se dice que una variable local se conoce en el procedimiento en el que está definida y en todos los procedimientos anidados a él que son los que componen el ámbito de dicho procedimiento, salvo que en alguno de esos procedimientos anidados este definida una variable local con el mismo nombre en cuyo caso dentro de ese procedimiento siempre nos referiremos a la variable local definida en él porque siempre se considera el ámbito más restringido.

PP

Var A,B

P1

207

A,C,D

P2

A

P3

D,E

P4 D,F

P5

P6 F,A

VARIABLES ÁMBITO SUBPROGRAMA

A del PP P4,P5

B del PP P1,P2,P3,P4,P5,P6

A del P1 P1,P3

C del P1 P1,P2,P3

D del P1 P1,P2,P3

A del P2 P2

D del P3 P3

E del P3 P3

D del P4 P4,P5,P6

F del P4P4,P5

F del P6P6

A del P6 P6

208

11.5. COMUNICACIÓN ENTRE SUBPROGRAMAS: PASO DE PARÁMETROS.

La mejor forma para llevar a cabo la comunicación ente subprogramas, es el paso de parámetros. Trataremos de evitar siempre que sea posible el uso de variables globales.

Cuando llamamos a una función o procedimiento, le pasamos a través de los parámetros la información que necesita, y en el caso de un procedimiento también devolvemos a través de sus parámetros los resultados. Para ello definiremos el tipo del parámetro a principio del subprograma, que es lo que conocemos como parámetros formales, y al hacer la llamada pasamos la información a través de los parámetros reales.

¿Cómo se efectúa la correspondencia entre parámetros formales y reales?:

Existen 2 métodos:

1. Correspondencia posicional: En este caso se emparejan los parámetros formales y reales por la posición que ocupan (orden de declaración) y de izquierda a derecha. Para que se pueda realizar esta asociación, tiene que haber el mismo número de parámetros formales y reales, y con el mismo tipo.

F (x:entero,y:real)

Var a:real

F (3,A)

2. Correspondencia por nombre implícito: Ahora en la llamada al subprograma se pone explícitamente a que parámetro formal corresponde cada real.

Ahora en la llamada ponemos el nombre del parámetro formal, separado por dos puntos (:) y el nombre del parámetro real que le pasamos, con lo cual ya no importa la posición en la que coloquemos la información.

F (x:3,y:A)

F (y:A,x:3)

Un lenguaje que permite esto es ADA.

Usaremos siempre el primer método (posicional).

Paso de parámetros:

Del modo de paso de parámetros va a depender el resultado que se obtenga.

209

1. Tipos de parámetros: Según se usen para meter datos o para obtener resultados.

Existen 3 tipos:

1. De entrada: Son parámetros que solo aportan información de entrada al subprogama en el que pertenecen como parámetros. Aporta el valor que tienen como entrada al subprograma. En el caso de una función, todos sus parámetros son de este tipo.

Como solo sirven como entrada, solo pueden ser leídos, pero no modificados, y aunque se modificasen dentro de un subprograma, fuera no va a tener efecto esa modificación.

2. De salida: Se usan solo y exclusivamente para devolver resultados a través de ellos. Su valor al hacer la llamada al subprograma no nos importa, sino que ese valor solo va a tener importancia cuando termina la ejecución del programa. Un parámetro de este tipo teóricamente nunca se puede leer, solo se va actualizar.

3. De entrada y salida: El valor del parámetro tiene importancia tanto a la entrada como a la salida del subprograma, nos aporta información cuando llamamos al subprograma y por otra parte devolvemos a través de él resultados cuando terminamos el subprograma, en este caso, tiene sentido tanto leer como actualizar el parámetro.

• Solo ADA es un lenguaje que va a soportar los 3 tipos de paso de parámetro. Se ponen como In, Out, In-Out.

• El resto de los lenguajes solo permiten dos tipos de parámetros, de entrada (solo para leer datos) y de entrada-salida (para devolver resultados, aunque también se puede usar para leer datos).

2. Métodos de paso de parámetros:

- Paso de parámetros por copia:

- Por valor.

- Por resultado.

- Por valor-resultado.

- Paso de parámetros por referencia.

- Paso de parámetros por nombre o nominal.

210

Paso de parámetros por copia:

La característica fundamental de este método de paso de parámetros es que el parámetro formal siempre se considera que tiene asociada una dirección de memoria en la que está almacenado y que por tanto se comporta igual que una variable local del subprograma en que aparece.

En este método lo que importa es el valor del parámetro actual.

1. Por valor: Nos interesa el valor del parámetro actual a la entrada, para ello este valor se copia en la dirección de memoria del parámetro formal asociado. En este caso el parámetro real puede se una constante, expresión o variable, y nunca se va a usar para devolver resultado a través de él, por esa razón precisamente puede ser una constante o una expresión, porque al no devolver resultados a través de él no necesita tomar ninguna zona de memoria en la que este almacenado, es más, incluso si el parámetro actual fuera una variable y la modificásemos dentro del subprograma (algo que no deberíamos hacer), fuera del subprograma no tendría ninguna repercusión esta modificación, es decir, esa variable serviría valiendo lo mismo en el programa desde el que se hace la llamada después y antes de hacerla.

El funcionamiento sería el siguiente:

- Al hacer la llamada al subprograma se evalúa el valor del parámetro real, y ese es el que se asocia, es decir, el que se guarda o asigna al parámetro formal asociado.

- Comenzamos a ejecutar el subprograma y si por casualidad se produce algún cambio en el parámetro formal, el parámetro actual no se verá afectado, es decir, su valor seguirá siendo el mismo en el subprograma desde donde se llama que antes de hacer la llamada al subprograma.

Algoritmo Ej

Var A:entero 3 3 6

Inicio A del PP X de P

211

A 3

P (A)

Escribir A

Fin

Procedimiento P(x:entero)

Inicio

X x*2

Escribir x

Fin p

El valor de A sería 3 y el de X sería 6.

2. Por valor-resultado: En el valor-resultado nos interesa el valor del parámetro actual tanto a la entrada como a la salida de la ejecución del subprograma.

Esto quiere decir que se cambia el valor del parámetro formal cambiará también el valor de su parámetro real asociado, cosa que no ocurría antes, y esto supone por tanto que ahora el parámetro real tiene que tener asociada obligatoriamente una dirección de memoria, por lo que siempre tendrá que ser una variable (no una constante ni una expresión).

El proceso sería el siguiente:

- Al hacer la llamada al subprograma se evalúa el parámetro real y su valor se copia en el parámetro formal asociado y al terminar la ejecución el valor del parámetro formal se vuelve a copiar en el parámetro real asociado.

Algoritmo Ej

Var A:entero Se copia

Inicio

A 3

P (A) 3 6 3 6

Escribir A P.Real P.Formal

Fin

Procedimiento P(x:entero)

212

Inicio Se devuelve

X x*2

Escribir x

Fin p

El valor de la A y la X sería 6.

3. Por resultado: Nos interesa el valor del parámetro real solamente a la salida o fin de la ejecución del subprograma en que aparece. Esto significa que al hacer la llamada no se copia el valor del parámetro real en el parámetro formal asociado, sin embargo a la salida se copia el valor del parámetro formal en la dirección del parámetro real asociado, esto significa por tanto, que el parámetro real tiene que tener asociada una expresión que tiene que ser una variable (no puede ser una constante o una expresión).

Algoritmo ej No se copia

Var A:entero

Inicio

A 3 P.Real P.Formal

P (A)

Escribir A

Fin

Procedimiento P(x:entero) Se copia a la salida

Inicio

X 1

X x*2

Escribir x

Fin p

213

El valor de A y de X es 2.

En la práctica la mayor parte de los lenguajes dentro del tipo de paso de parámetro por copia solo van a soportar el tipo de paso de parámetro por valor, que se usará cuando un parámetro solo lo quiero utilizar como entrada de información al subprograma, pero no para devolver resultados a través de él.

Los otros dos tipos de paso de parámetros por copia (por valor y por valor-resultado), no se implementan normalmente porque los efectos son prácticamente iguales que el paso de parámetros por referencia, es decir, cuando quiero usar un parámetro no solo para pasar información a través de él sino también para devolver resultados o si lo voy a usar sólo para devolver resultados, utilizaré el paso de parámetros por referencia que vamos a ver a continuación.

Para simbolizar que el tipo de paso de parámetros es por valor, en la definición del subprograma no pongo ningún tipo de paso de parámetros para ese parámetro, es decir, no poner ningún tipo significa que por defecto el tipo de paso de parámetros es por valor.

En el caso de las funciones como solamente pueden recibir información de entrada pero nunca pueden devolver información por sus parámetros ya que lo devuelven a través de la sentencia retorno y asociado a su nombre.

El tipo de paso de sus parámetros va a ser siempre por valor.

Paso de parámetros por referencia:

Ahora la característica principal de este tipo de paso de parámetros es que el parámetro formal va a tener también asignada una dirección de memoria en la que se almacena, pero en esa dirección NO SE GUARDA SU VALOR, sino que se almacena la dirección de su parámetro real asociado, es decir, el parámetro formal apunta al parámetro real que tiene asociado y cualquier modificación que se efectúe sobre el parámetro formal tendrá una repercusión directa en el parámetro real asociado ya que lo que modificará será el valor almacenado en la dirección que indica el parámetro formal que es la de su parámetro formal asociado.

El proceso será por tanto el siguiente:

- Al hacer la llamada al procedimiento en el parámetro formal que se pasa por referencia, se va a guardar la dirección del parámetro real asociado para que apunte a él.

- Durante la ejecución cualquier referencia al parámetro formal se hará accediendo a la dirección apuntada por dicho parámetro, es decir, accediendo directamente al parámetro real asociado, por lo que cualquier cambio en el parámetro formal afectará directamente al parámetro real asociado. De esta manera habremos pasado el resultado.

214

Para indicar que el tipo de paso de parámetro es por referencia, vamos a utilizar la palabra clave ent-sal precediendo al parámetro que se pasa por referencia.

A estos parámetros también se les llama parámetros variables (porque su valor varía), por eso en Pascal se usa la palabra clave Var para indicarlo.

En otros lenguajes como C, se usan como parámetros punteros para indicar que son direcciones.

Algoritmo EJ

Var A apunta

Inicio

A 3

P1(A) 3 dirección A

Escribir (A)

Fin A del PP X del P1

Procedimiento P1(ent-sal x:entero)

Inicio

X x*2

Fin P1

Por valor el parámetro actual no cambia de valor.

Por referencia el parámetro actual puede cambiar.

Paso de parámetros por nombre:

En este caso, el parámetro formal se sustituye literalmente por el parámetro actual asociado. Esta sustitución literal del parámetro formal por el parámetro actual no se produce hasta que no se usa el parámetro formal.

La ventaja es que si no usamos en ningún momento el parámetro formal dentro del subprograma llamado (cosa poco probable), no se tendrá que hacer ningún tipo de substitución.

Pero el gran inconveniente es que si se usa el parámetro formal, hay que ir a buscar en ese momento la expresión del parámetro real asociado.

215

El paso de parámetro por nombre es lo que se parece más a la substitución de parámetros en una función matemática.

F (x)= x+2

F (a+1) = a+1*2

F (x)= x+2

F (a+1)= a +1 2 <> (a+1)*2

Algoritmo EJ

Var A: entero

Inicio

A 3

P1(A+1)

Escribir (A)

Fin

Procedimiento P1(ent-sal x: entero)

Inicio

X x*2

Fin P1

Al final solo vamos a usar 2 tipos de paso de parámetros, que son los que usan casi todos los lenguajes: Por valor y por referencia.

Por valor: Solo lo usamos cuando un parámetro solo sirve para información de entrada, no devolvemos nada con él. Por eso este paso puede ser una constante, variable o expresión. Para simbolizarlo en la declaración de variables no ponemos nada.

Por referencia: Lo usamos cuando un parámetro lo usamos como entrada de información y como salida o solo como salida. Por esta razón ahora sí que se va a variar el parámetro formal y por lo tanto no podemos usar constantes ni expresiones, solo variables. Lo simbolizamos con la palabra ent-sal.

11.6. FUNCIONES Y PROCEDIMIENTOS COMO PARÁMETROS:

216

En la mayor parte de los lenguajes se permite también que una función o procedimiento pueda ser pasado como parámetro de otro subprograma. En este caso, es decir, cuando el parámetro formal es de tipo función o procedimiento, pasaremos como parámetro real funciones o procedimientos que tengan la misma definición que el que hemos puesto como parámetro formal, y en nuestro caso para indicar que se pasa como parámetro real una función o procedimiento, basta con poner su nombre.

Desde el subprograma al que se pasa como parámetro esa función o procedimiento podemos llamar en cualquier momento a esa función pasada como parámetro que en cada momento podrá ser una distinta dependiendo del parámetro formal asociado.

Funcion <nombre_f> (par:tipo;funcion <n_f>(x:entero,y:carácter):entero

Prodedimiento <nombre_f> procedimiento (x:tipo,...);...

Algoritmo EJ

Var v1,v2: entero

Inicio

V1 1

V2 2

P(v1,f1,v2)

P(v1,f2,v2)

Fin

Procedimiento P(x:entero;funcion F(A:entero;B:carácter):entero;ent-sal y:entero)

Inicio

X 2

Y F(x,’a’)

Fin P

Funcion F1(x:entero;y:carácter):entero

Inicio

217

Escribir y

Retorno (x+1)

Fin

Funcion F2(A:entero;B:carácter):entero

Inicio

Escribir “Hola” B

Retorno A

Fin F2

El paso de funciones y procedimientos como parámetros, nos va a permitir que desde un subprograma podamos llamar a otros, pero teniendo en cuenta que el subprograma llamado no va a ser uno determinado, sino que va a depender en cada momento del subprograma pasado como parámetro real, de esta manera el subprograma puede llamar a un conjunto de n subprogramas que cumplan unas determinadas características, pero solo uno en cada momento.

No hay que confundir el paso de una función como parámetro con la llamada a una función cuando aparece como parámetro real en la llamada a un subprograma. Para diferenciarlo, cuando paso una función como parámetro solo pondré su nombre, en cambio cuando llamo a una función para pasar el valor que devuelve como parámetro pondré el nombre de la función y con sus argumentos para indicar que ahí se puede hacer la llamada. Esto se puede hacer porque la llamada a una función puede aparecer en cualquier expresión en la que apareciese cualquier valor del tipo de datos que devuelve.

Procedimiento P(A:entero)

Inicio

Escribir A

Fin P

Funcion F(x:entero):entero

Inicio

Retorno (x*2)

Fin F

218

Algoritmo EJ

Var I

Inicio

I 2

P(F(I)) Esto no es pasar una función como parámetro

Fin

11.7. EFECTOS LATERALES:

Un efecto lateral es cualquier modificación que un subprograma (sea función o procedimiento), realiza en elementos situados fuera de él pero sin hacer esas modificaciones a través del paso de parámetros.

Los efectos laterales siempre hay que evitarlos porque no somos conscientes o no controlamos que se han producido.

Para realizar comunicación entre subprogramas solo se hará a través del paso de parámetro para evitar los efectos laterales.

Los efectos laterales normalmente se producen por el uso de variables globales o variables locales que abarcan varios procedimientos (esto solo es posible si hay anidación de subprogramas). Por lo tanto evitaremos su uso excepto que sea imprescindible.

Var A:entero

Algoritmo EJ

Var B:entero

Inicio

B 1

219

A 2

P(B)

Escribir A

Fin

Procedimiento P(x:entero)

Inicio

A x+2

Fin P

11.8. RECURSIVIDAD:

Se dice que un subprograma es recursivo cuando se llama a sí mismo. La recursividad se va a poder usar en subprogramas que pueden definirse en términos recursivos, es decir, en termino de sí mismo, como procesos de alguna manera repetitivos.

La recursividad trataremos de evitarla siempre que sea posible, es decir, siempre que lo mismo se pueda solucionar con un bucle, ya que cada vez que un subprograma se llama a sí mismo hay que almacenar en la pila del sistema la dirección de retorno de ese subprograma, con lo cual si hacemos muchas llamadas recursivamente iremos llenando la pila del sistema, y se desbordara acabando con la memoria.

Todo programa recursivo tiene que tener alguna condición que ponga fin a la recursividad, es decir, que el programa deje de llamarse a sí mismo cuando se cumpla la condición, sino se formaría un bucle infinito.

Funcion potencia (base:entero;exp:entero):real

Var P:real

I:entero

Inicio

P 1

Desde i=1 hasta exp

P P*base

220

Fin desde

Retorno P

Fin

Funcion potencia (base:entero;exp:entero):real

Inicio

Si exp=0 entonces retorno 1

Sino