[UCR]  
[/\]
Universidad de Costa Rica
Escuela de Ciencias de la
Computación e Informática
[<=] [home] [<>] [\/] [=>]

La Implementación de Poly.pas

Reporte Técnico ECCI-94-04

Proyecto 326-89-019

Adolfo Di Mare

Resumen [<>] [\/] [/\]

Se discute cómo está construida la implementación del ADT TPoly, que sirve para usar polinomios en programas Pascal. La implementación se ha realizado para el ambiente Turbo Pascal v5.0, aunque para trabajar con ella es más cómodo usar la versión v6.0 o una posterior. We discuss the implementation for the TPoly Abstract Data Type. This ADT is usefull for Pascal programs where polynomials are needed. This implementation has been made for the Turbo Pascal v5.0 environment, even though it is less cumbersome to use version v6.0 or later to work with it.

      La unidad poly.pas es un módulo Pascal muy simple que sirve para manejar polinomios. Esta implementación se ha hecho tomando como base la implementación del ADT Elem.pas, la que sirvió de plantilla para crear las operaciones de poly.pas.

      El ADT elemental Poly tiene todas las operaciones que los ADTs contenedores necesitan para manipular al ADT elemental, por lo que puede ser almacenado en cualquier contenedor.

      El valor didáctico de este ADT estriba en que, al estudiarlo, el estudiante puede ver porqué es muy sencillo usar a Elem.pas como plantilla para crear nuevos ADTs. Básicamente, el trabajo realizado consistió en es usar el editor de textos para remplazar el nombre TElem por TPoly, y luego agregar las operaciones particulares sobre polinomios.

      Como estos ADTs sirven como plantilla para crear los ADTs elementales que estarán almacenados en un contendor, su estudio tiene valor didáctico.

 

1. Abstracción de TPoly [<>] [\/] [/\]

      El ADT TPoly sirve para represenar polinomio real de de una variable real. Un polinomio es una función que tiene la siguiente forma:

p(x) = an* xn + ... + a1* x1 + a0

      Cada término [ai * xi] del polinomio está caracterizado por dos números. El coeficiente del término es el número real "ai" que multilplica a la variable "x", y el grado del término es el exponente entero al que está elevada la variable. El grado del polinomio es el grado más alto de todos sus términos. Los números reales son polinimios de grado cero. El polinomio cero también tiene grado cero.

      El ADT TPoly es un ADT elemental, pero no es un contenedor, pues los contenedores son aquellos ADTs cuya razón de existencia es almacenar a otros ADTs. Los más importantes contenedores son la Lista y el Arbol). Los ADTs elementales existen para independizar la implementación del contenedor del elemento contenido. Todo ADT elemental tiene un conjunto de operaciones básicas, que son las que usa el contenedores puedan manipularlos, y otro conjunto de operaciones que lo caracterizan. En el caso de TPoly, en esta segunda clase de operaciones se encuentra alguna de las operaciones algebraicas más importantes sobre polinomios. Las demás pueden implementarse en términos de éstas.

 

2. Operaciones [<>] [\/] [/\]

      Las operaciones del ADT TPoly son las operaciones aritméticas. Además, TPoly incluye todas las operaciones que un contenedor necesita para manipular a su ADT elemental. Las operaciones de TPoly son las siguientes:

Init(q)
Constructor; inicializa el polinomio.
Clear(q)
Limpia al polinomio.
Done(q)
Destructor; destruye al polinomio.
Copy(x,y)
Copia el valor del polinomio "y" en "x".
Move(x,y)
Le traslada a "x" el valor del polinomio "y".
Equal(x,y)
Compara el valor de "x" con el de "y".
Load(p,F)
Carga el valor de "p" desde el archivo "F".
Store(p,F)
Almacena el valor de "p" en el archivo "F".
OK(r)
Verifica la invariante del ADT.
Fix(r)
Repara polinomios.
Set_Term(p, c,n)
Incluye el término c * xn en p.
Degree(p)
Retorna el grado de p.
Coef(p, exp)
Retorna el coeficiente del término exp.
Add(p,q, r)
r := p+q;
Sub(p,q, r)
r := p-q;
Mult(p,q, r)
r := p*q;
Minus(p, r)
r := -p;
Is_ZERO(x)
¿Es x = 0?
Eval(p,x)
Calcula p(x)
To_STRING(r)
Representa a p como una hilera

      Las primeras operaciones [Init()...Fix()] son las que los contenedores usan para manipular al ADT que contienen. Por si solas no caracterizan al ADT TPoly. Las que se lo caracterizan son las otras, que sirven para cambiar el valor de un polinomio.

      Como Pascal no permite la Sobrecarga de Operadores, lo que si es permitido en Ada y C++, entonces las operaciones aritméticas se han definido como procedimientos que reciben en sus primeros argumentos los valores sobre los que operan, y retornan el resultado en el último argumento.

      La operación Poly.Set_Term(p, c,n) es la que permite cambiarle el valor al polinomio cambiando cada uno de sus términos. Las operaciones que complementan a Set_Term() son las funciones Degree() y Coef(), que permiten saber el coeficiente de cada uno de los términos del polinomio. Eval(p,x) permite evaluar eficientemente el polinomio en el número "x".

 

3. Modelo [<>] [\/] [/\]

      El modelo del ADT es un diagrama de la estructura de datos usado para implementarlo. El modelo de TPoly es un arreglo en donde se almacenan todos los coeficientes del polinomio, junto al grado del polinomio: 

         0   1   2   3   4   5   .. Max_Grado
+--------+---+---+---+---+---+---+------+---+
|_coef[] | 4 | 0 | 2 | 0 | 0 | 1 | .... |#!@|  x^5 + 2x^2 + 4
|--------+---+---+---+---+---+---+------+---+
|_grad ------------------------^   ....     |
+-------------------------------------------+

      El tamaño del arreglo _coef[] es Poly.Max_Grado y es el grado máximo que puede representarse con este ADT.

 

4. Comportamientos [<>] [\/] [/\]

      Al definir este ADT no se le definieron comportamientos, pues en general, estos se usan para los ADT contenedores.

 

5. Detalles de implementación [<>] [\/] [/\]

      Esta implementación es muy simple. Lo único que importa destacar es la necesidad de la operación poly.Adjust(p), que se invoca al final de la implementación de cada una de las operaciones de TPoly, para evitar que el grado del polinomio haya disminuido.

 

Reconocimientos [<>] [\/] [/\]

      Esta investigación se realizó dentro del proyecto de investigación 326-93-256 "DBgen: generación automática de programas a partir de su base de datos", inscrito ante la Vicerrectoría de Investigación de la Universidad de Costa Rica. La Escuela de Ciencias de la Computación e Informática también ha aportado fondos para este trabajo.

 

Bibliografía [<>] [\/] [/\]

[DiM-94b] Di Mare, Adolfo: La Implementación de Elem.pas, Reporte Técnico ECCI-94-02, Proyecto 326-89-019, Escuela de Ciencias de la Computación e Informática, Universidad de Costa Rica, 1994.
      http://www.di-mare.com/adolfo/p/elem.htm
[DiM-94f] Di Mare, Adolfo: La Implementación de List.pas, Reporte Técnico ECCI-94-06, Proyecto 326-89-019, Escuela de Ciencias de la Computación e Informática, Universidad de Costa Rica, 1994.
      http://www.di-mare.com/adolfo/p/list.htm
[LG-86] Liskov, Barbara & Guttag, John: Abstraction and Specification in Program Development, McGraw-Hill, 1986.

 

Indice [<>] [\/] [/\]

[-] Resumen
[1] Abstracción de TPoly
[2] Operaciones
[3] Modelo
[4] Comportamientos
[5] Detalles de implementación
[-] Reconocimientos
Bibliografía
Indice
Acerca del autor
Acerca de este documento
[/\] Principio [<>] Indice [\/] Final

 

Acerca del autor [<>] [\/] [/\]

Adolfo Di Mare: Investigador costarricense en la Escuela de Ciencias de la Computación e Informática [ECCI] de la Universidad de Costa Rica [UCR], en donde ostenta el rango de Profesor Catedrático. Trabaja en las tecnologías de Programación e Internet. Es Maestro Tutor del Stvdivm Generale de la Universidad Autónoma de Centro América [UACA], en donde ostenta el rango de Catedrático y funge como Consiliario Académico. Obtuvo la Licenciatura en la Universidad de Costa Rica y la Maestría en Ciencias en la Universidad de California, Los Angeles [UCLA].

[mailto] Adolfo Di Mare <adolfo@di-mare.com>

 

Acerca de este documento [<>] [\/] [/\]

Referencia: Di Mare, Adolfo: La Implementación de Poly.pas, Reporte Técnico ECCI-94-04 Proyecto 326-89-019, Escuela de Ciencias de la Computación e Informática (ECCI), Universidad de Costa Rica (UCR), 1994.
      http://www.di-mare.com/adolfo/p/poly.htm
      http://www.di-mare.com/adolfo/p/src/poly.zip
Autor: Adolfo Di Mare <adolfo@di-mare.com>
Contacto: Apdo 4249-1000, San José Costa Rica
Tel: (506) 207-4020       Fax: (506) 438-0139
Revisión: ECCI-UCR, Marzo 1999
Visitantes:


Copyright © 1994 Adolfo Di Mare
Derechos de autor reservados © 1994 Adolfo Di Mare <adolfo@di-mare.com>
[home] [<>] [/\]