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