#regolari

Un n-gono regolare è un poligono con n lati di uguale lunghezza e con n angoli di uguale misura.

Il triangolo equilatero è un 3-gono regolare. Poiché la somma degli angoli interni di un triangolo è pari a 180°, ciascuno degli angoli di un triangolo equilatero è di 60°.

Il quadrato è un 4-gono regolare. Poiché il quadrato è dissezionabile lungo una delle sua diagonali mediante due triangoli, la somma degli angoli interni è pari a 360°. Ne consegue che ciascuno degli angoli di un quadrato è di 90°.

È possibile generalizzare: un n-gono regolare può essere dissezionato con n-2 triangoli lungo le diagonali che si dipartono dai vertici. Ne consegue che la somma dei suoi n angoli interni è pari a (n-2) x 180° e che la misura di ciascuno di essi è pari a (n-2)/n x 180°. 

La tabella riporta tutti i valori di n per cui l'angolo interno è un valore intero. 

È possibile comporre l’angolo giro combinando tra loro poligoni regolari di ordine diverso? Si, è possibile farlo, in 21 modi diversi!

3 tassellature regolari (su 21)

Solo 3 tra gli angoli della tabella  suddividono l'angolo giro in un numero intero di parti: 60°, 90° e 120°. Ne consegue che solo 3 poligoni regolari (rispettivamente triangolo equilatero, quadrato ed esagono) tassellano il piano monoedricamente, cioè con un unico tipo di tassello, costituito da un poligono regolare, sempre delle stesse dimensioni. Si tratta delle 3 tassellature regolari (o platoniche): la triangolare (3.3.3.3.3.3), la quadrata (4.4.4.4)  e la esagonale (6.6.6).

8 tassellature semi-regolari (su 21)

Sono 8 le tassellature semi-regolari (o archimediche) realizzate con due o più di poligoni regolari, tutti con un vertice in comune. Sono la triesagonale (3.6.3.6), la rombotriesagonale (3.4.6.4), la esagonale troncata (3.12.12), la triangolare allungata (3.3.3.4.4), la quadrata troncata (4.8.8), la quadrata ‘snub’ (3.3.4.3.4), la triesagonale troncata (4.6.12) e la triesagonale ‘snub’ (3.3.3.3.6).

Tutte le tassellature regolari e semi-regolari hanno una tassellatura duale, il cui tassello è un planigono, ovvero un poligono formato unendo i centri della tassellatura di partenza.

È possibile comporre l’angolo giro combinando tra loro poligoni regolari di ordine diverso? Si, è possibile farlo, in 21 modi diversi! Tuttavia solo 11 tra queste combinazioni riescono anche a tassellare il piano.

10 ulteriori tassellature (su 21)

Le rimanenti 10 combinazioni di poligoni regolari tra le 21 in grado di comporre l’angolo giro, sono classificabili in due gruppi:

(3.3.4.12) - (3.3.6.6) - (3.4.3.12) - (3.4.4.6)

(3.7.42) - (3.8.24) - (3.9.18) - (3.10.15) - (4.5.20) - (5.5.10) 

Le combinazioni del primo gruppo tassellano il piano localmente (è infatti possibile circondare il poligono più grande con quelli più piccoli, replicando la medesima sequenza attorno a ciascun vertice), ma non globalmente (la sequenza non è sempre ulteriormente replicabile per i poligoni più piccoli). Queste fanno parte di un gruppo di tassellature demi-regolari (o polimorfi), con la proprietà di essere uniformi di ordine 2. Sono in tutto 20 e sono ottenibili con la mescolanza di tassellature regolari e semi-regolari.

Le combinazioni del secondo gruppo non tassellano il piano, perché non è possibile riprodurre costantemente la medesima sequenza attorno a ciascun vertice.

Tassellatura Triangolare (3.3.3.3.3.3)

La tassellatura triangolare (o deltille o anche kishextille) è una delle 3 tassellature regolari del piano, assieme a quella quadrata e a quella esagonale. La sua duale è la tassellatura esagonale (6.6.6).

New Post has been published on http://delusitraditieincazzati.com/2013/12/05/porcellum-bocciato-m5s-siamo-illegittimi-boldrini-no-siamo-regolari/

Porcellum bocciato: M5S “siamo illegittimi”. Boldrini: “no, siamo regolari”

/********************************************************************************/

/*Usare la system call setitimer per creare un programma che stampi l'ora esatta*/

/*a intervalli regolari.La durata dell'intervallo e' specificata in millisecondi*/

/*come parametro. */

/********************************************************************************/

#include <sys/time.h>

#include <sys/types.h>

#include <unistd.h>

#include <signal.h>

#include <stdlib.h>

sig_t stampaData()

{

execlp("date","date",0);

}

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

int ris;

struct itimerval time;

pid_t cpid;

sig_t hand;

/*imposto il periodo(it_interval)ad argv[1].*/

/*value e' il contatore che decrementa sempre */

/*quando arriva a 0 manda un segnale e lo risetta*/

/*al valore di it_interval*/

time.it_interval.tv_sec=0;

time.it_interval.tv_usec=atoi(argv[1])*1000;

time.it_value.tv_sec=0;

time.it_value.tv_usec=atoi(argv[1])*1000;

/*specifico il gestore che verra' usato dopo il segnale*/

hand = signal(SIGALRM,(sig_t)stampaData);

while(1)

{

cpid=vfork();

if(cpid==0)

{

/*con setitimer apetto un periodo e mando un segnale*/

ris=setitimer(ITIMER_REAL,&time,0);

/*mi addormento fino a quando arriva il segnale*/

pause();

/*gestisco il segnale altrimenti terinerebbe il processo*/

signal(SIGALRM,hand);

}

}