poli_10.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.1r (POLI_10)'; { 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                          { este codigo es el mismo que el de EXP_FIN, se repite aca solo por si el final del\r
 330                            archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
 331                            de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\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 v1[iExp] := rCoef { asigna el valor correspondiente }\r
 336                                               else v2[iExp] := rCoef { al polinomio correspondiente }\r
 337                             else est := ERROR; { si no es menor, pone el estado en ERROR }\r
 338                          coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
 339                          exponente := '';   { exponente para poder realizar las lecturas de los proximos }\r
 340                          { fin del codigo identico a EXP_FIN }\r
 341                          if poliN = 2 then cargarVectores := true { si se leyeron los 2 polinomios, devuelve true }\r
 342                                       else cargarVectores := false; { si no se leyeron los dos, devuelve false }\r
 343                          seguir := false; { poner seguir en false para que se termine el bucle }\r
 344                     end;\r
 345                 ERROR:  { Si hubo un error ... }\r
 346                    begin\r
 347                         cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
 348                         seguir := false; { seguir se pone en false para que termine el bucle }\r
 349                    end;\r
 350            end; { case }\r
 351          end; { while }\r
 352          close(f); { se cierra el archivo de lectura de datos }\r
 353     end; { cargarVectores }\r
 354 \r
 355     {########################################################}\r
 356 \r
 357     procedure suma(v1, v2: Vector; var vr: Vector);\r
 358     { procedimiento que suma dos polinomios.\r
 359       v1: vector que contiene el primer polinomio a sumar\r
 360       v2: vector que contiene el segundo polinomio a sumar\r
 361       vr: vector donde se almacenara el resultado de la suma }\r
 362 \r
 363     var\r
 364        i: integer; { indice para usar en el ciclo for }\r
 365 \r
 366     begin { suma }\r
 367          inicializaVector(vr);        { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 368          for i := 0 to TAM - 1 do     { recorre el vector (de tama¤o maximo TAM) }\r
 369              vr[i] := v1[i] + v2[i];  { suma los coeficientes de los terminos con igual exponente }\r
 370     end; { suma }\r
 371 \r
 372     {########################################################}\r
 373 \r
 374     procedure resta(v1, v2: Vector; var vr: Vector);\r
 375     { procedimiento que resta dos polinomios.\r
 376       v1: vector que contiene el primer polinomio\r
 377       v2: vector que contiene el polinomio para restarle al primero\r
 378       vr: vector donde se almacenara el resultado de la resta }\r
 379 \r
 380     var\r
 381        i: integer; { indice para usar en el ciclo for }\r
 382 \r
 383     begin { resta }\r
 384          inicializaVector(vr);        { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 385          for i := 0 to TAM - 1 do     { recorre el vector (de tama¤o maximo TAM) }\r
 386              vr[i] := v1[i] - v2[i];  { resta los coeficientes de los terminos con igual exponente }\r
 387     end; { resta }\r
 388 \r
 389     {########################################################}\r
 390 \r
 391     procedure producto(v1, v2: Vector; var vr: Vector);\r
 392     { procedimiento que multiplica dos polinomios.\r
 393       v1: vector que contiene el primer polinomio a multiplicar\r
 394       v2: vector que contiene el segundo polinomio a multiplicar\r
 395       vr: vector donde se almacenara el resultado de la multiplicacion }\r
 396 \r
 397     var\r
 398        i, j: integer; { indices para usar en los ciclos for }\r
 399 \r
 400     begin { producto }\r
 401          inicializaVector(vr);        { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 402          for i := 0 to TAM - 1 do     { recorre el 1er vector (de tama¤o maximo TAM) }\r
 403              for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
 404                  vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
 405                  { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
 406                  { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
 407     end; { producto }\r
 408 \r
 409     {########################################################}\r
 410 \r
 411     function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
 412     { procedimiento que divide dos polinomios.\r
 413       v1: vector que contiene el polinomio denominador\r
 414       v2: vector que contiene el polinomio divisor\r
 415       vr: vector donde se almacenara el resultado de la division\r
 416       vResto: vector donde se almacenara el resto de la division\r
 417       devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
 418       devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
 419 \r
 420     var\r
 421        i, j: integer; { indices para usar en los ciclos for }\r
 422        vRTmp,         { vector auxuliares para almacenar el termino actual del resultado }\r
 423        vTmp: Vector;  { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
 424                         termino actual del resultado por el divisor }\r
 425 \r
 426     begin { division }\r
 427          inicializaVector(vr);     { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 428          inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 429          inicializaVector(vTmp);   { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 430          inicializaVector(vRTmp);  { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 431          for i := TAM - 1 downto 0 do  { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
 432              if v1[i] <> 0 then break;\r
 433              { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
 434              { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
 435          for j := TAM - 1 downto 0 do  { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
 436              if v2[j] <> 0 then break;\r
 437              { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
 438              { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
 439          if (j = 0) and (v2[j] = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
 440             then                   { el polinomio 2 es nulo y no se puede efectuar la division }\r
 441               begin                { se devuelve false y se quedan los vectores resultado en 0 }\r
 442                    division := false; { devuelve false }\r
 443                    exit;              { sale del procedimiento }\r
 444               end;\r
 445          while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
 446            begin\r
 447                 vr[i-j] := v1[i] / v2[j]; { almacena el resultado de la division entre los coeficientes en\r
 448                                             la posicion de la resta de ambos }\r
 449                 vRTmp[i-j] := vr[i-j];    { almacena ese resultado en un polinomio temporal cuyo unico termio\r
 450                                             no nulo es el del exponente i-j, para luego multiplicarlo }\r
 451                 producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
 452                                             en otro temporal, para luego hacer la resta }\r
 453                 resta(v1, vTmp, v1);      { resta al primer polinomio, v1, (en su estado actual, no el original)\r
 454                                             el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
 455                                             la misma forma }\r
 456                 vRTmp[i-j] := 0;          { resetea el termino del temporal vRTmp que se asigno para los calculos }\r
 457                 for i := i downto 0 do    { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
 458                     if v1[i] <> 0 then break;\r
 459                     { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
 460                       si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
 461            end; { while }\r
 462          vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
 463          division := true; { devuelve true indicando que se finalizo con exito }\r
 464     end; { division }\r
 465 \r
 466     {########################################################}\r
 467 \r
 468 { Continuacion del programa principal }\r
 469 \r
 470 var\r
 471    i: integer; { variable auxiliar }\r
 472    v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
 473    continua: boolean; { valor para obtener los resultados de algunas funciones }\r
 474 \r
 475 begin { Comienzo del programa principal }\r
 476      continua := cargarVectores(v1, v2);\r
 477      if continua then\r
 478         begin\r
 479           muestraVector(v1, 'Polinomio 1 = ');\r
 480           muestraVector(v2, 'Polinomio 2 = ');\r
 481           suma(v1, v2, vResult);\r
 482           muestraVector(vResult, 'Polinomio 1 + Polinomio 2 = ');\r
 483           resta(v1, v2, vResult);\r
 484           muestraVector(vResult, 'Polinomio 1 - Polinomio 2 = ');\r
 485           producto(v1, v2, vResult);\r
 486           muestraVector(vResult, 'Polinomio 1 * Polinomio 2 = ');\r
 487           continua := division(v1, v2, vResult, vResto);\r
 488           if continua\r
 489              then\r
 490                begin\r
 491                     muestraVector(vResult, 'Polinomio 1 / Polinomio 2 = ');\r
 492                     muestraVector(vResto, 'Resto = ');\r
 493                end\r
 494              else writeln('El segundo polinomio es nulo, por lo tanto no se puede efectuar la division');\r
 495         end\r
 496      else\r
 497         begin\r
 498           writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
 499           writeln('       sea correcto y que no este siendo usado por otro programa.');\r
 500         end;\r
 501 end.