poli_13.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.2.3r (POLI_13)'; { 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          readln(tmp); { entrada del nombre de archivo }\r
 175          if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
 176          while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
 177            begin\r
 178                 clrscr; { borra la pantalla }\r
 179                 textcolor( Yellow ); { establece el color para el texto a amarillo }\r
 180                 gotoxy( 25, 3 ); { va a las coordenas de pantalla 19 horizontal, 3 verical }\r
 181                 writeln( 'OPERACIONES ENTRE POLINOMIOS' ); { titulo }\r
 182                 gotoxy( 25, 4 ); { va a las coordenas de pantalla 19 horizontal, 4 verical }\r
 183                 writeln( '~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~' ); { subrayado del titulo }\r
 184                 textcolor( LightCyan ); { establece el color para el texto a cian claro }\r
 185                 gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
 186                 write('  El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
 187                 if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
 188                    then                   { entonces, elije un mensaje apropiado }\r
 189                        write(': ')\r
 190                    else\r
 191                      begin                { si no es el predeterminado, muestra otro mensaje }\r
 192                           writeln('.');\r
 193                           write('   (ENTER = ', DEFAUL_FILE_NAME, '): ');\r
 194                      end;\r
 195                 readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
 196                 if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
 197                                                             si no se escribio nada }\r
 198            end; { fin del loop de verificacion }\r
 199          ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
 200     end; { ObtenerNombreArchivo }\r
 201 \r
 202     {########################################################}\r
 203 \r
 204     function trans(c: char; e: Estado): Estado;\r
 205     { establece el estado en el que se encuentra la lectura }\r
 206     { c es el caracter que se leyo, e es el estado actual de la lectura }\r
 207 \r
 208     begin { trans }\r
 209          case e of { acciona segun es estado actual de la lectura }\r
 210               INICIO: { estado de inicio de la lectura }\r
 211                      case c of { acciona segun el caracter leido }\r
 212                          '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
 213                          SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
 214                          else trans := ERROR; { si es otro, da ERROR }\r
 215                      end;\r
 216               COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
 217                      case c of { acciona segun el caracter leido }\r
 218                          '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
 219                          SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
 220                          ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
 221                          else trans := ERROR; { si es otro, da ERROR }\r
 222                      end;\r
 223               COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
 224                    case c of { acciona segun el caracter leido }\r
 225                         '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
 226                         '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
 227                         SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
 228                         else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
 229                    end;\r
 230               COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
 231                    case c of { acciona segun el caracter leido }\r
 232                         '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
 233                         SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
 234                         else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
 235                    end;\r
 236               COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
 237                        case c of { acciona segun el caracter leido }\r
 238                            '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
 239                            SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
 240                            else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
 241                        end;\r
 242               EXP_BUSCA: { estado de busqueda del proximo exponente }\r
 243                        case c of { acciona segun el caracter leido }\r
 244                            '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
 245                            SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
 246                            else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
 247                        end;\r
 248               EXP: { estado de lectura del exponente del termino actual del polinomio }\r
 249                   case c of { acciona segun el caracter leido }\r
 250                        '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
 251                        CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
 252                                                (quiere decir que hubo un <ENTER>) }\r
 253                        ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
 254                        else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
 255                   end;\r
 256               EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
 257                       if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
 258                                 else trans := ERROR; { si no lo es, devuelve ERROR }\r
 259               EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
 260                                ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
 261                       case c of { acciona segun el caracter leido }\r
 262                            '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
 263                            CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
 264                            else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
 265                       end;\r
 266               POLI_FIN: { estado de finalizacion del polinomio actual }\r
 267                       if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
 268                                                            entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
 269                                 else trans := ERROR; { si no lo es, devuelve ERROR }\r
 270               FIN: { estado que adquiere cuando se finalizo la tarea }\r
 271                   trans := FIN; { se queda en este estado avisando que termino su tarea }\r
 272               else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
 273                   trans := ERROR; { si es otro, da ERROR }\r
 274          end; { case }\r
 275     end; { trans }\r
 276 \r
 277     {########################################################}\r
 278 \r
 279     function cargarVectores(var v1, v2: Vector): boolean;\r
 280     { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
 281       que lo lee y, al finalizar, cierra el archivo de texto.\r
 282       v1 es el primer vector a cargar\r
 283       v2 es el segundo vector a cargar\r
 284       devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
 285 \r
 286     var\r
 287        f: Text; { archivo de texto con los datos }\r
 288        c: char; { caracter que se extrae del archivo de texto }\r
 289        nombreArchivo: String; { nombre del archivo de datos }\r
 290        est: Estado; { Indicador del estado actual de la lectura }\r
 291        seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
 292        i, { indice del vector del polinomio para ser inicializado }\r
 293        iExp, { valor temporal para almacenar al exponente }\r
 294        code, { almacena el resultado de la funcion val (no se usa porque los\r
 295                datos ya estan validados }\r
 296        poliN: integer; { numero del polinomio que se esta leyendo }\r
 297        rCoef: real; { valor temporal para almacenar al coeficiente }\r
 298        exponente, { string que representa al exponente leido }\r
 299        coeficiente: String; { string que representa al coeficiente leido }\r
 300 \r
 301     begin { cargarVectores }\r
 302          rCoef := 0.0; { inicializacion de variable }\r
 303          iExp := 0;    { inicializacion de variable }\r
 304          coeficiente := ''; { inicializacion de variable }\r
 305          exponente := '';   { inicializacion de variable }\r
 306          est := INICIO; { empieza con el estado de INICIO }\r
 307          poliN := 1; { establece que se procesara el primer polinomio }\r
 308          inicializaVector(v1); { inicializacion del vector 1 (primer polinomio) }\r
 309          inicializaVector(v2); { inicializacion del vector 2 (segundo polinomio) }\r
 310          nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
 311          assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
 312          reset(f); { abre el archivo para leerlo desde el principio }\r
 313          seguir := true; { inicializa seguir e true para comenzar el bucle }\r
 314          while seguir do begin { continua mientras seguir sea true }\r
 315            read(f, c); { lee un caracter del archivo de texto }\r
 316            est := trans(c, est); { establece el nuevo estado de lectura }\r
 317            case est of { toma una desicion dependiendo del estado en que se encuentre }\r
 318                 INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
 319                 COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
 320                 COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
 321                    coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
 322                                                      de texto del coeficiente }\r
 323                 COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
 324                               se realiza cuando termina de leer el exponente (es necesario\r
 325                               para establecer el indice del vector }\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 v1[iExp] := rCoef { asigna el valor correspondiente }\r
 336                                                   else v2[iExp] := rCoef { al polinomio correspondiente }\r
 337                                 else est := ERROR; { si no es menor, pone el estado en ERROR }\r
 338                              coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
 339                              exponente := '';   { exponente para poder realizar las lecturas de los proximos }\r
 340                         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 v2[iExp] := rCoef { si es el 2do polinomio, asigna el valor correspondiente }\r
 357                                    else cargarVectores := false { si es el primero, no se hizo bien la lectura }\r
 358                             else cargarVectores := false; { si no es menor, no se hizo bien la lectura }\r
 359                     end;\r
 360                 ERROR:  { Si hubo un error ... }\r
 361                    begin\r
 362                         cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
 363                         seguir := false; { seguir se pone en false para que termine el bucle }\r
 364                    end;\r
 365            end; { case }\r
 366          end; { while }\r
 367          close(f); { se cierra el archivo de lectura de datos }\r
 368     end; { cargarVectores }\r
 369 \r
 370     {########################################################}\r
 371 \r
 372     procedure suma(v1, v2: Vector; var vr: Vector);\r
 373     { procedimiento que suma dos polinomios.\r
 374       v1: vector que contiene el primer polinomio a sumar\r
 375       v2: vector que contiene el segundo polinomio a sumar\r
 376       vr: vector donde se almacenara el resultado de la suma }\r
 377 \r
 378     var\r
 379        i: integer; { indice para usar en el ciclo for }\r
 380 \r
 381     begin { suma }\r
 382          inicializaVector(vr);        { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 383          for i := 0 to TAM - 1 do     { recorre el vector (de tama¤o maximo TAM) }\r
 384              vr[i] := v1[i] + v2[i];  { suma los coeficientes de los terminos con igual exponente }\r
 385     end; { suma }\r
 386 \r
 387     {########################################################}\r
 388 \r
 389     procedure resta(v1, v2: Vector; var vr: Vector);\r
 390     { procedimiento que resta dos polinomios.\r
 391       v1: vector que contiene el primer polinomio\r
 392       v2: vector que contiene el polinomio para restarle al primero\r
 393       vr: vector donde se almacenara el resultado de la resta }\r
 394 \r
 395     var\r
 396        i: integer; { indice para usar en el ciclo for }\r
 397 \r
 398     begin { resta }\r
 399          inicializaVector(vr);        { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 400          for i := 0 to TAM - 1 do     { recorre el vector (de tama¤o maximo TAM) }\r
 401              vr[i] := v1[i] - v2[i];  { resta los coeficientes de los terminos con igual exponente }\r
 402     end; { resta }\r
 403 \r
 404     {########################################################}\r
 405 \r
 406     procedure producto(v1, v2: Vector; var vr: Vector);\r
 407     { procedimiento que multiplica dos polinomios.\r
 408       v1: vector que contiene el primer polinomio a multiplicar\r
 409       v2: vector que contiene el segundo polinomio a multiplicar\r
 410       vr: vector donde se almacenara el resultado de la multiplicacion }\r
 411 \r
 412     var\r
 413        i, j: integer; { indices para usar en los ciclos for }\r
 414 \r
 415     begin { producto }\r
 416          inicializaVector(vr);        { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 417          for i := 0 to TAM - 1 do     { recorre el 1er vector (de tama¤o maximo TAM) }\r
 418              for j := 0 to TAM - 1 do { recorre el 2do vector (de tama¤o maximo TAM) }\r
 419                  vr[i+j] := vr[i+j] + (v1[i] * v2[j]);\r
 420                  { multiplica los coeficientes de los terminos y lo almacena en la posicion del exponente }\r
 421                  { igual a la suma de los exponentes de v1 y v2, sumando el valor previo de dicha posicion }\r
 422     end; { producto }\r
 423 \r
 424     {########################################################}\r
 425 \r
 426     function division(v1, v2: Vector; var vr, vResto: Vector): boolean;\r
 427     { procedimiento que divide dos polinomios.\r
 428       v1: vector que contiene el polinomio denominador\r
 429       v2: vector que contiene el polinomio divisor\r
 430       vr: vector donde se almacenara el resultado de la division\r
 431       vResto: vector donde se almacenara el resto de la division\r
 432       devuelve true si el segundo polinomio no es 0 y se efectua la division y\r
 433       devuelve false si segundo polinomio es 0 y no se puede efectuar la division }\r
 434 \r
 435     var\r
 436        i, j: integer; { indices para usar en los ciclos for }\r
 437        vRTmp,         { vector auxuliares para almacenar el termino actual del resultado }\r
 438        vTmp: Vector;  { vector auxuliares para almacenar el polinomio que es la multiplicacion del\r
 439                         termino actual del resultado por el divisor }\r
 440 \r
 441     begin { division }\r
 442          inicializaVector(vr);     { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 443          inicializaVector(vResto); { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 444          inicializaVector(vTmp);   { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 445          inicializaVector(vRTmp);  { inicializa al vector resultado en 0 para evitar que quede "basura" }\r
 446          for i := TAM - 1 downto 0 do  { recorre el 1er vector (de tama¤o maximo TAM) de atras para adelante }\r
 447              if v1[i] <> 0 then break;\r
 448              { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
 449              { si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
 450          for j := TAM - 1 downto 0 do  { recorre el 2do vector (de tama¤o maximo TAM) de atras para adelante }\r
 451              if v2[j] <> 0 then break;\r
 452              { busca empezando por el indice (exponete) mas alto el primer coeficiente no nulo }\r
 453              { si lo encuentra sale del for dejando al valor de j como el de dicho inidice }\r
 454          if (j = 0) and (v2[j] = 0) { si el no se encontro ningun coeficiente no nulo, entonces }\r
 455             then                   { el polinomio 2 es nulo y no se puede efectuar la division }\r
 456               begin                { se devuelve false y se quedan los vectores resultado en 0 }\r
 457                    division := false; { devuelve false }\r
 458                    exit;              { sale del procedimiento }\r
 459               end;\r
 460          while i >= j do { si el primer exponente es mayor o igual que el segundo empieza a dividir }\r
 461            begin\r
 462                 vr[i-j] := v1[i] / v2[j]; { almacena el resultado de la division entre los coeficientes en\r
 463                                             la posicion de la resta de ambos }\r
 464                 vRTmp[i-j] := vr[i-j];    { almacena ese resultado en un polinomio temporal cuyo unico termio\r
 465                                             no nulo es el del exponente i-j, para luego multiplicarlo }\r
 466                 producto(vRTmp, v2, vTmp);{ multiplica este polinomio por el segundo almacenado el resultado\r
 467                                             en otro temporal, para luego hacer la resta }\r
 468                 resta(v1, vTmp, v1);      { resta al primer polinomio, v1, (en su estado actual, no el original)\r
 469                                             el temporal vTmp y lo almacena en v1, para poder volver a operarlo de\r
 470                                             la misma forma }\r
 471                 vRTmp[i-j] := 0;          { resetea el termino del temporal vRTmp que se asigno para los calculos }\r
 472                 for i := i downto 0 do    { recorre el vector v1 (de tama¤o maximo TAM) de atras para adelante }\r
 473                     if v1[i] <> 0 then break;\r
 474                     { busca empezando por el indice (exponete) i el primer coeficiente no nulo\r
 475                       si lo encuentra sale del for dejando al valor de i como el de dicho inidice }\r
 476            end; { while }\r
 477          vResto := v1; { asigna el vector v1 (que ya no se procesara mas al resto }\r
 478          division := true; { devuelve true indicando que se finalizo con exito }\r
 479     end; { division }\r
 480 \r
 481     {########################################################}\r
 482 \r
 483     procedure mensajeSalida; { muestra un mensaje en la salida del programa }\r
 484 \r
 485       begin\r
 486          writeln;   { linea en blanco }\r
 487          NormVideo; { reestablece los colores a los valores por defecto }\r
 488          clrscr;    { borra la pantalla }\r
 489          writeln;   { linea en blanco }\r
 490          textcolor(white); { cambia el color del texto }\r
 491          writeln(' OPERACIONES ENTRE POLINOMIOS versi¢n ', VERSION); { mensaje con version del programa }\r
 492          NormVideo; { reestablece los colores a los valores por defecto }\r
 493          writeln('  Desarrollado por: JavierGrijalba');      { mensaje con los integrantes del grupo }\r
 494          writeln('                    Leandro Lucarella');\r
 495          writeln('                    Erasmo Troncovich');\r
 496          writeln('                    Diego Wojmicki');\r
 497          writeln('  para la Facultad de Ingenier¡a de la Universidad de Buenos Aires.');\r
 498          writeln('  Consultas y/o sugerencias a:');\r
 499          writeln;\r
 500          textcolor(LightMagenta); { cambia el color del texto }\r
 501          write('                lluca@cnba.uba.ar');\r
 502          NormVideo; { reestablece los colores a los valores por defecto }\r
 503          write('   o   ');\r
 504          textcolor(LightMagenta); { cambia el color del texto }\r
 505          writeln('grijalba@cvtci.com.ar');\r
 506          NormVideo; { reestablece los colores a los valores por defecto }\r
 507          writeln;\r
 508          writeln('  (c) 1999 - Todos los derechos reservados.');\r
 509          delay(750);\r
 510       end;\r
 511 \r
 512 \r
 513     {########################################################}\r
 514 \r
 515 \r
 516 var\r
 517    i: integer; { variable auxiliar }\r
 518    v1, v2, vResult, vResto: Vector; { vectores para hacer las operaciones }\r
 519    seguir, { indicador para saber si sigue corriendo el programa }\r
 520    noNulo, { indicador para saber si en la division el divisor es nulo }\r
 521    continua: boolean; { indicador para saber si se leyeron bien los polinomios }\r
 522    tecla: char; { entrada de teclado del usuario para elegir una opcion }\r
 523 \r
 524 begin { programa principal }\r
 525      textbackground( Blue ); { establece el color para el fondo a azul }\r
 526      continua := cargarVectores(v1, v2); { carga los vectores del archivo de datos }\r
 527      if continua then { si se leyeron bien ... }\r
 528        begin\r
 529             seguir := true; { inicializa la variable en true para que entre en el ciclo while }\r
 530             while seguir do { mientras el usuario no salga del programa }\r
 531               begin\r
 532                    clrscr; { borra la pantalla }\r
 533                    textcolor(Yellow); { establece el color para el texto a amarillo }\r
 534                    gotoxy( 25, 3 ); { va a las coordenas de pantalla 19 horizontal, 3 verical }\r
 535                    writeln( 'OPERACIONES ENTRE POLINOMIOS' ); { titulo }\r
 536                    gotoxy( 25, 4 ); { va a las coordenas de pantalla 19 horizontal, 4 verical }\r
 537                    writeln( '~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~' ); { subrayado del titulo }\r
 538                    textcolor(LightCyan); { establece el color para el texto a cian claro }\r
 539                    gotoxy( 1, 7 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
 540                    writeln( '  Elija que desea hacer:' ); { mensaje }\r
 541                    writeln( '  ----- --- ----- ------' ); { mensaje }\r
 542                    textcolor(LightGray); { establece el color para el texto a gris claro }\r
 543                    writeln; { mensaje con las opciones ... }\r
 544                    writeln;\r
 545                    writeln( '     1.- Ver el polinomio 1.' );\r
 546                    writeln( '     2.- Ver el polinomio 2.' );\r
 547                    writeln( '     3.- Sumar los polinomios.' );\r
 548                    writeln( '     4.- Restar el polinomio 2 al polinomio 1 (poli1 - poli2).' );\r
 549                    writeln( '     5.- Restar el polinomio 1 al polinomio 2 (poli2 - poli1).' );\r
 550                    writeln( '     6.- Multiplicar los polinomios.' );\r
 551                    writeln( '     7.- Polinomio 1 dividido polinomio 2 (poli1 / poli2).' );\r
 552                    writeln( '     8.- Polinomio 2 dividido polinomio 1 (poli2 / poli1).' );\r
 553                    writeln( '     0.- Salir.' );\r
 554                    gotoxy(1, 23); { va a las coordenas de pantalla 1 horizontal, 23 verical }\r
 555                    textcolor(White ); { establece el color para el texto a blanco }\r
 556                    write('  Ingrese su opci¢n: ');\r
 557                    textcolor(Yellow); { establece el color para el texto a amarillo }\r
 558                    tecla := readkey;    { lee una tecla del usuario indicando la opcion que elijio }\r
 559                    while ((tecla < '1') or (tecla > '8')) and (tecla <> '0') do { mientras sea una tecla no admitida }\r
 560                      begin\r
 561                           textcolor(White); { establece el color para el texto a blanco }\r
 562                           gotoxy( 1, 23 ); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
 563                           write('  Ingrese su opci¢n ("1" a "8" o "0"): ' );\r
 564                           textcolor(Yellow); { establece el color para el texto a amarillo }\r
 565                           tecla := readkey;    { lee una tecla del usuario indicando la opcion que elijio }\r
 566                      end; { while }\r
 567                    if tecla = '0' then  { si la opcion fue salir del programa ... }\r
 568                      begin\r
 569                           mensajeSalida; { presenta un mensaje de salida }\r
 570                           exit;          { sale del programa }\r
 571                      end;\r
 572                    clrscr; { borra la pantalla }\r
 573                    textcolor(Yellow); { establece el color para el texto a amarillo }\r
 574                    gotoxy(19, 3); { va a las coordenas de pantalla 19 horizontal, 3 verical }\r
 575                    writeln( 'OPERACIONES ENTRE POLINOMIOS'); { titulo }\r
 576                    gotoxy(19, 4); { va a las coordenas de pantalla 19 horizontal, 4 verical }\r
 577                    writeln('~~~~~~~~~~~ ~~~~~ ~~~~~~~~~~'); { subrayado del titulo }\r
 578                    textcolor(LightCyan); { establece el color para el texto a cian claro }\r
 579                    gotoxy(1, 7); { va a las coordenas de pantalla 1 horizontal, 7 verical }\r
 580                    case tecla of\r
 581                        '1': muestraVector(v1, '  Polinomio 1 = ');\r
 582                        '2': muestraVector(v2, '  Polinomio 2 = ');\r
 583                        '3': begin\r
 584                                  suma(v1, v2, vResult);\r
 585                                  muestraVector(vResult, '  Polinomio 1 + Polinomio 2 = ');\r
 586                             end; { case 3 }\r
 587                        '4': begin\r
 588                                  resta(v1, v2, vResult);\r
 589                                  muestraVector(vResult, '  Polinomio 1 - Polinomio 2 = ');\r
 590                             end; { case 4 }\r
 591                        '5': begin\r
 592                                  resta(v2, v1, vResult);\r
 593                                  muestraVector(vResult, '  Polinomio 2 - Polinomio 1 = ');\r
 594                             end; { case 5 }\r
 595                        '6': begin\r
 596                                  producto(v1, v2, vResult);\r
 597                                  muestraVector(vResult, '  Polinomio 1 * Polinomio 2 = ');\r
 598                             end; { case 6 }\r
 599                        '7': begin\r
 600                                  noNulo := division(v1, v2, vResult, vResto);\r
 601                                  if noNulo\r
 602                                    then\r
 603                                        begin\r
 604                                             muestraVector(vResult, '  Polinomio 1 / Polinomio 2 = ');\r
 605                                             muestraVector(vResto, '  Resto = ');\r
 606                                        end\r
 607                                    else writeln('  El polinomio 2 es nulo, por lo tanto no se puede efectuar la division.');\r
 608                             end; { case 7 }\r
 609                        '8': begin\r
 610                                  noNulo := division(v2, v1, vResult, vResto);\r
 611                                  if noNulo\r
 612                                    then\r
 613                                        begin\r
 614                                             muestraVector(vResult, 'Polinomio 2 / Polinomio 1 = ');\r
 615                                             muestraVector(vResto, 'Resto = ');\r
 616                                        end\r
 617                                    else writeln('  El polinomio 1 es nulo, por lo tanto no se puede efectuar la division.');\r
 618                             end; { case 8 }\r
 619                        '0': ; { no hace nada, nunca deberia entrar en este case }\r
 620                    end; { case }\r
 621                    writeln; { los siguientes mensajes son para que el usuario pueda ver los datos y luego }\r
 622                    writeln; { presione una tecla para continuar }\r
 623                    textcolor(white); { pone el color del texto en blanco }\r
 624                    writeln(' Presione una tecla para continuar ...');\r
 625                    tecla := readkey;\r
 626               end; { while }\r
 627        end\r
 628      else { si los vectores no se leyeron bien ... }\r
 629          begin { presenta un mensaje de error }\r
 630               writeln('ERROR: No se pudieron cargar los datos. Revise que el formato del archivo');\r
 631               writeln('       sea correcto y que no este siendo usado por otro programa.');\r
 632          end;\r
 633 end. { procedure menuGenerar }