POLI_2 (0.6.0a):
	Funcionamiento basico de lectura de los polinomios desde el archivo de texto.

POLI_3 (0.7.0a):
	Se le agragan los procedimientos pensados en la clase para operar entre polinomios
	("suma", "resta", "producto" y "division").
	Se le agrega un procedimiento para inicializar los vectores.
	Se unifica el tipo de vectores, desapareciendo "VectorResultado" y pasando el tipo
	"Vector" a tener el tamaño maximo (TAM_MAX).
	Se borran las lineas para DEBUG (refinar) y el tipo de dato "Termino".
	Por ahora no compila ...

POLI_4 (0.8.0a):
	Compila pero no fueron probadas las operaciones (solo se arreglo el codigo erroneo
	que no permitia compilar).

POLI_5 (0.8.2a):
	Se testeo la suma y funciona correctamente. Tambien se agrega un procedimiento para mostrar
	los polinomios por pantalla ("muestraVector").

POLI_6 (0.8.4a):
	Se mejora notablemente el procedimiento , agregandole una funcion "exponente"
	para mejorar la presentacion de los polinomios por pantalla. Ahora la salida es mas limpia
	y legible.

POLI_7 (0.8.5a):
	Se testea la resta y se arregla la dicho procedimiento porque tenia un operador mal, lo que hacia
	que se sume en vez de que se reste.
	Se cambia:
		vr[i] := v1[i] + v2[i];  { resta los coeficientes de los terminos con igual exponente }
					  ===
	por:
		vr[i] := v1[i] - v2[i];  { resta los coeficientes de los terminos con igual exponente }
					  ===

POLI_8 (0.9.0b):
	Se testea el producto y se arregla la dicho procedimiento porque tenia una nombre de variable mal,
	lo que hacia que la variable j no se incremente y que i pierda su valor, dando un resultado erroneo.
	Se cambia:
		for i := 0 to TAM - 1 do { recorre el 2do vector (de tamaño maximo TAM) }
		   ===
	por:
		for j := 0 to TAM - 1 do { recorre el 2do vector (de tamaño maximo TAM) }
		   ===

POLI_9 (0.9.8b):
	Se corrije nuevamente el procedimiento "muestraVector" para que si el polinomio es nulo,
	se presente en pantalla un cero en vez de no presentar nada como se hacia antes.
	Se testea la division y se encuentra que si el segundo polinomio es nulo, da un error de
	ejecucion (runtime error). Para evitarlo, se transforma el procedimiento en funcion, haciendo
	que devuelva true si se efectuo con exito (el segundo polinomio no es nulo) o false si no
	se pudo efectuar (el segundo polinomio es nulo). De esta manera el bloque que llame a esta
	funcion puede decidir que hacer en caso de que el segundo polinomio sea nulo.
	Tambien se agregan los comentarios a esta funcion.

POLI_10 (1.0.1r):
	Se agrega una descripcion del programa indicando el formato que debe tener el archivo con los datos.
	Tambien se agrega a esta y todas las versiones anteriores una constante llamada VERSION, que
	almacena un String con la version del programa para ser mostrada cuando se mejore la salida.
	Tambien se modifica el nombre del programa como PolinomiosEnVector para diferenciarlo de la nueva
	implementacion con un record (TERM o PolinomiosEnTermino).

POLI_11 (1.0.5r):
	Se corrije el case en la seccion FIN de la funcion cargarVectores:
	Se reescribe por casi completo porque tenía varias lineas que no aportaban nada y un par
	de errores por los cuales la funcion devolvia verdadero sin que se hayan leido ambos polinomios.
	Ahora es mas concisa, legible y eficiente.

POLI_12 (1.1.3b):
	Se mejora la interfaz para el usuario. Ahora se basa en menues a color con diferentes opciones.
	Tambien se agrega un procedimiento para presentar un mensaje en la salida pero aún no está 
	implementado.

POLI_13 (1.2.3r):
	Se implementa el mensaje de salida y se corrigen algunas pequeñas lineas del bloque principal del
	programa. Tambien se corrijen algunos mensajes para que la salida sea mas prolija. Entre las
	correcciones se encuentra la funcion obtenerNombreArchivo que en ciertas circunstancias se
	superponian los mensajes.

POLI_14 (1.2.5r):
	Se corrijen algunos otros mensajes de pantalla y se cambia el titulo del programa por el nombre
	del mismo.

==========================================================================================================
==========================================================================================================

TERM_0 (0.0.1a):
	Se empiezan a hacer los cambios para transformar el programa POLI en TERM, programa similar pero
	que guarda los datos en un record llamado Termino:
	type
		Termino = record
						coef: real;
						exp: integer;
				  end;
	El nombre del programa es: PolinomiosEnTermino.
	Hasta ahora se modifico hasta la linea 330 aproximadamente y dudo que compile (de hacerlo seria una
	coincidencia).

TERM_1 (0.1.0a):
	Se agregan 2 variables en la funcion cargarVectores:
		n: integer -> indica el termino actual del polinomio para hacer las asignaciones.
		asignado: boolean -> indica si ya se hizo la asignacion.
	Se agrega una condicion mas para el formato del archivo con los datos (el orden de los terminos
	segun el exponente).
	Se hace una cantidad de cambios considerables al case en sus secciones:
		COEF_FIN: se inicializan las nuevas variables.
		EXP_FIN: se corrije el metodo de asignacion para funcionar con la nueva estructura Termino.
		POLI_FIN: se cambian y agregan algunas asignaciones para funcionar con la nueva implementacion.
		FIN: se efectuan cambios considerables para adaptarlo al nuevo sistema.
	Finalmente se sacan las antiguas funciones suma, resta, producto y division. Tambien se pone en
	comentarios sus llamadas desde el bloque principal para lograr que el codigo compile.
	El programa compila y supuestamente deberia funcionar la lectura de datos. No se hizo ninguna
	prueba de ejecucion del programa a esta altura...

TERM_2 (0.2.0a):
	Se agregan un par de lineas de DEBUG y con esto se ve que la funcion muestraVector funciona
	correctamente. Se arreglan un par de lineas en el case de cargarVectores, en la seccion EXP_FIN:
	En las lineas 346/7 decia:
			v1[n].coef := rCoef;
			v1[n].exp := iExp; 
	y fue reemplazado por
			v2[n].coef := rCoef;
			v2[n].exp := iExp;
	Gracias a esto antes se reemplazaba los valores de v1 y nunca se le asignaba nada a v2 (con una
	excepcion).
	Aparentemente, con estas correcciones ya funciona la parte de lectura.

TERM_3 (0.9.0b):
	Se cambia toda la forma de encarar el problema. Practicamente se anulan todas las modificaciones
	hechas en las versiones TERM_1 y TERM_2. Ahora la implementacion de este programa es mucho mas
	similar a la de POLI, ya que se estaba haciendo cada vez mas compleja sin necesidad y sin proporcionar
	beneficios (ni de espacio, ni de velocidad, ni de memoria).
	Los cambios con respecto a POLI son minimos, solo se modifican las funciones mostrarVector (sigue
	igual que en TERM_0), la funcion cargarVectores (en las secciones EXP_FIN y FIN, de manera
	practicamente identica), en la funcion inicializaVector y en las funciones de operaciones (suma,
	resta, producto y division).
	Los cambios se centran en su mayoria (casi en su totalidad) en el reemplazo de instrucciones como
	esta:
			vr[i-j] := v1[i] / v2[j];

	por instrucciones de este estilo:

			vr[i-j].coef := v1[i].coef / v2[j].coef;
			vr[i-j].exp := v1[i].exp - v2[j].exp;

	Todavia no se probó el funcionamiento del programa pero se espera que no haya grandes problemas.

TERM_4 (1.2.0r):
	Se implementa la misma interfaz grafica que se utilizo en POLI. Ademas se prueba la funcionalidad
	del programa.

TERM_5 (1.2.2r):
	Se corrijen algunos otros mensajes de pantalla y se cambia el titulo del programa por el nombre
	del mismo.