Sobre Valgrind

/*
| example1.c
|
| Uso de Valgrind
| 
| If you use uninitialized memory, write off the end of an array, 
| or forget to free a pointer, Valgrind can detect it. 
| 
| We'll focus mainly on the memcheck tool for this tutorial as running 
| valgrind with the memcheck tool will allow us to check correct memory usage.
| 
| 
| Compilacion
| $ gcc example1.c -o example1 -g
| 
| Valgrind
| $ valgrind --tool=memcheck --leak-check=yes ./example1
|
| Opciones
| --tool=memcheck
| --leak-check=yes
| --show-reacheable=yes  There will be times when the --leak-check=yes option will not result in showing you all memory leaks. 
*                       To find absolutely every unpaired call to free or new, you'll need to use the --show-reachable=yes option. Its output is almost exactly the same, but it will show more unfreed memory. 
| 
| Salida de Valgrind

==5316== Memcheck, a memory error detector
==5316== Copyright (C) 2002-2011, and GNU GPL'd, by Julian Seward et al.
==5316== Using Valgrind-3.7.0 and LibVEX; rerun with -h for copyright info
==5316== Command: ./example1
==5316== 
==5316== 
==5316== HEAP SUMMARY:
==5316==     in use at exit: 100 bytes in 1 blocks
==5316==   total heap usage: 1 allocs, 0 frees, 100 bytes allocated                         [1]
==5316== 
==5316== 100 bytes in 1 blocks are definitely lost in loss record 1 of 1                    [2]
==5316==    at 0x402BE68: malloc (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)
==5316==    by 0x80483F8: main (example1.c:58)                                              [3]
==5316== 
==5316== LEAK SUMMARY:
==5316==    definitely lost: 100 bytes in 1 blocks                                          [4]
==5316==    indirectly lost: 0 bytes in 0 blocks
==5316==      possibly lost: 0 bytes in 0 blocks
==5316==    still reachable: 0 bytes in 0 blocks
==5316==         suppressed: 0 bytes in 0 blocks
==5316== 
==5316== For counts of detected and suppressed errors, rerun with: -v
==5316== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

| 
| [1] El numero de allocs no coincide con el numero de frees, por lo tanto, no se esta liberando
|     memoria correctamente.
| [2] Memoria perdida
| [3] Para conocer el numero de linea que causa el problema, se debe usar la opcion -g de gcc
| [4] Sumario de memoria perdida
| 
| 
| Fuente: http://www.cprogramming.com/debugging/valgrind.html
*/

#include <stdlib.h>

int main()
{
    char *x = malloc(100);
    return 0;
}
/*
| example2.c
|
| Uso de Valgrind
| 
| Valgrind can also find the use of invalid heap memory using the memcheck tool. 
| For instance, if you allocate an array with malloc or new and then try to 
| access a location past the end of the array:
| 
| char *x = malloc(10);
| x[10] = 'a';
|
| Compilacion
| $ gcc example2.c -o example2 -g
| 
| Valgrind
| $ valgrind --tool=memcheck --leak-check=yes ./example1
|
| Opciones
| --tool=memcheck
| --leak-check=yes
| --show-reachable=yes  There will be times when the --leak-check=yes option will not result in showing you all memory leaks. 
*                       To find absolutely every unpaired call to free or new, you'll need to use the --show-reachable=yes option. Its output is almost exactly the same, but it will show more unfreed memory. 
| 
| Salida de Valgrind
|
==5517== Invalid write of size 1                                    [1]
==5517==    at 0x8048404: main (example2.c:67)
==5517==  Address 0x4200032 is 0 bytes after a block of size 10 alloc'd
==5517==    at 0x402BE68: malloc (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)
==5517==    by 0x80483F8: main (example2.c:66)
|
| 
| [1] Error de escritura
| 
| 
| Fuente: http://www.cprogramming.com/debugging/valgrind.html
*/

#include <stdlib.h>

int main()
{
    char *x = malloc(10);
    x[10] = 'a';
    return 0;
}
/*
| example3.c
|
| Uso de Valgrind
| 
| Another type of operation that Valgrind will detect is the use of an uninitialized 
| value in a conditional statement. Although you should be in the habit of 
| initializing all variables that you create, Valgrind will help find those cases where you don't. 
| 
| Compilacion
| $ gcc example3.c -o example3 -g
| 
| Valgrind
| $ valgrind --tool=memcheck --leak-check=yes --show-reachable=yes  ./example3
|
| Opciones
| --tool=memcheck
| --leak-check=yes
| --show-reachable=yes  There will be times when the --leak-check=yes option will not result in showing you all memory leaks. 
*                       To find absolutely every unpaired call to free or new, you'll need to use the --show-reachable=yes option. Its output is almost exactly the same, but it will show more unfreed memory. 
| 
| Salida de Valgrind
|
==5661== Conditional jump or move depends on uninitialised value(s) [1]
==5661==    at 0x80483F2: main (example3.c:47)
|
| 
| [1] Uso de variable no inicializada
| 
| 
| Fuente: http://www.cprogramming.com/debugging/valgrind.html
*/

#include <stdlib.h>
#include <stdio.h>

int main()
{
    int x;
    
    if (x == 0)
        printf("x is zero");
    
    return 0;
}
/*
| example4.c
|
| Uso de Valgrind
| 
| Another type of operation that Valgrind will detect is the use of an uninitialized 
| value in a conditional statement. Although you should be in the habit of 
| initializing all variables that you create, Valgrind will help find those cases where you don't. 
| 
| Compilacion
| $ gcc example4.c -o example4 -g
| 
| Valgrind
| $ valgrind --tool=memcheck --leak-check=yes --show-reachable=yes  ./example4
|
| Opciones
| --tool=memcheck
| --leak-check=yes
| --show-reachable=yes  There will be times when the --leak-check=yes option will not result in showing you all memory leaks. 
*                       To find absolutely every unpaired call to free or new, you'll need to use the --show-reachable=yes option. Its output is almost exactly the same, but it will show more unfreed memory. 
| 
| Salida de Valgrind
|
==5733== Conditional jump or move depends on uninitialised value(s) [1]
==5733==    at 0x80483EE: foo (example4.c:39)
==5733==    by 0x8048413: main (example4.c:47)

|
| 
| [1] Traceback de la variable no inicializada
| 
| 
| Fuente: http://www.cprogramming.com/debugging/valgrind.html
*/

#include <stdlib.h>
#include <stdio.h>

void foo(int y)
{
    if (y == 0)
        printf("y is zero");
}


int main()
{
    int x;
    foo(x);
    
    return 0;
}
/*
| example5.c
|
| Uso de Valgrind
| Valgrind doesn't perform bounds checking on static arrays (allocated on the stack).
| So if you declare an array inside your function: 
| 
|   char x[10];
|   x[11] = 'a';
|
| Compilacion
| $ gcc example5.c -o example5 -g
| 
| Valgrind
| $ valgrind --tool=memcheck --leak-check=yes --show-reachable=yes  ./example5
|
| Opciones
| --tool=memcheck
| --leak-check=yes
| --show-reachable=yes  There will be times when the --leak-check=yes option will not result in showing you all memory leaks. 
*                       To find absolutely every unpaired call to free or new, you'll need to use the --show-reachable=yes option. Its output is almost exactly the same, but it will show more unfreed memory. 
| 
| Salida de Valgrind
|
==5733== Conditional jump or move depends on uninitialised value(s) [1]
==5733==    at 0x80483EE: foo (example4.c:39)
==5733==    by 0x8048413: main (example4.c:47)

|
| 
| [1] Traceback de la variable no inicializada
| 
| 
| Fuente: http://www.cprogramming.com/debugging/valgrind.html
*/

#include <stdlib.h>
#include <stdio.h>

int main()
{
    int x[10];
    //x[9] = 1;       // correcto
    x[11] = 1;       // correcto
    
    return 0;
}

Fuente: cprogramming.com

Sobre R

Variables


> name <- "carmen"; n1 <- 10; n2 <- 100; m <- 0.5

Mostrar variables

> ls()
[1] "m"    "n"    "n1"   "n2"   "name"
> ls(pattern="m")
[1] "m"    "name"
> ls(pat="m")
[1] "m"    "name"

> ls(pat="^m")
[1] "m"
> ls.str()
m :  num 0.5
n :  num 16
n1 :  num 10
n2 :  num 100
name :  chr "carmen"
> M <- data.frame(n1, n2, m)
> M
  n1  n2   m
1 10 100 0.5
> ls.str()
m :  num 0.5
M : 'data.frame':	1 obs. of  3 variables:
 $ n1: num 10
 $ n2: num 100
 $ m : num 0.5
n :  num 16
n1 :  num 10
n2 :  num 100
name :  chr "carmen"
> ls.str(pat="M")
M : 'data.frame':	1 obs. of  3 variables:
 $ n1: num 10
 $ n2: num 100
 $ m : num 0.5
> print(ls.str(pat="M"), max.level=-1)
M : 'data.frame':	1 obs. of  3 variables:

Eliminar variables

> ls()
[1] "list" "m"    "M"    "n1"   "n2"   "name"
> rm(m, n1)
> ls()
[1] "list" "M"    "n2"   "name"
> ls()
[1] "list" "m"    "M"    "n1"   "n2"   "name"
> rm(list=ls(pat="M"))
> ls()
[1] "list" "n2"   "name"

Sobre Latex

Múltiples referencias en Beamer

\begin{frame}[allowframebreaks]
\frametitle{Referencias}
\tiny\bibliographystyle{plain}                           % style
\bibliography{book_chapters,library}            % *.bib
\end{frame}

Fuente: tex

máx y max


\documentclass[letterpaper,11pt]{article}

%\usepackage[english, spanish, es-nodecimaldot, es-tabla, es-minimal]{babel} % max
\usepackage[english, spanish, es-nodecimaldot, es-tabla]{babel} % máx
\selectlanguage{spanish}

\usepackage[utf8]{inputenc}
\usepackage{lmodern}

\title{sample}
\author{author}
\date{\today}

\begin{document}

\maketitle

\begin{equation}
\max
\end{equation}

\end{document}

Python: Una alternativa a PYTHONPATH y la importación de paquetes

Muchos post recomiendan agregar tu directorio de trabajo (ej./home/user/projects/ci) en PYTHONPATH para importar código. Sin embargo, una forma rápida para reemplazar este método consiste en crear un enlace simbólico a tu directorio de trabajo en /usr/lib/python2.7/dist-packages.

auraham@virtual:/usr/lib/python2.7/dist-packages$ 
sudo ln -s /home/user/projects/ci

¿Por qué /usr/lib/python2.7/dist-packages? Bueno, al revisar la variable path muchos de los directorios radican en éste:

from sys import path
print path

['',
 '/usr/bin',
 '/usr/local/lib/python2.7/dist-packages/ipdb-0.7-py2.7.egg',
 ...
 '/usr/lib/python2.7/dist-packages',
 '/usr/lib/python2.7/dist-packages/PIL',
 '/usr/lib/python2.7/dist-packages/gst-0.10',
 '/usr/lib/python2.7/dist-packages/gtk-2.0',
 ...
]

Ventajas:

  • No requiere modificar path dentro ningún script
  • No requiere herramientas, como virtualenv ni snippets adicionales
  • Al incluir el directorio en el nivel más alto, tienes acceso a subdirectorios (subpaquetes)

Desventajas:

  • Si deseas llevar tu código a otro equipo, debes crear el enlace de nuevo.

Trucos matplotlib (en progreso)

Plot de ejemplo

ejemplo

from pylab import *

x = linspace(-100, 100+1, 1000)
y1 = 1*x
y2 = 1.5*x
y3 = 2*x
y4 = 3*x

#figure(num=None, figsize=(8, 6), dpi=80, facecolor='w', edgecolor='k')
fig = figure(num=None, figsize=(8, 6), dpi=100)

ax = fig.add_subplot(111)
ax.plot([x[0], x[-1]], [y1[0], y1[-1]])
ax.plot([x[0], x[-1]], [y2[0], y2[-1]])
ax.plot([x[0], x[-1]], [y3[0], y3[-1]])
ax.plot([x[0], x[-1]], [y4[0], y4[-1]])
#ax.set_title('Control Proporcional')
ax.set_xlabel('Error $e$')
ax.set_ylabel('Motor $u$')
ax.set_xlim((-100,100))
ax.set_ylim((-100,100))
ax.legend(('$k=1$', '$k=1.5$', '$k=2$', '$k=3$'),
           'lower right', shadow=True, fancybox=True)
ax.grid()


savefig('proportional.eps', dpi=100)
show()

Remover etiquetas en ticks

setp( ax1.get_xticklabels(), visible=False)

Ejemplo:

ejemplo

"""
spaces.py
"""
from pylab import *
from mpl_toolkits.mplot3d import Axes3D
   
fig1 = figure("decision")
fig1.gca().xaxis.set_major_locator(plt.NullLocator())
ax1 = fig1.add_subplot(111, projection='3d')
ax1.set_xlabel('$x_1$')
ax1.set_ylabel('$x_2$')
ax1.set_zlabel('$x_3$')
x,y,z = 5,4,3
ax1.scatter(x, y, z, c='g', marker='o')

# remover ticks ax1
setp( ax1.get_xticklabels(), visible=False)
setp( ax1.get_yticklabels(), visible=False)
setp( ax1.get_zticklabels(), visible=False)

show()

Fuente: matplotlib.org

Acentos

from matplotlib import rcParams
rcParams['text.usetex'] = True
...
ax1.set_title(r"espacio de decisi\'on")

ejemplo2

Ejemplo:

from pylab import *
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import rcParams
rcParams['text.usetex'] = True

fig1 = figure("decision")
fig1.gca().xaxis.set_major_locator(plt.NullLocator())
ax1 = fig1.add_subplot(111, projection='3d')
ax1.set_xlabel('$x_1$')
ax1.set_ylabel('$x_2$')
ax1.set_zlabel('$x_3$')
ax1.set_title(r"espacio de decisi\'on")
x,y,z = 5,4,3
ax1.scatter(x, y, z, c='g', marker='o')

# remover ticks ax1
setp( ax1.get_xticklabels(), visible=False)
setp( ax1.get_yticklabels(), visible=False)
setp( ax1.get_zticklabels(), visible=False)

show()

Fuente: matplotlib.org, stackoverflow

Intellij: Usar OpenCV en Android

1. Descargar OpenCV para andriod
Selection_003

2. Descomprimir el zip

Enseguida, descomprime OpenCV-2.4.6-android-sdk-r2.zip

$ unzip OpenCV-2.4.6-android-sdk-r2.zip

De aquí en adelante, el directorio en donde se encuentre será OPEN_CV (/home/auraham/OpenCV-2.4.6-android-sdk)

3. Importar los proyectos de ejemplo y el sdk a Intellij

El directorio OPEN_CV contiene un conjunto de programas de prueba en samples. Para poder ejecutarlos en un dispositivo, realiza lo siguiente:

3.1 Ir a File/Import Project... y seleccionar el directorio OPEN_CV

Select File or Directory to Import_004

3.2 Crear proyecto a partir de las fuentes existentes

Import Project_006

3.3 Siguiente hasta finalizar

4. Módulos
Una vez importados los programas de ejemplo, deberá aparecer esta lista de módulos en tu proyecto:

Selection_009

5. Ejecución en el teléfono (15-puzzle)

Asegúrate de seleccionar la opción USB device

Run-Debug Configurations_011

Presiona Run / Run '15-puzzle'

En el log de Intellij aparecerá lo siguiente:

Waiting for device.
Target device: 0123456789ABCDEF
Uploading file
	local path: /home/auraham/OpenCV-2.4.6-android-sdk/out/production/15-puzzle/15-puzzle.apk
	remote path: /data/local/tmp/org.opencv.samples.puzzle15
Installing org.opencv.samples.puzzle15
DEVICE SHELL COMMAND: pm install -r "/data/local/tmp/org.opencv.samples.puzzle15"
pkg: /data/local/tmp/org.opencv.samples.puzzle15
Success

Si no es así, retira el dispositivo y reinicia Intellij.

Listo, con esto tendrás un programa en ejecución

Proyecto más interesante

1. Descarga el zip del tutorial

2. Descomprime el zip

$ unzip OpenCV_code_example.zip

3. Importa el proyecto como se mencionó anteriormente

Select File or Directory to Import_012

4. Imporar el módulo java [sdk]

Antes de poder ejecutar el programa de ejemplo, se requiere hacer una referencia al módulo java [sdk] ubicado en OPEN_CV/sdk/java. Para esto, realiza lo siguiente:

4.1 Ir a File/Project Structure... /Modules
4.2 Presionar el botón Add/Import Module e importar el módulo java

4.3 Seleccionar Siguiente en todos los pasos
4.4 Aparecerá un cuadro de diálogo, selecciona Reuse

4.5 Selecciona OpenCVTutorial y ve al tab Dependencies.
4.6 Selecciona Add/Module Dependency/sdk

Choose Modules_016

4.7 Presiona Apply/OK

Una vez importado el sdk, puedes ejecutar la aplicación en tu dispositivo.

Kile y el problema de ‘too long lines 1024′

Básicamente el problema consiste en que Kile evita editar archivos con líneas muy largas. Una solución modificar Settings/Configure Kile…/Editor/Open Save/ la opción Line Length Limit a 0 (i.e. sin límite).

Por otra parte, Kile tiene un historial de los archivos previamente editados con el fin de guardar algunos atributos, entre ellos, el modo de sólo-lectura. Es decir, no basta con cambiar el párametro anterior, sino que se debe eliminar este archivo.

$rm /home/auraham/.kde/share/config/kilerc

Al reiniciar Kile aparecerá una ventana indicando que debe realizar un cambio en la configuración (por el paso de KDE3 a KDE4), pero es normal. Tras realizar lo anterior, no he perdido mis preferencias (mis shortcuts, mi diccionario, etc).