poli_9.pas

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