term_0.pas

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