Tag Archives: giuseppe ciaburro

Come salvare un file in Matlab

MATLAB

In questa lezione impareremo come salvare un file in Matlab. Vediamo allora come salvare dei dati in un filedi testo. Si voglia, ad esempio,  salvare i risultati della funzione exp(x) entro l’intervallo (1; 2) con passo 0.1. Si costruisca dapprima il vettore seguente:

x = 1 : 0.1 : 2 ;

e quindi si valuta una matrice A nel modo seguente:

A = [ x ;exp(x) ];

Decidiamo che il nome esterno del file su cui si vuole salvare la matrice A sia file.txt ; esso dovrà essere posto all’interno di apici perchè si tratta di una stringa. Apriamo il file in scrittura con il parametro ’wt’ assegnandogli il nome interno nomefile. L’istruzione è la seguente:

nomefile = fopen ( ’file.txt’ , ’wt’);

In questo modo si deposita nel file nomefile la matrice A, scrivendo le due colonne di numeri decimali:

  1. la prima colonna con 6 cifre di cui 2 decimali
  2. la seconda colonna 8 cifre di cui 4 decimali.

matlab

Attraverso il comando  fprintf, che rappresenta un acronimo di file print formatted, saremo in grado di stampare a video quanto contenuto nel file appena creato.

fprintf ( nomefile , ’%6.2g %8.4g\n’ , A);

Si noti che per primo si mette il nome interno nomefile, per secondo si mette il formato per terzo si mette la matrice A.

Quindi si chiude il file con il comando:

fclose (nomefile);

Se si vuole analizzare il file così creato lo si può fare con un editor di testo qualsiasi, in questo modo potremo verificare che l’operazioen attraverso la quale abbiamo salvato un file in Matlab è riuscita correttamente.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Come installare ActivePython

python

Vediamo allora come installare ActivePython che ci occorre per procedere con la programmazione in ambiente Python; per scaricare il pacchetto basterà collegarsi al sito della ActiveState disponibile al seguente url:

 http://www.activestate.com/activepython/

Dopo una schermata introduttiva nella quale vengono presentate le caratteristiche del pacchetto e dove reperire idonea documentazione, nella parte bassa della finestra sarà possibile scegliere la distribuzione compatibile con la nostra macchina, selezionandola in una lista davvero ricca che annovera le seguenti distribuzioni:

  • •           Windows x86
  • •           Linux x86
  • •           Linux x86_64
  • •           Mac OS X (Universal)
  • •           Solaris 8 SPARC
  • •           Solaris 8 SPARC (64-bit)
  • •           Solaris 10 x86
  • •           AIX PowerPC
  • •           HP-UX PA-RISC

python

Una volta scelta la piattaforma relativa alla nostra macchina cliccando sul relativo link partirà il download, alla fine del quale potremo trovare il file ActivePython-3.1.2.3-win32-x86.msi sul nostro hard disk. A questo punto basterà cliccare due volte sul file, per attivare la procedura di installazione che risulterà totalmente automatizzata, ci dovremo semplicemente limitare ad assistere da spettatori se non seguire le istruzioni dell’installer.

Se disponiamo di poco spazio sull’hard disk, potremo effettuare un’installazione personalizzata ed escludere la documentazione, ma non risulta particolarmente  raccomandabile a meno che non siate già dei guru del linguaggio e quindi non abbiate bisogno di un aiuto. Una volta completata l’installazione, chiuderemo l’installer ed apriremo l’interfaccia dell’interprete Python attraverso il seguente percorso:

 Start->Programs->ActiveState ActivePython 3.01.->PythonWin IDE

Da questo momento potremo iniziare ad interagire con l’ambiente integrato appena installato avendo potuto verificare come installare ActivePython.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Link a risorse consigliate:

Installazione di Python su Windows

python

Il linguaggio Python supporta il sistema operativo Windows, anzi le performance che manifesta sono a dir poco eccellenti, anche se il sistema nativo del Python è come sappiamo Linux.

Di seguito analizzeremo le procedure di installazione di Python su Windows, analizzando in particolare la procedura dettagliata relativa ad una macchina amd con sistema operativo Windows. Si è deciso di procedere con questa simulazione in quanto su macchine Linux il pacchetto Python è di solito già presente; semmai sarà necessario solo procedere ad un aggiornamento alla versione più recente.

Ci sono essenzialmente due modi per installare Python, entrambi risultano piuttosto veloci e sfruttano la possibilità che offrono tutti gli applicativi Windows di utilizzare delle procedure di installazione automatizzate, i cosiddetti installer, attraverso i quali la fase di installazione del software si riduce da parte dell’utente alla necessità di dover cliccare, una serie di volte su dei bottoni con la scritta avanti.

python

In questo caso la cosa risulta particolarmente vantaggiosa in quanto con un solo file si riesce ad installare tutto il software necessario per poter essere immediatamente operativi.

Nel primo metodo utilizzeremo il pacchetto distribuito dalla ActiveState denominato ActivePython che produce un’installazione Windows per Python che comprende una versione completa di Python, un IDE (integrated development environment, in italiano ambiente integrato di sviluppo che aiuta i programmatori nello sviluppo del software), con un editor capace di riconoscere codice Python e quindi di evidenziare i token, più alcune estensioni di Windows per Python che consentono un accesso completo ai servizi specifici di Windows, alle sue API ed al suo registro.

ActivePython è liberamente scaricabile, tuttavia non è open source. Rappresenta un ottimo pacchetto completo che ci permette di accedere all’interprete in modo agevole e senza difficoltà; l’unica nota di demerito può essere rappresentata dal fatto che l’installer di ActivePython di solito risulta essere indietro di alcuni mesi nell’aggiornamento rispetto ai rilasci delle nuove versioni di Python.

Per il secondo metodo invece utilizzeremo il pacchetto disponibile sul sito ufficiale del linguaggio già segnalato in precedenza; anche in questo caso utilizzeremo un installer che sarà in grado di installare sulla nostra macchina sia l’interprete che la Python Gui.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Link a risorse consigliate:

Il software Python

python

Vediamo innanzitutto dove reperire il software Python da installare sulla nostra macchina per poter iniziare a programmare con Python. I pacchetti che dovremo installare sono disponibili sul sito ufficiale del linguaggio al seguente url:

http://www.python.org/

Naturalmente prima di scaricare le versioni del software dovremo informarci sul tipo di macchina a nostra disposizione e sul sistema operativo su di essa installato. Ricordiamo però che Python è disponibile praticamente per tutti i sistemi operativi in circolazione.

L’interprete Python consentirà la traduzione del nostro codice Python in un linguaggio comprensibile al nostro computer e che gli permetterà di eseguire le istruzioni in esso contenute. Nel periodo di stesura di questo libro, la versione corrente dell’inteprete Python è la 3.1.2 che rappresenta quella stabile ed è per questo che negli esempi  che ci accompagneranno nei capitoli successivi ci riferiremo a tale versione.

python

Possiamo tranquillamente scaricare il software Python dalla rete, in quanto la programmazione con Python è tutta open source e quindi liberamente scaricabile da internet dove possiamo trovare dei siti che oltre a fornire procedure dettagliate per il download della versione corrente del software forniscono anche una soddisfacente documentazione.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Link a risorse consigliate:

La portabilità di Python

python

Una caratteristica che ha determinato il successo di Python nel panorama mondiale della programmazione è stata la sua estrema portabilità; esistono versioni di Python per piattaforma Linux (suo ambiente naturale visto che qui è stato sviluppato), per sistemi operativi Unix-like, Mac OS, e Windows in tutte le sue versioni.

La versatilità di Python si manifesta nella sua interezza nel momento che esiste una versione di Python anche per l’obsoleto sistema operativo con interfaccia orientata ai caratteri MS-DOS.

python

Ma lo sviluppo di Python non si ferma alle piattaforme appena viste ma si estende a quelle che oggi vengono diffusamente utilizzate per la programmazione dei cellulari, di navigatori satellitari e quant’altro. Infine, ma non per ultimo, Python può essere utilizzato su Java e nella .NET virtual machines.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Link a risorse consigliate:

La sintassi di Python

python

La sintassi di Python lo rende perfetto per la costruzione di semplici DSL da utilizzare all’interno della propria applicazione, grazie alla sua sintassi ed alle sue funzionalità di metaprogrammazione.

Abbiamo già specificato che Python è totalmente Object Oriented, questo si traduce nel fatto che in Python tutto è un oggetto. In tale aspetto riesce a surclassare il linguaggio ad oggetti per eccellenza e cioè Java in quanto in Python non esiste nessuna distinzione tra tipi base e oggetti, allo stesso tempo la programmazione orientata agli oggetti in Python non risulta ne invasiva ne fastidiosa, e ciò è dovuto alla sua maggior purezza.

Una caratteristica particolarmente gradita dai programmatori Python è stata la possibilità di utilizzare i cosiddetti blocchi che rappresentano una feature non comune nei linguaggi più diffusi e che permettono di rappresentare diversi problemi, anche molto diversi tra loro, con modalità chiare e significative.

python

Il Python risulta amato, allo stesso modo, dai programmatori professionisti che ne apprezzano le caratteristiche più avanzate, e dai principianti in quanto si presenta particolarmente adatto ad essere imparato come primo linguaggio.

Infatti grazie alla sua semplicità, è possibile apprendere le nozioni di base della programmazione, senza doversi preoccupare di innumerevoli convenzioni e aspetti non strettamente legati alla realizzazione degli algoritmi numerici.

Inoltre Python si presenta efficacemente espressivo in quanto fornisce molte strutture dati e tipi built-in ( i tipi built-in rappresentano dei tipi già definiti all’interno del linguaggio); esempi sono:

  • dict,
  • liste,
  • regexp,
  • numeri interi di dimensione arbitraria.

La sintassi di Python fa si che le classi presentino un’interfaccia molto dettagliata, che determina una semplicità nell’utilizzo nelle operazioni comuni.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Link a risorse consigliate:

Le caratteristiche peculiari di Python

python

Le caratteristiche peculiari di Python lo rendono un linguaggio di programmazione soprattutto semplice, il suo utilizzo si apprende in pochi giorni, senza presentare grosse difficoltà grazie ad una sintassi snella e davvero pratica; in aggiunta presentando a corredo un numero davvero corposo di librerie incluse nella distribuzione ed integrabili con quelle installabili, si rende possibile, come già anticipato  realizzare i nostri programmi in brevissimo tempo.

Python si presenta particolarmente dinamico, un esempio è fornito dal fatto che le variabili possono essere tranquillamente utilizzate senza la necessità di dichiararne il tipo, sarà allora l’interprete in grado di identificarle; tutto questo però senza perdere in precisione in quanto le operazioni non consentite tra tipi diversi provocheranno un errore, cioè non potrà mai accadere, in modo più o meno nascosto, che un valore di un certo tipo venga utilizzato come se fosse di tipo diverso (strong typing).

Grazie a questo un operazione del tipo 1+”2″ (somma di un numero e di una stringa) determinerà un errore di runtime, diversamente da linguaggi come php o perl che invece non permettono un controllo analogo.

python

In Python è possibile manipolare le classi ed i metodi a runtime, cioè possono essere aggiunti, cancellati o modificati. In questo modo molte delle cose che negli altri linguaggi rappresentano delle strutture complesse possono in Python costituire dei semplici metodi; è altresì possibile aggiungere classi e metodi personalizzati, creando dei Domain Specific Language (DSL). Un Domain Specific Language è un minilinguaggio adatto ad uno specifico problema, l’ideale sarebbe avere un linguaggio per ogni scopo, ma senza il problema di doverlo ogni volta imparare da zero.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Link a risorse consigliate:

Le origini del linguaggio Python

python

Lo sviluppo di Python inizia nel 1989 al National Research Institute for Mathematics and Computer Science (CWI) di Amsterdam ad opera di Guido Van Rossum, che vi lavora come ricercatore. L’idea è quella di implementare in maniera più efficiente i concetti alla base di ABC (All Basic Code), un linguaggio di programmazione pensato per essere facilmente appreso e utilizzato da persone che non avessero alcuna esperienza o conoscenza di progettazione e sviluppo software. Le origini del linguaggio Python nascono dall’esigenza del gruppo di lavoro cui Van Rossum partecipava, di avere a disposizione un linguaggio di scripting per Amoeba, un prototipo di sistema operativo distribuito al quale stavano lavorando.

C’è da precisare che il nome che Van Rossum attribuì al linguaggio non ha niente a che vedere con il rettile che tanto terrore ha disseminato sulla terra. Il nome fu il frutto di un’intera nottata a pensare ad un nome che fosse corto, unico e originale; alla fine fu evidentemente ispirato da una serie televisiva che la BBC trasmetteva agli inizi degli anni 70 “ The Monty Python’s Flying Circus ”.

Sulla nascita del linguaggio l’autore tiene a precisare: “ nel dicembre del 1989, ero alla ricerca di un progetto di programmazione per tenermi occupato durante le vacanze natalizie. Il mio ufficio… sarebbe stato chiuso, e non avrei avuto altro tra le mani che il mio computer di casa. Allora decisi di scrivere un interprete per il nuovo linguaggio di scripting che avevo in mente di recente un discendente del linguaggio ABC ”.

python

Van Rossum cominciò realizzando un semplice parser e una semplice macchina virtuale, riciclando le parti migliori di ABC. La prima release del linguaggio fu resa pubblica nel Febbraio del 1991 e, per un lungo periodo, lo sviluppo di Python è stato eseguito nei laboratori del CNRI a Reston negli Stati Uniti.

Nel giugno del 2000, il team di sviluppo di Python si trasferisce a PythonLabs, una organizzazione facente parte del network BeOpen, con il compito di sviluppare il linguaggio Python. Tale team annoverava tra gli sviluppatori anche il suo ideatore Guido Van Rossum. Il 27 ottobre 2000 l’intero PythonLabs Team ha lasciato BeOpen.com a causa di alcuni disaccordi reciproci in merito al futuro di Python.

Il team ha lavorato per Digital Creations creando il framework Zope e Guido Van Rossum ha creato una organizzazione non-profit chiamata Python Software Foundation (PSF), al fine di curare gli sviluppi futuri di Python. In questa lezione abbiamo approfondito le origini del linguaggio Python.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Link a risorse consigliate:

Le procedure ricorsive nel Fortran


FORTRANUna procedura ricorsiva, nel Fortran, rappresenta una costruzione artificiosa che ci consente di utilizzare una funzione in se stessa. Analizziamo come nel liguaggio di programmazione Fortran possa essere gestita una procedura di talke tipo; vediamo allora un semplice esempio di funzione ricorsiva alfine di mettere in evidenza appunto il fatto che la funzione richiama se stessa:

RECURSIVE FUNCTION factorial(n) RESULT(res)
INTEGER res, n
IF(n.EQ.1) THEN
   res = 1
ELSE
   res = n*factorial(n-1)
END IF
END

Analizziamo allora nel dettaglio la funzione che presenta una struttura ramificata. La condizione n == 1 è la base della ricorsione. Questo è l’unico modo che si ha per ottenere che il programma smetta di chiamare se stesso.

La parte contenuta nel costrutto else rappresenta la ricorsione. C’è da notare che la chiamata factorial(n-1) avviene all’interno della funzione che sta definendo factorial(n). La parte essenziale di tutto il procedimento di ricorsione è appunto la chiamata a un valore inferiore, n-1, e tale chiamata continuerà fino a quando non si verificherà un valore di n pari a 0.

Possiamo quindi affermare che una procedura di ricorsione che abbia successo chiamerà sempre un valore inferiore.Ci sono molti pericoli connessi all’utilizzo di un algoritmo di ricorsione. Ad esempio così come accade con i cicli while, è possibile per la funzione di chiamare se stessa all’infinito in modo da non fornire mai una risposta.

Un’altro problema che può nascere dal suo utilizzo è legato al fatto che la ricorsione può causare calcoli ridondanti che, anche se possono essere conclusi, possono richiedere molto tempo. Infine  mentre un programma ricorsivo è in esecuzione ha bisogno di spazio in più per accogliere l’overhead della ricorsione.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Le subroutine nel Fortran


FORTRANUna subroutine nel Fortran rappresenta un tipo di procedura, essa viene richiamata specificandone il nome attraverso l’istruzione CALL che riceve i valori di input e restituisce quelli di output attraverso una lista di argomenti.

Il costrutto nella sua forma generale per definire una subroutine è il seguente:

SUBROUTINE nome_subroutine [(lista_di_argomenti)]
 
    [definizione e dichiarazione delle variabili]
    [corpo della procedura]
[CONTAINS
    procedure interne]
[RETURN]
END [SUBROUTINE [nome_subroutine]]

 

Nella definizione della struttura è possibile identificare il nome della subroutine, che dovrà rispettare le regole per la scelta dei nomi nel Fortran, seguito dall’elenco delle varibili di scambio tra la procedura ed il programma chiamante.

Segue la definizione e la dichiarazione delle variabile che sono utilizzate all’interno della procedura, quindi segue il corpo della procedura cioè le istruzioni che dovrà eseguire nel momento in cui verrà chiamata dal programma principale.

Quando un programma chiama una subroutine, l’esecuzione del programma viene temporaneamente sospesa per consentire l’esecuzione della subroutine. Quando viene raggiunta l’istruzione RETURN o l’istruzione END SUBROUTINE l’esecuzione dell’unità chiamante riprende dalla riga successiva a quel la che ha effettuato la chiamata.

La chiamata avviene attraverso l’istruzione CALL, la cui sintassi è:

CALL nome_subroutine ([lista_di_argomenti])

 

Un esempio di soubroutine di fortran 90 è fornito di seguito:

!TRASFORMATA DI FOURIER DISCRETA
!________________________________
subroutine dft (A,N,E)
implicit none
17
integer :: N !numero di campioni
integer :: E !numero di campinature effettuate
integer :: i,j !indice di riga e di colonna della matrice
complex :: uim !unita' immaginaria
complex,dimension(0:1000,0:1000) :: A !matrice complessa

uim=(0,1)
do i=0, n-1
   do j=0, n-1
     A(i,j)=exp(-(2*3.14*uim*i*j)/n)
   end do
end do
E=N
end

Questa subroutine calcola le trasformate discrete di fourier dato un certo campione.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

Le funzioni nel Fortran


FORTRANLe funzioni, nel Fortran, rappresentano un tipo di sottoprogrammi che, se necessario, possono essere richiamati più volte all’interno del programma principale per soddisfare una particolare esigenza ed effettuare degli opportuni calcoli.

Le funzioni definite dall’utente, a differenza delle funzioni standard già ingoblate nell’ambiente di programmazione, vengono scritte al fine di soddisfare uno specifico scopo che nessun altro strumento a disposizione del programmatore è in grado di soddisfare.

Le funzioni sono definite attraverso un costrutto del tipo:

FUNCTION Area_Circle(r) USE Circle, ONLY : Pi
IMPLICIT NONE
REAL :: Area_Circle
REAL, INTENT(IN) :: r
Area_Circle = Pi * r * r
END FUNCTION Area_Circle

È tramite il nome della funzione che si richiama la funzione all’interno del programma principale. Gli argomenti contenuti nelle parentesi tonde sono gli identificatori su cui la funzione opera.

Le funzioni lavorano sui valori memorizzati negli argomenti e restituiscono un risultato del tipo specificato. L’elenco degli identificatori costituisce un insieme di oggetti fittizi, ai quali, quando il sottoprogramma viene richiamato, vengono rimpiazzati i valori degli argomenti dell’istruzione chiamante.

Dopo la definizione della una funzione, csegue il blocco di istruzioni che costituiscono il sottoprogramma. Tra queste vi deve essere almeno un’istruzione di assegnazione con il nome della funzione a sinistra del segno di uguale, che assegna un valore a questa variabile e che viene quindi restituito al programma chiamante al termine della funzione, che come tutti i programmi deve terminare con END.

Vediamo come esempio un programma che richiama al suo interno una funzione:

MODULE Circle
!---------------------------------------------------------------------
! ! Modulo che contiene la definizione delle variabili necessarie
! per la computazione dell'area del cerchio di raggio r !
!---------------------------------------------------------------------
REAL, PARAMETER :: Pi = 3.1415927
REAL :: radius
END MODULE Circle
PROGRAM Area
!---------------------------------------------------------------------
! ! Questo programma computa l'area del cerchio dato il raggio !
! Uses: MODULE Circle ! FUNCTION Area_Circle (r) !
!---------------------------------------------------------------------
16
USE Circle, ONLY : radius IMPLICIT NONE
INTERFACE
FUNCTION Area_Circle (r)
REAL, INTENT(IN) :: r
END FUNCTION Area_Circle
END INTERFACE
! Prompt user per il raggio del cerchio write(*, '(A)', ADVANCE =
"NO") "Digita il raggio del cerchio: " read(*,*) radius
! Write out area of circle using function call write(*,100) "Area
del cerchio con raggio", radius, " is", &
Area_Circle(radius)
100 format (A, 2x, F6.2, A, 2x, F11.2)
END PROGRAM Area
!-----Area_Circle----------------------------------------------------
! ! Funzione che calcola l'area del cerchio di raggio r !
!---------------------------------------------------------------------
FUNCTION Area_Circle(r) USE Circle, ONLY : Pi
IMPLICIT NONE REAL :: Area_Circle REAL, INTENT(IN) :: r
Area_Circle = Pi * r * r
END FUNCTION Area_Circle

Questo programma usa la funzione Area_Circle per computare l’area d’un cerchio di raggio r. La funzione compare dopo l’istruzione di fine programma della zona principale di programma, in modo da essere classificata come subprogram esterno. Poichè è una procedura esterna, il programma principale usa un INTERFACE BLOCK per definire tutti i parametri richiesti dalla funzione Area_Circle.

La versione in fortran 90 del subprogram funzione si comporta allo stesso modo del subprogram funzione presente nel fortran 77. Si noti che l’ unica differenza sostanziale qui è la capacità di dichiarare esplicitamente gli argomenti della funzione in se.Prendere la nota speciale del descrittore INTENT(IN) del tipo.

Questo attributo della variabile r nel subprogram di funzione identifica rigorosamente la variabile r come variabile di input. Tali variabili non possono essere modificati dal subprogram in modo involontario.

LINK DI APPROFONDIMENTO PER L’ARGOMENTO: