term_3.pas

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