snatverk

Cacti error: file size limit exeeded

2012-01-21T12:09:00.001Z

I work with cacti to monitorize sensors and temperature. The other day I got an error related with file size limit. The error message is similar to this:

/bin/bash: line 1: 23691 File size limit exceededphp /var/www/html/cacti/poller.php > /dev/null 2>

This occurs because the cati log file has exceeded the limit. To solve this[1], we can include the cacti log file in logrotate. So we need logrotate installed in our system. In resume we must do the following steps:

1. We create a new logrotate file for cacti.

# vim  /etc/logrotate.d/cacti

2. Add the followings lines:

/var/www/html/cacti/log/cacti.log {
	# keep two weeks of versions online
	rotate 14
	# rotate the log each day
	daily
	# compress the logs
	compress
	# create new file with the correct user/group attributes
	create 644 apache apache
	# add a YYYYMMDD extension instead of a number
	dateext
}

3. Then, we force the rotation:

# logrotate -f /etc/logrotate.conf

References

[1] http://www.question-defense.com/2008/09/29/how-to-rotate-the-cacti-logs-file-cactilog
[2] Logrotate manual: http://linuxcommand.org/man_pages/logrotate8.html

Anti-SOPA blackout day

2012-01-18T21:31:00.001Z

How to work with states in PLY

2012-01-15T14:19:00.000Z

We have talked about PLY several times[1]. In this post I want to explain how to work and implement lexer states in PLY. In PLY documentation [2], you can find a whole explanation about the lexer states. I only pretend to show a very simple example with lexer states and how to use it in the parser code. The example shows how to ignore the content between two tokens and return it as a token.

How to build states

It is easy to create states. PLY wait to find the states variable. In this variable we specify the token and the type of state:

Inclusive: we extends the previous states for lexer. So we can use other tokens defined in the previous states.
Exclusive: we create a new state. In this case is necessary to implement an error state and a ignore state because we do not extends from previous tokens.

For instance:

states = (
    ('foo', 'exclusive'),

    ('bar', 'inclusive'), 
)

Then we join on these states to token variable.

Example

I want to show a very simple example that ignores all content and return it as a token. In some occasions we need to do it, for example to create a special ignore content node in the AST. Note the regular expression of the rule t_foo_CONTENT. This expression match all until #end string.

Lexer

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import ply.lex as lex

states = (
    ('foo', 'exclusive'),
)

tokens = ['foo', 'NUMBERS', 'END', 'CONTENT']

def t_NUMBERS(t):
    r'\d+'
    print 'General numbers '
    return t

def t_foo(t):
    r'foo'
    t.lexer.code_start = t.lexer.lexpos
    print 'I have detected foo token'
    t.lexer.begin('foo')
    return t

def t_foo_END(t):
    r'foo'
    print 'End of state foo'
    t.lexer.begin('INITIAL')
    return t


def t_foo_CONTENT(t):
    r'[^$]+\#end'
    return t

t_ignore = ' \t'

def t_foo_error(t):
    print 'Lexical error: "' + str(t.value[0]) + '" in line ' + str(t.lineno)
    t.lexer.skip(1)

def t_error(t):
    print 'Lexical error: "' + str(t.value[0]) + '" in line ' + str(t.lineno)
    t.lexer.skip(1)

def test(data, lexer):
    lexer.input(data)
    while True:
        tok = lexer.token()
        if not tok:
            break
        print tok

lexer = lex.lex()

if __name__ == '__main__':

    data = ''' foo  123 123 esto bla bla bla 
    #endfoo 123'''

    lexer.input(data)
    test(data, lexer)

_______________________________________________________

Parser

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import ply.yacc as yacc
from lexer import tokens

def p_start(p):
    ''' start : NUMBERS foo prod END '''
    p[0] = p[1]

def p_prod(p):
    ''' prod : CONTENT '''
    p[0] = p[1]

def p_error(p):
    print 'Syntax error at line ' + str(p.lexer.lineno)

parser = yacc.yacc()

if __name__ == '__main__':
    data = ''' 123 foo 321 #endfoo '''
    parser.parse(data)

    data = ''' 123 foo bla bla bla bla #endfoo '''
    parser.parse(data)

_______________________________________________________

When foo is detected, the DFA entries in a new state (foo state) and will be in this state until #endfoo is detected.

References

[1] Previous entries for PLY
[2] PLY webpage: http://www.dabeaz.com/ply/

How to configure a public ssh with dyndns?

2011-09-25T21:48:00.000+01:00

If you want a web server, ssh, ftp or any other service, you usually need a static IP. So, you have two options:

To pay for a static IP with your ISP
To use a dynamic DNS. Yes, dynamic DNS.

A few weeks ago, I wanted to install and configure a public ssh in my computer with dyndns. This weekend I have done it. In this post, I will show you how I did it.

1. Create an account in DynDNS

There are several providers that offer Dynamic DNS. One of best known is DynDNS. This site offers a free DNS until 2 hosts. You have to register and create a new host. This host is a name (under dyndns domain - *.dyndns-blog.com) which you have to connect. Other option is to create a new domain.

2. To install a virtual machine with Ubuntu

I have installed an Ubuntu server in a virtual machine. This is going to be my ssh server. So, you have to install at least openssh such as additional packages in the installation of ubuntu server.

Then you have to set up a static IP inside of your private network. For example, you can set up the IP 192.168.1.200. So you have to edit /etc/network/interface file and add the static IP.

# The primary network interface
auto eth0
iface eth0 inet static
address 192.168.1.200
netmask 255.255.255.0
gateway 192.168.1.1

To ensure that virtual machine is well installed and configured, you can reboot the virtual machine and try to connect from the phishical computer or other virtual machine.

3. Configure ddclient

Ddclient is a Perl client used to update dynamic DNS entries for accountson Dynamic DNS Network Services' free DNS service. The configuration is very simple.

$ sudo apt-get install ddclient

During the installation, the installer will ask us for username, password and the Dynamic DNS service provider. In linhost there is a complete tutorial to configure it. http://linhost.info/2008/12/ddclient-set-up-for-ubuntu/

Other posibility is to configure in the router instead of ddclient on server. Nowadays, routers have this service by default. You only need is to enable it.

4. Router

And finally, we have to activate the ssh port in the router and redirect the 22 port to virtual machine. This was a headache, because my router is special (Telefónica).

In resume we need to activate ssh service from WAN. In this point you can activate for example, Web Server (port 80) or any other.

Then you need to redirect the ports to virtual machine. In my case, I had to add an additional entry to NAT with port 22 to 192.168.1.200.

References

DynDNS: http://dyn.com/dns/dyndns-free/
Ubuntu help: https://help.ubuntu.com/community/DynamicDNS

GRID::Machine

2011-07-28T22:12:00.003+01:00

GRID::Machine is a perl module for Remote Procedure Calls over a SSH link. With this module, we can create, change directories, run remote programs, run perl functions, copy and compile with make automatically among other things.

Note that in the other machine is possible that GRID::Machine module does not installed. Moreover, they may be different versions. This is very useful, especially in heterogeneous systems.

How to install?

GRID::Machine is available from CPAN. So, you can install it with cpan command or cpanm.

$ cpanm GRID::Machine

Then you can check if the module was installed properly:

$ perl -MGRID::Machine -e 1

Example

The following code is a very simple example to show this module. We have a list of machines and we want to run ps command for each machine. After we create the GRID Machine object, we can write a subrutine. This function will be ran in the other machine. In this example, we print the host and finally we print the result.

_________________________________________________________

 1 #!/usr/bin/perl
 2 use strict;
 3 use GRID::Machine;
 4 
 5 # List of machines
 6 my @machines = qw/ localhost lab1 /;
 7 my %m = {};
 8 
 9 for (@machines) {
10     print "Creating object: $_\n";
11     my $gm = GRID::Machine->new(host=>$_, uses=>[qw(Sys::Hostname)]);
12     # We can installed a perl subrutine 
13     $gm->sub(hostname=> q{
14         print " ----------- Machine: ".hostname()." ---------\n";
15     });
16     $m{$_} = $gm;
17 }
18 
19 # ...
20 
21 # Now, we run ps command for all machines
22 for (@machines) {
23     print "\n";
24     print $m{$_}->hostname();
25     print $m{$_}->system("ps --sort -pcpu aux  | head -n 10");  
26 }
27 ________________________________________________________

References

Pythonbrew

2011-07-25T14:01:00.000+01:00

pythonbrew is a program to automate the building and installation of python in the users HOME. Pythonbrew is inspired by perlbrew, that we have just commented in a previous post.

The installation is very simple, actually, is like perlbrew.

$ curl -kLO http://github.com/utahta/pythonbrew/raw/master/pythonbrew-install
$ chmod +x pythonbrew-install
$./pythonbrew-install

This installation is in $HOME by default. If you want to install in other directory, we will need to set PYTHONBREW_ROOT variable.

Now, we can install any python version. For instance:

$ pythonbrew install 3.2
$ pythonbrew use 3.2

Some useful commands:

pythonbrew use : Switch a particular version in a current session.
pythonbrew switch: change system python version.
pythonbrew update: It updates pythonbrew version
pythonbrew list: It shows a list with all python installed.

References

Pythonbrew website

Perlbrew and cpanm

2011-07-22T19:15:00.000+01:00

Perlbrew is a software to install multiple perl versions in our system without root permissions. Perlbrew is installed in $HOME or in any directory of our file system (for example /opt/soft/perlbrew) with a simple environment variable.

Installing perlbrew

Perlbrew is very simple to install and configure it. In the first reference is explained how to install perlbrew in $HOME. So, I am going to explain a root installation/configuration.

$ sudo su -
# export PERLBREW_ROOT=/opt/perlbrew

# curl -L http://xrl.us/perlbrewinstall | bash  

Perlbrew will install in /opt/perlbrew directory. Now, we need some environment variables. For root, we only need the next line in the ~/.bashrc file.

#.bashrc file
source /opt/perlbrew/etc/bashrc

Now, we can install a particular perl version. For example:

$ perlbrew install perl-5.14.1

Now, the rest of system users need some environment variables to use perlbrew.

# File .bashrc of any user.
source /opt/perlbrew/etc/bashrc
PATH=/opt/perlbrew/bin/:$PATH

If we have a system with a lot of users and we haven't enough space, this would be a way to install and configure it.

Installing cpanm

The next step would be configure cpan for each perl version. Instead of to do that, we can install cpanm (cpan minus) and to save time. We can install cpanm with perlbrew directly or with the source package.

For example, we switch to perl 5.14 (previously installed)

1. With perlbrew:

$ perlbrew switch perl-5.14.1
$ perlbrew install-cpanm

2. Downloading the package:

$ perlbrew switch perl-5.14.1
$ curl -L http://cpanmin.us | perl - App::cpanminus

Install a perl module:

$ cpanm GRID::Machine

References

Modules

2011-07-09T19:53:00.000+01:00

The Environment Modules package provides for the dynamic modification of a user's environment via modulefiles. For example, we can have two o more gcc versions (gcc 4.3.5, gcc.4.6.0, etc). With a single command, we can use the appropriate gcc version.

For instance:

$ module list
Currently Loaded Modulefiles:
1) /java/sun1.6
$ module load gcc/4.6.0
$ module list
Currently Loaded Modulefiles:
1) /java/sun1.6 2) /gcc/4.6.0
$ gcc --version
gcc (GCC) 4.6.0
$ module del gcc
$ gcc --version
gcc (GCC) 4.1.2 20080704 (Red Hat 4.1.2-50)

The last line shows the gcc system version.

How to install?

Modules depends to tcl. If we have an ubuntu system, we need to install tcl8.4-dev (ubuntu package).

$ sudo apt-get install tcl8.4-dev

We download the program and install.

$ wget http://sourceforge.net/projects/modules/files/Modules/modules-3.2.8/modules-3.2.8a.tar.gz
$ tar xvzf modules-3.2.8a.tar.gz
$ cd modules-3.2.8a
$ ./configure
$ make
$ sudo make install

Then we have to run add.modules program in /usr/local/Modules/3.2.8/bin/

$ sudo /usr/local/Modules/3.2.8/bin/add.modules

This program will update PATH to module program and will add the information to skel user file.

Then, we have to create a soft link from Modules directory to bin directory.

$ cd /usr/local/Modules
$ sudo ln -s 3.2.8/bin/

Finally, we need to set the MODULEPATH variable in ~/.bashrc file

For example:

# bashrc file
MODULEPATH=/opt/env/

In this directory, we will have all sofware. For instance, gcc, icc, mathlab, etc.

Configuration

We need to create a single configuration file. With this file, we indicate to modules the PATH to find the appropiate files. For example, if we have installed the gcc 4.6.0 in our system:

______________________________________________________

#%Module -*- tcl -*-
#
proc ModulesHelp { } {
  puts stderr "\tThis module loads GNU gcc environment variables." 
}

module-whatis   "Loads GNU gcc environment." 
conflict icc
conflict ifort

prepend-path PATH "/opt/envhpc/gcc-4.6.0/bin" 
prepend-path LD_LIBRARY_PATH "/opt/envhpc/gcc-4.6.0/lib" 
prepend-path LD_LIBRARY_PATH "/opt/envhpc/gcc-4.6.0/lib64" 
prepend-path LD_LIBRARY_PATH "/opt/envhpc/mpc/0.9/lib" 
prepend-path LD_LIBRARY_PATH "/opt/envhpc/mpfr/3.0.1/lib" 
prepend-path LD_LIBRARY_PATH "/opt/envhpc/gmp/5.0.2/lib" 
prepend-path MANPATH "/opt/envhpc/gcc-4.6.0/man"

setenv CC gcc
setenv CXX g++
setenv F77 gfortran
setenv F90 gfortran

______________________________________________________

A complete Tcl code reference is in manual 4 of modules. See reference section to find more information. With module avail command and module add/delete, we can load and unload a particular version.

References

Instalación de gcc en linux

2011-07-04T23:05:00.000+01:00

Para instalar una nueva versión de GCC nuevo se necesitan algunas librerías:

libmpfr
GNU Multiple Precision Library (GMP)
MPC Library version 0.8.1

Depende del sistema operativo que tengamos y de la versión que queramos instalar se necesitarán más o menos librerías. Por ejemplo, Ubuntu, suele traer muchas de estas librerías instaladas por defecto. Por otra parte, se necesita una versión de estas librerías acorde a una determinada versión de gcc, pero, en el caso de que no se tenga, se puede proporcionar dentro del directorio tar.gz del código fuente de gcc y descomprimido en un directorio con el mismo nombre de la librería. En el momento del configure sabe de dónde cogerlo.

Nos bajamos el tar.gz del core de gcc (o gcc + g++ + fortran). Descomprimimos el tar.gz y luego creamos otro directorio aparte (build o cualquier otro nombre) que servirá para hacer el configure y el make. En la instalación de gcc no se puede hacer el configure y el make en el mismo directorio del fuente porque da un error, pero parece que algunas distribuciones como Ubuntu saben resolver estos conflictos.

$ tar xvzf gcc-core-4.6.0.tar.gz
$ mkdir build

Por ejemplo, para la versión 4.6.0:

$ cd ~
$ wget http://gcc.skazkaforyou.com/releases/gcc-4.6.0/gcc-core-4.6.0.tar.gz

Hacemos lo mismo con el código de C++/Fortran, etc. Descomprimimos y creamos el directorio build

$ cd ~
$ mkdir gcc
$ cd gcc
$ tar xvzf gcc-core-4.6.0.tar.gz
$ mkdir build

Desde este directorio hacemos el configure y el make:

$ ../gcc-4.6.0/configure --prefix=/opt/gcc4.6 --enable-languages=c,c++,fortran

Si hemos instalado todas las librarías necesarias, se nos creará en el directorio build el makefile. Por lo que hacemos:

$ make -j 2 # si tenemos 2 cores
# make install

Si combinamos esta forma de instalación con el programa modules de GNU, podemos tener en nuestro sistema varias versiones de gcc disponibles.

Referencias

GCC: http://gcc.gnu.org/
Prerequisitos: http://gcc.gnu.org/install/prerequisites.html
Configuración: http://gcc.gnu.org/install/configure.html

Generar ficheros excel con Python

2011-04-21T19:30:00.003+01:00

pyExcelerator es un módulo Python creado por Roman V. Kiseliov para escribir y leer datos en formato excel. Se necesita una versión superior a la 2.4 de python. La ventaja (opinión) de usar este módulo frente a otros como CSV, es que permite formatos unicode, se lee/escribe bien tanto en OpenOffice como en Microsoft Office y tiene una API muy sencilla.

Instalar módulo en Ubuntu

$ sudo apt-get install python-excelerator

Lo básico

Una vez instalado, vamos a lo básico. Comenzaremos por escribir algo. Decir que, si nos descargamos el módulo en http://sourceforge.net/projects/pyexcelerator/ , en él hay muchísimos ejemplos que nos pueden servir de guía para lo que queramos hacer.

____________________________________________

from pyExcelerator import *

# Instance the objects
workbook = Workbook()
worksheet = workbook.add_sheet("my first sheet")

# Write a row
worksheet.write(1, 1, "Example")
# Save the content
workbook.save('file.xls')
______________________________________

Lo que se hace es, instanciar un libro de trabajo y una hoja. Podemos crear tantas hojas de trabajo como queramos. A continuación escribimos en la posición (1,1) la palabra Example y guardamos con el nombre file.xls.

Dar formato

También podemos escribir con distintos tipos de letra, colores, cursiva, etc. Esto lo podemos hacer mediante la clase Font del módulo. Con el font, le indicamos todas las propiedades necesarias.

______________________________________

from pyExcelerator import *

# Instance the objects
workbook = Workbook()
worksheet = workbook.add_sheet("my first sheet")

# Style
font = Font()
font.name = "Arial"
font.colour_index = 1
font.bold = True
style = XFStyle()
style.font = font

# Write
worksheet.write(1, 1, "Example", style)

# Save the content
workbook.save('file.xls')

______________________________________

Esto también se puede hacer sobre el objeto style, puesto que internamente usa Font.

Leer a formato CSV

Para leer y poder procesar los datos, usamos la función parse_xls, a la que le pasamos un fichero y la codificación, que puede ser utf-8. Esta función, retorna todas las hojas worksheet y sus valores, por lo que tenemos que recorrerlas y por ejemplo, insertarlas en una matriz. A continuación se lista un ejemplo completo de como hacer esto. El siguiente código es una adaptación del código del autor del directorio examples.

Ejemplo completo

______________________________________
# -*- coding: utf-8 -*-
# This example was adapted from Roman V. Kiseliov
# in examples section project

from pyExcelerator import *

class Excel(object):
    def __init__(self, name_space='0'):
        self.column = 0
        self.row = 0
        self.workbook = Workbook()
        self.worksheet = self.workbook.add_sheet(name_space)

    def write_row(self, content):
        self.column = 0
        for i in content:
            self.worksheet.write(self.row, self.column, i)
            self.column += 1
        self.row += 1

    def write_with_format(self, content, bold=False, name='Arial', colour_index=4):
        font = Font()
        font.name = name
        font.colour_index = colour_index
        font.bold = bold
        style = XFStyle()
        style.font = font
        self.column = 0
        for i in content:
            self.worksheet.write(self.row, self.column, i, style)
            self.column += 1
        self.row += 1

    def save(self, filename='file.xls'):
        self.workbook.save(filename)

    @classmethod
    def read(self, filename, coding='utf-8', verbose=False):
        for sheet_name, values in parse_xls(filename, coding):
            matrix = [[]]
            if verbose:
                print 'Sheet = "%s"' % sheet_name.encode(coding,  'backslashreplace')
                print '----------------'
            for row_idx, col_idx in sorted(values.keys()):
                v = values[(row_idx, col_idx)]
                if isinstance(v, unicode):
                    v = v.encode(coding, 'backslashreplace')
                else:
                    v = `v`
                v = '%s' % v.strip()
                last_row, last_col = len(matrix), len(matrix[-1])
                while last_row <= row_idx:
                    matrix.extend([[]])
                    last_row = len(matrix)
                while last_col < col_idx:
                    matrix[-1].extend([''])
                    last_col = len(matrix[-1])
                matrix[-1].extend([v]
            if verbose:
                for row in matrix:
                    csv_row = ', '.join(row)
                    print csv_row
        return matrix

if __name__ == '__main__':
    print 'Generando xls ........... ',
    header = ['Nombre', 'Apellidos', 'DNI']
    excel = Excel()
    excel.write_with_format(header, bold=True)
    datos = [u'Tutú', u'Tiñi', '1239812H']
    excel.write_row(datos)
    datos = [u'Kaká', u'Asd', '8712382H']
    excel.write_row(datos)
    excel.save()
    print 'ok'

    print 'Leyendo datos ........... '
    Excel.read('file.xls', verbose=True)
    print '................... ok '
______________________________________

Este módulo contiene muchísimas más cosas. Escritura de fórmulas, imágenes, estilos, conversión a html, etc. En la sección de ejemplos del proyecto se puede ver en detalle todo esto.

Referencias

pyExcelerator project

Python: análisis de cubrimiento de código

2011-03-06T20:12:00.002Z

Una herramienta muy potente que tiene perl es el módulo Devel::Cover. Para python hay un módulo equivalente, coverage. Este tipo de programas, lo que hace es un análisis de cubrimiento de código, orientado sobre todo a los test. Esto es muy útil para saber si nuestros test de la aplicación cubren la totalidad del código (caso ideal) y si no, cuanto nos falta para llegar a ello, resaltando las partes de código ejecutadas y las que no.

Para instalarlo, podemos bajarnos las fuentes y compilarlas o usar el repositorio.

$ sudo apt-get install python-coverage

Es un programa muy fácil de usar. El programa dispone de una pequeña ayuda:

$ python-coverage help
Coverage.py, version 3.2
Measure, collect, and report on code coverage in Python programs.

usage: coverage [options] [args]

Commands:
    annotate    Annotate source files with execution information.
    combine     Combine a number of data files.
    erase       Erase previously collected coverage data.
    help        Get help on using coverage.py.
    html        Create an HTML report.
    report      Report coverage stats on modules.
    run         Run a Python program and measure code execution.
    xml         Create an XML report of coverage results.

Use "coverage help " for detailed help on any command.
Use "coverage help classic" for help on older command syntax.
For more information, see http://nedbatchelder.com/code/coverage

Generación de informes

Lo primero que tenemos que hacer es ejecutar el programa. Esto lo que hará es generar un fichero .coverage con la información de cubrimiento.

$ python-coverage run example02.py

Para ver los resultados, usamos la opción report:

$ python-coverage report -m example02.py
Name Stmts Exec Cover Missing
-----------------------------------------
example02 14 14 100%

Luego podemos generar el fichero html:

$ python-coverage html -d coverhtml
$ firefox coverhtml/index.html

Usar la API

Esto no acaba aquí. Si uno quiere, puede hacer un programa para ejecutar el análisis en los puntos del programa que se quiera y luego generar un informe.

La API está bien explicado, y la verdad, es bastante sencillo.Un ejemplo:

__________________________________________________

# -*- coding: utf-8 -*-
import coverage
cov = coverage.coverage()
cov.start()
def cuadrados(lista):
    """ Calcula el cuadro de los números de la lista
    >>> l = [0,1,2,3]
    >>> cuadrados(l)
    [0, 1, 4, 9]
    """
    return [n ** 2 for n in lista]

def _test():
    import doctest
    doctest.testmod()

_test()

cov.stop()
cov.html_report(directory='covhtml')

_______________________________________________

$ python mycov.py

El programa crea un directorio covhtml con los resultados.

Referencias

Extensión graphlog para Mercurial

2011-02-28T14:58:00.001Z

He encontrado una extensión muy útil en línea de comandos que imprime el log con todas las vías (branchs y clones) por los que ha pasado el proyecto. Es extensión se coloca en el .hgrc dentro de nuestro proyecto.

[extensions]
hgext.graphlog=

Ahora, usamos la opción glog de mercurial:

Trabajar con branchs en mercurial

2011-01-26T14:43:00.003Z

Una de las formas de trabajar en paralelo varios desarrolladores es mediante branchs. En mercurial, aparte de tener cada uno su propio clone, también es posible tener una o más ramas independientes. La forma de trabajo es la siguiente:

Se crea un branch:

$ hg branch new_branch

Donde new_branch es el nombre que le queremos dar. Para saber en qué branch estamos trabajando, usamos el mismo comando sin argumentos:

$ hg branch
new_branch

Ahora, la línea de trabajo es como se muestra en la siguiente figura:

La forma de trabajo en el branch como si estuviésemos en el default, con la diferencia de que se hacen los commit y los push sin que afecten a la rama principal (default). Entonces, ¿cómo podemos fusionar esos cambios?. Hacemos un merge desde la rama default hacia el new_branch.

$ hg merge new_branch

Bajar una rama conmutar entre ellas

Si queremos hacernos un clon cuando ya hay ramas creadas, por defecto nos bajaremos la rama default. Para conmutar a otra rama hacemos lo siguiente:

$ hg branch -f new_branch

Esto nos sitúa sobre la rama que queremos. Ahora tenemos que actualizar para traernos los últimos cambios:

$ hg update

De la misma forma, podemos conmutar de una rama a otra haciendo estos dos pasos.

Luego, el trabajo normal:

$ hg ci -m "..."
$ hg pull
$ hg push

Si queremos traernos los cambios de cualquier rama, hacemos un merge con la rama que queremos:

$ hg branch
new_branch
$ hg merge default

Cuando queramos cerrar definitivamente la rama, ejecutamos el commit de la siguiente forma:

$ hg commit --close-branch -m 'Branch new_branch closed'

Referencias

Hay un tutorial muy bueno sobre diferentes modos de trabajar con branchs en mercurial, (una de ellas es hacer branch "físicos").

Añadir hoja de estilo en Django

2011-01-18T00:49:00.002Z

Para añadir hojas de estilo, el directorio de imágenes y los ficheros javascript de forma que Django sepa dónde está cada cosa y cómo llegar. Una de las formas de resolver esto es la siguiente: suponer que tenemos la siguiente jerarquía de directorios, dentro del proyecto principal.

$ tree templates/
templates/
|-- css
|-- images
`-- js

Lo primero que tenemos que hacer es incluir las siguientes URL's en el fichero urls.py:
_______________________________________________________


# Media
(r'css/(?P<path>.*)$', 'django.views.static.serve',
{'document_root': settings.STATIC_ROOT + 'templates/css'}),
(r'images/(?P<path>.*)$', 'django.views.static.serve', 
{'document_root': settings.STATIC_ROOT + 'templates/images'}),
(r'js/(?P<path>.*)$', 'django.views.static.serve',
{'document_root': settings.STATIC_ROOT + 'templates/js'}),

_______________________________________________________

También, tenemos que incluir al inicio del fichero urls.py el import necesario para usar la variable STATIC_ROOT:
_______________________________________________________

import settings

_______________________________________________________

Ahora, tenemos que definir esta variable en el settings.py. Lo que haremos es colocarla como la ruta hasta la aplicación:
_______________________________________________________

STATIC_ROOT = '/path/to/app/'

_______________________________________________________

Y por último, tenemos que actualizar la lista TEMPLATE_DIRS con la url hasta el directorio template:
_______________________________________________________

STATIC_ROOT + 'templates/',

_______________________________________________________

Con esto, ya tenemos todo le necesario para usar las CSS en nuestra aplicación. Cuando se haga referencia a qué hoja de estilo coger en el html, ésta debe apuntar a la raíz del template, con lo que quedaría así:

<link href="/css/style.css" rel="stylesheet" type="text/css"/>

Referencias

Django-doc

Parser de mini-C en Python

2011-01-07T21:00:00.000Z

He estado aprendiendo desde hace algún tiempo un módulo para hacer el lexer y parser de un compilador en Python. Se trata de una herramienta relativamente fácil de usar (comparada con otras como antlr) y muy parecidas en sintaxis a LEX y YACC. De hecho, el nombre de PLY viene de Python-Lex-Yacc.

Hay muchísimos tutoriales y ejemplos de este módulo, así que mi intención aquí no es más que explicar cómo se usa y poco más.

Qué instalar

Tenemos que instalar el módulo ply para Python. Esto lo podemos hacer desde los repositorios de Ubuntu o a través del tar.gz de la página del proyecto.

$ sudo apt-get install python-ply

Analizador léxico

Lo primero en realizar es el analizador léxico. Lo que tenemos que hacer es importar el módulo de ply y comenzar a trabajar con él.

import ply.lex as lex

# list of tokens
tokens = (
    # Reserverd words
    'ELSE',
    'IF',
    'INT',
    'RETURN',
    'VOID',
    'WHILE',
   
    # Symbols
    'PLUS',
    'MINUS',
    'TIMES',
    'DIVIDE',
    'LESS',
    'LESSEQUAL',
    'GREATER',
    'GREATEREQUAL',
    'EQUAL',
    'DEQUAL',
    'DISTINT',
    'SEMICOLON',
    'COMMA',
    'LPAREN',
    'RPAREN',
    'LBRACKET',
    'RBRACKET',
    'LBLOCK',
    'RBLOCK',

    # Others   
    'ID', 
    'NUMBER',
)

Lo que se ha hecho es hacer un array con todos los tokens del lenguaje. En este caso de ha cogido un subconjunto de C, al que hemos llamado cminus.

Ahora, como es de esperar, debe haber expresiones regulares para todas estos tokens. Una forma de hacer esto es (esto es nuevo a partir de la versión 3 de PLY) coger todos aquellos tokens que solo sea una sentencia y hacerlo directamente de la forma:

# Regular expressions rules for a simple tokens

t_PLUS   = r'\+'

t_MINUS  = r'-'

t_TIMES  = r'\*'

t_DIVIDE = r'/'

t_EQUAL  = r'='

t_LESS   = r'<'

t_GREATER = r'>'

t_SEMICOLON = ';'

t_COMMA  = r','

t_LPAREN = r'\('

t_RPAREN  = r'\)'

t_LBRACKET = r'\['

t_RBRACKET = r'\]'

t_LBLOCK   = r'{'

t_RBLOCK   = r'}'

Para el resto de tokens, lo que hacemos es una función. Notar que todas las reglas comienzan con una t, esto es así porque el módulo coge todo aquello que contenga esa t_TOKEN crea el diagrama de transición correspondiente. Algunas de ellas son:

def t_ELSE(t):
    r'else'
    return t

def t_IF(t):
    r'if'
    return t

def t_NUMBER(t):
    r'\d+'
    t.value = int(t.value)
    return t

def t_ID(t):
    r'\w+(_\d\w)*'
    return t

def t_newline(t):
    r'\n+'
    t.lexer.lineno += len(t.value)

t_ignore = ' \t'

def t_comments(t):
    r'/*(.|\n)*?\*/'
    t.lexer.lineno += t.value.count('\n')

def t_comments_C99(t):
    r'//(.)*?\n'
    t.lexer.lineno += 1

def t_error(t):
    print "Lexical error: " + str(t.value[0])
    t.lexer.skip(1)

Análisis sintáctico

Ahora vamos a darle un orden a todos estos tokens que nos van llegando. Esto lo conseguimos con una gramática. Especificar gramáticas en PLY es muy similar a como se hace en YACC.

''' not_terminal : list_of_terminals not_terminals '''

Por ejemplo,

""" program : PROGRAM ID SEMICOLON block EOF """

Lo que hace el PLY, es coger la primera cadena de cada producción, analizarla y crear el analizador sintáctico. Por ejemplo, algunas de las producciones del C-menos son:
______________________________________________________

import ply.yacc as yacc
from cminus_lexer import tokens
import cminus_lexer

def p_program(p):
    'program : declaration_list'
    pass

def p_declaration_list_1(p):
    'declaration_list : declaration_list declaration'

    pass

def p_declaration_list_2(p):
    'declaration_list : declaration'
    pass

def p_declaration(p):
    '''declaration : var_declaration
                  | fun_declaration'''
    pass

def p_var_declaration_1(p):
    'var_declaration : type_specifier ID SEMICOLON'
    pass

def p_var_declaration_2(p):
    'var_declaration : type_specifier ID LBRACKET NUMBER RBRACKET SEMICOLON'
    pass

def p_type_specifier_1(p):
    'type_specifier : INT'
    pass

def p_type_specifier_2(p):
    'type_specifier : VOID'
    pass

def p_fun_declaration(p):
    'fun_declaration : type_specifier ID LPAREN params RPAREN compount_stmt'
    pass

def p_empty(p):
    'empty :'
    pass

______________________________________________________

Nótese que los símbolos no terminales están en minúscula y los terminales están en mayúscula. Esto es por convenio. Además, los tokens son los creados anteriormente en el analizador léxico. En el PLY es necesario colocar una producción tonta que haga la función de epsilon. (P → epsilon). Esta no hace nada. Este es un analizador que simplemente comprueba que la sintaxis es correcta, pero si no es correcta, necesitamos que cante el error. Esto lo hacemos mediante la producción p_error().

______________________________________________________

def p_error(p):
    if p is not None:
        print "Syntax error at line " + str(p.lexer.lineno) +

        " Unexpected token  " + str(p.value)
    else:
        print "Syntax error at line: " + str(cminus_lexer.lexer.lineno)

 
______________________________________________________

Una vez que tengamos todas las reglas escritas, tenemos llamar al método del parser. La primera vez que se ejecute, se construirá un fichero py con el analizador, llamado parsetab.py y otro con la información del léxico y sintáctico llamado parser.out.

______________________________________________________

parser = yacc.yacc()


if __name__ == '__main__':
    data = '''
        // Comment C99 style
        int gcd (int u, int v) {
            if (v == 0) 
                return u

             else
                return gcd(v, v-u);
        }
    '''
    parser.parse(data, tracking=True)

______________________________________________________

Para ejecutar el programa, invocamos al parser y éste cogerá el código de ejemplo descrito anteriormente y le pasará el analizador sintáctico.

$ python cminus_parser.py
Syntax error at line 6 Unexpected token else

Código completo

Se puede ver el código completo en el repositorio:

http://bitbucket.org/jjfumero/cminus

El siguiente paso es construir el AST. La estrategia a seguir es ir construyéndolo a medida que se hace el parser.

Referencias

Instalación de Cuda en Ubuntu

2010-12-28T00:40:00.003Z

Lo que tenemos que hacer es bajarnos el CudaToolkit en la página de nvidia.

http://developer.nvidia.com/object/cuda_3_2_downloads.html

Una vez descargado, ejecutamos el binario como superusuario.

$ ./cudatoolkit_3.2.9_linux_64_ubuntu10.04.run

Esto nos instala, entre otras cosas el compilador de Cuda. Ahora, tenemos que agregar una nueva ruta hacia estos compiladores. Lo podemos hacer en el ~/.bashrc:

# CUDA
export PATH=/usr/local/cuda/bin/:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda/lib64/:/usr/local/cuda/lib/

Ante el error:

$ nvcc ejemplo.cu -o ejemplo
gcc: error trying to exec 'cc1plus': execvp: No existe el archivo o directorio

Significa que requiere del compilador de c++ => tenemos que hacer sudo apt-get install g++.

Instalación del SDK + Ejemplos

También podemos descargarnos GPU Computing SDK code samples, que contiene bastantes programas de ejemplo y simulaciones. Una vez descargado e instalado, probablemente tengamos que instalar algunas librerías más. Por ejemplo, para compilar el fluidsGL, tenemos que ir a ./NVIDIA_GPU_Computing_SDK/C/src/fluidsGL/. En src es donde están los ejemplos. Para compilar, simplemente usamos el makefile que nos deja nvidia.

$ make

Al compilar, pueden salir problemas parecidos a los siguientes:

/usr/bin/ld: cannot find -lGL
/usr/bin/ld: cannot find -lXi
/usr/bin/ld: cannot find -lXmu
/usr/bin/ld: cannot find -lglut
collect2: ld returned 1 exit status
make: *** [../../bin/linux/release/fluidsGL] Error 1

Y puede que algunos más. Esto es porque nos faltan algunas librerías por instalar. En concreto son necesarias:

$ sudo apt-get install libxmu-dev libxi-dev libxt-dev freeglut3-dev libx11-dev

Referencias:

http://developer.nvidia.com/object/cuda_3_2_downloads.html

Cómo ejecutar ficheros msi con Wine

2010-12-17T22:31:00.000Z

Para poder ejecutar los famosos ficheros Windows Installation en Wine usamos la opción msiexec /i y el fichero a ejecutar.

$ wine msiexec /i file.msi

Otra forma de hacerlo es con la opción start.

$ wine start file.msi

Convertir resaltado de sintaxis a html con ViM

2010-11-29T15:31:00.000Z

Hay un comando en ViM con el que podemos convertir cualquier código que estemos editando (con colores, tabuladores, etc) a formato HTML.

:TOhtml

Este comando de ViM creará un fichero con la extensión html. Para crear el html influye el esquema de color que tengamos en el ViM. Si tenemos el default (lo más común) es que los caracteres cercanos al amarillo, como las palabras reservadas, no se vean muy bien en el html. Un esquema de color adecuado (al menos para mí) es el esquema de color xellner.

:colorscheme zellner

Convertir un repositorio subversion a un repositorio mercurial

2010-11-21T17:22:00.002Z

Por trabajo, comencé a usar mercurial como sistema de control de versiones. Me fui acostumbrando al modo de trabajo de Mercurial y ahora me está gustando más que subversion. Ahora, algunas prácticas que tenía pendientes y que las tenía con subversion me he planteado la migración a Mercurial.

La pregunta es: ¿se puede hacer la migración sin perder el log de lo hecho anteriormente? La respuesta es sí. Tras buscar un poco en la documentación (link) se encuentra un pequeño manual sobre cómo hacerlo. Es más, se pueden convertir desde varios Sistemas de Control de Versiones como Bazaar o CVS.

Por ejemplo, desde subversion, necesitamos un módulo de python: python-subversion.

$ sudo apt-get install python-subversion

Luego tendríamos que crear un directorio y hacer un init:

$ mkdir proyecto
$ cd proyecto
$ hg init

Ahora, tenemos que editar el fichero .hg/hgrc y añadirle una extensión.

$ vim .hg/hgrc

Añadimos las líneas como sigue:

[extensions]
hgext.convert=

Ahora, importamos el proyecto con la opción convert de mercurial. Por ejemplo, si el repositorio lo tenemos en local:

$ hg convert file:///path/to/repo_svn
$ hg update

Ahora podemos trabajar con el mismo repositorio pero con mercurial y sin perder el historial.

DVDs encriptados en Ubuntu 10.10

2010-10-30T11:10:00.000+01:00

Lo que tenemos que hacer es instalar la librería libdvdread4 y ejecutar el script de instalación. Este instalará libdvdcss2.

$ sudo apt-get install libdvdread4
$ sudo /usr/share/doc/libdvdread4/install-css-sh

Memoria compartida en Linux

2010-09-14T11:05:00.002+01:00

La memoria compartida es uno de los mecanismos de Comunicación Entre Procesos (IPC) que hay en Linux.

Para usar memoria compartida en Linux es necesario seguir una serie de pasos que luego se traducen a llamadas al sistema.

Necesitamos obtener un identificador de IPC. Para ello convertimos una ruta (path) del sistema en un identificador IPC. Este identificador es necesario para crear la crear la zona de memoria virtual. Esto es muy sencillo de hacer con la llamada al sistema ftok.
Crear el segmento de memoria compartida con la llamada al sistema shmget.
Operar con la memoria compartida. Indicamos lo que queremos compartir con la llamada al sistema shmat.
Destruimos el segmento de memoria compartida con la llamada al sistema shmdt y shmctl.

Obtener el identificador IPC

Modo de uso:

#include <sys/types.h>
#include <sys/ipc.h>

key_t ftok(const char *pathname, int proj_id);

El primer parámetro es una ruta. Lo que se puede hacer es coger una ruta que siempre esté en el sistema, por ejemplo "/bin/cp". El segundo parámetro es un número aleatorio, pero que conozcan todos los procesos que quieren unirse al mismo segmento de memoria compartida (al igual que la ruta).

Por ejemplo podemos hacer:

int key = ftok ("/bin/cp", 123);

Información más detallada:
$ man ftok

Crear el segmento de memoria compartida

Esto lo hacemos con la llamada al sistema shmget.

#include <sys/ipc.h>
#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);

El primer parámetro es la clave obtenida en la llamada al sistema anterior.
El segundo parámetro es el tamaño de la memoria a compartir dados en bytes.
El tercer parámetro son flags para el modo de uso y quién accede al segmento de memoria.

Los flags son:

IPC_CREAT: crea un nuevo segmento.
IPC_EXCL: se combina con IPC_CREAT y si el segmento ya existía, entonces la creación de segmento falla.
mode_flags: son los permisos del segmento sobre usuario, grupo y otros, además de los permisos especiales.

Esta función retorna -1 si hubo error y actualiza la variable errno.

Por ejemplo, creamos una zona de memoria compartida para 10 enteros

int id = shmget(key, sizeof(int) * 10, 0777 | IPC_CREAT);

Información más detallada:
$ man shmget

Operaciones con la memoria compartida

Ahora tenemos que unir nuestros datos al segmento de memoria compartida. Esto es lo que hace la llamada al sistema shmat. Se le especifica el ID obtenido en shmget:

void *shmat(int shmid, const void *shmaddr, int shmflg);

La dirección de memoria compartida a la que se asocia depende del parámetro shmaddr y shmflg. Para más información sobre estos dos parámetros hacer un man shmat.

Para el uso que le vamos a dar, bastará con poner estos dos parámetros a 0, con esto le indicamos que el sistema coja una dirección apropiada donde fijar el segmento.

int *array;
array = shmat(id, 0, 0);

Desasignar la memoria compartida

Cuando ya hayamos acabado de usar la memoria compartida, se debe liberar el segmento "cogido". Esto se hace con 2 llamadas al sistema: shmdt y shmctl.

shmdt: lo que hace es que desasocia la zona de datos del programa con la memoria compartida.
shmctl: sirve para pasar recibir información de la memoria compartida, o para establecer usuario y permisos del segmento. También sirve para destruir el segmento de memoria compartida.

Ejemplos de uso:

/* Free the shared memory */
shmdt ((char *)array);
shmctl (id, IPC_RMID, (struct shmid_ds *)NULL);

El parámetro IPC_RMID lo que hace es eliminar el segmento de memoria compartida.

Ejemplo

Se tienen 2 programas. Uno cliente y otro servidor (si se quiere ver así). El servidor crea la memoria compartida y sirve un dato. El cliente se acopla a la memoria compartida y recoge el dato.

/* p1.c -- demostrate the mecanism of
 *         shared memory
 * blog   : snatverk.blogspot.com
 * date   : Tue Sep 14 10:54:37 WEST 2010
 * compile: $ gcc p1.c -o p1
 */

#include <stdio.h>
#include <sys/types.h>

#include <sys/ipc.h>
#include <string.h>
#include <errno.h>
#include <sys/shm.h> /* shm*  */

#define FILEKEY "/bin/cat"

#define KEY 1300
#define MAXBUF 10

int main () {
 /* Key to shared memory */
   int key = ftok(FILEKEY, KEY);
   if (key == -1) {
      fprintf (stderr, "Error with key \n");
      return -1; 
   }

   /* we create the shared memory */
   int id_zone = shmget (key, sizeof(int)*MAXBUF, 0777 | IPC_CREAT);
   if (id_zone == -1) {
      fprintf (stderr, "Error with id_zone \n");
      return -1; 
   }

   printf ("ID zone shared memory: %i\n", id_zone);

   int *buffer; /* shared buffer */
   /* we declared to zone to share */
   buffer = shmat (id_zone, (char *)0, 0);
   if (buffer == NULL) {
      fprintf (stderr, "Error reserve shared memory \n");
      return -1; 
   }

 
   printf ("Pointer buffer shared memory: %p\n", buffer);

   int i;
   for (i = 0; i < MAXBUF; i++) 
      buffer[i] = i;

   /* The daemon executes until press some character */
   char c;
   c = getchar();

   /* Free the shared memory */
   shmdt ((char *)buffer);
   shmctl (id_zone, IPC_RMID, (struct shmid_ds *)NULL);
   return 0;
}

___________________________________________________
El segundo proceso:

/* p2.c -- demostrate the mecanism of
 *         shared memory
 * blog   : snatverk.blogspot.com
 * compile: $ gcc p2.c -o p2
 */

#include <stdio.h>
#include <sys/types.h>

#include <sys/ipc.h>
#include <string.h>
#include <errno.h>
#include <sys/shm.h> /* shm*  */

#define FILEKEY "/bin/cat"
#define KEY 1300
#define MAXBUF 10

int main () {
   /* Key to shared memory */
   int key = ftok(FILEKEY, KEY);
   if (key == -1) {

      fprintf (stderr, "Error with key \n");
      return -1; 
   }

   /* we create the shared memory */
   int id_zone = shmget (key, sizeof(int)*MAXBUF, 0777 | IPC_CREAT);
   if (id_zone == -1) {
      fprintf (stderr, "Error with id_zone \n");
      return -1; 
   }

   printf ("ID zone shared memory: %i\n", id_zone);

   int *buffer; /* shared buffer */
   /* we declared to zone to share */
   buffer = shmat (id_zone, (char *)0, 0);
   if (buffer == NULL) {

      fprintf (stderr, "Error reserve shared memory \n");
      return -1; 
   }

 
   printf ("Pointer buffer shared memory: %p\n", buffer);

   /* Write the values of shared memory */
   int i;
   for (i = 0; i < MAXBUF; i++) 
      printf ("%i\n", buffer[i]);
   return 0;
}

Instalación de Ruby y Ruby On Rails en Ubuntu

2010-08-30T18:10:00.002+01:00

La instalación de Ruby y Ruby on Rails en Ubuntu es muy sencilla. Para instalar Ruby, se necesitan los paquetes ruby, ri (ruby information) e irb (interactive ruby).

$ sudo apt-get install ruby ri irb

Ahora, podemos instalar rubygems desde los repositorios y bajarnos la última versión (recomendable) para instalar luego Rails. La versión que tiene Ubuntu (al menos en Ubuntu 9.X u 10.04) es la 1.3.5. Cuando instalamos rails con ruby gems, se nos pide que al menos se tenga la versión 1.3.6 de rubygems. Si se intenta actualizar rubygems:

$ sudo gem update --system

Nos da un error como que esto se hace mediante los repositorios de Debian/Ubuntu y no desde el propio programa. Yo opté por descargarme el código fuente e instalarlo yo mismo y funcionó.

$ wget http://production.cf.rubygems.org/rubygems/rubygems-1.3.7.tgz
$ tar -xvzf rubygems-1.3.7.tgz
$ cd rubygems-1.3.7
$ sudo ruby setup.rb

Con esto ya tenemos actualizada la versión de rubygems. Ahora toca instalar Rails.

$ sudo gem install rails --include-dependencies

Decir que Rails3 me está dando problemas con la configuración de la base de datos, por lo que otra opción es instalar rails desde los repositorios de Ubuntu, con el nombre de paquete rails. Ahora, en función de la base de datos que tengamos, tenemos que instalar la correspondiente librería para ruby. Por ejemplo, si tenemos instalado MySQL, entonces hacemos:

$ sudo apt-get install libmysql-ruby libmysqlclient-dev
$ sudo gem install mysql

¡Ahora, a disfrutar de Rails!

netduino

2010-08-27T11:14:00.000+01:00

En bricogeek, he encontrado un post interesante presentando este microcontrolador. El nombre de netduino viene de .NET + Arduino. El microcontrolador que tiene es un Atmel de 32 bits a 48MHz de frecuencia. Además, tiene más memoria, unos 60KB de RAM. El netduino incluye en la placa un pulsador.

En la página del proyecto nos podemos descargar este Micro Framework para .NET y hacer nuestros programas en Visual Studio 2010. Lo que me gusta es que se programa en C# con el editor Visual Studio. El framework es gratuito y es bajo licencia Creative Commons. Está en fase de experimentación la posibilidad de programarlo en C# bajo MONO.

La página del proyecto: http://www.netduino.com/

Solución bloqueo barra gnome-panel

2010-07-31T11:48:00.001+01:00

Ayer, como casi siempre todo funcionaba a la perfección en mi Ubuntu 9.10. Hoy, de repente (aún no sé el motivo) la barra gnome-panel se quedó completamente bloqueada.

"Googleando" un rato, encontré una solución parcial, un apaño. Es matar al proceso gnome-panel, luego vuelve a funcionar como si nada hubiese pasado.

$ killall gnome-panel

La pega a esta solución, es que cada vez que reinicies, se tiene matar nuevamente el proceso. Esta solución es prácticamente inaceptable.

Propongo otra solución, tal como se comenta en Ubuntu-life, si algo falla, una opción es volver a los valores por defecto, que de momento me va bien. Por tanto podemos resetear los parámetros de los paneles que vienen por defecto en Gnome.

$ gconftool-2 --recursive-unset /apps/panel

Luego reiniciamos la máquina y listo. Puedo confirmar que va bien, al menos a mi se me ha solucionado.

Dejo unos enlaces de donde he sacado esta información.

Multiplicación a la Russe en C

2010-07-26T16:48:00.004+01:00

Existen varios algoritmos para la multiplicación. Uno bastante curioso y sorprendente es el de la multiplicación a la russe. Este algoritmo no es que sea muy didáctico, de hecho no se enseña en los colegios, puesto que tan solo requiere dividir y multiplicar por 2. En escencia, saberse la tabla del 2, y por supuesto, saber sumar, ¡y funciona!.

Algoritmo y ejemplo

Lo mejor para entender como funciona el algoritmo es un ejemplo. Vamos a multiplicar 35*91: el resultado debe ser de 3185.

Lo que se hace es coger el multiplicando y dividirlo por 2 mientras el resultado sea mayor a 1. Con el multiplicador se hace los contrario, se multiplica por 2. Los números que se suman son aquellas partes derechas en las que la parte izquierda sea impar. Dicho de otro modo, se suman aquellos números de la columna de multiplicaciones en los que la columna de divisiones sea impar.

Un pseudocódigo sería algo así:

russe(x, y)
begin
while (x >= 1) do
    if (x mod 2) then
       mult = mult + y;
    endif
x = x/2;
y = y*2;
end
return mult;
end

Implementación en C

Resulta tentador implementar un algoritmo así. Es muy sencillo. Si tenemos en cuenta que las multiplicaciones y divisiones por 2 se hacen mediante desplazamientos a izquierda y a derecha respectivamente, resulta muy fácil.

Una mejora a esto es poner el número más pequeño como multiplicando, puesto que así nos podemos ahorrar algunas iteraciones.

_______________________________________________________

/* russe.c -- algoritmo de multiplicación a la russe
 * date: sáb jul 24 09:34:54 WEST 2010
 * Author: Juan José Fumero Alfonso
 * Compile: gcc russe.c -O3 -o russe
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>  /* getopt */

#define AUTHOR "Juan José Fumero Alfonso"

void author () {
 printf ("Author: %s\n", AUTHOR);
}

void version () {
 printf ("Multiplicación a la Russe, version 0.2\n");
}

void help () {
 printf ("Use mode: \n");
 printf ("\t$ ./russe -[-hva] x <number1> -y <number2>  \n");
 printf ("\t-v: print version\n");
 printf ("\t-a: print author\n");
 printf ("\t-h: show this help\n");
}

/* Función con que realiza la multicación a la russe */
int mrusse (int auxa, int auxb) {
  int mult = 0;
  while (auxa >= 1) {
    if ((auxa % 2) == 1)  {
      mult += auxb;
    }
    auxa = auxa >> 1;
    auxb = auxb << 1;
 }
 return mult;
}

/* Entrada de los dos número a multiplicar desde la línea de 
 * comandos
 */
int main (int argc, char **argv) {
 /* Recogida ie números */
 int x, y;
 int flgn1 = 0, flgn2 = 0;
 int opt;
    while ((opt = getopt(argc, argv, ":havx:y:")) != -1) {
      switch (opt) {
        case 'h': 
           help();
          return 0;
          break;
        case 'v': 
          version();
          return 0;
          break;
        case 'a':
          author();
          return 0;
          break;
        case 'x': /* recogida de números */
         flgn1 = 1;
         x = atoi(optarg);
         break;
       case 'y': /* recogida de números */
         flgn2 = 1;
         y = atoi(optarg);
       break;
         default: /* '?' */
         help();
         exit(EXIT_FAILURE);
     }
  }
  if ((flgn1 == 0) && (flgn2 == 0)) {
     fprintf (stderr, "Error in numbers\n");
     return -1;
  } 
  int mult = mrusse(x, y);
  printf ("\t%i * %i = %i\n", x, y, mult);
  return 0;
}

_______________________________________________________

La función principal es mrusse, que es la que hace la multiplicación por software. El resto es sólo para permitir diversas opciones de entrada al programa. Modo de uso:

$ ./russe -x 35 -y 91

Use la opción -h para la ayuda.

Asignar un nuevo UUID a máquina virtual de VirtualBox

2010-07-07T13:12:00.000+01:00

Si queremos tener más de una copia de una máquina virtual ejecutándose, se necesita que cada máquina tenga su propio UUID distinto del resto. Hay al menos dos formas de hacer esto.

1. Asignación de un nuevo UUID manualmente

Se hace la copia con el comando cp, por ejemplo, y luego tenemos que asignar manualmente un UUID nuevo para la máquina copiada. Esto se hace:

$ VBoxManage internalcommands setvdiuuid copy.vdi

2. Clonando una máquina virtual

El segundo método es usar el comando de VirtualBox clonehd. Este hace una copia y asigna un UUID a la nueva máquina automáticamente.

$ VBoxManage clonehd original.vdi copy.vdi

Ejemplo listas enlazadas en Java

2010-06-02T09:24:00.005+01:00

Algunas de las estructuras de datos que se usan con frecuencia en programación son las listas, pilas y colas. Pero probablemente (al menos a mi me pasa) cuando vayamos a implementar alguna utilidad con estas estructuras de datos, acordarse del nombre de la clase y como se usaba (en Java) es todo un ejercicio de memoria (no sólo con Java sino con cualquier lenguaje), a no ser que estemos constantemente programando en el mismo lenguaje. Aquí pongo un ejemplo muy sencillo que muestra el uso de listas en Java.

Tenemos que importar el paquete java.util que contiene las clases apropiadas para el manejo de listas e iteradores. Se puede descargar el código fuente enlace.

_______________________________________________________

// Ejemplo de uso de listas en Java
// Autor: Juan José Fumero Alfonso
// Blog : snaterk.blogspot.com

import java.util.*;
public class MyList {
    public static void main(String[] args) {

        //creamos la lista a
        List a = new LinkedList();
        //añadimos elementos a la lista
        for (int i = 0; i < 100; i++)
            a.add(i);
        //Imprimimos la lista
        System.out.println(a);
        //Si queremos imprimir los elementos a pelo

        ListIterator it = a.listIterator();
        //Iterator it2 = a.iterator();
        while (it.hasNext())
            System.out.println(it.next());
        //Eliminar todos los elementos de la lista    
        a.removeAll(a);

        //Imprimir el resultado
        System.out.println(a);
        System.exit(0);

    }
}

_______________________________________________________

Scripts administración de redes en Linux

2010-05-29T21:07:00.004+01:00

El primer script facilita un poco la tarea si tenemos que asignar manualmente una dirección IP a una interfaz de red mediante línea de comandos (en este caso se ha cogido la eth0).
_______________________________________

#! /bin/bash

# Autor: Juan José Fumero Alfonso
# Fecha: 26/03/10
# Script de automatización de asignación
# una nueva ip para la interface eth0.

# comprobamos si las cadenas $1, $2 son
# vacías
if  [ -z $1 ] & [ -z $2 ]; then
 echo -e "Modo uso: ./ip <address> <mask> "
else
 echo -e "\n************ eht0 ******************"
 echo -e "\tAsignando ip: $1"
 echo -e "\tCon máscara : $2"
 sudo ifconfig eth0 up $1 netmask $2
 echo -e "\n"
fi

_______________________________________

El segundo script elimina la puerta de enlace que tenía y añade la que le indiquemos como argumento:
_______________________________________

#! /bin/bash

# Autor: Juan José Fumero Alfonso
# Fecha: 26/03/10

# Comprobamos si la cadena $1 es vacía
if [ -z $1 ]
then
    echo -e "Modo de uso: ./routerGateway <address>"
else
    # eliminamos la ruta por defecto
    sudo route del default
    # añadimos la nueva
    sudo route add default gw $1 eth0
fi

_______________________________________

Comunicación con arduino en C++

2010-05-07T21:11:00.005+01:00

No es muy complicado comunicar nuestra placa arduino mediante el puerto serial con C++ usando la librería LibSerial. Esta librería tiene una clase, SerialStream, que nos abstrae de la "complejidad" de la estructura termios. Para usarla es necesario instalarla. En Ubuntu lo podemos encontrar en los repositorios. Si no, aquí está el enlace: http://sourceforge.net/projects/libserial/files/

Instalación de la librería (en Ubuntu)

$ sudo apt-get install libserial-dev

API de LibSerial

En la siguiente URL, se encuentra el API bien documentada.

http://libserial.sourceforge.net/doxygen

Ahora veremos cómo hacer las operaciones básicas (desde abrir el puerto, hasta la lectura/escritura).

Abrir un puerto
_________________________________________

#include <SerialStream.h>

    SerialStream serial_port("/dev/ttyUSB0");

_________________________________________

Asignación de baudios
_________________________________________
serial_port.SetBaudRate(SerialStreamBuf::BAUD_9600);
_________________________________________

El ejemplo es para el caso de 9600 baudios (suele ser habitual). Pero asignarle otras (ver en este enlace).

Número de bits a transmitir

Se hace con la llamada al método SetCharSize().
_________________________________________
serial_port.SetCharSize( SerialStreamBuf::CHAR_SIZE_8) ;
_________________________________________

CHAR_SIZE_X, la X puede variar entre 5 y 8

Lecturas y escrituras

//Escritura (mandar un dato) 

char c;

cin >> c;

serial_port << c;

//Lectura: recibir un dato

char c;

serial_port >> c;

Ejemplo completo

/* 
   Author: Juan José Fumero Alfonso
   Date: Fri May  7 19:48:06 WEST 2010
   Note: To compile is necesary install libserial: Serial port 
         programming in C++ under POSIX operating system
            $ sudo apt-get install libserial-dev
   Doc : http://libserial.sourceforge.net/doxygen
   Compile:
     \_ $ g++ ejemplo.cpp -o ejemplo -lserial
*/

#include <iostream>
#include <string>
#include <unistd.h>
#include <SerialStream.h>

using namespace std;
using namespace LibSerial;

int main (int argc, char **argv) {

    int oc; 
    string dev;
    bool dsp = false;
    while ((oc = getopt(argc, argv, ":d:")) != -1) {
        switch(oc) {
            case 'd':
                //device
                cout << "Dispositivo: ";
                dev = optarg;
                cout << " :: " << dev << endl;
                dsp = true;
                break;
            case ':':
                cerr << "Missing argument " << endl;
                return -1;
                break;
        }
    }    
    
    if (!dsp) {
        dev = "/dev/ttyUSB0";
    }
    SerialStream serial_port(dev);
    serial_port.SetBaudRate(SerialStreamBuf::BAUD_9600);
    serial_port.SetCharSize( SerialStreamBuf::CHAR_SIZE_8);

    char num;
    while (1) {
        cout << "Number of blinks? : ";
        cin >> num;
        serial_port << num;
    }
    return 0;
}

Para probarlo, se puede hacer el típico ejemplo blink (conectando un LED al pin 13) y enviar un número entre 0 y 9 que indicará el número de parpadeos que debe realizar el LED en el arduino. El correspondiente código pde es el siguiente: (cogido de http://todbot.com/, aunque no es nada del otro mundo).

/*
 * Serial Read Blink
 * -----------------
 * Turns on and off a light emitting diode(LED) connected to digital  
 * pin 13. The LED will blink the number of times given by a 
 * single-digit ASCII number read from the serial port.
 *
 * Created 18 October 2006
 * copyleft 2006 Tod E. Kurt <tod@todbot.com>
 * http://todbot.com/
 * 
 * based on "serial_read_advanced" example
 */
int ledPin = 13;   // select the pin for the LED
int val = 0;       // variable to store the data from the serial port

void setup() {
  pinMode(ledPin,OUTPUT);    // declare the LED's pin as output
  Serial.begin(9600);        // connect to the serial port
}

void loop () {
  val = Serial.read();      // read the serial port
  // if the stored value is a single-digit number, blink the LED that number
  if (val > '0' && val <= '9' ) {
    val = val - '0';          // convert from character to number
    for (int i=0; i<val; i++) {
      digitalWrite(ledPin,HIGH);
      delay(150);
      digitalWrite(ledPin, LOW);
      delay(150);
    }
  }
}

Esta Clase (SerialStream) tiene más métodos como establecer los bits de parada, control de paridad, etc. Se puede ver en la documentación de la clase.

Más información

http://libserial.sourceforge.net/

Arduino: books and documentation

2010-05-07T13:50:00.002+01:00

Hay muchísimas páginas con manuales, tutoriales, ejemplos, etc sobre Arduino. Considero que las siguientes están bastante bien para empezar.

Ejemplos:

Lenguaje (referencia):

http://arduino.cc/en/Reference/HomePage

Tutoriales|Manuales:

http://www.ladyada.net/learn/arduino/
Traducción del libro “Arduino Programming Notebook” [Brian W. Evans] por Rafael Enríquez Herrado de la Universidad Córdoba.
[] http://www.jcarazo.com/tmp/Arduino_user_manual_es.pdf
[] Código fuente: http://jcarazo.com/tmp/arduino_user_manual_es_sources.tar.gz

Chuletario:

En pdf: link

Books:

Practical Arduino: http://www.practicalarduino.com/about

Getting Started with Arduino: http://oreilly.com/catalog/9780596155520

Arduino: Lectura potenciómetro y escritura PWM

2010-04-19T20:52:00.000+01:00

He conseguido un Arduino y uno de los primeros ejemplos que he hecho es el siguiente: leer por un pin Analógico el valor del potenciómetro, y asignarle ese valor a la PWM, de esta forma, conseguimos que el LED se apaque y se encienda conforme variamos el valor del potenciómetro. El circuito es el siguiente:

(La imagen de la placa Arduino es de la Wikipedia).

El circuito es muy sencillo. Se conecta el potenciómetro al pin 5 de las entradas analógicas. También colocamos un LED conectado al Pin 9 (PWM) con una resistencia para que no se queme.

Lo que he hecho es aprovechar la PWM para poner 2 LEDs. El programa es muy simple también:

1 /*
2   Ejemplo de uso de potenciómetro y PWM
3 */
4
5
6 int ledPin = 9;    // LED connected to digital pin 9
7 int potnPin = 5;   // Pin de lectura del potenciómetro
8 int value = 0;
9
10 void setup()  {
11   pinMode(ledPin, OUTPUT);
12   pinMode(potnPin, INPUT);
13   Serial.begin(9600);
14 }
15
16 void loop()  {
17     value = analogRead(potnPin)/4;
18     analogWrite(ledPin, value);
19     Serial.print(value, DEC);
20     Serial.println();
21 }

Administración de cuotas en Linux

2010-03-20T11:51:00.000Z

En GNU/Linux se administran las cuotas con el comando edquota, donde le asignamos espacio a los diferentes usuarios en un archivo de configuración. Pero para llegar a este punto, necesitamos decirle al sistema que queremos que una determinada partición funcione con cuotas de disco.

1. Editar el /etc/fstab

Editamos (como root) el fichero de /etc/fstab, que es donde están todos las particiones y discos disponibles.

# vi /etc/fstab

Luego, añadimos en la columna options y en su correspondiente fila, las opciones usrquota y grpquota. Suponer que queremos habilitar la partición /home para la administración de quotas.

/dev/hda6 /home ext3 defaults,usequota,grpquota 1 2

Ahora tenemos 2 posibilidades:

Reiniciar.
Ejecutar: mount -o remount /home

2. Crear la base de datos de cuotas

Ahora, necesitamos crear unos archivos especiales que contiene la base de datos de cuotas de los usuarios. Para hacer esto, ejecutamos el comando quotacheck

# quotacheck -a /dev/hda6

Tras ejecutar este comando, se crea en la partición seleccionada 2 ficheros: aquota.user y aquota.group. Éstas son las bases de datos que hablamos antes.

3. Habilitar/deshabilitar cuotas

Podemos habilitarla cuotas con el comando quotaon y deshabilitarlas con el comando quotaoff. Por ejemplo

# quotaon -uvg /home
/dev/sda6 [/home]: group quotas turned on
/dev/sda6 [/home]: user quotas turned on

De la misma forma, usamos el comando quotaoff.

4. Asignar cuotas a los usuarios

Vamos a lo más importante, asignarle un espacio en disco. Es una tarea muy sencilla y se hace con el comando edquota. Este comando edita un fichero de configuración donde le asignaremos el espacio que queramos. Aquí hay que tener en cuenta 2 cosas. Límite suave (soft), y límite duro (hard). El límite duro e estricto, le negará al usuario la capacidad de exceder esta cuota, mientras que si excede el un límite suave o flexible, el sistema le dará una advertencia.

Ejemplo: asignar 20MB a un usuario user1

# edquota -u user1

Se nos abre un editor, nano, vim (el predeterminado del sistema).

Disk quotas for user user1 (uid 1001):
Filesystem blocks soft hard inodes soft$
/dev/sda6 100 20000 20000 22 0$

De la misma forma, también podemos asignar cuota de disco a grupos con la opción -g.

# edquota -g Grupo

Hay una opción interesante para replicar la cuota de disco de un usuario, y así no tener que ir uno por uno configurando su cuota. Es la opción -p. Por ejemplo, queremos que los usuarios user2, user3 y user4 tengan la misma configuración que user1.

# edquota -p user1 user2 user3 user4

5. Ver resumen de cuotas

Se pueden ver los resultados con el comando repquota (ejecutarlo como root). Éste genera un resumen del uso en disco de todos los usuarios y grupos.

# repquota -s /home

La opción -s es --human-readable y nos sale más legible (en MB, GB, etc).

Otro comando es quota -u user, para ver la cuota de un usuario en concreto.

6. Referencias:

Instalar Flash Player 10 en Ubuntu 64 bits

2010-02-28T18:33:00.000Z

En los foros de ubuntu-es, he encontrado este script en bash que descarga e instala el Flash Player para sistemas Ubuntu de 64 bits. Es un script muy sencillo y práctico.

Link: http://www.ubuntu-es.org/?q=node/76907#comment-341710

Problema del XOR con Neuroph

2010-02-24T18:42:00.006Z

Neuroph es un Framework de código abierto que incluye multitud de clases con los algoritmos más conocidos de redes neuronales. Ya hemos hablado de este Framework en alguna ocasión. Toda la documentación de la API e incluso ejemplos la podemos encontrar en la página de ellos:

http://neuroph.sourceforge.net/index.html

En este post, pondré un ejemplo con el algoritmo Momentum-Backpropagation que proporciona Neuroph para resolver el problema del XOR. Decir que casi todo el código es basado en los ejemplos de la página del proyecto, simplemente se ha modificado el algoritmo de aprendizaje de la red. No es muy complicado.

________________________________________________________________



// Author: Juan José Fumero Alfonso
// Blog  : snatverk.blogspot.com
import org.neuroph.core.NeuralNetwork;import org.neuroph.nnet.MultiLayerPerceptron;import org.neuroph.core.learning.TrainingSet;import org.neuroph.core.learning.TrainingElement;import org.neuroph.core.learning.SupervisedTrainingElement;import org.neuroph.nnet.learning.MomentumBackpropagation;import java.util.Vector;import org.neuroph.util.TransferFunctionType;public class XorBackPropagation {

    public static void main (String[] args) {

        TrainingSet trainingSet = new TrainingSet();
        trainingSet.addElement(new SupervisedTrainingElement
(new double[]{0, 0}, new double[]{0}));

        trainingSet.addElement(new SupervisedTrainingElement
(new double[]{0, 1}, new double[]{1}));

        trainingSet.addElement(new SupervisedTrainingElement
(new double[]{1, 0}, new double[]{1}));

        trainingSet.addElement(new SupervisedTrainingElement
(new double[]{1, 1}, new double[]{0}));

        // create multi layer perceptron
        MultiLayerPerceptron myMlPerceptron = 
new MultiLayerPerceptron(TransferFunctionType.TANH, 2, 3, 1);

        //Create Backpropagation with momentum
        MomentumBackpropagation mb =
new MomentumBackpropagation(myMlPerceptron);

        //Properties to MomentumBackpropagation
        mb.setMomentum(0.85);
        mb.setMaxError(0.0001);
        mb.setMaxIterations(1000);

        //Learn
        long t1, t2;
        t1 = System.currentTimeMillis();
        mb.learn(trainingSet);
        t2 = System.currentTimeMillis();
        System.out.println("Tiempo de entrenamiento: " +
(t2-t1) + " milisegundos");

        //Get net
        NeuralNetwork nn = mb.getNeuralNetwork();

        //Display the results
        for(TrainingElement trainingElement :
trainingSet.trainingElements()) {

                nn.setInput(trainingElement.getInput());
                nn.calculate();
                Vector<Double> networkOutput = nn.getOutput();

                System.out.print("Input: " + trainingElement.getInput());
                System.out.println(" Output: " + networkOutput);

        }
        System.exit(0);
    }
}
________________________________________________________________

Juego Pong: segunda parte

2010-02-24T15:19:00.013Z

Recordando un poco la primera parte, el objetivo es desarrollar el juego Pong en Java que, mediante una red neuronal tipo Backpropagation, se le presente los datos de entrada (muchos de ellos puede que hayan sido los de entrenamiento) y averigüe dónde va a caer la pelota, desplazando la raqueta hasta la posición deseada.

Para ello primero la red debe pasar una etapa de entrenamiento en la que se irán a recogiendo los movimientos que hace el usuario, es decir, que la red va a intentar aprender de lo que hace el jugador en este proceso de entrenamiento. Una vez entrenado, el juego debe enfrentarse contra lo que ha aprendido.

El juego está implementado en el lenguaje de programación Java y se hace uso de un framework de software libre neuroph. El juego se divide en tres etapas:

Etapa de entrenamiento: El juego almacena lo que hace el usuario. En este punto, se recogen las acciones del usuario para poder pasárselas en una etapa posterior a la red neuronal.
Etapa de aprendizaje: Se entrena la propia red neuronal, pasándole los valores entrenados con el valor deseado. Es por tanto una red con aprendizaje supervisado. Se emplea una red de tipo BackPropagation con Momentum para agilizar el proceso de aprendizaje.
Etapa de juego: El juego se enfrenta con lo que ha aprendido. Se deduce que mientras más juegue el usuario en la etapa de aprendizaje, mejor entrenada estará la red y mejor será jugando en esta última etapa.

Interfaz gráfica

La interfaz gráfica consta de dos partes principales:

Un panel de dibujo donde estará la pelota y la raqueta de juego.
Una zona de control, donde estarán varios botones para el entrenamiento y el testeo del juego.

El panel de dibujo, corresponde con la clase PanelDibujo. Esta clase implementa, entre otras, a la interfaz Runnable, y por tanto, es un Thread. El motivo por el que es un Thread es para mantener en un bucle infinito la animación de la pelota y de la raqueta y al mismo tiempo realizando la captura de datos, además de poder dar diferentes velocidades durmiendo menos tiempo el dicho Thread.
La clase ControlPanel corresponde con la creación de los botones y etiquetas con información. La clase MarcoPong es la encargada de componer todos los elementos de la ventana y de registrar los eventos de los botones como oyentes de la clase PanelDibujo. Es por ello, que la clase PanelDibujo también implementa las interfaz ActionListener.
Por último, la clase Test, instancia la clase MarcoPong y registra el exit para salir.

Clase Test

1 import java.awt.event.*;
2 import javax.swing.*;
3
4 public class Test {
5
6    public static void main( String args[]) {
7      MarcoPong frame = new MarcoPong("Pong Game");
8      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
9      frame.setVisible(true);
10  }
11 }

Clase MarcoPong

1 import java.awt.*;
2 import java.awt.event.*;
3 import javax.swing.*;
4
5 public class MarcoPong extends JFrame {
6
7     public static final int WIDTH = 400;
8     public static final int HEIGHT = 300;
9
10  public MarcoPong(String t) {
11   super(t);
12         setSize(WIDTH, HEIGHT);
13         JPanel panel = new PanelContenedor();
14      Container contentPanel = this.getContentPane();
15      contentPanel.add(panel);
16   }
17 }
18
19 class PanelContenedor extends JPanel {
20     PanelDibujo pd;
21     ControlPanel cp;
22
23     public PanelContenedor() {
24         pd = new PanelDibujo();
25         cp = new ControlPanel();
26         setLayout(new BorderLayout());
27         add(BorderLayout.CENTER, pd);
28         add(BorderLayout.EAST, cp);
29         cp.bTraining.addActionListener(pd);
30         cp.bStop.addActionListener(pd);
31         cp.bPlay.addActionListener(pd);
32   Thread t = new Thread(pd);
33   t.start();
34    }
35 }

Clase ControlPanel

1 import java.awt.*;
2 import java.awt.event.*;
3 import javax.swing.*;
4
5 public class ControlPanel extends JPanel {
6
7     public JButton bTraining;
8     public JButton bPlay;
9     public JButton bStop;
10     public static JLabel labelT;
11     public static JLabel labelG;
12     public static JLabel labelF;
13
14     public ControlPanel() {
15         // setLayout (new BorderLayout());
16         setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
17         setLayout(new GridLayout(8, 1, 2, 3));
18         bTraining = new JButton("Training");
19         bPlay = new JButton("Play");
20   bStop = new JButton("Stop");
21         labelT = new JLabel("Total: 0");
22         labelG = new JLabel("Goods: 0");
23         labelF = new JLabel("Failure: 0");
24         add(bTraining);
25         add(bStop);
26         add(bPlay);
27         add(labelT);
28         add(labelG);
29         add(labelF);
30     }
31 }
32

Entrada de datos

Al pulsar el botón Training comenzará la fase de recogida de datos que serán entregados a la red neuronal. Los datos a recoger son:

La posición según eje x de la pelota.
La dirección a la que va la pelota: 0 para la izquierda y 1 para la derecha.

El único dato de salida es:

La posición x a la que tiene que ir la pelota.

Por tanto, a la entrada de datos, para cada par (x, dirección) se le asocia una salida que es la posición x de la raqueta.

Para representar los datos de entrada, se ha hecho la clase NetData que cuenta con los siguientes atributos:

int dir : dirección de la pelota.
double xracket: valor entre 0 y 1, pues la red neuronal trabaja con estos valores. Entonces se tiene que hacer es escalado a la entrada y salida de este dato.

¿Cómo se asocian los datos?

Se almacena el par (x, dir) cuando la pelota está en y = 10. Esto es una línea en la parte superior de la zona de juego tal y como se ve en la figura (la línea azul). A este par (x, dir) se le asocia como salida la x de la raqueta normalizada, esto es, dividiendo la x de la raqueta entre `MAXX` (constante en el programa que indica la dimensión de las x del panel de dibujo).

Entrenamiento MomentumBackpropagation

Se ha usado una topología de red multicapa fullconection con entretamiento tipo Backpropagation y función de activación sigmoide. El número de capas son 3: la capa de entrada a a red, la capa oculta que cuenta con 4 neuronas y la capa de salida con una neurona.

Creación de la red

78 multiLaterPerceptron = new MultiLayerPerceptron
(TransferFunctionType.SIGMOID, 2, 4, 1);

Entrenamiento

357         mb = new MomentumBackpropagation(multiLaterPerceptron);
358         mb.setMomentum(0.9);
359         mb.setMaxError(0.1E-90);
360         mb.setMaxIterations(3000);
361         long t1, t2;
362         t1 = System.currentTimeMillis();
363         mb.learn(trainingSet);
364         t2 = System.currentTimeMillis();

Salida de datos

Accedemos a esta parte pulsando el botón PLAY (previamente de tiene que haber entrenado). A partir de este momento, la salida x de la raqueta se obtiene tras haber introducido como entrada a la red la x y la dirección por la que va la pelota cuando y = 10. Es decir, cuando la pelota esté en y = 10, se obtiene la dirección de la pelota y su valor en el eje x. Esto se le pasa como entrada a la red neuronal y devuelve un valor de salida. éste, es un valor normalizado que habrá que multiplicar por MAXX para obtener la posición X de la raqueta.

Referencias:

Código fuente completo:

Para compilar es necesario el compilador de java-sun. Además es necesario incluir el directorio org del framework neuroph en el directorio donde estén los fuentes de juego.

Richard Stallman en Tenerife

2010-02-03T10:27:00.004Z

Richard Stallman dará el próximo día 8 de febrero una charla en el Auditorio de Guía de Isora. Según el cartel "hablará sobre las metas y la filosofía del movimiento del Software Libre, y el estado y la historia del sistema operativo GNU".

La charla será de 11:30 a 14:30. La entrada será libre y gratuita.

Links: http://www.fsf.org/events/20100208tenerife

Juego Pong(I): versión alfa

2010-01-13T18:57:00.004Z

Tengo que hacer un pequeño proyecto para la asignatura de Modelos Conexionistas y he decidido implementar el juego Pong mediante una Red Neuronal supervisada en Java.

El trabajo consiste en que el jugador comience a entrenar la red. Para ello , simplemente se pone a jugar en tipo frontón (contra una pared) y se van recogiendo los datos (para cada tupla (x, y, dirección_pelota), se pueden dar 3 salidas posibles: quedarse parado, ir a la izquierda o ir a la derecha). Luego, se pasan esos datos por una red neuronal. En principio voy a coger BackPropagation. Una vez entrenada la red, un jugador se enfrenta contra los valores aprendidos en el proceso de aprendizaje de la red.

Esta versión, a la que he llamado Pong-Alfa2 (la alfa1 es muy simple), sólo está implementada la interfaz gráfica en Java. Mi intención es ir colocando todo el proceso poco a poco (a medida que lo vaya haciendo). En esta versión, aunque aparezca entrenamiento, no se está entrenando, sólo se controla la interfaz gráfica. Se comienza a jugar dando al botón "Training". Cuando se falla, sale un mensaje "Game Over", entones se pulsa el botón Play para continuar. De momento lo tengo así, aunque esto lo cambiaré en las siguientes versiones.

La clase principal, responsable de la captura de eventos del ratón y botones es la que he llamada PanelDibujo.java.
_________________________________________________________

/*
 * Juego PONG
 * Autor: Juan José Fumero Alfonso
 * web  : snatverk.blogspot.com
 */


import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

import java.awt.geom.*;
import java.awt.geom.Point2D.*;

public class PanelDibujo extends JPanel implements Runnable, ActionListener{

    public static final int MAXY = 405;
    public static final int MAXX = 580;

    boolean arriba, izquierda;
    private int r, gr, b;
    int x, y;  //Coordenadas de la pelota

    Point p; 
    Rectangle2D.Double rec;
    Ellipse2D.Double cir;
    boolean gameOver;
    NetData[][] nL;
    NetData[][] nR;
    boolean training;
    boolean bloqueado;

    public PanelDibujo() {
        setBackground(Color.white);
        //Inicializamos atributos
        p = new Point();
        rec = new Rectangle2D.Double();
        cir = new Ellipse2D.Double();
        gameOver = false;
        nL = new NetData[MAXX][MAXY];
        nR = new NetData[MAXX][MAXY];

        for (int i = 0; i < MAXX; i++) {
            for (int j = 0; j < MAXY; j++) {
                nL[i][j] = new NetData();
                nR[i][j] = new NetData();
                nR[i][j].setDir(true);
            }
        }
      //Registramos al objeto this como oyente de evento de movimiento
      //de ratón
      this.addMouseMotionListener(new MouseMotionAdapter() {
          public void mouseMoved(MouseEvent e)
          {
              p = e.getPoint();
              repaint();
          }
      }
      );
 }

 public void run() {
  //Lógica de la pelota
  while(true) {
        if ((training) && (!bloqueado)) {
            if ((x < MAXX) && (!izquierda)) 
                x++;
            else 
                x--;
            if (x == MAXX)
                izquierda = true;
            if (x == 0)
                izquierda = false;

            if (y == (MAXY - 10) && (!arriba)) {
                if (((p.getX() - 25) <= x) && (p.getX() + 25 >= x)) {
                    System.out.println("Ok: sigue jugando");
                    arriba = true;
                }

                else if (!arriba) {
                    System.out.println("Matado!!!!");
                    gameOver = true;
                    repaint();
                    bloqueado = true;
                }
            }

            if ((y < MAXY) && (!arriba)) 
                y++;
            else 
                y--;
            if (y == MAXY)
                arriba = true;
            if (y == 0)
                arriba = false;
            } 
            repaint();
            try {

              Thread.sleep(5);
           }
           catch (Exception e) { 
                System.out.println("Error: Eception" + e.toString());
           }
        }
   }

   public void paintComponent(Graphics g) {
        super.paintComponent(g);
        if (!gameOver) {
            GeneralPath gp = new GeneralPath();
            Graphics2D g2 = (Graphics2D)g;
        
            //Dibujamos zona de juego
            gp.moveTo(1, 1);
            gp.lineTo(1, MAXY + 10);

            gp.moveTo(MAXX + 10, 1);
            gp.lineTo(MAXX + 10, MAXY + 10);

            gp.moveTo(0, MAXY + 10);
            gp.lineTo(MAXX  + 10, MAXY + 10);

            gp.moveTo(1, 1);
            gp.lineTo(MAXX + 10, 1);

            g2.draw(gp);

            g2.setPaint(new Color(r, gr, b));
            rec.setRect((p.getX()-25), MAXY + 5, 50,10);

            g2.fill(rec);

            g2.setPaint(new Color(255, 0, 0));

            cir.setFrame(x, y, 15, 15);
            g2.fill(cir);
        }
        else {
            g.setFont(new Font( "Helvetica", Font.BOLD, 50));
            g.drawString("GAME OVER", 150, 200);
        }
    }

    public void actionPerformed (ActionEvent e) {

        String nameButton = e.getActionCommand();
        if (e.getSource() instanceof JButton) {
            if ("Training".equals(nameButton))  {
                training = true;
                System.out.println("Se ha pulsado Training");
            }

            if ("Play".equals(nameButton))  {
                training = true;
                System.out.println("Se ha pulsado play");
                bloqueado = false;
                gameOver = false;
            }

        }

    }
}

_________________________________________________________

La clase NetData está preparada para la recogida de datos: en esta primera versión sólo se inicializan.

Puede descargar el código completo aquí:

Animación 3D: MultiEyeS

2009-12-29T17:29:00.008Z

La siguiente animación la hice en una asignatura que tuve hace 2 años (técnicas gráficas). Hace poco, haciendo limpia y copias de seguridad lo encontré y lo grabé por demanda de algunos de mis compañeros de clase.

La animación está hecha con OpenGL sobre C#. Para poder usar OpenGL, incluí en el proyecto TAO Framework que es un conjunto de clases para .NET y Mono con OpenGL, OpenAL, FreeGlut entre otros.

Cómo se hizo

La aplicación está escrita en C# usando la plataforma .NET.

La idea es muy sencilla.

Un rectángulo donde se proyecta la imagen de fondo. En el método timer, lo que se hace es ir variando poco a poco el color del material.
Una esfera, donde se le ha incorporado la imagen del ojo modificada para que no quede la imagen desplazada. En el método timer se va incrementando el ángulo de rotación.
El conjunto de esferas más pequeñas (20) que salen del ojo. Las esferas se van insertando una encima de la otra (trasladando la coordenada de las íes en una distancia igual a la mitad del diámetro).

Por ejemplo, el bucle donde se van apilando las esferas es el siguiente:

______________________________________________________________________

                for (int i = 0; i < 20; i++)
                {
                    Gl.glTranslated(0, 0.65, 0);
                    Gl.glRotated(-yrot, 1, 1, 1);
                    //DrawSphere2();
                    Gl.glCallList(3);
                }

______________________________________________________________________

Donde el método Gl.glCallList(3) es la lista de presentación 3 englobada en el método DrawSphere2.

______________________________________________________________________

        private void ListDrawSphere2()
        {
            Gl.glNewList(3, Gl.GL_COMPILE);
            DrawSphere2();
            Gl.glEndList();
        }

        private void DrawSphere2()
        {
            Gl.glPushMatrix();

            Gl.glEnable(Gl.GL_TEXTURE_2D);
            Gl.glTexEnvi(Gl.GL_TEXTURE_2D,

            Gl.GL_TEXTURE_ENV_MODE, (int)Gl.GL_DECAL);
            //Se usa la textura que el usuario selecciona en el combo
            Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[7]);
            Gl.glFrontFace(Gl.GL_CCW);

            Glu.GLUquadric p = Glu.gluNewQuadric();
            Glu.gluQuadricDrawStyle(p, Glu.GLU_FILL);
            Glu.gluQuadricNormals(p, Glu.GLU_SMOOTH);
            Glu.gluQuadricTexture(p, Gl.GL_TRUE);
            Glu.gluSphere(p, 1.5, 30, 30);

            Gl.glPopMatrix();
        }

______________________________________________________________________

Música y Foto

La música es un fragmento de la canción de Tool (Intension) del álbum Vicarious (2006). Aunque se ha modificado ligeramente con el Audacity.

La foto del ojo se ha modificado con el Photoshop (aquella época en la que lo usaba), aunque con el GIMP se puede hacer también y queda igual.

Reconocer tarjetas SD en AAO con Ubuntu 9.10

2009-12-28T17:10:00.000Z

Al instalar Ubuntu en el Acer Aspire One, es posible que no reconozca el lector de tarjetas SD. Existe al menos una solución. En el blog de hayunmundoahifuera está la solución muy bien explicado, tanto para Ubuntu 9.10 como para versiones anteriores.

Plugin Latex para Gedit

2009-11-26T22:09:00.001Z

He estado buscando por internet y he encontrado un plugin para el editor de predeterminado de Gnome, el Gedit. Éste es un editor bastante sencillo y que confieso que nunca uso, soy más de vim, aunque para este tipo de tareas, si puedo disponer de un editor que agilice un poco la tarea, mucho mejor. El caso es que éste plugin incluye combinaciones de teclas, por ejemplo para generar y previsualizar el pdf. También proporciona algunos botones para el tipo de letra, incluir items, tablas, código, gráficos, un panel lateral con los símbolos más usuales etc. En definitiva, algo parecido al kile, pero más ligero y sin errores (que el kile 2.1 para el KDE4 da bastantes problemas).

Os dejo el enlace de descarga:

http://live.gnome.org/Gedit/LaTeXPlugin/Development

Cómo instalarlo

Es muy sencillo. Se descarga el tar.gz, lo descomprimimos y llevamos el contenido, que son un directorio y un fichero (GeditLaTeXPlugin/ y GeditLaTeXPlugin.gedit-plugin), al directorio ~./gnome2/gedit/plugins .En el caso de que no exista el directorio plugins, lo creamos.

Luego abrimos en Gedit y en Editar -> Preferencias y la pestaña Complementos, activamos en GeditLatexPlugin.

Para poder compilarlo, este plugin hace uso del programa rubber, que es un sistema de construcción de documentos de latex. En caso de que no esté instalado, hacemos:

$ sudo apt-get install rubber

Con esto, debería de funcionar.
Enjoy!!

Mostrar la Hora en un Applet Java

2009-10-23T17:19:00.002+01:00

El siguiente programa es un ejemplo muy sencillo de un Applet Java que muestra la hora actual del sistema. Se usa la interfaz Runnable para poder preguntar cada segundo por la hora actual.

________________________________________________________

/*
 * Applet que muestra la hora en una etiqueta. 
 */

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Calendar;
import java.util.GregorianCalendar;

public class AppletHour extends JApplet implements Runnable {

    private int hora, minutos, segundos;
    JLabel label;
    Calendar calendario;
    Thread h1;

    public void init() {
            getContentPane().setLayout(new BorderLayout());
            Container c = getContentPane();
            label = new JLabel(" ");
            label.setFont(new Font( "Helvetica", Font.BOLD, 50 ));
            c.add(label, BorderLayout.CENTER);
            h1 = new Thread(this);
            h1.start();
   }

    public void calcula () {

        Calendar calendario = new GregorianCalendar();
        hora = calendario.get(Calendar.HOUR_OF_DAY);
        minutos = calendario.get(Calendar.MINUTE);
        segundos = calendario.get(Calendar.SECOND); 
    }

    public void run() {
        Thread ct = Thread.currentThread();
        while(ct == h1) {   
            calcula();
            label.setText(hora + ":" + minutos + ":" + segundos);
            try {
           //System.out.println(hora + ":" + minutos + ":" + segundos);
                Thread.sleep(1000);
            }
            catch(InterruptedException e) {}
        }
    }

    public void stop() {
        h1 = null;
    }
}

________________________________________________________

Thread en Java

2009-10-09T17:13:00.003+01:00

Los Thread (hilos) en Java, se les suele llamar también procesos ligeros (lightweight processes). Éstos consumen menos recursos que la creación y ejecución de un proceso normal. La creación de un proceso duplica exactamente los mismos recursos que el proceso padre (el que le creó), esto implica el estado del proceso, el contador de programa, información de planificación, etc. Cuando se crea un thread en Java, lo único que necesita es el contador de programa la pila de ejecución, puesto que los demás recursos los comparte con el padre.

Creación de Thread en Java

Hay dos formas de crear los Thread.

Heredando (extends) de la clase Thread. Esta clase se encuentra en el paquete java.lang. Este paquete se importa por defecto en todo programa Java.
Implementando la interfaz Runnable. Esta interfaz se encuentra en el paquete java.lang.

Heredando de Thread

Es muy sencillo. Se hereda y se implementa el método run(). Cuando queramos poner en marcha el thread, se invoca al método start, no al run. El método start es que el planifica y asigna recursos al thread. Un ejemplo: en el método run, se hace un bucle grande e imprime cada 500 Iteraciones y el thread que lo está ejecutando. Variando esta cantidad, se ve como se alternan los thread.

________________________________________________________

/* 
 *  Método 1: Heredando de la clase Thread
 *  La clase Thread pertenece al paquete  
 *  java.lang que se importa por defecto.
 */

public class TestThread extends Thread {

    public static void main (String []args) {
    
        TestThread h1 = new TestThread();
        TestThread h2 = new TestThread();
        //Creamos 2 thread

        h1.start();
        h2.start();
    }

    //Si se hereda de la clase Thread, se debe 
    //implementar el método run()
    public void run() {
        for (int i = 0; i < 500000; i++)
            if ((i % 500) == 0)
                System.out.println(getName()+ " : " + i);
    }
}
________________________________________________________

Implementando la interfaz Runnable

Java no permite herencia múltiple. Por eso disponemos de la interfaz Runnable y así "permitir" herencia múltiple. Lo que tenemos que hacer es implementar, al igual que antes, el método run(). Además, para crear el Thread, ahora tenemos que crearnos un dato nuevo de tipo Thread y pasarle como argumento (en el contructor) el tipo implementado con la interfaz Runnable. Se ve mejor con un ejemplo.

________________________________________________________

public class TestRunnable implements Runnable {

    //Dato
    int hilo;
    public TestRunnable(int hilo) {
        this.hilo = hilo;
    }

    public static void main (String []args) {
        (new Thread(new TestRunnable(0))).start();
        (new Thread(new TestRunnable(1))).start();
    }

    public void run () {
        for (int i = 0; i < 500000; i++) {
            if ((i % 500) == 0)
                System.out.println(hilo + " : " + i);
        }
    }
}

__________________________________________

Referencias:

Generando un makefile con fpcmake

2009-09-26T20:49:00.001+01:00

Con FreePascal, existe una herramienta llamada fpcmake que genera un makefile a partir de un fichero de configuración, y así poder usar el make de GNU.

Instalación

En Ubuntu, esta herramienta está incluida en el paquete fp-utils (Un único paquete de 3730kB). Para instalarla hacemos:

$ sudo apt-get install fp-utils

Fichero de configuración

El fichero de configuración tiene que llamarse makefile.fpc . En él, escribimos los nombres de los fuentes (units, ficheros principales y ejemplos), versión del compilador a usar, nombre de paquete, versión, etc. No son obligatorias todas las etiquetas, lo que, si no se definen, no estarás dichas disponibles las opciones en el makefile.

Algunas de las secciones son las siguientes:

[target]
Esta sección es la más importante del fichero makefile.fpc. Es donde están especificadas las reglas para compilar todo (make all) y de donde se coge el make default. Algunas de las opciones son:

programs: lista de programas separadas por espacio sin la extensión .pas. El fpcmake los pone automáticamente.
units : lista de unidades separadas por espacios sin la extensión. El fpcmake los pone automáticamente.
examples: lista de programas de ejemplo. Al igual que los dos anteriores, separados por espacio y sin extensión.

[compiler]
En esta sección se puede especificar:

version: en esta sección se puede especificar la versión del compiladors
options: las opciones para compilar. Por ejemplo, le podemos pasar -g para depurar.
unitdir: lista de directorios separados por dos puntos de las units incluidas (si están en otro directorio). Hay que pasarle al compulador la opción -Fu.

[package]
Un paquete es un conjuto de units. En esta sección se pueden especificar:

name: nombre del paquete.
version: versión del paquete
main: para indicar el paquete forma parte de otro paquete.

Existen más secciones como install (donde se especifican los directorios donde se colocarán los programas y datos), dist, para crear una distribución de los programas etc.
Para más detalle, se puede consultar el manual en consola:

$ man 5 fpcmake

Otra fuente es el apéndice E de la guía de programadores de freepascal. link. Aquí está todo bien detallado.

Un ejemplo sencillo es el siguiente:

$ cat -n makefile.fpc
     1    [target]
     2    programs=main             #Programa principal
     3    units=unit1 unit2          #Todas las units
     4    examples=test1 test2 #Programas ejemplo
     5
     6
     7    [compiler]
     8    version=2.2.2-8
     9    options=-g   #opciones del compilador
    10

Generar el Makefile

Una vez hecho el archivo de configuración hacemos:

$ fpcmake
Processing makefile.fpc
i386-linux requires: rtl
Writing Makefile

Usando make

Con el makefile generado, tenemos múltiples opciones. Algunas de ellas son:

make : compila los princiales más las units especificadas.
make examples: compila los programas ejemplos.
make clean : borra todos los .o y .ppu
make install : instala los programas más las units.
make info : devuelve información acerca del programa, directorios de trabajo, versión, librerías, etc.

Nota: cuando hacemos el make, se nos crea una carpeta units/ donde se van a colocar todos los .o y .ppu. Al hacer make clean, se borrarán de este directorio.

#bug en versiones debian

Hay un bug en versiones del compilador 2.2.0 para sistemas de 64 bits:

$ fpcmake -v
FPCMake Version 2.0.0 [2009/01/08]
Processing makefile.fpc
Targets: "x86_64-linux"
Globals:
    FPCDIR = ""
    PACKAGESDIR = "$(FPCDIR)/packages $(FPCDIR)/packages/base $(FPCDIR)/packages/extra $(FPCDIR)/packages"
    UNITSDIR = "$(FPCDIR)/units/$(FULLTARGET)"
    BASEDIR = "/home/juanjo/Desktop/Clases0910/FreePascal/listas"
Required packages for linux-x86_64: rtl
Package "rtl": Looking for Makefile.fpc: " /packages/rtl/Makefile.fpc /packages/base/rtl/Makefile.fpc /packages/extra/rtl/Makefile.fpc /packages/rtl/Makefile.fpc "
Package "rtl": Looking for Package.fpc: " /units/x86_64-linux/rtl/Package.fpc "
Error: Target "linux", package "rtl" not found

Enlace del bug: http://bugs.freepascal.org/view.php?id=10775

Manual básico de gdb

2009-09-24T22:49:00.003+01:00

El depurador gdb (GNU Debugger) es el depurador estándar de Linux. Fue creado por Richard Stallman en el año 1988. Después de esta introducción de wikipedia, pasamos a ver como se usa.

Con gdb podemos depurar código C/C++, Pascal, y Ada. Es un depurador de línea de comandos, aunque existe una parte gráfica llamada DDD. A mí personalmente, el DDD me dio muchos problemas. Me fío más de la línea de comandos.

Para usarlo, es necesario compilar el fuente con la opción de depuración, para C, C++ y Pascal, dicha opción es -g.

Programa de ejemplo pascal para probar con gdb.

______________________________________________________

program ejemplo;

procedure proc ();
var
  i : integer;
begin
  for i := 1 to 10 do
    writeln('In for: ', i);
end;
  
begin
  writeln('This is the first line');
  proc();
end.

______________________________________________________

Compilamos con la opción -g

$ fpc -g ejemplo.pas

Cargando el depurador

$ gdb ./ejemplo
GNU gdb 6.8-debian
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu"...
(gdb)

Listar el código

Para listar el código usamos el comando list o l simplemente. El patrón es el siguiente:
list | l lineInit, lineEnd

Ejemplo:

(gdb) list 1, 5
1   program ejemplo;
2
3   procedure proc ();
4   var
5      i : integer;
(gdb)

Nota: Si le damos a ENTER sin ninguna opción, se vuelve a repetir el último comando.

(gdb)
6    begin
7    for i := 1 to 10 do
8        writeln('In for: ', i);
9    end;
10
11
12    begin
13    writeln('This is the first line');
14    proc();
15    end.(gdb)

Colocar breakpoints

Para colocar breakpoints usamos el comando break line, o b line, donde line es el número de línea que queremos el breakpoint. Suponer que la queremos colocar el la línea 13.

(gdb) b 13
Breakpoint 1 at 0x400229: file ejemplo.pas, line 13.

Comenzar la ejecución

Una vez tengamos hayamos puesto puntos de ruptura (también se podría poner wachpoint y catchpoint) pasamos a ejecutar el programa. Para ello usamos la instrucción run.

(gdb) run
Starting program: /home/user/Desktop/ejemplo

Breakpoint 1, main () at ejemplo.pas:13
13 writeln('This is the first line');
(gdb)

Traza

Ahora tenemos varias posibilidades:

Ir paso a paso pasando por cada función: usamos step
Ejecutar la instrucción actual: usamos stepi
Ir paso a paso sin pasar por cada función: cont.

Por ejemplo:

(gdb) step
This is the first line
14    proc();
(gdb)
PROC () at ejemplo.pas:7
7    for i := 1 to 10 do
(gdb)
8        writeln('In for: ', i);
(gdb)
In for: 1
7    for i := 1 to 10 do
(gdb)
8        writeln('In for: ', i);
(gdb) cont
Continuing.
In for: 2
In for: 3
In for: 4
In for: 5
In for: 6
In for: 7
In for: 8
In for: 9
In for: 10

Program exited normally.

Imprimir el valor de una variable

Para mostrar por pantalla el valor de una variable usamos la instrucción print nombre_variable.

(gdb) step
8 writeln('In for: ', i);
(gdb) print i
$3 = 1

Limpiar la lista de breakpoints

Para quitar un breakpoint, usamos clear num_Line. Donde num_Line es el número de línea donde teníamos un breakpoint. Si no nos acordamos la línea en la que lo hemos puesto, usamos el comando info breakpoints.

Para eliminar todos los breakpoints usamos delete breakpoints.

Ejemplo:

(gdb) info breakpoints
Num     Type           Disp Enb Address            What
3       breakpoint     keep y   0x0000000000400229 in main at ejemplo.pas:13
4       breakpoint     keep y   0x00000000004001ac in PROC at ejemplo.pas:7
(gdb) delete breakpoints
Delete all breakpoints? (y or n) y
(gdb) info breakpoints
No breakpoints or watchpoints.
(gdb)

Uso básico de subversion

2009-09-17T20:28:00.003+01:00

Subversion es un sistema de control de versiones bajo Licencia Apache. Creado para sustituir a CVS.

Instalando subversion

Lo podemos descargar desde la página principal de subversion. Si estamos un ubuntu podemos hacer:

$ sudo apt-get install subversion

Existen también interfaces gráficas para subversion como son KdeSVN y Tortoise.

Sistema de Control de Versiones

Un sistema de control de versiones (por dar una definición distinta a los miles de páginas que hablan de esto) es un programa que permite la copia nuestros documentos sin tener que recurrir a copiarlos con distinto nombre, o en directorios distintos mientras lo estamos desarrollando.

Por ejemplo. suponer que estamos desarrollando un programa en C. Podríamos tener una primer programa que funcione, pero que para nada está completada. Pues una primera versión podría ser esta. Al segundo día de desarrollo, mejoramos la interactividad con el usuario y tocamos muchas cosas del código. Si no nos funciona pueden pasar dos cosas:

a) Que tengamos una copia de seguridad por cualquier otro lado y recuperarla.

b) Que no la tengamos y si no nos funciona, nos la tenemos que ingeniar para arreglarlo.

Al usar subversion, guardaríamos los cambios en un repositorio, tantas veces como queramos. Si luego, nos hiciera falta volver a una versión anterior, o queremos saber lo que hicimos el 2 de diciembre del 2005 (siempre y cuando esté en el repositorio), podríamos recuperarlo con un simple comando. Esa es la idea, facilitar al desarrollador la creación de programas. Es más, si hay varios desarrolladores trabajando, cada uno se baja del repositorio los últimos cambios, y al finalizar los expone para que sus compañeros sigan trabajando sin necesidad de tener cientos de carpetas.

Subversion está pensado principalmente para trabajar con ficheros de texto, como es el código fuente de programas. Esto no quiere decir que en nuestro repositorio podamos subir imágenes, ficheros word, etc, pero hay que tener cuidado, porque subversion almacena las diferencias de un fichero a otro. Si es un fichero de texto, las diferencias son las líneas de texto (o trozos de texto, si se quiere ver así) en las que cambia. Mientras que si subimos un fichero binario, al hacer el mínimo cambio, su representación binario es diferente, con lo cuál, el fichero binario será completamente distinto al del repositorio. Esto implica que el repositorio aumentará de tamaño dependiendo del binario y del número de veces que lo versionemos. Por eso, en este aspecto hay que tener cuidado.

Lo que se suele hacer es versionar los fuentes (ficheros de texto), que es con lo que se trabaja día a día. Si acaso alguna imagen (iconos) que son imágenes que no suelen cambiar.

Creando un repositorio

La forma de crear un repositorio es con el comando svnadmin. Se entenderá mejor con un ejemplo.

$ svnadmin create MiRepositorio

Esto crea una jerarquí de directorios como la siguiente:

No os preocupéis, en principio no hay que tocar nada de aquí, afortunadamente.

Importar un proyecto

Una vez creado el repositorio, lo que tenemos que hacer es importar nuestros ficheros y directorios donde estábamos haciendo el desarrollo. Suponer la siguiente jerarquía de proyecto:

$ tree Proyecto/
Proyecto/
|-- Dos
`-- Uno
`-- file.txt

2 directories, 1 file

Dos carpetas y un fichero. Ahora queremos subir esto al repositorio. A este paso se le llama importar el proyecto.

$ svn import /tmp/MiProyecto/ file:///tmp/MiRepositorio/ -m "Creación del proyecto"
Añadiendo      /tmp/Proyecto/Uno
Añadiendo      /tmp/Proyecto/Uno/file.txt
Añadiendo      /tmp/Proyecto/Dos

Commit de la revisión 1.

Donde los argumentos son:

La ruta donde está el proyecto a importar.
La ruta del repositorio.
Comentario acerca de la versión

Ya podemos borrar la jerarquía de proyecto. Ahora solo nos hace falta el repositorio.

Espacio de trabajo

Una vez importado, creamos el espacio de trabajo, que podría ser el el home mismo. Para bajarnos la última versión del programa usamos el argumento checkout de subversion.

$ svn checkout file:///tmp/MiRepositorio/

El segundo argumento es la ruta completa donde está el repositorio. Se nos crea, en el directorio donde lo hayamos hecho, la jerarquía que teníamos del proyecto, con la peculiaridad de que ahora tenemos unos archivos .svn donde estará la información necesaria para comunicarse con el repositorio.

Comandos de trabajo

Los comandos más comunes para el trabajo diario son:

svn update : actualiza el repositorio.

$ svn update
En la revisión 1.

svn add file : añade un fichero o un conjunto de ficheros al repositorio.

$ svn add file2.txt

svn commit : guarda los cambios y crea una nueva versión.

$ svn commit -m "Comentario de la version"
Añadiendo Uno/file2.txt
Transmitiendo contenido de archivos .
Commit de la revisión 2.

Si queremos volver a una versión anterior, una de las formas es asociarla por el comentario que se hizo cuando se produjo el commit.

$ svn log
------------------------------------------------------------------------
r2 | user | 2009-09-17 20:14:37 +0100 (jue 17 de sep de 2009) | 1 line

Comentario de la version
------------------------------------------------------------------------
r1 | user | 2009-09-17 19:52:08 +0100 (jue 17 de sep de 2009) | 1 line

Creación del proyecto
------------------------------------------------------------------------

Por tanto, si ahora queremos recuperar la primera hacemos un checkout de la primera.

$ svn checkout -r 1 file:///tmp/MiRepositorio/ Rev2

Le pasamos -r y luego el número de la versión. La última cadena "Rev2" es simplemente para colocarlo en un directorio llamado Rev2. Lo crea dinámicamente.

Para ver las diferencias usamos la opción diff. Por ejemplo, para ver la diferencia entre la versión 1 y la 2 hacemos:

$ svn diff -r 1:2 file:///tmp/MiRepositorio/
Index: Uno/file2.txt
============================================

Manuales

No es muy complicado de usar, al menos lo básico y una vez que se acostumbre es muy útil. Esto no es más que un pequeño comienzo. Para ver manuales y tutoriales están las siguiente urls.

Copias de seguridad en MySQL

2009-09-11T11:10:00.002+01:00

Hay dos métodos para hacer copias de seguridad. Yo explicaré los dos, aunque el recomendable es el segundo, que hace uso del comando mysqldump.

Método 1: Copiar archivos de la base de datos

Este método es a pelo, es decir, coger directamente los archivos dentro de la jerarquía de directorios de mysql donde están definidas las bases de datos. Este método no se recomienda porque pueden haber diferencias de formatos entre distintas versiones de MySQL, si lo que pretendemos es traspasar la base de datos de una máquina a otra. En Windows, la ruta donde se guardan las bases de datos es parecida a la siguiente:

C:\Archivos de programa\MySQL\MySQL Server5.X\data[nombreBaseDeDatos]

Donde X completa la versión que tengamos de MySQL. En sistemas Linux y Mac OS x se encuentra en /var/lib/mysql/

Método 2: Uso del comando mysqldump

El segundo método, y el recomendado es hacer uso de comando mysqldump. Este comando tiene múltiples opciones. Veremos aquí sólo algunas de ellas. Lo necesario para sobrevivir. Por supuesto, siempre queda la documentación.

$ man mysqldump

La ventaja de usar este comando, es que no depende de la versión y funciona igual en cualquier máquina. La sintaxis típica para este comando es:

$ mysqldump -u usuario -p objeto_a_respaldar

El objeto a respaldar puede ser toda la base de datos, una base de datos en concreta, una tabla o un conjunto de tablas. Para verlo mejor, hacemos una ejemplos. Suponer que tenemos una base de datos test y una tabla dentro de esa base de datos que se llama cliente.

Respaldo de base de datos: Vamos a copiar la base de datos test:

$ mysqldump -u root -p test > test.bk.sql

Respaldo de una tabla: Vamos a respaldar la tabla cliente.

$mysqldump -u root -p test cliente > cliente.bk.sql

Respaldo de toda la base de datos:

$ mysqldump -u root -p --all-databases > database.bk.sql

Restaurar la base de datos

Si queremos recuperar los datos, es muy sencillo. Si hemos usado el método de coger directamente el archivo, es llevarlo nuevamente a su sitio correspondiente. Si hemos usado el comando mysqldump queda como sigue.

Si hemos hecho copia de toda la base de datos (--all-databases) la recuperación queda:

$ mysql -u root -p < databases.bk.sql

Si hemos hecho una copia selectiva de alguna base de datos, hay que añadirle la opción -D.

$ mysql -u root -p -D test < test.bk.sql

Creación de tablas en MySQL

2009-09-10T17:41:00.001+01:00

En este post, me centraré en cómo crear tablas, inserción de datos y hacer consultas sencillas usando MySQL. Todo esto lo haré desde la línea de comandos.

Creación de tablas

La sintaxis es la siguiente, de forma muy reducida.

mysql> CREATE TABLE nombre_tabla (
nombre_columna1 tipo_dato opciones,
nombre_columna2 tipo_dato opciones ...);

nombre_tabla y nombre_columna son los nombres que les queramos dar. Los tipo de datos más comunes son:

1. Numéricos

int (tamaño): entero de 4 bytes.
bigint(tamaño): entero largo de 8 bytes.
float (precisión): flotante de 24 dígitos.
double(precisión): real de 53 dígitos.

2. Cadenas

char(tamaño): cadenas de longitud fija.
varchar(tamaño): cadenas de longitud variable.

3. Fechas

date : almacena una fecha en formato 'AAAA-MM-DD'
datetime: almacena una fecha y una hora: 'AAAA-MM-DD HH:MM:SS'
time: almacena la hora. 'HH:MM:SS'

Las opciones más comunes son las siguientes:

not null: no permitimos que la columna tenga valores nulos.
primary key: establecemos la clave primaria de la tabla.
foreign key: establecemos la clave ajena de la tabla.

________________________________________________________

Ejemplo: Se desea crear una tabla Cliente que tenga como atributos el DNI, el nombre y la edad. Cada cliente se identifica por su DNI, por lo que ésta será su clave primaria.

create table cliente (
dni VARCHAR(9) NOT NULL,
nombre VARCHAR(50),
edad INT(3),
PRIMARY KEY (dni));

Insertar filas en las tablas

Ahora vamos a insertar filas. Es muy sencillo. La sintaxis es la siguiente:

mysql>INSERT INTO nombre_tabla VALUES (
valor1, valor2, ... , valorn)

donde n es igual al número de columnas de la tabla.

Por ejemplo: si queremos insertar un cliente en la tabla creada anteriormente sería:

INSERT INTO cliente VALUES (
"12345678A", "peter", 22
);

Selección de filas

Si queremos ver las filas insertadas la forma es mediante la instrucción SELECT.

mysql> SELECT nombre_Col1, nombre_Col2,
FROM nombre_tabla
WHERE (condición);

Esta es la forma general. Por ejemplo, si quisiéramos ver todas las filas y las columnas haríamos:

SELECT * FROM cliente;

El siguiente ejemplo muestra sólo los dni de los clientes que sean menores de 30 años. Esta restricción se la especificamos en la cláusula WHERE.

SELECT dni
FROM cliente
WHERE (edad < 30);

Actualización de valores

Usamos la sentencia a UPDATE de mysql:

UPDATE cliente
SET nombre="juanito"
WHERE dni="12345678A";

Todo esto no es más que una pequeñísima instrucción a MySQL. Para ampliar no hay nada mejor que los manuales de referencia de mysql.

Primeros pasos en MySQL

2009-09-08T18:15:00.009+01:00

Una vez instalado MySQL,(en un post anterior expliqué como instalarlo para Ubuntu) entramos mediante línea de comandos en el Sistema Gestor de Base de Datos (SGBD).

Entrada a MySQL

La instrucción es la siguiente:

$ mysql -u root -p

Durante el proceso de instalación, tuvimos que poner la contraseña para el usuario root, pues es esa la que nos pide inmediatamente.

Mostrar las bases de datos

Lo primero que podemos hacer es ver las bases de datos que están disponibles. Para ello usamos el comando show con el argumento databases.

mysql> show databases;

Se nos mostrará una lista, entre las que podemos encontrar information_schema y mysql, donde están almacenados, por ejemplo, los usuarios.

Crear una Base de Datos

Para crear una base de datos usamos la sentencia create database nombre_BD

mysql> CREATE DATABASE test;

Crear un usuario

Ahora, creamos un usuario con permisos a la base de datos 'test'. Y así no tener que entrar como root. Hay varias formas de crear un usuario. Una de ellas es con la sentencia GRANT.

1. Sentencia GRANT

Por ejemplo, podemos crear un usuario con todos los provilegios sobre la base de datos test que acabamos de crear. Para ello hacemos lo siguiente:

mysql> grant all on test.* to new_user@localhost identified by 'pass';

La sentencia anterior, crea un usuario llamado new_user con todos los provilegios sobre la base de datos test. Al poner 'all' estamos concediendo todos los privelegios sobre la base de datos test al usuario new_user. Si queremos podemos restringirlo y solamente ponerle, por ejemplo, inserción y consulta. En ese caso, usaremos SELECT, INSERT. Todos los privilegios van separados por comas. Se puede ver la lista completa de privilegios en la documentación de mysql. Sentencia grant.

Ahora, para entrar como el nuevo usuario hacemos:

$ mysql -u new_user -p pass

2. Sentencia CREATE USER

Otra forma de crear un usuario es mediante la sentencia CREATE USER. Un ejemplo:

mysql> CREATE USER new_user@localhost IDENTIFIED BY 'pass'

Con esta forma de crear, el usuario nuevo no tiene ningún privilegio. Por tanto, tendremos que concedérselos con la sentencia GRANT.

En el siguiente post explicaré como crear tablas y acceder a ellas.

Sucesión de Fibonacci en C++

2009-09-02T15:56:00.004+01:00

Muestro un ejemplo en C++ que devuelve la item n-ésimo de la sucesión de Fibonacci. Es un programa de línea de comandos que tiene 4 opciones: -v para el modo verbose, -h para la ayuda, -t para imprimir el tiempo que tarda en segundos y -n para calcular el n-ésimo número de Fibonacci.

Ejemplo de uso:

$ ./fibo -vtn 15 #imprime los 15 primeros coeficientes

El programa usa un algoritmo de tipo iterativo (los más sencillitos), y tiene una complejidad de O(n).

El código es el siguiente:
______________________________________________________

/*
    Fecha: 01/09/09
    Programa: retorna la suma n-ésima
           de la sucesión de fibonacci
*/


#include <iostream>
#include <string>
#include <sstream>
#include <time.h>
#include <unistd.h>
using namespace std;

int main (int argc, char **argv) {

    /* variables */
    double sum;
    double fibo_aux[2];
    fibo_aux[0] = 0;
    fibo_aux[1] = 1;
    unsigned long num = -1;
    char oc;
    bool do_time = false, do_verbose = false, do_help = false;

    while ((oc = getopt(argc, argv, ":vn:ht")) != -1) {
        switch (oc) {
            case 'v':
                do_verbose = true;
                break;
            case 'h':
                cout << "./fibo [-options] [num]" << endl;

                cout << "Options: \n\t -v : modo verbose \n\t

                -h: esta ayuda\n\t -t : imprime el tiempo que tarda \n\t -n

                 <numero>: calcula fibonacci de orden <numero>" << endl;
                do_help = true;
            case 't':
                do_time = true;
                break;
            case 'n':
                stringstream buf(optarg);
                buf >> num;
            break;
        }
    }

    if (!do_help) {
        //Por defecto calcula los 10 primeros

        //números de la sucesión de fibonacci
        if (num == -1) 

            num = 10;

        long t1 = clock();

        if (do_verbose) {

            cout << "f[0] = " << fibo_aux[0] << endl;
            cout << "f[1] = " << fibo_aux[1] << endl;

        }

        for (int i = 0; i <= num; i++) {
           sum = fibo_aux[0] + fibo_aux[1];
             if ((do_verbose==1) && (i > 1)) {
                cout << "f[" << i << "] = " <<

                fibo_aux[0] << endl;
            }
            if (num != i) {
                fibo_aux[0] = fibo_aux[1];
                fibo_aux[1] = sum;

            }
        }
        long t2 = clock();
        cout << "Fibonacci(" << num << ") = "

        << fibo_aux[0] << endl;
        if (do_time) {
      cout << "Tiempo total: " <<

               (t2-t1)/(double)CLOCKS_PER_SEC << " segundos" << endl;
        }
    }
    return 0;
}

_____________________________________________________