Meox Blog – a programming language resource

In questi giorni, avendo qualche ora in più a disposizione vorrei proporvi due letture estive. Ovvero meravigliosi libri che dovrebbero essere il punto di partenza per chiunque volesse capirci qualcosa in più sulla programmazione e su quello che realmente essa sia: un arte. Il primo libro è: Structure and Interpretation of Computer Programs di Harold Abelson e Gerald Jay Sussman. Testo utilizzato al MIT per insegnare agli studenti a programmare usando la testa e lo Scheme. Il libro lo potete tranuillamente scaricare dal sito degli autori o qui in formato PDF. Io ho iniziato a leggerlo appena in questi giorni nonostante abbia terminato la laurea nel dicembre 2007. Mi sembra assurdo che in tutti i miei anni di studi alla facoltà di ingegneria nessun professore o un assistente che sia abbiano mai fatto mensione ad un libro utilizzato in quasi tutte le università americane, oltre che al MIT, per oltre venti anni. E mi pare ancora più assurdo che nessuno abbia mai tenuto un corso sul Lisp, o i sui dialetti, e che nessuno ci abbia mai parlato del lambda calcolo. Ma va be siamo in Italia … forse invecchiando sono diventato troppo esigente. L’altro libro di cui volevo parlarvi è Higher Order Perl scritto da Mark Jason Dominus. Il libro spiega come usare il Perl come linguaggio funzionale piuttosto che come sustituto del C. Anche in questo caso si tratta di un libro incredibilmente affascinante e come ogni cosa bella rilasciato gratuitamente (lo trovate qui in formato PDF).

Vi auguro un buona lettura.

Se andate su Wikipedia al seguente link link troverete una chiara spiegazione sulla congettura di Collatz. Se prendiamo un qualsiasi numero e iteriamo la seguente procedura:

la congettura afferma che prima o poi arriveremo sempre ad 1. Questo è quantomeno affascinante, il sapere cioè che ogni numero sottoposto a questa legge converga inesorabilmente ad 1 un numero finito di passi. Allora mi è venuto in mente di studiare come si comportano i numeri primi, e ho così scritto un semplice programma in c++ usando le gmplib per capire l’andamento delle orbite dei primi, ovvero del numero di iterazioni necessarie a raggiungere uno. I risultati non mostrano per adesso alcun comportamento particolare ma ancora mi riservo qualche ulteriore analisi.

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

int main(int argc, char *argv[])
{
  int i = 0, k = 0, c = 10;
  mpz_t s, n, one;

  if(argc > 1)
    c = strtol (argv[1], 0, 10);

  mpz_init (s);
  mpz_init (n);
  mpz_init (one);

  mpz_set_ui (s, 3);
  mpz_set_ui (one, 1);

  FILE *fd = fopen ("orbita.txt", "w");

  while( i < c )
  {
    if (mpz_probab_prime_p (s, 15) == 2) // if s is definitely prime
    {
      mpz_set (n, s);
      char *stxt = mpz_get_str(0, 10, s);
      printf ("Trovato primo: %s, con orbita = ", stxt);
      while ( mpz_cmp_ui (n, 1) != 0 )
      {
	if( mpz_tstbit(n, 0) == 0 ) // pari
	{
	  mpz_divexact_ui (n, n, 2);
	}
	else
	{
	  // n = 3*n + 1
	  mpz_mul_ui (n, n, 3);
	  mpz_add_ui (n, n, 1);
	}
	k++;
      }
      printf ("%d\n", k);
      fprintf(fd, "%s %d\n", stxt, k);
      free(stxt);
      k = 0;
      i++;
    }
    mpz_add_ui (s, s, 2);
  }

  mpz_clear (s);
  mpz_clear (n);
  mpz_clear (one);

  fclose (fd);

  return 0;
}