Ejemplo (Transformada de Fourier):

$latex \hat{f}(\xi)=\int_{-\infty}^{\infty} f(x) e^{-2 \pi i x \xi} d x $

Resulta en:

Para más información y opciones adicionales, visita la documentación de WordPress sobre el tema.

Consideremos una planta SISO escrita en forma afín (es decir, con separadas):

con vector de estados, vector de entradas al sistema, e vector de salidas. La idea de este approach es determinar una entrada específica para esta planta (una regla de control), de modo que todas las no linealidades se anulen:

Todo el sistema en conjunto, por lo tanto, se convierte en un mapeo lineal 1-a-1 entre la entrada nueva y la salida del sistema original.

¿Cuál es la ventaja de todo esto? El nuevo sistema es lineal, por lo tanto, podemos aplicar cualquier método que sirva para sistemas LTI en esta nueva planta modificada. Cabe destacar que estos métodos son mucho más universales que los métodos para control no lineal. Éstos últimos normalmente tienen requisitos mucho más restrictivos con respecto a su aplicabilidad.

/usr/lib/python2.7/lib-tk/Tkinter.pyc in __init__(self, screenName, baseName, className, useTk, sync, use)
1686 baseName = baseName + ext
1687 interactive = 0
-> 1688 self.tk = _tkinter.create(screenName, baseName, className, interactive, wantobjects, useTk, sync, use)
1689 if useTk:
1690 self._loadtk()

TclError: no display name and no $DISPLAY environment variable


¿Cuál es el problema en este caso? Según la información que encontré en el siguiente post de PythonAnywhere.com, el comando %paste toma la información directamente desde tu portapapeles, siendo así mucho más cómodo para nosotros, los que programamos. Sin embargo, el problema aquí es que por razones de seguridad, la sesión IPython no puede acceder al portapapeles de mi máquina local, dado que está siendo ejecutado a través de una sesión ssh. La solución en este caso es utilizar una variante: el comando %cpaste, que a diferencia del anterior, este solicita a través de consola pegar directamente el trozo de código que queremos ejecutar. De este modo, IPython recibe la información de manera explícita porque nosotros manualmente la pegamos. No olvides poner los dos guiones al final

In [3]: %cpaste
Pasting code; enter '--' alone on the line to stop or use Ctrl-D.
:

Fuente:
%paste magic fucntion in ipython? | siguiente post de PythonAnywhere

Más información después del salto:

La versión a utilizar en esta guía es Gadget-2.0.7. Más información y link de descarga están disponibles en el sitio web oficial GADGET2.

Antes de realizar algo, es necesario instalar las dependencias de GADGET:

1. HDF5

   La versión de HDF5 que utiliza GADGET es 1.6.x, puesto que se han hecho modificaciones incompatibles con el programa en las versiones posteriores. Al buscar en los repositorios en Synaptic, me encuentro con el paquete libhdf5-7, pero ésta corresponde a la versión 1.8.8-9, por lo que no nos sirve, así que toca configurar a mano. Descargamos la versión shared del siguiente link, dependiendo de su sistema operativo y configuración http://www.hdfgroup.org/ftp/HDF5/releases/hdf5-1.6.10/bin/. Mi sistema es de 64bits, por lo que descargué la versión linux-x86-64, pero si el tuyo es de 32bits debes descargar el linux-x86. Descomprimimos en nuestra carpeta HOME y renombramos la carpeta a .hdf5.

   usuario@linux ~/Descargas $ tar xvzf 5-1.6.10-linux-x86_64-shared.tar.gz
usuario@linux ~/Descargas $ mv 5-1.6.10-linux-x86_64-shared ../.hdf5

   Posteriormente configuraremos el Makefile de GADGET para que reconozca el directorio de HDF5.

2. FFTW

   Tenemos la suerte de que este paquete esté en los repositorios con la versión que necesitamos (2.1.5), puesto que la versión 3 no es compatible con GADGET. Sólo basta con ejecutar esto:
   usuario@linux $ sudo apt-get install fftw-dev sfftw-dev

3. GSL (GNU Scientific Library)

   usuario@linux $ sudo apt-get install libgsl0-dev

4. MPICH

   Necesitamos la versión 1.0 o superior. En los repositorios lo encontramos fácilmente:
   usuario@linux $ sudo apt-get install mpich2 build-essential

5. SZIP

   Descargamos el código fuente desde la siguiente página http://www.hdfgroup.org/doc_resource/SZIP/. El link está casi al final (link directo). Descomprimimos y vamos al directorio resultante:
   % mkdir ~/.szip
% ./configure --prefix=/home/($tuusuario)/.szip
% make
% make check
% make install

Configuración del Makefile

En el Makefile debemos notificar a GADGET en dónde se encuentran las librerías y cabeceras necesarias. Descomprimimos el contenido del tarball de Gadget2 en nuestra carpeta HOME, y buscamos la línea que dice SYSTYPE=”MPA”, cerca de la línea 89. Esto es para configurar los directorios dependiendo de la configuración de tu computador. Nosotros modificaremos éste, que es más general:

usuario@linux ~ $ cd ~/Gadget-2.0.7/Gadget2
usuario@linux ~/Gadget-2.0.7/Gadget2 $ nano Makefile

Localizamos el siguiente párrafo y agregamos lo que aparece en negrita:
ifeq ($(SYSTYPE),"MPA")
CC = mpicc
OPTIMIZE = -O3 -Wall
GSL_INCL = -I/usr/common/pdsoft/include
GSL_LIBS = -L/usr/common/pdsoft/lib -Wl,"-R /usr/common/pdsoft/lib"
FFTW_INCL=
FFTW_LIBS=
MPICHLIB =
HDF5INCL = -I/home/($tuusuario)/.hdf5/include
HDF5LIB = -L/home/($tuusuario)/.hdf5/lib -L/home/($tuusuario)/.szip/lib -lsz -lhdf5 -lz
endif


Ahora, para correr el ejemplo de la galaxia, necesitamos modificar lo siguiente en el Makefile:

#OPT += -DPERIODIC
OPT += -DUNEQUALSOFTENINGS
#OPT += -DPMGRID=128
OPT += -DHAVE_HDF5
#OPT += -DDOUBLEPRECISION
#OPT += -DDOUBLEPRECISION_FFTW

Si no hacemos estas últimas modificaciones al Makefile, no será posible correr el ejemplo de galaxia. Ahora procedemos a compilar:

usuario@linux ~/Gadget-2.0.7/Gadget2 $ make

El comando anterior no debiera darte ningún error de compilación y resultarte un binario llamado «Gadget2». Ahora, para correr la simulación con el archivo de ejemplo de la galaxia, debemos editar el archivo parameterfiles/galaxy.param y crear una carpeta galaxy en el actual directorio (el mismo del ejecutable de Gadget) para guardar la salida de la simulación.

usuario@linux ~/Gadget-2.0.7/Gadget2 $ mkdir galaxy
usuario@linux ~/Gadget-2.0.7/Gadget2 $ nano parameterfiles/galaxy.param

Editamos la línea que dice
InitCondFile ICs/galaxy_littleendian.dat
Y la dejamos así:
InitCondFile /home/($tuusuario)/Gadget-2.0.7/ICs/galaxy_littleendian.dat

Guardamos con Ctrl-O, y luego Enter, y salimos con Ctrl-X.

Finalmente corremos la simulación con el siguiente comando:
usuario@linux ~/Gadget-2.0.7/Gadget2 $ mpirun -np 2 ./Gadget2 parameterfiles/galaxy.param

Los archivos de salida son snapshots que tienen información de cada una de las partículas que se están simulando. Luego de unas horas debiera finalizar la simulación y seremos capaces de visualizar lo «ocurrido» con algunas herramientas, tales como SPLASH, entre otras. Eso queda para otro post.

Happy Science!

...

Un error extraño. Revisé que las librerías estuvieran en algún archivo de /etc/ld.so.conf.d, agregué el directorio manualmente a la variable de entorno LD_LIBRARY_PATH, pero nada. El error seguía apareciendo.

La solución es muy simple. Debes abrir el Makefile que está en /directorio/de/splash/build (no el que está en el directorio raíz de SPLASH), agregar la línea en negrita, y comentar (agregar un símbolo #) las otras que digan X11LIBS.

#

Después, hacer un make clean y recompilar:

usuario@linux ~/splash $ make clean

usuario@linux ~/splash $ make SYSTEM=gfortran

Fuente | Pregunta en GoogleGroups

Miniguía Instalación SPLASH | Deltalinuxer

En primer lugar, si estamos utilizando Ubuntu/Linux Mint/similar, debemos instalar los paquetes libcairo2-dev y gfortran, que son necesarios para compilar sin problemas. Gfortran es un compilador de fortran. Si quieres utilizar otro, échale una mirada al README que viene en el archivo que vamos a descargar en un momento.

usuario@linux ~ $ sudo apt-get install libcairo2-dev

Para instalar esta utilidad, primero descargamos el código fuente desde la página oficial SPLASH. Luego, vamos al lugar donde descargamos el archivo y descomprimimos:

usuario@linux ~ $ cd ~/Descargas
usuario@linux ~/Descargas $ tar xvzf splash-2.2.0.tar.gz
usuario@linux ~/Descargas $ cd splash
usuario@linux ~/Descargas/splash $ make SYSTEM=gfortran
usuario@linux ~/Descargas/splash $ sudo make install

Luego de esto, debieras ser capaz de utilizar los comandos asociados al programa. En el caso de GADGET, se usa el comando gplash, seguido del nombre del snapshot generado por la simulación.

Espero les haya sido de utilidad.

Página oficial de SPLASH | SPLASH
Página oficial de Gadget2 | GADGET

En esencia, un puntero en C es un tipo de dato (una variable) que apunta a una dirección en memoria (RAM). Se declara de la siguiente forma:

tipo *nombre_puntero;

Esa dirección de memoria a la que apunta puede ser la dirección de otra variable, una estructura, o incluso una función! Sin embargo, el puntero sólo puede apuntar a variables de su propio tipo, es decir, si tengo un puntero de tipo char solo puedo hacer que apunte a variables char.

Hay que tener claro que las variables son datos que se guardan en memoria para ser utilizados en el programa que estamos creando. Cuando declaramos una, estamos reservando un espacio en la memoria. Este espacio tiene un nombre definido (se expresa en hexadecimal, algo asi como 0x23b231 por ejemplo). Este «nombre» es lo que guardamos en un puntero. Ahora, cuando damos un valor a una variable, estamos escribiendo sobre la memoria dicho valor, al que accedemos cuando llamamos la variable.

En ese punto se hace necesario definir dos operadores que son muy útiles en C para trabajar con punteros. El primero es el operador de dereferenciación (o deSreferenciación, da igual je) que se obtiene anteponiendo asterisco al nombre de la variable. Su función es retornar el valor de la variable a la que apunta el puntero. Suena feo ¿no? Primero definamos el otro operador. Éste es el operador & que hace específicamente lo contrario: devuelve la dirección de memoria de la variable. Ahora sí el ejemplo para clarificar las cosas :


int *pointer; /* Definimos el puntero que apuntará a un INT */
int numero = 20; /* definimos una variable arbitraria, solo para ejemplificar */
pointer = № /* El operador & devuelve la dirección en memoria de la variable numero, y 'pointer' toma ese valor. Dicho de otra forma, ahora 'pointer' apunta a 'numero' */


De esta forma, el puntero ‘pointer’ guarda en su interior la dirección de memoria de la variable ‘numero’, por lo en palabras de programador, ‘pointer’ apunta a ‘numero’. Ahora, lo conveniente de los punteros, es que si lo llamamos anteponiéndole un asterisco (dereferenciación) podremos acceder al valor de la variable que guarda, o sea:


printf("%d", *pointer);


Tal código imprime ’20’ en pantalla. No es tan difícil como parece. ¿Qué pasaría si no pusiéramos el asterisco? Simplemente se imprimiría el valor que guarda el puntero, es decir, la dirección de memoria de ‘numero’, sin embargo, para hacer esto sería más correcto poner dentro del printf un %p que es para imprimr direcciones de memoria.


printf("%p", pointer); /* lo probé en mi PC y me retornó 0x7fff97f9a834 */


Éste último código es equivalente a haber puesto &numero, ya que & retorna la dirección de memoria de la variable. Ahora, ¿qué sucedería si a ‘pointer’ le anteponemos el operador &? Retornaría la dirección de memoria del mismo puntero. Recordemos que un puntero es una variable también, por ende, está alojada en algún lugar de la memoria del PC, y ciertamente este lugar de la memoria tiene una dirección :).

Otro uso interesante del operador * es que puedes modificar el valor de la variable a la que apuntas usando el puntero. Un ejemplo considerando las variables ‘pointer’ y ‘numero’ del código anterior:


numero = 30; /* Modificamos el valor de 'numero' */
printf("%d", numero); /* Claramente esto imprime '30' en pantalla */
*pointer= 200; /* Modificamos el valor de la variable apuntada por pointer a 200 */
printf("%d", numero); /* Esto imprime '200' en pantalla */


O sea, cuando antepones * al llamar a un puntero, es como si estuvieras trabajando directamente con la variable apuntada.

No confundir: Una cosa es anteponer un asterisco al nombre de una variable en su declaración, esto indica que estás declarando un puntero… Y otra cosa muy distinta es anteponer un asterisco al nombre de un puntero cuando lo llamas, esto indica que quieres acceder al valor de la variable a la que apunta. Ojo con eso.

Lo más probable es que te estés preguntando para qué utilizarías punteros en tu programa. Eso queda para un próximo tutorial

Les recomiendo lean El Lenguaje de Programación de Kernighan&Ritchie. Explica todo esto con una profundidad mayor.

Las instrucciones después del salto!

En primera instancia, sería bueno saber más o menos lo que hace esta función. malloc() reserva un espacio en memoria del tamaño que tú prefieras (se le dice en los argumentos), devolviendo un puntero void (mucho cuidado con eso!) que debe ser casteado al tipo de puntero que necesites.

malloc se define de la siguiente manera:

void* malloc(size_t tamanyo_en_bytes)

NOTA: Para realizar este tipo de operaciones es necesario tener como conocimiento previo la intrínseca relación que hay entre arrays y punteros, ya que estos son prácticamente lo mismo, solo que se escriben de distinta forma. Si tienes dudas con respecto a ésto te recomiendo eches una hojeada al famosísimo «El Lenguaje de Programación C» de Kernighan&Ritchie, sino haz algunas búsquedas en la web sobre el tema.

Bueno, al grano. Si queremos crear un nuevo array lo hacemos de la siguiente forma (considerando que necesitamos un array de int. Cabe destacar que crearemos una función que tenga dos argumentos enteros: uno que se llame tamanyo_en_ejeY y otro tamanyo_en_ejeX, y que además retorne un puntero del tipo int**

int** magicoCreadorDeArrays( int tamanyo_en_ejeX, int tamanyo_en_ejeY ){
int mihermosoarray**;
mihermosoarray = (int**) malloc( tamanyo_en_ejeY * sizeof(int*) );
int i;
for(i=0; i< tamanyo_en_ejeY; i++) mihermosoarray[i] = (int*) malloc( tamanyo_en_ejeX * sizeof(int) );
return mihermosoarray;
}


Con esto puedes utilizar la función en cualquier otro lado. En el siguiente ejemplo se considera la creación de un array de 20×30 (filas x columnas):

int **miarray;
int Y = 20;
int X = 30;
miarray = magicoCreadorDeArrays( X, Y );


Por cierto! Como has reservado un bloque de memoria utilizando malloc() no debes olvidar liberar ese bloque cuando dejes de utilizarlo con la siguiente instrucción:

int i;
for(i=0; i< X; i++) free(miarray[i]);
free(miarray);

Fuente:
Please Make a Note | 2D Arrays in C using malloc()

$ acpi -t