poli_11.pas

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