Sistemas de Programación IA & Computación Aplicada - Notas de Curso -------------------------------------------------------------------

Autor: Prof. Ing. Guillermo Kalocai, UNS.DIE.LIP (g.kalocai@ieee.org)Revisión: Ing. Andrés P. Repetto, UNS.DIE.LIP (aprepetto@criba.edu.ar)Acualizado a: Set99

+-----------------------------------------------------------------------+ ¦ ADVERTENCIA 1: ¦ ¦ ¦ ¦ Estas notas de curso en modo alguno -es decir, ** NO! **- reemplazan ¦ ¦ a los contenidos desarrollados durante las clases y, mucho menos, ¦ ¦ al material bibliográfico referenciado. Solo constituyen un aporte ¦ ¦ complementario a los mencionados cuya caracerística más valiosa ¦ ¦ consiste, posiblemente, en estar organizadas de un modo muy similar ¦ ¦ a la línea de desarrollo de los temas durante el cursado. ¦ +-----------------------------------------------------------------------+

+-----------------------------------------------------------------------+ ¦ ADVERTENCIA 2: ¦ ¦ ¦ ¦ Estas notas preliminares de curso son *PRELIMINARES* (la redundan- ¦ ¦ cia es expresa). Bajo la responsabilidad (complicidad ?) del autor ¦ ¦ han sido liberadas ANTES de estar completas de modo tal que algunos ¦ ¦ pocos títulos no han sido aún desarrollados, algunas tablas están ¦ ¦ incompletas o desactualizadas, etc. Así todo, la mayor parte del ¦ ¦ contenido está actualizado y completo, quedando bajo responsabili- ¦ ¦ dad del autor la pronta liberación de copias que vayan resolviendo ¦ ¦ estas falencias. ¦ +-----------------------------------------------------------------------+

+-----------------------------------------------------------------------+ ¦ ADVERTENCIA 3: ¦ ¦ ¦ ¦ Estas notas preliminares de curso están sujetas a revisión constante ¦ ¦ y en esta, su primer salida a la luz, seguramente será posible a los ¦ ¦ lectores identificar varios herrors hortográficos (por ejmplo...) ¦ ¦ cuando no en la construcción de algunas oraciones o en la presenta- ¦ ¦ ción de los listados de código. Se ruega y agradece por adelantado ¦ ¦ al lector que todo error identificado, sea del tipo de los comenta- ¦ ¦ dos u otros, sea reportado al autor a la brevedad. Después de todo, ¦ ¦ la decisión de distribuir este material en medio magnético tiene por ¦ ¦ propósito facilitar el rápido reemplazo del mismo con errores corre- ¦ ¦ gidos y, eventualmente, con contenido ampliado y actualizado. ¦ +-----------------------------------------------------------------------+

+-----------------------------------------------------------------------+ ¦ ADVERTENCIA 4: ¦ ¦ ¦ ¦ Usualmente los alumnos del curso se preguntan por qué un curso intro- ¦ ¦ ductorio de computación para estudiantes de Ingeniería no se basa en ¦ ¦ el uso de planillas de cálculo, bases de datos, programas de matemáti-¦ ¦ ca, etc. Hay varias respuestas, aunque todas estas de estricto gusto ¦ ¦ del autor, lo que, por cierto, no les asigna la calidad de Verdad Uni-¦ ¦ versal. Así todo, algunas de ellas son: ¦ ¦ a) Los productos comerciales especializados de probada fama han conse-¦ ¦ guido tal cualidad como producto de, a saber y entre otras: ¦ ¦ a.1) Son muy sencillos e intuitivos de usar para la solución del ¦ ¦ tipo de problemas específicos a que apuntan. ¦ ¦ ¦ a.2) Eso los hace muy sencillos e intuitivos de aprender con bi- ¦ ¦ bliografía específica, de bajo costo y muy accesible a una ¦ ¦ mente, inclusive, sin preparación universitaria. ¦ ¦ a.3) Es más, a la fecha hay programación en TV y cursos tutoriales ¦ ¦ vía internet que constituyen muy buenas fuentes referencia ¦ ¦ para el autoaprendizaje de estas herramientas. ¦ ¦ a.4) Si se desean soluciones específicas a problemas complejos, se ¦ ¦ han de aprender y usar las herramientas de extensión de que ¦ ¦ estos productos disponen, casi todas basadas en un lenguaje ¦ ¦ de programación. ¦

¦ a.5) De enseñarse el uso especializado de un producto específico, ¦ ¦ con marca y apellido, se estaría casando a los cursantes con ¦ ¦ una tecnología cuya vida comercial, en vista de la experien- ¦ ¦ cia, es de dudosa duración. Lo único que permanece intacto ¦ ¦ es lo que es común a todos los productos de ese tipo, lo que ¦ ¦ los ha hecho famosos, y es, por cierto..., lo básico ! ¦ ¦ a.6) Por todo lo dicho, no justifico un curso universitario que ¦ ¦ aborde estos temas más allá del aspecto ilustrativo. Sería ¦ ¦ parecido a cursar una asignatura en la que se enseña cómo re- ¦ ¦ solver problemas de ingeniería con una calculaora... ¦ +-----------------------------------------------------------------------+

+-----------------------------------------------------------------------+ ¦ En reconocimiento por soportar tanta intimidación, GRACIAS !!! ¦ +-----------------------------------------------------------------------+

--------------------------------------PARTE I--------------------------------

Introducción------------

En esta primera parte se presentan los conceptos básicos en los que, tantoen la forma de abstracciones como en la de realizaciones, se basa eldesarrollo de programas, al menos, hasta en lo que al alcance del cursorespecta e interesa.

Se describe una concepción general e informal de la computación para luegodesembarcar en la computadora y sus componentes, los programas y suscomponentes. Finalmente se despliegan las nociones básicas para el desarrollode programas en un estilo procedural utilizándose el QB como herramienta dedesarrollo para la elaboración de ejemplos.

Es justo remarcar que las metodologías de programación propuestas respondena una concepción fuertemente empírica y que sería un error asumir que lasnociones -muy básicas- aquí presentadas son suficientes para encarar sistemasde programación de envergadura, y esto sin tener en cuenta el conjunto deparadigmas de programación alternativos y/o complementarios que no sonsiquiera mencionados.

La máquina de computar----------------------

Entre las características más relevantes de la especie humana encomparación con las inferiores (animales, vegetales y, por supuesto,minerales) sobresale la inteligencia. A través de la historia, el hombre hahecho gala de la misma de muy diversos modos, uno de los cuales ha consistidoen la búsqueda incesante de modos y medios para facilitar su trabajo (y/opara, directamente, posibilitar la aparición de nuevas tareas, siempretendiendo a mejorar su standard de vida o, directamente y en muchos casos, aposibilitar su supervivencia). Aún antes de saberlo, el hombre desarrolló laprimer máquina en el mismo instante en que utilizó una herramienta por élconstruida a fin de potenciar una de sus habilidades innatas, como porejemplo, el uso de un garrote para cazar ("2001: A Space Odyssey", A. Clarke).

La pespectiva con que se encara el término 'máquina' es la de cualquierdispositivo capaz de transformar materia o energía, de un estado inicial auno final, supuesto más útil para un fin determinado.

+-----------------+ +-------------------+ ¦Materia o Energía¦ +-------------+ ¦Materia y/o energía¦ ¦ +--->¦M A Q U I N A+---->¦ ¦ ¦(estado inicial) ¦ +-------------+ ¦(estado final) ¦ +-----------------+ +-------------------+

+--tiempo----->

Por ejemplo, un motor térmico transforma energía térmica en cinética, unaradio energía eléctrica en sonido y un horno, masa en pan. La máquina, debidoa su construcción y modo de uso, pone en marcha un proceso específico

destinado a operar una determinada transformación. Tal vez, para hacer másgeneral la concepción, sería adecuado referir a un 'proceso' más que a unamáquina, siendo esta última la responsable de implementar físicamente almismo. En este breve párrafo hay involucradas ideas muy importantes que, aúna riesgo de parecer triviales, van a ser reiteradas. Por un lado, que esposible transformar cosas inútiles, o de poca utilidad, en cosas útiles, y porotro que, para que eso ocurra, es necesario un proceso intermedio que consumeun tiempo. Si ese proceso está materializado en un máquina, la misma y su modode uso, contienen la información necesaria para el desarrollo del proceso.Sería de utilidad a esta altura tomarse un momento para pensar si todas lasmáquinas y procesos responden a este esquema, y se propone como ejerciciodesplegar una lista de ejemplos a fin de acabar su comprensión. La mencionadalista debería incluir en una columna el nombre de la máquina o proceso, elmaterial o forma de energía inicial, y el resultado final, buscándose un sesgoprogresivo hacia dispositivos y mecanismos no vistos tradicionalmente comotales. Adicionalmente, al conjunto formado por el estado inicial y el finalde las entidades sujetas a ser modificadas por el proceso se las sueledenominar el "ambiente" del mismo.

No es extraño que al hacer mención a una computadora se suela utilizar,también, el término 'máquina'. Ahora, si intentamos encuadrar a un sistema decómputo dentro del marco previamente presentado, vemos que no encaja del todobien (se propone incluir a la computadora en la lista antes mencionada ydescribir la materia prima, el proceso involucrado, y el resultado obtenido).La computadora, efectivamente, produce un resultado útil. I.e., a partir deuna materia prima en una forma de escasa o nula utilidad se obtiene unamateria elaborada. Pero esa materia no es un material ni es una forma deenergía, y este es el aspecto que dificulta que la misma encaje en nuestra'definición' de máquina. Efectivamente, la computadora transforma un nuevotipo de material: información. Su ambiente es uno caracterizado por estarconstituido íntegramente por información. Y tan eficiente ha mostrado ser lacomputadora que hoy en día pocas personas dudan en sostener que nosencontramos en algo así como la 'edad de la información' lo que, más allá decualquier consideración filosófica y/o estratégica a cualquier nivel, nohubiera sido posible sino mediante el surgimiento de estas 'máquinas'.Efectivamente, los procesos involucrados no son en muchos casos nuevos, perola tecnología que ha permitido su implementación física sí lo es.

Por citar un ejemplo, inclusive capitalizado por la sabiduría popular en'una imagen habla por mil palabras', una lista de números representantes decoordenadas y alturas correspondientes a un terreno puede tornarse intratablepara todos los fines prácticos en tanto su tamaño crece -pensemos, porejemplo, en una lista de 100 páginas-. La misma información es factible deser graficada en curvas de nivel las que sin duda, no sólo no resultantediosas de interpretar sino que, de un vistazo, arrojan un panorama generalde la situación, Y SE TRATA SIEMPRE DE LA MISMA INFORMACION: NO SE HA AGREGADONI QUITADO NADA. Solamente ha mediado el trabajo de transformar datosnuméricos en gráficos.

Otro. De qué serviría la inmensa cantidad de datos que genera un censonacional si la organización y análisis de los mismos no puede llevarse a caboen un tiempo razonable. Claro, el trabajo necesario para extraer conclusionesbien puede hacerse manualmente (también la graficación de las curvas denivel). Incluso, si bien tedioso, no es complejo. Pero si el tiempo empleadoes excesivo, los resultados obtenidos al final pueden ya no corresponder a larealidad que les dio origen y a la cual pretenden representar, máxime teniendoen cuenta la velocidad con que, hoy por hoy, las cifras involucradas varían.Y, aunque así no fuera, la información siempre es un producto con fechas.

Algunas aplicaciones típicas de las computadoras son el procesamiento deimágenes a fin de mejorarlas resaltando aspectos de interés; el procesamientode texto; la simulación de modelos a fin de predecir posibles comportamientos(por ejemplo, el clima, procesos químicos, procesos industriales, elmovimiento de planetas y estrellas, etc.); el control de sistemas, por ejemplode transmisión de datos o de plantas o procesos industriales; etc., etc.,etc.. Y en esto se refleja la segunda y distintiva característica de lossistemas de cómputo, que surge como respuesta a 'Cómo puede ser que una mismamáquina sirva para propósitos tan dispares ?'. Esta segunda cualidadmencionada es la 'adaptabilidad' de los sistemas de cómputo. Una computadoraes una máquina que a través de un proceso denominado 'programación' puede ser

acondicionada para desarrollar muy diversos tipos de tareas, sin ir más lejos,como las mencionadas previamente. Esto no ocurre, en general, con otro tipo demáquinas: una caldera sirve para generar vapor y no para otra cosa; unamartillo sirve para clavar y no para otra cosa. Por qué ? Porque, como ya seha dicho, en su construcción y modo de uso está íntimamente fijo su propósitoy efecto. En cambio una computadora, al ser programable, es capaz de sermodificada en su configuración y modo de uso a fin de desarrollar trabajosde distinta índole.

Panorama histórico del desarrollo de las computadoras-----------------------------------------------------

La computadora no es producto de una inspiración sorpresiva sino elresultado de una larga serie de eventos, tanto intelectuales comotecnológicos. Muchas de las ideas que sustentan su funcionamiento yaplicaciones no son nuevas. Incluso las hay muy antiguas. La diferencia la hahecho la tecnología cuyo impresionante avance de fines de siglo ha hechoposible su implementación y utilización.

Posiblemente, la historia de la computación nació en el mismo tiempo enque se desarrolló nuestro sistema numérico posicional que posibilita unamecánica objetiva para el tratamiento de cantidades. No tardó mucho el hombreen buscar la automatización de algunas operaciones dado lo algorítmico de lamecánica numérica. Los griegos y romanos fueron para nuestra civilizaciónoccidental, tal vez, los primeros beneficiarios de una herramienta para laautomatización de sumas y diferencias mediante un dispositivo rudimentariopero no por eso menos ingenioso denominado ábaco.

Basado en un desarrollo de Blaise Pascal de mediados del s. XVII queposibilitaba la automatización de sumas y restas, Gottfried von Leibnitzperfeccionó, sobre fines del mismo siglo, una calculadora que mecanizabatambién productos y cocientes.

A principios del s. XIX, Charles Babagge, profesor de matemática de laUniversidad de Cambridge, concibió la 'máquina diferencial'. La misma eracapaz no sólo de desarrollar automáticamente las operaciones básicas sino queademás posibilitaba hacerlo en cadenas sin necesidad de la intervenciónhumana. En una palabra, era configurable. Con la misma, y a partir deaproximaciones polinomiales, se construyeron las primeras tablas delogaritmos y funciones trigonométricas automáticamente generadas. Babbage notardó en verificar que su máquina, con el agregado de extensiones mecánicas,era capaz de tratar polinomios de grado arbitrario por lo que diseñó unsucesor, la 'máquina analítica'. La misma era capaz de modificarautomáticamente la estructura de cálculo en función del problema entratamiento pero nunca llegó a ser construída dado que con la tecnología delmomento no era posible alcanzar la precisión en las piezas mecánicas quehubiera sido necesaria de acuerdo al diseño. En este sentido, Babbage estuvoadelantado a su época y sus ideas guiaron a quienes lo siguieron.

Durante la década de 1880, la oficina de censos de EEUU encargó al Dr.Herman Hollerith el desarrollo de una máquina capaz de automatizar elprocesamiento estadístico de los datos. El procesamiento manual de los mismostomaba nueve años y, dado que el censo nacional se llevaba a cabo cada diez,el crecimiento poblacional pronto iba a inutilizar al método. A partir deletras y números codificados en tarjetas de cartón, Hollerith consiguióautomatizar el análisis llevando el tiempo insumido a solo tres años. En 1896Hollerith dejó la oficina de censos para iniciar Tabulating Machines Companyla que, después de un tiempo, se transformaría en International BusinessMachines Corporation, más conocida hoy en día como IBM.

Hasta ese momento, todos los dispositivos de cómputo automático estabanconstruídos a partir de partes mecánicas. En 1937, George Stibitz de BellTelephone Laboratories construyó el primer sistema de cómputo automático queincorporaba partes eléctricas así como al sistema binario de representaciónnumérica. El mismo estaba preparado para operar con números complejos y paracomunicar datos desde y/o hacia una terminal remota. Una versión posteriorincorporó la posibilidad de programar la secuencia de operaciones codificadasen una cinta de papel perforado. Bastaba cambiar la secuencia de símbolospara modificar el comportamiento de la cadena de cómputo. El siguientedesarrollo electromecánico fue la MARK I, a cargo de Howard Aiken, de la

Universidad de Harvard y concluyó en 1944.

A partir de 1943 comenzó el desarrollo de la primer computadora totalmenteelectrónica, a cargo de los profesores John W. Eckert y J.Prespen Mauchly, dela Universidad de Pennsylvania. Se trató de la ENIAC, tecnológicamentepredecesora de todas las modernas computadoras electrónicas.

El paso final hacia el modelo computacional actualmente generalizado fuedado por el Dr. John von Neumann quien, en 1945 en la Universidad dePrinceton, propuso el desarrollo de la 'computadora digital de programaalmacenado', en la que tanto lo datos como las instrucciones del control sehallan entremezclados en el código del programa. Su propuesta le valió eltítulo de padre de la computación moderna, llegándose a partir de suconcepción a la primer computadora comercial de la historia: en Mayo de 1949la UNIVAC I.

En la actualidad, fuera de la propuesta de von Neumann, existenmodalidades alternativas de computación pero sin duda, y debido a motivoscasi estrictamente comerciales, la computadora digital de programa almacenadoes la que, incorporando los sucesivos adelantos tecnológicos, muestra laaplicación más generalizada, desde sus versiones personales (las PCs. en susdiversos tipos y modelos) hasta los mainframes y las supercomputadoras,aunque estos últimos dos tipos de computadoras responden a arquitecturasalternativas más adecuadas a su finalidad.

Este breve cronología, además de breve, es incompleta. Muchos otros hechosfueron cimentando el desarrollo de las computadoras pero justo era no dejarde lado una muy sucinta perspectiva histórica.

Modelo de funcionamiento de una computadora-------------------------------------------

El gran secreto dentro de una computadora es fundamentalmente tecnológicodado que la idea abstracta sobre la que se basa su funcionamiento es sencilla.

+-------------------------------------------------------------------------+ ¦La misma consiste en que un sistema de cómputo es capaz de desarrollar en¦ ¦forma absolutamente ¦ ¦ +------------+ ¦ ¦ ¦.Rigurosa ¦ ¦ ¦ ¦.Incansable ¦ ¦ ¦ ¦.Veloz ¦ ¦ ¦ +------------+ ¦ ¦una lista o secuencia de tareas elementales. ¦ +-------------------------------------------------------------------------+

y el secreto es tecnológico dado que de no contarse con la tecnologíaadecuada, esta idea hubiera quedado en los papeles. De hecho, la base es tansencilla que cualquier persona medianamente inteligente podria haberlaconcebido, al menos en sus rudimentos. Analicemos el siguiente ejemplo:

* Una hormiga es capaz de transportar granitos de arena. * Una hormiga, durante su vida, no será capaz de transladar sino una relativamente pequeña cantidad de granitos de arena. * Las hormigas como cuerpo social, y si se lo proponen, son capaces de mover una montaña completa, supuesta la cantidad necesaria de ellas. Bien sabemos que, a menos de un insecticida, pocas cosas consiguen interponerse a sus propósitos. Por otro lado no cabe duda que cuentan, literalmente hablando, con 'todo el tiempo del mundo' por lo que, si así se lo proponen, la montaña resultará inexorablemente desplazada.

Qué se podría decir, entonces, de las hormigas como cuerpo organizado ? Queson tenaces (rigurosas), incansables y, a su modo, suficientemente veloces(dado que cuentan con 'todo el tiempo del mundo', para sus fines, su velocidades la adecuada). No habrá pasado desapercibido para el lector que la intenciónes poner de manifiesto un paralelismo. Entonces las computadoras se parecen alas hormigas ? Desde el ángulo en que se ha encarado el ejemplo,absolutamente. Sólo restaría un detalle: que a las hormigas se les pudieraimponer desde el exterior un propósito o meta a alcanzar así como los pasospara llegar con éxito. Y cómo serían esos pasos ?. Sería una lista de tareas,

cada una muy sencilla, a la altura de cada hormiga individual, pero que,desarrolladas conjuntamente y con la debida rigurosidad conduciríandefinitivamente al fin propuesto. Magia ?. No:

+----------------+ ¦.Rigurosidad ¦ ¦.Incansabilidad ¦ ¦.Rapidez ¦ +----------------+

Por ejemplo, las tareas encomendadas podrían consistir en mover esamontaña, cavar una túnel o, al menos, hacer un hormiguero. En definitiva,cualquier tarea que se pueda describir en términos de "cortar un pizca muypequeña de material", "transportar la pizca de material a algún sitio", etc.,todas estas mini-tareas elementales que las hormigas conocen y son capaces deejecutar.

Otro ejemplo aplicable es el de los esclavos del faraón. Los faraonescodiciaban, entre otras cosas, perpetuarse mediante obras de arquitectura deproporciones gigantescas, muchas veces, sus propias tumbas. Pero no lasconstruían ellos... Disponían, gracias a su posición, de todo un ejército deesclavos para cumplir sus deseos. Y cómo funcionaba ésto ? El faraón le decíaa su jefe de arquitectos con qué obra estaba soñando, este hacía los planos y,aprobados por aquel, se encargaba que se iniciaran las obras. Por supuestoque los esclavos, literalmente, dejaban la vida en la obra pero, desde elpunto de vista del faraón, esclavo más, esclavo menos, el trabajo progresaba,fuera que se trata de una pirámide, una esfígie o un acueducto. Y como susansias de perpetuidad superaban a su apuro, los trabajos iban suficientementerápido. Pero, en qué consistían ? Básicamente en disponer de bloques, másgrandes o más pequeños, pero siempre bloques, uno pegado a los demás, pero enmuy diversas disposiciones, de acuerdo a los planos del arquitecto. Y quétenemos entonces ? Nuevamente un mecanismo constructivo muy riguroso (salirsede los planos seguramente se pagaba con la vida), incansable (cada esclavoindividual se cansaba hasta la muerte, pero, aun así, la obra no se detenía)y suficientemente rápido (el faraón estaba dispuesto a esperar).

Hemos dicho que para el desarrollo de un trabajo es necesario contar conuna herramienta o máquina capaz de llevar a cabo un proceso. Genéricamente,a tal dispositivo lo denominamos "procesador". En el caso de las computadoras,el procesador, al igual que las hormigas, conoce y sabe ejecutar una listade mini-tareas elementales que, adecuadamente combinadas y en la cantidadsuficiente, pueden dar lugar a la ejecución de un tarea que lleva a una metade mayor envergadura que cada mini-tarea individual.

Dentro de una computadora se despliega el siguiente esquema o arquitectura:

+-Computadora-----------------------------------------------+ ¦ +----------+ +---------------+ +----------------+ ¦ ¦ ¦ ¦ ¦ Unidad Central¦ ¦ ¦ ¦ ¦ Memoria <-----> de Proceso <----> Entrada/Salida <-------> ¦ ¦ ¦ ¦ (CPU) ¦ ¦ (I/O) ¦ (exterior) ¦ +----------+ +---------------+ +----------------+ ¦ +-----------------------------------------------------------+

Como se aprecia en el esquema, los vínculos entre los módulos sonbidireccionales y manifiestan los posibles sentidos del flujo de información(el material a procesar) entre ellos y con el exterior.

La CPU hace las veces de nuestra sociedad de hormigas. Es la CPU la quelleva a cabo las tareas elementales rápida, rigurosa e incansablemente. Lalista finita de tareas elementales que una CPU puede desarrollar y cómo laslleva a cabo están implícitas en su construcción y son las característicasque distinguen a los diversos tipos y modelos de CPUs (80386, 80486, Pentium,68030, PowerPC, etc.). Esas tareas son como ladrillos. Con LOS MISMOSladrillos se puede construir un departamento, un castillo o un puente. Laforma de los ladrillos y el modo de vincular uno con otro son elementales ycomunes en los tres casos. La diferencia está en el plan global, i.e. en elmodo de administración de esas tareas elementales. En el contexto de las CPUs, estas ta-reas elementales son operaciones que básicamente se pueden englobar en lassiguientes categorías:

.LECTURA de datos en un sitio establecido. .ESCRITURA de datos en el mismo u otro sitio. .OPERACIONES ARITMETICAS Y LOGICAS BASICAS con y entre datos. .CONTROL DE SECUENCIA de los programas.

Cabe reiterar que no son sino combinaciones adecuadas de estos mismos muyescasos bloques básicos las que dan lugar a los muy diversos programas de usodiario en las computadoras. También cabe asombrarse del hecho que esto seaasí.

La memoria está destinada a contener, justamente, la mencionada lista detareas que organiza y articula a las acciones elementales, así como amantener algunos resultados intermedios que pudieran ser de interés paraalcanzar la meta final propuesta en el programa.

La unidad de entrada/salida (I/O) es la que vincula a todo el conjuntoanterior con el mundo exterior. De nada serviría un sistema como el descriptosi no fuera posible ubicar, desde el exterior, un programa en la memoria.Tampoco sería de utilidad un sistema de cómputo que, eficiente o no, fueraincapaz de interactuar con el exterior, tanto para comunicar los resultadoscomo para hacerse de los datos a procesar.

Sin dejar de tener en cuenta componentes tecnológicos, es claro que va aresultar de primordial importancia la tarea intelectual de concebir programasque alcancen sus fines previstos haciendo un uso INTELIGENTE de los recursosdisponibles. Esto es, para nada sirve contar con la computadora más poderosasi no se la usa adecuadamente, y son los programas los que consiguen, o no,estos propósitos. Y son los programadores los respondables de que ocurra unacosa o la otra.

Componentes básicos de un sistema de cómputo: hardware y software-----------------------------------------------------------------

La arquitectura de un sistema de cómputo es una descripción en bloquesfuncionales de sus partes principales y del modo en que las mismas estánvinculadas e interactúan. De más está decir que cada módulo es un subsistemafactible de ser descripto, a su vez, a través de su arquitectura interna.I.e., cada módulo o subsistema está compuesto, internamente, por otrosmódulos que interactúan entre sí. Esto da lugar a que, por ejemplo, cadaparte de la arquitectura esté compuesta por

+---------------------------------------+ ¦ +--------------+ +-----------+ ¦ ¦ ¦ ã----Á ¦ ¦ ¦ ¦SubSistema 1 ¦ ¦SubSist. 2 ¦ ¦ ¦ +------Ê-------+ +-----------+ ¦ ¦ ... ¦ ...-----> ¦ Sistema o <----... ¦ +------ð-------+ ¦ ¦ ¦ ¦ Módulo ¦ ¦ ¦SubSistema n ¦ ¦ ¦ +--------------+ ¦ +---------------------------------------+

i.e., cada descripión está sujeta a ser refinada (descripta en mayor detalle)mediante un mecanismo análogo.

Cada subsistema de los comentados puede ser identificado con una parteconcreta, dispositivo o conjunto de dispositivos de una computadora. Todoslos componentes que, individualmente o en grupos, conforman la arquitecturafísica de una computadora se engloban como el 'HARDWARE' de la misma. Sonparte del hardware circuitos integrados (chip) de memoria, el microprocesador(CPU), un teclado, un monitor, etc., etc., etc.

Pero vimos que existe otro componente de no menor importancia para darsentido a un sistema computado. Se trata de los programas. Los mismos, que asu vez, veremos, son factibles de ser también descriptos medianterefinamientos sucesivos, se engloban bajo el término 'SOFTWARE'.

Si bien el harware y el software son entidades independientes, ningunatiene sentido práctico sin la otra. De nada sirve un programa sin unacomputadora para poder ejecutarlo ni una computadora sin programas parainstruir a sus componentes físicos sobre cómo desarrollar una tarea.

Hardware--------

+-----------------------------------------------------------------------+ ¦ ADVERTENCIA (OTRA MAS...) ¦ ¦ ¦ ¦ Dada la velocidad de avance de la tecnología es imposible mantener ¦ ¦ actualizadas las tablas que, en este título, pretenden, justamente, ¦ ¦ reflejarla. Aunque esto suene a contrasentido, de las citadas tablas ¦ ¦ se puede entrever un tendencia, y tan buena ha probado ser esta ¦ ¦ extrapolación que ha sido objeto de bautizmo: Ley de Moore. La misma, ¦ ¦ aun cuando completamente empírica, permite anticipar la velocidad de ¦ ¦ avance de la tecnología de integración digital, base tecnológica de ¦ ¦ la edad de la informacion. ¦ ¦ ¦ ¦ Las tablas están actualizadas, aproximadamente, a 1993... ¦ +-----------------------------------------------------------------------+

Se presentan listas típicas de los componentes de cada uno de los módulosprincipales de la arquitectura física de una computadora.

La CPU (el procesador) está constituida por un chip especial denominadomicroprocesador que, para la generalidad de las PCs IBM(R) compatibles es detipo 80x86 (8086, 80286, 80386, 80486, Pentium), más algunos subsistemas deapoyo. La CPU es capaz de tomar (LEER, una de las operaciones elementales queel procesador conoce) una instrucción (cada una de las ordenes elementales quecomponen un programa), interpretar su propósito y ejecutarlo, para luegorepetir con la próxima. Este proceso ocurre automática e ininterrumpidamentedesde el inicio de un programa hasta su finalización (de más está decir,entonces, que una de las instrucciones debe preveer la finalización de losprogramas). Al tratarse de un dispositivo electrónico, esta maniobra de leery ejecutar instrucciones elementales se desarolla incansablemente y a granvelocidad, como vimos, características deseables para un sistema de cómputo.Como ya se ha dicho, por otra parte, cada instrucción yace en la memoria.

La tabla que continúa pone de manifiesto la velocidad con que latecnología progresa y explica en parte la gran inserción actual de lossistemas personales de cómputo, responsable en parte de la llamada era de lainformación en la que a fin de siglo nos vemos involucrados.

Fecha de Precio de Precio actual MIPS Cantidad de µProc. Lanzamiento Lanzamiento (???-??) Transistores +-------------------------------------------------------------+ 8086 ¦ Jun. 78 ¦U$ 360 ¦-- ¦.33 a ¦29000 ¦ ¦ ¦ ¦ ¦.75 ¦ ¦ +-------------+------------+--------------+-------+-----------¦ 80286 ¦ Feb. 82 ¦U$ 360 ¦U$ 8 ¦1.2 a ¦134000 ¦ ¦ ¦ ¦ ¦2.66 ¦ ¦ +-------------+------------+--------------+-------+-----------¦ 80386 ¦ Oct. 85 ¦U$ 299 ¦U$ 91 ¦5 a ¦275000 ¦ ¦ ¦ ¦ ¦11.4 ¦ ¦ +-------------+------------+--------------+-------+-----------¦ 80486 ¦ Ago. 89 ¦U$ 950 ¦U$ 317 ¦20 a ¦1200000 ¦ ¦ ¦ ¦ ¦54 ¦ ¦ +-------------+------------+--------------+-------+-----------¦ Pentium ¦ Mar. 93 ¦U$ 900 ¦ ?????? ¦112 ¦3100000 ¦ +-------------+------------+--------------+-------+-----------¦ ??????? ¦ ??????? ¦U$ ???? ¦ ?????? ¦????? ¦??????? ¦ +-------------------------------------------------------------+

Como se ve, cada vez más potencia de cómputo por un costo relativoinferior. Esto no es sino consecuencia de volúmenes de venta, y enconsecuencia, de producción, crecientes a gran velocidad.

La memoria está constituido por un conjunto de chips que, como sistema,presentan la capacidad de almacenar instrucciones y datos. La misma puede servista como una secuencia de casilleros INDIVIDUALIZABLES mediante unidentificador denominado 'dirección'. Así, cada uno de estos casilleros oceldas numeradas destinadas a contener una instrucción elemental o un datoPUEDE SER DISTINGUIDA INEQUIVOCAMENTE DE LAS DEMAS, del mismo modo que, porejemplo, una dirección postal individualiza a un edificio en una ciudad.

----------------------------------------------- ... ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ... ---------------------------------------------- 5 6 7 8 9 10 11 12 13 14 15 16 17 18

El sistema de memoria, al ser programada la computadora, resulta ESCRITOdesde el exterior con el programa, el que al ejecutarse, es LEIDO por la CPU.

Pero el sistema de cómputo es, en el fondo, un sistema eléctrico por lo quedebe mantenerse conectado a la línea de alimentación eléctrica y encendido siha de funcionar. Cuando se suprime la alimentación eléctrica, la CPU deja deoperar y la memoria pierde su contenido (se borra). Podría pensarse que,entonces, cada vez que se re-enciende la PC hay que re-escribir la memoriacon los programas desde el exterior. Y ésto sería cierto si el sistema dememoria no contara con un subsistema de memoria secundaria capaz de mantenera los programas aún sin la asistencia de alimentación eléctrica. Esesubsistema, caracterizado como discos rígidos, diskettes, cintas, etc., basasu funcionamiento en propiedades magnéticas similares a las de los cassettesde audio que, como es público y notorio, no se borran cuando se corta la luz.Al subsitema de memoria compuesto por chips se lo suele denominar memoriaprincipal o primaria, para distinguirlo de la secundaria mencionada. Cabríapreguntarse, dada la interesante propiedad de la memoria secundaria, para quéhay memoria primaria ? Por qué no lee el procesador las instrucciones de losprogramas directamente de la memoria secundaria ? La memoria primaria esmiles de veces mas rápida que la secunadria. I.e., puede ser leída y/o escritaa mucha mayor velocidad. De poco serviría una CPU que ejecute muy rápidamentelas instrucciones si leer cada una insume un tiempo mucho mayor (se recuerdaque la CPU ejecuta solo una instrucción por vez y, a cada paso, debe recuperardel sistema de memoria la siguiente sentencia a cumplir). Las velocidades deambos subsitemas, CPU y memoria, deben ser comparables para que el conjuntosirva. Así, cada tipo de memoria presenta ventajas y desventajas.

Velocidad Capacidad Dependencia con de lectura de almace- la alimentación /escritura namiento eléctrica +----------------------------------------+ Memoria 1aria. ¦ alta ¦ baja ¦ total ¦ +-----------+-----------+----------------¦ Memoria 2aria. ¦ baja ¦ alta ¦ independiente ¦ +----------------------------------------+

Medidas típicas aproximadas para PCs actuales (????-??) son:

Velocidad Capacidad Costo (Seg) (MBy) U$/MBy +----------------------------------+ Memoria 1aria. ¦ 10e-6 ¦ 1..32 ¦ ¸ 80 ¦ +-----------+-----------+----------¦ Memoria 2aria. ¦ 10e-3 ¦ 40..500 ¦ ¸ 1.3 ¦ +----------------------------------+

La política general de uso del sistema de memoria es la siguiente: losprogramas se mantienen en memoria 2aria. hasta que deben ser ejecutados.Cuando ésto ocurre son copiados a la principal, que es la que está envinculación directa con al CPU.

Para finalizar con el sistema de memoria, los medios de almacenamientomasivo (como también se suele denominar al sistema 2ario.) se hanpopularizado mayormente como díscos rigidos y diskettes. Una tabla

comparativa de los mismos es la siguiente:

Velocidad Capacidad Costo Removible (Seg) (MBy) (U$/MBy) +---------------------------------------------------+ Disco rígido ¦ 10e-3 ¦ 40..1200 ¦ ¸ 1.3 ¦ NO ¦ +--------------+-------------+---------+------------¦ Diskette ¦ 10e-2 ¦ 0.36..2.88 ¦ ¸ 0.8 ¦ SI ¦ +---------------------------------------------------+

Como se ve, la ventaja descollante que presentan los diskettes frente a losdiscos rigidos es el hecho de ser removibles. I.e., un diskette puede serretirado de la PC una vez usado a fin e ser almacenado o transladado a otrositio mientras que para quitar y/o instalar un disco rígido, la PC debe serdesarmada. Existen discos rígidos removibles y unidades de cinta de grancapacidad de almacenamiento, pero sus razones costo/beneficio aún nocontrapesan al par disco rígido-diskette, al menos para la generalidad de loscasos.

En estos días se ha venido popularizando el uso de CD-ROMs. Los mismosson unidades de almacenamiento secundario de muy alta capacidad (llegandoincluso al orden de los GBy (10e9 By) y muy pequeño tamaño (el de un discocompacto de audio)). En general son unidades de sola lectura (sólo puedeser leída la información y programas que una fábrica ha estampado en ellos)y su uso más generalizado se orienta hacia la presentación de informaciónen forma de multimedio (texto, audio, imágenes y video). Un dispositivoespecial debe ser instalado en las computadoras para poder leerlos (drive deCD-ROM).

El tercer módulo de hardware presentado es la unidad de entrada/salida,que permite vincular a las anteriores (CPU y memoria) con el exterior. Lamisma puede asumir varias formas diferentes, las más populares, teclado ymonitor, cada una en sus diversos tipos. Las posibilidades son varias, porejemplo:

+--------------------------------------------+ ¦Entrada ¦Salida ¦ +----------------------+---------------------¦ ¦Teclado ¦Monitor ¦ ¦Mouse ¦Impresora ¦ ¦Palette ¦Plotter ¦ ¦Light pen ¦Modem (datos, fax) ¦ ¦Touch Screen ¦DAC (actuadores) ¦ ¦Modem (datos, fax) ¦Parlante ¦ ¦ADC (sensores) ¦ ¦ ¦Micrófono ¦ ¦ ¦Scanner ¦ ¦ ¦Cámaras de video ¦ ¦ ¦Cámaras fotográficas ¦ ¦ +--------------------------------------------+

A través de éstos, las materias prima y elaborada de la cadena de cómputose vincula con los sistemas que procesan una para obtener la otra.

NOTA: En estos últimos párrafos se han mencionado unidades de medida de capacidad de memoria (By algunos múltiplos, KBy, MBy y GBy), de tiempo(Seg y algunos submúltiplos, mSeg, uSeg) y de velocidad (Hz y su múltiplo,MHz), y en todos los casos se ha han presentado comparaciones tratando dereflejar la evolución histórica de los sistemas personales de cómputo y dedistintos dispositivos con funciones similares entre sí a los efectosjustificar su existencia. Pero más allá de estas comparaciones es importantepercibir la real diferencia que representan los distintos de órdenes demagnitud en la dimensión de una variable. Por ejemplo, la diferencia entre 1Seg y 1 mSeg es mil veces -vaya novedad!-. Y cuánto representa "mil veces"menos ? Por ejemplo, la distancia entre Bahía Blanca y Buenos Aires es deunos 700 Km. Mil veces menos son unos 700 m, es decir siete cuadras... LaTierra da un giro completo en su órbita cada 365 días (un año). Mil vecesmenos equivale a 8.76 hs, es decir poco más de un tercio de UN día... Y lacomparación contra un uSeg (una millonésima de segundo) es aún más drástica.

Una millonésima parte de la distancia entre Bahía Blanca y Buenos Airesequivale a 0.7 m, es decir 70 cm, es decir, poco más de tres baldosas. Yrespecto de los 365 días equivale a 31.536 Seg, es decir, apenas excede almedio minuto. En la dirección contraria basta invertir los términos: un KBycoresponde a mil veces un By y un MBy a un millón de By. Y si hubiera dehacerce la comparación entre un By y un GBy (mil millones de By), bastaríadecir que mil millones de segundos son la pequeña cantidad de 277777.77777...hs, es decir 11574.07 días, es decir 31.71 años. Im-pre-sio-nan-te, no ?

Software--------

Hemos dicho entonces, resumiendo, que en un medio de almacenamiento masivoresiden los programas que, al momento de ser usados, son copiados a lamemoria principal. Hecho esto, la CPU comienza a leer y ejecutar, instrucciónpor instrucción, hasta que el programa termina, requiriendo entretanto losservicios de los dispositivos de entrada/salida para solicitar datos yarrojar resultados.

Cómo se armoniza todo esto ? Cómo se controla qué debe ocurrir a cadamomento a fin de que el planteo anterior funcione ? De esto se encarga elsoftware. Está sobre el software la responsabilidad de administrar el usoarmónico de los recursos de hardware de la PC. Para esto, coexisten distintosniveles entre los que es repartida la responsabilidad mencionada.

+------------+ ¦APLICACIONES¦ +------------------+ ¦SISTEMA OPERATIVO¦ +----------------------+ ¦ ROM BIOS ¦ +----------------------+ --------- H A R D W A R E----------------------------

Para interpretar el diagrama anterior debe previamente aclararse elsignificado que, en el contexto que nos ocupa, se da al término'abstracción'. Cuando se presentó la arquitectura básica de una PC seesquematizaron tres bloques principales (memoria, CPU e I/O). Si con sólotres bloques se completa la funcionalidad de una PC se entiende que cada unoes capaz de desarrollar un número importante de tareas complejas o de altonivel de 'abstracción' o complejidad. Dijimos que, en realidad, cada bloqueestaba constituido internamente por subsistemas intercomunicados. Es naturaly correcto suponer que cada subsistemadesarrolla, entonces, una tarea más sencilla, de menor nivel de abstracción ocomplejidad, y que reside en el trabajo cooperativo y sinergético el mayornivel de abstracción que el sistema más general presenta. Lo mismo esaplicable si cada subsistema se despliega en sub-sub-sistemas, y asísiguiendo... Es evidente que lo que inicialmente se describía en tres móduloscon tareas complejas (alto nivel) termina siendo un gran encadenamiento debloques, cada uno de los cuales desarrolla una porción muy pequeña y concreta(bajo nivel).

Otro ejemplo más cotidiano. Siendo que alguna vez lo hayamos usado o no,en general todos sabemos qué es, para qué sirve y cómo se usa un walkman. Sinduda, este conocimiento basta para que sea algo de alguna utilidad. En basea la misma nos basta verlo como una cajita negra en la que se ubica uncassette de audio, se le colocan pilas y, puesto en marcha, produce sonido.Habrá, sin embargo, quien es más curioso y desea saber cómo es que semejantedispositivo transforma pilas y cintas en música. Si ese es el interés, esnecesario explicar que, en el interior de esa cajita, y alimentadoeléctricamente por las pilas -que para eso están- hay, entre otras cosas, unmotorcito eléctrico y un pequeño amplificador electrónico de audio. Cuando sepone en funcionamiento el sistema, el motorcito hace que la cinta se desplace.Al moverse la cinta, que tiene impresa una señal magnética grabada en lafábrica, produce un campo magnético variable, función de lo grabado y de suvelocidad de desplazamiento. Enfrentado este campo variable a un sensor muysensible, se induce una corriente eléctrica proporcional que, amplificada porel amplificador, alcanza un nivel suficiente para energizar a los auriculares,produciéndose así el sonido. Puede ser que nuestro audiófilo aún no este

conforme y desee saber cómo se obtiene el sonido a partir de una señaleléctrica tal cual es obtenida del amplificador. Hay que explicar, entonces,que esa corriente variable en función de la señal magnética primitiva se hacecircular por una pequeña bobinita, adherida a una pieza móvil muy liviana ytodo inmerso en un campo magnético fijo. Al ser constante el campo magnéticoy variable la corriente circulante, la bobinita que la conduce se ve sometidaa una fuerza que tiende a desplazarla, y como está adherida a una piezaliviana y móvil, se desplaza. Si este desplazameinto ocurre a la suficientevelocidad (entre 100 y 20000 veces por segundo), el aire alrededor de estapieza móvil se ve impactado con ondas de sonido, que son las que llegan aloído como tal.

Se podría seguir profundizando la explicación del funcionamiento de cadaparte pero, para el propósito buscado, basta. Se destaca que se han idodelinenado niveles de abstracción en la explicación: primero era una cajitanegra. Luego, en su interior, un motor, amplificador y pilas, habiendo,finalmente, llegado en un tercer nivel al principio de funcionamiento delauricular. Cabe reflexionar en dos aspectos. Por un lado que, al irincrementando el nivel de detalle cada descripción se va desarrollando entérminos más elementales. Tanto es así que, alcanzada la profundidad deexplicación necesaria, cualquier individuo debería ser capaz de entender cómoy por qué funciona el walkman. Esto es positivo. Claro, el segundo aspecto aobservar no lo es tanto. Seguramente el leector, si acaso ha alcanzado a leertodo el párrafo descriptivo antes de darse por vencido, ha notado que, cuantomayor es el nivel de detalle, mayor es la cantidad de texto necesaria, y mayorla cantidad de cosas que se han de mantener en mente y a las que se ha deestar atento para conservar la coordinación de los conceptos que da sentido ala idea general. Efectivamente, de no ser por esto último, y de contar con eltiempo necesario, todos podríamos aprender y entender todo. Lamentablemente,ni contamos con tanto tiempo ni somos capaces de no perdernos entre tantosdetalles. No ocurre ésto con los sistemas de cómputo. Disponen de todo eltiempo necesario y no se cansan. No distinguen entre grados de detalles y sólose ajustan a la lista de instrucciones que les son provistas.

En lo que al software respecta, en un extremo están las 'aplicaciones'del diagrama anterior. Son los programas de usuario (editores de texto,planillas de cálculo, bases de datos, graficadores, CAD, CAE, etc., etc.,etc.) que desarrollan un trabajo completo, descriptible en un alto nivel (dehecho, unas pocas palabras bastan para declarar su propósito). En el otroextremo el hardware, cuyos recursos deben ser debidamente utilizados para quelos programas cumplan con su cometido. Los niveles o capas intermedias, enlas que el nivel de abstracción de sus partes constructivas es menor en tantoestán más cercanas al hardware, sirven como un sistema de aislacionessucesivas entre niveles que, separando uno de otro, descomponen una tareacompleja en partes más sencillas.

La ROM BIOS (Read Only Memory - Basic Input Output System) es un chip dememoria interna de exclusiva lectura presente en toda PC cuyas característicasson:

.Muy baja capacidad .Muy alta velocidad de lectura .No volatilidad

Esta memoria es grabada en fábrica, no es posible borrala (al menos para elcomún de los usuarios de PCs), y cada modelo de PC tiene una diferente. LasROM BIOS contienen una serie de pequeños programas muy elementales quepermiten desarrollar acciones básicas sobre los dispositivos standard delhardware (por ejemplo, hay pequeños programas independientes para escribir uncaracter en la pantalla; para leer una tecla del teclado; para escribir oleer una unidad de datos a/de un diskette; etc.). Dado que, dentro delos límites de la compatibilidad con el standard PC, cada fabricante puedeintroducir leves modificaciones en el hardware, ha de proporcionar también elsoftware básico que 'sabe cómo manejar' ese hardware específico. El envase enque ese software a medida es entregado es la ROM BIOS. Las instrucciones deesos programas elementales son las básicas que el procesador conoce.

El Sistema Operativo (SO o DOS, -Disk Operating System-) es una capaintermedia que vincula a las aplicaciones con los programas en ROM BIOS.El SO es una pieza de software que ofrece servicios para la gestión de

dispositivos lógicos. Cabe entonces una aclaración sobre este último término.Los programas que residen en la ROM BIOS actúan sobre dispositivos físicos(drives de diskettes, monitor, teclado, etc.). Dado que los dispositivosfísicos no siempre son iguales en todas las PCs, la ROM BIOS ofrece losservicios necesarios como para standarizar su acceso. Cuando los dispositivosfísicos, del tipo y modelo que fueran, han de ser vistos desde un nivel másabstracto, se los ve como 'dispositivos lógicos'. Los mismos pueden ser dedos tipos predefinidos standard y cualquier tipo de dispositivo físico,existente o aún por existir, puede encuadrarse dentro de uno de ambos. Estafilosofía de trabajo, si bien puede resultar un tanto oscura, ha conducido ala actual popularidad de las PCs por lo que no debe ser considerada como undetalle menor. Además, el DOS ofrece todos los servicio necesarios para lagestión de datos (lectura y escritura) en forma de archivos dentro de unsistema de discos; para la coordinación en el uso armónico de los recursos dela PC; para crear las condiciones iniciales necesarias para el trabajo cadavez que la PC es (re)encendida (Boot Sequence); y para ejecutar la intefacecon el usuario, imprescindible para que el operador del sistema puedasolicitar sus servicios a través de comandos desde un dispositivo de entrada(por ejemplo, el teclado).

Resumiendo:

+------------------------------------------------------------------------+ ¦Capa ¦ Contiene ¦Ofrece ¦ +--------+----------------------+----------------------------------------¦ ¦Hardware¦ Dispositivos físicos ¦.La realización de los trabajos. ¦ +--------+----------------------+----------------------------------------¦ ¦ROM BIOS¦ Programas básicos ¦.Servicios de acceso (lectura y ¦ ¦ ¦ de acceso a los dis- ¦escritura) a los diversos dispositivos ¦ ¦ ¦ positivos físicos ¦físicos específicos. ¦ +--------+----------------------+----------------------------------------¦ ¦DOS ¦ Funciones de nivel ¦.Servicios de acceso (lectura y ¦ ¦ ¦ medio para acceso ¦ escritura) a los dispositivos lógicos. ¦ ¦ ¦ standard a disposi- ¦.Servicios para la gestión de archivos ¦ ¦ ¦ tivos lógicos y ges- ¦ en el sistema lógico de discos. ¦ ¦ ¦ tión de datos. ¦.Servicios para la inicialización de la ¦ ¦ ¦ ¦ PC. ¦ ¦ ¦ ¦.Armonización de los dispositivos de la ¦ ¦ ¦ ¦ PC. ¦ ¦ ¦ ¦.Interface con el usuario. ¦ +--------+----------------------+----------------------------------------¦ ¦APLICs. ¦Lógica interna para ¦.Editores de texto. ¦ ¦ ¦la gestión de datos ¦.Planillas de cálculo. ¦ ¦ ¦y el uso de los ser- ¦.Bases de datos. ¦ ¦ ¦vicios del DOS. ¦.Programas de cálculo numérico. ¦ ¦ ¦ ¦.Programas para diseño y simulación. ¦ ¦ ¦ ¦.Etc., etc., etc. ¦ +------------------------------------------------------------------------+

La PC actual------------

En la actualidad (1993) el exponente más encumbrado en la línea de lasPCs es la que tiene en su corazón al microprocesador Pentium(R) de Intel. Enorden de precedencia, los procesadores anteriores fueron el 8088/86 (en la PCoriginal, a principios de los 80), luego el 80286, el 80386 y, anterior alPentium, el 80486. Cada modelo sucesivo fue trayendo consigo mayor velocidadde procesamiento y mayor capacidad de uso de memoria. Agregado a esto se debemencionar que diversos fabricantes fueron, y siguen, liberando al mercado muydiversos tipos de dispositivos "implantables" en las PCs a fin de aumentarsus posibilidades, todos ellos destinados a ampliar el espectro deprestaciones en el rubro entrada/salida de datos. Esto se traduce endiferentes sistemas de video (para utilizar monitores de resolución,velocidad y contenidos cromáticos crecientes); procesadores de video;procesadores de sonido; procesadores de comunicaciones; redes; multimedios;etc., etc., etc.

--------------------------------------PARTE II-------------------------------

Problemas y Programas

---------------------

Un problema es, en general, un aspecto de la vida real cuyas condiciones ylimitaciones lo hacen inconveniente. Para "quitarlo del camino" se busca unasolución al mismo la que, planteada, se intenta luego llevar a cabo. En todoslos casos, como ya se ha dicho, es necesario adoptar un mecanismo de ejecucióno procesador capaz de entender y ejecutar la solución esbozada.

La forma de la solución propuesta depende de la idea que del problema realse tenga. Es importante distinguir entre el problema real y la idea que de élse tenga. A la idea con que se concibe a un problema la denominamos MODELO.Siempre se buscan soluciones a los problemas en términos de sus modelos, estoes, en base al grado de comprensión y conocimiento que de ellos se tenga.Un modelo podria clasificarse como CORRECTO O INCORRECTO y, para el primercaso, en COMPLETO O INCOMPLETO.

+----------+ +--¦incorrecto¦ +------+ ¦ +----------+ ¦modelo+-¦ +------+ ¦ +--------+ +----------+ +--¦correcto+----¦completo ¦ +--------+ ¦ +----------+ ¦ +----------+ +--¦incompleto¦ +----------+

Un modelo INCORRECTO es aquel que no responde a la realidad que intentamodelar. Por ejemplo, en ningún caso tendrá sentido expresar o modelar alpeso de un cuerpo como una función trigonométrica de su masa. Enconsecuencia, cualquier evaluación que desee hacerse a partir de ese modeloincorrecto está irremediablemente destinada a fracasar. (Cabe recordar quepeso = masa * aceleración de la gravedad). Mal predestinado está unparacaidista que suponga que, por acción de la gravedad, los objetos, enlugar de caer, se elevan.

En cambio, un modelo CORRECTO, va a representar a la realidad de unproblema con éxito. Pero la realidad suele ser demasiado complicada y, en lamedida que mayor cantidad de sus aspectos han de ser tenidos en cuenta, elmodelo adoptado va ganado en complejidad. De más está decir que un modeloperfecto puede ser tan complejo que su uso sea totalmente impráctico ydesaconsejable. A fin de simplificar los modelos se debe, entonces,restringir la cantidad de aspectos -nivel de detalle- tenidos en cuenta,recortándose desde los detalles más ínfimos hasta los más representativos. Esfácil deducir que, cuanto menos características sean tenidas en cuenta, tantomás sencillo será el modelo aunque, por supuesto, se irá alejandopaulatinamente de la realidad que intenta representar, por supuesto, ariesgo de pasar a la categoría de incorrecto. Y donde está el límite en estapuja de costo/beneficio ? Ese límite está dado, justamente, por la eleccióndel nivel de detalle que sea de utilidad para el propósito perseguido. Porejemplo, sabemos que cualquier masa, por alejada que esté, ejerce unaatracción gravitatoria sobre todo el resto de los cuerpos del Universo.Claro, si la distancia es suficientemente grande o las masas involucradassuficientemente pequeñas, el efecto aludido puede ser despreciable. La Luna,aunque distante, es capaz de influir, y en medida para nada despreciable, enlas mareas terrestres. La relación distancia-masas de la Luna y de los mareses suficiente como para que esa acción sea importante. La misma Luna tambiénejerce su acción sobre el nivel de agua dentro de un vaso que podemos tener amano, pero la relación de masas-distancia en este caso es tan despareja queel efecto, aún cuando no es nulo, pasa perfectamente desapercibido y, paratodos los fines prácticos, es considerado nulo o inexistente. Esta últimaconsideración implica que en un modelo de ese nivel de agua, los aportes dede la masa lunar son descartables y, si bien el modelo no corresponde a larealidad con exactitud, la aproxima razonablemente bien para todos los finesprácticos. Para esos fines prácticos, el modelo es completo. Pero si el mismocriterio es aplicado al nivel del mar, la simplificación ya no es válida y dalugar a un modelo incompleto. Se obtendrían resultados parecidos a losreales, pero con errores de importancia.

Un aspecto a tener en cuenta al elaborar un modelo es la información con

que se cuenta de la realidad. Información incompleta díficilmente pueda darlugar a un modelo completo. Por ejemplo, en tiempos de Cristóbal Colón sesuponía plana a la Tierra. Los mapas de ese tiempo (modelos de la Tierra, laidea que de la misma se tenía) estaban elaborados a partir de informaciónincompleta. De más está decir que si Cristóbal Colón hubiera tenido a esosmodelos por fidedignos díficilmente este texto hubiera sido escrito. Engeneral, vamos a asumir que la realidad que se pretende modelar se conocesuficientemente bien como para confiar que un modelo supuestamente correctolo es.

Podemos deducir finalmente que, si bien la correctitud de un modelo esrelativamente fácil de verificar (mediante experimentación), su completitudofrece una frontera mucho más ancha y gris, dependiendo la misma del uso quese desee hacer de los resultados (esta verificación también se vale deexperimentos pero su diseño y análisis de resultados debe ser mucho máscuidadoso). De más está decir que del mismo problema real se pueden plantear,entonces, varios modelos.

Cómo saber cuándo se ha alcanzado a plantear un modelo correcto ysuficientemente completo ? Esa respuesta la puede dar el razonamiento, pero lapalabra final la tiene la corroboración práctica. De un modo u otro, elmodelado es un tema con entidad científica propia cuyo estudio amerita de uncompleto estudio, muy lejano de ser desarrollado en este texto.

Las soluciones que se proponen para un problema van a estar en relacióndirceta, como se dijera, con el modelo que se ha planteado. Para un modeloincorrecto de poco vale plantear alguna solución. Cualquiera sea ésta, losresultados solo arrojarán sombras. En cambio, si el modelo es correcto, elcamino hacia el éxito está abierto. Pero el conjunto de las soluciones admiteuna clasificación similar a la de los modelos: CORRECTAS o INCORRECTAS,COMPLETAS o INCOMPLETAS.

Una solución incorrecta dará lugar lugar a resultados no verificables enla realidad, ni siquiera cercanamente. Una solución correcta, en cambio,ofrece correlación con la realidad a menos de errores, la mayor parte de lasveces predecibles y/o acotables. Dentro de la soluciones correctas, lascompletas son aquellas que dan respuesta a cualquier aspecto del problemamodelado y solucionado. Las incompletas, aún cuando correctas, no dan todaslas respuestas. Tenemos entonces:

+---------------------+ +-------------------+ ¦modelo correcto ¦ +-¦solución incorrecta¦ ¦completo o incompleto+---¦ +-------------------+ ¦ ¦ ¦ +-------------------+ +-------------------+ +---------------------+ +-¦solución correcta +---¦solución completa ¦ +-------------------+ ¦ +-------------------+ ¦ +-------------------+ +-¦solución incompleta¦ +-------------------+Algoritmos----------

Planteado todo este panorama que, conceptualmente, es mucho más sencilloque lo que parece a primera vista, decimos que, dado un problema del que seelabora un modelo o, directamente, dado el modelo de un problema, plantearemossoluciones al mismo en términos de 'algoritmos'. Un algoritmo es una listafinita de pasos, el resultado de cuya ejecución desemboca en una solución alproblema. Esto es, un algoritmo corresponde a la descripción de la dinámica deun proceso con adecuado grado de detalle. Como cualquier proceso, estávinculado a un estado de las cosas antes y después de su ejecución. Alconjunto de estados previo y posterior a la ejecución de un proceso lodenominaremos 'ambiente' o 'contexto' del proceso. Si la solución ha deejecutarse mediante un método automático, como es el caso de una computadora,un 'programa' ha de ser implementado de modo que refleje esa lista de pasos oinstrucciones, de acuerdo a un formalismo preconvenido. Ese formalismo sedenomina 'lenguaje de programación' y define una serie de normas para laescritura e interpretación de la lista de pasos. Por qué ha de haber reglaspara la descripción de los pasos que hacen a un algoritmo ? Porque esealgoritmo está destinado a ser ejecutapor algún mecanismo (natural oartificial) y, a tal fin, debe ser puesto en términos que el mecanismo

ejecutor comprenda. Es así que definimos lo siguiente:

* Un PROCESADOR es un dispositivo capaz de entender y ejecutar un enunciado (acción) elemental (primitiva). Evidentemente la calidad de "primitiva" de una acción es absolutamente dependiente del procesador considerado: la que para un procesador puedo serlo, para otro no.

Por ejemplo, si el problema consiste en cambiar una cubierta a un vehículo,una posible lista de pasos podría ser la siguiente:

Detener el vehículo. Poner el vehículo en cambio. Obtener la rueda de auxilio, una llave y un crique. Aflojar las tuercas de la rueda a cambiar con la llave. Colocar el crique debajo del vehículo y elevarlo hasta que la rueda a cambiar quede suficientemente separada del suelo. Terminar de quitar la tuercas de sujección con la llave. Reemplazar la cubierta. Colocar nuevamente las tuercas. Liberar al crique para que la rueda vuelva a apoyar en el suelo. Fijar las tuercas con la llave. Guardar la rueda, la llave y el crique.

Se puede intuir que esta lista de pasos, si bien se encuadra dentro de lodicho para un algoritmo, difícilmente corresponda a un programa decomputadora (al menos una de los modelos populares). Aun así, si hubiera unrobot -que, entre otras cosas, debe tener alguna capacidad computacional-capaz de entender cada una de las frases propuestas, posiblemente le bastaranpara aprender a solucionar el problema.

La ejecución de una acción no primitiva necesita previamente de sudescomposición en una serie de primitivas cuya organización dé como resultadoel esperado de la acción no primitiva inicial. Por ejemplo, si quitar unneumático no es una primitiva, se puede descomponer en:

colocar la llave en la 1er. tuerca repetir quitar la tuerca en que está la llave. desplazar la llave a la siguiente tuerca mientras haya tuercas para quitar desalojar al neumático.

y si 'quitar la tuerca en que está la llave' no es aún una primitiva se puedereemplazar por:

repetir girar la llave en sentido antihorario un determinado ángulo mientras no se haya salido la tuerca de la espiga

Otro ejemplo. Hoy en día se comercializan muebles desarmadosindustrializados. Se distribuyen en cajas en cuyo interior están las partesseparadas, (tablas, patas, rueditas, etc.), los elementos de ensamblaje(tornillos, bujes, etc.) y, muy importante, las instrucciones. Supongamos queuna persona compra dos muebles iguales del tipo descripto pero que solodifieren en la hoja de instrucciones. La hoja de una de las cajas tiene todoslos pasos con lujo de detalles para el armado del mueble y, la otra, una hojaque una sola instrucción que reza "armar el mueble" (!). Digamos que son lascajas A y B respectivamente.

Si la persona desea armar ambas mesas y tiene la suerte de comenzar por lacaja A, las instrucciones de la B no pasarán de llamarle la atención pero,aún asi, no le impediran concretar su meta: armar ambas mesas. En cambio, siprincipa por la caja B se verá imposibilitado de alcanzar con éxito ambosarmados.

Qué ha cambiado en cada caso ? En el 1er. caso la mesa B no es armada por"el mismo" mecanismo ejecutro que la A. Durante el armado de la A, nuestroamigo aprendió algo (cómo armar la mesa, dado que las instruicciones de lamesa A eran suficientemente detalladas). Ese cambio hizo que se transformaraen un mecanismo ejecutor distinto al momento de leer las instrucciones de la

mesa B: fue capaz de entender una sola instrucción más abstracta. En cambio,en el 2do. caso, el inicio por la mesa B impide que la persona aprenda aarmar la mesa B lo que altera completamente el panorama.

En definitiva, debe al lector quedar claro que la calidad de lasinstrucciones de un algortimo, su grado expresivo, su abstarcción, es funcióndirecta del grado de comprensión del mecanismo ejecutor.

La descomposición en pasos de mayor detalle y menor grado de abstarcciónque se requiere para explicar algo a un mecanismo de ejecución másrudimentario se denomina 'por refinamientos sucesivos' (o 'análisisdescendente') y consiste en descomponer una acción T en una secuencia t1, t2,...tn equivalente a T. El propósito de la ejecución de cada acción tk en quese descompone una acción T consiste en cambiar el entorno (ambiente), de Eika Ejk. Esto es,

[Ei] T [Ej]

equivale por descomposición a:

[Ei1=Ei] t1 [Ej1=Ei2] t2 [Ej2=Ei3] t3 ... [Ej(n-1)=Ein] tn [Ejn=Ej]

y si alguno de los tk no es primitivo, da origen a una nueva descomposiciónen base al mismo patrón.

La disposición de acciones primitivas organizadas de modo tal que lossucesivos pequeños cambios de ambiente transformen al ambiente inicial en elfinal (deseado) se denomina 'ALGORITMO'. Es importante destacar que paraoperar el cambio deseado en el ambiente pueden idearse un sinnúmero dealgoritmos diferentes, si bien los habrá más o menos eficientes desde laóptica de algún conjunto de recursos cuya utilización se desee optimizar (porejemplo tiempo y/o memoria cuando los algoritmos son implementados comoprogramas de computadora).

La programación consiste en diseñar (tarea eminentemente creativa)algoritmos para resolver problemas con un procesador dado, ajustados a unaserie de restricciones que son de interés optimizar, para luego codificarlosen un lenguaje adecuado (el 'lenguaje de programación') que el procesador seacapaz de entender. Esta segunda fase es fuertemente mecánica mientras que laprimera es casi de creación literaria.

Un aspecto de gran importancia a tener en cuenta en la confección de éstosalgoritmos es que, cualquiera sea su naturaleza, dos tipos básicos deentidades dinámicas los componen: acciones y mediciones. En general, a cadaacción sigue una medición. El propósito de una acción consiste en que unaparte de la realidad resulte modificada; que algo cambie; que haya un antes yun después (no tiene sentido hacer algo que no va a surtir efecto alguno).Pero, en qué magnitud se debe ejercer la acción ? Por cuánto tiempo ? Larespuesta a estas preguntas parte de adecuadas mediciones de los cambios queel desarrollo de la acción causa. En nuestra experiencia diaria muchas deestas mediciones forman parte del sentido común y no las advertimos. Cuandoasimos el picaporte de la puerta nuestro cerebro ordena a la musculatura denuestro brazo que lo desplace y, a medida que nuestra vista informa al cerebrodel curso de aproximación (la medición del efecto), éste va ajustando susórdenes a fin de asegurar el propósito. Es muy fácil ver qué ocurre cuando lamedición no se lleva a cabo: basta intentarlo con los ojos cerrados. En unamaniobra mucho más torpe, necesitamos ponemos en juego un sistema de medidamucho menos preciso: el tacto. Llegamos, seguramente, al picaporte, pero no sepuede negar que todo resulta más ineficiente. Y si, además, inhibimos de algúnmodo al tacto, es casi imposible predecir el éxito de la operación. Del mismomodo, si se mira con atención, se aprecia rápidamente que cada uno de lospasos de nuestro algoritmo para cambiar la cubierta involucra, y puede serdescompuesto, en toda una serie de acciones y mediciones. Volveremos sobreesto más adelante.

Lo mismo un programa de computadora, que intenta formalizar un algoritmo,va a estar compuesto, básicamente, de una serie alternada de acciones ymediciones, una de la cuales, finalmente, permitirá decir que el último cambiogenerado por una acción corresponde al producto final que hace a la meta delprograma. Entonces se debe prever la finalización del programa.

Cabe destacar que cada una de las posibles acciones a que se hacereferencia, independientemente de su complejidad -nivel de abstracción paraun ambiente o entorno dado- no es sino un trabajo, con una materia prima y unresultado, un antes y un después de su ejecución.

Estrictamente hablando, la medición es también una acción: la acción y elefecto de medir (como diría el crucigrama). Antes de la medición no se conoceun valor y después sí. Qué ha cambiado ? Nada en lo que hace al proceso quese mide, aunque sí la disponibilidad de información en un nivel que podríamosdenominar "metafísico" respecto del mismo. La disponibilidad de informacióna este nivel es la que permite tomar decisiones acerca de las futuras accionesa emprender. Desde esta óptica, entonces, todos los componentes de unalgortimo son acciones. Lo que incorporan las acciones de medición, adiferencia del resto de las acciones, es la posibilidad de alternativas, detomar decisiones producto del estado del ambiente que se mide. Básicamente,una acción ejecutiva se puede simbolizar como:

+--------+ materia prima -->-¦ ACCION +-->- resultado +--------+

mientras que una acción de medición se puede esquematizar como:

+-----------+ ¦ +---->--- alternativa 1 ambiente -->--¦ MEDICION ¦ ¦ +---->--- alternativa 2 +-----------+

En general se van a distinguir a las acciones ejecutivas como "acciones"y a las evaluativas o de medición como "mediciones".

Debería estar claro a esta altura que las acciones operan sobre cualquiertipo de entidad (objeto) para la que se las haya concebido (materia, energíao información) (aunque en el contexto computacional casi siempre se trate deinformación), mientras que las mediciones transitan exclusivamente el universode la información. Aún así, y en el contexto de los programas -en los que lamateria prima es información- las acciones solo operan en ese ámbito.

Objetos-------

La modificación de un ambiente sujeto a una acción cambia el estado (almenos una de las propiedades) de un 'objeto'. Los objetos son las entidadescalificadas con, al menos, un nombre que los individualiza, y una serie depropiedades cuyos valores caracterizan e indican el estado y atributos delobjeto. En el contexto de un programa estos objetos (no confundir con losobjetos de la 'programación orientada a objetos') son las 'variables' y las'constantes', contienen la información sobre la que trabajan las acciones yestán representados por un nombre, un tipo, una estructura (organización)interna, una restricción de acceso y, en cada momento, un juego de valores.Cabe como ejercitación verificar que los objetos de la realidad, que muchasveces los programas simulan, están afectados de las mismas características.Cabe también distinguir a modo de ejemplo que los archivos, objetos con losque opera un sistema operativo -que es un programa- están también dotados delos mencionados atributos:

nombre - tipo - organización interna - modo de acceso - valor (o contenido)

Una característica fundamental de los objetos es que sus propiedades sólopueden tener un valor por vez y algunas de ellas, inclusive, no pueden sermodificadas. De hecho, la única propiedad que puede ser modificada (y no entodos los objetos), es el 'valor'. El reemplazo de un valor por otro destruyeal actual. En el contexto de los programas, el contenido del atributo 'valor'de una variable permanece hasta que es reemplazado por otro o hasta que lamisma deja de existir (lo que también es válido para cualquier otro tipo de

objetos).

El propósito por excelencia de los objetos es el de contener información(la moneda de cambio en los dispositivos de cómputo) organizada y, como ya seanticipara, se los halla en dos sabores principales: constantes y variables,ambos con el juego de propiedades descripto.

Las 'constantes' son piezas de información cuya propiedad 'valor' no puedeser modificada por una acción de modo tal que esa propiedad sólo puede serleída pero no escrita. Esto es producto del hecho que su propiedad 'modo deacceso' es de lectura exclusiva, excluyéndose la posibilidad de escritura. Encambio, las 'variables' son objetos cuya propiedad 'valor' sí puede ser tantoleída como escrita (el 'modo de acceso' permite las operaciones tanto delectura como de escritura). Una variable es como una caja en la que puedenalojarse y revisarse datos. Las constantes son cajas pero con tapatransparente: se puede ver su contenido pero no se lo puede cambiar.

Con relación a la propiedad 'nombre', su propósito es dar la posibilidad deindividualizar un objeto respecto de los otros e invocarlo, del mismo modo que'patente' diferencia a los automóviles, aún pudiendo llegar a haber variosidénticos.

La propiedad 'tipo' de los objetos hace mención al tipo básico deinformación que pueden contener. Es así que, dependiendo del lenguaje deprogramación, pueden distinguirse tipos numéricos simples, alfanuméricossimples, subtipos de éstos y tipos lógicos. En algunos lenguajes, de hecho, nose hacen estas distinciones y cualquier objeto puede alojar a cualquier tipode dato de entre los mencionados. La discriminación tiene el propósito deposibilitar un uso más eficiente de los recursos del sistema y de ayudar alprogramdor a prevenir errores (aunque esto último es una circunstanciasubjetiva que depende la experiencia de cada programador).

Finalmente y con relación a la organización interna de los objetos, sehace mención a diversos modos en que se pueden definir objetos simples, quecontienen información en las categorías mencionadas, u objetos más complejosdestinados a modelar realidades más elaboradas. Según esta propiedad, losobjetos se pueden clasificar en

simples - estructurados - vectores

Los primeros corresponden a contenedores de un solo tipo básico de dato: UNentero, UN valor real -en punto flotante-, UNA cadena alfanumérica, etc. Lasotras dos organizaciones son superestructuras basadas en la primera. Las'estructuras' son agrupaciones jerarquizadas de diferentes tipos de datos enUN SOLO envase. Por ejemplo, el documento de identidad de una persona es UNSOLO contenedor de información y, dentro suyo hay mezclada información, almenos, numérica y alfanumérica. No podría representarse esta situaciónutilizando un objeto simple. Sin embargo, uno estructurado, en el que sedefinen compartimientos o parcelas internas, eventualmente de diferentestipos, sí puede ser utilizado con comodidad. Desde una perspectiva gráfica,si un objeto simple es una caja simple de un tamaño único, uno estructurado esuna caja con divisiones internas de diversas magnitudes que pueden alojardiferentes tipos de contenidos, incluso, otros (sub)objetos tambiénestructurados.

+---------+ +--------------------+ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ +--------¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ +---------+ ¦ ¦ ¦ ¦ +--------¦ ¦ ¦ Un objeto simple ¦ ¦ ¦ ¦ +--------------------+

Un ojeto estructurado, con tres campos principales, uno de los cuales es una estructura con otros tres campos.

Por ejemplo, objetos estructurado son adecuados para la representación de

fechas y horas: cada una de esas realidades tiene tres componentesindisolubles (día/mes/año en un caso y hh:mm:ss en el otro). A los componentesde cada uno de estos objetos se los denomina 'campos' y están afectados de lasmismas propiedades que todos los objetos (nombre, estructura interna, tipo yvalor).

Finalmente, el tercer tipo de organización interna que se mencionará sonlos vectores. Estos pueden ser identificados con 'colecciones', i.e.,agrupamientos de objetos todos del mismo tipo y organización internacompuestos, en principio, por más de un item, seleccionable cada uno de ellosmediante un índice numérico a través de una operación denominada 'indexación':el objeto nro. 0 de la colección, el nro. 1, el nro. 2, etc. Gráficamente lanoción se corresponden con la oportunamente presentada para la memoria RAM:una colección, en ese caso, de Bytes.

----------------------------------------------- ... ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ... ---------------------------------------------- 5 6 7 8 9 10 11 12 13 14 15 16 17 18

Si bien aún hay más modalidades de organización interna (p.e., las listasenlazadas), la descripción no avanzará más allá de las mencionadas.

Acciones básicas----------------

Una operación básica en el contexto de los objetos variables de losprograma es la posibilidad de modificar sus contenidos (la propiedad 'valor').La acción -ejecutiva- destinada a tal fin es la 'asignación' que,simbólicamente, puede representarse con el símbolo '<-' y, sintácticamente,mediante la fórmulación:

<variable> <- <expresión>

en que <variable> representa al nombre que individualiza a una dada variable y<expresión> a una operación cuya evaluación da por resultado un valorcompatible con el tipo de dato y organización interna que <variable> es capazde almacenar. Puede definirse en los siguiente términos (asumiendo que lainterpretación de ':=' es 'equivale a' y la de '|' es 'o exclusivo'):

<expresión> := <constante> | <variable> | <expresión> <operador binario> <expresión> | <operador unario> <expresión> | <operador funcional> (<argumentos>)

Ya se ha mencionado qué cosa son las variables y las constantes. Unoperador binario representa a una operación que necesita de dos datos (porejemplo, la suma, necesita de dos sumandos; más sumandos hacen uso de supropiedad asociativa). Por su parte, un operador unario representa... porsupuesto!, una operación que necesita de un solo dato (como por ejemplo el'-', indicando un cambio de signo). En general, estos 'datos necesarios' sesuelen denominar 'argumentos'. Es así que ejemplos de asignaciones válidasson:

a <- 20 (la variable 'a' es asignada con la constante '20') a <- b (la variable 'a' es asignada con el valor de la variable 'b') a <- b + 20 (la vble. 'a' es asignada con el valor resultante de evaluar la suma entre el contenido de la variable 'b' y la constante '20') a <- a + b (la variable 'a' es asignada con el valor resultante de evaluar la suma entre su propio contenido y el de la variable 'b') a <- -a (la variable 'a' as asignada con el resultado de evaluar la expresión que invierte el signo de su contenido)

En todos estos casos, de más está decirlo, se asume que 'a' es una variablesimple de tipo numérico, que 'b' también lo es y que los operadoresinvolucrados representan a las usuales operaciones aritméticas designadas con

los símbolos homónimos. Por otro lado se debe notar que se utilizó siempre ala variable 'a' pero que esta elección ha sido circunstancial. Sin duda esmuy (MUY) amplio el repertorio de posibilidades para bautizar variables.Cuando los tipos de las variables, constantes y, en general, expresionesinvolucradas, no son numéricos, se asume que existen operadores adecuados paracada caso, como de hecho ocurre.

Ahora, qué es un operador funcional ? No corresponde ni más ni menos que ala invocación de una función tal como ocurre en la sintaxis de una ecuaciónmatemática común (pe., 'cos(x)'). Esto es, la invocación del nombre de unafunción acompañada del juego de parámetros correspondientes (ninguno, uno omás) da como resultado su evaluación y consecuente obtención de un valorproducto de su funcionamiento. Fuera de las funciones matemáticas standard,todos los lenguajes de programación proveen herramientas para definir nuevasfunciones 'a medida' de las necesidades, lo que corresponde a describir cómose deben comportar y darles un nombre de bautismo por el cual invocarlas aposteriori. De hecho, gran parte del trabajo de un programador se consumediseñando y escribiendo funciones a medida.

Además de la operación de asignación la otra operación básica a los objetoses la de lectura (y ésta es aplicable a TODOS los objetos, fueran variables oconstantes). No hay una sintaxis especial a tal efecto sino que bastareconocer su ubicación en una expresión para descubrir a cuál de estas dosoperaciones se las somete: si la mención a un objeto está a la izquierda deloperador de asignación ('<-'), entonces es porque va a ser asignado (escrito)con un valor producto de la evaluación de la expresión a la derecha del mismo.Se sigue entonces que, lo que yace a la derecha del '<-' debe ser evaluado y,a tal efecto, los objetos involucrados, leídos. Regla mnemotécnica: lo queestá a la izquierda del '<-' resulta escrito y lo que está a la derecha,leído.

Una mención especial ha de hacerse referente a la denominación de los tiposno simples de variables. En el caso de los objetos estructurados, al sercada uno de sus campos un sub-objeto afectado de todas las propiedades deaquellos, el operador '.' sirve a los efectos de poner de manifiesto lasdependencias jerárquicas involucradas. Por ejemplo, la variable estructuradacuyo nombre es 'Dcto' y pretende modelar un DNI, debe tener campos, porejemplo, para el número (entero), nombre de la persona (cadena alfanumérica),su domicilio (cadena alfanumérica) y su fecha de nacimiento (subestructura detres campos numéricos enteros para día, mes y año). Cada campo sería entoncesaccedido mediante la siguiente sintaxis:

Dcto.Número Dcto.Nombre Dcto.Domicilio Dcto.FechaDeNacimiento.Día Dcto.FechaDeNacimiento.Mes Dcto.FechaDeNacimiento.Año

asumiendo que los campos involucrados se han bautizado del modo indicado(observe la estructura jerarquizada).

Para los vectores, dado que cada elemento de la colección se seleccionamediante un índice numérico, la sintaxis utilizada consiste en señalarentre paréntesis tal dirección. Por ejemplo:

Estampillas(65)

hace referencia al elemento 65to. del vector denominado 'Estampillas'. Y sicada elemento de esta colección puede ser de cualquier tipo, por ejemplo unoestructurado, y asumimos al padrón como una colección de personasrepresentadas por su DNI, la referencia:

Padrón(37).Dcto.FechaDeNacimiento.Mes

menciona a la información del mes de nacimiento del individuo cuyo DNI figuraen el sitio 37mo. de la colección que representa al padrón.

Es muy importante destacar en todo ésto que los nombres de campos y variablesen estos ejemplos se han elegido arbitrariamente, pero, de exprofeso,

coincidentes con la noción de aquello que representan. Esta práctica essumamente recomendable porque contribuye en gran medida a simplificar lainterpretación y el mantenimiento de los programas. De más está decir que unprogramador inglés hubiera elegido nombres como, naturalmente:

Roster(37).IdDocument.BirthDate.Month

y, por cierto, hubiera respetado totalmente el criterio sugerido.

Otras acciones naturales a los objetos son las de ser creados y destruidos.Acerca de las mismas se hablará más adelante pero, en particular, valedestacar que durante la creación de objetos se especifican sus atributos, comoel nombre, tipo y organización interna.

Cabe a esta altura hacer una mención especial a las funciones de entrada/salida de información. Todo lo dicho hasta ahora ronda un ámbito bastanteideal, pero la realidad es que tanto los datos utilizados por los programascomo los resultados logrados deben ser obtenidos y comunicados al mundo'exterior'. Cuando se hizo la descripción básica de la arquitectura de unsistema de cómputo se mencionó la existencia de una unidad de entrada/salidaa tal efecto y se la caracterizó mediante varios dispositivos físicos de entrelos posibles. Ahora bien, para obtener datos del 'exterior', estos debenLEIDOS, y para presentar resultados, éstos deben ser ESCRITOS. Muy bien,todos los lenguajes de programación proveen operaciones de lectura yasignación (escritura) a objetos especiales que son los dispositivos deentrada/salida. En lo que a la sintaxis propuesta corresponde podemosespecificar entonces que la lectura de datos desde un dispositivo de entradabien puede ser la siguiente:

<variable> <- [dispositivo de entrada]

y la de presentación de resultados:

[dispositivo de salida] <- <expresión>

Control-------

Se ha mencionado que un algoritmo es una secuencia finita de acciones, cadauna de las cuales produce un 'microcambio' en el ambiente, la sucesión de loscuales lleva al resultado final.

La noción de secuencia manifiesta un orden temporal en que una serie deeventos tienen lugar, lo que se denomina el 'flujo de control' del mismo. Esteordenamiento está implícito, i.e., es la misma secuencia por defecto, en quela 1er. acción se desarrolla al principio, la segunda a continuación, y asísiguiendo, hasta la última.

Aún así, la ya mencionada imprescindibilidad de las mediciones da lugara la noción de alternativas. I.e., la consecuencia de efectuar una medición(una comparación) abre dos caminos, separa al universo en dos partesdisjuntas: aquella en que el el contraste se verifica verdadero y sucomplemento, en que resulta falso. Por ejemplo: "Es hoy Sábado ?" divide aluniverso del discurso que continúa en dos complementarios. Si la pregunta espertinente y es Sábado, habrá unas consecuncias. Caso contrario (no esSábado), habrá otras. Si las consecuencias en ambos casos coinciden, entoncesla pregunta no era pertinente (era innecesaria).

Gráficamente, una lista de acciones es:

+----+ +----+ +----+ ...--¦ #1 +---¦ #2 +- ... -¦ #n +-... +----+ +----+ +----+

en cambio, la incorporación de una medición involucra:

+-----+ +----+ +----+ +---¦ +--... ¦ ¦ ¦ +-----+ +-----+ ... --¦ +---¦ ? ¦

¦ ¦ ¦ +-----+ +-----+ +----+ +----+ +---¦ +--... +-----+

en la que NO se pueden seguir AMBOS caminos a la vez. Resulta entonces quelas mediciones consiguen alterar el flujo de control de los algortimos deacuerdo a las circunstancias ambientales en los puntos de medición. Estaposibilidad de DECISION AUTOMATICA aporta un grado de libertad fundamental enla medida que permite a los programas adoptar consecuencias alternativasmientras están siendo utilizados.

La sintaxis de la medición básica es:

<acciones previas>

si <expresión lógica> entonces -- -------- <consecuencia 1> sino ---- <consecuencia 2> fin ---

<acciones posteriores>

y una posible interpretación gráfica la siguiente:

+--------------+ +-¦consecuencia 1+----+ +---------+ +---------+ V ¦ +--------------+ ¦ +------------+ ¦ acciones+------¦expresión+----+ +-¦acciones ¦ ¦ previas ¦ ¦ lógica +----+ ¦ ¦posteriores ¦ +---------+ +---------+ F ¦ +--------------+ ¦ +------------+ +-¦consecuencia 2+----+ +--------------+

en la que se aprecia claramente que las 'acciones previas' y las 'accionesposteriores' ocurren independientemente del resultado de la expresión lógicapero que, entre ellas, el paso intermedio dado por 'consecuencia 1' o'consecuencia 2', no queda elegido a priori sino que la decisión surge comoproducto del ambiente puntual de la medición cada vez que se alcanza esainstancia del algoritmo. Cabe mencionar que no es inválido que las'consecuencia 1' o 'consecuencia 2' sean listas vacías de acciones, aunque noambas a la vez puesto que indicaría una medición impertinente.

Ciclo de vida de un programa-----------------------------

Bueno, y qué es un programa de computadora ? Hemos visto que la finalidadde una computadora es ayudar a su usuario a resolver un problema (al menosuno) supuesto que éste ha sido identificado, comprendido, y un algoritmo parasu solución ha sido propuesto que amerite su implementación mediante unmecanismo automático. Esto es, el usuario (el programador, si es quien va aimplementar esa solución), tiene una idea clara acerca de su problema así comodel modo en que lo va a resolver. Basta con ésto ? Bastaría si su mecanismo deejecución fuera otro individuo con sus mismos conocimientos, capacidad yhabilidad de razonamiento. Si su procesador es de cualquier otro tipo elprogramador deberá incluir un paso adicional consistente en acondicionar ladescripción de su algoritmo a un lenguaje que el mecanismo entienda,posiblemente necesitando reducir el nivel de abstracción de la descripción delas partes de la metodología. Confeccionar un programa de computadora no essino traducir un algoritmo descripto en lenguaje natural a un lenguajecomprensible para el mecanismo ejecutor, es decir, escrito utilizandoúnicamente las sentencias que éste conoce. Por ejemplo, supongamos que sedesea comparar dos datos horarios especificados como hora y minutos:

.Obtener Hora y Minutos del primer horario.

.Obtener Hora y Minutos del segundo horario. .Si la hora del segundo horario es mayor que la del primero entonces el segundo horario es posterior. .sino, si la hora del primer horario es mayor que la del segundo entonces el primer horario es posterior .sino, si los minutos del 2do. horario son mayores que los del 1ro. entonces el 2do. horario es posterior .sino, si los minutos del 1er. horario son mayores que los del 2do. entonces el 1ro. es posterior .sino ambos horarios son iguales.

'En lenguaje QB DIM Hora1 as integer, Min1 as integer, Hora2 as integer, Min2 as integer INPUT Hora1, Min1 INPUT Hora2, Min2 IF Hora1 > Hora2 THEN PRINT "Horario 1 (";Hora1;":";Min1;") es posterior a Horario 2 (";Hora2;":";Min2;")" ELSEIF Hora2 > Hora1 THEN PRINT "Horario 2 (";Hora2;":";Min2;") es posterior a Horario 1 (";Hora1;":";Min1;")" ELSEIF Min1 > Min2 THEN PRINT "Horario 1 (";Hora1;":";Min1;") es posterior a Horario 2 (";Hora2;":";Min2;")" ELSEIF Min2 > Min1 THEN PRINT "Horario 2 (";Hora2;":";Min2;") es posterior a Horario 1 (";Hora1;":";Min1;")" ELSE PRINT "Ambos horarios coinciden." END IF END

// En lenguaje C int Hora1, Min1, Hora2, Min2; scanf("%i %i", &Hora1, &Min1); scanf("%i %i", &Hora2, &Min2); if Hora1 > Hora2 printf("Horario 1 (%i:%i) es posterior a Horario 2 (%i:%i)", Hora1, Min1, Hora2, Min2); elseif Hora2 > Hora1 printf("Horario 2 (%i:%i) es posterior a Horario 1 (%i:%i)", Hora2, Min2, Hora1, Min1); elseif Min1 > Min2 printf("Horario 1 (%i:%i) es posterior a Horario 2 (%i:%i)", Hora1, Min1, Hora2, Min2); elseif Min2 > Min1 printf("Horario 2 (%i:%i) es posterior a Horario 1 (%i:%i)", Hora2, Min2, Hora1, Min1); else printf("Ambos horarios coinciden.");

Los aspectos de las tres implementaciones son similares, aún cuando sereconoce que algún tipo de traducción ha mediado. Esto se debe a que loslenguajes de computadora utilizados son de "alto nivel". Es decir, son capacesde manejar descripciones de manera y nivel muy similar al utilizado en ellenguaje diario. Claro, la tarea encomendada fue también sencilla. Tareas másabstractas como como "verificar el diseño de una estructura metálica frente auna serie de restricciones" ameritan de una descripción más amplia que unaspocas líneas de castellano.

Un programa, mientras permanece como una lista finita de pasos escrita enun lenguaje de programación de alto nivel, es comprensible solamente paraaquel que lo escribió y para todo el resto de las personas que conocen lospormenores del lenguaje utilizado. Pero lejos está de ser un producto capazde ser ejecutado en un sistema de cómputo.

De acuerdo a lo que hemos visto hasta ahora, la plataforma de cómputo esun sistema electrónico que, como tal, solamente es capaz de actuar frente aestímulos de tipo eléctrico. Cómo, entonces, puede un programa comandar a unsistema de ese tipo ? El programa, mediante una serie de pasos, es convertidoa una serie equivalente de 1s. y 0s. (es traducido a un código binario o debajo nivel) para la cual existe una solución tecnológica bien conocida yeficiente que transcribe la secuencia de dígitos obtenida en magnitudeseléctricas adecuadas. En definitiva, una vez que el código (programa) llegó a

la forma binaria, el problema está resuelto. Y cómo se llega, entonces, alcódigo de bajo nivel ? Para esto se utilizan programas especiales denominadoscompiladores y linkers. El compilador toma al archivo con el programa escritoen el lenguaje de alto nivel ('código fuente') y genera otro archivoequivalente en un lenguaje binario denominado 'código objeto'. El archivoobjeto es luego tomado por el linker y sin cambiar su forma original binaria,le agrega una serie de componentes imprescindibles para el funcionamiento delprograma en el entorno del sistema operativo. La salida del linker es unarchivo directamente ejecutable por el sistema operativo de la computadora,i.e. una aplicación completa.

+------+ +--------+ +-------------+ ¦ ¦ +------------+ ¦ ¦ +--------+ ¦ ¦ ¦Código+-> COMPILADOR Ã-> Código +--> LINKER Ã---> Código ¦ ¦Fuente¦ +------------+ ¦ Objeto ¦ +--------+ ¦ Ejecutable ¦ ¦ ¦ ¦ ¦ ¦ (Aplicación ¦ ¦ ¦ ¦ ¦ ¦ Terminada) ¦ +------+ +--------+ +-------------+

ARCHIVO PROGRAMA ARCHIVO PROGRAMA PROGRAMA

El compilador, previa traducción de alto nivel a bajo nivel, verifica quela sintaxis del código adhiera a las normas preestablecidas para el lenguajeen cuestión. De hallar discrepancias (por ejemplo, palabras mal escritas) noconluye la compilación anunciando los errores encontrados. El código fuentedeberá, en consecuencia, ser editado (modificado mediante un programa editor)a fin de hacerle los cambios necesarios. Así, el ciclo de vida de una programapuede esquematizarse del siguiente modo:

+------------+ ¦ Librerías ¦ +------------+ ¦ SI V SI+-----------+ +-----------+ +-------------+ +-------------+ +------------+¦ EDITOR +->¦COMPILADOR +>¦ Compilación +>¦ LINKER +>¦ Ejecutable +-+¦ (fuente) ¦ ¦ (objeto) ¦ ¦ OK ? ¦ ¦ (ejecutable)¦ ¦ OK ? ¦ ¦+-----------+ +-----------+ +-------------+ +-------------+ +------------+ ¦ ^ ^ ^ ¦NO ¦NO ¦ ¦ ¦ +-----------------------------+ ¦ ¦ ¦ ¦ ¦ ¦ ¦ +--------------------------------------------------------------+ ¦ ¦ +--------------+ +---------------------+ ¦ ¦ NO ¦ Funciona de ¦ ¦ Programa terminado ¦ ¦ +---------------------¦ acuerdo a lo +-<-------¦ (ejecutable) +-<---+ ¦ esperado ? ¦ ¦ ¦ +--------------+ +---------------------+ SI¦ +-- THE END !

(las 'librerías' constituyen un aspecto adicional al que se hará referenciamás adelante)

Se ha usado el término 'archivo'. Se denomina así al contenedor de unapieza de información con entidad propia, sujeta a ser utilizada por el sistemaoperativo. Es más, es el SO el que define y reconoce los formatos y modos deacceso a los archivos. Por ejemplo, este texto fue elaborado con un programaprocesador de texto y almacenado como un archivo en un disco rígido. Cada vezque fue necesario vincular al texto con el procesador de texto -paramodificarlo-, éste solicitó los servicios de acceso a archivo del sistemaoperativo. Por asociar el concepto mediante analogías podríamos decir que unarchivo es a la información lo que las palabras a las ideas: un envase que lascontiene y que posibilita su interpretación e intercambio. Los archivos son,en definitiva, las unidades de información que el SO maneja en su nivel másalto.

Una consideración adicional ha de ser hecha a fin de establecer diferenciasy similitudes entre 'archivo' y 'programa'. Hemos dicho que el SO ubica enarchivos a todas las unidades de información que maneja. Algunos de los mis-mos contienen sólo materia prima o materia elaborada (información cruda para

ser procesada o datos producto del trabajo de un programa). Otros contienenlas instrucciones necesarias para procesar la información. Son los llamadosprogramas. Tanto unos como otros están contenidos en archivos (esto esimprescindible para que el SO pueda administrarlos). La diferencia consiste ensu propósito (definido por su contenido). Los archivos que contienen códigofuente y código objeto constituyen una suerte de categoría intermedia. No sonejecutables, como los programas propiamente dichos, pero sí contienen lainformación necesaria para crear un ejecutable. Por ese motivo, a veces, selos denomina también programas. De todos modos, estrictamante hablando, no loson. En lo sucesivo se hará un uso apropiado de la terminología: archivos dedatos, fuentes, objetos y ejecutables.

+------------+ +¦ de Datos ¦ (texto, gráficos, tablas, números, ¦+------------+ etc.) ¦+------------+ +-----------+ +¦ Fuentes ¦ (texto de programas en lenguaje de alto ¦ Archivos +---------¦+------------+ nivel) +-----------+ ¦+------------+ (el SO provee +¦ Objetos ¦ (código binario -1s. y 0s.-) los servicios ¦+------------+ de acceso) ¦+------------+ +¦ Ejecutables¦ (código binario ejecutable por el SO) +------------+ (son los programas)

Nota: Alternativamente al modelo propuesto para llegar de un algoritmo a un archivo binario comprensible por una computadora (mediante el uso deprogramas compiladores y linkers), hay otro que hace uso de programas'intérpretes'. Un compilador responde a la idea de un traductor. El traductortoma un texto en un idioma y crea otro que dice exactamente lo mismo pero enotro idioma. Lo mismo hace un compilador. Alternativamente a los traductoreshay intérpretes. Estos no traducen textos completos sino frase por frase y entiempo real. Del mismo modo trabajan los programas 'intérpretes'. Toman unarchivo fuente con el código en alto nivel de un programa y, línea por línea,lo van convirtiendo en código de bajo nivel y ejecutándolo. Este proceso esciertamente más sencillo, pero también más lento e ineficiente.

Depuración----------

En el esquema referido al ciclo de vida de un programa hay un bloque quecontiene a la pregunta "Funciona el programa de acuerdo a lo esperado ?".La mayor parte de las veces la respuesta es "no". El mismo diagrama conduce'alegramente' a que la siguiente acción consiste en modificar el programa,para lo que hay que volver a editar el fuente. Pero cómo decidir qué se debemodificar ? La respuesta a esta pregunta es todo un capítulo del estudio dela programación denominado 'depuración' (o, en inglés, 'debugging').

No se trata de una tarea trivial y, muchas veces, su éxito (y eficiencia),depende de la experiencia del programador. Esto es, no hay un algoritmo paradepurar programas. Sólo hay herramientas, experiencia y sentido común. Aúnasí, es posible delinear algunas ideas fundamentales.

Hemos visto que las causas conducentes a que un programa no funcione deacuerdo a lo esperado son que el mismo no sea correcto o que no sea completo.Hay, sin embargo, otras posibilidades que dependen exclusivamente de aquelque verifica el funcionamiento del programa. El usuario de un programa bienpuede utilizarlo mal, o bien puede interpretar mal los resultados que obtiene.Esto conduce a incorporar al subjetivismo en el esquema de análisis decomportamiento de un programa: +--------------------------+ +---------------+ +-¦El programa es incorrecto ¦ +-¦ El programa no+-¦ +--------------------------+ ¦ ¦ funciona bien ¦ ¦ +--------------------------+ +-------------------+ ¦ +---------------+ +-¦El programa es incompleto ¦ ¦ El programa parece+--¦ +--------------------------+ ¦ no funcionar bien ¦ ¦ +--------------------------+ +-------------------+ ¦ +--------------+ +-¦El programa se utiliza mal¦

+-¦ El programa +--¦ +--------------------------+ ¦ funciona bien¦ ¦ +-----------------------------+ +--------------+ +-¦Se malinterpreta el resultado¦ +-----------------------------+

Un programa resulta incompleto, como ya se dijera, cuando funciona biensólo algunas veces. Esto es, cuando da un resultado correcto sólo paraalgunas combinaciones (muchas o pocas) de los datos de entrada. Descubrir estetipo de errores no es en general una tarea sencilla dado que el subconjunto decombinaciones de valores de entrada que lo hace fallar puede ser muy reducidoen comparación con el conjunto complementario. Máxime teniendo en cuenta que,salvo para programas triviales, la cardinalidad del conjunto de vectores deentrada (conjunto de combinaciones de datos de entrada) puede serdescorazonadoramente inmensa. En estos casos sólo se puede recurrir a laexperiencia. La misma puede dictar el ensayo de determinados vectores deentrada que conduzcan al programa a trabajar en condiciones quasi-patológicas,proclives a hacerlo fallar. En general se busca hacer trabajar al programa enuna discontinuidad. Por ejemplo, en un programa de administración de cuentascorrientes sería interesante saber cómo se comporta cuando cambia el año (del31 de Diciembre al 1 de Enero), o cuando se presenta un año bisiesto. Contodo, identificado un problema, nada implica que no haya otros. Y aún cuandotodos hayan sido individualizados, resta solucionarlos. Para tranquilidad delos programamadores irresponsables, la programación de hoy en día hace engeneral imposible probar la completitud de un programa. Esto sólo seríaposible si los programas fueran tratados como entidades matemáticas formales-teoremas-, sujetas a pruebas formales. Pero ésto es harina de otro costal yestá bastante alejado del alcance del curso.

A fin de prevenir el mal uso de un programa, el programador puede incluiren su código funcionalidad destinada a capturar errores. Usar un programaconsiste en invocarlo y aportarle los datos de entrada que fueran necesariosen el momento oportuno. Si esos datos están fuera de los valores en que sesupone deben estar es posible que el programa, asumiéndolos correctos, arrojeresultados erróneos. Para evitar esto basta incorporar, en cada entrada dedatos, el código necesario para verificar que el valor esté en rango. Porejemplo, si se ha de ingresar un mes del año, sería prudente verificar que eldato dado fuera un entero en el rango 1..12.

La mala interpretación de los resultados es un hecho imprevisible dado quedepende exclusivamente del usuario del programa. Cuando se diseña e implementaun programa sólo se puede confiar en que aquel que lo va a usar va ainterpretar correcta y completamente el problema que desea resolver, que elprograma en cuestión es la herramienta adecuada y que va a conocer suscaracterísticas suficientemente bien como para no equivocar la interpretaciónde los resultados obtenidos. En este sentido vale comparar el uso delprograma con la realización de un experimento: el mismo puede dar un resultadoerróneo debido a que (a) ha sido mal diseñado; (b) ha sido bien diseñado peromal llevado a cabo y/o (c) ha sido bien diseñado y desarrollado pero elresultado fue malinterpretado.

Finalmente, cuando un programa es incorrecto, se puede recurrir a técnicasconocidas de depuración. En general la falla se aloja en la lógica delprograma y para hallar la ubicación de la misma es necesario desarrollar unexamen pormenorizado de la dinámica del programa. Por un lado se puede volvera analizar su estructura general intentando dar con detalles que no fuerontenidos en cuenta, como por ejemplo la construcción incorrecta de eventos decontrol de lazos o una mala disposición de los mismos. Por otro lado esposible estudiar la evolución de las variables del programa a medida que vasiendo ejecutado. Efectivamente, si se desconfía del valor que una variableasume en un momento dado del programa, basta modificarlo temporalmente de modotal que se presente en pantalla el contenido de la variable según va cambiandode valor. Es posible que, en algún momento, se verifique la sospecha. Porejemplo, puede ocurrir que un error inadvertido durante la programaciónpropicie que una variable utilizada como denominador en una expresiónaritmética quede asignada con cero con la consiguiente catástrofe para elprograma. Afortunadamente las herramientas de programación disponibles hoyen día hacen relativamente sencilla la tarea de debugging. Éstas permitensubordinar la ejecución de los programas a su control a fin de posibilitarque los mismos sean ejecutados paso a paso; que la ejecución de determinadostrozos de código quede condicionada; que el contenido de variables

seleccionadas se presente en pantalla; etc.

Programa QB-----------

Un programa es la implementación o representación en un lenguaje adecuadode un algoritmo.

Un programa QB está compuesto por uno o más 'módulos'. Cada módulo estácompuesto, a su vez, por una lista secuencial finita de 'sentencias' (código)a nivel de módulo; ninguna, una o más 'funciones'; y ninguna, una o más'subrutinas' o 'procedimientos', todas a su vez conformadas como listasfinitas de sentencias.

+--------------------------------------------------------Programa QB----+ ¦ ¦ ¦ +-------------------Módulo 1---+ +-------------------Módulo n--+ ¦ ¦ ¦ Código a nivel de módulo 1. ¦ ¦ Código a nivel de módulo n. ¦ ¦ ¦ ¦ ... ¦ ¦ ... ¦ ¦ ¦ ¦+-----Sub 1+ +-----Sub m+ ¦ ¦+-----Sub 1+ +-----Sub k+¦ ¦ ¦ ¦¦Código de ¦ ¦Código de ¦ ¦ ¦¦Código de ¦ ¦Código de ¦¦ ¦ ¦ ¦¦la Sub 1 ¦ ¦la Sub m ¦ ¦ ¦¦la Sub 1 ¦ ¦la Sub k ¦¦ ¦ ¦ ¦¦... ¦ ¦... ¦ ¦ ¦¦... ¦ ¦... ¦¦ ¦ ¦ ¦¦ ¦ ... ¦ ¦ ¦ ¦¦ ¦ ... ¦ ¦¦ ¦ ¦ ¦+----------+ +----------+ ¦ ¦+----------+ +----------+¦ ¦ ¦ ¦+Function 1+ +Function p+ ¦ ¦+Function 1+ +Function q+¦ ¦ ¦ ¦¦ ¦ ¦ ¦ ¦ ¦¦ ¦ ¦ ¦¦ ¦ ¦ ¦¦Código de ¦ ¦Código de ¦ ¦ ¦¦Código de ¦ ¦Código de ¦¦ ¦ ¦ ¦¦Function 1¦ ... ¦Function p¦ ¦ ¦¦Function 1¦ ... ¦Function q¦¦ ¦ ¦ ¦¦... ¦ ¦... ¦ ¦ ... ¦¦... ¦ ¦... ¦¦ ¦ ¦ ¦+----------+ +----------+ ¦ ¦+----------+ +----------+¦ ¦ ¦ +------------------------------+ +-----------------------------+ ¦ +-----------------------------------------------------------------------+

NOTA: en toda la explicación que sucede, se entiende que la terminología estáaplicada y debe ser entendida en vinculación con el ambiente QuickBasic(R)para el desarrollo de programas en lenguaje QuickBasic.

[Sentencias]

Se entiende por sentencia a una línea de texto ASCII capaz de sercompilada exitosamente por el compilador BC, o de ser ejecutada con idénticoresultado dentro del ambiente QB. Para que tal cosa pueda ocurrir esimprescindible que la sintaxis de la misma adhiera a las normas establecidaspara la escritura de sentencias QB, las que se detallan en el manualcorrespondiente al producto. El propósito y significado de cada sentencia esel de una orden. Mediante una sentencia se ordena al sistema de cómputo (laPC) que desarrolle un trabajo específico, por ejemplo, limpiar la pantalla,leer el teclado para recoger un dato, graficar una línea o imprimir un textoen la impresora.

Como se ha dicho, el compilador se encarga de traducir el texto de unprograma a un formato comprensible por el hardware del sistema de cómputo.Si el texto a compilar (o fuente) no sigue normas sintácticas preestablecidaspor el fabricante del compilador, éste no va a comprender el texto y no va apoder hacer su trabajo. Esto por el mismo motivo que un traductor, digamos,de castellano a inglés, no va a poder hacer su trabajo si el disertantehispanoparlante, aún con palabras en castellano, rompe con las normassintácticas del idioma. No le va a ser posible traducir aquellas frases cuyosentido no logra hilvanar y comprender.

Una taxonomía de las sentencias puede ser la siguiente:

+----------+ +-----------------------------+ ¦Sentencias+--¦No-ejecutables (declarativas)¦ +----------+ ¦+-----------------------------+ ¦+-----------+ +-------------+ +¦Ejecutables+---¦de asignación¦ +-----------+ ¦+-------------+

¦+----------+ +¦de control¦ ¦+----------+ ¦+-----------------+ +¦de entrada/salida¦ +-----------------+

Así, un lista correctamente estructurada de sentencias QB puede dar lugara un programa QB, i.e. a una lista de órdenes que al ser ejecutadas ensecuencia dan por resultado la realización de un trabajo.

[Sentencias Declarativas]

+----------+ +-----------------------------+ ¦Sentencias+--¦No-ejecutables (declarativas)¦ +----------+ ¦+-----------------------------+ :

Se denominan sentencias declarativas a aquellas que, sin ejecutar unaacción concreta, manifiestan una modalidad de trabajo. Por ejemplo, para"declarar" que todos los nombres que comiencen con la letra 'A' van a sertomados como valores enteros (sentencia DEFINT); que se debe reservar memoriapara almacenar un conjunto compacto de datos (sentencia DIM) o quedeterminados objetos de un módulo van a ser compartidos por otros (sentenciaCOMMON).

[Sentencias Ejecutables]

El resto de las sentencias que no son declarativas son ejecutables. I.e.,dan lugar a que una acción o medición concreta comience y finalice.

: ¦+-----------+ +-------------+ +¦Ejecutables+---¦de asignación¦ +-----------+ ¦+-------------+ ¦+----------+ +¦de control¦ ¦+----------+ ¦+-----------------+ +¦de entrada/salida¦ +-----------------+

[Sentencias de Asignación]

Antes de hablar sobre sentencias de asignación es imprescindible hacerreferencia al concepto de "variable".

: ¦+-----------+ +-------------+ +¦Ejecutables+---¦de asignación¦ +-----------+ ¦+-------------+ ¦ +--... ¦ ¦ +--...

Las computadoras, se dijo, son máquinas que procesan informaciónvaliéndose de programas que disponen convenientemente del hardware. Lainformación, a fin de ser utilizada por el software, debe estar en un formatoque éste reconozca y comprenda. Ese formato es el definido por las variablesen sus diversos tipos. Las variables son entidades dentro de un programadestinadas a contener la información sujeta a procesamiento, por ejemplo,números o texto. Dado que ese procesamiento significa modificar lainformación y que la misma está contenida en variables, las mismas han deadmitir la posibilidad de ser leídas y/o escritas. Una variable puedeidealizarse como una especie de caja -contenedor-. La misma es accedida paralectura -es leída- a fin de conocer su contenido y para escritura -esescrita- para modificar su contenido. Una variable contiene, en un momento

dado, un solo dato. Así, toda vez que una variable es escrita, su contenidose ve irrecuperablemente modificado y su anterior valor irremediablementeperdido. Resumiendo,

+------------------------------------------------------------------+ ¦ .Una variable: ¦ ¦ .es un contenedor de información ¦ ¦ .debe ser LEIDA a fin de que su contenido sea utilizable. ¦ ¦ .debe ser ESCRITA a fin de que su contenido sea modificado. ¦ ¦ .puede contener sólo un valor en cada momento. ¦ +------------------------------------------------------------------+

En este sentido, las variables son a los programas lo que los archivos alsistema operativo: sus unidades para contener información.

Dicho esto, la operación destinada a escribir una variable se denominaasignación. Por ejemplo,

+--------------------------+ ¦ CantidadDePaginas = 128 ¦ +--------------------------+

es una sentencia de asignación cuyo efecto es el de escribir -asignar- a lavariable denominada 'CantidadDePaginas' el dato numérico '128'.Implícitamente se ha puesto de manifiesto que a una variable está asociado unnombre identificatorio. Resulta evidente la necesidad de esta asociación.Dado que una variable puede contener sólo un valor -dato- en cada momento yque para la normalidad de los casos un programa debe hacer uso de unacantidad de datos mayor que 1, ha de ser posible distinguir e individualizara cada uno de los contenedores. Para este fin, cada uno es vinculado con unnombre único de modo tal que cada vez que en el contexto de un programa sehace referencia al mismo nombre de variable se debe entender que se trata dela misma variable.

QB admite variables de diversas características, tanto en lo que hace altipo de datos que pueden contener como en lo relativo a su organizacióninterna. Para más detalles sobre este punto se recomienda la literaturaespecífica. De todos modos y como panorama general, las variables QBdistinguen los tipos de datos que pueden contener en:

¦Enteros de precisión simple (integer) ¦Enteros de precisión doble (long) ¦Punto flotante de precisión simple (single) ¦Punto flotante de precisión doble (double) ¦Alfanuméricos (strings)

y distingue los distintos tipos de organización interna según:

¦Variables simples ¦Arreglos de una o más dimensiones ¦Tipos definidos por el usuario

En cuanto a las denominaciones válidas para las mismas se remite al lectora la literatura específica (manual del lenguaje).

Finalmente, cabe decir que en función de la utilización que de ellas sehaga dentro de un programa, las variables pueden asumir algunos rolesespeciales que son interesantes de destacar:

Contador: toda variable destinada a llevar una cuenta de eventos. Por ejemplo la cantidad de teclas que se han oprimido.

Indice o Puntero: toda variable destinada a señalar un lugar específico de un arreglo. Ejemplos sobrados se presentan en la segunda parte de este material.

Flag o Bandera: toda variable destinada a señalar que un evento ha tenido o no lugar. Por ejemplo, un valor 1 en la variable 'Leido' debe ser

interpretado como que un dato ha sido leído. Si en un punto del programa, 'Leido' NO vale 1 se deduce que el dato aún NO fue leído dado que sólo el procedimiento de leerlo 'activa' al flag, asignándole 1.

Es importante destacar que esta división de roles de las variables espuramente semántica y cualquier variable puede ser usada en cada caso: no hayvariables especiales para cada una de los propósitos mencionados. Sufinalidad se depenede sólo del modo en que se usan.

Detallado el propósito y algunas caracerísticas de las variablescorresponde, entonces, hacer lo propio con el concepto de asignación. Como sedijera, la misma está destinada a actualizar el valor contenido en unavariable. La asignación puede asumir las siguientes formas:

<variable> = <expresión>

donde, interpretando al símbolo '|' como 'o', es decir, como'alternativamente':

<constante> ES una constante válida en el lenguaje <expresión> ES <constante> | <variable> | <operador> <expresión> | <expresión> <operador> <expresión> | <operador> (<expresión>) | (<expresión>) <operador> (<expresión>) <variable> ES una variable válida de QB <operador> ES <operador aritmético> | <operador lógico> | <operador relacional> | <operador funcional> <operador aritmético> ES + | - | * | / | \ | ^ | () <operador lógico> ES NOT | AND | OR | XOR | EQV | IMP <operador relacional> ES > | < | = | <= | >= | <> <operador funcional> ES la invocación a una función válida en QB

Así, por ejemplo, son asignaciones válidas en QB:

CantidadDePaginas = 128 DosPI = 2 * 3.1415927 AnioEsMayor = AnioFinal > AnioFinal Verdadero = NOT Falso Area = Pi * Radio ^ 2 Hipotenusa = SQR(x ^ 2 + y ^ 2) Uno = SIN(x) ^ 2 + COS(x) ^ 2

y son ilegales:

1 = SIN(x) ^ 2 + COS(x) ^ 2 x * y = Equis * YGriega TAN(Angulo) = 0.45

Si al momento de la asignación la variable objeto de la operación no habíasido aún referenciada dentro de su alcance, entonces, previo a la misma, lavariable es creada por el QB. Caso contrario, QB utiliza el espaciopreviamente asignado al identificador.

[Sentencias de control]

: ¦+-----------+ +¦Ejecutables+-----... +-----------+ ¦ ¦+----------+ +¦de control¦ ¦+----------+ ¦ +--...

Las sentencias de control tienen por propósito posibilitar la "medición"del estado -contenido- de variables de cuyo valor depende que se ejecutenalgunas partes del programa y no otras.

Como ya se adelantara, cuando se desarrolla un trabajo, de la naturalezaque fuera, hay implícito un concepto de medición. Si no, cómo saber cuándo eltrabajo está concluido ?. O cómo saber si la ejecución va por buen camino ?.De uno modo u otro el mecanismo ejecutor del trabajo debe enterarse sobre elprogreso de su misión a fin de hacer las correcciones que resulten oportunas.Por ejemplo, cuando se conduce un automóvil es en general imprescindible mirarel camino por el parabrisas. Sino se corre el riesgo de no advertir la curvaque bordea al precipicio, con las consecuencias que son de imaginar. Y una vezque se ha tomado la curva, es aconsejable no quitar la vista de la ruta. Casocontrario el giro puede tornarse de 360 grados con no menos riesgos para lospasajeros.

En un sistema de cómputo que hace un trabajo, en qué consisten lasmediciones que determinan el progreso del proceso ? Dado que lo que seprocesa es información y que la misma ha de ser llevada de un estado iniciala uno final pasando por diversos estados intermedios, lo que se debemonitorear, entonces, es cómo marchan esas transformaciones parciales. Y dadoque los depósitos de la información, tanto en su estado inicial como en losintermedios y final, son las variables, de lo que se trata es de leer elcontenido de algunas variables claves en momentos importantes y disponer lascosas a fin de que se ejecuten acciones correctivas condicionadasoportunamente.

Las sentencias QB que implementan diversas modalidades de medición son:

+----------------------------+ +----------------------------+ ¦ If <condición> then ¦ ¦ do ¦ ¦ <bloque de sentencias> ¦ ¦ <bloque de sentencias> ¦ ¦ else ¦ ¦ loop while <condición> ¦ ¦ <bloque de sentencias> ¦ ¦ ¦ ¦ end if ¦ ¦ ¦ +----------------------------+ +----------------------------+ +----------------------------+ +----------------------------+ ¦ do ¦ ¦ while <condición> ¦ ¦ <bloque de sentencias> ¦ ¦ <bloque de sentencias> ¦ ¦ loop until <condición> ¦ ¦ wend ¦ +----------------------------+ +----------------------------+ +------------------------------------------------------------------+ ¦ for <asignación> to <expresión> step <expresión> ¦ ¦ <bloque de sentencias> ¦ ¦ next <Variable de Control> ¦ +------------------------------------------------------------------+ +----------------------------------------+ ¦ select case <expresión> ¦ ¦ case <caso 1> ¦ ¦ <bloque de sentencias 1> ¦ ¦ ... ¦ ¦ case <caso n> ¦ ¦ <bloque de sentencias n> ¦ ¦ case else ¦ ¦ <bloque de sentencias por defecto> ¦ ¦ end select ¦ +----------------------------------------+

Para todos los casos,

<condición> ES <operador lógico> <expresión lógica> | <expresión lógica> <operador lógico> <expresión lógica> | <operador lógico> (condición) | (<expresión lógica>) <operador lógico> (<expresión lógica>)donde

<expresión lógica> ES <expresión> <operador relacional> <expresión>

asimismo,

<bloque de sentencias> ES una secuencia válida de sentencias QB.

[Sentencias de Entrada/Salida]

: ¦+-----------+ +¦Ejecutables+-----... +-----------+ ¦ ¦ +--... ¦ ¦+-----------------+ +¦de entrada/salida¦ +-----------------+

Finalmente, las sentencias de Entrada/Salida son las que posibilitan lacomunicación entre el programa y el medio externo. Al programa ingresa desdeel exterior la información -en estado inicial- y, asignada a un sistema devariables convenientemente dispuesto, comienza a ser procesada pasando porpor los diversos estados intermedios, hasta llegar a un estado final que debeser comunicado nuevamente al exterior. Las sentencias de Entrada/Salidaproveen herramientas para la transferencia y transformación de la informacióna formatos compatibles con los dispositivos de origen/destino. Esto es, sibien en el contexto de un programa los datos son mantenidos en variables,cuando un valor ha de ser presentado en pantalla ha de sufrir unamodificación de su aspecto que lo haga compatible con ese medio. El mismodato debe sujetarse a una modificación diferente si va a ser impreso en unaimpresora, y otra si va a ser almacenado en disco. Para cada caso, sentenciasespecíficas dan lugar al acondicionamiento adecuado.

Para aprender y comprender en detalle la sintaxis y semántica propia delas sentencias del QB (que, como se dijera, sirven para estructurarfunciones y subrutinas, las que a su vez están estructuradas en módulos, losque a su vez dan origen a los programas) se recomienda remitirse al manualcorrespondiente así como a la bibliografía específica. Los ejemplos que en lamisma se presentan son totalmente demostrativos y sumamente útiles en elproceso de aprendizaje y entrenamiento. Por otro lado, dado que el QB es unambiente de programación, también se hace necesario adquirir habilidad en suuso. Otra vez, la bibliografía específica resulta totalmente adecuada.

[Módulo]

Se denomina módulo a cada archivo fuente componente de un programa QB.Todo programa QB debe, entonces, estar conformado por, al menos, un módulo.Así todo, cuando las restricciones en el manejo de memoria y/o el estilo deprogramación lo dicten conveniente, nada impide que un programa sea separadoen más de un módulo. Por ejemplo, de tratarse de un programa destinado acalcular esfuerzos en una estructura para después graficarlos, o destinado adesarrollar los cálculos necesarios para la nivelación de terrenos para darcomo resultado curvas de nivel, bien pueden suponerse dos módulos. Unoconteniendo todo el código correspondiente a los cálculos y el otro con eldedicado a la graficación. Podría inclusive crearse un tercer módulo para laadministración de los datos desde y hacia archivos en disco, y otro paracontener la interfase con el usuario.

Como se aprecia, la división en módulos puede, y en general se sugiere queasí sea, responder a un agrupamiento del código destinado a un propósitosespecíficos y autocontenidos. Por otro lado, amén de esta división por motivosestilísticos, no es extraño que, a medida que un programa comienza a crecer,el compilador BC muestre sus limitaciones (por ejemplo, en el tamaño de lastablas de símbolos que es capaz de administrar). Esto da lugar a que no seconsiga una compilación exitosa del programa. Cuando algo así ocurre se deberecurrir necesariamente al particionamiento del programa en trozos máspequeños, manejables por el compilador. Dada esta imposición, como antes,resulta conveniente hacer el particionamiento con los criterios estilísticoscomentados.

[Funciones y Subrutinas]

Este punto está desarrollado más adelante.

Una Metodología para el desarrollo de programas-----------------------------------------------

Una de las piezas bibliográficas más relevantes referida a la elaboraciónde programas es una obra en tres volúmenes cuyo autor es Donald Knuth y cuyotítulo es "El Arte de la Programación de Computadoras" (The Art of ComputersProgramming). A un lector que no ha "experimentado" la programación decomputadoras y que se enfrenta por vez primera a los libros mencionados lepuede surgir la duda acerca de su título: "por qué 'El Arte...'". Se conoceal cine como 'séptimo arte' y, si bien no está claro el ordenamiento del restode las artes, con seguridad la plástica, la danza y la dramatización son otrasartes tan relevantes como el séptimo. Sin duda, cuando Knuth pensó en untítulo para su obra, tuvo a la dramatización -al teatro- como inspiración. Larazón ? La razón es clara para quien haya dedicado algunas horas de suactividad a intentar concebir y escribir programas: los mismos sonperfectamente asimilables a obras de teatro. Efectivamente, una obra de teatroconsta de un ecenario -un ambiente- en que se desarrolla, uno o más actores, yun guión. El autor de la obra -el artista- idea un argumento y diseña a lospersonajes. El argumento es la dinámica de la obra y los personajes susobjetos o, visto como un pro- grama, el guión de la obra detalla a cada pasocómo se comportan e interactuan entre sí los actores -los objetos-. Por larazón expuesta y dada la finalidad de un programa -que consiste en implementarun algoritmo que resuelva un problema- su concepción tiene mucho que ver conuna adecuada elección de los "personajes de la obra" (los objetos virtualesque modelan a los del problema reales) y la articulación de su comportamientoe interacción, lo que se describe en el "guión de la obra" (el algoritmo oflujo de control del programa), y así como hay diversos estilos literarios,también los hay para elaborar programas.

Existen diversas metodologías para el desarrollo de programas, cada unaadecuada a los diversos paradigmas de programación. Para el tipo deprogramación que el QB representa (imperativa y procedural), una formaadecuada es la denominada metodología "top-down" (de arriba hacia abajo)(desdelo más abstracto hasta lo más concreto). No debería ya a esta altura extrañaruna propuesta semejante. En más de uno de los títulos hasta ahora presentadosse puso de manifiesto un modo de concebir las ideas y los diseños en que,partiendo de lo más general (en grandes bloques o módulos) se llega,refinando sucesivamente, a lo más detallado (en bloques pequeños o atómicos).De esto mismo se trata la programación procedural, concibiendo a losprogramas como una relación entre partes importantes para ir luego refinandocada una en sus posibles componentes. De hecho, conviene desarrollar a lasaproximaciones iniciales al problema en lenguaje natural. Ejemplos...

Ejm. 1: Se desea obtener el promedio de una serie de números.

+----------------------------------------------------------------+ ¦ Obtener la cantidad de números a promediar. ¦ ¦ Mientras haya números para promediar. ¦ ¦ Obtener el próximo número. ¦ ¦ Sumarlo a la suma de los obtenidos hasta el momento. ¦ ¦ ¦ ¦ Presentar el promedio como la suma obtenida dividida por ¦ ¦ cantidad de números sumados. ¦ +----------------------------------------------------------------+

Para la interpretación del texto encuadrado se debe tener en cuenta que se hatabulado (indentado) el o los pasos que se consideran subordinados a algunaacción de control. Para el caso anterior, "Obtener el próximo número" y"Sumarlo a la suma de los obtenidos hasta el momento" se debe repetir en tantohaya números aún sin promediar. Èsto es claro. Por eso ambas acciones estáncondicionadas a "Mientras haya números para promediar", y la indentación ponede manifiesto explícitamente qué partes están subordinadas a otras. No esdifícil ver que la anterior constituye una lista que, en un lenguaje natural,expresa una metodología para obtener un promedio. Pero como tal, sólo escomprensible por una persona, y siempre y cuando, además de leer, comprendaqué es una suma y qué una división. Pero cómo se llega de aquí a algoequivalente comprensible para una computadora, i.e., a un programa ? Larespuesta pasa por ir refinando sucesivamente y en TODOS los pasos necesariosa cada una de las sentencias del algoritmo.

Para nuestro ejemplo, cada una de las acciones es directamente traducibleen sentencias QB

+----------------------------------------------------+ ¦ input CantidadDeDatos ¦ ¦ DatoNr = 1: Suma = 0 ¦ ¦ while DatoNr <= CantidadDeDatos ¦ ¦ input NuevoDato ¦ ¦ Suma = Suma + NuevoDato ¦ ¦ DatoNr = DatoNr + 1 ¦ ¦ wend ¦ ¦ print "El promedio vale: "; Suma/CantidadDeDatos ¦ +----------------------------------------------------+

El propósito de la variable DatoNr es claro y hace a la burocracia internadel programa: es necesario para mantener un control de la cantidad de númerosque hasta el momento se han obtenido y promediado. Cabe destacar (yrecomendar) la elección hecha para los nombres de las variables. Se aconsejautilizar nombres significativos del propósito de las mismas. Esto, además dehacer más amena la elaboración y lectura de los fuentes, sirve comodocumentación implícita.

Si se hubiera deseado presentar el resultado en el medio de la pantalla,en lo que a nivel de detalle respecta, ya hubiera sido necesario unrefinamiento del último paso. "Presentar al promedio como la suma obtenidadividida por la cantidad de números sumados" podría haber significado:

+---------------------------------------------------------------------+ ¦ Calcular la mitad de la altura de la pantalla (FILA) ¦ ¦ Calcular la mitad del ancho de la pantalla menos la mitad de la_ ¦ ¦ longitud de la frase a presentar (COLUMNA) ¦ ¦ Ubicar al cursor de la pantalla en el punto obtenido (FILA, COLUMNA)¦ ¦ Imprimir el resultado del promedio ¦ +---------------------------------------------------------------------+

La descompsición anterior ya puede ser traducida directamente al QB como

+---------------------------------------------------------------+ ¦ Mensaje$ = "El promedio vale: "+ str$(Suma/CantidadDeDatos) ¦ ¦ Fila = 24/2; ¦ ¦ Columna = 80/2 - len(Mensaje$)/2 ¦ ¦ locate Fila,Columna ¦ ¦ print Mensaje$ ¦ +---------------------------------------------------------------+

quedando el programa final, entonces, como:

+--------------------------------------------------------------+ ¦ input CantidadDeDatos ¦ ¦ DatoNr = 1: Suma = 0 ¦ ¦ while DatoNr <= CantidadDeDatos ¦ ¦ input NuevoDato ¦ ¦ Suma = Suma + NuevoDato ¦ ¦ DatoNr = DatoNr + 1 ¦ ¦ wend ¦ ¦ ¦ ¦ Mensaje$ = "El promedio vale: "+ str$(Suma/CantidadDeDatos) ¦ ¦ Fila = 24/2; ¦ ¦ Columna = 80/2 - len(Mensaje$)/2 ¦ ¦ locate Fila,Columna ¦ ¦ print Mensaje$ ¦ +--------------------------------------------------------------+

Ejm. 2: Se desea implementar un juego consistente en que el jugador debe adivinar un número elegido por el programa al azar. A partir de cada intento del jugador, el programa responde con una clave que le indica si ha acertado alguna(s) de las cifras y/o posiciones a fin de que se vaya aproximando al resultado.

Un primer intento podría ser:

+-------------------------------------------------------------------+ ¦ Elegir número clave ¦ ¦ Hacer lo siguiente: ¦ ¦ Pedir al jugador su número candidato ¦ ¦ Verificar coincidencia de cifras y posiciones y armar la pista ¦ ¦ Devolver la pista para el jugador ¦ ¦ Mientras el número candidato no sea igual al número clave ¦ +-------------------------------------------------------------------+

La acción que no tiene traducción directa al QB es "Verificar coincidencia decifras y posiciones y armar la pista". De no ser por ella, el programa QBpodría directamente implementarse como:

+-----------------------------------------------------------------------+ ¦ Clave = int(rnd * 10000) 'Claves entre 0 y 9999 ¦ ¦ do ¦ ¦ input "Su nuevo candidato ?", Candidato ¦ ¦ [Verificar coincidencia de cifras y posiciones y armar la pista] ¦ ¦ print Pista$ ¦ ¦ loop while Candidato <> Clave ¦ +-----------------------------------------------------------------------+

Ahora desarrollamos "Verificar coincidencia de cifras y posiciones"

+----------------------------------------------------------------+ ¦ Inicializar Pista ¦ ¦ Buscar coincidencia en cifras y posición e indicar en la pista ¦ ¦ Si no hay total coincidencia ¦ ¦ Buscar coincidencia en las cifras e indicar en la pista ¦ +----------------------------------------------------------------+

que, de no ser por "Buscar coincidencia en cifras y posición" y "Buscarcoincidencia en las cifras", podría implementarse como

+--------------------------------------------------------------------+ ¦ Pista$ = "mmmm" ¦ ¦ [Buscar coincidencia en cifras y posición e indicar en la pista] ¦ ¦ if Pista$ <> "BBBB" then ¦ ¦ [Buscar coincidencia en las cifras e indicar en la pista] ¦ ¦ end if ¦ +--------------------------------------------------------------------+

"Buscar coincidencia en cifras y posición e indicar en la pista " podría, asu vez, implementarse como:

+---------------------------------------------------------+ ¦ Clave$ = str$(Clave) : Candidato$ = str$(Candidato) ¦ ¦ for i=1 to len(Clave$) ¦ ¦ if mid$(Clave$,i,1) = mid$(Candidato$,i,1) then ¦ ¦ mid$(Pista$,i,1) = "B" ¦ ¦ end if ¦ ¦ next i ¦ +---------------------------------------------------------+

y "Buscar coincidencia en las cifras e indicar en la pista " como:

+-----------------------------------------------------------+ ¦ for i=1 to len(Pista$) ¦ ¦ if mid$(Pista$,i,1)="m" then ¦ ¦ for j=1 to len(Candidato$) ¦ ¦ if mid$(Candidato$,i,1)=mid$(Clave$,j,1) then ¦ ¦ if mid$(Pista$,j,1)="m" then ¦ ¦ mid$(Pista$,i,1) = "b" ¦ ¦ end if ¦ ¦ end if ¦ ¦ next j ¦ ¦ end if ¦ ¦ next i ¦ +-----------------------------------------------------------+

Por lo tanto, juntando los sucesivos refinamientos se obtiene:

+----------------------------------------------------------------------+ ¦ Clave = 1000 + INT(RND * 9000) 'Claves entre 1000 y 9999 ¦ ¦ DO ¦ ¦ PRINT : INPUT "Su nuevo candidato ? ", Candidato ¦ ¦ Pista$ = "mmmm" ¦ ¦ Clave$ = STR$(Clave): Candidato$ = STR$(Candidato) ¦ ¦ FOR i = 1 TO LEN(Clave$) ¦ ¦ IF MID$(Clave$, i, 1) = MID$(Candidato$, i, 1) THEN ¦ ¦ MID$(Pista$, i, 1) = "B" ¦ ¦ END IF ¦ ¦ NEXT i ¦ ¦ IF Pista$ <> "BBBB" THEN ¦ ¦ FOR i = 1 TO LEN(Pista$) ¦ ¦ IF MID$(Pista$, i, 1) = "m" THEN ¦ ¦ FOR j = 1 TO LEN(Candidato$) ¦ ¦ IF MID$(Candidato$, i, 1) = MID$(Clave$, j, 1) THEN ¦ ¦ IF MID$(Pista$, j, 1) = "m" THEN ¦ ¦ MID$(Pista$, i, 1) = "b" ¦ ¦ END IF ¦ ¦ END IF ¦ ¦ NEXT j ¦ ¦ END IF ¦ ¦ NEXT i ¦ ¦ END IF ¦ ¦ PRINT Pista$ ¦ ¦ LOOP WHILE Candidato <> Clave ¦ +----------------------------------------------------------------------+

Funciones y Subrutinas----------------------

En los dos ejemplos anteriores, partiendo de una descripción en lenguajecasi natural, se llegó a la implementación QB de la solución a los problemaspropuestos. Para alguien no conocedor de la sintaxis ni de la semántica delQB, ambos programas resultan listas incomprensibles de cosas no máscomprensibles.

Vamos a concentrarnos nuevamente en el segundo ejemplo. Supongamos que elsiguiente texto fuera un programa QB válido.

+----------------------------------------+ ¦ ElegirNúmeroClave ¦ ¦ do ¦ ¦ PedirNuevoCandidato ¦ ¦ VerificarCoincidenciaClaveCandidato ¦ ¦ ImprimirPista ¦ ¦ while Candidato <> Clave ¦ ¦ end ¦ +----------------------------------------+

Sin duda que su interpretación, aún para aquellos conocedores del QB, resultamucho más clara que en el caso del programa al que se llegó anteriormente. Labuena noticia es que este modo de trabajo es totalmente válido. Entonces, elQB 'comprende' esas instrucciones tan abstractas ?. No. Lo que ocurre es quemás adelante, en algún otro sitio del fuente que conforma al programa, se hade definir qué significa cada una de las acciones designadas con nombres queno son los propios de la jerga nativa del QB. Por ejemplo, se ha de definirel propósito de 'PedirNuevoCandidato' -qué debe entender el QB cuando esenombre es invocado-, lo que no se hace sino escribiendo la lista desentencias a la que ese nombre debe resultar equivalente. Cuando elcompilador/linker de QB se encuentra con 'PedirNuevoCandidato', al noreconocerlo como propio de su diccionario, busca en otro sitio del fuente siese nombre ha sido definido y a qué lista de sentencias QB equivale.

Lo que se ha hecho es definir una SUBRUTINA (a la que se ha bautizado como'PedirNuevoCandidato'). Nuestro programa quedaría entonces del siguiente

modo:

+--------------------------------------------------------+ ¦ ElegirNúmeroClave ¦ ¦ do ¦ ¦ PedirNuevoCandidato ¦ ¦ VerificarCoincidenciaClaveCandidato ¦ ¦ ImprimirPista ¦ ¦ while Candidato <> Clave ¦ ¦ end ¦ ¦ ¦ ¦ +---------------------------------------------------+ ¦ ¦ ¦ sub PedirNuevoCandidato 'Definición de la sub. ¦ ¦ ¦ ¦ PRINT ¦ ¦ ¦ ¦ INPUT "Su nuevo candidato ? ", Candidato ¦ ¦ ¦ ¦ end sub ¦ ¦ ¦ +---------------------------------------------------+ ¦ ¦ +---------------------------------------------------+ ¦ ¦ ¦ sub VerificarCoincidenciaClaveCandidato ¦ ¦ ¦ ¦ ... ¦ ¦ ¦ ¦ end sub ¦ ¦ ¦ +---------------------------------------------------+ ¦ ¦ +---------------------------------------------------+ ¦ ¦ ¦ sub ElegirNúmeroClave ¦ ¦ ¦ ¦ ... ¦ ¦ ¦ ¦ end sub ¦ ¦ ¦ +---------------------------------------------------+ ¦ ¦ +---------------------------------------------------+ ¦ ¦ ¦ sub ImprimirPista ¦ ¦ ¦ ¦ ... ¦ ¦ ¦ ¦ end sub ¦ ¦ ¦ +---------------------------------------------------+ ¦ +--------------------------------------------------------+

Tal vez convenga a esta altura recordar lo que se decía bajo el título'Programa QB', donde se describía la arquitectura de un programa QB. Se veráque el ejemplo anterior no es ni más ni menos que un caso al que ese esquemageneral se ajusta.

Todo esta nueva presentación del esquema está muy cerca de funcionar.Restan comentar algunos detalles relevantes.

En general, una subrutina puede ser vista como una especie de caja negra.Se debe saber de ella qué ocurre cuando se la invoca, i.e, qué trabajorealiza, pero no es necesario conocer cómo lo realiza, i.e. cuál es el códigocon que ha sido definida. Cabe la siguiente analogía: no necesito sermecánico para usar un automóvil. Con una subrutina ocurre lo mismo. Si nadamás se conoce su propósito y su nombre, basta invocar en el código esenombre para que el trabajo que se supone hace, sea hecho. Dicho de otro modo,bien puede un programador escribir las subrutinas y bautizarlas, y otrousarlas de acuerdo a las especificaciones dadas por el primero, sin tener lamás lejana idea sobre cómo funcionan. Es más, ni siquiera es necesario que losmencionados programadores entren alguna vez en contacto. Bien pueden nuncallegar a conocerse.

Dado que las subrutinas hacen un trabajo definido, y si se aplica elconcepto de trabajo planteado al principio de este material, se puede inferirque de algún modo y previo a la realización de su propósito, la subrutinadebe tomar contacto con los datos que va a modificar. De algún modo le debenser comunicados. Esa comunicación se hace en base al mecanismo de "pasaje deparámetros". Los vehículos para la información dentro de un programa son lasvariables. Así, tanto en la invocación como en la definición de unasubrutina, se agregan a su identificador una lista de nombres de variables.Las mismas transportan tanto a los eventuales datos de entrada como a loseventuales datos de salida. Por ejemplo, una subrutina que calcula unpromedio entre dos números debe recibir como entrada a los números y dar comoresultado el promedio calculado:

+-------------------+ +-----------------------+ x ----> ¦ ¦ sub Promedio (x,y,z) ¦

¦ z = (x + y) / 2 +----> z ¦ z = (x + y) / 2 ¦ y ----> ¦ ¦ end sub ¦ +-------------------+ +-----------------------+

Esto permite que la misma subrutina sea aplicada a diversos casos,consistiendo cada uno en una de las posibles combinaciones de parámetros deentrada. Por ejemplo, el siguiente programa despliega todos los promediosposibles para números enteros entre 1 y 10:

+------------------------------------------------------------+ ¦ for i=1 to 10 ¦ ¦ for j=1 to 10 ¦ ¦ Promedio i,j,k ¦ ¦ print "El promedio entre ";i;" y ";j;" vale: ";k ¦ ¦ next j ¦ ¦ next i ¦ ¦ end ¦ ¦ ¦ ¦ sub Promedio (x,y,z) 'Definición de la subrurina ¦ ¦ z=(x+y)/2 ¦ ¦ end sub ¦ +------------------------------------------------------------+

Dos puntos han de ser atendidos. En primer término, cabe destacar lasintaxis de la invocación en la que se hace referencia a las variables i, j yk, parámetros de la subrutina y vehículos para ambos datos de entrada y el desalida. Por otro, se observa que estos parámetros no coinciden con losnombres x,y,z, utilizados en la definición. Èsto es totalmente válido.Cuando el QB encuentra la invocación 'Promedio i,j,k' sólo utiliza laubicación relativa de las variables dentro de la lista de parámetros paraindividualizarlas y disponer así de los contenidos en modo inequívoco. I.e.,QB asume que, de acuerdo a la definición de la subrutina, tanto el primerparámetro como el segundo deben ser parámetros de entrada (en la definiciónestá implícito que se asume que los valores de x e y vienen "desde elexterior"), y el tercero, de salida (por resultar asignado con un valor -(x+y)/2 -). Sabido ésto, el usuario de la rutina Promedio() ubica los datosa promediar en las variables que pasan en primer y segundo término de lalista de parámetros, QB se encarga de copiarlos a las variables x e y,respectivamente, y de ubicar al resultado de la operación en la variable z.Al terminar el promedio, el usuario del mismo sabe que en el tercer parámetro-k- está el resultado.

De más está decir que, al concluir la operación de una subrutina (mediante"end sub" o "exit sub", el control del programa retorna siempre a lasentencia inmediata posterior a la de invocación, en este caso:

print "El promedio entre ";i;" y ";j;" vale: ";k

A poco de comenzar a utilizar esta potente modalidad en los programas nosólo se mejora sensiblemente la claridad y la calidad de la programaciónsino que, además, se delínea un estilo definido: la ya mencionadaprogramación procedural.

Las "funciones" son un tipo particular de subrutinas cuya característicaes la de tomar ninguno, uno o más argumentos y devolver un único valor a lasalida.

Las subrutinas que fueron planteadas hasta el momento podían tenerninguno, uno o más argumentos y, entre éstos, podían haber, a su vez,ninguno, uno o más de entrada, de salida o de doble propósito. Por ejemplo,una subrutina destinada a presentar una portada en la pantallla (por ejemplo:Portada()) bien puede no necesitar ningún dato para hacer su trabajo nidevolver valor alguno. Así, la misma tendrá una lista vacía de parámetros.Una subrutina que separe un número en sus partes entera y decimal tendrá unargumento de entrada -el número a separar- y dos de salida -la parte entera yla parte decimal-. Pero la categoría de subrutinas cuyas característicascoinciden con las planteadas para las funciones son un caso particular dadoque son de aplicación muy generalizada. Tanto es así que el mismo QB conllevauna lista para nada despreciable de funciones prefabricadas y listas parausar sin perjuicio de todas otras aquellas que un programador desee

implementar. Por ejemplo, las funciones trigonométricas, o las funcionesstring. Las mismas toman ninguno, uno o más argumentos y devuelven un valorpor el sólo mecanismo de su invocación. Así la sentencia

y = cos(x)

da como resultado que a la variable sea asignada 'y' con el resultado deevaluar la función cos() para el contenido actual de la variable 'x'. Se debeobservar la sintaxis: la sóla invocación del nombre de la función con sulista de argumentos produce el valor de evaluación de la misma. Por eso

z = sin(x)^2 + cos(y)^2

es una asignación QB complemente válida.

Para definir una función "a medida" de una necesidad, i.e. una funcióncuyos nombre y código son elegidos por un programador, la sintaxis a utilizares muy similar a la mostrada para el caso de las subrutinas. De hecho, dadoque la subrutina Promedio() planteada con anterioridad está en condiciones deser una función (en tanto devuelve un sólo valor), será re-escrito el códigoa fin de que el lector compare y note las diferencias, tanto en ladefinición como en la invocación de la función.

+------------------------------------------------------------------------+ ¦ for i=1 to 10 ¦ ¦ for j=1 to 10 ¦ ¦ print "El promedio entre ";i;" y ";j;" vale: "; Promedio(i,j) ¦ ¦ next j ¦ ¦ next i ¦ ¦ end ¦ ¦ ¦ ¦ function Promedio (x,y) 'Definición de la función ¦ ¦ Promedio=(x+y)/2 ¦ ¦ end function ¦ +------------------------------------------------------------------------+

Los siguientes hechos son destacables en la comparación:

.Sólo dos parámetros son ahora necesarios, los de entrada. El anterior parámetro de salida -z- aparece ahora como resultado directo de la invocación a Promedio().

.A fin de que un valor sea devuelto por una función, antes que la misma concluya en un "end function" o en un "exit function", el valor a ser devuelto debe ser asignado al nombre mismo de la función como si se tratara de una variable.

Alcance y Tiempo de Vida de las Variables-----------------------------------------

Se denomina 'alcance' al rango de visibilidad de una variable. Esto es, quéparte o partes de un programa tienen acceso a una variable, sea para leerla opara escribirla.

Presentamos a las funciones y subrutinas como cajas negras ocompartimientos estancos cuya vía de comunicación con el exterior se limita asu lista de parámetros. Toda otra variable utilizada dentro de una subrutinao función se dice "local" a la misma en tanto NO ES VISIBLE -accesible,utilizable- desde el exterior. Por ejemplo, en

+------------------------------------------------------------+ ¦ cls ¦ ¦ m = 200 ¦ ¦ print Promedio(10,20),m ¦ ¦ end ¦ ¦ ¦ ¦ function Promedio (x,y) 'Definición de la función ¦ ¦ m = 35 ¦ ¦ Promedio = (x+y)/2 ¦

¦ end function ¦ +------------------------------------------------------------+

la impresión en pantalla es

+--------------------+ ¦ 15 200 ¦ +--------------------+

dado que el valor de m que la sentencia print 've' es el que se encuentra anivel de módulo y NO el que está a nivel de la función el que, si bien tieneel mismo nombre, corresponde a una variable totalmente distinta, independientee inconfundible. La separación gráfica de cada parte en cajas pone demanifiesto y contribuye a la comprensión de lo dicho

+--------------------------------------------------------------+ ¦ cls 'Código a nivel de módulo ¦ ¦ m = 200 ¦ ¦ print Promedio(10,20),m ¦ ¦ end ¦ ¦ ¦ ¦ +---------------------------------------------------------+ ¦ ¦ ¦ function Promedio (x,y) 'Definición de la función ¦ ¦ ¦ ¦ m = 35 ¦ ¦ ¦ ¦ Promedio = (x+y)/2 ¦ ¦ ¦ ¦ end function ¦ ¦ ¦ +---------------------------------------------------------+ ¦ +--------------------------------------------------------------+

Del mismo modo, cualquier referencia a la variable 'm' es interpretada comoacceso a la 'm' local.

Y si se hace la distinción de las variables locales es debido a que existela contrapartida, es decir, las variables "globales". Las mismas sonaccesibles desde cualquier sitio de un programa (sea interno a una función osubrutina, o a nivel de módulo). Las variables que adhieren a esta modalidaddeben ser declaradas con la palabra clave 'SHARED'. Por ejemplo

+--------------------------------------------------------------+ ¦ cls 'Código a nivel de módulo ¦ ¦ shared m ¦ ¦ m = 200 ¦ ¦ print Promedio(10,20),m ¦ ¦ end ¦ ¦ ¦ ¦ +---------------------------------------------------------+ ¦ ¦ ¦ function Promedio (x,y) 'Definición de la función ¦ ¦ ¦ ¦ m = 35 ¦ ¦ ¦ ¦ Promedio = (x+y)/2 ¦ ¦ ¦ ¦ end function ¦ ¦ ¦ +---------------------------------------------------------+ ¦ +--------------------------------------------------------------+

da lugar a que en pantalla aparezca

+----------------+ ¦ 15 35 ¦ +----------------+

El '35' es escrito en 'm' dentro de la función a posteriori de la asignación'm = 200' pero, al ser 'm' global resulta perfectamente visible a nivel demódulo. De no haber sido 'm' global, la salida hubiera sido

+----------------+ ¦ 15 200 ¦ +----------------+

Estos conceptos son aplicables a la generalidad de funciones y subrutinas.

El segundo concepto relativo a la categorización de las variables es su

'tiempo de vida'. Los programas son procesos que, un nuestro Universo físico,consumen, al menos, tiempo. Esto es, como todo proceso físico, no se ejecutaninstantáneamente, ni, mucho menos, terminan antes de comenzar. Aún cuandoparezca ridículo hacer mención a estas limitaciones, éstas sirven para tomarconciencia de que los objetos que internamente son usados por los programasestán, entonces, también, sujetos a las mismas condiciones. Así pues, duranteel transcurso de la ejecución de un programa, las variables en la memoria dela computadora son creadas, utilizadas y dejan de existir cuando el programatermina. Pero no todas las variables 'nacen' cuando los programas se iniciany 'mueren' cuando concluyen. Es posible hacer que determinadas variables'duren' tiempos inferiores al consumido por la ejecución. Por ejemplo, ennuestro programa con la función Promedio(), la variable local 'm' es creadacuando la función es invocada, DESPUÈS de haberse iniciado el programa, ydesaparece cuando la función termina, ANTES que el programa termine. Sedenomina 'dinámica' a este tipo de variables. En contraposición, se denominan'estáticas' a aquellas variables cuyo tiempo de vida coincide con el delprograma. Todas las variables globales son estáticas. Las variables localesson, por defecto, dinámicas, pero pueden ser hechas estáticas. En tal caso,cuando una función o subrutina conteniendo variables locales estáticas esinvocada más de una vez, los valores que contenían esas variables en laúltima invocación son 'recordados'. De hecho, no se han perdido, habiéndoseconservado. El resto de las variables locales (dinámicas), al ser re-creadasen cada nueva invocación, no conservan registro alguno de sus anteriores'vidas'. De hecho, son variables distintas con el mismo nombre. Por ejemplo:

+-----------------------------------------+ ¦ defint a-z ¦ ¦ ¦ ¦ for i=k to 10 ¦ ¦ Saludar ¦ ¦ next k ¦ ¦ ¦ ¦ end ¦ ¦+--------------------------------------+ ¦ ¦¦ sub Saludar() ¦ ¦ ¦¦ STATIC i ¦ ¦ ¦¦ ¦ ¦ ¦¦ i = i + 1 ¦ ¦ ¦¦ locate i, i: print "Hola a todos !" ¦ ¦ ¦¦ ¦ ¦ ¦¦ end sub ¦ ¦ ¦+--------------------------------------+ ¦ +-----------------------------------------+produce en la pantalla el siguiente resultado:

+----------------------------- ¦Hola a todos ! ¦ Hola a todos ! ¦ Hola a todos ! ¦ Hola a todos ! ¦ Hola a todos ! ¦ Hola a todos ! ¦ Hola a todos ! ¦ Hola a todos ! ¦ Hola a todos ! ¦ Hola a todos ! ¦

La variable local 'i', al ser estática, recuerda su valor en cada nuevainvocación a 'Saludar()' y, así, la fila y columna de la sentencia LOCATE seven incrementadas. De no haberse declarado como estática, el mensaje hubierasido escrito en pantalla también 10 veces, pero todas en la misma posición.De paso, se aprecia que la declaración que hace estática a una variable localconsiste en la palabra reservada 'STATIC', sucedida por la lista de lasvariables involucradas.

Resumiendo, podemos clasificar a la variables, por su alcance, en localesy globales, y, por su tiempo de vida, en estáticas y dinámicas.

+-----------+ +---------+ +----------+

¦ VARIABLES +---------¦GLOBALES +------¦ESTÁTICAS ¦ +-----------+ ¦ +---------+ +----------+ ¦ +--------+ +----------+ +---¦LOCALES +-------¦ESTÁTICAS ¦ +--------+ ¦ +----------+ ¦ +----------+ +---¦DINÁMICAS ¦ +----------+

Errores en el Procesamiento Computacional de Cantidades Numéricas-----------------------------------------------------------------

Se planteó anteriormente que los errores de cómputo pueden filtrarse en unao más de las etapas que llevan a la implementación de la solución a unproblema. En particular, se analizará la influencia que el tratamientocomputacional de cantidades numéricas puede 'aportar'. Efectivamente, algunosprogramas son de naturaleza numérica porque modelan soluciones a problemas denaturaleza numérica. No todos los problemas son de este tipo. Por ejemplo, lainformatización de una biblioteca no es un problema numérico, aunque sí lo esel cálculo de una estructura para soportar un edificio o la resolución de unsistema de ecuaciones lineales. Este apartado está enfocado en los erroresque conlleva el tratamiento de cantidades numéricas, en particular, lasmagnitudes reales.

Vimos que los pasos para alcanzar la solución computada a un problema son:

+--------------+ +-------------------+ ¦Problema Real ¦ +--------------->¦Implementación de ¦ +--------------+ ¦ +-->¦un Programa ¦ ¦ ¦ ¦ +-------------------+ +--------------------+ ¦ ¦ +--------------+ ¦Modelo del Problema +<---¦ ++-------+ ¦ ¦Ejecución del ¦ +--------------------+ ¦ +ÂErrores¦-+ +>¦Programa ¦ ¦ ¦ +Ð----Ð-+ ¦ +--------------+ +-------------+ ¦ ¦ +-----+ +-----------+ ¦Algoritmo de +<--------- ¦---+ ¦Solución ? ¦ ¦la Solución ¦ ¦ +-----------+ +-------------+ ¦ +-------------------+

Como se aprecia, el riesgo de que aparezcan errores no es despreciable en lamedida que son múltiples los puntos de ingreso de los mismos.

Teniendo en cuenta que los problemas que en general se desean resolver sonparte de la realidad y que, como consecuencia, las soluciones halladas han deser aplicadas a ese dominio tan particular, resulta evidente que carece desentido poner un gran empeño en aumentar la exactitud de una etapa deldesarollo si los errores introducidos en alguna de las previas tiran por laborda tan loable propósito. Por ejemplo, si el modelo numérico de un problematiene una precisión de ± 10% (el modelo representa a la realidad a menos deesa incertidumbre), poco sentido tiene que el programa que implementa elalgoritmo de solución arroje resultados con muchos decimales.

Cabe a esta altura distinguir entre 'precisión' y 'exactitud'. La precisiónes un error o incertidumbre cuantificada que puede esperarse de un método,proceso o dispositivo. Por ejemplo, un termómetro puede medir la temperaturacon un error de ± 5%. Esto se interpreta diciendo que la temperatura realestá dentro de una banda de ± 5% de la indicación, aún cuando la lectura seala real. La exactitud está vinculada con la cantidad de dígitos que un método,proceso o dispositivo asegura en su resultado. Por ejemplo, si nuesttrotermómetro estuviera graduado en décimas de grado, su exactitud sería 0.1[°C]. La exactitud es una propiedad estática relacionada con la construccióndel proceso o dispositivo. En cambio la precisión es una propiedad dinámicaque depende de las condiciones en que se opera al proceso o dispositivo. Porejemplo, la exactitud del termómetro no depende de la temperatura. Esto es,su escala seguirá estando graduada en 0.1 [°C]. En cambio no ocurre lo mismocon su precisión. Si el fondo de escala del termómetro está a 100 [°C] y losumergimos en aluminio fundido, dudosamente la condición de trabajo permitasostener la especificación del 5% de error. En definitiva, cuando se pone de

manifiesto la precisión, debe acompañarse de las condiciones en que la mismase verifica.

Otros dos conceptos que caben ser distinguidos son 'falla' y 'error'. Unafalla es impredecible y es, en general, producto de un descuido ocircunstancia fortuita. Por ejemplo, un error puede dar pie a una falla. Comotal, no es entonces posible cuantificar a las fallas a menos que sea entérminos estadísticos. Los errores, en cambio, son producto de incertidumbres,la mayor parte de las veces, cuantificables y predecibles en la medida queprovienen de simplificaciones asumidas 'razonables'. La magnitud de esta'razonabilidad' -el grado de simplificación introducido- es función directade la utilidad que, aún con errores, los resultados obtenidos ofrecen.

Cuanto menos se comprendan los detalles de un problema real, mayor es lachance de que el modelo elegido para representarlo y estudiarlo contengaincertidumbres sustanciales. Por este sencillo motivo es que seguramentepasarán muchos años antes de que se desarrollen modelos numéricos capaces derepresentar confiablemente a fenómenos económicos o sociales. Y sin llegar aciencias de contenido más humanístico, la misma física ha aceptado desde haceya mucho tiempo el Principio de Incertidumbre de Heisenberg. De acuerdo almismo, la medición de un evento es un proceso que lo afecta. Comoconsecuencia, no es posible cuantificar en valores absolutamente reales alevento, cualquiera que sea. Sólo se obtiene un valor producto de lainteracción entre el evento y la medición. Este principio garantiza lapresencia de errores al tratar problemas de la realidad, aún cuando secontara con el modelo perfecto.

Gran parte de los errores que aparecen en el tratamiento numérico demodelos de la realidad se deben a que los valores iniciales se obtienen noexcentos de errores. En aquellos, sólo se pueden asegurar algunas pocas cifrasdecimales. Al irse encadenando operaciones y resultados intermedio, estospequeños errores iniciales bien pueden irse multiplicando hasta llegar avalores sin sentido. Por ejemplo, supongamos obtener a la distancia entreBuenos Aires y Bahía Blanca como 700 [Km] ± 20 [Km] (no es una malaproximación), y la distancia entre Buenos Aires y Punta Alta como 650 [Km]± 20 [Km] (tampoco demasiado mala). Si no se usa el sentido común al elaborarun programa que compute la distancia entre Punta Alta y Bahía Blanca partiendode los datos iniciales se puede obtener como resultado que la misma es de(700 - 650) [Km] ± 40 [Km], es decir, 50 [Km] ± 40 [Km]. Absolutamentegrosero. Los programas no se destacan por su sentido común de modo tal quequeda como responsabilidad del programador incorporarlo en el código.

Representación de Cantidades Numéricas--------------------------------------

A fin de representar y utilizar cantidades numéricas, la mayoría de lossistemas de cómputo utilizan una representación binaria de los mismos en lugarde su habitual representación decimal. En este sentido es importantediferenciar una magnitud numérica de su representación. En el primer caso setrata de un concepto abstracto. En el segundo, una de las infinitasmodalidades para de describirlo a fin de poder manipularlo. Una analogía va aaclarar esta diferencia:

El concepto "tamaño reducido" puede ser representado y escrito en diferentes idiomas:

-> en castellano: "pequeño" (o el mismo "tamaño reducido") -> en inglés: "small" -> en italiano: "piccolo"

Sea cual fuere el idioma -o modalidad de presentación- la idea subyacentesubsiste y permanece inalterada. Basta un mecanismo de traducción para quetanto el español, como el inglés. como el italiano entiendan de aquello deque se habla. En el caso de las cantidades numéricas ocurre algo similar. Porejemplo:

El familiar (?) número 26

-> en base 10 -decimal- se escribe lisa y lanamente como "26"

-> en base 2 -binaria- resulta "11010" -> en base 16 -hexadecimal- es "1A"

La misma idea en diferentes idiomas. El mismo contenido es distintos envases.

Más formalmente, un número decimal como el 342.105 significa y se interpretacomo:

3 * 10^2 + 4 * 10^1 + 2 * 10^0 + 1 * 10^(-1) + 0 * 10^(-2) + 5 * 10^(-3)

que no es sino una suma de múltiplos de potencias enteras de 10, múltiplosque asumen valores de un menú acotado de posibilidades: los 10 dígitosdecimales (0, 1, 2..9). Se trata entonces de una representación en basedecimal.

Lo que se ha descripto en palabras ("suma de múltiplos...") no es sino elmecanismo que permite la representación e interpretación de una magnitudnumérica en una base dada. Claro está que es perfectamente factible aplicarel mismo mecanismo a cualquier otra base. Así, por ejemplo, el número 231.02en base 4 representa a:

2 * 4^2 + 3 * 4^1 + 1 * 4^0 + 0 * 4^(-1) + 2 * 4^(-2) = 45.125 (en base 10)

(obsérvese que los dígitos disponibles ahora para ponderar a las potencias de4 son 0, 1, 2 y 3). Del mismo modo, el 11010 en base 2 -binaria- representa a:

1 * 2^4 + 1 * 2^3 + 0 * 2^2 + 1 * 2^1 + 0 * 2^0 = 26 (en base 10)

En este sistema binario, son solo dos los dígitos posibles (0 y 1) y, engeneral, se los denomina dígitos binarios o "bits".

Cuando la base es superior a la decimal, no alcanzan los 10 dígitostradicionales para representar a los símbolos de la misma y, en general, seadoptan letras consecutivas, partiendo de la "A". Así, los dígitos de la base16 -hexadecimal- son 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F. Es poreste motivo que "1A" en base hexadecimal representa a:

1 * 16^1 + A * 16^0 = 26

donde "A" corresponde a la representación hexadecimal del número decimal 10.

Cabe acotar, y es conveniente reflexionar en el hecho, que no es posible unarepresentación de información, en nuestro caso, números, con un sistema queposea menos de dos símbolos distintos, como es el caso del binario. En uneventual sistema de un solo símbolo no se pueden distinguir cambios y, comoconsecuencia, no es posible que su uso sea capaz de conllevar informacióninteligible alguna.

En general, entonces, la representación de una número en una base genérica bconformado por los dígitos

a a a ... a a a n n-1 n-2 2 1 0

cada uno tomado del conjunto {0, 1, 2, ... b-1} (obsérvese que la cantidad dedígitos del sistema de representación es uno menos que la base b)

corresponde a:

a * b^n + a * b^(n-1) + a * b^(n-2) + ... + n n-1 n-2

+ a * b^2 + a * b^1 + a * b^0 2 1 0

donde n representa la posición del dígito dentro del conjunto crecientementeordenado de dígitos de la base b.

A fin de poner de manifiesto la base en que una magnitud está representada

se adopta entonces la siguiente notación:

( a a ... a a a ) n n-1 2 1 0 b <-- Base 'b'

En consecuencia, y volviendo al ejemplo inicial:

(26) = (11010) = (1A) 10 2 16

El algortimo presentado permite la conversión de una cantidad en cualquierbase a decimal. Basta conocer la secuencia ordenada de los dígitos o símbolosque conforman la citada base. Como era de esperar, el camino contrario tambiénes posible. Un cantidad decimal es traducible a cualquier otra base (mayor oigual que 2!).

Representación de cantidades en una computadora-----------------------------------------------

En particular, y por motivos históricos y tecnológicos, las computadoras en suinmensa mayoría han utilizado y utilizan para la representación interna decantidades numéricas (y también de otra información no numérica, si bien estoescapa al interés de estos párrafos) al sistema binario (b=2, y los dígitos,por convención, 1 y 0).

La memoria de una computadora (su campo de juego, cuaderno de notas, tablerode dibujo o lo que sea con lo que se lo quiera comprar para representar alespacio de trabajo), fuera de estar caracterizada por un tamaño definido (a lafecha, en MBy) y por una velocidad de acceso (a la fecha, en uSec), tiene unarestricción adicional denominada su "ancho de palabra". Dicha memoria puedeser vista como una secuencia de casillas con direcciones, que permiten laindividualización de cada una. Cada casilla individual tiene un tamañodefinido -en By- y, siendo todas iguales, el producto de esta magnitud por lacantidad total de casillas corresponde a la capacidad total de memoria delsistema. Ahora bien, si cada casilla o celda tiene una tamaño definido, estolimita, a su vez, la cantidad de datos diferentes que se pueden representaren su interior. Por ejemplo, si el ancho de la celda fuera 1 By (8 bits),solo se podrían representar cantidades entre 00000000 y 11111111, ambas enbase binaria, o, dicho de otro modo 256 cantidades diferentes. Si el ancho depalabra fuera de 2 By, las posibilidades de representación en cada celdacercerían a 2^16. Si fuera de 4 By, las magnitudes crecerían a 2^32 (serecomienda averiguar a cuánto asciende esta última cantidad).

Del párrafo anterior surgen, al menos, las siguientes consecuencias:

(a) Si la totalidad de la memoria se dividiera en UNA SOLA celda, la capacidad de representación sería alucinante... pero de UN SOLO número. Poco útil.(b) Dado que la cantidad total de memoria disponible es, por grande que sea, limitada, hay también una cota superior para la cantidad de celdas en que se la podría dividir: si la inferior es una celda, la superior conicide con la cantidad total de bits, es decir, un bit por celda (ancho de palabra de un bit). Claro, si bien ahora la cantidad que números que simultáneamente pueden estar en la memoria es, otra vez, inmensa, cada uno sólo puede ser 0 o 1. Nuevamente, los extremos, nos llevan a consecuencias alucinántemente inútiles.(c) Correcto! la solución está en medio de ambos extremos! Y no solo esto... No solo el ancho de palabra debe ser una cantidad superior a uno y muy inferior a la capacidad total de memoria sino que se debe buscar que todas las computadoras tengan el mismo, o, al menos, se componga algún mecanismo como para que resulte tal cosa. De no ser así, no sería posible que un mismo programa funcionara en correctamente en computadoras diferentes.

Pero no solo se presenta esta restricción en la memoria del sistema de cómputosino que también a nivel de su procesador (la CPU). La memoria solo sirve alos efectos de mantener "vivas" y accesibles las cantidades, pero la realoperación entre las mismas se produce en la CPU, cuya representación internaes, por supuesto, también binaria, y de un cantidad también limitada de bits.

Es así que, si se asignan, por ejemplo, 2 By para representar a un númeroentero, las posibilidades de representación se limitan a 2^16 númerosdiferentes, por ejemplo, entre 0 y 65535 (= 2^16-1) o entre -32767 y 32768,si se adopta una convención para la representación de cantidades con signo.

Y el resto de lo enetros ? Quedan afuera. La respuesta es dura pero es la real.Cualquier intención de representar una cantidad que se salga de los límitesimpuestos o cualquier operación que dé por resultado un número excesivamentegrande dará lugar a una condición de error como producto del hecho que talmagnitud no puede ser representada. Siempre queda el recurso de ampliar lacantidad de By con que se representa al entero, pero, por lejos que se lleveel ancho, siempre van a quedar infinitos números que no van a poder serrepresentados.

Solución ? NO LA HAY. El ancho de la representación es irremediablementelimitado y no queda sino conformarse con lo que disponible.

A modo de consuelo, y que no es menor, las representaciones en generaladoptadas para los diversos tipos de datos numéricos (enteros y reales) sonsuficientemente generosas como para poder contemplar casi cualquier resultadoque surge como paso intermedio o final de los problemas de ingeniería.

Como siempre, la realidad es un poco más compleja y algo diferente a ladescripta, pero la imagen es suficientemente clarificadora (o, al menos, esafue la intención...)

Se Puede confiar en la computadora ?------------------------------------

Cuando se utilizan computadoras para la resolución de problemas numéricostales como la solución de sistemas de ecuaciones diferenciales o algebraicasse debe ser muy cuidadoso y crítico, y estar al tanto del hecho que losresultados que aparecen en pantalla no siempre se compadecen con lo quedebieran si la resolución se desarrollara a mano.

La causa de este riesgo no menor es el modo en que las computadoras almacenannúmeros reales.

En primer término, como ya se ha dicho, la representación interna deinformación numérica es en base binaria. Los números enteros y las oparcionesentre ellos pueden dar lugar a resultados que exceden el rango derepresentación previsto, originando una situación de error "por desborde".Pero toda vez que esto no ocurre (la inmensa mayoría), los resultadosobtenidos son exactos. Esto es, 2 + 2 es 4 en el pizarrón y en la computadora.No ocurre lo mismo cuando se deben representar cantidades reales. Por ejemplo,la operación

10^48 + 1000 - 10^48 = 1000 (en el pizarrón)

es evaluada como 0 (cero) por la mayoría de las PCs. Malfuncionameinto ? No.La causa consiste en que, si bien los sumandos aparecen enteros, lasmagnitudes de algunos exceden al rango de representación de los enteros y,como tales, son convertidos automática e interna a una representación denúmeros reales. La suma se convierte en una suma de reales y, producto de larepresentación de los mismos, acarrea errores que se intentarán describir.

Otro ejemplo: ejecute el siguiente programa QBASIC, pero antes escriba la lista de valores que supone debería aparecer en pantalla:

DIM E AS SINGLE

FOR E = 0 to 25 STEP 0.1 PRINT (10^E + 1) - 10^E NEXT E

Resultó lo que esperaba ?

El sistema de numeración de los números reales es uno de los triunfos

intelectuales de la humanidad. Dada su infinitud, para representar númerosreales, las computadoras se valen de una alternativa reducida denominadarepresentación en punto flotante que permite una descripción APROXIMADA delas cantidades reales.

Un número en punto flotante de t dígitos en base b es de la forma:

± .d d d d ...d * b^e (observe el punto radical a la derecha del signo) 1 2 3 4 t

donde los dígitos "d1" a "dt" formar la "mantisa" que asume valores entre 0.1y 1, "b" la "base" y "e" el "exponente" que puede tomar valores enteros entree1 y e2 (e1 <= e <= e2). Por ejemplo:

12.462 (base 10 y punto fijo) --> 0.12462 * 10^2 (punto flotante) 1101.10111 (base 2) --> 0.110110111 * 2^4 (punto flotante)

Es así que una representación en punto flotante se caracteriza por losvalores b, t, e1 y e2 (esto es, R = R(b, t, e1, e2)) y consiste de unacantidad finita de elementos espaciados entre las sucesivas potencias de labase b. Específicamente, esta cantidad es 1+(e2-e1+1)*2*(b-1)b^(t-1). Porejemplo, para R(2, 3, -1, 2), se obtiene la siguiente representación:

+-----------------------------------------------------------------+ ¦ e 2^e m1 m2 m3 m4 m5 m6 m7 m8 ¦ +-----------------------------------------------------------------¦ ¦ -1 1/2 0.000 0.001 0.010 0.011 0.100 0.101 0.110 0.111 ¦ ¦ 0 1 0.000 0.001 0.010 0.011 0.100 0.101 0.110 0.111 ¦ ¦ 1 2 0.000 0.001 0.010 0.011 0.100 0.101 0.110 0.111 ¦ ¦ 2 4 0.000 0.001 0.010 0.011 0.100 0.101 0.110 0.111 ¦ +-----------------------------------------------------------------+

Si bien se aprecia que no están equidistantes entre ellos, está claro que sonuna cantidad limitada, y, si con ellos se han de representar y operar entrelos infinitos números reales, cabe suponer que se acarrearrán errores productode las aproximaciones. Est es, solo los números que se ven en la tabla puedenser representados con exactitud. El infinito resto de los números solo van aser aproximados por alguno de ellos.

Por ejemplo, la computadora Control Data Cyber (CDC) usa registros de 60 bitspara representar a los números en punto flotante, reservando 48 bits para lamantisa y limitando el exponente a -975 <= e <= 1071 (el extraño rango para ees producto de las restricciones impuestas or el diseño de las operacionesaritméticas en el sistema CDC). La computadora DEC-VAX usa 32 bits pararepresentar a los números en punto flotante, reservando 24 para la mantisa ylimitando e a -127 <= e <= 127.

Redondeo, Recorte o Truncamiento, Desbordamiento e Insignificancia------------------------------------------------------------------

Debido a la estructura de la representación en punto flotante de númerosreales, los operadores aritméticos asociados dan lugar a la propagación deerrores derivados del hecho que, los resultados que arrojan están, a su vez,representados en punto flotante. Esto es, si X e Y son dos números reales enpunto flotante cuya representación es R(b, t, e1, e2), X * Y va a tener más det dígitos en su mantisa, pero la representación va exigir un recorte oredondeo de los menos significativos que excedan a la posición t, lo queconduce a la aparición de un error adicional, más allá del que traían X e Ydebidos a las propias limitaciones de R(b, t, e1, e2).

Se dice que un número real en punto flotante es recortado a t dígitos cuandotodos los dígitos ubicados más allá del t-ésimo son directamente descartados,sin más cambios en el resto. Alternativamente, un número real en puntoflotante es redondeado a t dígitos cuando es reemplazado por otro número enpunto flotante de t dígitos que lo aproxima con error mínimo. Esto es, si eldígitot + 1 -ésimo es 0, el número se recorta directemente a t dígitos. Casocontrario, el número se recorta a t dígitos y se suma 1 al dígito menossignificativo.

El error relativo debido a la representación en punto flotante de un númeroes, a lo sumo, b^(1-t) para el recorte y 0.5*b(1-t) para el redondeo. Porejemplo, de un error relativo de 10^(-7) en el cálculo de un número se debenesperar 6 dígitos exactos.

Las características más salientes para el recorte son que el peor errorposible es el doble que en el caso del redondeo y que el signo del errorX - fl(X) coincide con el de X (siendo fl(X) la representación de X en puntoflotante). Por su parte, las del redondeo son que el peor error posible es lamitad que en el caso del truncamiento, siendo el signo de X - fl(X) negativoen la mitad de los casos y positivo en el resto. Esto conduce a un mejor comportamien-to en lo referido a la propagación de errores en operaciones aritméticasencadenadas.

En general, se puede demostrar que fl(X) se puede escribir como:

fl(X) = X * (1 + m)

donde m es un número muy pequeño dependiente de X y, para el recorte,

-2^(-n+1) <= m <= 0

y para el redondeo,

-2^(-n) <= m <= 2^(-n)

En el ejemplo previo R(2, 3, -1, 2), si X=5/4 e Y=3/8, el resultado defl(X + Y) es 3/2 o 7/4, pero no los 13/8 reales.

Cuando el resultado de una operación excede el marco de representación paraun sistema R(b, t, e1, e2) dado, se produce un error por desbordamiento. Enel ejemplo R(2, 3, -1, 2), cualquier resultado superior a 7/2 daría lugar atal situación. Por el contrario, cuando el resultado de una operación dalugar a un número distinto de cero, pero de magnitud inferior al menor númeroque R(b, t, e1, e2) puede representar (1/4 en nuestro ejemplo). En la mayoríade la computadoreas los errores por desborde son reportados, pero los errorespor insignificancia no, siendo los resultados automática y silenciosamentereemplazados por 0.

Por ejemplo, se animaría a predecir cuántas líneas imprimirá el siguienteprograma compilado en una computadora que utiliza aritmética binaria en 32bits y redondeo ?

DIM I AS INTEGER, H AS SINGLE, X AS SINGLE

I = 0: X = 0.0: H = 0.1 DO I = I + 1 X = X + H PRINT I, X LOOP UNTIL X > 360.0

Y cuántas el siguiente ?

DIM I AS INTEGER, H AS SINGLE, X AS SINGLE

I = 0: X = 0.0: H = 0.1 DO I = I + 1 X = I * H PRINT I, X LOOP UNTIL X > 360.0

Y el siguiente ?

DIM X AS DOUBLE

X = 0.0 DO X = X + 0.1

PRINT X, SQR(X) LOOP WHILE X <> 1.0

Arriesga una explicación ? ... Si se da por vencido, la explicación es lasiguiente: Para una representación binaria en punto flotante con redondeo en32 bits (tipo SINGLE en QBASIC), la fracción 1/10 no puede ser representadacon exactitud, siendo la mejor aproximación levemente superior. La moralejaes que un error de redondeo puede alterar completamente aunque sin causa"aparente" el resultado de una computación, por lo que no se deben descuidarestos "detalles". Téngase en cuenta que las computadoras, entre otras cosas,se utilizan para controlar procesos, de mayor o menor importancia, yreflexiónese cuáles podrían ser las consecuencias si, en lugar de producirseun giro de los 360 grados previstos... o si el tercer ejemplo se hubierautilizado para controlar un proceso que se supone hubiera de ocurrir sólo 10veces...

Soluciones ?------------

Hay caminos para quitar del paso los errores introducidos por larepresentación de magnitudes reales. Una posibilidad, que los suprime en un100%, consiste en representar a los números, en particular a los reales,mediante strings. Esto es, por ejemplo, representar al número 123.45 con elstring "123.45". Si con esto bastara sería mágico. En realidad larepresentación mediante strings es solo parte de la historia. La otra partees que se requiere la reconstrucción de todas las operaciones y funcionesnuméricas para que "entiendan" esta nueva representación y sean capaces deoperar con la misma. Por ejemplo, para sumar, se puede constuir una tabla queindique el resultado de la suma de los diversos dígitos ("1" más "1" es "2",... "1" más "5" es "6",... hasta "9" más "9" es "8 pero me llevo "1").Contando con una tabla de estas características es posible operar una sumacon precisión virtualmente infinita. Y si una resta se puede definir a partirde una suma, y, a partir de ellas, se puede definir al producto y al cociente,se va construyendo un aritmética "alternativa" que opera sobre strings excentade todo tipo de errores de represenatción. Claro, hay un costo: lamanipulación de los strings durante las distintas operaciones essuperlativamente costosa en tiempo de cómputo, muchísimo más lenta que laoperación numérica directa, lo que desacredita completamente por ahora a laventaja ganada. En definitiva, la solución propuesta es válida pero su interéses, y será mientras las computadoras no sean suficientemente rápidas, soloacadémico.

----------------------------- PARTE III - APLICACIONES ----------------------

En esta tercera parte se hará uso intensivo y extensivo de los conceptos eideas planteadas en la anteriores por lo que se asume que el lector ya los hacomprendido y ha adquirido un grado razonable de destreza en su uso.

En cuanto a los tres primeros temas de esta segunda parte -ordenación,búsqueda y cálculo-, los mismos constituyen los pilares sobre los que sebasan la mayor parte de los programas en tanto que es en éstas tareas en lasque los programas emplean la mayor parte del tiempo. El otro aspecto en quese consume buena parte del tiempo de programación, si bien no el tiempo deejecución, es en el diseño de interfases de usuario. Precisamente, el cuartotema -interfases de usuario- despliega un ejemplo en el que se implementa unsistema de menúes y la edición de una planilla.

El quinto tema -listas enlazadas- presenta una forma alternativa paraorganizar la información que da pie a una gestión más flexible de la misma.

En el sexto tema -principios de computación gráfica- se presentan nocionesbásicas sobre computación gráfica interactiva en lo relacionado a lasíntesis, representación, aproximación y transformaciones de formas bi ytridimensionales.

Para cada tema se propondrán una o más implementaciones QB. Las mismas noson únicas y mucho menos las mejores. Lo que se ha intentado es conservar unestilo didáctico al elegir una solución a cada planteo de entre las muchas

posibles.

Finalmente, se adjuntan en el diskette fuentes que implementan losdiversos algoritmos reseñados y que, se sugiere, sean ensayados dentro delambiente QB a fin de estudiar su comportamiento. Para ésto resultan de sumautilidad las herramientas de debugging provistas por el ambiente(breakpoints, watchpoints, single step, instant watches, etc.).

Ordenación de Información-------------------------

A nadie escapa que el orden en cuanto abstracción puede ser considerado unconcepto subjetivo: lo que para unos puede estar ordenado, para otros no. Enrealidad, basta conocer el criterio con que algo está o ha sido acomodado paraque ese orden pase al terreno de lo objetivo. Y es importante que hayaorden ?. Por cierto que lo es. De poco sirve saber que existe la piedrafilosofal si no se la puede encontrar, i. e. si no se sabe donde está. Y nose sabe donde está mientras no se haya establecido un criterio para ubicarlaen un sitio. En un ejemplo más "práctico", si los nombres de los usuarios delservicio telefónico no estuvieran ordenados alfabéticamente de poca utilidadsería la guía telefónica. Es claro entonces que la ordenación es unaactividad, más o menos tediosa, pero importante. Y dado que se trata de unatarea fundamentalmente algorítmica -es posible establecer una o más técnicasrepetibles cuya mecánica arroja orden sobre el desorden- nada más aconsejableque proponerla como candidata a ser implementada mediante un programa.

Sin duda son infinitas las categorías, formas y colores de "cosas" sujetasa ser ordenadas. Dado que el interés de éste tema reside en el planteocomputacional de algunas técnicas de ordenación, el conjunto de "cosas" aordenar será restringido a un arreglo numérico unidimensional cuyo primerdato válido se encuentra en la celda número 1. Esto es, cada uno de losalgoritmos propuestos será aplicado a un arreglo numérico unidimensional dedimensión N que se supone previamente dimensionado y cargado con los dato aordenar distribuídos al azar. En este último sentido, el azar no reviste laimportancia de un tema menor. Por el contrario, para muchas ramas de laciencia y la tecnología es un aspecto de primordial importancia y constituyetodo un capítulo de estudio. En lo que al alcance de este texto respecta, seconsiderará una distribución azarosa a aquella cuya distribución estadísticade datos asigne probabilidad constante a todos sus componentes. En general seadoptará como criterio de ordenación a la ordenación creciente, i.e. unarreglo ordenado contandrá en su primer celda al dato menor y su última celdaal mayor.

Una característica de los algoritmos de ordenación es la de ser "internos"o "externos". En el primer caso se asume que todo el conjunto de datos aordenar se encuentra en la memoria del sistema de cómputo. En el segundo,dado su tamaño en relación a la disponibilidad de RAM -limitada-, sólo unaporción por vez puede residir en la memoria principal. La consecuencia deeste hecho es que, al incorporarse a un algoritmo los tiempos de acceso amemoria secundaria, bien puede su performance decaer sensiblemente. Por éstemotivo hay metodologías que son adecuadas según el caso. Los métodospresentados serán evaluados y comparados como ordenaciones internas, si bienalgunos de ellos son apropiados también para desarrollar ordenacionesexternas.

Hay varios aspectos a tener en cuenta al evaluar algoritmos de ordenación.Así todo, y como consideración general para todos ellos -y para comparar dostécnicas cualesquiera para resolver un problema- vale considerar como lamejor a aquella que para llegar al mismo resultado hace la utilización máseconómica de los recursos disponibles. En lo que a un programa respecta, losrecursos utilizados son tiempo y espacio de almacenamiento y, en general,ambos guardan una relación inversa. Esto es, un aumento de la velocidad deejecución suele obtenerse a costa de un incremento en la cantidad de memoriautilizada (sea esta memoria principal, espacio en disco u otra) y viceversa.Un programa muy lento puede tornarse inútil. Un programa que consume memoriaen exceso puede resultar prohibitivo. De todos modos, la tecnología estádando cada vez con mayor velocidad y con costos similares o menores, hardwaremás rápido y memoria más barata, lo que resulta un panorama auspicioso paraaplicaciones impensables hasta no hace mucho tiempo.

Ordenación por Búsqueda del Menor --------------------------------

La idea consiste en separar al arreglo mediante un puntero en dos tramos:el ordenado y el desordenado. Inicialmente el tramo ordenado estará vacío yel desordenado consistirá en todo el arreglo. En sucesivas pasadas por eltramo desordenado se señalará el dato menor, el que será ubicado en su sitioen el tramo ordenado, lo que aumentará en 1 al tamaño del mismo, disminuyendoen esa misma cantidad al del tramo desordenado. Cuando el tamaño del tramodesordenado sea cero, el arreglo habrá quedado ordenado. Por ejemplo,supongamos el siguiente escenario:

+-------------------------------------------------- ------+ A ¦ 3 ¦ 45 ¦ 46 ¦ 56 ¦ 103 ¦ 100 ¦ 2034 ¦1000 ¦ 94 ¦...¦ 128 ¦ +-------------------------------------------------- ------+ 1 2 3 4 5 6 7 8 9 N ^ Frontera ¦ +-------+ ¦ ¦ --+--------+ +-------+

A() es el arreglo de datos, de N lugares o celdas, y Frontera el puntero queseñala la separación entre el subarreglo ordenado y el desordenado. Loscontenidos de los lugares entre 1 y el apuntado por Frontera-1 estánordenados. Las celdas entre la apuntada por Frontera y el final del arreglocontienen datos desordenados. El próximo dato a ordenar se encuentra,naturalmente, dentro del segmento desordenado. Así, basta buscar en el tramoentre Frontera y el final del arreglo al menor dato (el menor de entre losaún desordenados) para ubicarlo en el sitio apuntado por Frontera mediante unintercambio. Luego se incrementa en 1 al puntero Frontera y se regresa a ladescripción que dá inicio a este párrafo. Todo esto debe ser repetido hastaque Frontera señale al lugar anterior al final del arreglo. Cuando esasituación se verifique la ordenación estará concluída.

Una implementación QB puede ser la siguiente:

+---------------------------------------------------+ ¦ defint a-z ¦ ¦ ... ¦ ¦ for Frontera = 1 to N-1 ¦ ¦ Menor = A(Frontera): MenorEn = Frontera ¦ ¦ for i = Frontera + 1 to N ¦ ¦ if A(i) < Menor then ¦ ¦ Menor = A(i): MenorEn = i ¦ ¦ end if ¦ ¦ next i ¦ ¦ swap A(MenorEn), A(Frontera) ¦ ¦ next Frontera ¦ +---------------------------------------------------+

Desde cada ubicación de Frontera + 1, el puntero i recorre todos los datoshasta el último quedando señalado por MenorEn la ubicación del menor delsubarreglo, contenido que es intercambiado luego con el dato apuntado porFrontera. A posteriori Frontera se actualiza al próximo lugar a ordenar y serepite el proceso hasta que se agota el tramo desordenado.

Resulta de utilidad didáctica ejecutar el programa que implementa estemétodo de ordenación paso a paso y observar con adecuados watchpoints cómoevolucionan las variables, en particular los punteros Frontera e i, así comoel modo en que el arreglo va quedando ordenado, un dato más en cada pasada.

Se propone como ejercitación desarrollar algoritmos similares pero queimplementen la ordenación por búsqueda del mayor, y dejando el resultado tantoen orden ascendente como descendente.

Ordenación por Burbujeo o por Decantación-----------------------------------------

Esta técnica es una de las más tradicionales y, así como la anterior,resulta bastante intuitiva en su funcionamiento. Nuevamente se vandesarrollando sucesivas pasadas o recorridas del arreglo de datos y, en cadauna de ellas, se ubica en su lugar final un nuevo dato. En principio, despuésde N-1 pasadas, el arreglo queda ordenado.

Por qué N-1 pasadas ? Basta revisar al siguiente par de hechos:

.Un arreglo de un solo dato -una variable simple- está trivialmente ordenado. .De haber más de un dato, cada pasada ubica en su posición final a un nuevo dato.

Es fácil deducir entonces que N datos necesitan las N-1 pasadas comentadas.Una deducción similar es aplicable en el caso del método anterior.

En la primer pasada se arrastra, mediante oportunos intercambios, el datomayor hasta el fondo del arreglo (celda N). En la siguiente, el mayor de losrestantes hasta el sitio inmedianto anterior al último (celda N-1). En latercera, el mayor de los restantes hasta el lugar N-2, y así siguiendo hastaagotar los datos a ordenar. Dado que los datos más "pesados" van siendollevados al fondo rápidamente mientras que los livianos van acomodándose enlos espacios que aquellos van dejando, el proceso puede verse como unaespecie de burbujeo de los livianos, o decantación de los pesados. Como sea,el resultado final es una ordenación creciente en función del "peso" de cadadato. Una implementación de la idea puede ser la siguiente:

+-------------------------------------+ ¦ defint a-z ¦ ¦ ... ¦ ¦ for i = 1 to N - 1 ¦ Se aprecia que en cada ¦ for j = 1 to N - i ¦ pasada un nuevo dato ¦ if A(j) > A(j+1) then ¦ queda en su lugar definitivo. ¦ swap A(j), A(j+1) ¦ ¦ end if ¦ ¦ next j ¦ ¦ next i ¦ +-------------------------------------+

Un par de consideraciones pueden ser hechas a partir de esta implementación.Por un lado, resulta evidente que una vez que el arreglo está ordenado ya nohacen falta más intercambios, inclusive, si el arreglo está inicialmenteordenado, no ocurre ningún intercambio. Dicho de otro modo, la ausencia deintercambios es signo de que el arreglo está totalmente ordenado. Así, sepuede disponer de un flag indicador de la ocurrencia de intercambios. Cuandose inicia cada pasada el flag es desactivado. Si al finalizar una pasada elflag permanece aún desactivado entonces no hubo intercambios y el arregloestá ordenado.

+-------------------------------------+ ¦ defint a-z ¦ ¦ const SI = 1, NO = 0 ¦ ¦ for i = 1 to N - 1 ¦ ¦ HuboIntercambio = NO ¦ ¦ for j = 1 to N - i ¦ ¦ if A(j) > A(j+1) then ¦ ¦ swap A(j), A(j+1) ¦ ¦ HuboIntercambio = SI ¦ ¦ end if ¦ ¦ next j ¦ ¦ if HuboIntercambio = NO then ¦ ¦ print "Arreglo ordenado !" ¦ ¦ stop ¦ ¦ end if ¦ ¦ next i ¦ +-------------------------------------+

Esta mejora al algoritmo le incorpora cierto grado de "inteligencia" dadoque esta nueva implementación es capaz de detectar cuándo el arreglo haquedado ordenado no haciendo más trabajo del necesario. No ocurre lo mismocon la primer implementación o con el método de ordenación por búsqueda demenor. Ambas desarrollan TODAS las pasadas sin tener en cuenta si debenhacerlo o no.

Hay una segunda mejora que hace aún más rápido a este método y se basa enel hecho que a partir del sitio donde ocurrió el último intercambio de unapasada y hasta el final del arreglo, los datos están definitivamenteordenados. Tener en cuenta este hecho significa limitar la excursión hasta elsitio en que tuvo lugar el último intercambio en la pasada previa. Para estoes necesario un puntero adicional que para cada pasada resulte actualizadoseñalando a la celda que sufrió la operación. La incorporación de esteconocimiento puede implementarse como sigue:

+---------------------------------------------+ ¦ defint a-z ¦ ¦ const SI = 1, NO = 0 ¦ ¦ ¦ ¦ UltimoIntercambioEn = N ¦ ¦ for i = 1 to N - 1 ¦ ¦ HuboIntercambio = NO ¦ ¦ for j = 1 to UltimoIntercambioEn - 1 ¦ ¦ if A(j) > A(j+1) then ¦ ¦ swap A(j), A(j+1) ¦ ¦ HuboIntercambio = SI ¦ ¦ UltimoIntercambioEn = j ¦ ¦ end if ¦ ¦ next j ¦ ¦ if HuboIntercambio = NO then ¦ ¦ print "Arreglo ordenado !" ¦ ¦ stop ¦ ¦ end if ¦ ¦ ¦ ¦ 'El ciclo 'for' hace que j desborde en ¦ ¦ ' 1 a su extremo superior ¦ ¦ next i ¦ +---------------------------------------------+

Se propone como implementación para analizar a modo de ejercicio lasiguiente en la que, para cada pasada, se lleva el dato más pesado hacia elfondo del arreglo -decantación- y, simultáneamente, el más liviano hacia eltope -flotación-. Otra vez, la ausencia de intercambios marca la finalizacióndel proceso pero ahora la zona de datos aún por ordenar tiene a ambosextremos dinámicos en tanto van creciendo simultáneamente a ambos lados lossectores de datos ordenados.

+-----------------------------------------------------------------+ ¦ defint a-z ¦ ¦ const SI = 1, NO = 0 ¦ ¦ ¦ ¦ IniZonaDesordenada = 1: FinZonaDesordenada = N ¦ ¦ do ¦ ¦ HuboIntercambio = NO ¦ ¦ for i = IniZonaDesordenada to FinZonaDesordenado-1 ¦ ¦ if A(i) > A(i+1) then ¦ ¦ swap A(i), A(i+1) ¦ ¦ HuboIntercambio = SI ¦ ¦ FinZonaDesordenada = i ¦ ¦ end if ¦ ¦ next i ¦ ¦ for i = FinZonaDesordenada to IniZonaDesordenada+1 step -1 ¦ ¦ if A(i) < A(i-1) then ¦ ¦ swap A(i), A(i-1) ¦ ¦ HuboIntercambio = SI ¦ ¦ IniZonaDesordenada = i ¦ ¦ end if ¦ ¦ next i ¦

¦ loop while HuboIntercambio = SI ¦ ¦ ¦ +-----------------------------------------------------------------+

Ordenación por Inserción------------------------

La ordenación por inserción es, tal vez, el método más intuitivo de entrelos presentados. Es lo que la mayoría haríamos si tuviéramos para ordenar unconjunto de tarjetas etiquetadas. Se apilan todas las tarjetas una detrás dela otra. Luego se comienza a avanzar desde la primera y hacia atrásrevisándolas una por una en el orden en que están. Si una aparece fuera deorden, con una etiqueta de valor menor que la previa, se comienza a volverhacia adelante, una por una, hasta hallar una etiqueta de menor valor. En esesitio debería haber estado la tarjeta fuera de orden. Luego todo continúacomosi nada hubiera ocurrido hasta que llegue la última tarjeta. Por ejemplo:

+--------------------------------+ ¦ 25 ¦ +--------------------------------+ ¦ ¦ 60 ¦ ¦ +--------------------------------+ ¦ ¦ ¦ 15 ¦ ¦ ¦ +--------------------------------+ ¦ ¦ ¦ ¦ 30 ¦ ¦ ¦-+ +--------------------------------+ ¦ ¦ ¦ ¦ 20 ¦ ¦ ¦-+ +--------------------------------+ ¦ ¦ ¦ ¦ 10 ¦ ¦ ¦-+ ¦ ¦ ¦ ¦ ¦ ¦ ¦-+ ¦ ¦ ¦ ¦ ¦-+ ¦ ¦ +--------------------------------+

Las 1ra., 2da. y 3ra. tarjeta están en orden pero la cuarta (etiquetada 15)no. Se comienza a retroceder desde la la 4ta. hasta que, en la 1ra., apareceun etiqueta menor -10-. Se decide entonces que ese es el lugar de la tarjeta15, pasando entonces a ser la 2da. El nuevo orden es ahora 10-15-20-30-60-25.Se retoma el procedimiento y se halla a la última fuera de orden. Unretroceso similar al descripto la ubica en su lugar final (el 4to.) y la pilaqueda final y totalmente ordenada.

Una implementación QB de esta técnica puede ser la siguiente:

+----------------------------------------+ ¦ defint a-z ¦ ¦ ... ¦ ¦ for i=2 to N ¦ ¦ j=i ¦ ¦ while (a(j) < a(j-1) and j>1) ¦ ¦ swap a(j), a(j-1): j=j-1 ¦ ¦ wend ¦ ¦ next i ¦ +----------------------------------------+

Ordenación QuickSort--------------------

Las técnicas de ordenación propuestas hasta el momento gozan de lasencillez de lo intuitivo. Pero gozan también de la inconveniencia de lalentitud. En este sentido se debe aclarar que con 'lentitud' se hacereferencia a que la misma tarea podría ser terminada a una mucha mayorvelocidad. Esto, así todo, no deja de ser una valoración relativa: los métodosvistos son, con toda su 'lentitud' pero corriendo a bordo de un hardwaremoderno, infinitamente rápidos si se los compara con el trabajo manual. Lamencionada lentitud comienza a ponerse de manifiesto cuando la cardinalidaddel arreglo de datos -N- se incrementa. Efectivamente, casi nadie usaría una

computadora para ordenar 10 números. Pero sí lo pensaría dos veces si setratara de 100. Y estaría fuera de duda si N valiera 1000 o más (claro, y sise dispusiera de una computadora con un programa de ordenación).

La 'lentitud' de un método de ordenación puede ser cuantificada. Inclusivees posible caracterizarla mediante una función analítica. Esa función sedenomina 'Costo' y es función, entre otras cosas, principalmente de N. Esfácil ver que ese costo está relacionado con la cantidad de intercambios ycomparaciones que deben ser hechos para completar la ordenación. A másintercambios y comparaciones, más costoso es el método -más lento-. Losmétodos vistos se dicen de tipo cuadráticos. Eso se debe a que la función deCosto que los caracteriza está en relación directa con N^2. Por ejemplo, si Nse duplica, el costo tiende a cuadruplicarse. Este Costo es el costo de lasencillez.

La ciencia de la computación ha dado otros numerosos algoritmos que, afuerza de ser menos intuitivos, son mucho más rápidos (se insiste, estadiferencia de velocidad se aprecia sólo para N grandes). El QuickSort es undigno representante de dicha categoría en que el Costo es función de N*log(N),cuya pendiente es acentuadamente más reducida que la de N^2 para valoresgrandes de N.

La idea es la siguiente: se toma al arreglo y se elige una celda a la quese considerará pivote. Luego se 'desparraman' todos los datos del arreglo, losmenores que el contenido del pivote se envía al subarreglo izquierdo y losmayores al derecho. Después de esta operación, el dato en el sitio del pivotequeda en su lugar final mientras que los subarreglos a izquierda y derechaestán internamente desordenados. Esto es, todos los datos del subarregloizquierdo son menores que el pivote, mientras que todas las claves en elsubarreglo derecho son mayores que el pivote. Lo que sigue consiste en volvera aplicar la idea expuesta a cada uno de esos subarreglos.

Si se lee con atención el párrafo anterior se observará que no parece deltodo descabellado que la propuesta funcione. De hecho funciona y a granvelocidad.

El algoritmo es de naturaleza "recursiva". Esto es, el procedimiento vapartiendo sucesivamente al problema en partes menores, cada una de las cualeses de igual naturaleza que aquella de la cual se desprende y, en consecuencia,a la que se vuelve a aplicar el mismo procedimiento. Y todo esto sigueocurriendo hasta que se verifica una condición de terminación (llamadatambién de clausura). Como dato ilustrativo, un ejemplo típico de un algoritmorecursivo es uno de los modos de definir al factorial. La definiciónmatemática:

n! = n * (n-1)! para 0! = 1

es recursiva en tanto hace uso del concepto a definir dentro de su mismadefinición ("el factorial de n resulta del producto entre n y el factorial den-1). La clausura establece la condición en que se abandona la aplicaciónrecursiva de la definición (0! = 1).

Para el caso del QuickSort, el arreglo inicial se va partiendo ensubarreglos cada vez más pequeños, y ésta división se detiene cuando el tamañode cada sub...sub-arreglo ha llegado a 1 (clausura). Un arreglo de tamaño 1está trivialmente ordenado.

Una implementación de la metodología descripta puede ser la siguiente:

+---------------------------------------------------------------+ ¦ defint a-z ¦ ¦ ¦ ¦ sub QuickSort(A(), Ini, Fin) ¦ ¦ ¦ ¦ if not (Fin <= Ini) then 'Clausura ¦ ¦ i = Ini: j = Fin: Pivote = Ini ¦ ¦ ¦

¦ do ¦ ¦ do ¦ ¦ i = i + 1 ¦ ¦ loop while i < Fin and A(i) < A(Pivote) ¦ ¦ ¦ ¦ while j > Ini and A(j) > A(Pivote) ¦ ¦ j = j - 1 ¦ ¦ wend ¦ ¦ ¦ ¦ swap A(i), A(j) ¦ ¦ loop while i < j ¦ ¦ ¦ ¦ swap A(i), A(j) 'ubico al pivote en su sitio ¦ ¦ swap A(Pivote), A(j) ¦ ¦ ¦ ¦ QuickSort A(), Ini, j - 1 'llamadas recusivas ¦ ¦ QuickSort A(), j + 1, Fin ¦ ¦ end if ¦ ¦ end sub ¦ +---------------------------------------------------------------+

Vale la pena como ejercitación intentar una traza manual del comportamientodel algoritmo para un arreglo reducido. Inclusive, es posible verificar que,a diferencia de otros algoritmos, el peor caso para el QuickSort se da cuandoel arreglo está inicialmente ordenado.

Comparación de Algoritmos de Ordenación---------------------------------------

Como se anticipó, no todos los algoritmos de ordenación hacen su trabajocon la misma eficiencia. Por otro lado, se mencionó que una medida de lamencionada eficiencia es el Costo, que contabiliza la cantidad deintercambios que tienen lugar durante el proceso de ordenamiento. Paraestablecer una comparación entre diversos algoritmos se debe conformar unatabla que, para diferentes valores de N, contenga el costo que cada métodoobtiene, parametrizada con la "modalidad de desorden inicial" del arreglo aordenar. Esto último significa que, para todos los casos comparados, el"desorden" inicial ha de ser del mismo tipo (por ejemplo, aleatorio, o enorden descendente, si los ordenamientos son ascendentes). El propósito esdescartar la eventual sensibilidad de los algoritmos al estado inicial delarreglo.

El programa ORDEN.BAS adjunto contiene la implementación como funciones detodos los métodos presentados. Cada una tiene como argumentos el arreglo aordenar y los extremos inicial y final entre los cuales desarrollar eltrabajo, devolviendo como valor de retorno el Costo obtenido. Completan alprograma el módulo principal que construye la tabla y un par de subrutinaspara establecer las condiciones iniciales de cada caso y para presentar losresultados. Simultáneamente al cómputo de costo como cantidad de intercambiosse evalúa otra manifestación del costo, cual es el tiempo empleado en cadaordenación.

De la ejecución del programa se obtiene una serie de resultados que soncaracterísticos de los comportamientos de los algoritmos desarrollados. Es deinterés observar que, si se toma como parámetro la cantidad de intercambios:

.recién para conjuntos de datos de cardinalidad superior a 500 se comienza a apreciar la ventaja del QuickSort frente a los otros métodos.

.la ordenación por búsqueda de menor es en general bastante buena. De todos modos tiene el inconveniente de ser una ordenación interna, lo que limita sus utilización a conjuntos de datos relativamente chicos.

.el burbujeo mejorado presenta el mismo costo que la ordenación por inserción, lo que era de esperar si se pone un poco de atención en la dinámica de ambos algoritmos.

Si el parámetro es el tiempo empleado:

.el burbujeo común es el menos recomendable de los algoritmos.

[completar]

En general, y en base a bien probadas técnicas de análisis de algoritmosque escapan a la finalidad de estos capítulos, se puede establecer que:

+-------------------------------------------------------------------------+ ¦ Método de Ordenación ¦ Memoria Requerida ¦ Tiempo Promedio de Ejecución ¦ +----------------------+-------------------+------------------------------¦ ¦ Búsqueda de Menor ¦ ¦ ¦ ¦ por Conteo ¦ k1 * N + k2 ¦ k1 * N^2 + K2 * N ¦ ¦ Inserción ¦ N ¦ k1 * N^2 + k2 * N ¦ ¦ Burbujeo ¦ ¦ ¦ ¦ QuickSort ¦ N + lg(N) ¦ k1 * N * lg(N) + k2 * N ¦ +-------------------------------------------------------------------------+ [completar]

El programa SORT.BAS -parte de la distribución original del MS QB 4.5-es un programa demostrativo de la dinámica y la performance de algunosalgoritmos de ordenación, incluídos los presentados en este texto.

Ordenación por Conteo---------------------

Hasta el momento, los algoritmos presentados concluyen su trabajo habiendomodificado convenientemente el orden inicial de los datos del arregloinicialmente desordenado. Pero no es ésta la única manera de arrojar luz-orden- sobre sobre las tinieblas -desorden-. Una manera alternativa consisteen dejar las cosas como están y solamente decir cómo deberían acomodarse lascosas si fueran a estar ordenadas. Esto equivale a dar como resultado de laordenación una suerte de 'mapa'. Por ejemplo, tal mapa podría interpretarsecon frases del tipo "si el arreglo de datos estuviera ordenado, el dato queahora está en la celda n, debería estar en la m", y así siguiendo. No hayduda que, obtenido el mapa, es posible, entonces, generar la ordenación, oque el mapa y el arreglo ordenado contienen la misma información en lo queal ordenamiento respecta.

Es válido objetar que el mapa estaría consumiendo un espacio de memoriaadicional, de una cardinalidad igual al espacio de datos, posiblemente sinaportar mayor velocidad al proceso de ordenamiento. Esto es cierto, perola situación normal en ordenaciones reales consiste en acomodar datos queson más complejos que simples números y cuyo desplazamiento, en consecuencia,es más costoso en tiempo. Por otro lado, y en relación al párrafo inicial deeste capítulo, dado que el orden es un concepto en cierta forma subjetivo,es posible que en más de una ocasión sea de interés conservar a un conjuntode información ordenado de acuerdo a más de un criterio. Con los métodosvistos de ordenación no se consigue sino un sólo tipo de ordenación: hacefalta contar con tantos procedimientos de ordenación diferentes como criteriosde orden se deseen implementar y la ejecución de cada uno hace que laordenación previa se pierda -por cierto, es posible ordenar por tantos métodoscomo sea de interés a otras tantas copias del arreglo original, pero éstopuede dar pie a un consumo indebido de memoria, máxime en tanto los registrosa ordenar sean complejos-. En cambio, utilizando los mapas aludidos es posiblemantener simultáneamente tantos órdenes como pudiera ser de utilidad. Sincambiar nada en el arreglo original de datos, la ejecución de cadaprocedimiento de orde nación crearía un nuevo mapa acorde al criterioimplementado.

La ordenación por conteo resulta en la creación de un mapa de lainformación ordenada en orden creciente o decreciente. La idea básicaconsiste en que la clave i-ésima en el arreglo ordenado es mayor queexactamente i-1 claves. Esto parece trivial (lo es en realidad), pero da lugara un algoritmo. Otro modo de decir lo mismo es considerando que una clave queexcede a otras n claves debe ubicarse en el lugar n+1. Basta para desarrollarel algoritmo contar -ordenación por conteo-, para cada clave, a cuántas otrasexcede. El número obtenido es índice de su posición final en el arregloordenado.

Una posible descripción del algoritmo podría ser:

+-----------------------------------------------------------------------+ ¦ Crear un arreglo mapa del mismo tamaño que el arreglo a ordenar. ¦ ¦ Para cada clave del arreglo de datos: ¦ ¦ Contar cuántas otras distintas hay presentes y asignar en la celda ¦ ¦ homóloga del arreglo mapa el resultado de la cuenta. ¦ +-----------------------------------------------------------------------+

Este algoritmo es operativo pero presenta un inconveniente: a datosiguales asigna ubicaciones iguales. Teniendo en cuenta que una vez que se hacomparado la clave i-ésima con la j-ésima no tiene ya sentido volver acomparar la j-ésima con la i-éisma se puede replantear la siguiente idea:

+-----------------------------------------------------------------------+ ¦ Crear un arreglo mapa del mismo tamaño que el arreglo a ordenar e ¦ ¦ inicializarlo en 0. ¦ ¦ Para cada clave del arreglo de datos a partir de la última: ¦ ¦ Para cada una de las claves en ubicaciones previas: ¦ ¦ Si la clave de referencia es mayor que la actual: ¦ ¦ Incrementar en uno la celda del mapa en la posición de la ¦ ¦ referencia. ¦ ¦ Sino ¦ ¦ Incrementar en uno la celda del mapa en la posición de la ¦ ¦ clave actual. ¦ +-----------------------------------------------------------------------+

Este segundo algoritmo es capaz de administrar las claves repetidas debidoa que siempre -indefectiblemente para todas las comparaciones- se produce unincremento en uno en una celda del mapa.

Es interesante destacar que el algoritmo inicial surge de la observaciónde un hecho trivial. Muchas veces ocurre lo mismo y, si bien, en general nose obtienen las soluciones más generales y eficientes, sí se aborda unaaproximación que puede ir evolucionando con el tiempo.

Indirección-----------

Se denomina de este modo a una técnica de mapeo de índices de arreglos enbase a una idea similar a la empleada en la ordenación por conteo peroaplicable a cualquier metodología de ordenación. Mediante esta estrategia seorganizan arreglos de indirección que sirven como clave de interpretación paraobtener orden a partir de desorden.

Cada celda del arreglo mapa de la ordenación por conteo, una vez ejecutadoel algoritmo, se interpreta como la posición final dentro del arreglo ordenadopara el dato en la celda homóloga del arreglo de datos. Esto es:

"Si el arreglo A() estuviera ordenado crecientemente, el dato A(i) se ubicaría en el sitio Mapa(i)."

La indirección utiliza una idea similar, también construyendo un mapa, perocuya interpretación es:

"Si el arreglo A() estuviera ordenado crecientemente, Mapa(i) contendría el índice en que se halla el i-ésimo dato ordenado en el arreglo A()."

Esto es, para listar a los datos en orden habría que ejecutar:

+------------------------------------+ ¦ 'Listado ordenado por indirección ¦ ¦ for i=1 to N ¦ ¦ print A(Mapa(i)) ¦ ¦ next N ¦ +------------------------------------+

Como ejercitación se propone analizar las diferencias a que ésta varianteda pie, en comparación con el mapa producido por el algoritmo de conteo, almomento de presentar los datos ordenados.

El arreglo o mapa de indirección es uno numérico entero de dimensión igualque el conjunto de datos. Previo a la ejecución de la ordenación debe serinicializado, lo que se consigue haciendo coincidir el contenido de cada unade sus celdas con el índice correspondiente:

+-----------------------------------------------+ ¦ 'Inicialización del arreglo de indirección ¦ ¦ for i=1 to N ¦ ¦ Mapa(i)=i ¦ ¦ next i ¦ +-----------------------------------------------+

En virtud del modo de interpretación para el arreglo de indirección, elhecho de poner inicialmente en coincidencia al contenido de cada celda con suíndice equivale a decir que el arreglo de datos, tal y como está antes de laordenación, está desordenado y, por ese motivo "cada dato está en su lugar".Trivial. Pero necesario.

A continuación se puede implementar cualquier técnica de ordenamiento. Seacual fuera la elegida, se le deben introducir sutiles variantes a fin deposibilitar que el arreglo de indirección vaya siendo actualizadoconvenientemente en tanto la ejecución progresa. Tales sutiles variantesconsisten en:

(a) Toda referencia en el algoritmo original de ordenación, dentro de una comparación, a una posición en el arreglo de datos debe hacerse por, indirectamente, intermedio del de indirección. Por ejemplo, si en el algoritmo original se pregunta por

A(i) > A(I+1)

en el algoritmo modificado debe consultarse por

A(Mapa(i)) > A(Mapa(i+1))

(b) Todo desplazamiento de datos en el algoritmo original debe ser reemplazado por el homólogo pero en el arreglo de indirección. Por ejemplo, si el algoritmo original contenía

swap A(i), A(j)

el modificado debe contener

swap Mapa(i), Mapa(j)

El arreglo de indirección indica, entonces, y a cada momento, dónde estaríaubicado cada dato después de haber sido desplazado. Por este motivo, laslecturas del arreglo de datos deben ser indirectas, mientras que para lasescrituras (cambios en la ubicación de datos), basta con modificar a lasreferencias en el mapa. Por ejemplo, la ordenación por búsqueda de menor sepodría ver del siguiente modo:

+---------------------------------------------------+ ¦ defint a-z ¦ ¦ dim A(N), Mapa(N) ¦ ¦ ... ¦ ¦ 'Inicialización del arreglo de indirección. ¦ ¦ for i = 1 to N ¦ ¦ Mapa(i) = i ¦ ¦ next i ¦ ¦ ... ¦ ¦ 'Ordenación indirecta por búsqueda de menor. ¦ ¦ for Frontera = 1 to N-1 ¦ ¦ Menor = A(Mapa(Frontera)): MenorEn = Frontera ¦ ¦ for i = Frontera + 1 to N ¦ ¦ if A(Mapa(i)) < Menor then ¦

¦ Menor = A(Mapa(i)): MenorEn = i ¦ ¦ end if ¦ ¦ next i ¦ ¦ swap Mapa(MenorEn), Mapa(Frontera) ¦ ¦ next Frontera ¦ +---------------------------------------------------+

En lo sucesivo, para obtener la información ordenada bastará utilizar alarreglo de indirección:

+--------------------------------------------+ ¦ ... ¦ ¦ 'Impresión del arreglo ordenado ¦ ¦ for i = 1 to N ¦ ¦ print A(Mapa(i)) ¦ ¦ next i ¦ +--------------------------------------------+

Por segundo ejemplo, si se tratara de una ordenación por burbujeo:

+------------------------------------------------+ ¦ DEFINT A-Z ¦ ¦ CONST SI = 1, NO = 0 ¦ ¦ DIM A(N), Mapa(N) ¦ ¦ ... ¦ ¦ FOR i = 1 TO N ¦ ¦ Mapa(i) = i ¦ ¦ NEXT i ¦ ¦ ... ¦ ¦ UltimoIntercambioEn = N - 1 ¦ ¦ FOR i = 1 TO N - 1 'Veces ¦ ¦ HuboIntercambio = NO ¦ ¦ FOR j = 1 TO UltimoIntercambioEn ¦ ¦ IF A(Mapa(j)) > A(Mapa(j + 1)) THEN ¦ ¦ SWAP Mapa(j), Mapa(j + 1) ¦ ¦ HuboIntercambio = SI ¦ ¦ UltimoIntercambioEn = j - 1 ¦ ¦ END IF ¦ ¦ NEXT j ¦ ¦ IF HuboIntercambio = NO THEN ¦ ¦ PRINT "Vector ordenado !" ¦ ¦ EXIT FOR ¦ ¦ END IF ¦ ¦ NEXT i ¦ ¦ ¦ ¦ 'Resultado ordenado ¦ ¦ FOR i = 1 TO N ¦ ¦ PRINT A(i), A(Mapa(i)) ¦ ¦ NEXT i ¦ +------------------------------------------------+

En caso de ser de interés mantener varios criterios de ordenaciónsimultáneos sobre un arreglo de datos basta, como ya se comentó, organizar unode indirección según cada uno de los criterios. De hecho, puede inclusive sermás cómodo y flexible contar con una matriz de indirección, por ejemplo, cuyacantidad de filas coincida con la cantidad de datos a ordenar y cuya cantidadde columnas corresponda al número de criterios diferentes a implementar. Porejemplo, si contamos con una matríz de indirección de N filas y 2 columnas demodo tal que la 1er. fila ordena indirectamente en modo creciente a un 2do.arreglo de datos (de tamaño N), basta invertir la 1ra. columna sobre la 2da.para obtener en la misma el mapa de indirección para el arreglo de datosordenado decrecientemente.

+----------------------------------------------+ ¦ 'En la col. 2 se obtiene el mapa inverso ¦ ¦ for i = N to 1 step -1 ¦ ¦ Mapa(i,2) = Mapa(N-i+1,1) ¦ ¦ next i ¦

+----------------------------------------------+

Un concepto importante a esta altura es el derivado de la interpretacióndel arreglo de indirección. El contenido de cada celda del mismo es un datoque debe ser interpretado y utilizado como un índice (de hecho, es un índice)y que, como tal, se utiliza para indicar o señalar un sitio en otro arreglo oarreglos. El contenido de cada celda del arreglo de indirección se dice quecontiene una 'referencia' o 'dirección' de otro arreglo y, a cada celda en síse la denomina 'puntero' (dado que su contenido apunta a un sitio en otroarreglo). El arreglo de indirección es, entonces, un arreglo de punteros y,en general, cualquier variable cuyo contenido sea utilizado para posibilitaruna referencia dinámica a otra, califica para ser un puntero. Esta temáticaserá vuelta a mencionar y utilizar en el capítulo sobre listas enlazadas.

Recuperación de Información---------------------------

La recuperación de información está relacionada con la siguientecuestión: dado un conjunto de datos o claves, está presente o no entre losmismos una clave dada ? Se trata, pues, de un problema de búsqueda.

No son pocos los algoritmos dedicados a resolver este problema, y muchomenos se trata de una cuestión resuelta. Efectivamente, contínuamente surgenideas originales y variantes que se adaptan mejor a diferentescaracterísticas, tanto del conjunto original de datos como al medio dealmacenamiento que lo soporta. Al igual que en el caso de la ordenación, esteúltimo aspecto es relevante en tanto el tamaño de los conjuntos de datosdentro de los cuales ha de ser individualizada la información es creciente,mucho más rápidamente que la disponibilidad de memoria principal, por lo quelas bases de datos han de estar contenidas en dispositivos secundarios dealmacenamiento masivo. Lo dicho apunta a que, nuevamente, se puede plantearla dicotomía entre algoritmos para búsqueda interna (en RAM) o externa (endiscos, cintas u otros medios).

Respecto de la organización del conjunto o base de datos, las mismaspueden estar o no ordenadas (respecto de la modalidad de trabajo delalgoritmo particular en cuestión). Esto es, si un conjunto de datos no guardauna relación de orden conocida, no es posible diseñar un algoritmo que tomeventaja de la organización de la misma para buscar una clave. Comoconsecuencia, la única alternativa consiste en consultar por todos y cada unode los datos. Si se conoce la relación de orden que organiza a una base dedatos es posible construir un algoritmo que utilice este hecho a fin dereducir la cantidad de preguntas que ha de hacer hasta concluir que la clavebuscada está o no presente en el conjunto. De lo antedicho se desprende queun modo idóneo de medir el costo de un algoritmo de búsqueda consiste encontar la cantidad de preguntas que deben hacerse para determinar si unaclave pertenece al mismo o no.

Así las cosas, una primera clasificación de los métodos de búsquedapodría ser la siguiente:

+----------+ +--------+ +--------------------------+ ¦ Búsqueda +---¦Interna +-----------¦ en conjuntos ordenados ¦ +----------+ ¦ +--------+ ¦ +--------------------------+ ¦ ¦ +--------------------------+ ¦ +------¦ en conjuntos desordenados¦ ¦ +--------------------------+ ¦ +--------+ +--------------------------+ +-¦Externa +-----------¦ en conjuntos ordenados ¦ +--------+ ¦ +--------------------------+ ¦ +--------------------------+ +-----¦ en conjuntos desordenados¦ +--------------------------+

Los algoritmos que se presentarán se encuadran dentro del conjunto demétodos para búsqueda interna para conjuntos ordenados y desordenados. Comoen el caso de los métodos de ordenación, el conjunto de datos está para todoslos casos constituído por un arreglo numérico entero de dimensión N (de 1 aN) y la clave estará contenida en la variable 'Clave'.

Búsqueda en Arreglos Desordenados---------------------------------

Búsqueda Secuencial-------------------

Este algoritmo de búsqueda (y una de sus variantes en el título quecontinúa) es el único tipo concebible cuando el conjunto de datos numéricos seencuentra desordenado. La idea es sencilla: recorrer completamente el arreglopreguntando en cada celda si el dato presente es el buscado.

+------------------------------------------+ ¦ defint a-z ¦ ¦ sub BusquedaSecuencial (A(), N, Clave) ¦ ¦ for i = 1 to N ¦ ¦ if A(i) = Clave then ¦ ¦ print "La clave está en"; i ¦ ¦ exit sub ¦ ¦ end if ¦ ¦ next i ¦ ¦ print "La clave no está en A()" ¦ ¦ end sub ¦ +------------------------------------------+

De más está decir que, si el arreglo está inicialmente ordenado, elalgoritmo igualmente funciona. Se debe tener en cuenta, así todo, que otrosalgoritmos que hacen uso de la organización de la información, al costo deser más complejos, son más eficientes.

Búsqueda Secuencial Mejorada----------------------------

Parece difícil mejorar un algoritmo tan sencillo como el anterior si elconjunto de datos está desordenado. Aún así es posible. El método presentadotiene un costo de 2*N. Esto es fácil de deducir dado que, en el peor caso(cuando la clave no está presente) no solo se ha tenido que preguntar

if A(i)=Clave then ... end if

N veces, sino que se debe también contabilizar la pregunta IMPLICITA en elciclo

for i=1 to N ... next i

Para que el ciclo finalice cuando la variable de control (i en este caso)llega al valor final (N en este caso), siendo que en cada pasada esincrementada en el paso (1 en este caso), es necesaria una pregunta.Implícitamente el ciclo involucra

if [VariabledeControl] = [ValorFinal] then ...

que en nuestro caso se traduce como:

if i=N then ...

Así, es fácil deducir que el costo del método es 2*N.

Trivialmente, la pregunta

if A(i)=Clave then ... end if

no es eliminable. La mejora consiste en eliminar la implícita en el ciclofor. Para ésto se asume que el arreglo A() tiene al menos N+1 celdas (para loque basta dimensionarlo convenientemente) y se copia exprofeso a la clavebuscada en el lugar N+1. Se busca entonces por todo el arreglo a la clavecon la seguridad que será encontrada, en el peor de los casos, en la celdaN+1. Efectivamente, decidir si la clave estaba en el arreglo posteriormentea su recorrida se reduce a decidir si fue hallada en el lugar N+1 o en unoanterior. En aquel caso, no estaba.

+------------------------------------------------------+ ¦ defint a-z ¦ ¦ sub BusquedaSecuencialMejorada (A(), N, Clave) ¦ ¦ A(N+1) = Clave: i = 1 ¦ ¦ do ¦ ¦ if A(i) = Clave then ¦ ¦ if i < N+1 then ¦ ¦ print "La clave está en"; i: exit sub ¦ ¦ else ¦ ¦ print "La clave no está": exit sub ¦ ¦ end if ¦ ¦ i = i+1 ¦ ¦ loop ¦ ¦ end sub ¦ +------------------------------------------------------+

En este caso, la complejidad se reduce a N+1.

Búsqueda Directa----------------

El propósito básico de cualquier algoritmo de búsqueda consiste en decidirautomáticamente si una clave está o no presente dentro de un conjunto -basede datos-, y tanto mejor será la metodología cuanto menor sea el tiempo y lacantidad de recursos empleada. Por increíble que resulte existe un algoritmoque con UNA SOLA consulta es capaz de decidir sobre la presencia de una clavedentro de un conjunto.

Supongamos que las claves son numéricas y que, en lugar de ser utilizadascomo contenido de un arreglo son utilizdas como índices, cuyos contenidossolamente indican ESTA/NO_ESTA. Una base de datos de las citadascaracterísticas y que contuviera a las claves 2 y 7 tendría la siguienteconfiguración:

+------------------------------------------------------------ ¦no ¦SI ¦no ¦no ¦no ¦no ¦SI ¦no ¦no ¦no ¦no ¦no ¦no ¦no ¦no ... +------------------------------------------------------------ 1 2 3 4 5 6 7 8 9 10 11 12 13 14

Para saber si una clave está presente (como consecuencia de haber sidoalguna vez dada de alta) basta la consulta:

+------------------------------------------------------+ ¦ defint a-z ¦ ¦ sub BusquedaDirecta(A(), N, Clave) ¦ ¦ ¦ ¦ if A(Clave)=SI then ¦ ¦ print "La clave ";Clave;" está presente" ¦ ¦ else ¦ ¦ print "La clave ";Clave;" NO está presente" ¦ ¦ end if ¦ ¦ ¦ ¦ end sub ¦ +------------------------------------------------------+

y los procedimientos para dar de baja y alta son totalmente intuitivos:

+---------------------------------------+ ¦ ... ¦ ¦ A(Clave)=SI 'Clave dada de alta ¦ ¦ ... ¦

¦ A(Clave)=NO 'Clave dada de baja ¦ +---------------------------------------+

La desconfianza nos hace pensar que tamaño beneficio debe venir con algúncosto. Efectivamente. Si se observa con un poco de atención se apreciará queel tamaño del arreglo no puede ser menor que la mayor clave a almacenar,independientemente de la cantidad de claves que en un momento dado haya dadasde alta. Por ejemplo, si la clave 100000 ha de poder estar representada en labase de datos, el arreglo deberá dimensionarse con, al menos, esa cantidad deceldas. En definitiva, el costo del acceso inmediato es un consumo desmesuradode memoria.

Felizmente se han planteado metodologías para, conservando la velocidad deacceso, reducir notoriamente la cantidad de memoria empleada. Está fuera delalcance de este texto su desarrollo pero la idea se basa en un mapeo entre elespacio de las claves y el espacio de las direcciones consecutivas de losarreglos a través de funciones denominadas de 'funciones de hashing'.

Autorregulación---------------

Este título encierra una idea sencilla para mejorar la performancedinámica de los dos algoritmos presentados. Ambos se basan en una búsquedasecuencial y tanto más rápido encontrarán las claves buscadas cuanto máscerca estén las mismas del punto de inicio de la búsqueda. Si el arreglo dedatos no ha de estar subordinado a ningún criterio de orden nada impediríaque se cambie su organización interna, i.e., la secuencia de sus datos.Basado en ésto es que se propone una metodología para agilizar la búsquedasecuencial. La idea consiste en, cada vez que una clave buscada esencontrada, intercambiarla con la anterior:

+-----------------------+ ¦ ... ¦ ¦ if A(i)=Clave then ¦ ¦ ... ¦ ¦ swap A(i), A(i-1) ¦ ¦ else ¦ ¦ ... ¦ +-----------------------+

Con el uso del algoritmo, las claves que más veces han sido buscadas (las másrequerida) se van acomodando automáticamente al principio del arreglo lo quemejora su tiempo de acceso. Por supuesto que el concepto tiene baseestadística y sólo se puede apreciar la mejoría para un número grande deconsultas, y no par una en particular.

Búsqueda en Arreglos Ordenados------------------------------

Para todos los métodos de búsqueda que continúan se asume que el arreglode datos se halla completamente ordenado, por ejemplo, en modo creciente. Tresmodos hay de llegar a esta situación. Si el arreglo de datos en el que buscares dinámico (sus datos cambian en el tiempo), uno consiste en ordenarlo (conalgún algoritmo de ordenación apropiado) previo a la búsqueda. Una segundaposibilidad consiste en tenerlo siempre ordenado, tomando los recuadosnecesarios como para que cada nuevo dato que se da de alta sea ubicado en susitio en base a un esquema de ordenamiento previsto. La tercer alternativa escasi trivial y consiste en que se trate de un arreglo ya ordenado y estático.Sea cual fuera la causa de contar con un arreglo ordenado, esta propiedad haceque se puedan implementar métodos bastante más eficientes. Sin ir más lejos,en estas condiciones bastan un par de consultas previas a la aplicación decualquier algoritmo para decidir si tiene sentido o no seguir adelante con labúsqueda:

+-------------------------------------------------------+ ¦ defint a-z ¦ ¦ const NOESTA = -1 ¦ ¦ ... ¦ ¦ if A(1) > Clave or A(N) < Clave then ¦ ¦ print "La clave no está en el arreglo." ¦

¦ stop ¦ ¦ else ¦ ¦ ClaveEn = MetodoGenericoDeBusqueda(A(),N,Clave) ¦ ¦ if ClaveEn = NOESTA then ¦ ¦ print "La clave no está presente en A()." ¦ ¦ else ¦ ¦ print "La clave está en "; ClaveEn ¦ ¦ end if ¦ ¦ end if ¦ ¦ ... ¦ +-------------------------------------------------------+

Una aplicación importante de estos métodos de búsqueda sobre arreglosordenados es en algunos algoritmos de ordenación de entre los ya presentados.Por ejemplo, en la ordenación por inserción todas las claves entre la 1ra. yaquella cuya ubicación final se está buscando, están ordenadas. Si bien elproblema se resolvió en su momento con una búsqueda secuencial nada impidereemplazar la misma por otra más eficiente. Por ejemplo, de ser reemplazadapor una búsqueda binaria -que se presenta más adelante-, el nuevo algoritmopodría denominarse ordenación inserción binaria y sería, a todas luces, máseficiente.

Búsqueda por Pasos------------------

El criterio presentado precedentemente no sólo resulta válido para elarreglo completo sino también para un tramo cualquiera del mismo (unsubarreglo). Esto posibilita ir descartando rápidamente sectores completosdel arreglo hasta limitar la búsqueda exhaustiva a un sub-arreglo de dimensiónigual a la del paso adoptado.

+-----------------------------------------------------+ ¦ defint a-z ¦ ¦ function BusquedaPorPasos (A(),N,Clave) ¦ ¦ ¦ ¦ BusquedaPorPasos = NOESTA ¦ ¦ ¦ ¦ for i = 1 to N step Paso ¦ ¦ if A(i) > Clave then ¦ ¦ for j = i-Paso to i ¦ ¦ if A(j) = Clave then ¦ ¦ BusquedaPorPasos = j: exit function ¦ ¦ end if ¦ ¦ next j ¦ ¦ end if ¦ ¦ next i ¦ ¦ ¦ ¦ if (N mod Paso) = 0 then ¦ ¦ exit function ¦ ¦ else ¦ ¦ for i = N-Paso+1 to N ¦ ¦ if A(i) = Clave then ¦ ¦ BusquedaPorPasos = i: exit function ¦ ¦ end if ¦ ¦ next i ¦ ¦ end if ¦ ¦ ¦ ¦ end function ¦ +-----------------------------------------------------+

El primer ciclo for va haciendo avanzar de a Paso al índice del arreglomientras el valor hallado no supere al buscado. Si ésto ocurre, la clave, deestar presente, pertenece al sub-arreglo de longitud Paso inmediato anterior.Si Paso es es submúltiplo de N, en el peor caso, el ciclo for llegóexactamente al extremo N. De no ser así quedaron celdas sin verificar. Elúltimo ciclo for se encarga de revisarlas.

Surge la siguiente pregunta: Cuál será un valor adecuado, sino óptimo,para el valor del incremento Paso ? La deducción de la respuesta essencilla. Si la clave no está, el costo es función directa de

N/Paso + Paso

donde N/Paso corresponde a la consulta en el extremo de cada sub-arreglo yPaso a la correspondiente a todas y cada una de las celdas del último tramo.Como se busca un valor óptimo para Paso que minimice el costo, basta derivare igualar a cero. +--------------------+ -N/PasoOptimo^2 + 1 = 0 => ¦PasoOptimo = N^(1/2)¦ +--------------------+

Búsqueda Binaria----------------

La búsqueda binaria adopta un criterio similar al anterior pero en el queel paso ya no es una constante y, además, puede tomarse en avance o enretroceso. La idea consiste en ir descartando siempre la mitad del subarregloque no contiene a la clave buscada. Por ejemplo, la consulta inicial por eldato en la posición central del arreglo permite descartar segura ycompletamente medio sub-arreglo. Si se repite el procedimiento en el mediosub-arreglo restante, se pueden ahora descartar la mitad de lo que queda, esdecir, un cuarto de los datos, quedando el otro cuarto sujeto nuevamente almismo algoritmo. Así siguiendo se llega a un subarreglo de longitud unitariaque concluye la búsqueda, resulte ésta exitosa o no.

+---------------------------------------------------+ ¦ defint a-z ¦ ¦ function BusquedaBinaria(A(), N, Clave) ¦ ¦ ¦ ¦ const NOESTA=-1 ¦ ¦ ¦ ¦ Ini=0: Fin=N+1 ¦ ¦ do ¦ ¦ Med=(Ini+(Fin+1))/2 ¦ ¦ if A(Med)>=Clave then ¦ ¦ if A(Med)=Clave then ¦ ¦ BusquedaBinaria=Med: exit function ¦ ¦ else ¦ ¦ Fin=Med ¦ ¦ end if ¦ ¦ else ¦ ¦ Ini=Med ¦ ¦ end if ¦ ¦ loop while Fin-Ini > 1 ¦ ¦ ¦ ¦ BusquedaBinaria=NOESTA ¦ ¦ ¦ ¦ end function ¦ +---------------------------------------------------+

Los punteros Fin e Ini van acotando el sub-arreglo dentro del cual sebusca la clave.

Se presenta a continuación una implementación recursiva de la misma idea.

+-------------------------------------------------------------------------+ ¦ const NOESTA=-1, ESTA=0 ¦ ¦ ... ¦ ¦ defint a-z ¦ ¦ function BusquedaBinariaRecursiva(A(), Ini, Fin, Clave) ¦ ¦ ¦ ¦ if Fin-Ini=1 then ¦ ¦ BusquedaBinariaRecursiva=NOESTA: exit function ¦ ¦ else ¦ ¦ Med=((Fin+1)+Ini)/2 ¦ ¦ if A(Med)>=Clave then ¦ ¦ if A(Med)=Clave then ¦ ¦ BusquedaBinariaRecursiva=ESTA: exit function ¦ ¦ else ¦ ¦ Fin=Med ¦

¦ end if ¦ ¦ else ¦ ¦ Ini=Med ¦ ¦ end if ¦ ¦ BusquedaBinariaRecursiva=BusquedaBinariaRecursiva(A(),Ini,Fin,Clave) ¦ end if ¦ ¦ ¦ ¦ exit function ¦ +-------------------------------------------------------------------------+

Búsqueda por Interpolación--------------------------

Aún cuando el conjunto de claves sobre el que se despliega una búsquedaesté ordenado, la distribución de las mismas puede arrojar muy diversosresultados. Por ejemplo, si la distribución de los datos es lineal, ladistancia numérica entre claves consecutivas se va a mantener razonablementeconstante. Si es exponencial, la mencionada distancia se va a irincrementando paulatinamente con una velocidad, a su vez exponencial. Elconocimiento previo de la distribución de los datos ordenados puede serutilizado beneficiosamente en un algoritmo de búsqueda que, en función de lamisma, desarrolle una interpolación entre un par de extremos -en principiolos datos primero y último-. Este proceso lo desarrollamos inconcientementecuando, por ejemplo, hacemos una búsqueda en un diccionario. Si la palabraque buscamos comienza con la letra 'B', seguramente iniciaremos la búsquedaen la primera parte del libro. Caso contrario, de comenzar nuestra clave con'X', no dudamos en iniciar desde el final. Del mismo modo, una 'L' nos haríacomenzar por la mitad. Inconcientemente asumimos una distribuciónmedianamente lineal de las palabras y utilizamos esta presunción paraorientar nuestro intento. De más está decir que, al igual que en el caso deldiccionario, sería extraordinario si la clave fuera encontrada en el primerintento. De hecho, es muy probable que, a partir de lo que encontremos en elsitio del primer intento, sea necesario comenzar a retroceder o a avanzar conel mismo u otro criterio hasta decidir que la clave está o no presente. Lainterpolación consiste entonces en suponer una distribución para el conjuntode claves y, basado en la misma, calcular el sitio en que posiblemente seencuentra la clave. Tanto más cerca se estará de su posición real cuanto másacertada sea la suposición. Si la misma es suficientemente buena (lo que sóloocurre si (a) se conoce con anticipación la distribución real de la claves o(b) se cuenta con mucha suerte), la búsqueda en progreso o en regreso puedeir avanzando.

Se presentará el caso simple de interpolación lineal como primeraaproximación a fin de proceder con un algoritmo alternativo una vez descartadoun primer tramo del conjunto de datos. Efectivamente, si el conjunto de datosfuera contínuo, sería factible una aplicación iterativa o recursiva delalgoritmo, como se puede verificar, por ejemplo, aplicando la idea a labúsqueda del cero de una función monótona dentro de un intervalo que contengauno. Pero al ser el conjunto de datos -el arreglo-, discreto y estar cada unoubicado en sitios discretos -los lugares del arreglo-, el algoritmo, tal ycomo es planteado y en función de la distribución de datos y de la clavebuscada, bien puede no terminar. Por ese motivo la aplicación de este métodosirve solo al propósito de ser una primer aproximación al sitio de la clavebuscada.

+------------------------------------------------------+ ¦ defint a-z ¦ ¦ 'solo una 1er. aproximación ¦ ¦ sub BusquedaPorInterpolacion(A(), N, Clave, ClaveEn) ¦ ¦ ¦ ¦ Ini=1: Fin=N ¦ ¦ i=Ini+(Fin-Ini)*(Clave-A(Ini))/(A(Fin)-A(Ini)) ¦ ¦ if A(i)>=Clave then ¦ ¦ if A(i)=Clave then ¦ ¦ ClaveEn = i ¦ ¦ exit sub ¦ ¦ else ¦ ¦ OtroAlgoritmoDeBusqueda A(), Ini, i, Clave ¦ ¦ end if ¦ ¦ else ¦

¦ OtroAlgoritmoDeBusqueda A(), i, Fin, Clave ¦ ¦ end if ¦ ¦ ¦ ¦ end sub ¦ +------------------------------------------------------+

Listas Enlazadas----------------

A fin de que la información pueda ser procesada en un entornocomputacional es necesario que esté soportada (representada o contenida) enun formato compatible con las herramientas que la utilizan. Hasta el momentofueron dos los tipos de soportes utilizados: variables simples yarreglos (de una o más dimensiones). En lo que al QB respecta hay untercer tipo de contenedor y que son las variables estructuradas o registrosdefinidos por el usuario (la bibliografía específica es amplia y clara eneste aspecto). Hay otros tipos muy difundidos entre los ambientes deprogramación, entre ellos las listas enlazadas y los árboles. Se concentrarála atención en las primeras. QB no conlleva a este tipo de dato como nativoaunque sí puede hacer una buena simulación del mismo.

Cuando se presentó a la indirección como alternativa para el mantenimientode información ordenada mediante varios criterios simultáneamente se mencionóque la técnica consistía, en lugar de ordenar al conjunto de datosdirectamente (lo que admite un solo criterio rector por vez), en mantenerordenado indirectamente al espacio de direcciones del arreglo que soporta ala información original, la que a su vez se mantiene intacta. A fin de queesta técnica se pueda implementar es necesario conservar en un arregloauxiliar al espacio de direcciones -índices- del arreglo de datos. La ideaque se pretende resaltar es que se utilizan dos arreglos, uno conteniendodatos (las claves, numéricas o alfanuméricas) y otro conteniendo direcciones(exclusivamente números enteros), que, aún pudiendo ambos arreglos contenernúmeros, sus significados tan radicalmente distintos hacen carecer de sentidopensar en su confusión, deliberada o no. Supongamos el siguiente esquema.

ArregloDeDatos() ArregloDeIndireccion()

¦ ... ¦ ¦ ... ¦ +---------------¦ +---------------¦ 5 ¦ 187897 ¦ 5 ¦ 3 ¦ +---------------¦ +---------------¦ 6 ¦ -3.45 ¦ 6 ¦ 9 ¦ +---------------¦ +---------------¦ 7 ¦ 12.567 ¦ 7 ¦ 23 ¦ +---------------¦ +---------------¦ ¦ ... ¦ ¦ ... ¦

El concepto detrás del arreglo de indirección es el de puntero oapuntador. El contenido de cada celda del arreglo de indirección, en tantodirección, indica o apunta a una celda del arreglo de datos:

ArregloDeDatos() ArregloDeIndirección()

¦ ... ¦ ¦ ... ¦ +---------¦ +----------¦ 3 ¦ 23.456 ¦<-----------------+-- (3) ¦ 5 +---------¦ +----------¦ ¦ ¦ +-----------+---(9) ¦ 6 ... ¦ +----------¦ ¦ ¦ ¦ +---+---(23) ¦ 7 +---------¦ ¦ ¦ +----------¦ 9 ¦ -1.123 ¦<-----+ ¦ ¦ ... ¦ +---------¦ ¦ ¦ ¦ ¦ ... ¦ ¦ ¦ ¦ +---------¦ ¦ 23 ¦ 100000.0¦<-------------+

+---------¦ ¦ ... ¦

Así, al contener ArregloDeIndireccion(5) un 3, se interpreta que se estáhaciendo referencia indirecta a la ArrregloDeDatos(3) (o, lo que es lo mismo,a ArregloDeDatos(ArregloDeIndireccion(5)).

En este mismo sentido, una estructura enlazada consiste en la utilizaciónde uno o varios arreglos destinados a contener direcciones en conjunto conuno o más arreglos para datos. La complejidad de la representación va desdeconjuntos de un solo campo de datos y enlace simple a estructuras demúltiples campos de datos y múltiples enlace. Partiendo del caso más sencillo,el modelo abstracto que se propone es el siguiente:

(lista de registros)

H A L A L A L +---+ +-----------+ +-----------+ +-----------+ ¦ --+--->¦ ¦ -+--->¦ ¦ -+-->¦ ¦ -+-+ +---+ +-----------+ +-----------+ +-----------+ ¦ (cabecera) +------------------------------------------+ ¦ +-----------+ +-----------+ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +-----------+ +-----------+ --- A L A L (fin de lista)

Asumiendo que las 'A' representan a campos de datos mientras que las 'L'a campos de enlace, junto con la H -cabecera-, se aprecia que la listagraficada pone de manifiesto un orden: cada registro (par 'AL') tiene unprecedente y un subsecuente, habiendo una cabecera -H- que indica cuál es elprimer registro y una señal de finalización de la lista (indicando que nocontinúan más registros). Y si hay un orden en un conjunto de datos, el mismoestá organizado y en consecuencia es posible afectarlo de las operaciones queson propias de las bases de datos. Así, la lista enlazada constituye, delmismo modo que los arreglos, una posibilidad válida para la representación yalmacenamiento de datos en un contexto computacional. Se verá a continuaciónen qué puede una estructura más compleja como ésta presentar ventajas y cómose la construye a partir de las herramientas de que dispone el QB.

Construcción -simulación- de una lista enlazada-----------------------------------------------

Observe el siguiente trozo de código.

+-----------------------------------------------------+ ¦ const N=1000, FinDeLista=-1 ¦ ¦ dim A(N) as single, L(N) as integer, H as integer ¦ ¦ ¦ ¦ for i=1 to N-1 ¦ ¦ L(i)=i+1 ¦ ¦ next i ¦ ¦ L(N)=FinDeLista: H=1 ¦ ¦ ¦ +-----------------------------------------------------+

El ciclo for impone a cada i del arreglo L() el dato i+1, agregando a L(N) lamarca FinDeLista y fijando H con 1. Si presentamos gráficamente el resultadointerpretando a L() como un arreglo de direcciones obtenemos:

(cabecera) +-----+ A() L() ¦ --+--+ +------+ +------+ +-----+ +->1 ¦ ¦ +-------+- 2 ¦ H +------¦ ¦ +------¦ ...----+

¦ ... ¦ +-------... ¦ ... ¦ +------¦ ¦ +------¦ i ¦ ¦<+ +--------------+-i+1 ¦

+------¦ ¦ +------¦ i+1¦ ¦<--+ +------------+-i+2 ¦ +------¦ ¦ +------¦ i+2¦ ¦<----+ +---------+-i+3 ¦ +------¦ ¦ +------¦ i+3¦ ¦<-------+ +------+-i+4 ¦ +------¦ ¦ +------¦ i+4¦ ¦<----------+ +--+-i+5 ¦ +------¦ ¦ +------¦ ¦ ... ¦ ...--------+ ¦ ... ¦ ¦ ¦ +-------... ¦ ¦ +------¦ ¦ +------¦ N ¦ ¦<-----+ ¦ -1--+----+ +------+ +------+ --- (fin de lista)

Si a partir de la cabecera H se sigue la lista de vinculaciones (flechas) porel campo L() se obtiene una lista de idénticas características a la de laestructura abstracta presentada inicialmente.

H A L A L A L +---+ +-----------+ +-----------+ +-----------+ ¦ --+--->¦ ¦ -+--->¦ ¦ -+-->¦ ¦ -+-+ +---+ +-----------+ +-----------+ +-----------+ ¦ (cabecera) +------------------------------------------+ ¦ +-----------+ +-----------+ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +-----------+ +-----------+ --- A L A L (fin de lista)

Es destacable el hecho que esta última lista pueda ser recorridatotalmente -luego, utilizable- contando nada más con el esquema anterior yque, curiosamente, en ese mismo esquema no se hace referencia explícita aninguna dirección de ninguno de los arreglos involucrados. Todo funciona comosi la nueva estructura creada pudiera utilizarse con independencia de losarreglos que le dieron orígen. De hecho, en adelante, no volverá a hacersereferencia explícita a dirección alguna de ninguno de los arreglos.

Recorrido de una lista enlazada-------------------------------

El siguiente listado posibilita el recorrido básico de una lista de lascaracterísticas presentadas y asumiendo que la misma ya ha sido construida.

+-----------------------------+ ¦ const FinDeLista=-1 ¦ ¦ ... ¦ ¦ Y=H ¦ ¦ while Y<>FinDeLista ¦ ¦ HacerAlgo(Y) ¦ ¦ Y=L(Y) ¦ ¦ wend ¦ +-----------------------------+

Y asume el rol de puntero que recorre la lista. HacerAlgo() es una funcióngenérica que toma al registro apuntado por Y como argumento con algún finespecífico. Inicialmente Y apunta al primer registro y, si no está indicadocon la marca de fin de lista -significando que hay al menos un registropresente-, HacerAlgo() lo procesa. A posteriori, 'Y=L(Y)' desplaza al punteroY al registro siguiente y la secuencia se repite. Evidentemente, HacerAlgo()será invocada tantas veces como registros haya en la lista. Por ejemplo, si sedesea conocer cuál es la cantidad de registros en la lista, el código se puedereemplazar por:

+--------------------------------------------------------------+ ¦ const FinDeLista=-1 ¦ ¦ ... ¦ ¦ Y=H: CantidadDeRegistros=0 ¦ ¦ while Y<>FinDeLista ¦ ¦ CantidadDeRegistros=CantidadDeRegistros+1 ¦ ¦ Y=L(Y) ¦

¦ wend ¦ ¦ ¦ ¦ print "En la lista hay";CantidadDeRegistros;" registros." ¦ ¦ stop ¦ +--------------------------------------------------------------+

y si se desea comprobar si determinado dato está presente en la lista:

+--------------------------------------------------------------+ ¦ const FinDeLista=-1 ¦ ¦ ... ¦ ¦ input "Dato a buscar ";DatoBuscado: Y=H ¦ ¦ while Y<>FinDeLista ¦ ¦ if A(Y)=DatoBuscado then ¦ ¦ print "El dato";DatoBuscado;" está presente": stop ¦ ¦ else ¦ ¦ Y=L(Y) ¦ ¦ end if ¦ ¦ wend ¦ ¦ ¦ ¦ print DatoBuscado;" no está en la lista" ¦ ¦ stop ¦ +--------------------------------------------------------------+

En general, dado que la lista enlazada no es sino una forma alternativa paraalmacenar y administrar datos, mismos que residen en el campo A() -campo dedatos- de nuestra lista, es sobre el mismo que se desarrollan las operacionesque dan sentido a la utilidad de la lista y que, genéricamente, se englobarancomo 'HacerAlgo()'. Tal fue el caso de la búsqueda por un dato.

Lista de Diponibles-------------------

Hemos visto cómo se articula internamente una lista enlazada simple, capazde soportar a un conjunto de datos. Pero en general los conjuntos de datos sonentidades sujetas a cambiar, i.e., la realidad que representan suele serdinámica y, en consecuencia, los datos deben cambiar con ella. Esto da origena que la lista enlazada deba tener como propiedades la posibilidad de sermoficada, tanto para dar de alta a nuevos registros como para dar de baja aregistros que ya no sea de interés mantener enlistados. De dónde salenregistros frescos destinados a ser dados de alta ?. A qué sitio van a pararlos registros que se dan de baja ?. La respuesta a éstas preguntas encierrauna de las razones que justifican la complicación adicional que, en principio,parecen ofrecer estas listas frente a los arreglos.

Tal vez a alguno de los lectores ya se le haya ocurrido que una listaenlazada presenta cierta similitud con el caso ferroviario. Efectivamente,esto es así no sólo en la forma sino también en la dinámica, como se iráviendo a medida que sigamos avanzando. Por ejemplo, translademos laspreguntas recién planteadas al caso de los trenes. Cuando se desea incorporarun vagón a un tren, de dónde se consigue ?. Cuando se quita un vagón de unconvoy, dónde se lo ubica ? Un sistema ferroviario medianamente organizadodebe mantener un control sobre el sitio en que están sus trenes así como sobrela situación de sus vagones disponibles. Es más, por una sencilla razón deeconomía, parece lógico que los vagones libres estén siempre vinculados entresí, formando un tren de vagones en disponibilidad y ubicados en una estaciónconocida. Así, cuando uno o varios vagones han de ser agregados a un tren,basta extraerlos del tren de vagones libres -son dados de baja de entre losdisponibles para ser dados de alta en el tren-. Cuando uno o varios vagones deun tren han de salir de servicio temporalmente, a fin de poder ser más tardereutilizados, en el mismo tren del que salen O EN OTRO, es necesarioengancharlos en la formación de vagones libres -a la inversa que en el casoanterior, son dados de baja de un tren en viaje para ser dados de alta en eltren de disponibles-. COROLARIO: los vagones del sistema ferroviario no secrean ni se destruyen. Sólo cambian de tren. En otros términos, la cantidad devagones se conserva; la divergencia de la cantidad de vagones es cero; elsistema ferroviario es conservativo.

Sobre la base de esta analogía podemos deducir que, en un sistema de listasenlazadas existen siempre al menos dos listas. Una, la lista 'útil' en la que

se almacena y administra la información que representa a la realidad. La otra,una LISTA DE REGISTROS DISPONIBLES, de la que se extraen los registrosdestinados a dar de alta a nuevos datos en la primera lista, y a la que sedevuelven los dados de baja de la misma. Gráficamente:

H A L A L A L +---+ +-----------+ +-----------+ +-----------+ ¦ --+--->¦ ¦ -+--->¦ ¦ -+-->¦ ¦ -+-+ +---+ +-----------+ +-----------+ +-----------+ ¦ (cabecera) +------------------------------------------+ (lista útil) ¦ +-----------+ +-----------+ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +-----------+ +-----------+ --- A L A L (fin de lista)

HDISP A L A L A L +---+ +-----------+ +-----------+ +-----------+ ¦ --+--->¦ ¦ -+--->¦ ¦ -+-->¦ ¦ -+-+ +---+ +-----------+ +-----------+ +-----------+ ¦ (cabecera) +------------------------------------------+ (disponibles) ¦ +-----------+ +-----------+ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +-----------+ +-----------+ --- A L A L (fin de lista)

Como se ve, ambas listas se articulan del mismo modo. La diferencia entreambas consiste en que, dado que sus propósitos específicos son diferentes, suutilización es distinta. Por ejemplo, la incorporación de registros a la listaútil se hace de acuerdo a un criterio de aplicación. I.e., si va contenernúmeros de documentos, parece razonable que cada uno que vaya siendo dado dealta sea ubicado en orden numérico respecto de los ya existentes. Así, lalista se mantendrá contínuamente ordenada. No ocurre lo mismo con la lista dedisponibles. La misma tiene registros que, bien han sido dados de baja o bienno han sido nunca utilizados. Por ese motivo, el contenido de su campo dedatos es irrelevante -basura-, y no tiene sentido pensar en algún criterio deordenamiento el momento de reincorporarle registros dados de baja de la listaútil. El único criterio es el de mayor sencillez. Cuál es el sitio en el quees más rápido y sencillo el acceso a una lista enlazada ? Por su cabecera-HDISP, en este caso-.

Z A L +---+ +-----------+ ¦ --+--->¦ ¦ -+-- +---+ +-----------+

HDISP A L A L A L +---+ +-----------+ +-----------+ +-----------+ ¦ --+--->¦ ¦ -+--->¦ ¦ -+-->¦ ¦ -+-+ +---+ +-----------+ +-----------+ +-----------+ ¦ (cabecera) +------------------------------------------+ (disponibles) ¦ +-----------+ +-----------+ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +-----------+ +-----------+ --- A L A L (fin de lista)

Si el registro apuntado en Z ha de ser incorporado a la lista HDISP, nada mássencillo que:

+---------------------------+ ¦ L(Z)=HDISP 'Paso nro. 1 ¦ ¦ HDISP=Z 'Paso nro. 2 ¦ +---------------------------+

Este sencillo par de sentencias da pie a:

Z A L +---+ +-----------+ ¦ --+--->¦ ¦ -+----+ +---+ ¦ +-----------+ ¦ Paso nro. 1

Paso ¦ +----------------+ nro.2¦ ¦ HDISP ¦ ¦ A L A L A L +---+ ¦ ¦ +-----------+ +-----------+ +-----------+ ¦ --+------+ +>¦ ¦ -+--->¦ ¦ -+-->¦ ¦ -+-+ +---+ +-----------+ +-----------+ +-----------+ ¦ (cabecera) +-------------------------------------------------+ (disponibles) ¦ +-----------+ +-----------+ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +-----------+ +-----------+ --- A L A L (fin de lista)

Como se aprecia, si ahora se recorre la lista encabezada por HDISP, elresgistro que estaba apuntado en Z ha quedado incorporado.

Hay un aspecto de capital importancia. El orden en que ambas sentencias fueronejecutadas es totalmente relevante. De acuerdo al orden utilizado,primeramente se hace que L(Z) apunte a HDISP y en segundo término se hace queHDISP apunte al registro apuntado por Z. El resultado es el graficado. Deinvertirse las operaciones, en primer lugar se haría que HDISP apuntara alregistro apuntado por Z (el que se ha de incorporar). Pero L(Z) no apuntaba aningún sitio, como se aprecia en la figura inicial y, como consecuencia,lalista HDISP queda desarticulada. Ya no es posible recorrer sus registroscomponentes.

Z A L +---+ +-----------+ ¦ --+--->¦ ¦ -+----> ??????????? +---+ ¦ +-----------+ Paso nro. 2 Paso ¦ nro.1¦ HDISP ¦ A L A L A L +---+ ¦ +-----------+ +-----------+ +-----------+ ¦ --+------+ ¦ ¦ -+--->¦ ¦ -+-->¦ ¦ -+-+ +---+ +-----------+ +-----------+ +-----------+ ¦ (cabecera) +-------------------------------------------------+ (disponibles) ¦ +-----------+ +-----------+ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +-----------+ +-----------+ --- A L A L (fin de lista)

Otra vez, la analogía ferroviaria puede auxiliar nuestra comprensión en esteaspecto. Si estos juegos de altas y bajas son vistos como maniobrasferroviarias, puede asumirse que todos los desplazamientos tienen lugar sobrecuestas (terrenos en pendiente). Si por algún motivo un convoy quedadesconectado, directa o indiretamente, de una cabecera, si pierde 'en labajada'.

Generalizando entonces una función para dar de baja a un registro:

+------------------------+ ¦ defint a-z ¦ ¦ sub DarDeBaja(Z) ¦ ¦ ¦ ¦ L(Z)=HDISP: HDISP=Z ¦ ¦ ¦ ¦ end sub ¦ +------------------------+

Como se deduce en esta subrutina, tanto HDISP como los arreglos que conformana las listas se han declarado globales en el módulo principal. Esta forma dehacerlo parece razonable en tanto ambas estructuras enlazadas deben seraccesibles desde prácticamente todas las funciones y subrutinas de un programabasado en listas de ese tipo.

Para dar de alta a nuevo dato en la lista de registros útiles, primeramentedebe obtenerse, de haber alguno, un registro disponible de la lista dedisponibles. Luego se escribe en su campo de datos el dato a incorporar y,finalmente, el nuevo registro es agregado a la lista útil de acuerdo al

criterio elegido para su construcción.

+-----------------------------------------------+ ¦ defint a-z ¦ ¦ function Disponible() ¦ ¦ ¦ ¦ Disponible=HDISP ¦ ¦ if HDISP=FinDeLista then ¦ ¦ print "No hay más registros disponibles" ¦ ¦ else ¦ ¦ HDISP=L(HDISP) ¦ ¦ end if ¦ ¦ ¦ ¦ end function ¦ +-----------------------------------------------+

La función Disponible() retira un registro de la lista HDISP, previaverificación de la factibilidad de la opercaión. Efectivamente, sucesivasaltas pueden llegar a agotar a la lista de disponibles:

HDISP +---+ ¦ --+--------+ +---+ ¦ (cabecera) ------ (disponibles)

En esta situación no es posible retirar más disponibles por lo que la funciónconcluye con un mensaje alusivo, y devolviendo 'FinDeLista' como valor deretorno. De no ser éste el caso, Disponible() devuelve un puntero a unregistro disponible, el que está listo para ser dado de alta en la lista útil.Por ejemplo:

+----------------------------------------------------------+ ¦ defint a-z ¦ ¦ declare function Disponible() as integer ¦ ¦ declare sub InicializarListas() ¦ ¦ declare sub DarDeAlta(Z as integer) ¦ ¦ ¦ ¦ const DISPMAX = 1000, FinDeLista=-1 ¦ ¦ ¦ ¦ dim shared A(DISPMAX) as integer ¦ ¦ dim shared L(DISPMAX) as integer ¦ ¦ dim shared HDISP as integer, H as integer ¦ ¦ dim Z as integer ¦ ¦ ¦ ¦ InicializarListas ¦ ¦ ¦ ¦ Z=Disponible() ¦ ¦ if Z=FinDeLista then ¦ ¦ stop ¦ ¦ else ¦ ¦ input "dato a incorporar"; A(Z) ¦ ¦ DarDeAlta Z ¦ ¦ end if ¦ ¦ ¦ ¦ ... ¦ +----------------------------------------------------------+

En donde la subrutina DarDeAlta() toma a un registro apuntado por Z comoargumento y lo incorpora a la lista H de acuerdo a un criterio inscripto ensu código.

InicializarListas() ya fue comentada:

+----------------------------+ ¦ defint a-z ¦ ¦ sub InicializarListas() ¦ ¦ ¦ ¦ for i=1 to DISPMAX ¦

¦ L(i)=i+1 ¦ ¦ next i ¦ ¦ L(DISPMAX)=FinDeLista ¦ ¦ HDISP=1 ¦ ¦ H=FinDeLista ¦ ¦ ¦ ¦ end sub ¦ +----------------------------+

Altas y Bajas en la Lista de Datos - Registro Auxiliar------------------------------------------------------

El procedimiento InicializarListas() recién desplegado deja a la lista Hcomo vacía:

H +---+ ¦ --+--------+ +---+ ¦ (cabecera) ---

Efectivamente, la cuenta de registros en la misma es nula. Con todo, lacalidad de 'vacía' de una lista es una cuestión de convención -así como el -1es interpretado como fin de lista por convención-. En general resulta siempreconveniente mantener al menos un registro en una lista de datos. El mismo sedenomina registro AUXILIAR y su fin es meramente burocrático, NO SIENDO PARTEDE LA LISTA 'OFICIAL' DE DATOS. Así, la lista H VACIA estaría dada por:

H A L +---+ +-----------+ ¦ --+--->¦ ¦ -+---+ +---+ +-----------+ --- reg. auxiliar

para lo que InicializarListas debería modificarse como:

+------------------------------------+ ¦ defint a-z ¦ ¦ sub InicializarListas() ¦ ¦ ¦ ¦ for i=1 to DISPMAX-1 ¦ ¦ L(i)=i+1 ¦ ¦ next i ¦ ¦ L(DISPMAX)=FinDeLista: HDISP=1 ¦ ¦ ¦ ¦ 'H <- Auxiliar ¦ ¦ H=Disponible(): L(H)=FinDeLista ¦ ¦ ¦ ¦ end sub ¦ +------------------------------------+

La utilización de un registro auxiliar se adoptará en adelante como unapráctica standard por lo que un algoritmo para una recorrida de una lista dedatos podría implementarse como:

+-----------------------------------------+ ¦ defint a-z ¦ ¦ sub RecorrerLista() ¦ ¦ ¦ ¦ Y=H ¦ ¦ do ¦ ¦ X=Y: Y=L(Y) ¦ ¦ if Y=FinDeLista then ¦ ¦ print "Listo !": exit sub ¦ ¦ else ¦ ¦ HacerAlgo X, Y ¦ ¦ end if ¦ ¦ loop ¦ ¦ ¦ ¦ end sub ¦

+-----------------------------------------+

En éste se aprecia que dos punteros -X e Y- recorren a la lista H, X siempresiguiendo a Y desde el registro anterior.

X Y +---+ +---+ ¦ ¦ ¦ ¦ +---+ +---+ H A L ¦ A L ¦ A L +---+ +-----------+ +>+-----------+ +>+-----------+ ¦ --+--->¦ Auxiliar -+--->¦ ¦ -+-->¦ ¦ -+-+ +---+ +-----------+ +-----------+ +-----------+ ¦ (cabecera) +------------------------------------------+ (lista útil) ¦ +-----------+ +-----------+ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +-----------+ +-----------+ --- A L A L (fin de lista)

El uso de dos punteros para recorrer una lista también será adoptada como unamodalidad estándard de trabajo. El motivo es sencillo de comprender. Paraefectuar alguna operación sobre un registro es necesario tener acceso al mismo-esto es trivial-, y un registro perteneciente a una lista enlazada sólo puedeser alcanzado si está siendo apuntado por un puntero. El puntero Y, en nuestrocaso, cumple con ese propósito. Por ese motivo la subrutina HacerAlgo toma a Ycomo parámetro. HacerAlgo 'hace algo' con el registro apuntado por Y. Perosuele ocurrir que la operación implementada en HacerAlgo involucre al registroanterior. Por la modalidad constructiva de estos enlaces simples, a partir deun registro -apuntado por Y, por ejemplo- es trivial el acceso al siguiente:Se trata de L(Y). Pero no resulta tan sencillo el acceso al registro anterioral apuntado por Y. Al no haber un enlace al registro previo sólo es posible suacceso volviendo a recorrer la lista desde el principio, por ejemplo con unsegundo puntero T, para llegar al previo al apuntado por Y cuando se verifique'L(T)=Y' como cierto. Para evitar la pérdida de tiempo que esto significaría,tanto más cuanto prolongada cuanto más extensa fuera la lista H y más cerca desu cola estuviera el registro apuntado por Y, es que se recurre a la recorridacon el segundo puntero X. Al estar X apuntado siempre al registro previo alapuntado por Y -con lo que 'L(X)=Y' es siempre cierto-, 'HacerAlgo X,Y' tieneacceso a todo el material que en general es necesario.

A partir de lo dicho, desarrollaremos dos subrutinas auxiliares para dar dealta y dar de baja registros de nuestra lista útil. El criterio para dar dealta es nada más el mantenimiento de un orden ascendente.

+--------------------------------------------------+ ¦ defint a-z ¦ ¦ sub DarDeAlta(Z) ¦ ¦ ¦ ¦ Y=H ¦ ¦ do ¦ ¦ X=Y: Y=L(Y) ¦ ¦ if Y=FinDeLista then ¦ ¦ L(Z)=Y: L(X)=Z ¦ ¦ print "Dado de alta como último" ¦ ¦ exit sub ¦ ¦ else ¦ ¦ if A(Z) < A(Y) then ¦ ¦ L(Z)=Y: L(X)=Z ¦ ¦ print "Dado de alta !" ¦ ¦ exit sub ¦ ¦ end if ¦ ¦ end if ¦ ¦ loop ¦ ¦ ¦ ¦ end sub ¦ +--------------------------------------------------+

El contexto de uso de esta rutina podría ser:

+----------------------------------------------------------+ ¦ ... ¦ ¦ Z=Disponible() ¦ ¦ if Z=FinDeLista then ¦ ¦ print "No hay más disponibles. Operación abortada."¦ ¦ stop ¦ ¦ else ¦ ¦ input "Dato a dar de alta "; A(Z) ¦ ¦ DarDeAlta Z ¦ ¦ end if ¦ ¦ ... ¦ +----------------------------------------------------------+

En cuanto a la baja, una rutina DarDeBaja ya fue desarrollada bajo el título"Lista de Disponibles". Así todo, el contexto en que la misma podría ser usadasería de siguiente tipo:

+--------------------------------------------------------+ ¦ defint a-z ¦ ¦ sub DarDeBajaUnDato() ¦ ¦ ¦ ¦ input "Dato a dar de baja ";DatoADarDeBaja ¦ ¦ ¦ ¦ Y=H ¦ ¦ do ¦ ¦ X=Y: Y=L(Y) ¦ ¦ if Y=FinDeLista then ¦ ¦ print DatoADarDeBaja ;" no está en la lista" ¦ ¦ exit do ¦ ¦ else ¦ ¦ if A(Y)=DatoADarDeBaja then ¦ ¦ L(X)=L(Y) ¦ ¦ DarDeBaja Y 'Ya desarrollada ¦ ¦ print DatoADarDeBaja;" dado de baja !" ¦ ¦ exit do ¦ ¦ end if ¦ ¦ end if ¦ ¦ loop ¦ ¦ ¦ ¦ end sub ¦ +--------------------------------------------------------+

El programa adjunto ENLACE1.BAS consiste en articular en un programaestas funciones y subrutinas junto a algunas auxiliares. Se observa que laimplementación de algunas funciones es levemente diferente a la presentada enel texto. Su estudio ampliará sin duda la comprensión de los conceptosinvolucrados.

Listas Enlazadas: su Justificación----------------------------------

Hasta el momento nada se ha dicho sobre el motivo que justifica lautilización de listas enlazadas como alternativa a los arreglos. Como primeramedida, su idea e implementación en QB reviste gran interés didáctico, hechoque por sí solo bastaría para la inclusión del tema en estas notas. Así todo,la utilidad no se remite sólo a este aspecto. Amén de una mayor simplicidad yrapidez de los algoritmos de alta y baja (recordar que dar de alta o de bajaen un sistema de arreglos implica la necesidad de desplazar a todos los datosmás allá del punto de inserción o quite), la principal ventaja es unaadministración mucho más eficiente del espacio de almacenamiento -un uso másracional de la memoria-. Un ejemplo sencillo mostrará cómo se manifiesta éstehecho. Supongamos que se desea mantener un registro actualizado de laspatentes de los automóviles de nuestro país. Una forma razonable de hacerlo esorganizando N listas enlazadas, una para cada provincia, amén de la dedisponibles. Cada patente dada de alta se incorpora en la listacorrespondiente a la provincia a que pertenece. Antes de dar de alta a patentealguna, cuántos registros disponibles han de disponerse en la lista ad-hoc ?.Tantos como cantidad total de vehículos haya en el país. Cuando todos hayansido dados de alta, esa cantidad se distribuirá entre las diferentes listas.

HDISP PatNro L PatNro L PatNro L +---+ +-----------+ +-----------+ +-----------+ ¦ --+--->¦ ¦ -+--->¦ ¦ -+-->¦ ¦ -+-+ +---+ +-----------+ +-----------+ +-----------+ ¦ (Disponibles) +------------------------------------------+ ¦ +-----------+ +-----------+ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +-----------+ +-----------+ --- PatNro L PatNro L

HBaires PatNro L PatNro L PatNro L +---+ +-----------+ +-----------+ +-----------+ ¦ --+--->¦ Auxiliar -+--->¦ ¦ -+-->¦ ¦ -+-+ +---+ +-----------+ +-----------+ +-----------+ ¦ +------------------------------------------+ ¦ +-----------+ +-----------+ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +-----------+ +-----------+ --- PatNro L PatNro L

HNeuquen PatNro L PatNro L PatNro L +---+ +-----------+ +-----------+ +-----------+ ¦ --+--->¦ Auxiliar -+--->¦ ¦ -+-->¦ ¦ -+-+ +---+ +-----------+ +-----------+ +-----------+ ¦ +------------------------------------------+ ¦ +-----------+ +-----------+ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +-----------+ +-----------+ --- PatNro L PatNro L ...

HUsuhaia PatNro L PatNro L PatNro L +---+ +-----------+ +-----------+ +-----------+ ¦ --+--->¦ Auxiliar -+--->¦ ¦ -+-->¦ ¦ -+-+ +---+ +-----------+ +-----------+ +-----------+ ¦ +------------------------------------------+ ¦ +-----------+ +-----------+ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +-----------+ +-----------+ --- PatNro L PatNro L

Pensemos ahora cuál sería esa magnitud si el problema debiera ser resueltohaciendo uso de arreglos. La dimensión de cada arreglo provincial debe serigual a la cantidad TOTAL de automóviles dado se debe preparar el soporte paraque resista aún en el peor caso -todos los vehículos pertenecen a la mismaprovincia-. La cantidad de unidades de almacenamiento consumidas es 23 *CantidadTotalDeVehículos, contra sólo CantidadTotalDeVehículos para el casoenlazado.

1 2 ... CantidadTotalDeVehículos-----+ V +-------------------------- ----------------------+ 1 ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ +---+---+---+---+---+---+-- --+---+---+---+---+---¦ 2 ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ +---+---+---+---+---+---+-- --+---+---+---+---+---¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ...

+---+---+---+---+---+---+-- --+---+---+---+---+---¦ 23 ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ +-------------------------- ----------------------+

Tan conveniente resulta esta metodología de trabajo que, de hecho, laadministración del espacio de almacenamiento que tanto en disco como enmemoria principal hace el Sistema Operativo, se basa en estructuras de tipoenlazadas, si bien, de más está decirlo, no están desarrolladas en QB....

En relación a la ventaja mencionada en lo atinente a una mayor flexibilidadtoda vez que es necesario dar de alta y/o baja a una clave (o a desplazarla,

que bien puede puede ser visto como una secuencia de baja + alta en un sitiodiferente), una aplicación se puede apreciar en algunos algoritmos deordenación. Por ejemplo, la ordenación por inserción necesita deldesplazamiento de una porción de un lote de claves en una posición toda vezque se halla la ubicación relativa de una nueva clave dentro del mismo. Estaoperación de desplazamiento bien puede suprimirse si las claves estánorganizadas en una lista enlazada. El cambio de posición de la clave encuestión es una operación casi trivial cuyo costo, una baja y un alta, essumamente reducido.

Vector de Punteros------------------

El ejemplo anterior -registro de patentes por provincia- sugiere laposibilidad de componer algunos conceptos conocidos a fin sacar ventaja de laconjunción.

En el ejemplo, la cantidad de provincias está totalmente condicionada alcódigo del programa. I.e., para agregar un eventual vigésimocuarto estadoharía falta, necesariamente, modificar el código del programa. Por otro lado,para acceder a la lista de patentes de una provincia particular se debe haceruna referencia estática explícita a su puntero correspondiente. Pero porproblemas similares ya habíamos pasado. Es más, su solución se encaminó por ellado de la incorporación del concepto de arreglos, en los que un índice entiempo de ejecución podía, dinámicamente, direccionar a cualquiera de suscomponentes. Si transladamos la idea a nuestro problema obtenemos comoresultado de la mezcla un vector de punteros. En el mismo, el puntero a lalista correspondiente a cada provincia está contenido en una celda de unarreglo que, ahora sí, es dinámicamente direccionable. La lista dedisponibles, por una cuestión de prolijidad, se conserva con un punteroindependiente.

HDISP PatNro L PatNro L PatNro L +---+ +-----------+ +-----------+ +-----------+ ¦ --+--->¦ ¦ -+--->¦ ¦ -+-->¦ ¦ -+-+ +---+ +-----------+ +-----------+ +-----------+ ¦ (Disponibles) +------------------------------------------+ ¦ +-----------+ +-----------+ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +-----------+ +-----------+ --- PatNro L PatNro L

HPcias PatNro L PatNro L PatNro L +---+ +-----------+ +-----------+ +-----------+ 1 ¦ --+--->¦ Auxiliar -+--->¦ ¦ -+-->¦ ¦ -+-+ +---¦ +-----------+ +-----------+ +-----------+ ¦ 2 ¦ --+-+ +------------------------------------------+ +---¦ ¦ ¦ +-----------+ +-----------+ ... ¦ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +---¦ ¦ +-----------+ +-----------+ --- +-+-- ¦ ¦ PatNro L PatNro L ¦ +---¦ ¦ ¦ ¦ ¦ ¦ PatNro L PatNro L PatNro L ¦ +---+ ¦ +-----------+ +-----------+ +-----------+ ¦ +->¦ Auxiliar -+--->¦ ¦ -+-->¦ ¦ -+-+ ¦ +-----------+ +-----------+ +-----------+ ¦ ¦ +------------------------------------------+ ¦ ¦ +-----------+ +-----------+ ¦ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ ¦ +-----------+ +-----------+ --- ¦ PatNro L PatNro L ¦ ¦ ¦ PatNro L PatNro L PatNro L ¦ +-----------+ +-----------+ +-----------+ +--------->¦ Auxiliar -+--->¦ ¦ -+-->¦ ¦ -+-+ +-----------+ +-----------+ +-----------+ ¦ +------------------------------------------+

¦ +-----------+ +-----------+ +-->¦ ¦ -+--...-->¦ ¦ -+-----+ +-----------+ +-----------+ --- PatNro L PatNro L

Ahora, el puntero de acceso a la lista de la provincia i-ésima está ubicado enHPcias(i). Por ejemplo, para listar a todos los vehículos empadronadosbastaría:

+---------------------------------------------------------+ ¦ defint a-z ¦ ¦ ... ¦ ¦ for i=1 to CantidadDeProvincias ¦ ¦ print "Listado de patentes para la provincia ";i ¦ ¦ Y=L(HPcia(i)) 'Debido al auxiliar ¦ ¦ while Y<>FinDeLista ¦ ¦ print PatNro(Y), ¦ ¦ Y=L(Y) ¦ ¦ wend ¦ ¦ print ¦ ¦ next i 'Sencillo, no ? ¦ ¦ ... ¦ +---------------------------------------------------------+

Una aplicación particular en la que también se aprecia la economía queofrecen las estructuras enlazadas y en la que también se aplican vectores depunteros es en la representación y manipulación de matrices ralas. Lasmatrices ralas son matrices en las que gran parte de sus elementos asumen elmismo valor, por ejemplo 0. Por ejemplo, si se desea representar una matriz de100 filas y 100 columnas, aún cuando uno sólo de sus elementos sea diferentede 0, el espacio a reservar debe ser de 100 * 100 (10000). Sin duda que setrata de un costo innecesario si se conoce la ubicación del mismo. Lasiguiente estructura da lugar a una importante economía en el espacio dealmacenamiento.

Fila FC Dat L FC Dat L +---+ +-----------+ +-----------+ +-----------+ 1 ¦ --+--->¦ Auxiliar -+--->¦ ¦ ¦ +-->¦ ¦ ¦ +-+ +---¦ +-----------+ +-----------+ +-----------+ ¦ 2 ¦ --+-+ +------------------------------------------+ +---¦ ¦ ¦ +-----------+ +-----------+ ... ¦ +-->¦ ¦ ¦ +--...-->¦ ¦ ¦ +-----+ +---¦ ¦ +-----------+ +-----------+ --- +-+-- ¦ ¦ FC Dat L FC Dat L ¦N+---+ ¦ ¦ ¦ FC Dat L FC Dat L ¦ ¦ +-----------+ +-----------+ +-----------+ ¦ +->¦ Auxiliar -+--->¦ ¦ ¦ -+-->¦ ¦ ¦ +-+ ¦ +-----------+ +-----------+ +-----------+ ¦ ¦ +------------------------------------------+ ¦ ¦ +-----------+ +-----------+ ¦ +-->¦ ¦ ¦ +--...-->¦ ¦ ¦ +-----+ ¦ +-----------+ +-----------+ --- ¦ FC Dat L FC DAT L ¦ ¦ ¦ FC Dat L FC Dat L ¦ +-----------+ +-----------+ +-----------+ +--------->¦ Auxiliar -+--->¦ ¦ ¦ +-->¦ ¦ ¦ +-+ +-----------+ +-----------+ +-----------+ ¦ +------------------------------------------+ ¦ +-----------+ +-----------+ +-->¦ ¦ ¦ +--...-->¦ ¦ ¦ +-----+ +-----------+ +-----------+ --- FC Dat L FC Dat L

Sólo los elementos cuyo valor asume un valor diferente al valor por defecto esincorporado en un registro a partir del puntero a la fila correspondiente.Cada registro, además del campo correspondiente al valor -Dat-, contiene un

campo adicional de datos -FC- en el que se escribe la columna de la matrizoriginal a la que el elemento en cuestión pertenece. De este modo, una matrizrala que, por ejemplo, solo tuviera un elemento diferente, en fila 2, columna8, estaría representada como:

Fila +---+ +-----------+ 1 ¦ -+--->¦ Auxiliar -+---+ +---¦ +-----------+ ¦ 2 ¦ -+-----+ --- +---¦ ¦ FC Dat L 3 ¦ -+--+ ¦ +-----------+ +-----------+ +---¦ ¦ +>¦ Auxiliar -+--->¦ 8 ¦ ¦ -+--+ ... ¦ +-----------+ +-----------+ --- +---¦ ¦ +----------+ N ¦ ¦ +>¦ Auxiliar-+---+ +-+-+ +----------+ --- ¦ +----------+ +----->¦ Auxiliar-+---+ +----------+ ---

Enlaces Múltiples-----------------

Los enlaces múltiples consisten en una generalización del concepto deenlaces simples. En este caso bien puede haber uno o más campos de datos y doso más campo de enlace. Un estructura de este tipo se presenta ya como untejido, en cierto sentido, multidimensional, en el que cada registro puedetener más de un antecesor y/ó más de un sucesor. Un caso sencillo de enlacemúltiple es el de una lista lineal en la que cada registro contempla un enlaceal registro previo:

LPrev Dato LPost +-----------------+ <---+- ¦ ¦ -+---> +-----------------+

De este modo, una lista con enlace doble, en avance y en retroceso, podriatener la siguiente arquitectura:

HAvance LPrev Dato LPost +-----+ +-----------------+ +-----------------+<-------+ ¦ -+->¦ Auxiliar -+---->¦ ¦ ¦ -+---+ ¦ +-----+ +--+--------------+<-+ +--+--------------+ ¦ ¦ --- +-----+ ¦ ¦ ¦ ¦ +------------------------------------------+ ¦ ¦ +----------------------------------------+ ¦ +--+--------------+ +-----------------+<--------+ +-->¦ ¦ ¦ -+--...-->¦ ¦ ¦ -+----+ ¦ +-----------------+<-+ +--+--------------+ ¦ ¦ +--...---+ ¦ ¦ ¦ ¦ +--------------------------------------------------------------+ ¦ ¦ +----------------------------------------------------------+ ¦ +--+--------------+ +-----------------+ +-----+ +---->¦ ¦ ¦ ¦<----+ Auxiliar ¦<---+- ¦ +--------------+--+ +->+--------------+--+ +-----+ +-----+ --- HRetroceso

Como era de suponer, se hacen necesarios dos punteros (HAvance yHRetroceso) así como un registro auxiliar para cada uno de ellos. Es dedestacar que si se sigue a la lista por uno de sus enlaces a partir de lacabecera correspondiente haciendo caso omiso del otro enlace, la lista se vecomo una lista de enlace simple (con un registro en exceso en su cola). Estoes válido independientemente de la cantidad de enlaces que hagan a laarquitectura de los registros.

Las rutinas para creación de la lista de disponibles así como para dar de

alta y de baja a un registro podrían estar implementadas del siguiente modo:

+----------------------------------------------------+ ¦ 'Módulo principal ¦ ¦ defint a-z ¦ ¦ ¦ ¦ const N=1000, FinDeLista=-1 ¦ ¦ ¦ ¦ dim shared Dato(N), LPrev(N), LPost(N) ¦ ¦ dim shared HDISP as integer ¦ ¦ dim HAvance as integer, HRetroceso as integer ¦ ¦ ... ¦ +----------------------------------------------------+

+--------------------------------------------------------------+ ¦ defint a-z ¦ ¦ sub CrearListasVacías ¦ ¦ ¦ ¦ for i=1 to N-1 ¦ ¦ LPost(i)=i+1 ¦ ¦ next i ¦ ¦ LPost(N)=FinDeLista: HDisp=1 ¦ ¦ ¦ ¦ HAvance=Disponible() ¦ ¦ HRetroceso=Disponible() ¦ ¦ LPost(HAvance)=HRetroceso: LPost(HRetroceso)=FinDeLista ¦ ¦ LPrev(HRetroceso)=HAvance: LPrev(HAvance)=FinDeLista ¦ ¦ ¦ ¦ end sub ¦ +--------------------------------------------------------------+ +------------------------------+ ¦ defint a-z ¦ ¦ function Disponible() ¦ ¦ ¦ ¦ Disponible=HDisp ¦ ¦ HDisp<>FinDeLista then ¦ ¦ HDisp=LPost(HDisp) ¦ ¦ end if ¦ ¦ ¦ ¦ end function ¦ +------------------------------+

CrearListasVacias genera las siguientes listas:

HAvance +-----+ +-----------------+<-----+ ¦ -+->¦ Auxiliar -+--+ ¦ +-----+ +--+--------------+ ¦ ¦ --- +----+ +-+ ¦ +--+--------------+ +-----+ +-->¦ ¦ Auxiliar ¦<---+- ¦ +--------------+--+ +-----+ --- HRetroceso

HDisp LPrev Dato LPost +-----+ +-----------------+ +-----------------+ ¦ -+->¦ ¦ ¦ -+---->¦ ¦ ¦ -+---+ +-----+ +-----------------+ +-----------------+ ¦ +------------------------------------------+ ¦ +-----------------+ +-----------------+ +-->¦ ¦ ¦ -+--...-->¦ ¦ ¦ -+----+ +-----------------+ +-----------------+ ¦ +--------------------------------------------------------------+ ¦ +-----------------+ +---->¦ ¦ ¦ -+----+ +-----------------+ ---

para las que los siguientes aspectos son de interés: (a) La lista vacía consiste en los dos punteros con sus correspondientes registros auxiliares apuntándose entre sí.

(b) En la lista de disponibles, dado su propósito y modo de uso, basta que los registros se vinculen entre sí mediante uno sólo de los enlaces -cualquiera de ellos-, indpendientemente de la cantidad de campos de enlace que hubieran.

+--------------------------------------------------------------+ ¦ defint a-z ¦ ¦ sub DarDeAlta(DatoADarDeAlta) 'En orden ascendente ¦ ¦ ¦ ¦ Z=Disponible() ¦ ¦ if Z=FinDeLista then ¦ ¦ print "Lista de disponibles exhausta !" ¦ ¦ exit sub ¦ ¦ else ¦ ¦ Dato(Z)=DatoADarDeAlta ¦ ¦ ¦ ¦ Y=HAvance 'Podría haberse partido de HRetroceso ¦ ¦ do 'y "avanzar" con Y=LPrev(Y). ¦ ¦ Y=LPost(Y) ¦ ¦ if LPost(Y)=FinDeLista then ¦ ¦ LPost(Z)=Y: LPrev(Z)=LPrev(Y) ¦ ¦ LPost(LPrev(Y))=Z: LPrev(Y)=Z ¦ ¦ exit do ¦ ¦ else ¦ ¦ if Dato(Y)>Dato(Z) then ¦ ¦ LPost(Z)=Y: LPrev(Z)=LPrev(Y) ¦ ¦ LPost(LPrev(Y))=Z: LPrev(Y)=Z ¦ ¦ exit do ¦ ¦ end if ¦ ¦ end if ¦ ¦ loop ¦ ¦ end if ¦ ¦ ¦ ¦ end sub ¦ +--------------------------------------------------------------+ +--------------------------------------------------------------+ ¦ defint a-z ¦ ¦ sub DarDeBaja(Z) 'Z: puntero a registro a dar de baja ¦ ¦ ¦ ¦ LPost(LPrev(Z))=LPost(Z) ¦ ¦ LPrev(LPost(Z))=LPrev(Z) ¦ ¦ ¦ ¦ LPost(Z)=HDisp: HDisp=Z ¦ ¦ ¦ ¦ end sub ¦ +--------------------------------------------------------------+

Dada la arquitectura de la lista, el último registro para cada sentido derecorrido es el auxiliar para el sentido opuesto. El carácter de auxiliareslos inhabilita para contener datos útiles y, por tanto, y a diferencia de lalista de enlaces simples, el FinDeLista para los recorridos debe verificarseen LPost(Y).

De aquí en más, sólo la imaginación limita las posibilidades para el diseñode listas enlazadas: un campo de datos y varios de enlace; varios campos dedatos y varios de enlace, etc. La literatura en organización bases de datos esextensa y las herramientas de programación, más allá del QB, son cada vez máspotentes y accesibles. Esto hace que el nudo del problema se vaya trasladandoal diseño arquitectónico que más eficientemente pueda representar a larealidad que se debe modelar computacionalmente para hacer de los programasherramientas útiles.

--------------Registrar propieda intelectual de este trabajo---------------------Verificar que todas las implementaciones presentadas funcionen bien-------------------------Distribuir como un archivo ReadOnly--------------------

.Ubicar en cada título y en el índice las keywords que permitan accesodirecto a temas relacionados mediante el text_search de un editor de texto.Una idea es señalar el sitio donde un concepto es presentado por vez 1ra. conun símbolo especial seguido de la keyword a fin que todo el string pueda ser

hallado con rapidez.

.buscar [completar]

-----------------------------------------------------------------------------Bibliografía:

AGUILAR, Luis, Programación QuickBasic, McGraw Hill, 1990 ATKINSON, Kendal ("Elementary Numerical Analysis", Ed. Wiley, 2nd ed., 1995) BIONDI J., CLAVEL G., "Introducción a la Programación" (Tomo 1: Algorítmica y Lenguajes - Tomo 2: Estructuras de Datos), Ed. MASSON, 1985 Craig J. C., "Microsoft QuickBASIC Programmer's Toolbox" (1988), Microsoft Press. CVITANOVIC G.M., ERALIO W.E., Técnicas de Ordenación, Revista Telegráfica Electrónica, Enero de 1992, Editorial Arbó, Buenos Aires. DUNCAN, Advanced MS-DOS. JAMSA J., "QBasic: Programmer's Quick Reference" (1991), Microsoft Press. HALVORSON M. and RYGMYR D., "Running QBasic" (1991), Microsoft Press. HERGERT D., "Microsoft QuickBASIC" (3ra. edición, 1988), Microsoft Press. KALBASI, Kahlil ("Can you trust your computer ?", IEEE Potentials, Apr. 90) KNUTH, Donald, The Art of Computer Programming, Vol. III, Searching and Sorting, Addison-Wesley, 1973 MARTIN, Organización de las Bases de Datos. MicroSoft Press, QuickBasic 4.5 Lenguage Manual. MicroSoft Press, MS-DOS 5.0, User Manual. NAMEROFF, Steven, QB: Manual de referencia, Osborne/McGraw Hill, 1990 NEWMAN, SPRULL, Interactive Computer Graphics. WAITE, PRATA, et al., "The Waite Group's QBasic Reference Plus" (1991), Microsoft Press. WAITE, PRATA, et al., "The Waite Group's Microsoft QuickBASIC Bible" (1990), Microsoft Press. WAITE et al., "The Waite Group's Microsoft QuickBASIC Primer Plus" (1990), Microsoft Press. WILDE, Daniel, An Introduction to Computing, Prentice Hall, 1973.

-----------------------------------------------------------------------------Material consultado: Byte Magazine, iii-93 Notas de Curso de "Sistemas de Programación I" (DIE-UNS)

-----------------------------------------------------------------------------MS-DOS(R) corresponde a MicroSoft Disk Operating System, de MicroSoft(R)QB(R) corresponde a QuickBasic, de MicroSoft(R)BC corresponde a BasicCompiler, de MicroSoft(R)