--- /dev/null
+POLI_2 (0.6.0a):\r
+ Funcionamiento basico de lectura de los polinomios desde el archivo de texto.\r
+\r
+POLI_3 (0.7.0a):\r
+ Se le agragan los procedimientos pensados en la clase para operar entre polinomios\r
+ ("suma", "resta", "producto" y "division").\r
+ Se le agrega un procedimiento para inicializar los vectores.\r
+ Se unifica el tipo de vectores, desapareciendo "VectorResultado" y pasando el tipo\r
+ "Vector" a tener el tamaño maximo (TAM_MAX).\r
+ Se borran las lineas para DEBUG (refinar) y el tipo de dato "Termino".\r
+ Por ahora no compila ...\r
+\r
+POLI_4 (0.8.0a):\r
+ Compila pero no fueron probadas las operaciones (solo se arreglo el codigo erroneo\r
+ que no permitia compilar).\r
+\r
+POLI_5 (0.8.2a):\r
+ Se testeo la suma y funciona correctamente. Tambien se agrega un procedimiento para mostrar\r
+ los polinomios por pantalla ("muestraVector").\r
+\r
+POLI_6 (0.8.4a):\r
+ Se mejora notablemente el procedimiento , agregandole una funcion "exponente"\r
+ para mejorar la presentacion de los polinomios por pantalla. Ahora la salida es mas limpia\r
+ y legible.\r
+\r
+POLI_7 (0.8.5a):\r
+ Se testea la resta y se arregla la dicho procedimiento porque tenia un operador mal, lo que hacia\r
+ que se sume en vez de que se reste.\r
+ Se cambia:\r
+ vr[i] := v1[i] + v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ ===\r
+ por:\r
+ vr[i] := v1[i] - v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ ===\r
+\r
+POLI_8 (0.9.0b):\r
+ Se testea el producto y se arregla la dicho procedimiento porque tenia una nombre de variable mal,\r
+ lo que hacia que la variable j no se incremente y que i pierda su valor, dando un resultado erroneo.\r
+ Se cambia:\r
+ for i := 0 to TAM - 1 do { recorre el 2do vector (de tamaño maximo TAM) }\r
+ ===\r
+ por:\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tamaño maximo TAM) }\r
+ ===\r
+\r
+POLI_9 (0.9.8b):\r
+ Se corrije nuevamente el procedimiento "muestraVector" para que si el polinomio es nulo,\r
+ se presente en pantalla un cero en vez de no presentar nada como se hacia antes.\r
+ Se testea la division y se encuentra que si el segundo polinomio es nulo, da un error de\r
+ ejecucion (runtime error). Para evitarlo, se transforma el procedimiento en funcion, haciendo\r
+ que devuelva true si se efectuo con exito (el segundo polinomio no es nulo) o false si no\r
+ se pudo efectuar (el segundo polinomio es nulo). De esta manera el bloque que llame a esta\r
+ funcion puede decidir que hacer en caso de que el segundo polinomio sea nulo.\r
+ Tambien se agregan los comentarios a esta funcion.\r
+\r
+POLI_10 (1.0.1r):\r
+ Se agrega una descripcion del programa indicando el formato que debe tener el archivo con los datos.\r
+ Tambien se agrega a esta y todas las versiones anteriores una constante llamada VERSION, que\r
+ almacena un String con la version del programa para ser mostrada cuando se mejore la salida.\r
+ Tambien se modifica el nombre del programa como PolinomiosEnVector para diferenciarlo de la nueva\r
+ implementacion con un record (TERM o PolinomiosEnTermino).\r
+\r
+POLI_11 (1.0.5r):\r
+ Se corrije el case en la seccion FIN de la funcion cargarVectores:\r
+ Se reescribe por casi completo porque tenía varias lineas que no aportaban nada y un par\r
+ de errores por los cuales la funcion devolvia verdadero sin que se hayan leido ambos polinomios.\r
+ Ahora es mas concisa, legible y eficiente.\r
+\r
+POLI_12 (1.1.3b):\r
+ Se mejora la interfaz para el usuario. Ahora se basa en menues a color con diferentes opciones.\r
+ Tambien se agrega un procedimiento para presentar un mensaje en la salida pero aún no está \r
+ implementado.\r
+\r
+POLI_13 (1.2.3r):\r
+ Se implementa el mensaje de salida y se corrigen algunas pequeñas lineas del bloque principal del\r
+ programa. Tambien se corrijen algunos mensajes para que la salida sea mas prolija. Entre las\r
+ correcciones se encuentra la funcion obtenerNombreArchivo que en ciertas circunstancias se\r
+ superponian los mensajes.\r
+\r
+POLI_14 (1.2.5r):\r
+ Se corrijen algunos otros mensajes de pantalla y se cambia el titulo del programa por el nombre\r
+ del mismo.\r
+\r
+==========================================================================================================\r
+==========================================================================================================\r
+\r
+TERM_0 (0.0.1a):\r
+ Se empiezan a hacer los cambios para transformar el programa POLI en TERM, programa similar pero\r
+ que guarda los datos en un record llamado Termino:\r
+ type\r
+ Termino = record\r
+ coef: real;\r
+ exp: integer;\r
+ end;\r
+ El nombre del programa es: PolinomiosEnTermino.\r
+ Hasta ahora se modifico hasta la linea 330 aproximadamente y dudo que compile (de hacerlo seria una\r
+ coincidencia).\r
+\r
+TERM_1 (0.1.0a):\r
+ Se agregan 2 variables en la funcion cargarVectores:\r
+ n: integer -> indica el termino actual del polinomio para hacer las asignaciones.\r
+ asignado: boolean -> indica si ya se hizo la asignacion.\r
+ Se agrega una condicion mas para el formato del archivo con los datos (el orden de los terminos\r
+ segun el exponente).\r
+ Se hace una cantidad de cambios considerables al case en sus secciones:\r
+ COEF_FIN: se inicializan las nuevas variables.\r
+ EXP_FIN: se corrije el metodo de asignacion para funcionar con la nueva estructura Termino.\r
+ POLI_FIN: se cambian y agregan algunas asignaciones para funcionar con la nueva implementacion.\r
+ FIN: se efectuan cambios considerables para adaptarlo al nuevo sistema.\r
+ Finalmente se sacan las antiguas funciones suma, resta, producto y division. Tambien se pone en\r
+ comentarios sus llamadas desde el bloque principal para lograr que el codigo compile.\r
+ El programa compila y supuestamente deberia funcionar la lectura de datos. No se hizo ninguna\r
+ prueba de ejecucion del programa a esta altura...\r
+\r
+TERM_2 (0.2.0a):\r
+ Se agregan un par de lineas de DEBUG y con esto se ve que la funcion muestraVector funciona\r
+ correctamente. Se arreglan un par de lineas en el case de cargarVectores, en la seccion EXP_FIN:\r
+ En las lineas 346/7 decia:\r
+ v1[n].coef := rCoef;\r
+ v1[n].exp := iExp; \r
+ y fue reemplazado por\r
+ v2[n].coef := rCoef;\r
+ v2[n].exp := iExp;\r
+ Gracias a esto antes se reemplazaba los valores de v1 y nunca se le asignaba nada a v2 (con una\r
+ excepcion).\r
+ Aparentemente, con estas correcciones ya funciona la parte de lectura.\r
+\r
+TERM_3 (0.9.0b):\r
+ Se cambia toda la forma de encarar el problema. Practicamente se anulan todas las modificaciones\r
+ hechas en las versiones TERM_1 y TERM_2. Ahora la implementacion de este programa es mucho mas\r
+ similar a la de POLI, ya que se estaba haciendo cada vez mas compleja sin necesidad y sin proporcionar\r
+ beneficios (ni de espacio, ni de velocidad, ni de memoria).\r
+ Los cambios con respecto a POLI son minimos, solo se modifican las funciones mostrarVector (sigue\r
+ igual que en TERM_0), la funcion cargarVectores (en las secciones EXP_FIN y FIN, de manera\r
+ practicamente identica), en la funcion inicializaVector y en las funciones de operaciones (suma,\r
+ resta, producto y division).\r
+ Los cambios se centran en su mayoria (casi en su totalidad) en el reemplazo de instrucciones como\r
+ esta:\r
+ vr[i-j] := v1[i] / v2[j];\r
+\r
+ por instrucciones de este estilo:\r
+\r
+ vr[i-j].coef := v1[i].coef / v2[j].coef;\r
+ vr[i-j].exp := v1[i].exp - v2[j].exp;\r
+\r
+ Todavia no se probó el funcionamiento del programa pero se espera que no haya grandes problemas.\r
+\r
+TERM_4 (1.2.0r):\r
+ Se implementa la misma interfaz grafica que se utilizo en POLI. Ademas se prueba la funcionalidad\r
+ del programa.\r
+\r
+TERM_5 (1.2.2r):\r
+ Se corrijen algunos otros mensajes de pantalla y se cambia el titulo del programa por el nombre\r
+ del mismo.\r
--- /dev/null
+Calculo con el Matematica de polinomios de Datos2.txt
+
+PolynomialQuotient[1.99x^5+x^4+1.76x^3+0.5x^2+2x-1.2,-2.98x^5-1.23x^4-3.1x^3+2x^2+0.2x-6.1,x]
+-0.667785
+
+PolynomialRemainder[1.99x^5+x^4+1.76x^3+0.5x^2+2x-1.2,-2.98x^5-1.23x^4-3.1x^3+2x^2+0.2x-6.1,x]
+ 2 3 4
+-5.27349 + 2.13356 x + 1.83557 x - 0.310134 x + 0.178624 x
+ ^
+ Leandro Fijate que ahi segun nuestro
+ programa en pascalito va un 2.01 ??!?
+ No creo que hinchen las bolas por eso
+
+Che, Javier, tengo una buena noticia y una mala noticia.
+La buena es que nuestro programa de pascalito anda JOYA y la mala es que tu programa matematica anda
+como el ort...o. Lo probe a mano y esta bien el nuestro, fijate:
+
+ 1.99 X^5 + X^4 + 1.76 X^3 + 0.50 X² + 2 X - 1.20 | -2.98 X^5 - 1.23 X^4 - 3.10 X^3 + 2 X² + 0.02 X - 6.10
+ +--------------------------------------------------------
+- -0.667785...
+
+ 1.99X^5 + 0.82X^4 + 2.07X^3 - 1.33X^2 - 0.01X + 4.07
+-----------------------------------------------------------
+
+ 0 X^5 + 0.18 X^4 - 0.31 X^3 + 1.83 X^2 + 2.01 X - 5.27
+ ==========
+
+ Ahora que acabo de terminar esta porquería, me doy cuenta que tipeaste mal el polinomio asi que cambio el
+ titular de la mala noticia:
+ EL QUE ESTA COMO EL ORT....O SOS VOS!!!
+
+ Al segundo polinomio le mandaste ... + 0.2 X - ... en vez de ... + 0.02 X - ...
+
+ Bueno, lo importante es que el programa anda JOYA PERLA!!!
\ No newline at end of file
--- /dev/null
+-1 0\r
+2 1\r
+0 2\r
+1 3\r
+1 4\r
+1 5\r
+6 6\r
+5.6 7\r
+4.23 8\r
+-4.55 9\r
+3.3443 10\r
+-343.233 11\r
+3 12\r
+3 13\r
+223.122 14\r
+12.123 15\r
+1.123 16\r
+12 17\r
+54.3 18\r
+42 19\r
+0.54 20\r
+-3.22 21\r
+23.4 22\r
+1.7 23\r
+76.4 24\r
+-4 25\r
+48.4437833254562 26\r
+33.2 27\r
+-23 28\r
+-52 29\r
+68 30\r
+23.45 31\r
+-787.5 32\r
+33.434 33\r
+-4232.234 34\r
+3345.6334 35\r
+-4564 36\r
+4 37\r
+4.31 38\r
+0.2 39\r
+2 40\r
+-23.32 41\r
+12.31125656 42\r
+-6.0 43\r
+0.1 44\r
+2.2 45\r
+-3.3 46\r
+-1.4 47\r
+-2.5 48\r
+1123.233 49\r
+\r
+\r
+\r
+-1 0\r
+2 1\r
+0 2\r
+1 3\r
+1 4\r
+1 5\r
+6 6\r
+5.6 7\r
+4.23 8\r
+-4.55 9\r
+3.3443 10\r
+-343.233 11\r
+3 12\r
+3 13\r
+223.122 14\r
+12.123 15\r
+1.123 16\r
+12 17\r
+54.3 18\r
+42 19\r
+0.54 20\r
+-3.22 21\r
+23.4 22\r
+1.7 23\r
+76.4 24\r
+-4 25\r
+48.4437833254562 26\r
+33.2 27\r
+-23 28\r
+-52 29\r
+68 30\r
+23.45 31\r
+-787.5 32\r
+33.434 33\r
+-4232.234 34\r
+3345.6334 35\r
+-4564 36\r
+4 37\r
+4.31 38\r
+0.2 39\r
+2 40\r
+-23.32 41\r
+12.31125656 42\r
+-6.0 43\r
+0.1 44\r
+2.2 45\r
+-3.3 46\r
+-1.4 47\r
+-2.5 48\r
+1123.233 49
\ No newline at end of file
--- /dev/null
+-1.2 0\r
+2 1\r
+0.5 2\r
+1.76 3\r
+1 4\r
+1.9887 5\r
+\r
+-6.1 0\r
+0.02 1\r
+2 2\r
+-3.1 3\r
+-1.23 4\r
+-2.98251 5
\ No newline at end of file
--- /dev/null
+-1 0\r
+5 2\r
+2 4\r
+\r
+-6 0\r
+2 1\r
+1 4
\ No newline at end of file
--- /dev/null
+1 0\r
+3 1\r
+1 2\r
+\r
+0 0\r
+0 1\r
+0 2
\ No newline at end of file
--- /dev/null
+0 0\r
+-6 1\r
+10 3\r
+-3 2\r
+a5 4\r
+\r
+\r
+0 0\r
+2 1\r
+1 2
\ No newline at end of file
--- /dev/null
+program PolinomiosEnVector;\r
+{ Programa que lee 2 polinomios desde un archivo de texto para luego\r
+ hacer operaciones basicas entre estos (suma, resta, multiplicacion\r
+ y division).\r
+ El formato del archivo de texto debe ser de la siguiente manera:\r
+\r
+ * Se ingresan cada polinomio en lineas sucesivas.\r
+ * El primer polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto.\r
+ * El fin del primer polinomio (y comienzo del segundo) se indica por\r
+ medio de 1 o mas lineas en blanco.\r
+ * El segundo polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto a partir de dicha(s) linea(s) en blanco.\r
+ * Cada termino de un polinomio debe estar en la misma linea y comenzar\r
+ al principio de esta (excepto el primer termino).\r
+ * En cada linea se ingresa primero el coeficiente real (puede tener un\r
+ signo '-' al comenzar y/o un punto, y solamente uno) y luego el\r
+ exponente entero positivo.\r
+ * La separacion entre el coeficiente y el exponente debe estar dada por\r
+ uno o mas espacios o tabuladores.\r
+ * Cualquier caracter incluido en el texto que no sea un digito (0..9),\r
+ un punto ('.'), un signo menos ('-'), un espacio (' '), un tabulador\r
+ o alguno de los caracteres de nueva linea, dara un error en la\r
+ lectura.\r
+ * El archivo de texto debe tener formato DOS (es decir, el indicador de\r
+ nueva linea debe ser primero un caracter de retorno del carro\r
+ seguido inmediatamente por uno de avance de linea).\r
+}\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '1.2.5r (POLI_14)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Vector = array [0..TAM_MAX-1] of real; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio 'v' en pantalla con un titulo 's' }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ textcolor(lightcyan); { pone el color del texto en cian claro }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ textcolor(lightmagenta); { pone el color del texto en magenta claro }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (i = 0) and (v[i] = 0) then { si el primer exponente que encuentra es 0 y el coeficiente es 0, entonces }\r
+ begin { muestra el resultado como 0 y sale del procedimiento }\r
+ write('0'); { imprime que el resultado es cero }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ exit; { sale de este procedimiento }\r
+ end;\r
+ if (abs(v[i]) <> 1) or (i = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(v[i]):1, ' ') { imprime si es un numero entero }\r
+ else write(v[i]:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i] = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(i));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i] < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i]) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(abs(v[i])):1, ' ') { imprime si es un entero }\r
+ else write(abs(v[i]):1:2, ' '); { imprime si es un real }\r
+ write(exponente(i));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ v[i] := 0; { inicializa la variable actual en 0 }\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ clrscr; { borra la pantalla }\r
+ textcolor( Yellow ); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnVector' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ writeln(' Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ clrscr; { borra la pantalla }\r
+ textcolor( Yellow ); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnVector' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ write(' El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write(' (ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ cargarVectores := true; { en principio se establece que la lectura se hizo con exito ) }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ { este codigo es similar al de EXP_FIN, se hacen las asignaciones por el caso en que el fin\r
+ del archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 2\r
+ then v2[iExp] := rCoef { si es el 2do polinomio, asigna el valor correspondiente }\r
+ else cargarVectores := false { si es el primero, no se hizo bien la lectura }\r
+ else cargarVectores := false; { si no es menor, no se hizo bien la lectura }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] - v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division\r
+ devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
+ devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ if (j = 0) and (v2[j] = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
+ then { el polinomio 2 es nulo y no se puede efectuar la division }\r
+ begin { se devuelve false y se quedan los vectores resultado en 0 }\r
+ division := false; { devuelve false }\r
+ exit; { sale del procedimiento }\r
+ end;\r
+ while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j]; { almacena el resultado de la division entre los coeficientes en\r
+ la posicion de la resta de ambos }\r
+ vRTmp[i-j] := vr[i-j]; { almacena ese resultado en un polinomio temporal cuyo unico termio\r
+ no nulo es el del exponente i-j, para luego multiplicarlo }\r
+ producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
+ en otro temporal, para luego hacer la resta }\r
+ resta(v1, vTmp, v1); { resta al primer polinomio, v1, (en su estado actual, no el original)\r
+ el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
+ la misma forma }\r
+ vRTmp[i-j] := 0; { resetea el termino del temporal vRTmp que se asigno para los calculos }\r
+ for i := i downto 0 do { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
+ si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
+ division := true; { devuelve true indicando que se finalizo con exito }\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+ procedure mensajeSalida; { muestra un mensaje en la salida del programa }\r
+\r
+ begin\r
+ writeln; { linea en blanco }\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ clrscr; { borra la pantalla }\r
+ writeln; { linea en blanco }\r
+ textcolor(white); { cambia el color del texto }\r
+ writeln(' PolinomiosEnVector versi¢n ', VERSION); { mensaje con version del programa }\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ writeln(' Desarrollado por: Javier Grijalba'); { mensaje con los integrantes del grupo }\r
+ writeln(' Leandro Lucarella');\r
+ writeln(' Erasmo Troncovich');\r
+ writeln(' Diego Wojnicki');\r
+ writeln(' para la Facultad de Ingenier¡a de la Universidad de Buenos Aires.');\r
+ writeln(' Consultas y/o sugerencias a:');\r
+ writeln;\r
+ textcolor(LightMagenta); { cambia el color del texto }\r
+ write(' lluca@cnba.uba.ar');\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ write(' o ');\r
+ textcolor(LightMagenta); { cambia el color del texto }\r
+ writeln('grijalba@cvtci.com.ar');\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ writeln;\r
+ writeln(' (c) 1999 - Todos los derechos reservados.');\r
+ delay(750);\r
+ end;\r
+\r
+\r
+ {########################################################}\r
+\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
+ seguir, { indicador para saber si sigue corriendo el programa }\r
+ noNulo, { indicador para saber si en la division el divisor es nulo }\r
+ continua: boolean; { indicador para saber si se leyeron bien los polinomios }\r
+ tecla: char; { entrada de teclado del usuario para elegir una opcion }\r
+\r
+begin { programa principal }\r
+ textbackground( Blue ); { establece el color para el fondo a azul }\r
+ continua := cargarVectores(v1, v2); { carga los vectores del archivo de datos }\r
+ if continua then { si se leyeron bien ... }\r
+ begin\r
+ seguir := true; { inicializa la variable en true para que entre en el ciclo while }\r
+ while seguir do { mientras el usuario no salga del programa }\r
+ begin\r
+ clrscr; { borra la pantalla }\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnVector' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor(LightCyan); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ writeln( ' Elija que desea hacer:' ); { mensaje }\r
+ writeln( ' ----- --- ----- ------' ); { mensaje }\r
+ textcolor(LightGray); { establece el color para el texto a gris claro }\r
+ writeln; { mensaje con las opciones ... }\r
+ writeln;\r
+ writeln( ' 1.- Ver el polinomio 1.' );\r
+ writeln( ' 2.- Ver el polinomio 2.' );\r
+ writeln( ' 3.- Sumar los polinomios.' );\r
+ writeln( ' 4.- Restar el polinomio 2 al polinomio 1 (poli1 - poli2).' );\r
+ writeln( ' 5.- Restar el polinomio 1 al polinomio 2 (poli2 - poli1).' );\r
+ writeln( ' 6.- Multiplicar los polinomios.' );\r
+ writeln( ' 7.- Polinomio 1 dividido polinomio 2 (poli1 / poli2).' );\r
+ writeln( ' 8.- Polinomio 2 dividido polinomio 1 (poli2 / poli1).' );\r
+ writeln( ' 0.- Salir.' );\r
+ gotoxy(1, 23); { va a las coordenas de pantalla 1 horizontal, 23 verical }\r
+ textcolor(White ); { establece el color para el texto a blanco }\r
+ write(' Ingrese su opci¢n: ');\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ tecla := readkey; { lee una tecla del usuario indicando la opcion que elijio }\r
+ while ((tecla < '1') or (tecla > '8')) and (tecla <> '0') do { mientras sea una tecla no admitida }\r
+ begin\r
+ textcolor(White); { establece el color para el texto a blanco }\r
+ gotoxy( 1, 23 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ write(' Ingrese su opci¢n ("1" a "8" o "0"): ' );\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ tecla := readkey; { lee una tecla del usuario indicando la opcion que elijio }\r
+ end; { while }\r
+ if tecla = '0' then { si la opcion fue salir del programa ... }\r
+ begin\r
+ mensajeSalida; { presenta un mensaje de salida }\r
+ exit; { sale del programa }\r
+ end;\r
+ clrscr; { borra la pantalla }\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnVector' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor(LightCyan); { establece el color para el texto a cian claro }\r
+ gotoxy(1, 7); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ case tecla of\r
+ '1': muestraVector(v1, ' Polinomio 1 = ');\r
+ '2': muestraVector(v2, ' Polinomio 2 = ');\r
+ '3': begin\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 + Polinomio 2 = ');\r
+ end; { case 3 }\r
+ '4': begin\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 - Polinomio 2 = ');\r
+ end; { case 4 }\r
+ '5': begin\r
+ resta(v2, v1, vResult);\r
+ muestraVector(vResult, ' Polinomio 2 - Polinomio 1 = ');\r
+ end; { case 5 }\r
+ '6': begin\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 * Polinomio 2 = ');\r
+ end; { case 6 }\r
+ '7': begin\r
+ noNulo := division(v1, v2, vResult, vResto);\r
+ if noNulo\r
+ then\r
+ begin\r
+ muestraVector(vResult, ' Polinomio 1 / Polinomio 2 = ');\r
+ muestraVector(vResto, ' Resto = ');\r
+ end\r
+ else writeln(' El polinomio 2 es nulo, por lo tanto no se puede efectuar la division.');\r
+ end; { case 7 }\r
+ '8': begin\r
+ noNulo := division(v2, v1, vResult, vResto);\r
+ if noNulo\r
+ then\r
+ begin\r
+ muestraVector(vResult, 'Polinomio 2 / Polinomio 1 = ');\r
+ muestraVector(vResto, 'Resto = ');\r
+ end\r
+ else writeln(' El polinomio 1 es nulo, por lo tanto no se puede efectuar la division.');\r
+ end; { case 8 }\r
+ '0': ; { no hace nada, nunca deberia entrar en este case }\r
+ end; { case }\r
+ writeln; { los siguientes mensajes son para que el usuario pueda ver los datos y luego }\r
+ writeln; { presione una tecla para continuar }\r
+ textcolor(white); { pone el color del texto en blanco }\r
+ writeln(' Presione una tecla para continuar ...');\r
+ tecla := readkey;\r
+ end; { while }\r
+ end\r
+ else { si los vectores no se leyeron bien ... }\r
+ begin { presenta un mensaje de error }\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end. { programa principal }
\ No newline at end of file
--- /dev/null
+program PolinomiosEnVector;\r
+{ Programa que lee 2 polinomios desde un archivo de texto para luego\r
+ hacer operaciones basicas entre estos (suma, resta, multiplicacion\r
+ y division).\r
+ El formato del archivo de texto debe ser de la siguiente manera:\r
+\r
+ * Se ingresan cada polinomio en lineas sucesivas.\r
+ * El primer polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto.\r
+ * El fin del primer polinomio (y comienzo del segundo) se indica por\r
+ medio de 1 o mas lineas en blanco.\r
+ * El segundo polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto a partir de dicha(s) linea(s) en blanco.\r
+ * Cada termino de un polinomio debe estar en la misma linea y comenzar\r
+ al principio de esta (excepto el primer termino).\r
+ * En cada linea se ingresa primero el coeficiente real (puede tener un\r
+ signo '-' al comenzar y/o un punto, y solamente uno) y luego el\r
+ exponente entero positivo.\r
+ * La separacion entre el coeficiente y el exponente debe estar dada por\r
+ uno o mas espacios o tabuladores.\r
+ * Cualquier caracter incluido en el texto que no sea un degito (0..9),\r
+ un punto ('.'), un signo menos ('-'), un espacio (' '), un tabulador\r
+ o alguno de los caracteres de nueva linea, dara un error en la\r
+ lectura.\r
+ * El archivo de texto debe tener formato DOS (es decir, el indicador de\r
+ nueva linea debe ser primero un caracter de retorno del carro\r
+ seguido inmediatamente por uno de avance de linea).\r
+}\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '1.0.1r (POLI_10)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Vector = array [0..TAM_MAX-1] of real; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (i = 0) and (v[i] = 0) then { si el primer exponente que encuentra es 0 y el coeficiente es 0, entonces }\r
+ begin { muestra el resultado como 0 y sale del procedimiento }\r
+ write('0'); { imprime que el resultado es cero }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ exit; { sale de este procedimiento }\r
+ end;\r
+ if (abs(v[i]) <> 1) or (i = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(v[i]):1, ' ') { imprime si es un numero entero }\r
+ else write(v[i]:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i] = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(i));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i] < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i]) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(abs(v[i])):1, ' ') { imprime si es un entero }\r
+ else write(abs(v[i]):1:2, ' '); { imprime si es un real }\r
+ write(exponente(i));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ v[i] := 0; { inicializa la variable actual en 0 }\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ { este codigo es el mismo que el de EXP_FIN, se repite aca solo por si el final del\r
+ archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ { fin del codigo identico a EXP_FIN }\r
+ if poliN = 2 then cargarVectores := true { si se leyeron los 2 polinomios, devuelve true }\r
+ else cargarVectores := false; { si no se leyeron los dos, devuelve false }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] - v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division\r
+ devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
+ devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ if (j = 0) and (v2[j] = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
+ then { el polinomio 2 es nulo y no se puede efectuar la division }\r
+ begin { se devuelve false y se quedan los vectores resultado en 0 }\r
+ division := false; { devuelve false }\r
+ exit; { sale del procedimiento }\r
+ end;\r
+ while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j]; { almacena el resultado de la division entre los coeficientes en\r
+ la posicion de la resta de ambos }\r
+ vRTmp[i-j] := vr[i-j]; { almacena ese resultado en un polinomio temporal cuyo unico termio\r
+ no nulo es el del exponente i-j, para luego multiplicarlo }\r
+ producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
+ en otro temporal, para luego hacer la resta }\r
+ resta(v1, vTmp, v1); { resta al primer polinomio, v1, (en su estado actual, no el original)\r
+ el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
+ la misma forma }\r
+ vRTmp[i-j] := 0; { resetea el termino del temporal vRTmp que se asigno para los calculos }\r
+ for i := i downto 0 do { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
+ si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
+ division := true; { devuelve true indicando que se finalizo con exito }\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+{ Continuacion del programa principal }\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
+ continua: boolean; { valor para obtener los resultados de algunas funciones }\r
+\r
+begin { Comienzo del programa principal }\r
+ continua := cargarVectores(v1, v2);\r
+ if continua then\r
+ begin\r
+ muestraVector(v1, 'Polinomio 1 = ');\r
+ muestraVector(v2, 'Polinomio 2 = ');\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 + Polinomio 2 = ');\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 - Polinomio 2 = ');\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 * Polinomio 2 = ');\r
+ continua := division(v1, v2, vResult, vResto);\r
+ if continua\r
+ then\r
+ begin\r
+ muestraVector(vResult, 'Polinomio 1 / Polinomio 2 = ');\r
+ muestraVector(vResto, 'Resto = ');\r
+ end\r
+ else writeln('El segundo polinomio es nulo, por lo tanto no se puede efectuar la division');\r
+ end\r
+ else\r
+ begin\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end.
\ No newline at end of file
--- /dev/null
+program PolinomiosEnVector;\r
+{ Programa que lee 2 polinomios desde un archivo de texto para luego\r
+ hacer operaciones basicas entre estos (suma, resta, multiplicacion\r
+ y division).\r
+ El formato del archivo de texto debe ser de la siguiente manera:\r
+\r
+ * Se ingresan cada polinomio en lineas sucesivas.\r
+ * El primer polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto.\r
+ * El fin del primer polinomio (y comienzo del segundo) se indica por\r
+ medio de 1 o mas lineas en blanco.\r
+ * El segundo polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto a partir de dicha(s) linea(s) en blanco.\r
+ * Cada termino de un polinomio debe estar en la misma linea y comenzar\r
+ al principio de esta (excepto el primer termino).\r
+ * En cada linea se ingresa primero el coeficiente real (puede tener un\r
+ signo '-' al comenzar y/o un punto, y solamente uno) y luego el\r
+ exponente entero positivo.\r
+ * La separacion entre el coeficiente y el exponente debe estar dada por\r
+ uno o mas espacios o tabuladores.\r
+ * Cualquier caracter incluido en el texto que no sea un degito (0..9),\r
+ un punto ('.'), un signo menos ('-'), un espacio (' '), un tabulador\r
+ o alguno de los caracteres de nueva linea, dara un error en la\r
+ lectura.\r
+ * El archivo de texto debe tener formato DOS (es decir, el indicador de\r
+ nueva linea debe ser primero un caracter de retorno del carro\r
+ seguido inmediatamente por uno de avance de linea).\r
+}\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '1.0.5r (POLI_11)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Vector = array [0..TAM_MAX-1] of real; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (i = 0) and (v[i] = 0) then { si el primer exponente que encuentra es 0 y el coeficiente es 0, entonces }\r
+ begin { muestra el resultado como 0 y sale del procedimiento }\r
+ write('0'); { imprime que el resultado es cero }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ exit; { sale de este procedimiento }\r
+ end;\r
+ if (abs(v[i]) <> 1) or (i = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(v[i]):1, ' ') { imprime si es un numero entero }\r
+ else write(v[i]:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i] = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(i));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i] < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i]) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(abs(v[i])):1, ' ') { imprime si es un entero }\r
+ else write(abs(v[i]):1:2, ' '); { imprime si es un real }\r
+ write(exponente(i));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ v[i] := 0; { inicializa la variable actual en 0 }\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ cargarVectores := true; { en principio se establece que la lectura se hizo con exito ) }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ { este codigo es similar al de EXP_FIN, se hacen las asignaciones por el caso en que el fin\r
+ del archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 2\r
+ then v2[iExp] := rCoef { si es el 2do polinomio, asigna el valor correspondiente }\r
+ else cargarVectores := false { si es el primero, no se hizo bien la lectura }\r
+ else cargarVectores := false; { si no es menor, no se hizo bien la lectura }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] - v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division\r
+ devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
+ devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ if (j = 0) and (v2[j] = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
+ then { el polinomio 2 es nulo y no se puede efectuar la division }\r
+ begin { se devuelve false y se quedan los vectores resultado en 0 }\r
+ division := false; { devuelve false }\r
+ exit; { sale del procedimiento }\r
+ end;\r
+ while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j]; { almacena el resultado de la division entre los coeficientes en\r
+ la posicion de la resta de ambos }\r
+ vRTmp[i-j] := vr[i-j]; { almacena ese resultado en un polinomio temporal cuyo unico termio\r
+ no nulo es el del exponente i-j, para luego multiplicarlo }\r
+ producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
+ en otro temporal, para luego hacer la resta }\r
+ resta(v1, vTmp, v1); { resta al primer polinomio, v1, (en su estado actual, no el original)\r
+ el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
+ la misma forma }\r
+ vRTmp[i-j] := 0; { resetea el termino del temporal vRTmp que se asigno para los calculos }\r
+ for i := i downto 0 do { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
+ si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
+ division := true; { devuelve true indicando que se finalizo con exito }\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+{ Continuacion del programa principal }\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
+ continua: boolean; { valor para obtener los resultados de algunas funciones }\r
+\r
+begin { Comienzo del programa principal }\r
+ continua := cargarVectores(v1, v2);\r
+ if continua then\r
+ begin\r
+ muestraVector(v1, 'Polinomio 1 = ');\r
+ muestraVector(v2, 'Polinomio 2 = ');\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 + Polinomio 2 = ');\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 - Polinomio 2 = ');\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 * Polinomio 2 = ');\r
+ continua := division(v1, v2, vResult, vResto);\r
+ if continua\r
+ then\r
+ begin\r
+ muestraVector(vResult, 'Polinomio 1 / Polinomio 2 = ');\r
+ muestraVector(vResto, 'Resto = ');\r
+ end\r
+ else writeln('El segundo polinomio es nulo, por lo tanto no se puede efectuar la division');\r
+ end\r
+ else\r
+ begin\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end.
\ No newline at end of file
--- /dev/null
+program PolinomiosEnVector;\r
+{ Programa que lee 2 polinomios desde un archivo de texto para luego\r
+ hacer operaciones basicas entre estos (suma, resta, multiplicacion\r
+ y division).\r
+ El formato del archivo de texto debe ser de la siguiente manera:\r
+\r
+ * Se ingresan cada polinomio en lineas sucesivas.\r
+ * El primer polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto.\r
+ * El fin del primer polinomio (y comienzo del segundo) se indica por\r
+ medio de 1 o mas lineas en blanco.\r
+ * El segundo polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto a partir de dicha(s) linea(s) en blanco.\r
+ * Cada termino de un polinomio debe estar en la misma linea y comenzar\r
+ al principio de esta (excepto el primer termino).\r
+ * En cada linea se ingresa primero el coeficiente real (puede tener un\r
+ signo '-' al comenzar y/o un punto, y solamente uno) y luego el\r
+ exponente entero positivo.\r
+ * La separacion entre el coeficiente y el exponente debe estar dada por\r
+ uno o mas espacios o tabuladores.\r
+ * Cualquier caracter incluido en el texto que no sea un digito (0..9),\r
+ un punto ('.'), un signo menos ('-'), un espacio (' '), un tabulador\r
+ o alguno de los caracteres de nueva linea, dara un error en la\r
+ lectura.\r
+ * El archivo de texto debe tener formato DOS (es decir, el indicador de\r
+ nueva linea debe ser primero un caracter de retorno del carro\r
+ seguido inmediatamente por uno de avance de linea).\r
+}\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '1.1.3b (POLI_12)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Vector = array [0..TAM_MAX-1] of real; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio 'v' en pantalla con un titulo 's' }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ textcolor(lightcyan); { pone el color del texto en cian claro }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ textcolor(lightmagenta); { pone el color del texto en magenta claro }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (i = 0) and (v[i] = 0) then { si el primer exponente que encuentra es 0 y el coeficiente es 0, entonces }\r
+ begin { muestra el resultado como 0 y sale del procedimiento }\r
+ write('0'); { imprime que el resultado es cero }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ exit; { sale de este procedimiento }\r
+ end;\r
+ if (abs(v[i]) <> 1) or (i = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(v[i]):1, ' ') { imprime si es un numero entero }\r
+ else write(v[i]:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i] = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(i));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i] < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i]) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(abs(v[i])):1, ' ') { imprime si es un entero }\r
+ else write(abs(v[i]):1:2, ' '); { imprime si es un real }\r
+ write(exponente(i));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ v[i] := 0; { inicializa la variable actual en 0 }\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ clrscr; { borra la pantalla }\r
+ textcolor( Yellow ); { establece el color para el texto a amarillo }\r
+ gotoxy( 25, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'OPERACIONES ENTRE POLINOMIOS' ); { titulo }\r
+ gotoxy( 25, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ writeln(' Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ gotoxy( 5, 8 ); { va a las coordenas de pantalla 5 horizontal, 8 verical }\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ clrscr; { borra la pantalla }\r
+ textcolor( Yellow ); { establece el color para el texto a amarillo }\r
+ gotoxy( 25, 3 ); { va a las coordenas de pantalla 19 horizontal, 3 verical }\r
+ writeln( 'OPERACIONES ENTRE POLINOMIOS' ); { titulo }\r
+ gotoxy( 25, 4 ); { va a las coordenas de pantalla 19 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ write(' El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write(' (ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ gotoxy( 5, 9 ); { va a las coordenas de pantalla 5 horizontal, 9 verical }\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ cargarVectores := true; { en principio se establece que la lectura se hizo con exito ) }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ { este codigo es similar al de EXP_FIN, se hacen las asignaciones por el caso en que el fin\r
+ del archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 2\r
+ then v2[iExp] := rCoef { si es el 2do polinomio, asigna el valor correspondiente }\r
+ else cargarVectores := false { si es el primero, no se hizo bien la lectura }\r
+ else cargarVectores := false; { si no es menor, no se hizo bien la lectura }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] - v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division\r
+ devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
+ devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ if (j = 0) and (v2[j] = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
+ then { el polinomio 2 es nulo y no se puede efectuar la division }\r
+ begin { se devuelve false y se quedan los vectores resultado en 0 }\r
+ division := false; { devuelve false }\r
+ exit; { sale del procedimiento }\r
+ end;\r
+ while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j]; { almacena el resultado de la division entre los coeficientes en\r
+ la posicion de la resta de ambos }\r
+ vRTmp[i-j] := vr[i-j]; { almacena ese resultado en un polinomio temporal cuyo unico termio\r
+ no nulo es el del exponente i-j, para luego multiplicarlo }\r
+ producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
+ en otro temporal, para luego hacer la resta }\r
+ resta(v1, vTmp, v1); { resta al primer polinomio, v1, (en su estado actual, no el original)\r
+ el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
+ la misma forma }\r
+ vRTmp[i-j] := 0; { resetea el termino del temporal vRTmp que se asigno para los calculos }\r
+ for i := i downto 0 do { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
+ si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
+ division := true; { devuelve true indicando que se finalizo con exito }\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+ procedure mensajeSalida; { muestra un mensaje en la salida del programa }\r
+\r
+ begin\r
+ end;\r
+\r
+\r
+ {########################################################}\r
+\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
+ seguir, { indicador para saber si sigue corriendo el programa }\r
+ noNulo, { indicador para saber si en la division el divisor es nulo }\r
+ continua: boolean; { indicador para saber si se leyeron bien los polinomios }\r
+ tecla: char; { entrada de teclado del usuario para elegir una opcion }\r
+\r
+begin { programa principal }\r
+ textbackground( Blue ); { establece el color para el fondo a azul }\r
+ continua := cargarVectores(v1, v2); { carga los vectores del archivo de datos }\r
+ if continua then { si se leyeron bien ... }\r
+ begin\r
+ seguir := true; { inicializa la variable en true para que entre en el ciclo while }\r
+ while seguir do { mientras el usuario no salga del programa }\r
+ begin\r
+ clrscr; { borra la pantalla }\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ gotoxy( 25, 3 ); { va a las coordenas de pantalla 19 horizontal, 3 verical }\r
+ writeln( 'OPERACIONES ENTRE POLINOMIOS' ); { titulo }\r
+ gotoxy( 25, 4 ); { va a las coordenas de pantalla 19 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor(LightCyan); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ writeln( ' Elija que desea hacer:' ); { mensaje }\r
+ writeln( ' ----- --- ----- ------' ); { mensaje }\r
+ textcolor(LightGray); { establece el color para el texto a gris claro }\r
+ writeln; { mensaje con las opciones ... }\r
+ writeln;\r
+ writeln( ' 1.- Ver el polinomio 1.' );\r
+ writeln( ' 2.- Ver el polinomio 2.' );\r
+ writeln( ' 3.- Sumar los polinomios.' );\r
+ writeln( ' 4.- Restar el polinomio 2 al polinomio 1 (poli1 - poli2).' );\r
+ writeln( ' 5.- Restar el polinomio 1 al polinomio 2 (poli2 - poli1).' );\r
+ writeln( ' 6.- Multiplicar los polinomios.' );\r
+ writeln( ' 7.- Polinomio 1 dividido polinomio 2 (poli1 / poli2).' );\r
+ writeln( ' 8.- Polinomio 2 dividido polinomio 1 (poli2 / poli1).' );\r
+ writeln( ' 0.- Salir.' );\r
+ gotoxy(1, 23); { va a las coordenas de pantalla 1 horizontal, 23 verical }\r
+ textcolor(White ); { establece el color para el texto a blanco }\r
+ write(' Ingrese su opci¢n: ');\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ tecla := readkey; { lee una tecla del usuario indicando la opcion que elijio }\r
+ if tecla = '0' then { si la opcion fue salir del programa ... }\r
+ begin\r
+ mensajeSalida; { presenta un mensaje de salida }\r
+ exit; { sale del programa }\r
+ end;\r
+ while (tecla < '1') or (tecla > '8') do { mientras sea una tecla no admitida }\r
+ begin\r
+ textcolor(White); { establece el color para el texto a blanco }\r
+ gotoxy( 1, 23 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ write(' Ingrese su opci¢n ("1" a "8" o "0"): ' );\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ tecla := readkey; { lee una tecla del usuario indicando la opcion que elijio }\r
+ end; { while }\r
+ clrscr; { borra la pantalla }\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ gotoxy(19, 3); { va a las coordenas de pantalla 19 horizontal, 3 verical }\r
+ writeln( 'OPERACIONES ENTRE POLINOMIOS'); { titulo }\r
+ gotoxy(19, 4); { va a las coordenas de pantalla 19 horizontal, 4 verical }\r
+ writeln('~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~'); { subrayado del titulo }\r
+ textcolor(LightCyan); { establece el color para el texto a cian claro }\r
+ gotoxy(1, 7); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ case tecla of\r
+ '1': muestraVector(v1, ' Polinomio 1 = ');\r
+ '2': muestraVector(v2, ' Polinomio 2 = ');\r
+ '3': begin\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 + Polinomio 2 = ');\r
+ end; { case 3 }\r
+ '4': begin\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 - Polinomio 2 = ');\r
+ end; { case 4 }\r
+ '5': begin\r
+ resta(v2, v1, vResult);\r
+ muestraVector(vResult, ' Polinomio 2 - Polinomio 1 = ');\r
+ end; { case 5 }\r
+ '6': begin\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 * Polinomio 2 = ');\r
+ end; { case 6 }\r
+ '7': begin\r
+ noNulo := division(v1, v2, vResult, vResto);\r
+ if noNulo\r
+ then\r
+ begin\r
+ muestraVector(vResult, ' Polinomio 1 / Polinomio 2 = ');\r
+ muestraVector(vResto, ' Resto = ');\r
+ end\r
+ else writeln('El polinomio 2 es nulo, por lo tanto no se puede efectuar la division');\r
+ end; { case 7 }\r
+ '8': begin\r
+ noNulo := division(v2, v1, vResult, vResto);\r
+ if noNulo\r
+ then\r
+ begin\r
+ muestraVector(vResult, 'Polinomio 2 / Polinomio 1 = ');\r
+ muestraVector(vResto, 'Resto = ');\r
+ end\r
+ else writeln('El polinomio 1 es nulo, por lo tanto no se puede efectuar la division');\r
+ end; { case 8 }\r
+ '0': ; { no hace nada, nunca deberia entrar en este case }\r
+ end; { case }\r
+ writeln; { los siguientes mensajes son para que el usuario pueda ver los datos y luego }\r
+ writeln; { presione una tecla para continuar }\r
+ textcolor(white); { pone el color del texto en blanco }\r
+ writeln(' Presione una tecla para continuar ...');\r
+ tecla := readkey;\r
+ end; { while }\r
+ end\r
+ else { si los vectores no se leyeron bien ... }\r
+ begin { presenta un mensaje de error }\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end. { procedure menuGenerar }
\ No newline at end of file
--- /dev/null
+program PolinomiosEnVector;\r
+{ Programa que lee 2 polinomios desde un archivo de texto para luego\r
+ hacer operaciones basicas entre estos (suma, resta, multiplicacion\r
+ y division).\r
+ El formato del archivo de texto debe ser de la siguiente manera:\r
+\r
+ * Se ingresan cada polinomio en lineas sucesivas.\r
+ * El primer polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto.\r
+ * El fin del primer polinomio (y comienzo del segundo) se indica por\r
+ medio de 1 o mas lineas en blanco.\r
+ * El segundo polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto a partir de dicha(s) linea(s) en blanco.\r
+ * Cada termino de un polinomio debe estar en la misma linea y comenzar\r
+ al principio de esta (excepto el primer termino).\r
+ * En cada linea se ingresa primero el coeficiente real (puede tener un\r
+ signo '-' al comenzar y/o un punto, y solamente uno) y luego el\r
+ exponente entero positivo.\r
+ * La separacion entre el coeficiente y el exponente debe estar dada por\r
+ uno o mas espacios o tabuladores.\r
+ * Cualquier caracter incluido en el texto que no sea un digito (0..9),\r
+ un punto ('.'), un signo menos ('-'), un espacio (' '), un tabulador\r
+ o alguno de los caracteres de nueva linea, dara un error en la\r
+ lectura.\r
+ * El archivo de texto debe tener formato DOS (es decir, el indicador de\r
+ nueva linea debe ser primero un caracter de retorno del carro\r
+ seguido inmediatamente por uno de avance de linea).\r
+}\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '1.2.3r (POLI_13)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Vector = array [0..TAM_MAX-1] of real; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio 'v' en pantalla con un titulo 's' }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ textcolor(lightcyan); { pone el color del texto en cian claro }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ textcolor(lightmagenta); { pone el color del texto en magenta claro }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (i = 0) and (v[i] = 0) then { si el primer exponente que encuentra es 0 y el coeficiente es 0, entonces }\r
+ begin { muestra el resultado como 0 y sale del procedimiento }\r
+ write('0'); { imprime que el resultado es cero }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ exit; { sale de este procedimiento }\r
+ end;\r
+ if (abs(v[i]) <> 1) or (i = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(v[i]):1, ' ') { imprime si es un numero entero }\r
+ else write(v[i]:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i] = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(i));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i] < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i]) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(abs(v[i])):1, ' ') { imprime si es un entero }\r
+ else write(abs(v[i]):1:2, ' '); { imprime si es un real }\r
+ write(exponente(i));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ v[i] := 0; { inicializa la variable actual en 0 }\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ clrscr; { borra la pantalla }\r
+ textcolor( Yellow ); { establece el color para el texto a amarillo }\r
+ gotoxy( 25, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'OPERACIONES ENTRE POLINOMIOS' ); { titulo }\r
+ gotoxy( 25, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ writeln(' Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ clrscr; { borra la pantalla }\r
+ textcolor( Yellow ); { establece el color para el texto a amarillo }\r
+ gotoxy( 25, 3 ); { va a las coordenas de pantalla 19 horizontal, 3 verical }\r
+ writeln( 'OPERACIONES ENTRE POLINOMIOS' ); { titulo }\r
+ gotoxy( 25, 4 ); { va a las coordenas de pantalla 19 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ write(' El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write(' (ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ cargarVectores := true; { en principio se establece que la lectura se hizo con exito ) }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ { este codigo es similar al de EXP_FIN, se hacen las asignaciones por el caso en que el fin\r
+ del archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 2\r
+ then v2[iExp] := rCoef { si es el 2do polinomio, asigna el valor correspondiente }\r
+ else cargarVectores := false { si es el primero, no se hizo bien la lectura }\r
+ else cargarVectores := false; { si no es menor, no se hizo bien la lectura }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] - v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division\r
+ devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
+ devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ if (j = 0) and (v2[j] = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
+ then { el polinomio 2 es nulo y no se puede efectuar la division }\r
+ begin { se devuelve false y se quedan los vectores resultado en 0 }\r
+ division := false; { devuelve false }\r
+ exit; { sale del procedimiento }\r
+ end;\r
+ while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j]; { almacena el resultado de la division entre los coeficientes en\r
+ la posicion de la resta de ambos }\r
+ vRTmp[i-j] := vr[i-j]; { almacena ese resultado en un polinomio temporal cuyo unico termio\r
+ no nulo es el del exponente i-j, para luego multiplicarlo }\r
+ producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
+ en otro temporal, para luego hacer la resta }\r
+ resta(v1, vTmp, v1); { resta al primer polinomio, v1, (en su estado actual, no el original)\r
+ el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
+ la misma forma }\r
+ vRTmp[i-j] := 0; { resetea el termino del temporal vRTmp que se asigno para los calculos }\r
+ for i := i downto 0 do { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
+ si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
+ division := true; { devuelve true indicando que se finalizo con exito }\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+ procedure mensajeSalida; { muestra un mensaje en la salida del programa }\r
+\r
+ begin\r
+ writeln; { linea en blanco }\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ clrscr; { borra la pantalla }\r
+ writeln; { linea en blanco }\r
+ textcolor(white); { cambia el color del texto }\r
+ writeln(' OPERACIONES ENTRE POLINOMIOS versi¢n ', VERSION); { mensaje con version del programa }\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ writeln(' Desarrollado por: JavierGrijalba'); { mensaje con los integrantes del grupo }\r
+ writeln(' Leandro Lucarella');\r
+ writeln(' Erasmo Troncovich');\r
+ writeln(' Diego Wojmicki');\r
+ writeln(' para la Facultad de Ingenier¡a de la Universidad de Buenos Aires.');\r
+ writeln(' Consultas y/o sugerencias a:');\r
+ writeln;\r
+ textcolor(LightMagenta); { cambia el color del texto }\r
+ write(' lluca@cnba.uba.ar');\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ write(' o ');\r
+ textcolor(LightMagenta); { cambia el color del texto }\r
+ writeln('grijalba@cvtci.com.ar');\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ writeln;\r
+ writeln(' (c) 1999 - Todos los derechos reservados.');\r
+ delay(750);\r
+ end;\r
+\r
+\r
+ {########################################################}\r
+\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
+ seguir, { indicador para saber si sigue corriendo el programa }\r
+ noNulo, { indicador para saber si en la division el divisor es nulo }\r
+ continua: boolean; { indicador para saber si se leyeron bien los polinomios }\r
+ tecla: char; { entrada de teclado del usuario para elegir una opcion }\r
+\r
+begin { programa principal }\r
+ textbackground( Blue ); { establece el color para el fondo a azul }\r
+ continua := cargarVectores(v1, v2); { carga los vectores del archivo de datos }\r
+ if continua then { si se leyeron bien ... }\r
+ begin\r
+ seguir := true; { inicializa la variable en true para que entre en el ciclo while }\r
+ while seguir do { mientras el usuario no salga del programa }\r
+ begin\r
+ clrscr; { borra la pantalla }\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ gotoxy( 25, 3 ); { va a las coordenas de pantalla 19 horizontal, 3 verical }\r
+ writeln( 'OPERACIONES ENTRE POLINOMIOS' ); { titulo }\r
+ gotoxy( 25, 4 ); { va a las coordenas de pantalla 19 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor(LightCyan); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ writeln( ' Elija que desea hacer:' ); { mensaje }\r
+ writeln( ' ----- --- ----- ------' ); { mensaje }\r
+ textcolor(LightGray); { establece el color para el texto a gris claro }\r
+ writeln; { mensaje con las opciones ... }\r
+ writeln;\r
+ writeln( ' 1.- Ver el polinomio 1.' );\r
+ writeln( ' 2.- Ver el polinomio 2.' );\r
+ writeln( ' 3.- Sumar los polinomios.' );\r
+ writeln( ' 4.- Restar el polinomio 2 al polinomio 1 (poli1 - poli2).' );\r
+ writeln( ' 5.- Restar el polinomio 1 al polinomio 2 (poli2 - poli1).' );\r
+ writeln( ' 6.- Multiplicar los polinomios.' );\r
+ writeln( ' 7.- Polinomio 1 dividido polinomio 2 (poli1 / poli2).' );\r
+ writeln( ' 8.- Polinomio 2 dividido polinomio 1 (poli2 / poli1).' );\r
+ writeln( ' 0.- Salir.' );\r
+ gotoxy(1, 23); { va a las coordenas de pantalla 1 horizontal, 23 verical }\r
+ textcolor(White ); { establece el color para el texto a blanco }\r
+ write(' Ingrese su opci¢n: ');\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ tecla := readkey; { lee una tecla del usuario indicando la opcion que elijio }\r
+ while ((tecla < '1') or (tecla > '8')) and (tecla <> '0') do { mientras sea una tecla no admitida }\r
+ begin\r
+ textcolor(White); { establece el color para el texto a blanco }\r
+ gotoxy( 1, 23 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ write(' Ingrese su opci¢n ("1" a "8" o "0"): ' );\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ tecla := readkey; { lee una tecla del usuario indicando la opcion que elijio }\r
+ end; { while }\r
+ if tecla = '0' then { si la opcion fue salir del programa ... }\r
+ begin\r
+ mensajeSalida; { presenta un mensaje de salida }\r
+ exit; { sale del programa }\r
+ end;\r
+ clrscr; { borra la pantalla }\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ gotoxy(19, 3); { va a las coordenas de pantalla 19 horizontal, 3 verical }\r
+ writeln( 'OPERACIONES ENTRE POLINOMIOS'); { titulo }\r
+ gotoxy(19, 4); { va a las coordenas de pantalla 19 horizontal, 4 verical }\r
+ writeln('~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~'); { subrayado del titulo }\r
+ textcolor(LightCyan); { establece el color para el texto a cian claro }\r
+ gotoxy(1, 7); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ case tecla of\r
+ '1': muestraVector(v1, ' Polinomio 1 = ');\r
+ '2': muestraVector(v2, ' Polinomio 2 = ');\r
+ '3': begin\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 + Polinomio 2 = ');\r
+ end; { case 3 }\r
+ '4': begin\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 - Polinomio 2 = ');\r
+ end; { case 4 }\r
+ '5': begin\r
+ resta(v2, v1, vResult);\r
+ muestraVector(vResult, ' Polinomio 2 - Polinomio 1 = ');\r
+ end; { case 5 }\r
+ '6': begin\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 * Polinomio 2 = ');\r
+ end; { case 6 }\r
+ '7': begin\r
+ noNulo := division(v1, v2, vResult, vResto);\r
+ if noNulo\r
+ then\r
+ begin\r
+ muestraVector(vResult, ' Polinomio 1 / Polinomio 2 = ');\r
+ muestraVector(vResto, ' Resto = ');\r
+ end\r
+ else writeln(' El polinomio 2 es nulo, por lo tanto no se puede efectuar la division.');\r
+ end; { case 7 }\r
+ '8': begin\r
+ noNulo := division(v2, v1, vResult, vResto);\r
+ if noNulo\r
+ then\r
+ begin\r
+ muestraVector(vResult, 'Polinomio 2 / Polinomio 1 = ');\r
+ muestraVector(vResto, 'Resto = ');\r
+ end\r
+ else writeln(' El polinomio 1 es nulo, por lo tanto no se puede efectuar la division.');\r
+ end; { case 8 }\r
+ '0': ; { no hace nada, nunca deberia entrar en este case }\r
+ end; { case }\r
+ writeln; { los siguientes mensajes son para que el usuario pueda ver los datos y luego }\r
+ writeln; { presione una tecla para continuar }\r
+ textcolor(white); { pone el color del texto en blanco }\r
+ writeln(' Presione una tecla para continuar ...');\r
+ tecla := readkey;\r
+ end; { while }\r
+ end\r
+ else { si los vectores no se leyeron bien ... }\r
+ begin { presenta un mensaje de error }\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end. { procedure menuGenerar }
\ No newline at end of file
--- /dev/null
+program PolinomiosEnVector;\r
+{ Programa que lee 2 polinomios desde un archivo de texto para luego\r
+ hacer operaciones basicas entre estos (suma, resta, multiplicacion\r
+ y division).\r
+ El formato del archivo de texto debe ser de la siguiente manera:\r
+\r
+ * Se ingresan cada polinomio en lineas sucesivas.\r
+ * El primer polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto.\r
+ * El fin del primer polinomio (y comienzo del segundo) se indica por\r
+ medio de 1 o mas lineas en blanco.\r
+ * El segundo polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto a partir de dicha(s) linea(s) en blanco.\r
+ * Cada termino de un polinomio debe estar en la misma linea y comenzar\r
+ al principio de esta (excepto el primer termino).\r
+ * En cada linea se ingresa primero el coeficiente real (puede tener un\r
+ signo '-' al comenzar y/o un punto, y solamente uno) y luego el\r
+ exponente entero positivo.\r
+ * La separacion entre el coeficiente y el exponente debe estar dada por\r
+ uno o mas espacios o tabuladores.\r
+ * Cualquier caracter incluido en el texto que no sea un digito (0..9),\r
+ un punto ('.'), un signo menos ('-'), un espacio (' '), un tabulador\r
+ o alguno de los caracteres de nueva linea, dara un error en la\r
+ lectura.\r
+ * El archivo de texto debe tener formato DOS (es decir, el indicador de\r
+ nueva linea debe ser primero un caracter de retorno del carro\r
+ seguido inmediatamente por uno de avance de linea).\r
+}\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '1.2.5r (POLI_14)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Vector = array [0..TAM_MAX-1] of real; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio 'v' en pantalla con un titulo 's' }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ textcolor(lightcyan); { pone el color del texto en cian claro }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ textcolor(lightmagenta); { pone el color del texto en magenta claro }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (i = 0) and (v[i] = 0) then { si el primer exponente que encuentra es 0 y el coeficiente es 0, entonces }\r
+ begin { muestra el resultado como 0 y sale del procedimiento }\r
+ write('0'); { imprime que el resultado es cero }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ exit; { sale de este procedimiento }\r
+ end;\r
+ if (abs(v[i]) <> 1) or (i = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(v[i]):1, ' ') { imprime si es un numero entero }\r
+ else write(v[i]:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i] = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(i));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i] < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i]) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(abs(v[i])):1, ' ') { imprime si es un entero }\r
+ else write(abs(v[i]):1:2, ' '); { imprime si es un real }\r
+ write(exponente(i));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ v[i] := 0; { inicializa la variable actual en 0 }\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ clrscr; { borra la pantalla }\r
+ textcolor( Yellow ); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnVector' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ writeln(' Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ clrscr; { borra la pantalla }\r
+ textcolor( Yellow ); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnVector' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ write(' El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write(' (ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ cargarVectores := true; { en principio se establece que la lectura se hizo con exito ) }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ { este codigo es similar al de EXP_FIN, se hacen las asignaciones por el caso en que el fin\r
+ del archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 2\r
+ then v2[iExp] := rCoef { si es el 2do polinomio, asigna el valor correspondiente }\r
+ else cargarVectores := false { si es el primero, no se hizo bien la lectura }\r
+ else cargarVectores := false; { si no es menor, no se hizo bien la lectura }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] - v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division\r
+ devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
+ devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ if (j = 0) and (v2[j] = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
+ then { el polinomio 2 es nulo y no se puede efectuar la division }\r
+ begin { se devuelve false y se quedan los vectores resultado en 0 }\r
+ division := false; { devuelve false }\r
+ exit; { sale del procedimiento }\r
+ end;\r
+ while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j]; { almacena el resultado de la division entre los coeficientes en\r
+ la posicion de la resta de ambos }\r
+ vRTmp[i-j] := vr[i-j]; { almacena ese resultado en un polinomio temporal cuyo unico termio\r
+ no nulo es el del exponente i-j, para luego multiplicarlo }\r
+ producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
+ en otro temporal, para luego hacer la resta }\r
+ resta(v1, vTmp, v1); { resta al primer polinomio, v1, (en su estado actual, no el original)\r
+ el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
+ la misma forma }\r
+ vRTmp[i-j] := 0; { resetea el termino del temporal vRTmp que se asigno para los calculos }\r
+ for i := i downto 0 do { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
+ si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
+ division := true; { devuelve true indicando que se finalizo con exito }\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+ procedure mensajeSalida; { muestra un mensaje en la salida del programa }\r
+\r
+ begin\r
+ writeln; { linea en blanco }\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ clrscr; { borra la pantalla }\r
+ writeln; { linea en blanco }\r
+ textcolor(white); { cambia el color del texto }\r
+ writeln(' PolinomiosEnVector versi¢n ', VERSION); { mensaje con version del programa }\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ writeln(' Desarrollado por: JavierGrijalba'); { mensaje con los integrantes del grupo }\r
+ writeln(' Leandro Lucarella');\r
+ writeln(' Erasmo Troncovich');\r
+ writeln(' Diego Wojmicki');\r
+ writeln(' para la Facultad de Ingenier¡a de la Universidad de Buenos Aires.');\r
+ writeln(' Consultas y/o sugerencias a:');\r
+ writeln;\r
+ textcolor(LightMagenta); { cambia el color del texto }\r
+ write(' lluca@cnba.uba.ar');\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ write(' o ');\r
+ textcolor(LightMagenta); { cambia el color del texto }\r
+ writeln('grijalba@cvtci.com.ar');\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ writeln;\r
+ writeln(' (c) 1999 - Todos los derechos reservados.');\r
+ delay(750);\r
+ end;\r
+\r
+\r
+ {########################################################}\r
+\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
+ seguir, { indicador para saber si sigue corriendo el programa }\r
+ noNulo, { indicador para saber si en la division el divisor es nulo }\r
+ continua: boolean; { indicador para saber si se leyeron bien los polinomios }\r
+ tecla: char; { entrada de teclado del usuario para elegir una opcion }\r
+\r
+begin { programa principal }\r
+ textbackground( Blue ); { establece el color para el fondo a azul }\r
+ continua := cargarVectores(v1, v2); { carga los vectores del archivo de datos }\r
+ if continua then { si se leyeron bien ... }\r
+ begin\r
+ seguir := true; { inicializa la variable en true para que entre en el ciclo while }\r
+ while seguir do { mientras el usuario no salga del programa }\r
+ begin\r
+ clrscr; { borra la pantalla }\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnVector' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor(LightCyan); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ writeln( ' Elija que desea hacer:' ); { mensaje }\r
+ writeln( ' ----- --- ----- ------' ); { mensaje }\r
+ textcolor(LightGray); { establece el color para el texto a gris claro }\r
+ writeln; { mensaje con las opciones ... }\r
+ writeln;\r
+ writeln( ' 1.- Ver el polinomio 1.' );\r
+ writeln( ' 2.- Ver el polinomio 2.' );\r
+ writeln( ' 3.- Sumar los polinomios.' );\r
+ writeln( ' 4.- Restar el polinomio 2 al polinomio 1 (poli1 - poli2).' );\r
+ writeln( ' 5.- Restar el polinomio 1 al polinomio 2 (poli2 - poli1).' );\r
+ writeln( ' 6.- Multiplicar los polinomios.' );\r
+ writeln( ' 7.- Polinomio 1 dividido polinomio 2 (poli1 / poli2).' );\r
+ writeln( ' 8.- Polinomio 2 dividido polinomio 1 (poli2 / poli1).' );\r
+ writeln( ' 0.- Salir.' );\r
+ gotoxy(1, 23); { va a las coordenas de pantalla 1 horizontal, 23 verical }\r
+ textcolor(White ); { establece el color para el texto a blanco }\r
+ write(' Ingrese su opci¢n: ');\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ tecla := readkey; { lee una tecla del usuario indicando la opcion que elijio }\r
+ while ((tecla < '1') or (tecla > '8')) and (tecla <> '0') do { mientras sea una tecla no admitida }\r
+ begin\r
+ textcolor(White); { establece el color para el texto a blanco }\r
+ gotoxy( 1, 23 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ write(' Ingrese su opci¢n ("1" a "8" o "0"): ' );\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ tecla := readkey; { lee una tecla del usuario indicando la opcion que elijio }\r
+ end; { while }\r
+ if tecla = '0' then { si la opcion fue salir del programa ... }\r
+ begin\r
+ mensajeSalida; { presenta un mensaje de salida }\r
+ exit; { sale del programa }\r
+ end;\r
+ clrscr; { borra la pantalla }\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnVector' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor(LightCyan); { establece el color para el texto a cian claro }\r
+ gotoxy(1, 7); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ case tecla of\r
+ '1': muestraVector(v1, ' Polinomio 1 = ');\r
+ '2': muestraVector(v2, ' Polinomio 2 = ');\r
+ '3': begin\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 + Polinomio 2 = ');\r
+ end; { case 3 }\r
+ '4': begin\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 - Polinomio 2 = ');\r
+ end; { case 4 }\r
+ '5': begin\r
+ resta(v2, v1, vResult);\r
+ muestraVector(vResult, ' Polinomio 2 - Polinomio 1 = ');\r
+ end; { case 5 }\r
+ '6': begin\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 * Polinomio 2 = ');\r
+ end; { case 6 }\r
+ '7': begin\r
+ noNulo := division(v1, v2, vResult, vResto);\r
+ if noNulo\r
+ then\r
+ begin\r
+ muestraVector(vResult, ' Polinomio 1 / Polinomio 2 = ');\r
+ muestraVector(vResto, ' Resto = ');\r
+ end\r
+ else writeln(' El polinomio 2 es nulo, por lo tanto no se puede efectuar la division.');\r
+ end; { case 7 }\r
+ '8': begin\r
+ noNulo := division(v2, v1, vResult, vResto);\r
+ if noNulo\r
+ then\r
+ begin\r
+ muestraVector(vResult, 'Polinomio 2 / Polinomio 1 = ');\r
+ muestraVector(vResto, 'Resto = ');\r
+ end\r
+ else writeln(' El polinomio 1 es nulo, por lo tanto no se puede efectuar la division.');\r
+ end; { case 8 }\r
+ '0': ; { no hace nada, nunca deberia entrar en este case }\r
+ end; { case }\r
+ writeln; { los siguientes mensajes son para que el usuario pueda ver los datos y luego }\r
+ writeln; { presione una tecla para continuar }\r
+ textcolor(white); { pone el color del texto en blanco }\r
+ writeln(' Presione una tecla para continuar ...');\r
+ tecla := readkey;\r
+ end; { while }\r
+ end\r
+ else { si los vectores no se leyeron bien ... }\r
+ begin { presenta un mensaje de error }\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end. { procedure menuGenerar }
\ No newline at end of file
--- /dev/null
+program Polinomios;\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '0.6.0a (POLI_2)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ { Tipo de dato para identificar el estado de la entrada\r
+ de datos }\r
+ VectorResultado = array [0..TAM_MAX-1] of real; { vector para almacenar\r
+ el polinomio resultado }\r
+ Vector = array [0..TAM-1] of real; { vector para almacenar los polinomios }\r
+ Termino = record { tipo de dato que representa un termino de un poinomio }\r
+ coef: real; { coeficiente del termino }\r
+ exp: integer; { exponente de lavariable del polinomio }\r
+ end; { fin del tipo de dato }\r
+\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin\r
+ { mensaje para entrada del nombre de archivo }\r
+ writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+{DEBUG var l: Text; {}\r
+\r
+ begin\r
+{DEBUG assign(l, 'log.txt'); {}\r
+{DEBUG append(l); {}\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+{DEBUG begin {}\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+{DEBUG writeln(l, ' --> trans: COEF_BUSCA: c: ', ord(c)); {}\r
+{DEBUG end; {}\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+{DEBUG begin {}\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+{DEBUG writeln(l, ' --> trans: COEF: c: ', ord(c)); {}\r
+{DEBUG end; {}\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+{DEBUG begin {}\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+{DEBUG writeln(l, ' --> trans: COEF_PUNTO: c: ', ord(c)); {}\r
+{DEBUG end; {}\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+{DEBUG begin {}\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+{DEBUG writeln(l, ' --> trans: COEF_FIN: c: ', ord(c)); {}\r
+{DEBUG end; {}\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+{DEBUG begin {}\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+{DEBUG writeln(l, ' --> trans: EXP_BUSCA: c: ', ord(c)); {}\r
+{DEBUG end; {}\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+{DEBUG begin {}\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+{DEBUG writeln(l, ' --> trans: EXP: c: ', ord(c)); {}\r
+{DEBUG end; {}\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+{DEBUG begin {}\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+{DEBUG writeln(l, ' --> trans: EXP_FIN: c: ', ord(c)); {}\r
+{DEBUG end; {}\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+{DEBUG begin {}\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+{DEBUG writeln(l, ' --> trans: EXP_FIN_BUSCA: c: ', ord(c)); {}\r
+{DEBUG end; {}\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+{DEBUG begin {}\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+{DEBUG writeln(l, ' --> trans: POLI_FIN: c: ', ord(c)); {}\r
+{DEBUG end; {}\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+{DEBUG close(l); {}\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ for i := 0 to TAM - 1 do { iteracion para inicializar los vectores a cero }\r
+ begin { para que los valores que no son especificados no contengan "basura" }\r
+ v1[i] := 0; { inicializacion del vector 1 (primer polinomio) }\r
+ v2[i] := 0; { inicializacion del vector 2 (segundo polinomio) }\r
+ end;\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+{DEBUG nombreArchivo := 'datos.txt'; {}\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+{DEBUG writeln(' --> cargarVectores: EXP_FIN'); {}\r
+{DEBUG writeln(' v[', iExp,'] = ', rCoef:1:1); {}\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ { este codigo es el mismo que el de EXP_FIN, se repite aca solo por si el final del\r
+ archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+{DEBUG writeln(' --> cargarVectores: FIN'); {}\r
+{DEBUG writeln(' v[', iExp,'] = ', rCoef:1:1);}\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ { fin del codigo identico a EXP_FIN }\r
+ if poliN = 2 then cargarVectores := true { si se leyeron los 2 polinomios, devuelve true }\r
+ else cargarVectores := false; { si no se leyeron los dos, devuelve false }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+{DEBUG writeln(' --> cargarVectores: EN CICLO WHILE PRINCIPAL'); {}\r
+{DEBUG writeln(' c: ',ord(c),' | est: ',ord(est),' | poliN: ',poliN,' | coeficiente: ', {}\r
+{DEBUG coeficiente,' | exponente: ',exponente); {}\r
+ end; { while }\r
+{DEBUG writeln(' --> cargarVectores: SALIDA'); {}\r
+{DEBUG writeln(' c: ',ord(c),' | est: ',ord(est),' | poliN: ',poliN,' | coeficiente: ', {}\r
+{DEBUG coeficiente,' | exponente: ',exponente); {}\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+{ Continuacion del programa principal }\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2: vector;\r
+ resultado: boolean;\r
+\r
+begin { Comienzo del programa principal }\r
+ resultado := cargarVectores(v1, v2);\r
+ {if not resultado then exit;}\r
+ writeln('Polinomio 1:');\r
+ for i := TAM - 1 downto 0 do\r
+ if v1[i] <> 0 then\r
+ begin\r
+ if v1[i] < 0 then write(' - ', abs(v1[i]):1:2)\r
+ else write(' + ', v1[i]:1:2);\r
+ if i <> 0 then write('*X^', i);\r
+ end;\r
+ writeln;\r
+ writeln('Polinomio 2:');\r
+ for i := TAM - 1 downto 0 do\r
+ if v2[i] <> 0 then\r
+ begin\r
+ if v2[i] < 0 then write(' - ', abs(v2[i]):1:2)\r
+ else write(' + ', v2[i]:1:2);\r
+ if i <> 0 then write('*X^', i);\r
+ end;\r
+ writeln;\r
+ writeln(ord(resultado));\r
+end.
\ No newline at end of file
--- /dev/null
+program Polinomios;\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '0.7.0a (POLI_3)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Vector = array [0..TAM_MAX-1] of real; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector; t: integer);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to t - 1 do { recorre el vector }\r
+ v[i] := 0; { inicializa la variable actual en 0 }\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ for i := 0 to TAM - 1 do { iteracion para inicializar los vectores a cero }\r
+ begin { para que los valores que no son especificados no contengan "basura" }\r
+ v1[i] := 0; { inicializacion del vector 1 (primer polinomio) }\r
+ v2[i] := 0; { inicializacion del vector 2 (segundo polinomio) }\r
+ end;\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ { este codigo es el mismo que el de EXP_FIN, se repite aca solo por si el final del\r
+ archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ { fin del codigo identico a EXP_FIN }\r
+ if poliN = 2 then cargarVectores := true { si se leyeron los 2 polinomios, devuelve true }\r
+ else cargarVectores := false; { si no se leyeron los dos, devuelve false }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for i := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ procedure division(v1, v2: Vector; var vr, vResto: Vector);\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division }\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 donwto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 donwto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ while i >= j do\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j];\r
+ vRTmp[i-j] := vr[i-j];\r
+ producto(vRTmp, v2, vTmp);\r
+ resta(v1, vTmp, v1);\r
+ vRTmp[i-j] := 0;\r
+ for i := i downto 0 do\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1;\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+{ Continuacion del programa principal }\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector;\r
+ resultado: boolean;\r
+\r
+begin { Comienzo del programa principal }\r
+ resultado := cargarVectores(v1, v2);\r
+ {if not resultado then exit;}\r
+ writeln('Polinomio 1:');\r
+ for i := TAM - 1 downto 0 do\r
+ if v1[i] <> 0 then\r
+ begin\r
+ if v1[i] < 0 then write(' - ', abs(v1[i]):1:2)\r
+ else write(' + ', v1[i]:1:2);\r
+ if i <> 0 then write('*X^', i);\r
+ end;\r
+ writeln;\r
+ writeln('Polinomio 2:');\r
+ for i := TAM - 1 downto 0 do\r
+ if v2[i] <> 0 then\r
+ begin\r
+ if v2[i] < 0 then write(' - ', abs(v2[i]):1:2)\r
+ else write(' + ', v2[i]:1:2);\r
+ if i <> 0 then write('*X^', i);\r
+ end;\r
+ writeln;\r
+ writeln(ord(resultado));\r
+end.
\ No newline at end of file
--- /dev/null
+program Polinomios;\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '0.8.0a (POLI_4)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Vector = array [0..TAM_MAX-1] of real; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ v[i] := 0; { inicializa la variable actual en 0 }\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ { este codigo es el mismo que el de EXP_FIN, se repite aca solo por si el final del\r
+ archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ { fin del codigo identico a EXP_FIN }\r
+ if poliN = 2 then cargarVectores := true { si se leyeron los 2 polinomios, devuelve true }\r
+ else cargarVectores := false; { si no se leyeron los dos, devuelve false }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for i := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ procedure division(v1, v2: Vector; var vr, vResto: Vector);\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division }\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ while i >= j do\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j];\r
+ vRTmp[i-j] := vr[i-j];\r
+ producto(vRTmp, v2, vTmp);\r
+ resta(v1, vTmp, v1);\r
+ vRTmp[i-j] := 0;\r
+ for i := i downto 0 do\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1;\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+{ Continuacion del programa principal }\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector;\r
+ resultado: boolean;\r
+\r
+begin { Comienzo del programa principal }\r
+ resultado := cargarVectores(v1, v2);\r
+ {if not resultado then exit;}\r
+ writeln('Polinomio 1:');\r
+ for i := TAM - 1 downto 0 do\r
+ if v1[i] <> 0 then\r
+ begin\r
+ if v1[i] < 0 then write(' - ', abs(v1[i]):1:2)\r
+ else write(' + ', v1[i]:1:2);\r
+ if i <> 0 then write('*X^', i);\r
+ end;\r
+ writeln;\r
+ writeln('Polinomio 2:');\r
+ for i := TAM - 1 downto 0 do\r
+ if v2[i] <> 0 then\r
+ begin\r
+ if v2[i] < 0 then write(' - ', abs(v2[i]):1:2)\r
+ else write(' + ', v2[i]:1:2);\r
+ if i <> 0 then write('*X^', i);\r
+ end;\r
+ writeln;\r
+ writeln(ord(resultado));\r
+end.
\ No newline at end of file
--- /dev/null
+program Polinomios;\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '0.8.2a (POLI_5)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Vector = array [0..TAM_MAX-1] of real; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ writeln(s); { mustra el mensaje }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then { si el coeficiente no es nulo, muestra ... }\r
+ begin\r
+ if v[i] < 0 then write(' - ', abs(v[i]):1:2) { si el coeficiente en negativo }\r
+ else write(' + ', v[i]:1:2); { si el coeficiente en positivo }\r
+ case i of\r
+ 0: ; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: write(' X'); { si el exponente es 1, mustra el coeficiente y X }\r
+ else write(' X^', i); { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { case }\r
+ end; { if }\r
+ writeln;\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ v[i] := 0; { inicializa la variable actual en 0 }\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ { este codigo es el mismo que el de EXP_FIN, se repite aca solo por si el final del\r
+ archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ { fin del codigo identico a EXP_FIN }\r
+ if poliN = 2 then cargarVectores := true { si se leyeron los 2 polinomios, devuelve true }\r
+ else cargarVectores := false; { si no se leyeron los dos, devuelve false }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for i := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ procedure division(v1, v2: Vector; var vr, vResto: Vector);\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division }\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ while i >= j do\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j];\r
+ vRTmp[i-j] := vr[i-j];\r
+ producto(vRTmp, v2, vTmp);\r
+ resta(v1, vTmp, v1);\r
+ vRTmp[i-j] := 0;\r
+ for i := i downto 0 do\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1;\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+{ Continuacion del programa principal }\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector;\r
+ resultado: boolean;\r
+\r
+begin { Comienzo del programa principal }\r
+ resultado := cargarVectores(v1, v2);\r
+ if not resultado then exit;\r
+ muestraVector(v1, 'Polinomio 1 =');\r
+ muestraVector(v2, 'Polinomio 2 =');\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 + Polinomio 2 =');\r
+end.
\ No newline at end of file
--- /dev/null
+program Polinomios;\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '0.8.4a (POLI_6)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Vector = array [0..TAM_MAX-1] of real; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ writeln(s); { mustra el mensaje }\r
+ write(' '); { deja un espacio antes de empezar a mostrar el polinomio }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (abs(v[i]) <> 1) or (i = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(v[i]):1, ' ') { imprime si es un numero entero }\r
+ else write(v[i]:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i] = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(i));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i] < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i]) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(abs(v[i])):1, ' ') { imprime si es un entero }\r
+ else write(abs(v[i]):1:2, ' '); { imprime si es un real }\r
+ write(exponente(i));\r
+ end; { if }\r
+ writeln;\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ v[i] := 0; { inicializa la variable actual en 0 }\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ { este codigo es el mismo que el de EXP_FIN, se repite aca solo por si el final del\r
+ archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ { fin del codigo identico a EXP_FIN }\r
+ if poliN = 2 then cargarVectores := true { si se leyeron los 2 polinomios, devuelve true }\r
+ else cargarVectores := false; { si no se leyeron los dos, devuelve false }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for i := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ procedure division(v1, v2: Vector; var vr, vResto: Vector);\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division }\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ while i >= j do\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j];\r
+ vRTmp[i-j] := vr[i-j];\r
+ producto(vRTmp, v2, vTmp);\r
+ resta(v1, vTmp, v1);\r
+ vRTmp[i-j] := 0;\r
+ for i := i downto 0 do\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1;\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+{ Continuacion del programa principal }\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector;\r
+ resultado: boolean;\r
+\r
+begin { Comienzo del programa principal }\r
+ resultado := cargarVectores(v1, v2);\r
+ if not resultado then exit;\r
+ muestraVector(v1, 'Polinomio 1 =');\r
+ muestraVector(v2, 'Polinomio 2 =');\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 + Polinomio 2 =');\r
+end.
\ No newline at end of file
--- /dev/null
+program Polinomios;\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '0.8.5a (POLI_7)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Vector = array [0..TAM_MAX-1] of real; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ writeln(s); { mustra el mensaje }\r
+ write(' '); { deja un espacio antes de empezar a mostrar el polinomio }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (abs(v[i]) <> 1) or (i = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(v[i]):1, ' ') { imprime si es un numero entero }\r
+ else write(v[i]:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i] = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(i));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i] < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i]) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(abs(v[i])):1, ' ') { imprime si es un entero }\r
+ else write(abs(v[i]):1:2, ' '); { imprime si es un real }\r
+ write(exponente(i));\r
+ end; { if }\r
+ writeln;\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ v[i] := 0; { inicializa la variable actual en 0 }\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ { este codigo es el mismo que el de EXP_FIN, se repite aca solo por si el final del\r
+ archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ { fin del codigo identico a EXP_FIN }\r
+ if poliN = 2 then cargarVectores := true { si se leyeron los 2 polinomios, devuelve true }\r
+ else cargarVectores := false; { si no se leyeron los dos, devuelve false }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] - v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for i := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ procedure division(v1, v2: Vector; var vr, vResto: Vector);\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division }\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ while i >= j do\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j];\r
+ vRTmp[i-j] := vr[i-j];\r
+ producto(vRTmp, v2, vTmp);\r
+ resta(v1, vTmp, v1);\r
+ vRTmp[i-j] := 0;\r
+ for i := i downto 0 do\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1;\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+{ Continuacion del programa principal }\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector;\r
+ resultado: boolean;\r
+\r
+begin { Comienzo del programa principal }\r
+ resultado := cargarVectores(v1, v2);\r
+ if resultado then\r
+ begin\r
+ muestraVector(v1, 'Polinomio 1 =');\r
+ muestraVector(v2, 'Polinomio 2 =');\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 + Polinomio 2 =');\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 - Polinomio 2 =');\r
+ end\r
+ else\r
+ begin\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end.
\ No newline at end of file
--- /dev/null
+program Polinomios;\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '0.9.0a (POLI_8)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Vector = array [0..TAM_MAX-1] of real; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (abs(v[i]) <> 1) or (i = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(v[i]):1, ' ') { imprime si es un numero entero }\r
+ else write(v[i]:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i] = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(i));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i] < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i]) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(abs(v[i])):1, ' ') { imprime si es un entero }\r
+ else write(abs(v[i]):1:2, ' '); { imprime si es un real }\r
+ write(exponente(i));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ v[i] := 0; { inicializa la variable actual en 0 }\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ { este codigo es el mismo que el de EXP_FIN, se repite aca solo por si el final del\r
+ archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ { fin del codigo identico a EXP_FIN }\r
+ if poliN = 2 then cargarVectores := true { si se leyeron los 2 polinomios, devuelve true }\r
+ else cargarVectores := false; { si no se leyeron los dos, devuelve false }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] - v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ procedure division(v1, v2: Vector; var vr, vResto: Vector);\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division }\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ while i >= j do\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j];\r
+ vRTmp[i-j] := vr[i-j];\r
+ producto(vRTmp, v2, vTmp);\r
+ resta(v1, vTmp, v1);\r
+ vRTmp[i-j] := 0;\r
+ for i := i downto 0 do\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1;\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+{ Continuacion del programa principal }\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector;\r
+ resultado: boolean;\r
+\r
+begin { Comienzo del programa principal }\r
+ resultado := cargarVectores(v1, v2);\r
+ if resultado then\r
+ begin\r
+ muestraVector(v1, 'Polinomio 1 = ');\r
+ muestraVector(v2, 'Polinomio 2 = ');\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 + Polinomio 2 = ');\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 - Polinomio 2 = ');\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 * Polinomio 2 = ');\r
+ end\r
+ else\r
+ begin\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end.
\ No newline at end of file
--- /dev/null
+program Polinomios;\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '0.9.8b (POLI_9)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Vector = array [0..TAM_MAX-1] of real; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (i = 0) and (v[i] = 0) then { si el primer exponente que encuentra es 0 y el coeficiente es 0, entonces }\r
+ begin { muestra el resultado como 0 y sale del procedimiento }\r
+ write('0'); { imprime que el resultado es cero }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ exit; { sale de este procedimiento }\r
+ end;\r
+ if (abs(v[i]) <> 1) or (i = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(v[i]):1, ' ') { imprime si es un numero entero }\r
+ else write(v[i]:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i] = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(i));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i] <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i] < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i]) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i]) - trunc(abs(v[i])) = 0 then write(trunc(abs(v[i])):1, ' ') { imprime si es un entero }\r
+ else write(abs(v[i]):1:2, ' '); { imprime si es un real }\r
+ write(exponente(i));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ v[i] := 0; { inicializa la variable actual en 0 }\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ { este codigo es el mismo que el de EXP_FIN, se repite aca solo por si el final del\r
+ archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
+ else v2[iExp] := rCoef { al polinomio correspondiente }\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ { fin del codigo identico a EXP_FIN }\r
+ if poliN = 2 then cargarVectores := true { si se leyeron los 2 polinomios, devuelve true }\r
+ else cargarVectores := false; { si no se leyeron los dos, devuelve false }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] - v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division\r
+ devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
+ devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ if (j = 0) and (v2[j] = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
+ then { el polinomio 2 es nulo y no se puede efectuar la division }\r
+ begin { se devuelve false y se quedan los vectores resultado en 0 }\r
+ division := false; { devuelve false }\r
+ exit; { sale del procedimiento }\r
+ end;\r
+ while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j]; { almacena el resultado de la division entre los coeficientes en\r
+ la posicion de la resta de ambos }\r
+ vRTmp[i-j] := vr[i-j]; { almacena ese resultado en un polinomio temporal cuyo unico termio\r
+ no nulo es el del exponente i-j, para luego multiplicarlo }\r
+ producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
+ en otro temporal, para luego hacer la resta }\r
+ resta(v1, vTmp, v1); { resta al primer polinomio, v1, (en su estado actual, no el original)\r
+ el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
+ la misma forma }\r
+ vRTmp[i-j] := 0; { resetea el termino del temporal vRTmp que se asigno para los calculos }\r
+ for i := i downto 0 do { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
+ si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
+ division := true; { devuelve true indicando que se finalizo con exito }\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+{ Continuacion del programa principal }\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
+ continua: boolean; { valor para obtener los resultados de algunas funciones }\r
+\r
+begin { Comienzo del programa principal }\r
+ continua := cargarVectores(v1, v2);\r
+ if continua then\r
+ begin\r
+ muestraVector(v1, 'Polinomio 1 = ');\r
+ muestraVector(v2, 'Polinomio 2 = ');\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 + Polinomio 2 = ');\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 - Polinomio 2 = ');\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 * Polinomio 2 = ');\r
+ continua := division(v1, v2, vResult, vResto);\r
+ if continua\r
+ then\r
+ begin\r
+ muestraVector(vResult, 'Polinomio 1 / Polinomio 2 = ');\r
+ muestraVector(vResto, 'Resto = ');\r
+ end\r
+ else writeln('El segundo polinomio es nulo, por lo tanto no se puede efectuar la division');\r
+ end\r
+ else\r
+ begin\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end.
\ No newline at end of file
--- /dev/null
+program PolinomiosEnTermino;\r
+{ Programa que lee 2 polinomios desde un archivo de texto para luego\r
+ hacer operaciones basicas entre estos (suma, resta, multiplicacion\r
+ y division).\r
+ El formato del archivo de texto debe ser de la siguiente manera:\r
+\r
+ * Se ingresan cada polinomio en lineas sucesivas.\r
+ * El primer polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto.\r
+ * El fin del primer polinomio (y comienzo del segundo) se indica por\r
+ medio de 1 o mas lineas en blanco.\r
+ * El segundo polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto a partir de dicha(s) linea(s) en blanco.\r
+ * Cada termino de un polinomio debe estar en la misma linea y comenzar\r
+ al principio de esta (excepto el primer termino).\r
+ * Los terminos debes estar ordenados de menor a mayor segun el exponente.\r
+ * En cada linea se ingresa primero el coeficiente real (puede tener un\r
+ signo '-' al comenzar y/o un punto, y solamente uno) y luego el\r
+ exponente entero positivo.\r
+ * La separacion entre el coeficiente y el exponente debe estar dada por\r
+ uno o mas espacios o tabuladores.\r
+ * Cualquier caracter incluido en el texto que no sea un degito (0..9),\r
+ un punto ('.'), un signo menos ('-'), un espacio (' '), un tabulador\r
+ o alguno de los caracteres de nueva linea, dara un error en la\r
+ lectura.\r
+ * El archivo de texto debe tener formato DOS (es decir, el indicador de\r
+ nueva linea debe ser primero un caracter de retorno del carro\r
+ seguido inmediatamente por uno de avance de linea).\r
+}\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '1.2.2r (TERM_5)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Termino = record { tipo de dato que representa un termino de un polinomio }\r
+ coef: real; { parte del coeficiente del termino }\r
+ exp: integer; { parte del exponente del termino }\r
+ end; { Termino }\r
+ Vector = array [0..TAM_MAX-1] of Termino; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ textcolor(lightcyan); { pone el color del texto en cian claro }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ textcolor(lightmagenta); { pone el color del texto en magenta claro }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i].coef <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (v[i].exp = 0) and (v[i].coef = 0) then { si el primer exponente que encuentra es 0 y el coeficiente es 0, entonces }\r
+ begin { muestra el resultado como 0 y sale del procedimiento }\r
+ write('0'); { imprime que el resultado es cero }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ exit; { sale de este procedimiento }\r
+ end;\r
+ if (abs(v[i].coef) <> 1) or (v[i].exp = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0 then write(trunc(v[i].coef):1, ' ') {imprime si es un numero entero}\r
+ else write(v[i].coef:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i].coef = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(v[i].exp));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i].coef <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i].coef < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i].coef) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0\r
+ then write(trunc(abs(v[i].coef)):1, ' ') { imprime si es entero }\r
+ else write(abs(v[i].coef):1:2, ' '); { imprime si es un real }\r
+ write(exponente(v[i].exp));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ begin\r
+ v[i].coef := 0.0; { inicializa la variable actual en 0 }\r
+ v[i].exp := 0; { inicializa la variable actual en 0 }\r
+ end;\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ clrscr; { borra la pantalla }\r
+ textcolor( Yellow ); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnTermino' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ writeln(' Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ clrscr; { borra la pantalla }\r
+ textcolor( Yellow ); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnTermino' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ write(' El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write(' (ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1\r
+ then { si es el polinomio 1 }\r
+ begin\r
+ v1[iExp].coef := rCoef; { asigna el valor correspondiente }\r
+ v1[iExp].exp := iExp; { asigna el valor correspondiente }\r
+ end\r
+ else { si es el polinomio 2 }\r
+ begin\r
+ v2[iExp].coef := rCoef; { asigna el valor correspondiente }\r
+ v2[iExp].exp := iExp; { asigna el valor correspondiente }\r
+ end\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ cargarVectores := true; { en principio se establece que la lectura se hizo con exito ) }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ { este codigo es similar al de EXP_FIN, se hacen las asignaciones por el caso en que el fin\r
+ del archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 2\r
+ then { si es el polinomio 2 }\r
+ begin\r
+ v2[iExp].coef := rCoef; { asigna el valor correspondiente }\r
+ v2[iExp].exp := iExp; { asigna el valor correspondiente }\r
+ end\r
+ else cargarVectores := false { si es el primero, no se hizo bien la lectura }\r
+ else cargarVectores := false; { si no es menor, no se hizo bien la lectura }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ begin\r
+ vr[i].coef := v1[i].coef + v2[i].coef; { suma los coeficientes de los terminos con igual exponente }\r
+ vr[i].exp := i; { establece como valor del exponente al indice }\r
+ end;\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ begin\r
+ vr[i].coef := v1[i].coef - v2[i].coef; { resta los coeficientes de los terminos con igual exponente }\r
+ vr[i].exp := i; { establece como valor del exponente al indice }\r
+ end;\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ begin\r
+ vr[i+j].coef := vr[i+j].coef + (v1[i].coef * v2[j].coef);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ vr[i+j].exp := i+j; { establece como exponente a la suma de los otros dos }\r
+ end;\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division\r
+ devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
+ devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i].coef <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j].coef <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ if (j = 0) and (v2[j].coef = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
+ then { el polinomio 2 es nulo y no se puede efectuar la division }\r
+ begin { se devuelve false y se quedan los vectores resultado en 0 }\r
+ division := false; { devuelve false }\r
+ exit; { sale del procedimiento }\r
+ end;\r
+ while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
+ begin\r
+ vr[i-j].coef := v1[i].coef / v2[j].coef; { almacena el resultado de la division entre los coeficientes en }\r
+ vr[i-j].exp := v1[i].exp - v2[j].exp; { coeficientes en la posicion de la resta de ambos }\r
+ vRTmp[i-j].coef := vr[i-j].coef; { almacena ese resultado en un polinomio temporal cuyo unico termio }\r
+ vRTmp[i-j].exp := vr[i-j].exp; { no nulo es el del exponente i-j, para luego multiplicarlo }\r
+ producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
+ en otro temporal, para luego hacer la resta }\r
+ resta(v1, vTmp, v1); { resta al primer polinomio, v1, (en su estado actual, no el original)\r
+ el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
+ la misma forma }\r
+ vRTmp[i-j].coef := 0.0; {resetea el coeficiente del termino del temporal vRTmp que se asigno para los calculos}\r
+ vRTmp[i-j].exp := 0; { resetea el exponente del termino del temporal vRTmp que se asigno para los calculos }\r
+ for i := i downto 0 do { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i].coef <> 0 then break;\r
+ { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
+ si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
+ division := true; { devuelve true indicando que se finalizo con exito }\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+ procedure mensajeSalida; { muestra un mensaje en la salida del programa }\r
+\r
+ begin\r
+ writeln; { linea en blanco }\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ clrscr; { borra la pantalla }\r
+ writeln; { linea en blanco }\r
+ textcolor(white); { cambia el color del texto }\r
+ writeln(' PolinomiosEnTermino versi¢n ', VERSION); { mensaje con version del programa }\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ writeln(' Desarrollado por: Javier Grijalba'); { mensaje con los integrantes del grupo }\r
+ writeln(' Leandro Lucarella');\r
+ writeln(' Erasmo Troncovich');\r
+ writeln(' Diego Wojnicki');\r
+ writeln(' para la Facultad de Ingenier¡a de la Universidad de Buenos Aires.');\r
+ writeln(' Consultas y/o sugerencias a:');\r
+ writeln;\r
+ textcolor(LightMagenta); { cambia el color del texto }\r
+ write(' lluca@cnba.uba.ar');\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ write(' o ');\r
+ textcolor(LightMagenta); { cambia el color del texto }\r
+ writeln('grijalba@cvtci.com.ar');\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ writeln;\r
+ writeln(' (c) 1999 - Todos los derechos reservados.');\r
+ delay(750);\r
+ end;\r
+\r
+\r
+ {########################################################}\r
+\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
+ seguir, { indicador para saber si sigue corriendo el programa }\r
+ noNulo, { indicador para saber si en la division el divisor es nulo }\r
+ continua: boolean; { indicador para saber si se leyeron bien los polinomios }\r
+ tecla: char; { entrada de teclado del usuario para elegir una opcion }\r
+\r
+begin { programa principal }\r
+ textbackground( Blue ); { establece el color para el fondo a azul }\r
+ continua := cargarVectores(v1, v2); { carga los vectores del archivo de datos }\r
+ if continua then { si se leyeron bien ... }\r
+ begin\r
+ seguir := true; { inicializa la variable en true para que entre en el ciclo while }\r
+ while seguir do { mientras el usuario no salga del programa }\r
+ begin\r
+ clrscr; { borra la pantalla }\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnTermino' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor(LightCyan); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ writeln( ' Elija que desea hacer:' ); { mensaje }\r
+ writeln( ' ----- --- ----- ------' ); { mensaje }\r
+ textcolor(LightGray); { establece el color para el texto a gris claro }\r
+ writeln; { mensaje con las opciones ... }\r
+ writeln;\r
+ writeln( ' 1.- Ver el polinomio 1.' );\r
+ writeln( ' 2.- Ver el polinomio 2.' );\r
+ writeln( ' 3.- Sumar los polinomios.' );\r
+ writeln( ' 4.- Restar el polinomio 2 al polinomio 1 (poli1 - poli2).' );\r
+ writeln( ' 5.- Restar el polinomio 1 al polinomio 2 (poli2 - poli1).' );\r
+ writeln( ' 6.- Multiplicar los polinomios.' );\r
+ writeln( ' 7.- Polinomio 1 dividido polinomio 2 (poli1 / poli2).' );\r
+ writeln( ' 8.- Polinomio 2 dividido polinomio 1 (poli2 / poli1).' );\r
+ writeln( ' 0.- Salir.' );\r
+ gotoxy(1, 23); { va a las coordenas de pantalla 1 horizontal, 23 verical }\r
+ textcolor(White ); { establece el color para el texto a blanco }\r
+ write(' Ingrese su opci¢n: ');\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ tecla := readkey; { lee una tecla del usuario indicando la opcion que elijio }\r
+ while ((tecla < '1') or (tecla > '8')) and (tecla <> '0') do { mientras sea una tecla no admitida }\r
+ begin\r
+ textcolor(White); { establece el color para el texto a blanco }\r
+ gotoxy( 1, 23 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ write(' Ingrese su opci¢n ("1" a "8" o "0"): ' );\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ tecla := readkey; { lee una tecla del usuario indicando la opcion que elijio }\r
+ end; { while }\r
+ if tecla = '0' then { si la opcion fue salir del programa ... }\r
+ begin\r
+ mensajeSalida; { presenta un mensaje de salida }\r
+ exit; { sale del programa }\r
+ end;\r
+ clrscr; { borra la pantalla }\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnTermino' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor(LightCyan); { establece el color para el texto a cian claro }\r
+ gotoxy(1, 7); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ case tecla of\r
+ '1': muestraVector(v1, ' Polinomio 1 = ');\r
+ '2': muestraVector(v2, ' Polinomio 2 = ');\r
+ '3': begin\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 + Polinomio 2 = ');\r
+ end; { case 3 }\r
+ '4': begin\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 - Polinomio 2 = ');\r
+ end; { case 4 }\r
+ '5': begin\r
+ resta(v2, v1, vResult);\r
+ muestraVector(vResult, ' Polinomio 2 - Polinomio 1 = ');\r
+ end; { case 5 }\r
+ '6': begin\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 * Polinomio 2 = ');\r
+ end; { case 6 }\r
+ '7': begin\r
+ noNulo := division(v1, v2, vResult, vResto);\r
+ if noNulo\r
+ then\r
+ begin\r
+ muestraVector(vResult, ' Polinomio 1 / Polinomio 2 = ');\r
+ muestraVector(vResto, ' Resto = ');\r
+ end\r
+ else writeln(' El polinomio 2 es nulo, por lo tanto no se puede efectuar la division.');\r
+ end; { case 7 }\r
+ '8': begin\r
+ noNulo := division(v2, v1, vResult, vResto);\r
+ if noNulo\r
+ then\r
+ begin\r
+ muestraVector(vResult, 'Polinomio 2 / Polinomio 1 = ');\r
+ muestraVector(vResto, 'Resto = ');\r
+ end\r
+ else writeln(' El polinomio 1 es nulo, por lo tanto no se puede efectuar la division.');\r
+ end; { case 8 }\r
+ '0': ; { no hace nada, nunca deberia entrar en este case }\r
+ end; { case }\r
+ writeln; { los siguientes mensajes son para que el usuario pueda ver los datos y luego }\r
+ writeln; { presione una tecla para continuar }\r
+ textcolor(white); { pone el color del texto en blanco }\r
+ writeln(' Presione una tecla para continuar ...');\r
+ tecla := readkey;\r
+ end; { while }\r
+ end\r
+ else { si los vectores no se leyeron bien ... }\r
+ begin { presenta un mensaje de error }\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end. { programa principal }
\ No newline at end of file
--- /dev/null
+program PolinomiosEnTermino;\r
+{ Programa que lee 2 polinomios desde un archivo de texto para luego\r
+ hacer operaciones basicas entre estos (suma, resta, multiplicacion\r
+ y division).\r
+ El formato del archivo de texto debe ser de la siguiente manera:\r
+\r
+ * Se ingresan cada polinomio en lineas sucesivas.\r
+ * El primer polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto.\r
+ * El fin del primer polinomio (y comienzo del segundo) se indica por\r
+ medio de 1 o mas lineas en blanco.\r
+ * El segundo polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto a partir de dicha(s) linea(s) en blanco.\r
+ * Cada termino de un polinomio debe estar en la misma linea y comenzar\r
+ al principio de esta (excepto el primer termino).\r
+ * En cada linea se ingresa primero el coeficiente real (puede tener un\r
+ signo '-' al comenzar y/o un punto, y solamente uno) y luego el\r
+ exponente entero positivo.\r
+ * La separacion entre el coeficiente y el exponente debe estar dada por\r
+ uno o mas espacios o tabuladores.\r
+ * Cualquier caracter incluido en el texto que no sea un degito (0..9),\r
+ un punto ('.'), un signo menos ('-'), un espacio (' '), un tabulador\r
+ o alguno de los caracteres de nueva linea, dara un error en la\r
+ lectura.\r
+ * El archivo de texto debe tener formato DOS (es decir, el indicador de\r
+ nueva linea debe ser primero un caracter de retorno del carro\r
+ seguido inmediatamente por uno de avance de linea).\r
+}\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '0.0.1a (TERM_0)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Termino = record\r
+ coef: real;\r
+ exp: integer;\r
+ end;\r
+ Vector = array [0..TAM_MAX-1] of Termino; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i].coef <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (v[i].exp = 0) and (v[i].coef = 0) then { si el primer exponente que encuentra es 0 y el coeficiente es 0, entonces }\r
+ begin { muestra el resultado como 0 y sale del procedimiento }\r
+ write('0'); { imprime que el resultado es cero }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ exit; { sale de este procedimiento }\r
+ end;\r
+ if (abs(v[i].coef) <> 1) or (v[i].exp = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0 then write(trunc(v[i].coef):1, ' ') {imprime si es un numero entero}\r
+ else write(v[i].coef:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i].coef = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(v[i].exp));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i].coef <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i].coef < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i].coef) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0\r
+ then write(trunc(abs(v[i].coef)):1, ' ') { imprime si es entero }\r
+ else write(abs(v[i].coef):1:2, ' '); { imprime si es un real }\r
+ write(exponente(v[i].exp));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ begin\r
+ v[i].coef := 0.0; { inicializa la variable actual en 0 }\r
+ v[i].exp := 0; { inicializa la variable actual en 0 }\r
+ end;\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then\r
+ begin\r
+ v1[n].coef := rCoef { asigna el valor correspondiente }\r
+ v1[n].exp := iExp { asigna el valor correspondiente }\r
+ end\r
+ else\r
+ begin\r
+ v1[n].coef := rCoef { asigna el valor correspondiente }\r
+ v1[n].exp := iExp { asigna el valor correspondiente }\r
+ end;\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ { este codigo es el mismo que el de EXP_FIN, se repite aca solo por si el final del\r
+ archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then\r
+ begin\r
+ v1[n].coef := rCoef { asigna el valor correspondiente }\r
+ v1[n].exp := iExp { asigna el valor correspondiente }\r
+ end\r
+ else\r
+ begin\r
+ v1[n].coef := rCoef { asigna el valor correspondiente }\r
+ v1[n].exp := iExp { asigna el valor correspondiente }\r
+ end;\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ { fin del codigo identico a EXP_FIN }\r
+ if poliN = 2 then cargarVectores := true { si se leyeron los 2 polinomios, devuelve true }\r
+ else cargarVectores := false; { si no se leyeron los dos, devuelve false }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] - v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division\r
+ devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
+ devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ if (j = 0) and (v2[j] = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
+ then { el polinomio 2 es nulo y no se puede efectuar la division }\r
+ begin { se devuelve false y se quedan los vectores resultado en 0 }\r
+ division := false; { devuelve false }\r
+ exit; { sale del procedimiento }\r
+ end;\r
+ while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j]; { almacena el resultado de la division entre los coeficientes en\r
+ la posicion de la resta de ambos }\r
+ vRTmp[i-j] := vr[i-j]; { almacena ese resultado en un polinomio temporal cuyo unico termio\r
+ no nulo es el del exponente i-j, para luego multiplicarlo }\r
+ producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
+ en otro temporal, para luego hacer la resta }\r
+ resta(v1, vTmp, v1); { resta al primer polinomio, v1, (en su estado actual, no el original)\r
+ el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
+ la misma forma }\r
+ vRTmp[i-j] := 0; { resetea el termino del temporal vRTmp que se asigno para los calculos }\r
+ for i := i downto 0 do { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
+ si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
+ division := true; { devuelve true indicando que se finalizo con exito }\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+{ Continuacion del programa principal }\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
+ continua: boolean; { valor para obtener los resultados de algunas funciones }\r
+\r
+begin { Comienzo del programa principal }\r
+ continua := cargarVectores(v1, v2);\r
+ if continua then\r
+ begin\r
+ muestraVector(v1, 'Polinomio 1 = ');\r
+ muestraVector(v2, 'Polinomio 2 = ');\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 + Polinomio 2 = ');\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 - Polinomio 2 = ');\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 * Polinomio 2 = ');\r
+ continua := division(v1, v2, vResult, vResto);\r
+ if continua\r
+ then\r
+ begin\r
+ muestraVector(vResult, 'Polinomio 1 / Polinomio 2 = ');\r
+ muestraVector(vResto, 'Resto = ');\r
+ end\r
+ else writeln('El segundo polinomio es nulo, por lo tanto no se puede efectuar la division');\r
+ end\r
+ else\r
+ begin\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end.
\ No newline at end of file
--- /dev/null
+program PolinomiosEnTermino;\r
+{ Programa que lee 2 polinomios desde un archivo de texto para luego\r
+ hacer operaciones basicas entre estos (suma, resta, multiplicacion\r
+ y division).\r
+ El formato del archivo de texto debe ser de la siguiente manera:\r
+\r
+ * Se ingresan cada polinomio en lineas sucesivas.\r
+ * El primer polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto.\r
+ * El fin del primer polinomio (y comienzo del segundo) se indica por\r
+ medio de 1 o mas lineas en blanco.\r
+ * El segundo polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto a partir de dicha(s) linea(s) en blanco.\r
+ * Cada termino de un polinomio debe estar en la misma linea y comenzar\r
+ al principio de esta (excepto el primer termino).\r
+ * Los terminos debes estar ordenados de menor a mayor segun el exponente.\r
+ * En cada linea se ingresa primero el coeficiente real (puede tener un\r
+ signo '-' al comenzar y/o un punto, y solamente uno) y luego el\r
+ exponente entero positivo.\r
+ * La separacion entre el coeficiente y el exponente debe estar dada por\r
+ uno o mas espacios o tabuladores.\r
+ * Cualquier caracter incluido en el texto que no sea un degito (0..9),\r
+ un punto ('.'), un signo menos ('-'), un espacio (' '), un tabulador\r
+ o alguno de los caracteres de nueva linea, dara un error en la\r
+ lectura.\r
+ * El archivo de texto debe tener formato DOS (es decir, el indicador de\r
+ nueva linea debe ser primero un caracter de retorno del carro\r
+ seguido inmediatamente por uno de avance de linea).\r
+}\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '0.0.1a (TERM_0)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Termino = record\r
+ coef: real;\r
+ exp: integer;\r
+ end;\r
+ Vector = array [0..TAM_MAX-1] of Termino; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i].coef <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (v[i].exp = 0) and (v[i].coef = 0) then { si el primer exponente que encuentra es 0 y el coeficiente es 0, entonces }\r
+ begin { muestra el resultado como 0 y sale del procedimiento }\r
+ write('0'); { imprime que el resultado es cero }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ exit; { sale de este procedimiento }\r
+ end;\r
+ if (abs(v[i].coef) <> 1) or (v[i].exp = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0 then write(trunc(v[i].coef):1, ' ') {imprime si es un numero entero}\r
+ else write(v[i].coef:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i].coef = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(v[i].exp));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i].coef <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i].coef < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i].coef) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0\r
+ then write(trunc(abs(v[i].coef)):1, ' ') { imprime si es entero }\r
+ else write(abs(v[i].coef):1:2, ' '); { imprime si es un real }\r
+ write(exponente(v[i].exp));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ begin\r
+ v[i].coef := 0.0; { inicializa la variable actual en 0 }\r
+ v[i].exp := 0; { inicializa la variable actual en 0 }\r
+ end;\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ asignado, { indicador para saber si ya se asigno el valor al termino actual }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ n, { numero de termino del polinomio actual }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ asignado := false; { inicializacion de variable }\r
+ n := -1; { inicializacion de variable }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: { Si termino de leer el coeficiente ... }\r
+ begin\r
+ n := n + 1; { incrementa el termino en uno }\r
+ asignado := false; { se indica que no esta asignado todavia. }\r
+ { Se elije este estado para indicar esto (e incrementar el termino) porque siempre que\r
+ finalize bien el polinomio se pasa por \82l (no pasa lo mismo con EXP_FIN).\r
+ La asignacion se realiza cuando termina de leer el exponente }\r
+ end;\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then\r
+ begin\r
+ v1[n].coef := rCoef; { asigna el valor correspondiente }\r
+ v1[n].exp := iExp; { asigna el valor correspondiente }\r
+ asignado := true; { se indica que se hizo la asignacion.\r
+ esto solo tiene sentido si el archivo finaliza justo despues\r
+ de leer el ultimo exponente (no pasa po este estado y asignado\r
+ queda en false, avisandole a FIN que debe hacer la asignacion }\r
+ end\r
+ else\r
+ begin\r
+ v1[n].coef := rCoef; { asigna el valor correspondiente }\r
+ v1[n].exp := iExp; { asigna el valor correspondiente }\r
+ asignado := true; { se indica que se hizo la asignacion.\r
+ esto solo tiene sentido si el archivo finaliza justo despues\r
+ de leer el ultimo exponente (no pasa po este estado y asignado\r
+ queda en false, avisandole a FIN que debe hacer la asignacion }\r
+ end\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then\r
+ begin\r
+ poliN := 2; { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ n := -1; { empieza por el primer termino (vale n = 0 al pasar por COEF_FIN) }\r
+ end\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ cargarVectores := true; { en principio se establece que la lectura se hizo con exito ) }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ { este codigo es similar al de EXP_FIN, se hacen las asignaciones por el caso en que el fin\r
+ del archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ if poliN <> 2 { si no se leyeron ambos polinomios ... }\r
+ then\r
+ cargarVectores := false { devuelve false (no se realizo con exito la lectura }\r
+ else { si se leyeron ambos polinomios ... }\r
+ if not asignado then { si no se pudo hacer la asignacion ... }\r
+ { esto solo tiene sentido si el archivo finaliza justo despues\r
+ de leer el ultimo exponente (no pasa por el estado FIN_EXP y\r
+ FIN debe hacer la asignacion }\r
+ begin\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then\r
+ begin\r
+ v2[n].coef := rCoef; { asigna el valor correspondiente }\r
+ v2[n].exp := iExp; { asigna el valor correspondiente }\r
+ end\r
+ else\r
+ cargarVectores := false; { si no es menor, no se hizo bien la lectura }\r
+ end; { if not asignado }\r
+ end; { FIN: }\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] + v2[i]; { suma los coeficientes de los terminos con igual exponente }\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ vr[i] := v1[i] - v2[i]; { resta los coeficientes de los terminos con igual exponente }\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division\r
+ devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
+ devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j] <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ if (j = 0) and (v2[j] = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
+ then { el polinomio 2 es nulo y no se puede efectuar la division }\r
+ begin { se devuelve false y se quedan los vectores resultado en 0 }\r
+ division := false; { devuelve false }\r
+ exit; { sale del procedimiento }\r
+ end;\r
+ while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
+ begin\r
+ vr[i-j] := v1[i] / v2[j]; { almacena el resultado de la division entre los coeficientes en\r
+ la posicion de la resta de ambos }\r
+ vRTmp[i-j] := vr[i-j]; { almacena ese resultado en un polinomio temporal cuyo unico termio\r
+ no nulo es el del exponente i-j, para luego multiplicarlo }\r
+ producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
+ en otro temporal, para luego hacer la resta }\r
+ resta(v1, vTmp, v1); { resta al primer polinomio, v1, (en su estado actual, no el original)\r
+ el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
+ la misma forma }\r
+ vRTmp[i-j] := 0; { resetea el termino del temporal vRTmp que se asigno para los calculos }\r
+ for i := i downto 0 do { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i] <> 0 then break;\r
+ { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
+ si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
+ division := true; { devuelve true indicando que se finalizo con exito }\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+{ Continuacion del programa principal }\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
+ continua: boolean; { valor para obtener los resultados de algunas funciones }\r
+\r
+begin { Comienzo del programa principal }\r
+ continua := cargarVectores(v1, v2);\r
+ if continua then\r
+ begin\r
+ muestraVector(v1, 'Polinomio 1 = ');\r
+ muestraVector(v2, 'Polinomio 2 = ');\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 + Polinomio 2 = ');\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 - Polinomio 2 = ');\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 * Polinomio 2 = ');\r
+ continua := division(v1, v2, vResult, vResto);\r
+ if continua\r
+ then\r
+ begin\r
+ muestraVector(vResult, 'Polinomio 1 / Polinomio 2 = ');\r
+ muestraVector(vResto, 'Resto = ');\r
+ end\r
+ else writeln('El segundo polinomio es nulo, por lo tanto no se puede efectuar la division');\r
+ end\r
+ else\r
+ begin\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end.
\ No newline at end of file
--- /dev/null
+program PolinomiosEnTermino;\r
+{ Programa que lee 2 polinomios desde un archivo de texto para luego\r
+ hacer operaciones basicas entre estos (suma, resta, multiplicacion\r
+ y division).\r
+ El formato del archivo de texto debe ser de la siguiente manera:\r
+\r
+ * Se ingresan cada polinomio en lineas sucesivas.\r
+ * El primer polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto.\r
+ * El fin del primer polinomio (y comienzo del segundo) se indica por\r
+ medio de 1 o mas lineas en blanco.\r
+ * El segundo polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto a partir de dicha(s) linea(s) en blanco.\r
+ * Cada termino de un polinomio debe estar en la misma linea y comenzar\r
+ al principio de esta (excepto el primer termino).\r
+ * Los terminos debes estar ordenados de menor a mayor segun el exponente.\r
+ * En cada linea se ingresa primero el coeficiente real (puede tener un\r
+ signo '-' al comenzar y/o un punto, y solamente uno) y luego el\r
+ exponente entero positivo.\r
+ * La separacion entre el coeficiente y el exponente debe estar dada por\r
+ uno o mas espacios o tabuladores.\r
+ * Cualquier caracter incluido en el texto que no sea un degito (0..9),\r
+ un punto ('.'), un signo menos ('-'), un espacio (' '), un tabulador\r
+ o alguno de los caracteres de nueva linea, dara un error en la\r
+ lectura.\r
+ * El archivo de texto debe tener formato DOS (es decir, el indicador de\r
+ nueva linea debe ser primero un caracter de retorno del carro\r
+ seguido inmediatamente por uno de avance de linea).\r
+}\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '0.2.0a (TERM_2)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Termino = record\r
+ coef: real;\r
+ exp: integer;\r
+ end;\r
+ Vector = array [0..TAM_MAX-1] of Termino; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i].coef <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (v[i].exp = 0) and (v[i].coef = 0) then { si el primer exponente que encuentra es 0 y el coeficiente es 0, entonces }\r
+ begin { muestra el resultado como 0 y sale del procedimiento }\r
+ write('0'); { imprime que el resultado es cero }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ exit; { sale de este procedimiento }\r
+ end;\r
+ if (abs(v[i].coef) <> 1) or (v[i].exp = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0 then write(trunc(v[i].coef):1, ' ') {imprime si es un numero entero}\r
+ else write(v[i].coef:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i].coef = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(v[i].exp));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i].coef <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i].coef < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i].coef) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0\r
+ then write(trunc(abs(v[i].coef)):1, ' ') { imprime si es entero }\r
+ else write(abs(v[i].coef):1:2, ' '); { imprime si es un real }\r
+ write(exponente(v[i].exp));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ begin\r
+ v[i].coef := 0.0; { inicializa la variable actual en 0 }\r
+ v[i].exp := 0; { inicializa la variable actual en 0 }\r
+ end;\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ asignado, { indicador para saber si ya se asigno el valor al termino actual }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ n, { numero de termino del polinomio actual }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ asignado := false; { inicializacion de variable }\r
+ n := -1; { inicializacion de variable }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: { Si termino de leer el coeficiente ... }\r
+ begin\r
+ n := n + 1; { incrementa el termino en uno }\r
+ asignado := false; { se indica que no esta asignado todavia. }\r
+ { Se elije este estado para indicar esto (e incrementar el termino) porque siempre que\r
+ finalize bien el polinomio se pasa por \82l (no pasa lo mismo con EXP_FIN).\r
+ La asignacion se realiza cuando termina de leer el exponente }\r
+ end;\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1 then\r
+ begin\r
+ v1[n].coef := rCoef; { asigna el valor correspondiente }\r
+ v1[n].exp := iExp; { asigna el valor correspondiente }\r
+ asignado := true; { se indica que se hizo la asignacion.\r
+ esto solo tiene sentido si el archivo finaliza justo despues\r
+ de leer el ultimo exponente (no pasa po este estado y asignado\r
+ queda en false, avisandole a FIN que debe hacer la asignacion }\r
+ end\r
+ else\r
+ begin\r
+ v2[n].coef := rCoef; { asigna el valor correspondiente }\r
+ v2[n].exp := iExp; { asigna el valor correspondiente }\r
+ asignado := true; { se indica que se hizo la asignacion.\r
+ esto solo tiene sentido si el archivo finaliza justo despues\r
+ de leer el ultimo exponente (no pasa po este estado y asignado\r
+ queda en false, avisandole a FIN que debe hacer la asignacion }\r
+ end\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then\r
+ begin\r
+ poliN := 2; { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ n := -1; { empieza por el primer termino (vale n = 0 al pasar por COEF_FIN) }\r
+ end\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ cargarVectores := true; { en principio se establece que la lectura se hizo con exito ) }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ { este codigo es similar al de EXP_FIN, se hacen las asignaciones por el caso en que el fin\r
+ del archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ if poliN <> 2 { si no se leyeron ambos polinomios ... }\r
+ then\r
+ cargarVectores := false { devuelve false (no se realizo con exito la lectura }\r
+ else { si se leyeron ambos polinomios ... }\r
+ if not asignado then { si no se pudo hacer la asignacion ... }\r
+ { esto solo tiene sentido si el archivo finaliza justo despues\r
+ de leer el ultimo exponente (no pasa por el estado FIN_EXP y\r
+ FIN debe hacer la asignacion }\r
+ begin\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then\r
+ begin\r
+ v2[n].coef := rCoef; { asigna el valor correspondiente }\r
+ v2[n].exp := iExp; { asigna el valor correspondiente }\r
+ end\r
+ else\r
+ cargarVectores := false; { si no es menor, no se hizo bien la lectura }\r
+ end; { if not asignado }\r
+ end; { FIN: }\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ {########################################################}\r
+\r
+{ Continuacion del programa principal }\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
+ continua: boolean; { valor para obtener los resultados de algunas funciones }\r
+\r
+begin { Comienzo del programa principal }\r
+ continua := cargarVectores(v1, v2);\r
+ if continua then\r
+ begin\r
+ muestraVector(v1, 'Polinomio 1 = ');\r
+ muestraVector(v2, 'Polinomio 2 = ');\r
+{DEBUG} for i := 0 to 10 do {}\r
+{DEBUG} writeln(v1[i].coef, ' X^', v1[i].exp, ' | ', v2[i].coef, ' X^', v2[i].exp); {}\r
+{ suma(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 + Polinomio 2 = ');\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 - Polinomio 2 = ');\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 * Polinomio 2 = ');\r
+ continua := division(v1, v2, vResult, vResto);\r
+ if continua\r
+ then\r
+ begin\r
+ muestraVector(vResult, 'Polinomio 1 / Polinomio 2 = ');\r
+ muestraVector(vResto, 'Resto = ');\r
+ end\r
+ else writeln('El segundo polinomio es nulo, por lo tanto no se puede efectuar la division');\r
+} end\r
+ else\r
+ begin\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end.
\ No newline at end of file
--- /dev/null
+program PolinomiosEnTermino;\r
+{ Programa que lee 2 polinomios desde un archivo de texto para luego\r
+ hacer operaciones basicas entre estos (suma, resta, multiplicacion\r
+ y division).\r
+ El formato del archivo de texto debe ser de la siguiente manera:\r
+\r
+ * Se ingresan cada polinomio en lineas sucesivas.\r
+ * El primer polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto.\r
+ * El fin del primer polinomio (y comienzo del segundo) se indica por\r
+ medio de 1 o mas lineas en blanco.\r
+ * El segundo polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto a partir de dicha(s) linea(s) en blanco.\r
+ * Cada termino de un polinomio debe estar en la misma linea y comenzar\r
+ al principio de esta (excepto el primer termino).\r
+ * Los terminos debes estar ordenados de menor a mayor segun el exponente.\r
+ * En cada linea se ingresa primero el coeficiente real (puede tener un\r
+ signo '-' al comenzar y/o un punto, y solamente uno) y luego el\r
+ exponente entero positivo.\r
+ * La separacion entre el coeficiente y el exponente debe estar dada por\r
+ uno o mas espacios o tabuladores.\r
+ * Cualquier caracter incluido en el texto que no sea un degito (0..9),\r
+ un punto ('.'), un signo menos ('-'), un espacio (' '), un tabulador\r
+ o alguno de los caracteres de nueva linea, dara un error en la\r
+ lectura.\r
+ * El archivo de texto debe tener formato DOS (es decir, el indicador de\r
+ nueva linea debe ser primero un caracter de retorno del carro\r
+ seguido inmediatamente por uno de avance de linea).\r
+}\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '0.9.0b (TERM_3)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Termino = record { tipo de dato que representa un termino de un polinomio }\r
+ coef: real; { parte del coeficiente del termino }\r
+ exp: integer; { parte del exponente del termino }\r
+ end; { Termino }\r
+ Vector = array [0..TAM_MAX-1] of Termino; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i].coef <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (v[i].exp = 0) and (v[i].coef = 0) then { si el primer exponente que encuentra es 0 y el coeficiente es 0, entonces }\r
+ begin { muestra el resultado como 0 y sale del procedimiento }\r
+ write('0'); { imprime que el resultado es cero }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ exit; { sale de este procedimiento }\r
+ end;\r
+ if (abs(v[i].coef) <> 1) or (v[i].exp = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0 then write(trunc(v[i].coef):1, ' ') {imprime si es un numero entero}\r
+ else write(v[i].coef:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i].coef = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(v[i].exp));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i].coef <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i].coef < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i].coef) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0\r
+ then write(trunc(abs(v[i].coef)):1, ' ') { imprime si es entero }\r
+ else write(abs(v[i].coef):1:2, ' '); { imprime si es un real }\r
+ write(exponente(v[i].exp));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ begin\r
+ v[i].coef := 0.0; { inicializa la variable actual en 0 }\r
+ v[i].exp := 0; { inicializa la variable actual en 0 }\r
+ end;\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1\r
+ then { si es el polinomio 1 }\r
+ begin\r
+ v1[iExp].coef := rCoef; { asigna el valor correspondiente }\r
+ v1[iExp].exp := iExp; { asigna el valor correspondiente }\r
+ end\r
+ else { si es el polinomio 2 }\r
+ begin\r
+ v2[iExp].coef := rCoef; { asigna el valor correspondiente }\r
+ v2[iExp].exp := iExp; { asigna el valor correspondiente }\r
+ end\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ cargarVectores := true; { en principio se establece que la lectura se hizo con exito ) }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ { este codigo es similar al de EXP_FIN, se hacen las asignaciones por el caso en que el fin\r
+ del archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 2\r
+ then { si es el polinomio 2 }\r
+ begin\r
+ v2[iExp].coef := rCoef; { asigna el valor correspondiente }\r
+ v2[iExp].exp := iExp; { asigna el valor correspondiente }\r
+ end\r
+ else cargarVectores := false { si es el primero, no se hizo bien la lectura }\r
+ else cargarVectores := false; { si no es menor, no se hizo bien la lectura }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ begin\r
+ vr[i].coef := v1[i].coef + v2[i].coef; { suma los coeficientes de los terminos con igual exponente }\r
+ vr[i].exp := i; { establece como valor del exponente al indice }\r
+ end;\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ begin\r
+ vr[i].coef := v1[i].coef - v2[i].coef; { resta los coeficientes de los terminos con igual exponente }\r
+ vr[i].exp := i; { establece como valor del exponente al indice }\r
+ end;\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ begin\r
+ vr[i+j].coef := vr[i+j].coef + (v1[i].coef * v2[j].coef);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ vr[i+j].exp := i+j; { establece como exponente a la suma de los otros dos }\r
+ end;\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division\r
+ devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
+ devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i].coef <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j].coef <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ if (j = 0) and (v2[j].coef = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
+ then { el polinomio 2 es nulo y no se puede efectuar la division }\r
+ begin { se devuelve false y se quedan los vectores resultado en 0 }\r
+ division := false; { devuelve false }\r
+ exit; { sale del procedimiento }\r
+ end;\r
+ while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
+ begin\r
+ vr[i-j].coef := v1[i].coef / v2[j].coef; { almacena el resultado de la division entre los coeficientes en }\r
+ vr[i-j].exp := v1[i].exp - v2[j].exp; { coeficientes en la posicion de la resta de ambos }\r
+ vRTmp[i-j].coef := vr[i-j].coef; { almacena ese resultado en un polinomio temporal cuyo unico termio }\r
+ vRTmp[i-j].exp := vr[i-j].exp; { no nulo es el del exponente i-j, para luego multiplicarlo }\r
+ producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
+ en otro temporal, para luego hacer la resta }\r
+ resta(v1, vTmp, v1); { resta al primer polinomio, v1, (en su estado actual, no el original)\r
+ el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
+ la misma forma }\r
+ vRTmp[i-j].coef := 0.0; {resetea el coeficiente del termino del temporal vRTmp que se asigno para los calculos}\r
+ vRTmp[i-j].exp := 0; { resetea el exponente del termino del temporal vRTmp que se asigno para los calculos }\r
+ for i := i downto 0 do { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i].coef <> 0 then break;\r
+ { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
+ si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
+ division := true; { devuelve true indicando que se finalizo con exito }\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+{ Continuacion del programa principal }\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
+ continua: boolean; { valor para obtener los resultados de algunas funciones }\r
+\r
+begin { Comienzo del programa principal }\r
+ continua := cargarVectores(v1, v2);\r
+ if continua then\r
+ begin\r
+ muestraVector(v1, 'Polinomio 1 = ');\r
+ muestraVector(v2, 'Polinomio 2 = ');\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 + Polinomio 2 = ');\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 - Polinomio 2 = ');\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, 'Polinomio 1 * Polinomio 2 = ');\r
+ continua := division(v1, v2, vResult, vResto);\r
+ if continua\r
+ then\r
+ begin\r
+ muestraVector(vResult, 'Polinomio 1 / Polinomio 2 = ');\r
+ muestraVector(vResto, 'Resto = ');\r
+ end\r
+ else writeln('El segundo polinomio es nulo, por lo tanto no se puede efectuar la division');\r
+ end\r
+ else\r
+ begin\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end.
\ No newline at end of file
--- /dev/null
+program PolinomiosEnTermino;\r
+{ Programa que lee 2 polinomios desde un archivo de texto para luego\r
+ hacer operaciones basicas entre estos (suma, resta, multiplicacion\r
+ y division).\r
+ El formato del archivo de texto debe ser de la siguiente manera:\r
+\r
+ * Se ingresan cada polinomio en lineas sucesivas.\r
+ * El primer polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto.\r
+ * El fin del primer polinomio (y comienzo del segundo) se indica por\r
+ medio de 1 o mas lineas en blanco.\r
+ * El segundo polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto a partir de dicha(s) linea(s) en blanco.\r
+ * Cada termino de un polinomio debe estar en la misma linea y comenzar\r
+ al principio de esta (excepto el primer termino).\r
+ * Los terminos debes estar ordenados de menor a mayor segun el exponente.\r
+ * En cada linea se ingresa primero el coeficiente real (puede tener un\r
+ signo '-' al comenzar y/o un punto, y solamente uno) y luego el\r
+ exponente entero positivo.\r
+ * La separacion entre el coeficiente y el exponente debe estar dada por\r
+ uno o mas espacios o tabuladores.\r
+ * Cualquier caracter incluido en el texto que no sea un degito (0..9),\r
+ un punto ('.'), un signo menos ('-'), un espacio (' '), un tabulador\r
+ o alguno de los caracteres de nueva linea, dara un error en la\r
+ lectura.\r
+ * El archivo de texto debe tener formato DOS (es decir, el indicador de\r
+ nueva linea debe ser primero un caracter de retorno del carro\r
+ seguido inmediatamente por uno de avance de linea).\r
+}\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '1.2.0r (TERM_4)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Termino = record { tipo de dato que representa un termino de un polinomio }\r
+ coef: real; { parte del coeficiente del termino }\r
+ exp: integer; { parte del exponente del termino }\r
+ end; { Termino }\r
+ Vector = array [0..TAM_MAX-1] of Termino; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ textcolor(lightcyan); { pone el color del texto en cian claro }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ textcolor(lightmagenta); { pone el color del texto en magenta claro }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i].coef <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (v[i].exp = 0) and (v[i].coef = 0) then { si el primer exponente que encuentra es 0 y el coeficiente es 0, entonces }\r
+ begin { muestra el resultado como 0 y sale del procedimiento }\r
+ write('0'); { imprime que el resultado es cero }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ exit; { sale de este procedimiento }\r
+ end;\r
+ if (abs(v[i].coef) <> 1) or (v[i].exp = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0 then write(trunc(v[i].coef):1, ' ') {imprime si es un numero entero}\r
+ else write(v[i].coef:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i].coef = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(v[i].exp));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i].coef <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i].coef < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i].coef) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0\r
+ then write(trunc(abs(v[i].coef)):1, ' ') { imprime si es entero }\r
+ else write(abs(v[i].coef):1:2, ' '); { imprime si es un real }\r
+ write(exponente(v[i].exp));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ begin\r
+ v[i].coef := 0.0; { inicializa la variable actual en 0 }\r
+ v[i].exp := 0; { inicializa la variable actual en 0 }\r
+ end;\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ clrscr; { borra la pantalla }\r
+ textcolor( Yellow ); { establece el color para el texto a amarillo }\r
+ gotoxy( 25, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'OPERACIONES ENTRE POLINOMIOS' ); { titulo }\r
+ gotoxy( 25, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ writeln(' Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ clrscr; { borra la pantalla }\r
+ textcolor( Yellow ); { establece el color para el texto a amarillo }\r
+ gotoxy( 25, 3 ); { va a las coordenas de pantalla 19 horizontal, 3 verical }\r
+ writeln( 'OPERACIONES ENTRE POLINOMIOS' ); { titulo }\r
+ gotoxy( 25, 4 ); { va a las coordenas de pantalla 19 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ write(' El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write(' (ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1\r
+ then { si es el polinomio 1 }\r
+ begin\r
+ v1[iExp].coef := rCoef; { asigna el valor correspondiente }\r
+ v1[iExp].exp := iExp; { asigna el valor correspondiente }\r
+ end\r
+ else { si es el polinomio 2 }\r
+ begin\r
+ v2[iExp].coef := rCoef; { asigna el valor correspondiente }\r
+ v2[iExp].exp := iExp; { asigna el valor correspondiente }\r
+ end\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ cargarVectores := true; { en principio se establece que la lectura se hizo con exito ) }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ { este codigo es similar al de EXP_FIN, se hacen las asignaciones por el caso en que el fin\r
+ del archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 2\r
+ then { si es el polinomio 2 }\r
+ begin\r
+ v2[iExp].coef := rCoef; { asigna el valor correspondiente }\r
+ v2[iExp].exp := iExp; { asigna el valor correspondiente }\r
+ end\r
+ else cargarVectores := false { si es el primero, no se hizo bien la lectura }\r
+ else cargarVectores := false; { si no es menor, no se hizo bien la lectura }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ begin\r
+ vr[i].coef := v1[i].coef + v2[i].coef; { suma los coeficientes de los terminos con igual exponente }\r
+ vr[i].exp := i; { establece como valor del exponente al indice }\r
+ end;\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ begin\r
+ vr[i].coef := v1[i].coef - v2[i].coef; { resta los coeficientes de los terminos con igual exponente }\r
+ vr[i].exp := i; { establece como valor del exponente al indice }\r
+ end;\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ begin\r
+ vr[i+j].coef := vr[i+j].coef + (v1[i].coef * v2[j].coef);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ vr[i+j].exp := i+j; { establece como exponente a la suma de los otros dos }\r
+ end;\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division\r
+ devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
+ devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i].coef <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j].coef <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ if (j = 0) and (v2[j].coef = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
+ then { el polinomio 2 es nulo y no se puede efectuar la division }\r
+ begin { se devuelve false y se quedan los vectores resultado en 0 }\r
+ division := false; { devuelve false }\r
+ exit; { sale del procedimiento }\r
+ end;\r
+ while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
+ begin\r
+ vr[i-j].coef := v1[i].coef / v2[j].coef; { almacena el resultado de la division entre los coeficientes en }\r
+ vr[i-j].exp := v1[i].exp - v2[j].exp; { coeficientes en la posicion de la resta de ambos }\r
+ vRTmp[i-j].coef := vr[i-j].coef; { almacena ese resultado en un polinomio temporal cuyo unico termio }\r
+ vRTmp[i-j].exp := vr[i-j].exp; { no nulo es el del exponente i-j, para luego multiplicarlo }\r
+ producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
+ en otro temporal, para luego hacer la resta }\r
+ resta(v1, vTmp, v1); { resta al primer polinomio, v1, (en su estado actual, no el original)\r
+ el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
+ la misma forma }\r
+ vRTmp[i-j].coef := 0.0; {resetea el coeficiente del termino del temporal vRTmp que se asigno para los calculos}\r
+ vRTmp[i-j].exp := 0; { resetea el exponente del termino del temporal vRTmp que se asigno para los calculos }\r
+ for i := i downto 0 do { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i].coef <> 0 then break;\r
+ { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
+ si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
+ division := true; { devuelve true indicando que se finalizo con exito }\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+ procedure mensajeSalida; { muestra un mensaje en la salida del programa }\r
+\r
+ begin\r
+ writeln; { linea en blanco }\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ clrscr; { borra la pantalla }\r
+ writeln; { linea en blanco }\r
+ textcolor(white); { cambia el color del texto }\r
+ writeln(' OPERACIONES ENTRE POLINOMIOS versi¢n ', VERSION); { mensaje con version del programa }\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ writeln(' Desarrollado por: JavierGrijalba'); { mensaje con los integrantes del grupo }\r
+ writeln(' Leandro Lucarella');\r
+ writeln(' Erasmo Troncovich');\r
+ writeln(' Diego Wojmicki');\r
+ writeln(' para la Facultad de Ingenier¡a de la Universidad de Buenos Aires.');\r
+ writeln(' Consultas y/o sugerencias a:');\r
+ writeln;\r
+ textcolor(LightMagenta); { cambia el color del texto }\r
+ write(' lluca@cnba.uba.ar');\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ write(' o ');\r
+ textcolor(LightMagenta); { cambia el color del texto }\r
+ writeln('grijalba@cvtci.com.ar');\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ writeln;\r
+ writeln(' (c) 1999 - Todos los derechos reservados.');\r
+ delay(750);\r
+ end;\r
+\r
+\r
+ {########################################################}\r
+\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
+ seguir, { indicador para saber si sigue corriendo el programa }\r
+ noNulo, { indicador para saber si en la division el divisor es nulo }\r
+ continua: boolean; { indicador para saber si se leyeron bien los polinomios }\r
+ tecla: char; { entrada de teclado del usuario para elegir una opcion }\r
+\r
+begin { programa principal }\r
+ textbackground( Blue ); { establece el color para el fondo a azul }\r
+ continua := cargarVectores(v1, v2); { carga los vectores del archivo de datos }\r
+ if continua then { si se leyeron bien ... }\r
+ begin\r
+ seguir := true; { inicializa la variable en true para que entre en el ciclo while }\r
+ while seguir do { mientras el usuario no salga del programa }\r
+ begin\r
+ clrscr; { borra la pantalla }\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ gotoxy( 25, 3 ); { va a las coordenas de pantalla 19 horizontal, 3 verical }\r
+ writeln( 'OPERACIONES ENTRE POLINOMIOS' ); { titulo }\r
+ gotoxy( 25, 4 ); { va a las coordenas de pantalla 19 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor(LightCyan); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ writeln( ' Elija que desea hacer:' ); { mensaje }\r
+ writeln( ' ----- --- ----- ------' ); { mensaje }\r
+ textcolor(LightGray); { establece el color para el texto a gris claro }\r
+ writeln; { mensaje con las opciones ... }\r
+ writeln;\r
+ writeln( ' 1.- Ver el polinomio 1.' );\r
+ writeln( ' 2.- Ver el polinomio 2.' );\r
+ writeln( ' 3.- Sumar los polinomios.' );\r
+ writeln( ' 4.- Restar el polinomio 2 al polinomio 1 (poli1 - poli2).' );\r
+ writeln( ' 5.- Restar el polinomio 1 al polinomio 2 (poli2 - poli1).' );\r
+ writeln( ' 6.- Multiplicar los polinomios.' );\r
+ writeln( ' 7.- Polinomio 1 dividido polinomio 2 (poli1 / poli2).' );\r
+ writeln( ' 8.- Polinomio 2 dividido polinomio 1 (poli2 / poli1).' );\r
+ writeln( ' 0.- Salir.' );\r
+ gotoxy(1, 23); { va a las coordenas de pantalla 1 horizontal, 23 verical }\r
+ textcolor(White ); { establece el color para el texto a blanco }\r
+ write(' Ingrese su opci¢n: ');\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ tecla := readkey; { lee una tecla del usuario indicando la opcion que elijio }\r
+ while ((tecla < '1') or (tecla > '8')) and (tecla <> '0') do { mientras sea una tecla no admitida }\r
+ begin\r
+ textcolor(White); { establece el color para el texto a blanco }\r
+ gotoxy( 1, 23 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ write(' Ingrese su opci¢n ("1" a "8" o "0"): ' );\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ tecla := readkey; { lee una tecla del usuario indicando la opcion que elijio }\r
+ end; { while }\r
+ if tecla = '0' then { si la opcion fue salir del programa ... }\r
+ begin\r
+ mensajeSalida; { presenta un mensaje de salida }\r
+ exit; { sale del programa }\r
+ end;\r
+ clrscr; { borra la pantalla }\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ gotoxy(19, 3); { va a las coordenas de pantalla 19 horizontal, 3 verical }\r
+ writeln( 'OPERACIONES ENTRE POLINOMIOS'); { titulo }\r
+ gotoxy(19, 4); { va a las coordenas de pantalla 19 horizontal, 4 verical }\r
+ writeln('~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~'); { subrayado del titulo }\r
+ textcolor(LightCyan); { establece el color para el texto a cian claro }\r
+ gotoxy(1, 7); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ case tecla of\r
+ '1': muestraVector(v1, ' Polinomio 1 = ');\r
+ '2': muestraVector(v2, ' Polinomio 2 = ');\r
+ '3': begin\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 + Polinomio 2 = ');\r
+ end; { case 3 }\r
+ '4': begin\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 - Polinomio 2 = ');\r
+ end; { case 4 }\r
+ '5': begin\r
+ resta(v2, v1, vResult);\r
+ muestraVector(vResult, ' Polinomio 2 - Polinomio 1 = ');\r
+ end; { case 5 }\r
+ '6': begin\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 * Polinomio 2 = ');\r
+ end; { case 6 }\r
+ '7': begin\r
+ noNulo := division(v1, v2, vResult, vResto);\r
+ if noNulo\r
+ then\r
+ begin\r
+ muestraVector(vResult, ' Polinomio 1 / Polinomio 2 = ');\r
+ muestraVector(vResto, ' Resto = ');\r
+ end\r
+ else writeln(' El polinomio 2 es nulo, por lo tanto no se puede efectuar la division.');\r
+ end; { case 7 }\r
+ '8': begin\r
+ noNulo := division(v2, v1, vResult, vResto);\r
+ if noNulo\r
+ then\r
+ begin\r
+ muestraVector(vResult, 'Polinomio 2 / Polinomio 1 = ');\r
+ muestraVector(vResto, 'Resto = ');\r
+ end\r
+ else writeln(' El polinomio 1 es nulo, por lo tanto no se puede efectuar la division.');\r
+ end; { case 8 }\r
+ '0': ; { no hace nada, nunca deberia entrar en este case }\r
+ end; { case }\r
+ writeln; { los siguientes mensajes son para que el usuario pueda ver los datos y luego }\r
+ writeln; { presione una tecla para continuar }\r
+ textcolor(white); { pone el color del texto en blanco }\r
+ writeln(' Presione una tecla para continuar ...');\r
+ tecla := readkey;\r
+ end; { while }\r
+ end\r
+ else { si los vectores no se leyeron bien ... }\r
+ begin { presenta un mensaje de error }\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end. { procedure menuGenerar }
\ No newline at end of file
--- /dev/null
+program PolinomiosEnTermino;\r
+{ Programa que lee 2 polinomios desde un archivo de texto para luego\r
+ hacer operaciones basicas entre estos (suma, resta, multiplicacion\r
+ y division).\r
+ El formato del archivo de texto debe ser de la siguiente manera:\r
+\r
+ * Se ingresan cada polinomio en lineas sucesivas.\r
+ * El primer polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto.\r
+ * El fin del primer polinomio (y comienzo del segundo) se indica por\r
+ medio de 1 o mas lineas en blanco.\r
+ * El segundo polinomio puede comenzar a ingresarse en cualquier lugar\r
+ del archivo de texto a partir de dicha(s) linea(s) en blanco.\r
+ * Cada termino de un polinomio debe estar en la misma linea y comenzar\r
+ al principio de esta (excepto el primer termino).\r
+ * Los terminos debes estar ordenados de menor a mayor segun el exponente.\r
+ * En cada linea se ingresa primero el coeficiente real (puede tener un\r
+ signo '-' al comenzar y/o un punto, y solamente uno) y luego el\r
+ exponente entero positivo.\r
+ * La separacion entre el coeficiente y el exponente debe estar dada por\r
+ uno o mas espacios o tabuladores.\r
+ * Cualquier caracter incluido en el texto que no sea un degito (0..9),\r
+ un punto ('.'), un signo menos ('-'), un espacio (' '), un tabulador\r
+ o alguno de los caracteres de nueva linea, dara un error en la\r
+ lectura.\r
+ * El archivo de texto debe tener formato DOS (es decir, el indicador de\r
+ nueva linea debe ser primero un caracter de retorno del carro\r
+ seguido inmediatamente por uno de avance de linea).\r
+}\r
+\r
+uses\r
+ CRT, DOS; { Declaracion de funciones predefinidas\r
+ para crear la interfaz grafica }\r
+\r
+const\r
+ VERSION = '1.2.2r (TERM_5)'; { version del programa }\r
+\r
+ TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
+ la multiplicacion de polinomios }\r
+ TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
+ los vector con los que se va a operar }\r
+ CR = chr(13); { caracter de retorno del carro }\r
+ LF = chr(10); { caracter de nueva linea }\r
+ ENDF = chr(26); { caracter de fin del archivo }\r
+ TAB = chr(9); { caracter de tabulacion }\r
+ SPACE = chr(32); { caracter de espacio }\r
+\r
+type\r
+ { Tipo de dato para identificar el estado de la entrada de datos }\r
+ Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
+ Termino = record { tipo de dato que representa un termino de un polinomio }\r
+ coef: real; { parte del coeficiente del termino }\r
+ exp: integer; { parte del exponente del termino }\r
+ end; { Termino }\r
+ Vector = array [0..TAM_MAX-1] of Termino; { vector para almacenar los polinomios }\r
+\r
+\r
+ {########################################################}\r
+\r
+ procedure muestraVector(var v: Vector; s: String);\r
+ { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
+\r
+ {########################################################}\r
+\r
+ function exponente(exp: integer): String;\r
+\r
+ var\r
+ s: String; { variable temporal }\r
+\r
+ begin { exponente }\r
+ case exp of\r
+ 0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
+ 1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
+ 2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
+ else begin\r
+ str(exp, s); { convierte al exponente en string }\r
+ exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
+ end; { else }\r
+ end; { case }\r
+ end; { exponente }\r
+\r
+ {########################################################}\r
+\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { muestraVector }\r
+ textcolor(lightcyan); { pone el color del texto en cian claro }\r
+ writeln; { separacion de una linea }\r
+ write(s); { mustra el mensaje }\r
+ textcolor(lightmagenta); { pone el color del texto en magenta claro }\r
+ for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i].coef <> 0 then break; { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ if (v[i].exp = 0) and (v[i].coef = 0) then { si el primer exponente que encuentra es 0 y el coeficiente es 0, entonces }\r
+ begin { muestra el resultado como 0 y sale del procedimiento }\r
+ write('0'); { imprime que el resultado es cero }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ exit; { sale de este procedimiento }\r
+ end;\r
+ if (abs(v[i].coef) <> 1) or (v[i].exp = 0) { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ then if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0 then write(trunc(v[i].coef):1, ' ') {imprime si es un numero entero}\r
+ else write(v[i].coef:1:2, ' ') { imprime si es un numero real }\r
+ else if v[i].coef = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
+ write(exponente(v[i].exp));\r
+ for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
+ if v[i].coef <> 0 then { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
+ begin\r
+ if v[i].coef < 0 { si el coeficiente en negativo }\r
+ then write(' - ') { le agrega el signo - }\r
+ else write(' + '); { si no, le agrega el signo + }\r
+ if (abs(v[i].coef) <> 1) or (i = 0) then { si el modulo del coeficiente es distinto de 1 o si el exp. es 0 }\r
+ if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0\r
+ then write(trunc(abs(v[i].coef)):1, ' ') { imprime si es entero }\r
+ else write(abs(v[i].coef):1:2, ' '); { imprime si es un real }\r
+ write(exponente(v[i].exp));\r
+ end; { if }\r
+ writeln; { separacion de una linea }\r
+ writeln; { separacion de una linea }\r
+ end; { muestraVector }\r
+\r
+ {########################################################}\r
+\r
+ procedure inicializaVector(var v: Vector);\r
+ { procedimiento que inicializa un vector de tama¤o tam }\r
+\r
+ var i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { inicializaVector }\r
+ for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
+ begin\r
+ v[i].coef := 0.0; { inicializa la variable actual en 0 }\r
+ v[i].exp := 0; { inicializa la variable actual en 0 }\r
+ end;\r
+ end; { inicializaVector }\r
+\r
+ {########################################################}\r
+\r
+ function ObtenerNombreArchivo: String;\r
+ { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
+ de un archivo que exista) }\r
+\r
+ {########################################################}\r
+\r
+ function fileExists(FileName: String): Boolean;\r
+ { funcion extraida de la ayuda del Turbo Pascal 7\r
+ indica si el archivo existe }\r
+\r
+ var\r
+ F: file;\r
+\r
+ begin\r
+ {$I-}\r
+ Assign(F, FileName);\r
+ FileMode := 0; { Set file access to read only }\r
+ Reset(F);\r
+ Close(F);\r
+ {$I+}\r
+ FileExists := (IOResult = 0) and (FileName <> '');\r
+ end; { FileExists }\r
+\r
+ {########################################################}\r
+\r
+ { Continuacion de la funcion ObtenerNombreArchivo }\r
+ const\r
+ DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
+\r
+ var\r
+ tmp: String; { cadena para almacenar el resultado temporal }\r
+\r
+ begin { ObtenerNombreArchivo }\r
+ { mensaje para entrada del nombre de archivo }\r
+ clrscr; { borra la pantalla }\r
+ textcolor( Yellow ); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnTermino' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ writeln(' Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
+ readln(tmp); { entrada del nombre de archivo }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
+ while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
+ begin\r
+ clrscr; { borra la pantalla }\r
+ textcolor( Yellow ); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnTermino' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ write(' El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
+ if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
+ then { entonces, elije un mensaje apropiado }\r
+ write(': ')\r
+ else\r
+ begin { si no es el predeterminado, muestra otro mensaje }\r
+ writeln('.');\r
+ write(' (ENTER = ', DEFAUL_FILE_NAME, '): ');\r
+ end;\r
+ readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
+ if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
+ si no se escribio nada }\r
+ end; { fin del loop de verificacion }\r
+ ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
+ end; { ObtenerNombreArchivo }\r
+\r
+ {########################################################}\r
+\r
+ function trans(c: char; e: Estado): Estado;\r
+ { establece el estado en el que se encuentra la lectura }\r
+ { c es el caracter que se leyo, e es el estado actual de la lectura }\r
+\r
+ begin { trans }\r
+ case e of { acciona segun es estado actual de la lectura }\r
+ INICIO: { estado de inicio de la lectura }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
+ SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
+ ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
+ else trans := ERROR; { si es otro, da ERROR }\r
+ end;\r
+ COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
+ '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
+ SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
+ else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
+ end;\r
+ COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP_BUSCA: { estado de busqueda del proximo exponente }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
+ SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
+ else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
+ end;\r
+ EXP: { estado de lectura del exponente del termino actual del polinomio }\r
+ case c of { acciona segun el caracter leido }\r
+ '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
+ CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
+ (quiere decir que hubo un <ENTER>) }\r
+ ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
+ if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
+ ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
+ case c of { acciona segun el caracter leido }\r
+ '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
+ CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
+ else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
+ end;\r
+ POLI_FIN: { estado de finalizacion del polinomio actual }\r
+ if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
+ entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
+ else trans := ERROR; { si no lo es, devuelve ERROR }\r
+ FIN: { estado que adquiere cuando se finalizo la tarea }\r
+ trans := FIN; { se queda en este estado avisando que termino su tarea }\r
+ else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
+ trans := ERROR; { si es otro, da ERROR }\r
+ end; { case }\r
+ end; { trans }\r
+\r
+ {########################################################}\r
+\r
+ function cargarVectores(var v1, v2: Vector): boolean;\r
+ { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
+ que lo lee y, al finalizar, cierra el archivo de texto.\r
+ v1 es el primer vector a cargar\r
+ v2 es el segundo vector a cargar\r
+ devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
+\r
+ var\r
+ f: Text; { archivo de texto con los datos }\r
+ c: char; { caracter que se extrae del archivo de texto }\r
+ nombreArchivo: String; { nombre del archivo de datos }\r
+ est: Estado; { Indicador del estado actual de la lectura }\r
+ seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
+ i, { indice del vector del polinomio para ser inicializado }\r
+ iExp, { valor temporal para almacenar al exponente }\r
+ code, { almacena el resultado de la funcion val (no se usa porque los\r
+ datos ya estan validados }\r
+ poliN: integer; { numero del polinomio que se esta leyendo }\r
+ rCoef: real; { valor temporal para almacenar al coeficiente }\r
+ exponente, { string que representa al exponente leido }\r
+ coeficiente: String; { string que representa al coeficiente leido }\r
+\r
+ begin { cargarVectores }\r
+ rCoef := 0.0; { inicializacion de variable }\r
+ iExp := 0; { inicializacion de variable }\r
+ coeficiente := ''; { inicializacion de variable }\r
+ exponente := ''; { inicializacion de variable }\r
+ est := INICIO; { empieza con el estado de INICIO }\r
+ poliN := 1; { establece que se procesara el primer polinomio }\r
+ inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
+ inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
+ nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
+ assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
+ reset(f); { abre el archivo para leerlo desde el principio }\r
+ seguir := true; { inicializa seguir e true para comenzar el bucle }\r
+ while seguir do begin { continua mientras seguir sea true }\r
+ read(f, c); { lee un caracter del archivo de texto }\r
+ est := trans(c, est); { establece el nuevo estado de lectura }\r
+ case est of { toma una desicion dependiendo del estado en que se encuentre }\r
+ INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
+ COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
+ coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
+ de texto del coeficiente }\r
+ COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
+ se realiza cuando termina de leer el exponente (es necesario\r
+ para establecer el indice del vector }\r
+ EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ EXP: { Si esta leyendo el exponente ... }\r
+ exponente := exponente + c; { concatena el caracter a la representacion\r
+ de texto del exponente }\r
+ EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
+ begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 1\r
+ then { si es el polinomio 1 }\r
+ begin\r
+ v1[iExp].coef := rCoef; { asigna el valor correspondiente }\r
+ v1[iExp].exp := iExp; { asigna el valor correspondiente }\r
+ end\r
+ else { si es el polinomio 2 }\r
+ begin\r
+ v2[iExp].coef := rCoef; { asigna el valor correspondiente }\r
+ v2[iExp].exp := iExp; { asigna el valor correspondiente }\r
+ end\r
+ else est := ERROR; { si no es menor, pone el estado en ERROR }\r
+ coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
+ exponente := ''; { exponente para poder realizar las lecturas de los proximos }\r
+ end;\r
+ EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
+ POLI_FIN: { Si termino la lectura de un polinomio ... }\r
+ if poliN = 1 then poliN := 2 { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
+ else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
+ FIN: { Si se finalizaron las tareas ... }\r
+ begin\r
+ cargarVectores := true; { en principio se establece que la lectura se hizo con exito ) }\r
+ seguir := false; { poner seguir en false para que se termine el bucle }\r
+ { este codigo es similar al de EXP_FIN, se hacen las asignaciones por el caso en que el fin\r
+ del archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
+ de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
+ val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
+ val(exponente, iExp, code); { convierte el exponente en integer }\r
+ if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
+ then if poliN = 2\r
+ then { si es el polinomio 2 }\r
+ begin\r
+ v2[iExp].coef := rCoef; { asigna el valor correspondiente }\r
+ v2[iExp].exp := iExp; { asigna el valor correspondiente }\r
+ end\r
+ else cargarVectores := false { si es el primero, no se hizo bien la lectura }\r
+ else cargarVectores := false; { si no es menor, no se hizo bien la lectura }\r
+ end;\r
+ ERROR: { Si hubo un error ... }\r
+ begin\r
+ cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
+ seguir := false; { seguir se pone en false para que termine el bucle }\r
+ end;\r
+ end; { case }\r
+ end; { while }\r
+ close(f); { se cierra el archivo de lectura de datos }\r
+ end; { cargarVectores }\r
+\r
+ {########################################################}\r
+\r
+ procedure suma(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que suma dos polinomios.\r
+ v1: vector que contiene el primer polinomio a sumar\r
+ v2: vector que contiene el segundo polinomio a sumar\r
+ vr: vector donde se almacenara el resultado de la suma }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { suma }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ begin\r
+ vr[i].coef := v1[i].coef + v2[i].coef; { suma los coeficientes de los terminos con igual exponente }\r
+ vr[i].exp := i; { establece como valor del exponente al indice }\r
+ end;\r
+ end; { suma }\r
+\r
+ {########################################################}\r
+\r
+ procedure resta(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que resta dos polinomios.\r
+ v1: vector que contiene el primer polinomio\r
+ v2: vector que contiene el polinomio para restarle al primero\r
+ vr: vector donde se almacenara el resultado de la resta }\r
+\r
+ var\r
+ i: integer; { indice para usar en el ciclo for }\r
+\r
+ begin { resta }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el vector (de tama¤o maximo TAM) }\r
+ begin\r
+ vr[i].coef := v1[i].coef - v2[i].coef; { resta los coeficientes de los terminos con igual exponente }\r
+ vr[i].exp := i; { establece como valor del exponente al indice }\r
+ end;\r
+ end; { resta }\r
+\r
+ {########################################################}\r
+\r
+ procedure producto(v1, v2: Vector; var vr: Vector);\r
+ { procedimiento que multiplica dos polinomios.\r
+ v1: vector que contiene el primer polinomio a multiplicar\r
+ v2: vector que contiene el segundo polinomio a multiplicar\r
+ vr: vector donde se almacenara el resultado de la multiplicacion }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+\r
+ begin { producto }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := 0 to TAM - 1 do { recorre el 1er vector (de tama¤o maximo TAM) }\r
+ for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
+ begin\r
+ vr[i+j].coef := vr[i+j].coef + (v1[i].coef * v2[j].coef);\r
+ { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
+ { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
+ vr[i+j].exp := i+j; { establece como exponente a la suma de los otros dos }\r
+ end;\r
+ end; { producto }\r
+\r
+ {########################################################}\r
+\r
+ function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
+ { procedimiento que divide dos polinomios.\r
+ v1: vector que contiene el polinomio denominador\r
+ v2: vector que contiene el polinomio divisor\r
+ vr: vector donde se almacenara el resultado de la division\r
+ vResto: vector donde se almacenara el resto de la division\r
+ devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
+ devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
+\r
+ var\r
+ i, j: integer; { indices para usar en los ciclos for }\r
+ vRTmp, { vector auxuliares para almacenar el termino actual del resultado }\r
+ vTmp: Vector; { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
+ termino actual del resultado por el divisor }\r
+\r
+ begin { division }\r
+ inicializaVector(vr); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ inicializaVector(vRTmp); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
+ for i := TAM - 1 downto 0 do { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i].coef <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ for j := TAM - 1 downto 0 do { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
+ if v2[j].coef <> 0 then break;\r
+ { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
+ { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
+ if (j = 0) and (v2[j].coef = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
+ then { el polinomio 2 es nulo y no se puede efectuar la division }\r
+ begin { se devuelve false y se quedan los vectores resultado en 0 }\r
+ division := false; { devuelve false }\r
+ exit; { sale del procedimiento }\r
+ end;\r
+ while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
+ begin\r
+ vr[i-j].coef := v1[i].coef / v2[j].coef; { almacena el resultado de la division entre los coeficientes en }\r
+ vr[i-j].exp := v1[i].exp - v2[j].exp; { coeficientes en la posicion de la resta de ambos }\r
+ vRTmp[i-j].coef := vr[i-j].coef; { almacena ese resultado en un polinomio temporal cuyo unico termio }\r
+ vRTmp[i-j].exp := vr[i-j].exp; { no nulo es el del exponente i-j, para luego multiplicarlo }\r
+ producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
+ en otro temporal, para luego hacer la resta }\r
+ resta(v1, vTmp, v1); { resta al primer polinomio, v1, (en su estado actual, no el original)\r
+ el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
+ la misma forma }\r
+ vRTmp[i-j].coef := 0.0; {resetea el coeficiente del termino del temporal vRTmp que se asigno para los calculos}\r
+ vRTmp[i-j].exp := 0; { resetea el exponente del termino del temporal vRTmp que se asigno para los calculos }\r
+ for i := i downto 0 do { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
+ if v1[i].coef <> 0 then break;\r
+ { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
+ si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
+ end; { while }\r
+ vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
+ division := true; { devuelve true indicando que se finalizo con exito }\r
+ end; { division }\r
+\r
+ {########################################################}\r
+\r
+ procedure mensajeSalida; { muestra un mensaje en la salida del programa }\r
+\r
+ begin\r
+ writeln; { linea en blanco }\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ clrscr; { borra la pantalla }\r
+ writeln; { linea en blanco }\r
+ textcolor(white); { cambia el color del texto }\r
+ writeln(' PolinomiosEnTermino versi¢n ', VERSION); { mensaje con version del programa }\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ writeln(' Desarrollado por: JavierGrijalba'); { mensaje con los integrantes del grupo }\r
+ writeln(' Leandro Lucarella');\r
+ writeln(' Erasmo Troncovich');\r
+ writeln(' Diego Wojmicki');\r
+ writeln(' para la Facultad de Ingenier¡a de la Universidad de Buenos Aires.');\r
+ writeln(' Consultas y/o sugerencias a:');\r
+ writeln;\r
+ textcolor(LightMagenta); { cambia el color del texto }\r
+ write(' lluca@cnba.uba.ar');\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ write(' o ');\r
+ textcolor(LightMagenta); { cambia el color del texto }\r
+ writeln('grijalba@cvtci.com.ar');\r
+ NormVideo; { reestablece los colores a los valores por defecto }\r
+ writeln;\r
+ writeln(' (c) 1999 - Todos los derechos reservados.');\r
+ delay(750);\r
+ end;\r
+\r
+\r
+ {########################################################}\r
+\r
+\r
+var\r
+ i: integer; { variable auxiliar }\r
+ v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
+ seguir, { indicador para saber si sigue corriendo el programa }\r
+ noNulo, { indicador para saber si en la division el divisor es nulo }\r
+ continua: boolean; { indicador para saber si se leyeron bien los polinomios }\r
+ tecla: char; { entrada de teclado del usuario para elegir una opcion }\r
+\r
+begin { programa principal }\r
+ textbackground( Blue ); { establece el color para el fondo a azul }\r
+ continua := cargarVectores(v1, v2); { carga los vectores del archivo de datos }\r
+ if continua then { si se leyeron bien ... }\r
+ begin\r
+ seguir := true; { inicializa la variable en true para que entre en el ciclo while }\r
+ while seguir do { mientras el usuario no salga del programa }\r
+ begin\r
+ clrscr; { borra la pantalla }\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnTermino' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor(LightCyan); { establece el color para el texto a cian claro }\r
+ gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ writeln( ' Elija que desea hacer:' ); { mensaje }\r
+ writeln( ' ----- --- ----- ------' ); { mensaje }\r
+ textcolor(LightGray); { establece el color para el texto a gris claro }\r
+ writeln; { mensaje con las opciones ... }\r
+ writeln;\r
+ writeln( ' 1.- Ver el polinomio 1.' );\r
+ writeln( ' 2.- Ver el polinomio 2.' );\r
+ writeln( ' 3.- Sumar los polinomios.' );\r
+ writeln( ' 4.- Restar el polinomio 2 al polinomio 1 (poli1 - poli2).' );\r
+ writeln( ' 5.- Restar el polinomio 1 al polinomio 2 (poli2 - poli1).' );\r
+ writeln( ' 6.- Multiplicar los polinomios.' );\r
+ writeln( ' 7.- Polinomio 1 dividido polinomio 2 (poli1 / poli2).' );\r
+ writeln( ' 8.- Polinomio 2 dividido polinomio 1 (poli2 / poli1).' );\r
+ writeln( ' 0.- Salir.' );\r
+ gotoxy(1, 23); { va a las coordenas de pantalla 1 horizontal, 23 verical }\r
+ textcolor(White ); { establece el color para el texto a blanco }\r
+ write(' Ingrese su opci¢n: ');\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ tecla := readkey; { lee una tecla del usuario indicando la opcion que elijio }\r
+ while ((tecla < '1') or (tecla > '8')) and (tecla <> '0') do { mientras sea una tecla no admitida }\r
+ begin\r
+ textcolor(White); { establece el color para el texto a blanco }\r
+ gotoxy( 1, 23 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ write(' Ingrese su opci¢n ("1" a "8" o "0"): ' );\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ tecla := readkey; { lee una tecla del usuario indicando la opcion que elijio }\r
+ end; { while }\r
+ if tecla = '0' then { si la opcion fue salir del programa ... }\r
+ begin\r
+ mensajeSalida; { presenta un mensaje de salida }\r
+ exit; { sale del programa }\r
+ end;\r
+ clrscr; { borra la pantalla }\r
+ textcolor(Yellow); { establece el color para el texto a amarillo }\r
+ gotoxy( 30, 3 ); { va a las coordenas de pantalla 25 horizontal, 3 verical }\r
+ writeln( 'PolinomiosEnTermino' ); { titulo }\r
+ gotoxy( 30, 4 ); { va a las coordenas de pantalla 25 horizontal, 4 verical }\r
+ writeln( '~~~~~~~~~~~~~~~~~~~' ); { subrayado del titulo }\r
+ textcolor(LightCyan); { establece el color para el texto a cian claro }\r
+ gotoxy(1, 7); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
+ case tecla of\r
+ '1': muestraVector(v1, ' Polinomio 1 = ');\r
+ '2': muestraVector(v2, ' Polinomio 2 = ');\r
+ '3': begin\r
+ suma(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 + Polinomio 2 = ');\r
+ end; { case 3 }\r
+ '4': begin\r
+ resta(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 - Polinomio 2 = ');\r
+ end; { case 4 }\r
+ '5': begin\r
+ resta(v2, v1, vResult);\r
+ muestraVector(vResult, ' Polinomio 2 - Polinomio 1 = ');\r
+ end; { case 5 }\r
+ '6': begin\r
+ producto(v1, v2, vResult);\r
+ muestraVector(vResult, ' Polinomio 1 * Polinomio 2 = ');\r
+ end; { case 6 }\r
+ '7': begin\r
+ noNulo := division(v1, v2, vResult, vResto);\r
+ if noNulo\r
+ then\r
+ begin\r
+ muestraVector(vResult, ' Polinomio 1 / Polinomio 2 = ');\r
+ muestraVector(vResto, ' Resto = ');\r
+ end\r
+ else writeln(' El polinomio 2 es nulo, por lo tanto no se puede efectuar la division.');\r
+ end; { case 7 }\r
+ '8': begin\r
+ noNulo := division(v2, v1, vResult, vResto);\r
+ if noNulo\r
+ then\r
+ begin\r
+ muestraVector(vResult, 'Polinomio 2 / Polinomio 1 = ');\r
+ muestraVector(vResto, 'Resto = ');\r
+ end\r
+ else writeln(' El polinomio 1 es nulo, por lo tanto no se puede efectuar la division.');\r
+ end; { case 8 }\r
+ '0': ; { no hace nada, nunca deberia entrar en este case }\r
+ end; { case }\r
+ writeln; { los siguientes mensajes son para que el usuario pueda ver los datos y luego }\r
+ writeln; { presione una tecla para continuar }\r
+ textcolor(white); { pone el color del texto en blanco }\r
+ writeln(' Presione una tecla para continuar ...');\r
+ tecla := readkey;\r
+ end; { while }\r
+ end\r
+ else { si los vectores no se leyeron bien ... }\r
+ begin { presenta un mensaje de error }\r
+ writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
+ writeln(' sea correcto y que no este siendo usado por otro programa.');\r
+ end;\r
+end. { procedure menuGenerar }
\ No newline at end of file
projects / z.facultad / 75.40 / 2do-cuat / polinomios.git / commitdiff