Snippet : apici inversi in Bash

Una cosa che mi scordo regolarmente quando utilizzo bash ovvero come si crea il carattere apice rovescio su tastiere che ne sono sprovviste

La soluzione e' semplice

Alt Gr + apice diritto

Esempio con GUI con Zenity in shell Bash

Mentre stavo giocando con airoscript mi sono accorto di un script bash che mostrava delle simpatiche finestre di interfaccia; curiosando dentro il codice ho visto che il generatore delle finestre era Zenity, un programma studiato appositamente per rendere piu' interattiva la shell

Impiegando questo strumento e' stato possibile simulare un esempio di GUI da Bash
---------------------------------------------------------------
VALUE=`zenity --scale --text="Selezionare il valore" --value=0`

case $? in
    0)
        zenity --info --text="E'stato selezionato il valore $VALUE%"
        zenity --progress --title="Progress Bar" --text="Valore selezionato $VALUE%" --percentage=$VALUE;;
    1)
        zenity --error --text="Nessun valore selezionato";;
    -1)
        zenity --info --text="Errore non atteso";;
esac
---------------------------------------------------------------
Qui il link allo script

Webcam Logitech C310 su Debian Testing

Mi sono comprato la Logitech C310 perche' sembrava essere pienamente compatibile con Raspberry, cosa che in realta' si e' rivelata errata

In compenso la Webcam funziona in modo decisamente buono (se non ottimo) se paragonata alle altre Webcam dal costo di qualche euro inferiore
Le prove sono state effettuate nelle peggiori condizioni per una webcam ovvero in una stanza buia con la sola lampada della scrivania accesa ma la resa e' notevole

Screenshot da VLC

utilizzando FFMpeg invece si puo' usare la stringa (ripresa da qui)

ffmpeg -f alsa -ac 2 -ar 48000 -i hw:0,0 -acodec mp2 -f video4linux2  -r 30 -i /dev/video0 -vcodec mjpeg -sameq ffmpeg.avi

Per quanto riguarda Debian nella versione testing vengono riconosciuti correttamente sia la parte video che la  parte audio (microfono) ma il programma Cheese non riesce a funzionare correttamente (ha un ritardo veramente notevole)

Esempio Mandelbrot con GD/C e palette personalizzata

In questo esempio viene creato l'insieme di Mandelbrot utilizzando la libreria GD che si puo' installare in Debian mediante

apt-get install libgd2-noxpm-dev
(esiste una versione che include anche il formato xpm ma nel caso non interessa)

Vengono inoltre presentati due metodi per creare delle palette per la gestione dei colori (entrambe a 256 colori)

Palette 1

Palette 2

Link al progetto

Da compilare con clang -Wall -O3 mand_gd.c -o mand_gd -lgd
-------------------------------------------------------

#include <gd.h>
#include <stdio.h>
#include <math.h>
#include <error.h>

#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 480
#define RGB2INT(r,g,b)  (b + 256 * g + 256 * 256 * r)

float re_min = -2.0;
float im_min = -1.2;
float re_max = 1.0;
float im_max = 1.2;
int iterazioni = 255;

float a,b;
float x,y,x_new,y_new;
int k,j,i;

FILE *fp = {0};
gdImagePtr img = {0};
char *fname = "./mand_gd.png";
int s, color;
int red, green, blue;
int palette[256] = {0};

int main() {

float re_factor = (re_max-re_min);
float im_factor = (im_max-im_min);

//Inizializza lo schermo
img = gdImageCreateTrueColor(SCREEN_WIDTH, SCREEN_HEIGHT);

// crea la palette
for(s = 0; s < 256; s++) {
red   = (int)(128.0 + 128 * sin(3.1415 * s / 16.0));
green = (int)(128.0 + 128 * sin(3.1415 * s / 32.0));
blue  = (int)(128.0 + 128 * sin(3.1415 * s / 64.0));
palette[s] = RGB2INT(red, green, blue);
}

// crea una seconda palette
s = 0;
for(int ared=0;ared<=255;ared+=51)
{
for(int agreen=0;agreen<=255;agreen+=51)
{
for(int ablue=0;ablue<=255;ablue+=51)
{
palette[s]=RGB2INT(ared,agreen,ablue);
++s;
}
}
}

for (i=0;i<SCREEN_HEIGHT;i++)
{
for (j=0;j<SCREEN_WIDTH;j++)
{
a = re_min+(j*re_factor/SCREEN_WIDTH);
b = im_min+(i*im_factor/SCREEN_HEIGHT);

x = 0;
y = 0;
for (k=0;k<iterazioni;k++)
{
x_new = (x*x)-(y*y)+a;
y_new = (2*x*y)+b;
if (((x_new*x_new)+(y_new*y_new))>4)
{
red   = gdImageRed(img, palette[k]);
green = gdImageGreen(img, palette[k]);
blue  = gdImageBlue(img, palette[k]);
color = gdImageColorAllocate(img, red, green, blue);
gdImageSetPixel(img,j, i, color);
break;
}
x = x_new;
y = y_new;
}
}
}
if((fp = fopen(fname, "w")) == NULL)
  error(1, 0, "Error - fopen(): %s", fname);
 else {
  gdImagePng(img, fp);
  fclose(fp);
 }
gdImageDestroy(img);
return(0);
}

Numeri complessi in C/C++ con GSL e Complex

In questo esempio un paio di metodi in C e C++ per trattare i numeri primi

Fonte : http://www.relisoft.com/science/physics/images/ucircle.gif

Per il caso in C e' stata usata la libreria GNU Scientific Library (GSL) che offre, oltre a decine di altre funzioni, anche gli operatori ed i tipi per i numeri complessi. Per certi versi GSL puo' essere considerata la risposta alle Numerical Recipies in C

In C++ la gestione dei numeri complessi e' gia' inclusa nel linguaggio con un metodo piu' leggibile poiche' utilizza overloading degli operatori (nell'esempio e' stata usato in modo implicito l'overloading dell'operatore + somma)

L'esempio deve essere compilato come

g++ -Wall -O3 complessi.c -o complessi -lgsl 

-----------------------------------------------------------
#include <cstdlib>
#include <iostream>
// GSL
#include <gsl/gsl_complex.h>
#include <gsl/gsl_complex_math.h>
// C++
#include <complex>
using namespace std;

using namespace std;

int main(int argc, char *argv[])
{
    //------------ GSL
    cout << "GSL" << endl;
    gsl_complex z,w,u;
    GSL_SET_COMPLEX(&z,3,4);
    cout << "Z : Reale " << GSL_REAL (z) << ":Immaginario " << GSL_IMAG (z) << endl;
    GSL_SET_COMPLEX(&w,4,5);
    cout << "W : Reale " << GSL_REAL (w) << ":Immaginario " << GSL_IMAG (w) << endl;
    u = gsl_complex_add(z,w);
    cout << "Z+W : Reale " << GSL_REAL (u) << ":Immaginario " << GSL_IMAG (u) << endl;

   
    //------------ C++
    cout << endl << "C++" <<endl;
    complex<double> c1(3.0,4.0);
    complex<double> c2(4.0,5.0);
    complex<double> c3= c1 + c2;
    cout << "Reale : "<<real(c3) << ":Immaginario " << imag(c3) << endl;
   
    system("PAUSE");
    return EXIT_SUCCESS;
}

Pi Greco con OpenMP e GMP

Per testare il calcolo parallelo e l'Hyperthreading avevo la necessita' di un algoritmo parallelizzabile e con una convergenza piuttosto lenta per poter apprezzare le differenze di tempo di calcolo nella versione parallela e non parallela.

Scartato il calcolo di Pi Greco mediante la formula di Gauss (gia' utilizzata in un precedente post) perche' ricorsiva e quindi non parallelizzabile e scartato l'insieme di Mandelbrot perche' comunque un minimo complesso , ho provato a determinare il valore di Pi Greco mediante lo sviluppo in serie di Taylor mediante la formula

La sommatoria converge con estrema lentezza al valore di Pi Greco

Standard (tempo di esecuzione 0.049s)
-----------------------------------------------------

#include <cmath>
#include <iostream>

using namespace std;

int main()
{

float pi_s = 0.0;

for (int n=0; n<100000;++n)
{
pi_s = pi_s + (pow(-1,n)/(2*n+1));
}
cout << "Normale " << pi_s*4 << endl <<endl;

return 0;
}
-----------------------------------------------------


OMP (tempo di esecuzione 0.05s)
-----------------------------------------------------

#include <cmath>
#include <iostream>
#include <omp.h>

using namespace std;

int main()
{

float pi_s = 0.0;
#rpragma omp parallel
{
#pragma omp for reduction(+:pi_s) nowait
for (int n=0; n<100000;++n)
{
pi_s = pi_s + (pow(-1,n)/(2*n+1));
}
}
cout << "Normale " << pi_s*4 << endl <<endl;

return 0;
}

-----------------------------------------------------


GMP (tempo di esecuzione 0.1s)
-----------------------------------------------------

#include <cmath>
#include <iostream>
#include <gmp.h>

using namespace std;

int main()
{
mpf_t pi;
mpf_t transi;
mpf_t print;


int sopra;
int sotto;
//float pi_s = 0.0;

mpf_init_set_ui(pi,0);
mpf_init_set_ui(transi,1);
mpf_init_set_ui(print,0);

for (int n=0; n<100000000;++n)
{
sopra = pow(-1,n);
sotto = (2*n)+1;
mpf_set_si(transi,sopra);
mpf_div_ui(transi,transi,sotto);
mpf_add(pi,pi,transi);
mpf_mul_ui(print,pi,4);

//Calcolo eseguito senza GMP
//pi_s = pi_s + (pow(-1,n)/(2*n+1)); 
//cout << "Normale " << pi_s*4 << endl <<endl;
}
gmp_printf("Pi %.Ff\n",print);

return 0;
}



-----------------------------------------------------

L'integrazione di OMP e GMP non e' banale perche' se si uniscono i due esempi sopra riportati il compilatore riporta che la variabile pi has invalid type for ' reduction'

Creare progetti Swing/Java con Eclipse e NetBeans

Eclipse
La procedura per creare un progetto Swing con Eclipse ripercorre per le prime fasi quelle descritte nel precedente post

Per creare le interfacce Swing in Eclipse e' necessario utilizzare un Plugin (Window Builder) che comunque e' gia' presente sia nella versione Java di Eclipse sia nel pacchetto dei Google Plugins (http://dl.google.com/eclipse/plugin/4.2 per la versione di Eclipse Juno)
Si deve creare un Nuovo Progetto Java Application, dopo si seleziona il progetto nella colonna a sinistra del Package Explorer e si crea un nuovo package. A questo punto si clicca sul package e si seleziona New/Other/Swing Designer/Jframe

Al di sotto della finestra di Editor del codice ci sono due tab; tramite questi si puo' accedere all'editor visuale di Swing

NetBeans
Si deve creare un Nuovo Progetto/Java Application. Successivamente si sceglie il nome del progetto e si lascia il flag su Create Main Class ma si cancella il nome della class

A questo punto in Source Packages si legge <default package>. Si clicca destro e si seleziona nuovo JFrame e compare l'editor visuale