                  La Implementacin de Heap.pas

                               por

                          Adolfo Di Mare

                    Reporte Tcnico ECCI-94-08
                       Proyecto 326-93-256
                           Revisin 1.0


Resumen:
=======

Se  discute cmo est construida  la implementacin del ADT THeap, 
cuya  mayor utilidad es la  eficiencia con que permite implementar 
Colas  de  Prioridad.  Esta  implementacin del  ADT montculo  es 
bastante  sencilla por lo que su  valor es ms que todo didctico, 
aunque   es  relativamente  sencillo   mejorarla  para  usarla  en 
aplicaciones importantes.

Esta implementacin se ha realizado para el ambiente Turbo  Pascal 
v5.0, aunque para trabajar con ellas es ms cmodo usar la versin 
v6.0 o una posterior.


Abstract:
========

We discuss  how the  implementation for  THeap Abstract  Data Type 
(ADT) is  constructed.  THeap  is most  usefull when  implementing 
Priority Queues. This is a simple implementation that has a  value 
mostly didactic, even though it is relatively simple to improve it 
to use in more demanding applications.

These  implementations  has been  made for  the Turbo  Pascal v5.0 
environment, but  it is  less cumbersome  to use  version v6.0  or 
later to work with them.


Esta investigacin se realiz dentro del proyecto de investigacin 
326-93-256 "DBgen: Generacin de Sistemas  a partir de su Base  de 
Datos" inscrito ante  la  Vicerrectora  de  Investigacin  de  la 
Universidad  de  Costa  Rica.   La  Escuela  de  Ciencias  de   la 
Computacin e Informtica tambin ha aportado fondos para realizar 
este trabajo.


                  La Implementacin de Heap.pas
                  =============================


     Una clasificacin  simple de  los Tipos  Abstractos de  Datos 
(ADTs) los divide en dos tipos bsicos: los simples o elementales, 
y  los contenedores. Un  ADT es un contenedor  si contiene a otros 
ADTs. Los contenedores ms importantes son tres:

     1.- El ADT Arreglo [ARRAY]
     2.- El ADT Lista   [List.pas]
     3.- El ADT Arbol   [Tree.pas]

Existen  otros ADTs importantes,  como Graph.pas, Matriz.pas, etc, 
pero la  mayora  de  las  estructuras  de  datos  importantes  se 
obtienen al combinar inteligentemente a estos tres ADTs.  De todos 
estos, el ms importante es, sin duda alguna, el Arreglo, hasta el 
punto de que  todos  los  lenguajes  de  computacin  modernos  lo 
incluyen como una construccin sintctica bsica.

     Un  importante ejemplo de cmo  deben mezclarse los tres ADTs 
contenedores bsicos para lograr gran eficiencia es el ADT  THeap, 
que sirve  para implementar  los montculos  en los  que se  puede 
almacenar y accesar una Cola de Prioridad con gran eficiencia.

     Aunque  la  mayora  de  los textos  de Estructuras  de Datos 
siempre dedican una buena cantidad de espacio a discutir este ADT, 
es   importante  conocer  una   implementacin  completa  por  las 
siguientes razones:

1) Para  construir este  ADT es  necesario mezclar  los tres  ADTs 
   contenedores ms importantes  de  forma  elegante  y  sencilla.  
   Desde  este  punto de  vista, Heap.pas  es una  un ejemplo  muy 
   sencillo  y muy completo  de cmo se puede  construir un ADT en 
   trmino de otros.

2) La  mayora de  las implementaciones  del contenedor  THeap que 
   aparecen en la  literatura  se  concentran  en  los  trucos  de 
   programacin para manipular un arreglo simulando a un rbol,  y 
   en el mtodo de Ordenamiento HeapSort() que puede implementarse 
   usando montculos.  En  esta  implementacin  se  presenta  una 
   visin alternativa.

     Casi cualquier  contenedor puede  ser usado  para implementar 
una Cola de Prioridad,  pero la ventaja de  usar THeap es que  las 
principales operaciones de la Cola de Prioridad se pueden ejecutar 
con gran velocidad  y usando una  cantidad mnima de  memoria.  Un 
montculo es un ADT el contenedor que est organizado de forma que 
siempre en su parte superior est el elemento mayor.

     Un rbol satisface la Propiedad del Montculo cuando cada uno 
de sus  nodos tiene  un valor  superior a  sus descendientes.   Un 
montculo es un  rbol que satisface  la Propiedad del  Montculo.  
La invariante  del ADT  THeap es  que satisface  la Propiedad  del 
Montculo. Los  montculos fueron  inventados para  implementar el 
HeapSort() y las  Colas de Prioridad.   Un rbol que  satisface la 
Propiedad del Montculo como se muestra en la siguiente figura:

                                H
                                
                               [9]
                              / | \
                             /  |  \
                            /  / \  \
                         [3] [5] [8] [6]
                         /|\         /|\
                        / | \       / | \
                     [1] [2] [3] [5] [6] [4]
                                     / \
                                   [5] [4]

     En  este  diagrama se  nota que  el elemento  ms grande  del 
montculo H est  en la raz.   Adems, cualquier camino  desde un 
nodo hoja a la raz contiene valores crecientes.  Sin embargo,  es 
posible que un subrbol del montculo que se encuentra cerca de la 
raz (3 (1  2 3)) tenga  a todos sus  valores inferiores a  los de 
otro subrbol que est a mayor profundidad (6 (5 4)).

     Para definir el montculo como un Tipo Abstracto de Datos  es 
necesario distinguir entre un nodo del montculo, el contenido del 
nodo  y su posicin  en el montculo.  En  este diagrama los nodos 
son las cajitas  ([1]...[9])   que  estn  ligadas  por  medio  de 
aristas,  el contenido  de cada nodo  es lo que  aparece dentro de 
cada cajita (1..9), y la posicin de cada nodo es un apuntador  al 
nodo.


Abstraccin de THeap
====================

     Para almacenar  un montculo  en el  computador es  necesario 
crear una abstraccin del concepto "montculo", la que luego puede 
ser cristalizada  en la  implementacin del  ADT montculo.   Para 
definir  esta abstraccin  es necesario definir  los elementos que 
forman un montculo:

     1) Nodos
     2) Valor almacenado en cada nodo    [Unidad Task.pas]
     3) Posicin en el montculo
     4) Aristas de enlace entre nodos.

     En  la  implementacin, a  cada uno  de estos  conceptos debe 
corresponder un tipo de datos o un campo en una instancia. En esta 
implementacin, la correspondencia es la siguiente:

     1) Nodo       Tipo    TNode_RepHeap  Heap.pas
     2) Valor      Tipo    TTask          Task.pas
     3) Posicin   Tipo    PHpos          Heap.pas
     4) Arista     Campo                  Heap.pas

     Es  importante   destacar  que   existen  muchas   formas  de 
implementar el ADT montculo, cada una de las que tiene diferentes 
ventajas  que en general comportan  una mejora de rendimiento para 
realizar una  o  varias  de  las  operaciones.   Sin  embargo,  la 
implementacin que siempre  se usa es  la que permite  implementar 
eficientemente  el HeapSort().  Por eso en  general los montculos 
son rboles binarios semicompletos que pueden ser almacenados  con 
gran  eficiencia  en un  vector de  elementos. Los  montculos que 
Heap.pas manipula tienen la siguiente forma:

                               313
                               / \
                             32   12
                            /  \  /
                            7  8 10

     Para incrementar la modularidad del ADT, la implementacin de 
THeap consta  de  dos  unidades  Pascal.   La  primera,  Heap.pas, 
contiene todo el  cdigo  que  implementa  al  ADT  montculo.  La 
segunda es  la  unidad  llamada  Task.pas,  que  tiene  todas  las 
operaciones del ADT elemental contenido en la montculo.  Este ADT 
elemental puede ser, a su vez, otro contenedor.  El ADT  montculo 
puede contener a  cualquier otro ADT  para el que  estn definidas 
las  operaciones  elementales que  usa Heap.pas  para manipular  a 
Task.pas.

     En la mayora de los  contenedores el ADT contenido se  llama 
"Elem". En esta implementacin se usa el nombre "Task" porque  uno 
de las principales aplicaciones de las colas de prioridad se da en 
los Sistemas Operativos, los que deben mantener colas de  procesos 
ordenados de acuerdo a su prioridad.  De todas maneras es  posible 
adaptar el montculo  para que contenga  a otros ADTs  elementales 
con solo cambiar el nombre "Task" del ADT elemental en el programa 
fuente  Heap.pas,  lo que  se puede  hacer con  relativa facilidad 
usando  un  editor  de  texto.  Para  facilitarle este  trabajo al 
programador usuario  de  THeap,  en  el  mdulo  Heap.pas  hay  un 
recuadro  llamado  PARAMETERS  que   tiene  los  nombres  de   los 
identificadores que es necesario cambiar si el elemento  contenido 
en el montculo no se llama "Task".


Operaciones
===========

     Como  ocurre cuando  el programador usa  a la mayora  de los 
ADTs  contenedores,  las  operaciones  sobre  la  montculo  deben 
permitirle definir  sobre cul  de todos  los nodos  del montculo 
desea actuar. Para definir una posicin en el montculo se usa  el 
tipo de datos PHpos.

     Una variable de tipo PHpos es  un puntero a uno de los  nodos 
de  la montculo.  Como  este tipo est definido  como parte de la 
abstraccin del ADT montculo, entonces un PHpos es puntero Pascal 
que no puede  ser derreferenciado.  Esto  quiere decir que  si una 
variable  "p" es  de tipo PHpos,  entonces nunca puede  ser vlido 
manipular aquello a lo que apunta:


     VAR
       p : PHpos;
     ...
     p^ := ....;   {  ERROR !!! }
     FunProc(p):   { OK }

     El ADT montculo  tiene  todas  las  operaciones  de  un  ADT 
elemental. Estas operaciones son las siguientes:

     Init(H):     Constructor; inicializa el montculo.
     Clear(H):    Limpia el montculo.
     Done(H):     Destructor; destruye al montculo.

     Copy(x,y):   Copia el valor del montculo "y" en "x".
     Move(x,y):   Le traslada a "x" el valor del montculo "y".

     Equal(x,y):  Compara el valor de "x" con el de "y".

     Load(H,F):   Carga el valor de "H" desde el archivo "F".
     Store(H,F):  Almacena el valor de "H" en el archivo "F".

     OK(H):       Verifica la invariante del ADT.
     Fix(H):      Repara montculos.

THeap tiene todas las operaciones de un ADT contenedor:

     Empty(H):        Verifica si el montculo est vaco.
     Count(H):        Cantidad de elementos del montculo.

     Retrieve(H,p):   Transforma una posicin en puntero al valor.
     Locate(H,x):     Busca un valor en el montculo.
     Valid(H,p):      TRUE si "p" es una posicin de H.

     La operacin  Retrieve(H,p)   retorna  un  puntero  al  valor 
almancenado en uno de los nodos del montculo "H".  Esta operacin 
es  muy importante porque  es la que separa  al contenedor, que en 
este  caso es el  ADT THeap, de su  elemento contenido, TTask.  La 
existencia  de esta operacin se  justifica porque muchas veces el 
programador  necesita   escribir  algoritmos   que  manipulan   la 
estructura del montculo, sin importar cul es su contenido.  Como 
en esta abstraccin  se separa la  estructura del montculo  de lo 
que contiene,  entonces  los  algoritmos  que  slo  manipulan  la 
estructura del montculo no necesitan ser reprogramados cuando  se 
cambia el tipo de valor  almacenado en el montculo: la  operacin 
Retrieve(H,p) los independiza de ese valor.

     Si, por el contrario,  el programador necesita manipular  los 
valores de  los elementos  almacenados en  el montculo,  entonces 
puede accesarlos en  dos pasos: primero  debe obtener la  posicin 
"p" del nodo en el montculo,  y luego puede obtener el valor  del 
nodo usando Retrieve(H,p).

     La  operacin  Count(H) siempre  aparece en  los contenedores 
pues retorna el nmero total de elementos que contiene.

     Las  operaciones  arriba descritas  son comunes  a todos  los 
contenedores. Lo  que realmente  define al  ADT montculo  son las 
dems operaciones, las que pueden ser ejecutadas eficientemente en 
la estructura de datos montculo.  Las operacions ms  importantes 
de THeap  son Delete_Max()   e Insert(),  que permiten  insertar y 
borrar elementos del montculo con poco esfuerzo y manteniendo  la 
invariante del ADT.  La siguiente tabla muestra a las  operaciones 
que caracterizan a THeap junto con su tiempo de ejecucin:

                      Operacin         Esfuerzo
                   Ŀ
                    Delete_Max(H,T)  O(log(n))   
                   Ĵ
                    Insert(H,T)      O(log(n))   
                   Ĵ
                    Heapify(H)       O(n)        
                   Ĵ
                    HeapSort(H)      O(n*log(n)) 
                   Ĵ
                    Adjust(H,i,j)    O(log(n)) * 
                   

     En general la  operacin  de  borrado  de  un  ADT  tiene  un 
encabezado  direrente a Delete_Max(H,T),  pues Delete(C,p)  lo que 
hace es  eliminar al  elemento de  contenedor "C"  que est  en la 
posicin "p". Sin embargo, como un montculo se usa principalmente 
para implementar colas de prioridad entonces tiene sentido que  el 
nico  elemento que  pueda salir de  la cola sea  el mayor. Aunque 
Delete_Max() fuerza al programador a  pagar el costo de copiar  el 
elemento cada vez que se hace un borrado, en general el ADT  THeap 
se usa para almacenar elementos que pueden ser copiados a un costo 
muy bajo,  o sea,  que los  montculos en  general no  contienen a 
otros ADTs, como  la lista o  el rbol, que  son muy difciles  de 
copiar.   Despus de todo, en  general es bastante difcil definir 
un orden total  sobre un conjunto  de ADTs contenedores,  pues ese 
orden es necesario para determinar cul es el elemento ms  grande 
almacenado en el montculo.

     Para  borrar  al  elemento  mayor  del  lo  que  se  hace  es 
sustituirlo por el ltimo elemento, y restablecer la propiedad del 
montculo, lo que se logra en tiempo logartmico con la  operacin 
Adjust(),  como  se muestra  en el  siguiente diagrama  en que  se 
elimina el valor mayor [313] del montculo:

                Efecto de Delete_Max(H, [313])
           
      Inicio      Traslada        Rota      Montculo
                   ltimo       subrbol   restablecido

        313        -> 6            32           32
        / \          / \          /  \         /  \
      32   12      32   12    -> 6   12       8    12
     /  \  /      /  \          / \          / \
     7  8  6      7  8          7 8          7 6

     La operacin  Insert(H,T)   realiza  la  insercin  de  forma 
inversa  a cmo se hace el  borrado, pues agrega al nuevo elemento 
como ltimo del montculo y procede a restablecer la propiedad del 
montculo de abajo hacia arriba:

       Inicio      Agrega al        Rota         Montculo
                     Final        subrbol      restablecido

         43           43             43 <-           62
        /  \         /  \           /  \            /  \
      32    12     32    10 <-    32    62        32    43
     /  \   /     /  \  /  \     /  \  /  \      /  \  /  \
     7  8  10     7  8  4  62    7   8 4  10     7  8  4  10

     Las otras dos operaciones importantes de THeap son Heapify(H) 
que en tiempo lineal reacomoda  un rbol completo para que  cumpla 
con la la  propiedad del montculo,  y HeapSort(), que  sirve para 
ordenar  por el simple procedimiento  de eliminar del montculo su 
elemento superior hasta que ya queda vaco.

     La operacin Adjust(H,i,j) no aparece en la interfaz del  ADT 
THeap porque sus  parmetros [i,j] son  ndices dentro del  vector 
que almacena un ADT THeap, el que forma parte de su representacin 
interna.   Se menciona aqu por  completitud, pues cuando se habla 
de montculos siempre se menciona a Adjust().

     Como THeap  fue inventado  para crear  HeapSort(), que  es un 
mtodo   muy  eficiente  de   ordenamiento  interno,  entonces  la 
implementacin de las  operaciones de THeap  copia los valores  de 
una  posicin a otra del montculo,  lo que puede no ser apropiado 
en algunas aplicaciones en las que el contenedor no debe copiar  a 
los elementos  que contenga.   En estos  casos, lo  ms simple  es 
crear  un  montculo de  punteros a  los elementos  contenidos, en 
lugar  de  insertar  a  los  elementos  en  el  montculo.    Esta 
implementacin,  sin  embargo,  no  ofrece  esta  posibilidad   al 
programador, aunque es relativamente sencillo modificarla para que 
use punteros.


Modelo
======

     El  modelo del ADT  es un diagrama de  la estructura de datos 
usado para implementarlo.  La  forma ms eficiente de  implementar 
un montculo es representarlo  como un rbol binario  semicompleto 
almacenado un vector.  Sin embargo, para esto es necesario que  el 
montculo  sea   un  rbol   semicompleto,  como   se  muestra   a 
continuacin:

              1   2   3   4   5   6   7         6
     Ŀ      / \
      V[]=  6  5  3  1  4  2 #!@     5   3  <-@3
      Ĵ    / \ /
     _last          1 4 2
     

     Este modelo es muy eficiente, pues no utiliza espacio  alguno 
para  almacenar  los enlaces  entre los  nodos del  rbol. Es  muy 
sencillo encontrar el padre o a  los hijos de cada nodo pues  como 
el  rbol es semicompleto, entonces el  padre del nodo que est en 
el ndice "i" del vector siempre es el nodo que est en la  ndice 
(i DIV 2).  El campo "_last" es la ltima posicin del vector  V[] 
en uso. En el diagrama el padre de los nodos de valor "1" y "4" es 
"5", y se cumple que:
     @5 = 2 = (4 DIV 2) = (@1 DIV 2) = 2 = @5
     @5 = 2 = (5 DIV 2) = (@4 DIV 2) = 2 = @5

     @1 es el ndice nodo del vector V[] que contiene al
        valor "1", que en este caso es "4", pues V[4]=1.

     Adems, para agregar un nodo en el rbol basta ponerlo en  la 
ltima posicin del vector. Ms an, como esta estructura de datos 
fue  inventada  para implementar  el HeapSort(),  es relativamente 
sencillo  ordenar  de menor  a mayor  el montculo,  pues en  cada 
interacin  de HeapSort() lo que se  hace para ordenar es tomar el 
elemento mayor  del montculo  y ponerlo  al final  del vector,  y 
luego  reducir   el  tamao   del  vector,   como  se   muestra  a 
continuacin:

              1   2   3   4   5   6   7         6
     Ŀ      / \
      V[]=  6  5  3  1  4  2 #!@     5   3
1.0)  Ĵ    / \ /
     _last          1 4 2
     


              1   2   3   4   5   6   7         2
     Ŀ      / \
      V[]=  2  5  3  1  4  6 #!@     5   3
2.0)  Ĵ    / \
     _last   >>        1 4 6
     


              1   2   3   4   5   6   7         5
     Ŀ      / \
      V[]=  5  2  3  1  4  6 #!@     2   3
2.1)  Ĵ    / \
     _last   >>        1 4 6
     


              1   2   3   4   5   6   7         5
     Ŀ      / \
      V[]=  5  4  3  1  2  6 #!@     4   3
2.2)  Ĵ    / \
     _last   >>        1 2 6
     

              1   2   3   4   5   6   7         2
     Ŀ      / \
      V[]=  2  4  3  1  5  6 #!@     4   3
3.0)  Ĵ    /
     _last   >>        1 5 6
     

     En esta secuencia  se  muestra  como  en  cada  iteracin  el 
elemento mayor  del montculo  es trasladado  al final  del vector 
[2.0 - 3.0].   Luego, la propiedad  del montculo es  restablecida 
bajando desde la raz hasta las  hojas [2.1 - 2.2]. El proceso  se 
repite "n" veces,  donde "n" es  la cantidad inicial  de elementos 
del montculo.  Al final, los valores almacenado en el vector  del 
montculo V[] estn ordenados de menor a mayor.

     Definitivamente,  HeapSort()   es uno  de los  algoritmos ms 
elegantes que existen.


Comportamientos
===============

     Dado que Heap.pas  es una implementacin  hecha ms que  todo 
para  especificar  el  ADT  que se  usa en  HeapSort(), no  se han 
definido  comportamientos alguno  para ella, aunque  no es difcil 
incluirles  el  comportamiento  Insert_using_Move.   Es  ms  til 
incluirle el  comportamiento Use_Instance_Pointers,  el que  puede 
ser de gran utilidad para implementar Colas de Prioridad.


Detalles de implementacin
==========================

     Desgraciadamente en este ADT no se logra una separacin total 
entre el  ADT contenedor  y su  elemento contenido.   El principal 
problema  de esta falta de independencia  es que si en un programa 
se necesita usar dos tipos de montculo, ser necesario crear  dos 
copias completas del  ADT THeap, una  para cada tipo  de elemento. 
Ms an, es  imposible  que  un  mismo  elemento  est  en  varios 
contenedores a  menos  que  el  contenedor  use  punteros  a  cada 
elemento.  En  algunos lenguajes  modernos, como  C++ y  ADA, esta 
restriccin se soluciona, de forma parcial y poco elegante, con el 
uso  de  Tipos  Parametrizados,  llamados  plantillas  o  paquetes 
genricos.   Existe  una solucin  alterna, pero  requiere de  una 
filosofa de construccin de programas bastantes diferente, aunque 
su  uso incrementa  significativamente la modularidad  de los ADTs 
as  usados,  lo que  se logra  con la  unidad Binder.pas,  que se 
describe en otro documento.

     Otra  incomodidad bastante grande  que debe sobrellevar quien 
use el ADT  THeap es que  debe definir un  ADT de tipo  TTask para 
usar el contendor. En muchas ocasiones los programdores encuentran 
esto tan  engorroso que  terminan cambiando  la implementacin  de 
THeap para evitar  la proliferacin de  tipos TTask.  Esto  ocurre 
cuando se necesita  una montculo simple,  que contiene nmeros  o 
letras,  pues en estos  casos el definir todo  un ADT para objetos 
tan  simples es un trabajo  demasiado grande (aburrido?)  para el 
programador.

     El  tipo PHpos  se implementa como  un puntero que  apunta al 
mismo tipo, de forma que el programador no puede  derreferenciarlo 
y usarlo.  Aunque la forma natural de representar un montculo  es 
usando un  vector, al  especificar el  ADT no  es lo  ms correcto 
suponer que en  la implementacin siempre  se usa un  vector.  Por 
eso  en la abstraccin no existe  el tipo THind, que servira para 
referenciar  a cada componente del  vector de THeap.  Sin embargo, 
si el programador desea definir el ADT THeapV, en cuya abstraccin 
se especifica que se usa  un vector, entonces la funcin  Adjust() 
tendra el siguiente encabezado:

     TYPE
       THind = WORD;

     PROCEDURE Adjust(VAR H: THeapV; i, n: THind)

No siempre es claro hasta  dnde llega la abstraccin, y  comienza 
la  implementacin. No  es incorrecto especificar  THeapV de forma 
que use un  vector en su  implementacin, pues las  estructuras de 
datos existen  para hacer  programas eficientes,  y necesariamente 
esto  se  logra slo  al usar  las implementaciones  adecuadas. Lo 
importante es que la Abastraccin de Datos es una herramienta  que 
el programador usa para lograr programas modulares, y nunca  puede 
verse como un fin es si misma.  La pureza terica no siempre ayuda 
a hacer programas eficientes y fciles de mantener.


Bibliografa
============

[1] Aho, Alfred V.; John E.  Hopcroft; Jefrrey  D.  Ullman:  "Data 
    Structures and Algorithms"; 1983. [AHO-83].

[2] Borland; "Turbo Pascal Version 5.5"; 1984.

[3] Liskov, Barbara; Gutag,  John; "Abstraction  and Specification 
    in Program Development"; McGraw-Hill; 1986.

[4] Di Mare, Adolfo:  "Convenciones de  Programacin para  Pascal, 
    Revisin 2"; Reporte tcnico ECCI-01-88, ECCI-UCR, 1988.

[5] Di  Mare, Adolfo:  "Abstraccin de  Datos en  Pascal"; Reporte 
    tcnico PIBDC-01-89, ECCI-UCR, 1991.

[6] Horowitz, E.; Sahni,  S.: "Fundamentals  of Data  Structures"; 
    Computer Science Press; 1982.


               Reportes tcnicos de Adolfo Di Mare
               ===================================

     Los siguientes Reportes Tcnicos, todos confeccionados por el 
mismo autor, describen todos  las implementaciones y algunos  usos 
importantes de los ADTs programados en Turbo Pascal en al  Escuela 
de Ciencias de la Computacin e Informtica, de la Universidad  de 
Costa Rica. 

     Todas estas  implementaciones estn  disponibles en  Internet
por medio de ftp annimo en el directorio:

     http://www.di-mare.com/adolfo/p/src/Heap.zip

     Los derechos de autor  estn reservados  a nombre  del autor,
Adolfo Di Mare.

     El texto de cada Reporte Tcnico se encuentra  en el  archivo
de texto nombrado entre parntesis cuadrados.

[R1]  "Prueba  interactiva  de  ADTs", Reporte  Tcnico ECCI-94-01
      [Archivo UseADT.doc]; Mayo, 1994.

[R2]  "La Implementacin de Elem.pas"; Reporte  Tcnico ECCI-94-02
      [Archivo Elem.doc]; Mayo 1994.

[R3]  "La   Implementacin   de  Rational.pas";   Reporte  Tcnico
      ECCI-94-03 [Archivo Rational.doc]; Mayo 1994.

[R4]  "La Implementacin de Poly.pas"; Reporte  Tcnico ECCI-94-04
      [Archivo Poly.doc]; Mayo 1994.

[R5]  "La    Implementacin  de   ListAHO.pas";  Reporte   Tcnico
      ECCI-94-05 [Archivo Aho.doc]; Mayo 1994.

[R6]  "La Implementacin de List.pas"; Reporte  Tcnico ECCI-94-06
      [Archivo List.doc]; Mayo 1994.

[R7]  "La Implementacin de Tree.pas"; Reporte  Tcnico ECCI-94-07
      [Archivo Tree.doc]; Mayo 1994.

[R8]  "La Implementacin de Heap.pas"; Reporte  Tcnico ECCI-94-08
      [Archivo Heap.doc]; Mayo 1994.

[R9]  "Uso  de  la  unidad Test.pas";  Reporte Tcnico  ECCI-94-09
      [Archivo Test.doc]; Mayo 1994.

[R10] "Manejo  de excepciones  en Turbo  Pascal"; Reporte  Tcnico
      ECCI-94-10 [Archivo Except.doc]; Mayo 1994.
