poli_12.pas

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