Dígitos de control de una cuenta bancaria

Cálculo de dígitos de control de una cuenta bancaria

Hoja de cálculo Excel (Libro de Excel 97-2003) para calcular los dos de dígitos de control de una cuenta bancaria.

El cálculo de los dígitos de control se realiza a partir de los códigos de banco, sucursal y cuenta, introduciéndolos en las celdas Excel dígito a dígito.

Esta hoja Excel permite conocer el mecanismo de cálculo de ambos dígitos de control, mediante:

  • los textos explicativos que contiene la hoja,
  • su diseño de cálculo por fases (datos de entrada, parámetros de cálculo, resultados intermedios y resultados finales) y
  • las fórmulas visibles dentro de sus celdas.

GNU Plot, TOL, Html2Pdf y series temporales

Informes gráficos en PDF con GNU Plot + TOL + Two Pilots Html2Pdf

En la documentación adjunta a este post se cuenta el proceso de investigación sobre cómo automatizar la generación de informes con gráficos de series temporales mediante la combinación de GNU Plot con TOL con Html2Pdf de Two Pilots. El objetivo es mecanizar informes gráficos sin intervención humana.

Se presentan cuatro ejemplos, crecientes en complejidad:

  • El primero genera un gráfico simple en formato GIF utilizando GNU Plot, se trata de un programa de demostración de GNU Plot ligeramente modificado.
  • El segundo muestra la generación de un gráfico en formato GIF de una serie temporal larga con datos que proceden del Banco de Canada (Bank of Canada).
  • El tercero muestra cómo generar un gráfico en formato GIF con una serie temporal almacenada en el formato BDT de TOL. También se construye un fichero HTML que contiene el gráfico y lo convierte a PDF llamando tanto a GNU Plot como al conversor a PDF (Two Pilots Html2Pdf) desde TOL.
  • En el cuarto se genera el mismo gráfico que en el tercero pero en 3 formatos diferentes JPEG, GIF y PNG, se insertan los tres gráficos dentro de una página HTML y se produce el PDF utilizando la mejor calidad posible para la generación de los JPEG internos del PDF. Como se explica en el fichero PDF adjunto, al final de este post, el formato que proporciona mejores resultados es el PNG (formato que desde hace tiempo me gusta mucho, por ejemplo, todas las imágenes de este web están en formato PNG).
  • Finalmente en el quinto se utiliza multiplot para generar un gráfico del estilo de los que se emplean en los mercados bursátiles con datos de la operadora de telecomunicaciones Jazztel. También en este ejemplo, dejo de utilizar la extensión de demostración de los ficheros de GNU Plot (.dem) para utilizar la genuina (.plt).

Adjunto a continuación un trozo del código (el código fuente completo se puede ver en el documento adjunto a este post) donde se generan las especificaciones para GNU Plot a partir de una plantilla e igualmente para la página HTML y se invoca a GNU Plot y a Two Pilots Html2Pdf. La plantilla para GNU/Plot está inserta en el propio código TOL y la plantilla para la página HTML se lee de un fichero externo:


///////////////////////////////////////////////////////////////////
// GnuPlot prototype
///////////////////////////////////////////////////////////////////
Text ploSed =
"
set term gif font 'arial' 10 size SIZWID, SEDHEI
set output 'FILGIF'
set datafile separator ';'
set title 'GRATIT' textcolor lt 3 font 'arial,14'
set style data lines
set timefmt '%d/%m/%Y'
set xdata time
set xlabel 'LABELX' textcolor lt 3 font 'arial,12'
set xrange [ 'DTEINI':'DTEEND' ]
set xtics rotate by 90
set format x '%d/%m/%Y'
set ylabel 'LABELY' textcolor lt 3 font 'arial,12'
set yrange [ 0 : ]
set format y '%g'
set grid
set key left
plot 'FILDAT' using 1:2 t 'SERNAM'
reset
";


///////////////////////////////////////////////////////////////////
// Dates and names
///////////////////////////////////////////////////////////////////
Text iniTxt = FormatDate(First(UniqueUsers), "%d/%m/%Y");
Text endTxt = FormatDate(Last (UniqueUsers), "%d/%m/%Y");
Text serNam = Name(UniqueUsers);


///////////////////////////////////////////////////////////////////
// Build and write the GnuPlot command file
///////////////////////////////////////////////////////////////////
Text ploDem = ReplaceTable(ploSed,
  [[ [["SIZWID",  "800"]], [["SEDHEI",  "500"]],
     [["FILGIF", filGif]],
     [["GRATIT", "Demo: BDT to GIF Chart"]],
     [["LABELX", "Weeks"]],
     [["DTEINI",  iniTxt]], [["DTEEND", endTxt]],
     [["LABELY", serNam]],
     [["FILDAT", filDat]],
     [["SERNAM", serNam]] ]], 1);
Text WriteFile(filDem, ploDem);


///////////////////////////////////////////////////////////////////
// Run GnuPlot
///////////////////////////////////////////////////////////////////
Text cmdExe = "C:\\asc\\Bin\\gnuplot\\bin\\pgnuplot";
Text cmdTxt = cmdExe+" "+filDem;
Real cmdRun = System(cmdTxt); // Execute gnuplot


///////////////////////////////////////////////////////////////////
// Makes a Pdf file from the Html page
///////////////////////////////////////////////////////////////////
Text codHtm = ReplaceTable(ReadFile(filSed),
  [[ [["SIZWID",  "800"]], [["SEDHEI",  "500"]],
     [["FILGIF", filGif]],
     [["PLOCOD", ploDem]] ]], 1);
Text WriteFile(filHtm, codHtm);


///////////////////////////////////////////////////////////////////
// Makes a Html page from a seed
///////////////////////////////////////////////////////////////////
Text pdfExe = "\""+"C:\\Archivos de programa\\Two Pilots\\"+
                      "HTML2PDF Pilot\\HTML2PDF_Pilot.exe"+"\"";
Text pdfInp = "C:\\asc\\App\\GnuPlot.Test\\"+filHtm;
Text pdfOut = "C:\\asc\\App\\GnuPlot.Test\\"+filPdf;
Text pdfCmd = pdfExe+" "+             // Executable pdf convertor
              pdfInp+" "+             // Input file
              pdfOut+" "+             // Output file
              " /jpeg 100 /author asalmeron@asolver.com";

Real pdfRun = System(pdfCmd); // Execute html to pdf conversion
    

La documentación adjunta incluye, en el mismo orden anterior (salvo los tres códigos fuente HTML que están al final del todo): el código completo de especificaciones para GNU Plot, el código fuente TOL, los datos de series temporales utilizados en los gráficos y los ficheros de mandatos.

Ajax para el cambio de divisas

Conexión Ajax con el Rss del Banco de Canada para el cambio de divisas

¿Aburrido de tener que ir divisa a divisa buscando el cambio cada día, para copiarlo e introducirlo en hojas Excel?. Así estaba yo hasta que me programé esta combinación de JavaScript y PHP para leer los RSS (Really Simple Syndication en formato XML) del Banco de Canada (Bank of Canada), de siempre mi banco central favorito, para obtener una tabla de cambios con mis divisas habituales y poder pegar con comodidad esa tabla en las hojas Excel que necesitaban esos cambios actualizados.

El resultado es una página web, con un estilo vintage muy a mi gusto, en colores de computador clásico y con la preciosa Lucida Console por tipo de letra.

Todo el código JavaScript y PHP puede consultarse en PDF al final de este post, sólo pongo a continuación un par de funciones, la primera JavaScript y la segunda PHP, que muestran como se puede tener un estilo de programación similar con leguajes de programación diferentes.


///////////////////////////////////////////////////////////////////
   function XmlGetValue(itm, atr)

// PURPOSE: Returns a text value. If atr = cb:value and itm =
// ...<cb:value frequency="business" decimals="4">0.9947</cb:value>...
// first gets " frequency="business" decimals="4">0.9947<"
// and returns 0.9947
///////////////////////////////////////////////////////////////////
{
  var tmp = TxtBetween2Tag(itm,"<"+atr,"/"+atr+">");
  var txt = TxtBetween2Tag(tmp,">","<");
  return(txt);
}

///////////////////////////////////////////////////////////////////
   function GetRssFile()
   
// PURPOSE: Gets the contents of an external Rss feed and saves its
// contents to the cached file on the server.
///////////////////////////////////////////////////////////////////
{
  global $rssUrl, $pthFile;
  $contents=file_get_contents($rssUrl); // Fetch the Rss file
  $fp=fopen($pthFile, "w");             // Open local file for write
  fwrite($fp, $contents);     // Write contents of Rss to cache file
  fclose($fp);                          // Close the local file
}
  

Contador de separadores de campos

En una gran aseduradora nos volcaban ficheros inmensos de datos de operaciones sobre polizas desde el host, ficheros con millones de registros. Eran ficheros planos y ellos mismos elegían el carácter separador de campos. Esos ficheros los subíamos, a su vez, a otra base de datos que los cargaba utilizando, para interpretar la separación de campos, el carácter indicado en cada caso. Esta carga se realizaba empleando el programa de carga suministrado junto con el sistema de gestión de la base de datos.

El proceso de carga era lento y, además, con frecuencia, el carácter que habían elegido, aparecía en algún campo de texto de algún registro. Por ejemplo, elegían el asterisco y algunos campos de observaciones contenían asteriscos. Al llegar al primer registro con más separadores de los esperados el proceso de carga abortaba tras horas de ejecución.

La solución era programar un comprobador de ficheros, muy rápido, que antes de iniciar el proceso de carga, comprobara que todas las líneas del fichero contuvieran el mismo números de caracteres separadores de campo, asumiendo como correcto el número de separadores de la primera línea del fichero. Y sólo comenzar la carga a la base de datos tras comprobar que el fichero era correcto.

Hacía ya mucho tiempo que no programaba en C y esta era una ocasión para volver a él. El programa se llama chksep.exe, esta hecho en lenguaje C en pocas horas, por lo que seguro que se puede mejorar. Se ejecuta como chksep 42 < fichero.txt, donde el 42 es el código ASCII del caracter *, que era el separador de campos habitual, aunque se puede elegir cualquier otro carácter, por ejemplo, chksep 59 < fichero.txt, para el punto y coma.

El programa visualiza las líneas donde el número de separadores de campo es diferente al de la primera línea. En un computador portatil normal este programa es capaz de revisar un Giga en 2 minutos 15 segundos, lo que equivalía con los ficheros reales que nos daban a unos 800.000 registros por minuto. Por lo que en 5 ó 10 minutos se podía evitar que luego abortara una carga de horas. El programa también cuenta el número de líneas del fichero.

A continuación pongo el ciclo principal del programa y en el fichero PDF adjunto a este post el código fuente completo.

Me gustan mucho los programas eficaces de pocas líneas de código y que sean eficientes ya lo considero un regalo.


while((chrInp=getc(stdin)) != EOF)
{
       if(chrInp==sepChr) { sepCnt++; }     /* Es un separador */
  else if(chrInp==EOL)                 /* Es un salto de linea */
  {
    if(linCnt==1)                  /* Estabamos en la 1ª linea */
    {
      sepFst = sepCnt;   /* Referencia para el resto de lineas */
      printf("\n[%d] [%s] en la primera linea.", sepFst, sepStr);
    }
    else                                       /* Linea normal */
    {
      if(sepFst!=sepCnt)        /* Faltan o sobran separadores */
      {
        printf("\nlinea %d: [%d] [%s] en vez de [%d].",
               linCnt, sepCnt, sepStr, sepFst);
      }
    }
    linCnt++;             /* Incrementar el contador de lineas */
    sepCnt = 0;     /* Poner a cero el contador de separadores */
  }
}
printf("\nProcesadas [%d] lineas.", linCnt);
  

Aprender a contar euros (€)

Series numéricas, de colores y figuras geométricas

Cinco páginas de ejercicios para aprender a contar y sumar billetes de euros.

Riesgos de crédito para el Banco de Santander

Como becario trabaje en el desarrollo en Prolog II de un sistema experto de la clase MYCIN para la evaluación del riesgos de crédito para el Banco de Santander, en el área de créditos a empresas. La beca estaba dentro del marco de colaboración entre el Banco de Santander y el grupo de investigación creado por José Cuena en la Universidad Politécnica de Madrid (UPM).

Prolog es un lenguaje de programación lógico e interpretado con un mecanismo de inferencia mediante encadenamiento en profundidad de reglas. Por estas fechas, al poco tiempo de aprender a programar en Prolog (en especial Prolog II de Marsella), cree dos reglas capaces de procesar a otro conjunto de reglas, que recibían como argumentos de entrada, pero lo hice de forma que la exploración de dicho conjunto de reglas realizaba en anchura, no en profundidad. Mi director José Cuena me dijo divertido: «le dejo un motor de inferencia y lo primero que hace usted es cambiarle la dirección». Aquellas dos reglas ayudaron a la creación de sistemas expertos de acumulación y transmisión de evidencia (del tipo MYCIN, con una orientación semibayesiana) a partir de los a priori de los expertos, ya que la acumulación de la evidencia aportada por un conjunto de reglas necesita su evaluación conjunta, esto es en anchura, para poder ser combinada.

  • Scholar, «Risk assessment expert system», Santander Bank, Madrid, 1985-1986.
  • Becario, «Sistema experto de evaluación de riesgos», Banco de Santander, Madrid, 1985-1986.