term_1.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.0.1a (TERM_0)'; { 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\r
  52                     coef: real;\r
  53                     exp: integer;\r
  54               end;\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        asignado,    { indicador para saber si ya se asigno el valor al termino actual }\r
 283        seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
 284        i, { indice del vector del polinomio para ser inicializado }\r
 285        iExp, { valor temporal para almacenar al exponente }\r
 286        code, { almacena el resultado de la funcion val (no se usa porque los\r
 287                datos ya estan validados }\r
 288        n, { numero de termino del polinomio actual }\r
 289        poliN: integer; { numero del polinomio que se esta leyendo }\r
 290        rCoef: real; { valor temporal para almacenar al coeficiente }\r
 291        exponente, { string que representa al exponente leido }\r
 292        coeficiente: String; { string que representa al coeficiente leido }\r
 293 \r
 294     begin { cargarVectores }\r
 295          asignado := false;    { inicializacion de variable }\r
 296          n := -1;              { inicializacion de variable }\r
 297          rCoef := 0.0;         { inicializacion de variable }\r
 298          iExp := 0;            { inicializacion de variable }\r
 299          coeficiente := '';    { inicializacion de variable }\r
 300          exponente := '';      { inicializacion de variable }\r
 301          est := INICIO;        { empieza con el estado de INICIO }\r
 302          poliN := 1;           { establece que se procesara el primer polinomio }\r
 303          inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
 304          inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
 305          nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
 306          assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
 307          reset(f); { abre el archivo para leerlo desde el principio }\r
 308          seguir := true; { inicializa seguir e true para comenzar el bucle }\r
 309          while seguir do begin { continua mientras seguir sea true }\r
 310            read(f, c); { lee un caracter del archivo de texto }\r
 311            est := trans(c, est); { establece el nuevo estado de lectura }\r
 312            case est of { toma una desicion dependiendo del estado en que se encuentre }\r
 313                 INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
 314                 COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
 315                 COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
 316                    coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
 317                                                      de texto del coeficiente }\r
 318                 COEF_FIN: { Si termino de leer el coeficiente ... }\r
 319                    begin\r
 320                         n := n + 1; { incrementa el termino en uno }\r
 321                         asignado := false; { se indica que no esta asignado todavia. }\r
 322                          { Se elije este estado para indicar esto (e incrementar el termino) porque siempre que\r
 323                            finalize bien el polinomio se pasa por \82l (no pasa lo mismo con EXP_FIN).\r
 324                            La asignacion se realiza cuando termina de leer el exponente }\r
 325                    end;\r
 326                 EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
 327                 EXP: { Si esta leyendo el exponente ... }\r
 328                    exponente := exponente + c; { concatena el caracter a la representacion\r
 329                                                  de texto del exponente }\r
 330                 EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
 331                         begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\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\r
 336                                                     begin\r
 337                                                          v1[n].coef := rCoef; { asigna el valor correspondiente }\r
 338                                                          v1[n].exp := iExp; { asigna el valor correspondiente }\r
 339                                                          asignado := true; { se indica que se hizo la asignacion.\r
 340                                                          esto solo tiene sentido si el archivo finaliza justo despues\r
 341                                                          de leer el ultimo exponente (no pasa po este estado y asignado\r
 342                                                          queda en false, avisandole a FIN que debe hacer la asignacion }\r
 343                                                     end\r
 344                                                   else\r
 345                                                     begin\r
 346                                                          v1[n].coef := rCoef; { asigna el valor correspondiente }\r
 347                                                          v1[n].exp := iExp; { asigna el valor correspondiente }\r
 348                                                          asignado := true; { se indica que se hizo la asignacion.\r
 349                                                          esto solo tiene sentido si el archivo finaliza justo despues\r
 350                                                          de leer el ultimo exponente (no pasa po este estado y asignado\r
 351                                                          queda en false, avisandole a FIN que debe hacer la asignacion }\r
 352                                                     end\r
 353                                 else est := ERROR; { si no es menor, pone el estado en ERROR }\r
 354                              coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
 355                              exponente := '';   { exponente para poder realizar las lecturas de los proximos }\r
 356                         end;\r
 357                 EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
 358                 POLI_FIN: { Si termino la lectura de un polinomio ... }\r
 359                          if poliN = 1 then\r
 360                                         begin\r
 361                                              poliN := 2; { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
 362                                              n := -1; { empieza por el primer termino (vale n = 0 al pasar por COEF_FIN) }\r
 363                                         end\r
 364                                       else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
 365                 FIN: { Si se finalizaron las tareas ... }\r
 366                     begin\r
 367                          cargarVectores := true; { en principio se establece que la lectura se hizo con exito ) }\r
 368                          seguir := false; { poner seguir en false para que se termine el bucle }\r
 369                          { este codigo es similar al de EXP_FIN, se hacen las asignaciones por el caso en que el fin\r
 370                            del archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
 371                            de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
 372                          if poliN <> 2 { si no se leyeron ambos polinomios ... }\r
 373                             then\r
 374                                 cargarVectores := false { devuelve false (no se realizo con exito la lectura }\r
 375                             else { si se leyeron ambos polinomios ... }\r
 376                                 if not asignado then { si no se pudo hacer la asignacion ... }\r
 377                                                      { esto solo tiene sentido si el archivo finaliza justo despues\r
 378                                                        de leer el ultimo exponente (no pasa por el estado FIN_EXP y\r
 379                                                        FIN debe hacer la asignacion }\r
 380                                    begin\r
 381                                         val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
 382                                         val(exponente, iExp, code); { convierte el exponente en integer }\r
 383                                         if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
 384                                            then\r
 385                                                begin\r
 386                                                     v2[n].coef := rCoef; { asigna el valor correspondiente }\r
 387                                                     v2[n].exp := iExp; { asigna el valor correspondiente }\r
 388                                                end\r
 389                                            else\r
 390                                                cargarVectores := false; { si no es menor, no se hizo bien la lectura }\r
 391                                    end; { if not asignado }\r
 392                     end; { FIN: }\r
 393                 ERROR:  { Si hubo un error ... }\r
 394                    begin\r
 395                         cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
 396                         seguir := false; { seguir se pone en false para que termine el bucle }\r
 397                    end;\r
 398            end; { case }\r
 399          end; { while }\r
 400          close(f); { se cierra el archivo de lectura de datos }\r
 401     end; { cargarVectores }\r
 402 \r
 403     {########################################################}\r
 404 \r
 405     procedure suma(v1, v2: Vector; var vr: Vector);\r
 406     { procedimiento que suma dos polinomios.\r
 407       v1: vector que contiene el primer polinomio a sumar\r
 408       v2: vector que contiene el segundo polinomio a sumar\r
 409       vr: vector donde se almacenara el resultado de la suma }\r
 410 \r
 411     var\r
 412        i: integer; { indice para usar en el ciclo for }\r
 413 \r
 414     begin { suma }\r
 415          inicializaVector(vr);        { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 416          for i := 0 to TAM - 1 do     { recorre el vector (de tama¤o maximo TAM) }\r
 417              vr[i] := v1[i] + v2[i];  { suma los coeficientes de los terminos con igual exponente }\r
 418     end; { suma }\r
 419 \r
 420     {########################################################}\r
 421 \r
 422     procedure resta(v1, v2: Vector; var vr: Vector);\r
 423     { procedimiento que resta dos polinomios.\r
 424       v1: vector que contiene el primer polinomio\r
 425       v2: vector que contiene el polinomio para restarle al primero\r
 426       vr: vector donde se almacenara el resultado de la resta }\r
 427 \r
 428     var\r
 429        i: integer; { indice para usar en el ciclo for }\r
 430 \r
 431     begin { resta }\r
 432          inicializaVector(vr);        { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 433          for i := 0 to TAM - 1 do     { recorre el vector (de tama¤o maximo TAM) }\r
 434              vr[i] := v1[i] - v2[i];  { resta los coeficientes de los terminos con igual exponente }\r
 435     end; { resta }\r
 436 \r
 437     {########################################################}\r
 438 \r
 439     procedure producto(v1, v2: Vector; var vr: Vector);\r
 440     { procedimiento que multiplica dos polinomios.\r
 441       v1: vector que contiene el primer polinomio a multiplicar\r
 442       v2: vector que contiene el segundo polinomio a multiplicar\r
 443       vr: vector donde se almacenara el resultado de la multiplicacion }\r
 444 \r
 445     var\r
 446        i, j: integer; { indices para usar en los ciclos for }\r
 447 \r
 448     begin { producto }\r
 449          inicializaVector(vr);        { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 450          for i := 0 to TAM - 1 do     { recorre el 1er vector (de tama¤o maximo TAM) }\r
 451              for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
 452                  vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
 453                  { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
 454                  { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
 455     end; { producto }\r
 456 \r
 457     {########################################################}\r
 458 \r
 459     function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
 460     { procedimiento que divide dos polinomios.\r
 461       v1: vector que contiene el polinomio denominador\r
 462       v2: vector que contiene el polinomio divisor\r
 463       vr: vector donde se almacenara el resultado de la division\r
 464       vResto: vector donde se almacenara el resto de la division\r
 465       devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
 466       devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
 467 \r
 468     var\r
 469        i, j: integer; { indices para usar en los ciclos for }\r
 470        vRTmp,         { vector auxuliares para almacenar el termino actual del resultado }\r
 471        vTmp: Vector;  { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
 472                         termino actual del resultado por el divisor }\r
 473 \r
 474     begin { division }\r
 475          inicializaVector(vr);     { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 476          inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 477          inicializaVector(vTmp);   { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 478          inicializaVector(vRTmp);  { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 479          for i := TAM - 1 downto 0 do  { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
 480              if v1[i] <> 0 then break;\r
 481              { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
 482              { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
 483          for j := TAM - 1 downto 0 do  { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
 484              if v2[j] <> 0 then break;\r
 485              { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
 486              { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
 487          if (j = 0) and (v2[j] = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
 488             then                   { el polinomio 2 es nulo y no se puede efectuar la division }\r
 489               begin                { se devuelve false y se quedan los vectores resultado en 0 }\r
 490                    division := false; { devuelve false }\r
 491                    exit;              { sale del procedimiento }\r
 492               end;\r
 493          while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
 494            begin\r
 495                 vr[i-j] := v1[i] / v2[j]; { almacena el resultado de la division entre los coeficientes en\r
 496                                             la posicion de la resta de ambos }\r
 497                 vRTmp[i-j] := vr[i-j];    { almacena ese resultado en un polinomio temporal cuyo unico termio\r
 498                                             no nulo es el del exponente i-j, para luego multiplicarlo }\r
 499                 producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
 500                                             en otro temporal, para luego hacer la resta }\r
 501                 resta(v1, vTmp, v1);      { resta al primer polinomio, v1, (en su estado actual, no el original)\r
 502                                             el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
 503                                             la misma forma }\r
 504                 vRTmp[i-j] := 0;          { resetea el termino del temporal vRTmp que se asigno para los calculos }\r
 505                 for i := i downto 0 do    { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
 506                     if v1[i] <> 0 then break;\r
 507                     { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
 508                       si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
 509            end; { while }\r
 510          vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
 511          division := true; { devuelve true indicando que se finalizo con exito }\r
 512     end; { division }\r
 513 \r
 514     {########################################################}\r
 515 \r
 516 { Continuacion del programa principal }\r
 517 \r
 518 var\r
 519    i: integer; { variable auxiliar }\r
 520    v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
 521    continua: boolean; { valor para obtener los resultados de algunas funciones }\r
 522 \r
 523 begin { Comienzo del programa principal }\r
 524      continua := cargarVectores(v1, v2);\r
 525      if continua then\r
 526         begin\r
 527           muestraVector(v1, 'Polinomio 1 = ');\r
 528           muestraVector(v2, 'Polinomio 2 = ');\r
 529           suma(v1, v2, vResult);\r
 530           muestraVector(vResult, 'Polinomio 1 + Polinomio 2 = ');\r
 531           resta(v1, v2, vResult);\r
 532           muestraVector(vResult, 'Polinomio 1 - Polinomio 2 = ');\r
 533           producto(v1, v2, vResult);\r
 534           muestraVector(vResult, 'Polinomio 1 * Polinomio 2 = ');\r
 535           continua := division(v1, v2, vResult, vResto);\r
 536           if continua\r
 537              then\r
 538                begin\r
 539                     muestraVector(vResult, 'Polinomio 1 / Polinomio 2 = ');\r
 540                     muestraVector(vResto, 'Resto = ');\r
 541                end\r
 542              else writeln('El segundo polinomio es nulo, por lo tanto no se puede efectuar la division');\r
 543         end\r
 544      else\r
 545         begin\r
 546           writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
 547           writeln('       sea correcto y que no este siendo usado por otro programa.');\r
 548         end;\r
 549 end.