poli_2.pas

   1 program Polinomios;\r
   2 \r
   3 uses\r
   4     CRT, DOS; { Declaracion de funciones predefinidas\r
   5                 para crear la interfaz grafica }\r
   6 \r
   7 const\r
   8      VERSION = '0.6.0a (POLI_2)'; { version del programa }\r
   9 \r
  10      TAM_MAX = 100; { Tama¤o maximo del vector que almacena\r
  11                       la multiplicacion de polinomios }\r
  12      TAM = TAM_MAX div 2; { Tama¤o maximo del vector que contiene\r
  13                             los vector con los que se va a operar }\r
  14      CR = chr(13); { caracter de retorno del carro }\r
  15      LF = chr(10); { caracter de nueva linea }\r
  16      ENDF = chr(26); { caracter de fin del archivo }\r
  17      TAB = chr(9); { caracter de tabulacion }\r
  18      SPACE = chr(32); { caracter de espacio }\r
  19 \r
  20 type\r
  21     Estado = (INICIO, COEF_BUSCA, COEF, COEF_PUNTO, COEF_FIN, EXP_BUSCA, EXP, EXP_FIN, EXP_FIN_BUSCA, POLI_FIN, FIN, ERROR);\r
  22              { Tipo de dato para identificar el estado de la entrada\r
  23                de datos }\r
  24     VectorResultado = array [0..TAM_MAX-1] of real; { vector para almacenar\r
  25                                                     el polinomio resultado }\r
  26     Vector = array [0..TAM-1] of real; { vector para almacenar los polinomios }\r
  27     Termino = record { tipo de dato que representa un termino de un poinomio }\r
  28                     coef: real; { coeficiente del termino }\r
  29                     exp: integer; { exponente de lavariable del polinomio }\r
  30               end; { fin del tipo de dato }\r
  31 \r
  32 \r
  33   {########################################################}\r
  34 \r
  35   function ObtenerNombreArchivo: String;\r
  36   { funcion que obtiene un nombre de archivo valido (es decir, el nombre\r
  37     de un archivo que exista) }\r
  38 \r
  39     {########################################################}\r
  40 \r
  41     function fileExists(FileName: String): Boolean;\r
  42     { funcion extraida de la ayuda del Turbo Pascal 7\r
  43       indica si el archivo existe }\r
  44 \r
  45       var\r
  46          F: file;\r
  47 \r
  48       begin\r
  49            {$I-}\r
  50            Assign(F, FileName);\r
  51            FileMode := 0;  { Set file access to read only }\r
  52            Reset(F);\r
  53            Close(F);\r
  54            {$I+}\r
  55            FileExists := (IOResult = 0) and (FileName <> '');\r
  56       end;  { FileExists }\r
  57 \r
  58     {########################################################}\r
  59 \r
  60     { Continuacion de la funcion ObtenerNombreArchivo }\r
  61     const\r
  62          DEFAUL_FILE_NAME = 'datos.txt'; { nombre del archivo por defecto }\r
  63 \r
  64     var\r
  65        tmp: String; { cadena para almacenar el resultado temporal }\r
  66 \r
  67     begin\r
  68          { mensaje para entrada del nombre de archivo }\r
  69          writeln('Ingrese el nombre del archivo con los datos (ENTER = ', DEFAUL_FILE_NAME, '):');\r
  70          readln(tmp); { entrada del nombre de archivo }\r
  71          if tmp = '' then tmp := DEFAUL_FILE_NAME; { se fija si no se ingreso nada y reasigana el nombre }\r
  72          while not fileExists(tmp) do { repite el proceso hasta que el archivo exista }\r
  73            begin\r
  74                 write('El archivo ', tmp, ' no existe. Ingrese un nombre correcto');\r
  75                 if tmp = DEFAUL_FILE_NAME { si es el nombre de archivo predeterminado }\r
  76                    then                   { entonces, elije un mensaje apropiado }\r
  77                        write(': ')\r
  78                    else\r
  79                      begin                { si no es el predeterminado, muestra otro mensaje }\r
  80                           writeln('.');\r
  81                           write('(ENTER = ', DEFAUL_FILE_NAME, '): ');\r
  82                      end;\r
  83                 readln(tmp); { vuelve a leer el nombre del archivo para ser verificado }\r
  84                 if tmp = '' then tmp := DEFAUL_FILE_NAME; { asigna como nombre de archivo al predeterminado\r
  85                                                             si no se escribio nada }\r
  86            end; { fin del loop de verificacion }\r
  87          ObtenerNombreArchivo := tmp; { asigna el nombre correcto al valor de salida de la funcion }\r
  88     end; { ObtenerNombreArchivo }\r
  89 \r
  90     {########################################################}\r
  91 \r
  92     function trans(c: char; e: Estado): Estado;\r
  93     { establece el estado en el que se encuentra la lectura }\r
  94     { c es el caracter que se leyo, e es el estado actual de la lectura }\r
  95 \r
  96 {DEBUG var l: Text; {}\r
  97 \r
  98     begin\r
  99 {DEBUG  assign(l, 'log.txt'); {}\r
 100 {DEBUG  append(l); {}\r
 101          case e of { acciona segun es estado actual de la lectura }\r
 102               INICIO: { estado de inicio de la lectura }\r
 103                      case c of { acciona segun el caracter leido }\r
 104                          '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
 105                          SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tipo "espacio", busca el prox. coef. }\r
 106                          else trans := ERROR; { si es otro, da ERROR }\r
 107                      end;\r
 108               COEF_BUSCA: { estado de busqueda del primer ceoficiente del polinomio }\r
 109 {DEBUG          begin {}\r
 110                      case c of { acciona segun el caracter leido }\r
 111                          '-', '0'..'9': trans := COEF; { si es un numero (o negativo), empieza a leer el coeficiente }\r
 112                          SPACE, TAB, CR, LF: trans := COEF_BUSCA; { si es un caracter tupo "espacio", sigue buscando }\r
 113                          ENDF: trans := FIN; { si es el caracter de fin de archivo, pasa al estado de tarea finalizada }\r
 114                          else trans := ERROR; { si es otro, da ERROR }\r
 115                      end;\r
 116 {DEBUG               writeln(l, ' --> trans: COEF_BUSCA: c: ', ord(c)); {}\r
 117 {DEBUG          end; {}\r
 118               COEF: { estado de lectura del coeficiente del termino del polinomio (sin punto decimal) }\r
 119 {DEBUG          begin {}\r
 120                    case c of { acciona segun el caracter leido }\r
 121                         '0'..'9': trans := COEF; { si es un numero sigue con el mismo estado }\r
 122                         '.': trans := COEF_PUNTO; { si es punto cambia al estado COEF_PUNTO }\r
 123                         SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
 124                         else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
 125                    end;\r
 126 {DEBUG               writeln(l, ' --> trans: COEF: c: ', ord(c)); {}\r
 127 {DEBUG          end; {}\r
 128               COEF_PUNTO: { estado de lectura del coeficiente del termino del polinomio (con punto decimal) }\r
 129 {DEBUG          begin {}\r
 130                    case c of { acciona segun el caracter leido }\r
 131                         '0'..'9': trans := COEF_PUNTO; { si es un numero sigue con el mismo estado }\r
 132                         SPACE, TAB: trans := COEF_FIN; { si es un espacio o un tabulador, finaliza la lectura del coeficiente }\r
 133                         else trans := ERROR; { si es otra cosa, pasa a estado de error }\r
 134                    end;\r
 135 {DEBUG               writeln(l, ' --> trans: COEF_PUNTO: c: ', ord(c)); {}\r
 136 {DEBUG          end; {}\r
 137               COEF_FIN: { estado de fin de la lectura del coeficiente del termino del polinomio }\r
 138 {DEBUG          begin {}\r
 139                        case c of { acciona segun el caracter leido }\r
 140                            '0'..'9': trans := EXP; { si el caracter es un numero establece el estado en EXP (exponente) }\r
 141                            SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, pasa a buscar el proximo exponente }\r
 142                            else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
 143                        end;\r
 144 {DEBUG               writeln(l, ' --> trans: COEF_FIN: c: ', ord(c)); {}\r
 145 {DEBUG          end; {}\r
 146               EXP_BUSCA: { estado de busqueda del proximo exponente }\r
 147 {DEBUG          begin {}\r
 148                        case c of { acciona segun el caracter leido }\r
 149                            '0'..'9': trans := EXP; { si el caracter es un numero, empieza a leer el exponente }\r
 150                            SPACE, TAB: trans := EXP_BUSCA; { si es un espacio o tabulador, sigue buscando }\r
 151                            else trans := ERROR; { si no es ninguno de los anteriores, el estado pasa a ERROR }\r
 152                        end;\r
 153 {DEBUG               writeln(l, ' --> trans: EXP_BUSCA: c: ', ord(c)); {}\r
 154 {DEBUG          end; {}\r
 155               EXP: { estado de lectura del exponente del termino actual del polinomio }\r
 156 {DEBUG          begin {}\r
 157                   case c of { acciona segun el caracter leido }\r
 158                        '0'..'9': trans := EXP; { si es un digito, sigue en el mismo estado }\r
 159                        CR: trans := EXP_FIN; { si es un ratorno de carro, finaliza el exponente\r
 160                                                (quiere decir que hubo un <ENTER>) }\r
 161                        ENDF: trans := FIN; { si es el final del archivo, se indica que termino su tarea }\r
 162                        else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
 163                   end;\r
 164 {DEBUG               writeln(l, ' --> trans: EXP: c: ', ord(c)); {}\r
 165 {DEBUG          end; {}\r
 166               EXP_FIN: { estado de fin de la lectura del exponente del termino actual del polinomio }\r
 167 {DEBUG          begin {}\r
 168                       if c = LF then trans := EXP_FIN_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>) }\r
 169                                 else trans := ERROR; { si no lo es, devuelve ERROR }\r
 170 {DEBUG               writeln(l, ' --> trans: EXP_FIN: c: ', ord(c)); {}\r
 171 {DEBUG          end; {}\r
 172               EXP_FIN_BUSCA: { estado de fin de lectura de la nueva linea (luego de finalizar el exponente\r
 173                                ahora decide si termino el polinomio o si sigue leyendo el proximo coeficiente }\r
 174 {DEBUG          begin {}\r
 175                       case c of { acciona segun el caracter leido }\r
 176                            '-', '0'..'9': trans := COEF; { si es un digito (o negativo), pasa a leer en proximo coeficiente }\r
 177                            CR: trans := POLI_FIN; { si es un ratorno de carro o nueva linea, finaliza el polinomio }\r
 178                            else trans := ERROR; { si es otra cosa, devuelve ERROR }\r
 179                       end;\r
 180 {DEBUG               writeln(l, ' --> trans: EXP_FIN_BUSCA: c: ', ord(c)); {}\r
 181 {DEBUG          end; {}\r
 182               POLI_FIN: { estado de finalizacion del polinomio actual }\r
 183 {DEBUG           begin {}\r
 184                       if c = LF then trans := COEF_BUSCA { debe ser un caracter de nueva linea (para completar el <ENTER>),\r
 185                                                            entonces pasa a buscar el primer coeficiente del nuevo polinomio }\r
 186                                 else trans := ERROR; { si no lo es, devuelve ERROR }\r
 187 {DEBUG               writeln(l, ' --> trans: POLI_FIN: c: ', ord(c)); {}\r
 188 {DEBUG           end; {}\r
 189               FIN: { estado que adquiere cuando se finalizo la tarea }\r
 190                   trans := FIN; { se queda en este estado avisando que termino su tarea }\r
 191               else { otro estado, no deberia ocurrir, salvo que se le pase a la funcion un estado de ERROR }\r
 192                   trans := ERROR; { si es otro, da ERROR }\r
 193          end; { case }\r
 194 {DEBUG  close(l); {}\r
 195     end; { trans }\r
 196 \r
 197     {########################################################}\r
 198 \r
 199     function cargarVectores(var v1, v2: Vector): boolean;\r
 200     { Funcion que abre el archivo de texto con los datos, lo carga en el vector procesandolo debidamente a medida\r
 201       que lo lee y, al finalizar, cierra el archivo de texto.\r
 202       v1 es el primer vector a cargar\r
 203       v2 es el segundo vector a cargar\r
 204       devuelve true si la lectura fue hecha con exito, false si hubo un error }\r
 205 \r
 206     var\r
 207        f: Text; { archivo de texto con los datos }\r
 208        c: char; { caracter que se extrae del archivo de texto }\r
 209        nombreArchivo: String; { nombre del archivo de datos }\r
 210        est: Estado; { Indicador del estado actual de la lectura }\r
 211        seguir: boolean; { indicador para saber si debe seguir con el proceso }\r
 212        i, { indice del vector del polinomio para ser inicializado }\r
 213        iExp, { valor temporal para almacenar al exponente }\r
 214        code, { almacena el resultado de la funcion val (no se usa porque los\r
 215                datos ya estan validados }\r
 216        poliN: integer; { numero del polinomio que se esta leyendo }\r
 217        rCoef: real; { valor temporal para almacenar al coeficiente }\r
 218        exponente, { string que representa al exponente leido }\r
 219        coeficiente: String; { string que representa al coeficiente leido }\r
 220 \r
 221     begin\r
 222          rCoef := 0.0; { inicializacion de variable }\r
 223          iExp := 0;    { inicializacion de variable }\r
 224          coeficiente := ''; { inicializacion de variable }\r
 225          exponente := '';   { inicializacion de variable }\r
 226          est := INICIO; { empieza con el estado de INICIO }\r
 227          poliN := 1; { establece que se procesara el primer polinomio }\r
 228          for i := 0 to TAM - 1 do { iteracion para inicializar los vectores a cero }\r
 229            begin { para que los valores que no son especificados no contengan "basura" }\r
 230                 v1[i] := 0; { inicializacion del vector 1 (primer polinomio) }\r
 231                 v2[i] := 0; { inicializacion del vector 2 (segundo polinomio) }\r
 232            end;\r
 233          nombreArchivo := ObtenerNombreArchivo; { obtiene el nombre del archivo }\r
 234 {DEBUG  nombreArchivo := 'datos.txt'; {}\r
 235          assign(f, nombreArchivo); { asigna la variable al nombre del archivo }\r
 236          reset(f); { abre el archivo para leerlo desde el principio }\r
 237          seguir := true; { inicializa seguir e true para comenzar el bucle }\r
 238          while seguir do begin { continua mientras seguir sea true }\r
 239            read(f, c); { lee un caracter del archivo de texto }\r
 240            est := trans(c, est); { establece el nuevo estado de lectura }\r
 241            case est of { toma una desicion dependiendo del estado en que se encuentre }\r
 242                 INICIO: ; { No hace nada, nunca toma este valor. Solo incica que empezo el proceso }\r
 243                 COEF_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
 244                 COEF, COEF_PUNTO: { Si esta leyendo el coeficiente ... }\r
 245                    coeficiente := coeficiente + c; { concatena el caracter a la representacion\r
 246                                                      de texto del coeficiente }\r
 247                 COEF_FIN: ; { Si termino de leer el coeficiente, no hace nada, la asignacion\r
 248                               se realiza cuando termina de leer el exponente (es necesario\r
 249                               para establecer el indice del vector }\r
 250                 EXP_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
 251                 EXP: { Si esta leyendo el exponente ... }\r
 252                    exponente := exponente + c; { concatena el caracter a la representacion\r
 253                                                  de texto del exponente }\r
 254                 EXP_FIN: { Si termino de leer el exponente, hace las asignaciones correspondientes }\r
 255                         begin { convirtiendo las cadenas de texto en real e integer, segun el caso }\r
 256                              val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
 257                              val(exponente, iExp, code); { convierte el exponente en integer }\r
 258                              if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
 259                                 then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
 260                                                   else v2[iExp] := rCoef { al polinomio correspondiente }\r
 261                                 else est := ERROR; { si no es menor, pone el estado en ERROR }\r
 262 {DEBUG    writeln(' --> cargarVectores: EXP_FIN'); {}\r
 263 {DEBUG    writeln('     v[', iExp,'] = ', rCoef:1:1); {}\r
 264                              coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
 265                              exponente := '';   { exponente para poder realizar las lecturas de los proximos }\r
 266                         end;\r
 267                 EXP_FIN_BUSCA: ; { No hace nada, solo espera hasta que hayan datos significativos }\r
 268                 POLI_FIN: { Si termino la lectura de un polinomio ... }\r
 269                          if poliN = 1 then poliN := 2  { si se leyo el 1er polinomio, se indica que se leera el 2do }\r
 270                                       else est := FIN; { si no (ya se leyo el segundo), pone el estado en FIN }\r
 271                 FIN: { Si se finalizaron las tareas ... }\r
 272                     begin\r
 273                          { este codigo es el mismo que el de EXP_FIN, se repite aca solo por si el final del\r
 274                            archivo esta pegado al fin del ultimo exponente, en cuyo caso no pasa por el estado\r
 275                            de EXP_FIN (y, por ende, no se pueden hacer las asignaciones correspondientes }\r
 276                          val(coeficiente, rCoef, code); { convierte el coeficiente en real }\r
 277                          val(exponente, iExp, code); { convierte el exponente en integer }\r
 278                          if iExp < TAM { si el exponente es menor que el tama¤o maximo permitido ... }\r
 279                             then if poliN = 1 then v1[iExp] := rCoef { asigna el valor correspondiente }\r
 280                                               else v2[iExp] := rCoef { al polinomio correspondiente }\r
 281                             else est := ERROR; { si no es menor, pone el estado en ERROR }\r
 282 {DEBUG    writeln(' --> cargarVectores: FIN'); {}\r
 283 {DEBUG    writeln('     v[', iExp,'] = ', rCoef:1:1);}\r
 284                          coeficiente := ''; { una vez asignados, vacia los valores del coeficiente y el }\r
 285                          exponente := '';   { exponente para poder realizar las lecturas de los proximos }\r
 286                          { fin del codigo identico a EXP_FIN }\r
 287                          if poliN = 2 then cargarVectores := true { si se leyeron los 2 polinomios, devuelve true }\r
 288                                       else cargarVectores := false; { si no se leyeron los dos, devuelve false }\r
 289                          seguir := false; { poner seguir en false para que se termine el bucle }\r
 290                     end;\r
 291                 ERROR:  { Si hubo un error ... }\r
 292                    begin\r
 293                         cargarVectores := false; { Se devuelve false (hubo un ERROR, no se leyeron bien los vectores) }\r
 294                         seguir := false; { seguir se pone en false para que termine el bucle }\r
 295                    end;\r
 296            end; { case }\r
 297 {DEBUG    writeln(' --> cargarVectores: EN CICLO WHILE PRINCIPAL'); {}\r
 298 {DEBUG    writeln('     c: ',ord(c),' | est: ',ord(est),' | poliN: ',poliN,' | coeficiente: ', {}\r
 299 {DEBUG                  coeficiente,' | exponente: ',exponente); {}\r
 300          end; { while }\r
 301 {DEBUG    writeln(' --> cargarVectores: SALIDA'); {}\r
 302 {DEBUG    writeln('     c: ',ord(c),' | est: ',ord(est),' | poliN: ',poliN,' | coeficiente: ', {}\r
 303 {DEBUG                  coeficiente,' | exponente: ',exponente); {}\r
 304          close(f); { se cierra el archivo de lectura de datos }\r
 305     end; { cargarVectores }\r
 306 \r
 307     {########################################################}\r
 308 \r
 309 { Continuacion del programa principal }\r
 310 \r
 311 var\r
 312    i: integer; { variable auxiliar }\r
 313    v1, v2: vector;\r
 314    resultado: boolean;\r
 315 \r
 316 begin { Comienzo del programa principal }\r
 317      resultado := cargarVectores(v1, v2);\r
 318      {if not resultado then exit;}\r
 319      writeln('Polinomio 1:');\r
 320      for i := TAM - 1 downto 0 do\r
 321             if v1[i] <> 0 then\r
 322               begin\r
 323                    if v1[i] < 0 then write(' - ', abs(v1[i]):1:2)\r
 324                                 else write(' + ', v1[i]:1:2);\r
 325                    if i <> 0 then write('*X^', i);\r
 326               end;\r
 327      writeln;\r
 328      writeln('Polinomio 2:');\r
 329      for i := TAM - 1 downto 0 do\r
 330             if v2[i] <> 0 then\r
 331               begin\r
 332                    if v2[i] < 0 then write(' - ', abs(v2[i]):1:2)\r
 333                                 else write(' + ', v2[i]:1:2);\r
 334                    if i <> 0 then write('*X^', i);\r
 335               end;\r
 336      writeln;\r
 337      writeln(ord(resultado));\r
 338 end.