term_2.pas

   1 program PolinomiosEnTermino;\r
   2 { Programa que lee 2 polinomios desde un archivo de texto para luego\r
   3   hacer operaciones basicas entre estos (suma, resta, multiplicacion\r
   4   y division).\r
   5   El formato del archivo de texto debe ser de la siguiente manera:\r
   6 \r
   7    * Se ingresan cada polinomio en lineas sucesivas.\r
   8    * El primer polinomio puede comenzar a ingresarse en cualquier lugar\r
   9         del archivo de texto.\r
  10    * El fin del primer polinomio (y comienzo del segundo) se indica por\r
  11         medio de 1 o mas lineas en blanco.\r
  12    * El segundo polinomio puede comenzar a ingresarse en cualquier lugar\r
  13         del archivo de texto a partir de dicha(s) linea(s) en blanco.\r
  14    * Cada termino de un polinomio debe estar en la misma linea y comenzar\r
  15         al principio de esta (excepto el primer termino).\r
  16    * Los terminos debes estar ordenados de menor a mayor segun el exponente.\r
  17    * En cada linea se ingresa primero el coeficiente real (puede tener un\r
  18         signo '-' al comenzar y/o un punto, y solamente uno) y luego el\r
  19         exponente entero positivo.\r
  20    * La separacion entre el coeficiente y el exponente debe estar dada por\r
  21         uno o mas espacios o tabuladores.\r
  22    * Cualquier caracter incluido en el texto que no sea un degito (0..9),\r
  23         un punto ('.'), un signo menos ('-'), un espacio (' '), un tabulador\r
  24         o alguno de los caracteres de nueva linea, dara un error en la\r
  25         lectura.\r
  26    * El archivo de texto debe tener formato DOS (es decir, el indicador de\r
  27         nueva linea debe ser primero un caracter de retorno del carro\r
  28         seguido inmediatamente por uno de avance de linea).\r
  29 }\r
  30 \r
  31 uses\r
  32     CRT, DOS; { Declaracion de funciones predefinidas\r
  33                 para crear la interfaz grafica }\r
  34 \r
  35 const\r
  36      VERSION = '0.2.0a (TERM_2)'; { version del programa }\r
  37 \r
  38      TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
  39                       la multiplicacion de polinomios }\r
  40      TAM = TAM_MAX div 2; { Tama¤o maximo (virtual) del vector que contiene\r
  41                             los vector con los que se va a operar }\r
  42      CR = chr(13); { caracter de retorno del carro }\r
  43      LF = chr(10); { caracter de nueva linea }\r
  44      ENDF = chr(26); { caracter de fin del archivo }\r
  45      TAB = chr(9); { caracter de tabulacion }\r
  46      SPACE = chr(32); { caracter de espacio }\r
  47 \r
  48 type\r
  49     { Tipo de dato para identificar el estado de la entrada de datos }\r
  50     Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
  51     Termino = record\r
  52                     coef: real;\r
  53                     exp: integer;\r
  54               end;\r
  55     Vector = array [0..TAM_MAX-1] of Termino; { vector para almacenar los polinomios }\r
  56 \r
  57 \r
  58   {########################################################}\r
  59 \r
  60   procedure muestraVector(var v: Vector; s: String);\r
  61   { procedimiento que imprime el polinomio v en pantalla con un titulo s }\r
  62 \r
  63      {########################################################}\r
  64 \r
  65      function exponente(exp: integer): String;\r
  66 \r
  67      var\r
  68         s: String; { variable temporal }\r
  69 \r
  70      begin { exponente }\r
  71           case exp of\r
  72                0: exponente := ''; { si el exponente es nulo, mustra solo el coeficiente }\r
  73                1: exponente := 'X'; { si el exponente es 1, mustra el coeficiente y X }\r
  74                2: exponente := 'Xý'; { si el exponente es 2, mustra el coeficiente y Xý }\r
  75                else begin\r
  76                          str(exp, s); { convierte al exponente en string }\r
  77                          exponente := 'X^' + s; { si el exponente es mayor que 1, mustra el coeficiente y X^exp }\r
  78                end; { else }\r
  79           end; { case }\r
  80      end; { exponente }\r
  81 \r
  82      {########################################################}\r
  83 \r
  84 \r
  85   var\r
  86      i: integer; { indice para usar en el ciclo for }\r
  87 \r
  88   begin { muestraVector }\r
  89      writeln;    { separacion de una linea }\r
  90      write(s); { mustra el mensaje }\r
  91      for i := TAM_MAX - 1 downto 0 do { recorre el vector de atras para adelante }\r
  92             if v[i].coef <> 0 then break;  { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
  93      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
  94         begin                         { muestra el resultado como 0 y sale del procedimiento }\r
  95              write('0'); { imprime que el resultado es cero }\r
  96              writeln;    { separacion de una linea }\r
  97              writeln;    { separacion de una linea }\r
  98              exit;       { sale de este procedimiento }\r
  99         end;\r
 100      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
 101         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
 102                                                  else write(v[i].coef:1:2, ' ')      { imprime si es un numero real }\r
 103         else if v[i].coef = -1 then write('-'); { si es -1 entonces solo escribe el signo del termino }\r
 104      write(exponente(v[i].exp));\r
 105      for i := i - 1 downto 0 do { recorre el vector de atras para adelante }\r
 106          if v[i].coef <> 0 then  { si el coeficiente no es nulo, termina el for dejando a i en ese indice }\r
 107               begin\r
 108                    if v[i].coef < 0 { si el coeficiente en negativo }\r
 109                       then write(' - ')  { le agrega el signo - }\r
 110                       else write(' + '); { si no, le agrega el signo + }\r
 111                    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
 112                       if abs(v[i].coef) - trunc(abs(v[i].coef)) = 0\r
 113                          then write(trunc(abs(v[i].coef)):1, ' ') { imprime si es entero }\r
 114                          else write(abs(v[i].coef):1:2, ' ');     { imprime si es un real }\r
 115                    write(exponente(v[i].exp));\r
 116               end; { if }\r
 117      writeln;    { separacion de una linea }\r
 118      writeln;    { separacion de una linea }\r
 119   end; { muestraVector }\r
 120 \r
 121   {########################################################}\r
 122 \r
 123   procedure inicializaVector(var v: Vector);\r
 124   { procedimiento que inicializa un vector de tama¤o tam }\r
 125 \r
 126   var i: integer; { indice para usar en el ciclo for }\r
 127 \r
 128   begin { inicializaVector }\r
 129        for i := 0 to TAM_MAX - 1 do { recorre el vector }\r
 130          begin\r
 131            v[i].coef := 0.0;        { inicializa la variable actual en 0 }\r
 132            v[i].exp := 0;           { inicializa la variable actual en 0 }\r
 133          end;\r
 134   end; { inicializaVector }\r
 135 \r
 136   {########################################################}\r
 137 \r
 138   function ObtenerNombreArchivo: String;\r
 139   { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
 140     de un archivo que exista) }\r
 141 \r
 142     {########################################################}\r
 143 \r
 144     function fileExists(FileName: String): Boolean;\r
 145     { funcion extraida de la ayuda del Turbo Pascal 7\r
 146       indica si el archivo existe }\r
 147 \r
 148       var\r
 149          F: file;\r
 150 \r
 151       begin\r
 152            {$I-}\r
 153            Assign(F, FileName);\r
 154            FileMode := 0;  { Set file access to read only }\r
 155            Reset(F);\r
 156            Close(F);\r
 157            {$I+}\r
 158            FileExists := (IOResult = 0) and (FileName <> '');\r
 159       end;  { FileExists }\r
 160 \r
 161     {########################################################}\r
 162 \r
 163     { Continuacion de la funcion ObtenerNombreArchivo }\r
 164     const\r
 165          DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
 166 \r
 167     var\r
 168        tmp: String; { cadena para almacenar el resultado temporal }\r
 169 \r
 170     begin { ObtenerNombreArchivo }\r
 171          { mensaje para entrada del nombre de archivo }\r
 172          writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
 173          readln(tmp); { entrada del nombre de archivo }\r
 174          if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
 175          while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
 176            begin\r
 177                 write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
 178                 if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
 179                    then                   { entonces, elije un mensaje apropiado }\r
 180                        write(': ')\r
 181                    else\r
 182                      begin                { si no es el predeterminado, muestra otro mensaje }\r
 183                           writeln('.');\r
 184                           write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
 185                      end;\r
 186                 readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
 187                 if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
 188                                                             si no se escribio nada }\r
 189            end; { fin del loop de verificacion }\r
 190          ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
 191     end; { ObtenerNombreArchivo }\r
 192 \r
 193     {########################################################}\r
 194 \r
 195     function trans(c: char; e: Estado): Estado;\r
 196     { establece el estado en el que se encuentra la lectura }\r
 197     { c es el caracter que se leyo, e es el estado actual de la lectura }\r
 198 \r
 199     begin { trans }\r
 200          case e of { acciona segun es estado actual de la lectura }\r
 201               INICIO: { estado de inicio de la lectura }\r
 202                      case c of { acciona segun el caracter leido }\r
 203                          '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
 204                          SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
 205                          else trans := ERROR; { si es otro, da ERROR }\r
 206                      end;\r
 207               COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
 208                      case c of { acciona segun el caracter leido }\r
 209                          '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
 210                          SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
 211                          ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
 212                          else trans := ERROR; { si es otro, da ERROR }\r
 213                      end;\r
 214               COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
 215                    case c of { acciona segun el caracter leido }\r
 216                         '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
 217                         '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
 218                         SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
 219                         else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
 220                    end;\r
 221               COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
 222                    case c of { acciona segun el caracter leido }\r
 223                         '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
 224                         SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
 225                         else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
 226                    end;\r
 227               COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
 228                        case c of { acciona segun el caracter leido }\r
 229                            '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
 230                            SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
 231                            else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
 232                        end;\r
 233               EXP_BUSCA: { estado de busqueda del proximo exponente }\r
 234                        case c of { acciona segun el caracter leido }\r
 235                            '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
 236                            SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
 237                            else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
 238                        end;\r
 239               EXP: { estado de lectura del exponente del termino actual del polinomio }\r
 240                   case c of { acciona segun el caracter leido }\r
 241                        '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
 242                        CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
 243                                                (quiere decir que hubo un <ENTER>) }\r
 244                        ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
 245                        else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
 246                   end;\r
 247               EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
 248                       if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
 249                                 else trans := ERROR; { si no lo es, devuelve ERROR }\r
 250               EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
 251                                ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
 252                       case c of { acciona segun el caracter leido }\r
 253                            '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
 254                            CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
 255                            else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
 256                       end;\r
 257               POLI_FIN: { estado de finalizacion del polinomio actual }\r
 258                       if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
 259                                                            entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
 260                                 else trans := ERROR; { si no lo es, devuelve ERROR }\r
 261               FIN: { estado que adquiere cuando se finalizo la tarea }\r
 262                   trans := FIN; { se queda en este estado avisando que termino su tarea }\r
 263               else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
 264                   trans := ERROR; { si es otro, da ERROR }\r
 265          end; { case }\r
 266     end; { trans }\r
 267 \r
 268     {########################################################}\r
 269 \r
 270     function cargarVectores(var v1, v2: Vector): boolean;\r
 271     { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
 272       que lo lee y, al finalizar, cierra el archivo de texto.\r
 273       v1 es el primer vector a cargar\r
 274       v2 es el segundo vector a cargar\r
 275       devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
 276 \r
 277     var\r
 278        f: Text; { archivo de texto con los datos }\r
 279        c: char; { caracter que se extrae del archivo de texto }\r
 280        nombreArchivo: String; { nombre del archivo de datos }\r
 281        est: Estado; { Indicador del estado actual de la lectura }\r
 282        asignado,    { indicador para saber si ya se asigno el valor al termino actual }\r
 283        seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
 284        i, { indice del vector del polinomio para ser inicializado }\r
 285        iExp, { valor temporal para almacenar al exponente }\r
 286        code, { almacena el resultado de la funcion val (no se usa porque los\r
 287                datos ya estan validados }\r
 288        n, { numero de termino del polinomio actual }\r
 289        poliN: integer; { numero del polinomio que se esta leyendo }\r
 290        rCoef: real; { valor temporal para almacenar al coeficiente }\r
 291        exponente, { string que representa al exponente leido }\r
 292        coeficiente: String; { string que representa al coeficiente leido }\r
 293 \r
 294     begin { cargarVectores }\r
 295          asignado := false;    { inicializacion de variable }\r
 296          n := -1;              { inicializacion de variable }\r
 297          rCoef := 0.0;         { inicializacion de variable }\r
 298          iExp := 0;            { inicializacion de variable }\r
 299          coeficiente := '';    { inicializacion de variable }\r
 300          exponente := '';      { inicializacion de variable }\r
 301          est := INICIO;        { empieza con el estado de INICIO }\r
 302          poliN := 1;           { establece que se procesara el primer polinomio }\r
 303          inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
 304          inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
 305          nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
 306          assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
 307          reset(f); { abre el archivo para leerlo desde el principio }\r
 308          seguir := true; { inicializa seguir e true para comenzar el bucle }\r
 309          while seguir do begin { continua mientras seguir sea true }\r
 310            read(f, c); { lee un caracter del archivo de texto }\r
 311            est := trans(c, est); { establece el nuevo estado de lectura }\r
 312            case est of { toma una desicion dependiendo del estado en que se encuentre }\r
 313                 INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
 314                 COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
 315                 COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
 316                    coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
 317                                                      de texto del coeficiente }\r
 318                 COEF_FIN: { Si termino de leer el coeficiente ... }\r
 319                    begin\r
 320                         n := n + 1; { incrementa el termino en uno }\r
 321                         asignado := false; { se indica que no esta asignado todavia. }\r
 322                          { Se elije este estado para indicar esto (e incrementar el termino) porque siempre que\r
 323                            finalize bien el polinomio se pasa por \82l (no pasa lo mismo con EXP_FIN).\r
 324                            La asignacion se realiza cuando termina de leer el exponente }\r
 325                    end;\r
 326                 EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
 327                 EXP: { Si esta leyendo el exponente ... }\r
 328                    exponente := exponente + c; { concatena el caracter a la representacion\r
 329                                                  de texto del exponente }\r
 330                 EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
 331                         begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
 332                              val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
 333                              val(exponente, iExp, code); { convierte el exponente en integer }\r
 334                              if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
 335                                 then if poliN = 1 then\r
 336                                                     begin\r
 337                                                          v1[n].coef := rCoef; { asigna el valor correspondiente }\r
 338                                                          v1[n].exp := iExp; { asigna el valor correspondiente }\r
 339                                                          asignado := true; { se indica que se hizo la asignacion.\r
 340                                                          esto solo tiene sentido si el archivo finaliza justo despues\r
 341                                                          de leer el ultimo exponente (no pasa po este estado y asignado\r
 342                                                          queda en false, avisandole a FIN que debe hacer la asignacion }\r
 343                                                     end\r
 344                                                   else\r
 345                                                     begin\r
 346                                                          v2[n].coef := rCoef; { asigna el valor correspondiente }\r
 347                                                          v2[n].exp := iExp; { asigna el valor correspondiente }\r
 348                                                          asignado := true; { se indica que se hizo la asignacion.\r
 349                                                          esto solo tiene sentido si el archivo finaliza justo despues\r
 350                                                          de leer el ultimo exponente (no pasa po este estado y asignado\r
 351                                                          queda en false, avisandole a FIN que debe hacer la asignacion }\r
 352                                                     end\r
 353                                 else est := ERROR; { si no es menor, pone el estado en ERROR }\r
 354                              coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
 355                              exponente := '';   { exponente para poder realizar las lecturas de los proximos }\r
 356                         end;\r
 357                 EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
 358                 POLI_FIN: { Si termino la lectura de un polinomio ... }\r
 359                          if poliN = 1 then\r
 360                                         begin\r
 361                                              poliN := 2; { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
 362                                              n := -1; { empieza por el primer termino (vale n = 0 al pasar por COEF_FIN) }\r
 363                                         end\r
 364                                       else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
 365                 FIN: { Si se finalizaron las tareas ... }\r
 366                     begin\r
 367                          cargarVectores := true; { en principio se establece que la lectura se hizo con exito ) }\r
 368                          seguir := false; { poner seguir en false para que se termine el bucle }\r
 369                          { este codigo es similar al de EXP_FIN, se hacen las asignaciones por el caso en que el fin\r
 370                            del archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
 371                            de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
 372                          if poliN <> 2 { si no se leyeron ambos polinomios ... }\r
 373                             then\r
 374                                 cargarVectores := false { devuelve false (no se realizo con exito la lectura }\r
 375                             else { si se leyeron ambos polinomios ... }\r
 376                                 if not asignado then { si no se pudo hacer la asignacion ... }\r
 377                                                      { esto solo tiene sentido si el archivo finaliza justo despues\r
 378                                                        de leer el ultimo exponente (no pasa por el estado FIN_EXP y\r
 379                                                        FIN debe hacer la asignacion }\r
 380                                    begin\r
 381                                         val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
 382                                         val(exponente, iExp, code); { convierte el exponente en integer }\r
 383                                         if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
 384                                            then\r
 385                                                begin\r
 386                                                     v2[n].coef := rCoef; { asigna el valor correspondiente }\r
 387                                                     v2[n].exp := iExp; { asigna el valor correspondiente }\r
 388                                                end\r
 389                                            else\r
 390                                                cargarVectores := false; { si no es menor, no se hizo bien la lectura }\r
 391                                    end; { if not asignado }\r
 392                     end; { FIN: }\r
 393                 ERROR:  { Si hubo un error ... }\r
 394                    begin\r
 395                         cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
 396                         seguir := false; { seguir se pone en false para que termine el bucle }\r
 397                    end;\r
 398            end; { case }\r
 399          end; { while }\r
 400          close(f); { se cierra el archivo de lectura de datos }\r
 401     end; { cargarVectores }\r
 402 \r
 403     {########################################################}\r
 404 \r
 405     {########################################################}\r
 406 \r
 407 { Continuacion del programa principal }\r
 408 \r
 409 var\r
 410    i: integer; { variable auxiliar }\r
 411    v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
 412    continua: boolean; { valor para obtener los resultados de algunas funciones }\r
 413 \r
 414 begin { Comienzo del programa principal }\r
 415      continua := cargarVectores(v1, v2);\r
 416      if continua then\r
 417         begin\r
 418           muestraVector(v1, 'Polinomio 1 = ');\r
 419           muestraVector(v2, 'Polinomio 2 = ');\r
 420 {DEBUG}   for i := 0 to 10 do {}\r
 421 {DEBUG}       writeln(v1[i].coef, ' X^', v1[i].exp, ' | ', v2[i].coef, ' X^', v2[i].exp); {}\r
 422 {          suma(v1, v2, vResult);\r
 423           muestraVector(vResult, 'Polinomio 1 + Polinomio 2 = ');\r
 424           resta(v1, v2, vResult);\r
 425           muestraVector(vResult, 'Polinomio 1 - Polinomio 2 = ');\r
 426           producto(v1, v2, vResult);\r
 427           muestraVector(vResult, 'Polinomio 1 * Polinomio 2 = ');\r
 428           continua := division(v1, v2, vResult, vResto);\r
 429           if continua\r
 430              then\r
 431                begin\r
 432                     muestraVector(vResult, 'Polinomio 1 / Polinomio 2 = ');\r
 433                     muestraVector(vResto, 'Resto = ');\r
 434                end\r
 435              else writeln('El segundo polinomio es nulo, por lo tanto no se puede efectuar la division');\r
 436 }        end\r
 437      else\r
 438         begin\r
 439           writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
 440           writeln('       sea correcto y que no este siendo usado por otro programa.');\r
 441         end;\r
 442 end.