DG Log

Usando Luna - Clase C++ para facilitar el acceso a clases desde Lua.

2011-02-16T03:00:00Z

Usando Luna - Clase C++ para facilitar el acceso a clases desde Lua.

Lua no soporta directamente el binding a clases de C++, pero provee una API y mecanismos de extensión que lo hacen posible. Lua reconoce sólo funciones con la forma int(T::)(lua_State). Sin embargo, usando Luna es posible registrar clases y métodos.

Existen muchas bibliotecas para facilitar el binding a clases de C++. Decidí mostrar Luna porque no es muy conocida y es super sencilla. Luna no tiene ninguna dependencia y es sólamente un header. Mientras que otras bibliotecas tienen grandes dependencias (como boost) y un alto uso de metaprogramación (con ciertas ventajas, por supuesto).

Aún así, Luna provee todo lo que un desarrollador promedio de C++ necesita para agregar algo de scripting a su programa.


  #include <lua.hpp>

template<class T> class Luna {
  public:
    static void Register(lua_State *L) {
      lua_pushcfunction(L, &Luna<T>::constructor);
      lua_setglobal(L, T::className);

      luaL_newmetatable(L, T::className);
      lua_pushstring(L, "__gc");
      lua_pushcfunction(L, &Luna<T>::gc_obj);
      lua_settable(L, -3);
    }

    static int constructor(lua_State *L) {
      T* obj = new T(L);

      lua_newtable(L);
      lua_pushnumber(L, 0);
      T** a = (T**)lua_newuserdata(L, sizeof(T*));
      *a = obj;
      luaL_getmetatable(L, T::className);
      lua_setmetatable(L, -2);
      lua_settable(L, -3); // table[0] = obj;

      for (int i = 0; T::Register[i].name; i++) {
        lua_pushstring(L, T::Register[i].name);
        lua_pushnumber(L, i);
        lua_pushcclosure(L, &Luna<T>::thunk, 1);
        lua_settable(L, -3);
      }
      return 1;
    }

    static int thunk(lua_State *L) {
      int i = (int)lua_tonumber(L, lua_upvalueindex(1));
      lua_pushnumber(L, 0);
      lua_gettable(L, 1);

      T** obj = static_cast<T**>(luaL_checkudata(L, -1, T::className));
      lua_remove(L, -1);
      //lua_pop(L, 1);
      return ((*obj)->*(T::Register[i].mfunc))(L);
    }

    static int gc_obj(lua_State *L) {
      T** obj = static_cast<T**>(luaL_checkudata(L, -1, T::className));
      delete (*obj);
      return 0;
    }

    struct RegType {
      const char *name;
      int(T::*mfunc)(lua_State*);
    };
};

// ***************** Luna termina acá ***********************

class Foo {
  public:
    Foo(lua_State *L) {
      printf("in constructor\n");
      printf("argument: %d\n", luaL_checkint(L, -1));
      lua_pop(L, 2);
    }

    int foo(lua_State *L) {
      printf("in foo\n");
      return 0;
    }

    ~Foo() {
      printf("in destructor\n");
    }

    int Something(lua_State *L)
    {
            printf("something\n");
            return 0;
    }

    static const char className[];
    static const Luna<Foo>::RegType Register[];
};

const char Foo::className[] = "Foo";
const Luna<Foo>::RegType Foo::Register[] = {
  { "foo", &Foo::foo },
  { "Something", &Foo::Something },
  { 0 }
};

int main()
{
        lua_State *L = lua_open();
        luaL_openlibs(L);
        Luna<Foo>::Register(L);
        luaL_dofile(L, "luna.lua");
        lua_close(L);

        return 0;
}

Luego en un archivo “luna.lua”:


  foo = Foo(5)
foo:Something()
foo:foo()
print(foo[0])

La primer parte es todo Luna, la segunda parte es un sencillo ejemplo de como utilizarla.

En conclusión, para usar Luna se necesita que la clase tenga un const char* className donde ponemos el nombre con que la clase será expuesta a Lua. Además un arreglo de RegType donde la primer propiedad es el nombre del método que se verá en Lua y la segunda es el método en C++. Finalmente registrar la clase con Luna::Register.

Para más información visitar:

LunaWrapper

Binding code to Lua

Solución al tour del caballo en C++

2011-02-01T03:00:00Z

Solución al tour del caballo en C++

El problema del tour del caballo (o recorrido del caballo) es un problema matemático que involucra a un caballo en un tablero de ajedrez. El caballo es ubicado en alguna casilla del tablero y, moviendolo de acuerdo a las reglas del ajedrez, debe visitar cada casilla exactamente una vez. El tour del caballo se dice cerrado si finaliza en la misma casilla en la que comenzó, y abierto en caso contrario.

Aquí publico una forma de solucionar el problema del tour abierto utilizando el algoritmo de Warnsdorff. Este algoritmo es un algoritmo ávido que siempre obtiene solución, consiste en mover el caballo a la casilla que menor cantidad de movimientos inmediatamente siguiente ofrece.

Dicho de otra forma más algorítmica, de todas las casillas a la que podemos mover el caballo (según el movimiento del caballo y sin contar las que ya visitamos), lo movemos a la que en el movimiento siguiente nos ofrezca menor cantidad de movimientos.

No es difícil de implementar este algoritmo, y aquí está:


  // Knight's tour

#include <iostream>
#include <vector>
#include <set>

using namespace std;
typedef pair<int, int> ip;

inline void MK(int x, int y, int s, set<ip> &ss)
{
        if (x >= 0 && y >= 0 && x < s && y < s)
        {
                ss.insert(make_pair(x, y));
        }
}

int main()
{
        // Size x Size
        int size = 8;

        // Posicion inicial
        // Arriba a la izquierda es (0, 0)
        ip start(0, 0); // Menor que size, indexado en cero.


        vector< vector< set<ip> > > kgraph(size, vector< set<ip> >(size));
        // Hacer el grafo del caballo
        for (int i = 0 ; i < size ; i ++)
        {
                for (int j = 0 ; j < size ; j ++)
                {
                        set<ip> &ss = kgraph[i][j];
                        static int vx[] = {2, 2, -2, -2, 1, -1, 1, -1};
                        static int vy[] = {-1, 1, -1, 1, 2, 2, -2, -2};
                        for (int k = 0 ; k < 8; k ++)
                                MK(i + vx[k], j + vy[k], size, ss);
                }
        }

        int c = 1;
        vector< vector<bool> > v(size, vector<bool>(size, false));
        v[start.first][start.second] = true;

        // Algoritmo de Warnsdorff
        while (true)
        {
                ip pmin;
                int min = 64;

                set<ip> &s = kgraph[start.first][start.second];
                set<ip>::iterator it = s.begin();
                // Buscar la casilla posible que tiene la menor cantidad de
                // movimientos posibles
                while (it != s.end())
                {
                        int siz = kgraph[it->first][it->second].size();
                        if (!v[it->first][it->second] && siz <= min)
                        {
                                pmin = *it;
                                min = siz;
                        }
                        ++ it;
                }
                if (min == 64)
                        break;

                for (int i = 0 ; i < size ; i ++)
                {
                        for (int j = 0 ; j < size ; j ++)
                        {
                                kgraph[i][j].erase(pmin);
                        }
                }

                c ++;
                v[pmin.first][pmin.second] = true;
                cout << (char)(pmin.first + 'A') << pmin.second+1 << " ";
                start = pmin;
        }
        cout << endl;

        return 0;
}

Usando este código y python+pycairo hice algunos videos ilustrativos :)

En tablero de 8x8:

En tablero de 24x24:

Resolver el problema del tour cerrado es mucho más difícil, y no se conoce ningún algoritmo ávido. Uno de los mejores resultados obtenidos es usando redes neuronales artificiales.

Saludos. Diego.

Extraer datos y dar formato a la salida de algún programa o archivo usando AWK

2010-12-18T03:00:00Z

Extraer datos y dar formato a la salida de algún programa o archivo usando AWK

Es común querer extraer sólo una porción de información de la salida de algún programa, o del contenido de un archivo. Y a la vez querer darle cierto formato a esa salida, indicando que datos estás obteniendo. Utilizando AWK esto es muy fácil. AWK es un lenguaje de programación diseñado para procesamiento de texto (más sencillo que perl).

Por cada línea de texto que reciba de entrada, AWK diferencia “fields” (campos). Para acceder a cada campo utilizamos la sintaxis $1, $2, … en donde cada número indica el field al que queremos acceder. Los campos se dividen por algún caracter, por defecto el espacio. Entonces, si por ejemplo AWK recibe la línea: “Diego dglog.com.ar 2010” (sin las comillas). Los campos serán $1 = Diego, $2 = dglog.com.ar, $3 = 2010. Hay un caso especial, $0, que se refiere a la línea completa.

Un punto fuerte de AWK es el uso de expresiones regulares para detectar patrones y así quedarnos con sólo los datos que necesitamos. Para invocar AWK hacemos:

$ awk '/patrón 1/ { ... código a ejecutar si se cumple el patrón 1 ... }
      /patrón 2/ { ... código a ejecutar si se cumple el patrón 2 ... }
      ...'

Muy útil nos resulta la función printf, que funciona tal cual la de C. Veamos un ejemplo, si ejecuto ‘ls -g’ en el directorio donde guardo el blog, obtengo:

total 40
-rw-r--r-- 1 users  666 Sep 10 07:06 acerca_de.html
drwxr-xr-x 2 users 4096 Dec 18 13:05 articles
-rw-r--r-- 1 users  328 Sep 10 12:44 articles.html
drwxr-xr-x 2 users 4096 Dec 18 13:11 blog
drwxr-xr-x 2 users 4096 Sep 10 06:23 feed
drwxr-xr-x 2 users 4096 Oct 22 16:56 images
-rw-r--r-- 1 users  190 Sep 10 05:15 index.html
-rw-r--r-- 1 users  252 Aug 20 17:01 misc.html
-rw-r--r-- 1 users 1864 Dec 18 12:53 stylesheet.css
drwxr-xr-x 2 users 4096 Sep 20 21:25 todo

Supongamos que queremos extraer sólamente el nombre del archivo, y el tamaño. Podemos detectar que el tamaño es $4, y como el nombre del archivo es el último, podemos usar $NF que indica el último campo. Entonces hacemos:

$ ls -g | awk '{printf "%s: %d Kb\n", $NF, $4;}'
40: 0 Kb
acerca_de.html: 666 Kb
articles: 4096 Kb
articles.html: 328 Kb
blog: 4096 Kb
feed: 4096 Kb
images: 4096 Kb
index.html: 190 Kb
misc.html: 252 Kb
stylesheet.css: 1864 Kb
todo: 4096 Kb

Con printf indicamos que %s se reemplace por $NF, y %d por $4, donde el primero es un string (por eso %s) y el segundo un entero (por eso la %d). Está casi perfecto, sólo que la primer línea (“total 40”) no nos sirve, así que especificamos como patrón, que la ignore, usando el caracter ’!’ de la siguiente manera:

$ ls -g | awk '!/^total/{printf "%s: %d Kb\n", $NF, $4;}'
acerca_de.html: 666 Kb
articles: 4096 Kb
articles.html: 328 Kb
blog: 4096 Kb
feed: 4096 Kb
images: 4096 Kb
index.html: 190 Kb
misc.html: 252 Kb
stylesheet.css: 1864 Kb
todo: 4096 Kb

Y ahora sí quedó perfecto :). Una cosita más, el caracter de separación de campo se puede cambiar con la opción -F, por ejemplo, si queremos que los campos se separen por medio de la coma, ejecutamos:

$ awk -F, '{...}'

Awk es mucho más que esto, es un lenguaje de programación en el que se pueden hacer muchos scripts interesantes y muchos más complejos. Pero siempre viene bien saber al menos algo de cada herramienta.

Para finalizar, también se lo puede usar para extraer información de un sitio web (descargando el código fuente de la página con curl). Por ejemplo, aquí un script que escribí para extraer datos del clima de Santa Fé (Argentina). Es cuestión de ponerse a ver un poco el código fuente del sitio web y detectar dónde está la información que buscamos.

Saludos, Diego.

Acceder al clipboard desde la terminal con xclip

2010-12-16T03:00:00Z

Acceder al clipboard desde la terminal con xclip

Muchas veces me ha resultado útil poder acceder (modificar y leer) el clipboard. Esto se puede hacer con el programa xclip de manera muy sencilla.

Primero debemos instalar el programa xclip, se puede encontrar en los repositorios de las distribuciones de linux más conocidas.

Existen tres selecciones o clipboards, estas son:

Primaria: La selección primaria y la más común, creo. Es la que se copia con sólo seleccionar algo, y luego se pega con el click del medio del mouse.
Secundaria: Esta selección es la que menos se usa en aplicaciones.
Clipboard: Esta es la que se se copia con Ctrl+C y se pega con Ctrl+V.

Para mostrar lo que tenemos guardado en las selecciones primaria, secundaria y clipboard se utiliza “primary”, “secondary” y “clipboard” respectivamente, junto con la opción -selection. De la siguiente manera:

xclip -o -selection "primary"
xclip -o -selection "secondary"
xclip -o -selection "clipboard"

Donde -o es por “output” (salida).

Si, por ejemplo, queremos enviar el contenido de la selección primaria a un archivo llamado ‘salida’, podemos hacer:

xclip -o "primary" > salida

Si en cambio queremos apendizar la selección del clipboard al archivo llamado ‘salida’, podemos hacer:

xclip -o "clipboard" >> salida

Donde > y » se usa para redirigir la salida estándar a un archivo. En el primer caso se sobreescribe todo el archivo (se crea si no existe) y en el segundo caso se pone al final del mismo.

Para cargar alguna selección al clipboard se utiliza -selection seguido de la selección que queremos modificar, por ejemplo:

echo "texto" | xclip -i -selection "primary"
echo "texto" | xclip -i -selection "secondary"
echo "texto" | xclip -i -selection "clipboard"

cargará ‘texto’ en las selecciones primaria, secundaria y clipboard, respectivamente. La opción -i es para indicar “input” (entrada), que en realidad es opcional.

También podemos cargar en la selección el contenido de un archivo, de la siguiente manera:

xclip -selection "clipboard" < nombre_del_archivo

Saludos, Diego.

Múltiples layouts de teclado con setxkbmap

2010-12-15T03:00:00Z

Múltiples layouts de teclado con setxkbmap

Para tener múltiples layouts y poder intercambiar entre ellos con alguna combinación de teclas, podemos utilizar el siguiente comando:

setxkbmap -option grp:alt_shift_toggle es,ru

Con ese comando elegimos los layouts es (español) y ru (ruso), y para intercambiar de uno a otro se utiliza la combinación de teclas alt+shift, para otras combinaciones de teclas, hay que cambiar altshift_toggle_ por alguno de las siguientes:

alt_shift_toggle: Alt+Shift (la elegida anteriormente).
ctrl_shift_toggle: Ctrl+Shift.
alts_toggle: Ambas teclas Alt.
ctrls_toggle: Ambas teclas Ctrl.

Se pueden especificar más layouts, y el cambio irá circularmente del actual al siguiente. Por ejemplo, para poner los layouts español (es), USA (us) y ruso (ru), y que el cambio sea al presionar Ctrl+Shift, hacemos:

setxkbmap -option grp:ctrl_shift_toggle es,us,ru

Una opción más que a veces puede resultar útil, es que se pueda hacer el cambio temporal teniendo presionada la tecla AltGr, si estamos en el layout ruso por ejemplo, y queremos escribir rápido un caracter con el layout español sería muy lento presionar Alt+Shift para ir al layout español, escribir el caracter deseado y Alt+Shift de nuevo para volver. En cambio, con el siguiente comando:

setxkbmap -option grp:switch,grp:alt_shift_toggle es,ru

mientras tengamos presionada AltGr el layout será el siguiente, hasta que la tecla se suelte.

Saludos, Diego.