Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Uso di
Versione 14/06/2013
Sommario
Introduzione .....................................................................................................................................................................4
Istallazione ........................................................................................................................................................................5
Comandi di base ..............................................................................................................................................................7
Creazione e assegnazione di variabili ...............................................................................................................9
Operazioni sulle variabili .................................................................................................................................... 10
Istruzioni di controllo ........................................................................................................................................... 12
Grafica .......................................................................................................................................................................... 13
Gestione input/output .......................................................................................................................................... 15
Script ............................................................................................................................................................................ 16
Funzioni e librerie .................................................................................................................................................. 17
Altre .............................................................................................................................................................................. 18
Operazioni con Excel (o fogli elettronici). ............................................................................................... 18
File di startup....................................................................................................................................................... 19
Applicazioni per il Laboratorio di Meccanica .................................................................................................. 20
Simulazione di dati ................................................................................................................................................. 20
Lancio di dadi (o monete) .............................................................................................................................. 20
Estrazione di un campione da una distribuzione................................................................................. 21
Simulazione di misure con errori ............................................................................................................... 22
Montecarlo per la valutazione dellincertezza in modo semplificato .......................................... 24
Lettura di dati da file ............................................................................................................................................. 27
Fit ................................................................................................................................................................................... 31
Derivata col fit .......................................................................................................................................................... 37
Elaborazione di dati: lo smoothing ................................................................................................................. 39
Analisi statistica dei dati ...................................................................................................................................... 40
Istogramma .......................................................................................................................................................... 40
Percentili................................................................................................................................................................ 42
Coefficiente di correlazione e scatter-plot .............................................................................................. 43
Test del chi quadro ............................................................................................................................................ 45
Valutazione dellincertezza col metodo di Montecarlo .......................................................................... 46
Function di servizio ............................................................................................................................................... 51
Esperienze.................................................................................................................................................................. 52
Molla ........................................................................................................................................................................ 52
2
Fluidi ........................................................................................................................................................................ 54
Pendolo fisico....................................................................................................................................................... 55
Volano ..................................................................................................................................................................... 55
Uso avanzato .................................................................................................................................................................. 56
Alcuni comandi ........................................................................................................................................................ 56
Ancora sulle funzioni............................................................................................................................................. 57
Funzioni con argomenti variabili ................................................................................................................ 57
Funzioni definite dinamicamente ............................................................................................................... 58
Efficienza ............................................................................................................................................................... 58
GUI ................................................................................................................................................................................. 60
Strutture, list, mlist, cell array, etc................................................................................................................... 62
Appendici ........................................................................................................................................................................ 64
Consigli pratici ......................................................................................................................................................... 64
Differenze con Matlab ........................................................................................................................................... 65
Esercizi ........................................................................................................................................................................ 66
Altri utili documenti .............................................................................................................................................. 67
Introduzione
Scilab un pacchetto di programmi gratuiti per il calcolo numerico sviluppati dallo INRIA e
dallo ENPC in Francia, e poi da Scilab Consortium in seno alla Fondazione Digiteo. Oggi Scilab
sviluppato da Scilab Enterprises.
Scilab stato ampiamente impiegato in alcuni progetti industriali e di ricerca, e molti
contributi sono stati fatti dagli utenti. Il linguaggio di programmazione, di alto livello (a
differenza del C), interpretato. La sintassi simile a quella di MATLAB ma i due programmi, i
loro applicativi ed i plug-in non sono completamente compatibili, anche se esiste un
convertitore nel pacchetto di Scilab, che opera, con qualche problema, le conversioni Matlab
Scilab.
Scilab include anche un pacchetto chiamato Xcos, per la simulazione e la costruzione di
modelli di sistemi dinamici, includendo sia sotto-sistemi continui che discreti.
Altri pacchetti applicativi esterni, gli ATOMS, possono essere installati.
Scilab disponibile gratuitamente per vari sistemi operativi, tra cui Windows, Mac OS X e
Linux e pu scaricarsi gratuitamente dal sito http://www.scilab.org/ .
MATLAB, a cui si ispira Scilab, un ambiente per il calcolo numerico e l'analisi statistica che
comprende anche l'omonimo linguaggio di programmazione creato dalla MathWorks.
MATLAB consente di manipolare matrici, visualizzare funzioni e dati, implementare algoritmi,
creare interfacce utente, e interfacciarsi con altri programmi. Nonostante sia specializzato nel
calcolo numerico, un toolbox opzionale interfaccia MATLAB con il motore di calcolo simbolico
di Maple. MATLAB usato da milioni di persone nell'industria e nelle universit per via dei
suoi numerosi tool a supporto dei pi disparati campi di studio applicati e funziona su diversi
sistemi operativi, tra cui Windows, Mac OS, GNU/Linux e Unix. Vedi
http://www.mathworks.it/ .
In questa guida si suppone che lo studente abbia una conoscenza elementare della
programmazione (come acquisita, per esempio, nel corso di Laboratorio di calcolo).
Queste brevi note hanno lunico scopo di fornire rapidamente le nozioni di Scilab necessarie
per il corso di Laboratorio di Meccanica. Se, come auspicabile, si volesse andare oltre nella
conoscenza di questo strumento di programmazione, si pu trovare in rete molta
documentazione di guida e tutorial, come indicato nellultimo capitolo. In particolare per
qualsiasi uso evoluto di Scilab fondamentale un testo come introscilab.pdf (lo si trova con
Google o nel sito di Scilab) o simili.
Istallazione
Una volta scaricato il pacchetto relativo al proprio sistema operativo da
http://www.scilab.org/, seguire le semplici istruzioni interattive.
A corredo di questo corso, sono state scritte alcune funzioni e script che sono raccolte nel file
Per_LM_Scilab.zip e descritte in questo manuale.
Per un comodo utilizzo, una volta installato Scilab, lo spazio di lavoro1 pu essere strutturato
opportunamente, con una cartella LM con le funzioni della raccolta di Per_LM_Scilab.zip. Va
quindi caricata la libreria (col comando lib) ed comodo creare un file di startup che viene
automaticamente eseguito ogni volta che si fa partire Scilab.
Per maggiori dettagli, vedere lAppendice Consigli pratici.
Comandi di base
Aprendo Scilab appare un ambiente di lavoro (working environment) molto simile a quello
di Matlab.
Questo, che pu essere configurato in vari modi, composto di varie sotto-finestre e cio:
Uno o pi comandi possono essere scritti in un file di testo, costituendo cos un programma
(pi correttamente, uno script). A questo scopo comodo usare leditor di Scilab, chiamato
SciNotes; per aprirlo si pu usare il comando editor o lo si pu far partire dallicona della barra
delle applicazioni, o anche dal menu Applicazioni. I file di script hanno normalmente
estensione .sce . Con SciNotes si possono editare pi file contemporaneamente.
I comandi di uno script vengono eseguiti col comando
exec nomescript
alternativamente possono essere messi in esecuzione direttamente dalleditor SciNotes, per
esempio dal menu a discesa _Esegui e poi scegliendo Salva ed esegui.
Ecco la finestra delleditor:
________________________________________
Non qui riportata una descrizione dettagliata dei comandi (che pu trovarsi nellhelp o nei
manuali). Si mostreranno alcuni esempi che si consiglia di ripetere sul proprio terminale
Scilab. Gli esempi sono in file .sce, scaricabili dal sito del corso. Altri esempi di uso pratico
possono ricavarsi nei programmi riportati nei prossimi capitoli.
//
//
//
//
//
//
//
//
//
//
//
Note:
%pi indica pi greco, %e indica la base dei logaritmi naturali, %i lunit immaginaria; %t e %T
indicano il valore booleano vero, %f e %F il valore booleano falso, %inf o Inf infinito.
Gli array (o vettori) sono matrici con una sola riga o una sola colonna.
Gli elementi di un array o di una matrice sono indicati racchiusi tra parentesi quadre, separati
da spazi o virgole; il punto e virgola separa le varie righe.
ones(m,n) una funzione che crea una matrice di 1 di m righe ed n colonne. Analogamente
zeros(m,n) crea una matrice di zeri.
Se si scrive un comando senza assegnazione a una variabile (il nome della variabile e il segno
di uguale), viene creata di default la variabile ans.
a=A+B
b=B+C
// c=B*C
c1=B*C'
c2=B.*C
//d1=B/C'
//d2=B./C
d3=B/C
e1=B^A
//e2=B^C
e3=B.^C
e4=A^B
//f=1/0
f=%inf
f1=f+100
f2=f/100
f3=1/f
f4=f/f2
// ERRORE !
operazione incoerente
// ERRORE !
// ERRORE !
operazione incoerente
divisione per zero
// ERRORE !
g1=D*D'
g2=D'*D
g3=D*E
g4=g2.*E
g5=E^2
10
g5=E^2.5
x=0:0.1:5;
y=cos(x*2*%pi);
11
Istruzioni di controllo
Le istruzioni di controllo di Scilab sono simili a quelle del C, ma con delle differenze
sintattiche.
else
.
end
In Scilab I loop sono molto meno usati che in C. Ci poich operare direttamente su vettori e matrici
molto pi veloce. Come in C, il loop tipico viene eseguito tramite il for, ma con una diversa sintessi:
for i = 1 : n
end
case
case
else
end
Un loop in cui non sono noti a priori il numero di cicli, pu essere realizzato, similmente al C, con
unistruzione while.
while
end
12
Grafica
Il comando base per la grafica 2D plot (e la sua variante plot2d):
// grafica2d
x=0:0.01:4;
y=exp(-(x));
y1=cos(x*3*%pi);
y2=sin(x*3*%pi);
figure;plot(y);
figure;plot(x,y)
set(gca(),"grid",[1 1])
title("spostamento in funzione del tempo")
xlabel('t'),ylabel('s')
figure;plot2d('nl',x,y),title('logy'),set(gca(),"grid",[1 1])
figure;plot2d('ln',x+0.01,y),title('logx'),set(gca(),"grid",[1 1])
figure;plot2d('ll',x+0.01,y),title('loglog'),set(gca(),"grid",[1 1])
figure;plot(x,y1)
set(gca(),"grid",[1 1])
// crea una griglia
set(gca(),"auto_clear","off") // permette di mettere pi grafici su una finestra
plot(x,y1,'r.')
plot(x,y2,'g')
set(gca(),'zoom_box',[min(x),-1.2,max(x),1.2]) // cambia la finestra visibile
Notare la modifica della finestra grafica eseguita tramite la modifica delle propriet degli
oggetti. gca() d un handle (un manico) per modificare le propriet delloggetto axes
(assi); vengono modificate le propriet grid (gestisce la griglia), auto_clear (gestisce la
cancellazione del plot) e zoom_box (gestisce la finestra di zoom).
Per cambiare lo zoom sulla figura, si pu anche usare zoom_rect() (vedi i dettagli con lhelp).
Se si d semplicemente il comando gca(), vengono visualizzate tutte le propriet delloggetto
axes. Per conoscere il valore di una propriet occorre usare il comando get: per esempio, per
conoscere il valore della propriet zoom_box, si usa il comando
val=get(gca(),'zoom_box') .
La gestione delle propriet degli assi (e delle figure) pu farsi direttamente dalla figura,
tramite il menu Modifica. Alternativamente si pu far partire leditore grafico col comando
ged (ged(action, fignum)).
Ci sono altre funzioni per la grafica 2D:
14
Gestione input/output
Qui vengono mostrati dei semplici esempi di input/output su file di testo e su schermo. I
comandi essenziali sono analoghi a quelli del C, con qualche differenza funzionale. Ecco quelli
che abbiamo qui usato:
// inpoutput
N=10;
k=1:N;
n=6;
tabn=k*6;
for i = 1:N
disp(msprintf('%d x %d = %d\n',n,k(i),tabn(i))) // output sul display
end
fid=mopen('tabellina.dat','wt'); // apre un file testo per scrivere
mfprintf(fid,'Tabellina del %d \n\n',n)
for i = 1:N
mfprintf(fid,'%d x %d = %d\n',n,k(i),tabn(i))
end
mclose(fid)
fid1=mopen('dati.dat','wt'); // apre un file testo per scrivere
for i = 1:2*N
mfprintf(fid1,'%d %f %e \n',i,rand(1,2))
end
mclose(fid1)
fid2=mopen('dati.dat','r'); // apre un file per leggere, vengono creati nuovi array
ii=zeros(N,1);aa=ii;bb=ii;
for i = 1:N
[nn,ii(i),aa(i),bb(i)]=mfscanf(fid2,'%d %f %f ');
end
mclose(fid2)
15
Script
Pi comandi possono essere raccolti in un file (detto script) ), normalmente con estensione
.sce . Per creare uno script occorre un qualsiasi editor (come, per esempio, il notepad), oppure
leditor interno di Scilab, SciNotes, che si pu far partire dal men File della finestra principale
o col comando editor. Per mandare in esecuzione questi comandi si pu dare il comando
exec nomescript
oppure farlo partire dal men _Esegui di SciNotes.
In uno script (o in una funzione) la doppia sbarra // inizia un commento nella riga. Se si vuole
continuare un comando su pi righe, basta interrompere ciascuna riga con tre punti successivi
().
16
Funzioni e librerie
Una funzione un insieme di comandi racchiusi dai due comandi function ed
endfunction. La forma la seguente:
function [out1, ..., outm] = nomefunzione(input1, ..., inputn)
comandi
endfunction
Gli input1, ..., inputn sono gli argomenti di ingresso dati alla funzione e out1,
..., outm gli argomenti di uscita, prodotti dalla funzione. Essa pu essere richiamata dalla
linea di comando o da uno script o da unaltra funzione.
Una funzione viene normalmente salvata in un file di testo (come uno script), normalmente
con estensione .sci, e pu essere eseguita anche pi volte con diversi argomenti di input.
Per poter usare una funzione questa va caricata in memoria, cosa che viene fatto con il
comando exec nomefunzione , o, pi comodamente, direttamente da SciNotes, dal men
_Esegui col comando Salva e esegui.
Un modo pi comodo per gestire pi funzioni costruire una libreria. Per far ci occorre
raccogliere in una stessa cartella (per esempio base) tutte e sole le funzioni di cui vogliamo
costruire una libreria e quindi dare il comando
genlib('baselib','C:\Users\SergioF\Documents\Scilab\base\')
in questo caso si creata una libreria di nome baselib, contenente le funzioni che abbiamo
messo nella cartella C:\Users\SergioF\Documents\Scilab\base\3. In questa cartella
compariranno la forma binaria delle nostre funzioni, pi altri file di controllo.
Quando vogliamo utilizzare la libreria la carichiamo con
baselib=lib('C:\Users\SergioF\Documents\Scilab\base')
e quindi possiamo usarne le funzioni. Come vedremo in seguito, le librerie di nostro interesse
possono essere caricate automaticamente allo startup di Scilab.
ATTENZIONE ! In Scilab (a differenza di Matlab e altri linguaggi di programmazione)
lambiente esterno non comunica con linterno della funzione solo tramite gli argomenti di
input, ma lambiente della funzione vede le variabili esterne (ma non viceversa).
17
Altre
Operazioni con Excel (o fogli elettronici).
Scilab ha dei comandi che permettono di leggere e scrivere dati in file Excel di tipo xls.
Per la lettura, il comando
[fd,SST,Sheetnames,Sheetpos] = xls_open('Test1.xls')
apre un file Excel di nome Test1.xls e ne acquisisce la struttura. Col comando
[Value1,TextInd1] = xls_read(fd,Sheetpos(1));
vengono letti i dati nel primo foglio, creando la matrice Value1. I dati numerici vengono posti
pari a NaN.
Per quanto riguarda la scrittura, essendo M una matrice numerica,
csvWrite(M,'test.csv')
crea un file in formato comma separated variables, cio variabili separate da virgole, di
nome test.csv, che pu essere importato allinterno di un foglio Excel.
Una guida su tutte le funzioni disponibili riguardo ai fogli elettronici si ottiene con il comando
help.Spreadshhet
18
File di startup
Quando viene fatto partire Scilab, vengono eseguiti i comandi che si trovano nei file
SCIHOME/.scilab , SCIHOME/scilab.ini , e SCI/ scilab.star, dove SCIHOME il nome
simbolico della cartella di partenza e SCI di quella di istallazione di Scilab. (Per vedere a cosa
corrisponde ciascun nome simbolico, battere al prompt di Scilab il nome simbolico.).
comodo mettere in uno di questi file (si consiglia scilab.ini), dei comandi che per esempio
portano alla cartella di lavoro normalmente usata e istallano la/le librerie duso, se ce ne sono.
Per esempio le due righe:
cd C:\Users\SergioF\Documents\Scilab
19
Simulazione di dati
Lancio di dadi (o monete)
Per la simulazione usiamo la funzione rand, generatore di numeri casuali distribuiti
uniformemente tra 0 e 1.
// dadiec
n=50;
u0=rand(1,n,"uniform");
// uniforme da 0 a 1
20
Per il lancio della moneta si associa 1 a testa e -1 a croce. Notare la passeggiata casuale
eseguita facendo un passo in avanti e a destra per ogni testa e un passo indietro e a destra per
ogni croce.
21
devst(4)=stdev(p);
fprintf(6,'distr.
fprintf(6,'distr.
fprintf(6,'distr.
fprintf(6,'distr.
uniforme
normale
binomiale
poissoniana
media
media
media
media
=
=
=
=
%f
%f
%f
%f
devst
devst
devst
devst
=
=
=
=
%f',media(1),devst(1));
%f',media(2),devst(2));
%f',media(4),devst(3));
%f',media(4),devst(4));
function [mis, el, es, ec, tr, dist]=LM_misure(valv, errlet, errsist, errcas, trend,
pr_dist, amp_dist)
// LM_MISURE simulazione misure
//
//
[mis el es ec tr dist]=LM_misure(valv,errlet,errsist,errcas,trend,pr_dist,amp_dist)
//
//
valv
valore vero (array; se 2 elementi, primo valv, secondo numero
//
di misure)
//
errlet
errore di lettura (p. es. 0.001)
//
errsist
errore sistematico (di taratura) [b a]: b*vv+a
//
errcas
deviazione standard del rumore casuale
//
trend
trend (aumento del valore per misura)
//
pr_dist
probabilit dei disturbi occasionali
//
amp_dist ampiezza media disturbi occasionali
mis=[];
el=[];
es=[];
ec=[];
tr=[];
dist=[];
mode(0);
ieee(1);
if max(size(valv))==2 then
valv = mtlb_e(valv,1)*ones(mtlb_e(valv,2),1);
end;
n = max(size(valv));
tr = (0:n-1)'*trend;
es=(valv+tr).*errsist(1)+errsist(2);
ec = errcas*rand(n,1,"normal");
i = find(rand(n,1) < pr_dist)';
dist = zeros(n,1);
dist = mtlb_i(dist,i,laplrnd(amp_dist,max(size(i)),1));
mis0=valv+tr+es+ec+dist;
mis = round(mis0/errlet)*errlet;
el = mis-mis0;
endfunction
stato realizzato anche lo script I_LM_misure che utilizza in modo comodo e interattivo la
LM_misure. Vengono proposti dei valori per i parametri di ingresso (che possono modificarsi
22
interattivamente), vengono prodotti dei grafici con le misure, gli errori e i loro istogrammi e
viene creato un file con tutti i dati, che pu essere aperto con qualsiasi editor di testi
(attenzione per, perch contiene molte colonne e quindi ci possono essere problemi di
allineamento).
// I_LM_misure
mode(0);
ieee(1);
answ = x_mdialog('Parametri di misure ripetute',["Numero misure";"Valore vero";"Errore di
lettura";"Errore sistematico (alfa)";"Errore sistematico (beta)";"Errore
casuale";"Trend";"Probabilit disturbi";"Ampiezza
disturbi"],["60";"10";"0.1";"0.2";"0.01";"0.4";"0.0";"0.04";"3"]);
Nmis = evstr(answ(1));
valv = evstr(answ(2));
errlet = evstr(answ(3));
esalf = evstr(answ(4));
esbet = evstr(answ(5));
errcas = evstr(answ(6));
trend = evstr(answ(7));
pr_dist = evstr(answ(8));
amp_dist = evstr(answ(9));
[mis,el,es,ec,tr,dist] =
LM_misure([valv,Nmis],errlet,[esbet,esalf],errcas,trend,pr_dist,amp_dist);
figure;plot(mis),set(gca(),"auto_clear","off"),plot(mis,"r."),set(gca(),"grid",[1,1])
title("Misure ripetute"),xlabel("Numero d''ordine")
figure;plot(el),set(gca(),"auto_clear","off"),plot(es,"r"),plot(ec,"k"),set(gca(),"grid",
[1,1])
plot(el,"."),plot(es,"r."),plot(ec,"k.")
title("Errori"),xlabel("Numero d''ordine"),
legend("Errori di lettura","Errore sistematico","Errori casuali");
figure;plot(tr),set(gca(),"auto_clear","off"),plot(dist,"k"),set(gca(),"grid",[1,1])
plot(tr,"."),plot(dist,"k.")
title("Disturbi e trend"),xlabel("Numero d''ordine"),
legend("Trend","Disturbi");
mea = mean(mis,"m");
sd = stdev(mis);
messagebox([msprintf("media = %f",mea),msprintf("st.dev. = %f",sd)],"Statistica Misure")
figure;histplot(100,mis,normalization=%f),title("Istogramma delle misure")
figure;histplot(round(sqrt(Nmis)),el,normalization=%f)
title("Istogramma errori di lettura")
figure;histplot(round(sqrt(Nmis)),ec,normalization=%f)
title("Istogramma errori casuali")
figure;histplot(round(sqrt(Nmis)),es,normalization=%f)
title("Istogramma errori sistematici")
timstr = snag_timestr(now());
fid = mopen("misure_"+timstr+".dat","wt");
mfprintf(fid,"
Simulazione di misure \r\n\r\n");
mfprintf(fid,"
Errore di lettura
%f \r\n",errlet);
mfprintf(fid,"
Errore casuale
%f \r\n",errcas);
mfprintf(fid,"
Errore sistematico alfa e beta %f %f \r\n",esalf,esbet);
mfprintf(fid,"
Trend
%f \r\n",trend);
mfprintf(fid,"
Disturbo (prob,amp) %f
%f\r\n",pr_dist,amp_dist);
mfprintf(fid,"\r\n N
misura
err.lett.
err.cas.
err.sist.
disturbo \r\n");
if errlet > 0 then
ndig = ceil(log10(1/errlet));
else
ndig = 6;
23
trend
end;
format = msprintf("%%4d
%%12.%df
%%10f
%%10f
%%10f
%%10f
%%10f
\r\n",ndig);
for i = 1:Nmis
mfprintf(fid,format,i,mis(i),el(i),ec(i),es(i),tr(i),dist(i));
end;
mfprintf(fid,"\r\n
media %f
%f
%f
%f
%f
%f
\r\n",mean(mis,"m"),mean(el,"m"),mean(ec,"m"),mean(es,"m"),mean(tr,"m"),mean(dist,"m"));
mfprintf(fid," dev.st. %f
%f
%f
%f
%f
%f
\r\n",stdev(mis),stdev(el),stdev(ec),stdev(es),stdev(tr),stdev(dist));
mclose(fid)
24
Ed ecco i risultati:
Incertezza valutata
sullincertezza
In teoria
1
-
Metodo semplificato
0.846
0.444
Possiamo ora domandarci come vanno i due metodi di valutazione dellincertezza se invece
che operare su 3 misure lo si fa su un altro numero N. Ecco il programma:
// monte_sign
semplificato
//
N=2000;
sd=zeros(1,N);
sd1=sd;
msd=zeros(1,9);
msd1=msd;
for j = 1:9
for i = 1:N
r=grand(1,j+1,'nor',0,1); // j+1 numeri casuali con distribuzione
normale standardizzata
sd(i)=stdev(r);
sd1(i)=(max(r)-min(r))/2;
end
msd(j)=mean(sd);
msd1(j)=mean(sd1);
end
figure,plot(2:10,msd),holdon,plot(2:10,msd,'.')
25
plot(2:10,msd1,'r'),plot(2:10,msd1,'r.'),gridon
plot(ones(1,10),'g'),xlabel('Numero di misure')
ylabel('Incertezza stimata')
title('Blu sigma, Rosso (max-min)/2, Verde valore teorico')
e i risultati:
Si noti che la stima dellincertezza fatta con la semi-differenza tra la massima e la minima
misura abbastanza ragionevole nel caso in cui N uguale a 3 o a 4 (simile o migliore alla
stima della deviazione standard, mentre per N>4 d risultati in eccesso. Per N-2 una stima
ragionevole dellincertezza prendere semplicemente la differenza tra la massima e la
minima misura (il valore aspettato circa 1.13).
26
leggi_xyinc per leggere dati da un file testo. Il formato in cui i dati sono scritti nel file,
per ogni riga,
x incertezza_di_x y incertezza_di_y
ATTENZIONE ! usare il punto o la virgola come separatore decimale a seconda dello
standard del computer in uso.
Suggerimento: settare il proprio computer in modo da usare come separatore decimale il
punto (uso standard internazionale).
Possono essere inserite righe di commento, inizianti per %. Le righe vuote sono ignorate. I
dati devono essere scritti usando il punto come separatore decimale (non la virgola !). La
funzione pu essere in due modi:
o col nome (col path se in unaltra cartella) del file da leggere
[x,dx,y,dy]=leggi_xyinc(nomefile);
o senza argomento dingresso (sar richiesto interattivamente il file(
[x,dx,y,dy]=leggi_xyinc();
I dati saranno nei quattro vettori x,dx,y,dy di lunghezza il numero delle righe di dati.
27
a=msscanf(line,' %g %g %g %g');
x(i)=a(1);
dx(i)=a(2);
y(i)=a(3);
dy(i)=a(4);
end
end
end
mclose(fid);
endfunction
28
leggi_pasco per leggere dati da un file prodotto dal sistema Pasco, usato per alcune
esperienze. I dati in questo file sono spesso scritti usando la virgola come separatore
decimale (dipende dal settaggio del computer), quindi si dovuto realizzare una ulteriore
function (readascii_comma) che cambia le virgole in punti.
La funzione pu essere in due modi:
o col nome (col path se in unaltra cartella) del file da leggere
[t,s,dt,n]=leggi_pasco(nomefile);
I dati saranno nei vettore t (i tempi di acquisizione) e s (misura, p.es. distanza o peso); dt
indica il tempo di campionamento (non sempre esattamente, come si pu controllare
vedendo i dati in t) e n il numero di misure (dimensione di t e s).
function [t, s, dt, n]=leggi_pasco(fil)
[nout,nin]=argn();
if nin < 1 then
[fnam,pnam]=uigetfile('*',' ',"Quale file aprire ?");
fil=pnam+"\"+fnam;
end
disp(fil)
A=readascii_comma(fil,2,2);
t=A(:,1);
29
s=A(:,2);
n=length(t);
dt=(t(n)-t(1))/(n-1);
endfunction
function a=readascii_comma(fil, ncomments, ncol)
//READASCII_comma reads an ASCII file to a vector, with comma-to-dot
conversion
//
//
a=readascii(file,ncomments,ncol)
//
//
ncomments
is the number of lines containing comments (skipped and
displayed)
//
ncol
is the number of the columns of the output array
//
(must be a sub-multiple of the total number of the data)
[fid,message]=mopen(fil,'r');
if fid == -1
disp(message);
end
for i = 1:ncomments
line=mgetl(fid,1);
disp(line);
end
c=mgetl(fid);
c=strsubst(c,',','.');
a=msscanf(-1,c,' %g %g');
mclose(fid);
endfunction
30
Fit
Sono qui raccolti alcune function Scilab per fare fit di dati sperimentali.
La function gen_lin_fit permette di fare fit polinomiali, armonici o generici, col metodo della
massima verosimiglianza (minimo chi quadro).
Nel caso dei polinomi, va fornito il grado come parametro.
Nel caso della combinazione lineare di funzioni sinusoidali, vanno fornite come parametri le
frequenze.
Nel caso generale il parametro la matrice nxM dei valori delle M funzioni base per gli n punti
di ascissa.
Se la variabile ipl maggiore di zero, vengono prodotti anche i grafici.
function [a, covarout, F, res, chiq, ndof, err, errel]=gen_lin_fit(x, y, unc,
ic, par, ipl)
// GEN_LIN_FIT general linear fit
//
//
[a,covarout,F,res,chiq,ndof,err,errel]=gen_lin_fit(x,y,unc,ic,par,ipl)
//
//
x
abscissa value (length n) or gd
//
y
ordinate value (length n) or nothing
//
unc
y uncertainty (length n; if single number, all equal)
//
ic
type of linear fit:
//
0 -> general;
par the matrix [n,M]
//
1 -> polynomial; par the order
//
2 -> sinusoidal; par the frequencies
//
ipl
= 1 -> plot
//
//
a
fit parameters (length M)
//
covarout covariance matrix
//
F
base functions
//
res
residuals
//
chiq
chi-square value
//
ndof
degrees of freedom
//
err
mean square error
//
errel mean square relative error
// Modalit mostra
mode(0);
// Mostra un avviso per una eccezione in virgola mobile
ieee(1);
// Inizializzazione delle variabili in uscita (non trovate nelle variabili
in ingresso)
a=[];
covarout=[];
F=[];
res=[];
chiq=[];
ndof=[];
err=[];
errel=[];
n = max(size(x));
31
if max(size(unc))==1 then
const = unc;
unc(1:n) = const;
end;
[nout,nin]=argn();
if nin < 6 then
ipl = 0;
end;
x=x(:);y=y(:);unc=unc(:);
select ic
case 0 then
A = par;
[n,M] = size(A);
case 1 then
M = par+1;
for i = 0:par
A(1:length(x .^(par-i)),i+1) = x.^(par-i);
end;
case 2 then
nfr = max(size(par));
M = nfr*2;
ii = 0;
for i = 1:nfr
if par(i) > 0 then
A(1:n,ii+1)=cos(((2*%pi)*par(i))*x);
A(:,ii+2) = sin(((2*%pi)*par(i))*x);
ii = ii+2;
else
A(1:n,ii+1)=cos(((2*%pi)*par(i))*x);
ii = ii+1;
M = M-1;
end;
end;
end;
F = A;
for i = 1:M
A(:,i) = A(:,i) ./unc;
end;
y1 = y ./unc;
B = A'*A;
b = A'*y1;
covarout = inv(B);
a = covarout*b;
chiq = sum((y1-A*a).^2);
ndof = n-M;
y2 = F*a;
res = y2-y;
for i = 1:n
f = F(i,:);
err(1,i) = (f*covarout)*f';
end;
32
err = sqrt(err);
err = sqrt(sum(err.^2)/n);
errel = err/sqrt(sum(y .^2)/n);
if ipl > 0 then
figure; plot(F), set(gca(),"grid",[1,1]), title("base functions")
figure; plot(x,y,"."), set(gca(),"auto_clear","off"), plot(x,y2,"r"),
set(gca(),"grid",[1,1]), title("fit")
figure; plot(x,res,"."), set(gca(),"grid",[1,1]), title("residuals")
end;
endfunction
set(gca(),"grid",[1,1]);
33
Questa funzione molto comoda per lavorare con i dati della strumentazione Pasco. Ecco un
esempio:
-
Compare una finestra con i dati graficati, su cui si pu scegliere un segmento (col mouse); una
fatta la scelta (pi di una volta, se si vuole), appare il grafico con la (le) parti scelte evidenziate
in rosso:
34
Quindi, per ogni segmento scelto viene chiesto il grado del polinomio con cui fare il fit:
e infine appare una finestra con i dati scelti con sovrapposto il fit e i residui (la differenza tra
il fit e i dati):
35
In uscita viene prodotta un array di mlist (in pratica, strutture), una per ogni segmento
scelto. Ciascuna contiene i dati e i risultati del relativo fit, e cio, per il k-esimo segmento,
data(k).x e data(k).y contengono ascisse e ordinate dei punti selezionati nel segmento
data(k).a contiene i coefficienti del polinomio del polinomio interpolante, a partire da
quello della potenza pi alta
data(k).aunc contiene le incertezze per i vari coefficienti
data(k).covar la matrice di covarianza per i coefficienti
data(k).F le funzioni base del fit (in questo caso, semplicemente le potenze di x)
data(k).res i residui del fit
36
37
Si noti che alla struttura data sono stati aggiunti tre elementi:
38
39
Istogramma
La funzione histplot non molto comoda da usare ed inoltre solo grafica, cio non produce
in uscita i valori dellistogramma. La funzione hist_LM istogramma i dati contenuti in una
matrice. I parametri dellistogramma, contenuti in x, possono essere dati in quattro diversi
modi:
40
case 1 then
m=floor(x);
dm=x-m;
xmin=min(data);
xmax=max(data);
dx=(xmax-xmin)/m;
case 2
xmin=x(1);
dx=x(2);
m=ceil((max(data)-xmin)/dx)+1;
xmax=xmin+m*dx;
case 3
xmin=x(1);
dx=x(2);
m=x(3);
xmax=xmin+m*dx;
end
if lx <= 3 then
xh=(xmin+dx/2):dx:xmax;
x=[xmin xmin+(1:m)*dx];
k=floor((data-xmin)/dx)+1;
kk=find(k>m);
k(kk)=m;
kk=find(k<1);
k(kk)=1;
fr=nfreq(k);
h=zeros(m,1);
h(fr(:,1))=fr(:,2);
else
m1=length(x);
m=m1-1;
xh=(x(2:m1)+x(1:m1-1))/2;
h=xh*0;
for i = 1:m
k=find(data>=x(i) & data < x(i+1));
h(i)=length(k);
end
k=find(data >= x(i+1));
h(m)=h(m)+k;
k=find(data < x(1));
h(1)=h(1)+k;
end
figure
for i = 1:m
plot([x(i),x(i)],[0,h(i)]);
plot([x(i),x(i+1)],[h(i),h(i)]);
plot([x(i+1),x(i+1)],[h(i),0]);
end
plot([x(m+1),x(m+1)],[h(1),0]);
xb=x;
endfunction
41
Percentili
Per un certo campione (o insieme di dati) spesso utile conoscere quale il valore al di sotto
del quale c una certa percentuale dei dati. questo in un certo senso una generalizzazione
della mediana (che il valore al di sotto del quale il 50 % dei dati).
Ecco una funzione che esegue questo calcolo:
function y=percentile(x, p)
// Calcola i percentili di un campione
//
//
x
dati
//
p
percentuale (da 0 a 100; anche array)
x=gsort(x);
y=p*0;
N=length(x(:));
for i = 1:length(p)
ii=round(N*p(i)/100+0.5);
if ii < 1 then
ii=1;
end
if ii > N then
ii=N;
end
y(i)=x(ii);
end
endfunction
42
43
end
n=length(x);
sx=stdev(x);
sy=stdev(y);
ro=corr(x,y,1)/(sx*sy);
ro1=zeros(1,N);
for i = 1:N
ii=rand_perm(n);
ro1(i)=corr(x(ii),y,1)/(sx*sy);
end
figure,histplot(100,ro1,normalization=%t)
sd0=stdev(ro1);
endfunction
Essa calcola prima il coefficiente di correlazione tra x ed y (la function corr di Scilab calcola
la covarianza) e in seguito lo calcola N volte avendo permutato casualmente gli elementi di x:
ci permette di valutare la significativit del valore di ro, poich si suppone che la
permutazione casuale abbia distrutto la correlazione. inc0 la deviazione standard dei
valori del coefficiente di correlazione con i dati permutati.
Con i dati usati per lo scatter-plot troviamo ro=0.741 e sd0=0.218 e la distribuzione dei ro per
i dati permutati
44
45
46
nomevar(i)=part(arginp,ini:indeq(i)-1);
valvar(i)=part(arginp,indap(i)+1:indcl(i)-1);
ini=indpv(i)+1;
end
strcom=funinp;
str1=strcom;
r=zeros(nvar,N);
y=zeros(1,N);
for i = 1:nvar
vars(i)=nomevar(i);
execstr('aa=['+valvar(i)+'];');
val(i)=aa(1);
uncer(i)=aa(2);
typ(i)=aa(3);
select typ(i)
case 0 then
r(i,:)=val(i)+grand(1,N,'nor',0,uncer(i));
case 1 then
r(i,:)=val(i)+(grand(1,N,'unf',-uncer(i),uncer(i)));
case 2 then
r(i,:)=val(i)+grand(1,N,'exp',uncer(i));
//
case 3 then
//
r(i,:)=val(i)+usernd(N)*uncer(i);
end
if i == 1
strcom=strcom+msprintf('r(%d,:)',i);
str1=str1+msprintf('val(%d)',i);
else
strcom=strcom+msprintf(',r(%d,:)',i);
str1=str1+msprintf(',val(%d)',i);
end
end
strcom=strcom+');';
str1=str1+');';
kk=strindex(str1,',');
kk0=strindex(str1,');');
kk=[kk kk0];
execstr(strcom);
unc.yy=mean(y);
unc.dy=stdev(y);
[yhist x]=hist_LM(200,y,0);
dx=x(2)-x(1);
yhist=yhist/(N*dx);
aaa=percentile(y,[sigm 0.5 sigp]*100);
unc.ymedian=median(y);
unc.sig1=[aaa(1)-aaa(2) aaa(3)-aaa(2)];
figure,plot2d2(x,yhist),gridon
figure,plot2d2('nl',x,yhist),gridon
aaa=gca();
poly1= aaa.children(1).children(1);
poly1.thickness = 2;
execstr(str1);
unc.y=y;
bi=length(funinp);
y=zeros(1,NP);
yphist=list();
figure;holdon
for i = 1:nvar
select typ(i)
case 0 then
47
r=val(i)+grand(1,NP,'nor',0,uncer(i));
case 1 then
r=val(i)+(grand(1,NP,'unf',-uncer(i),uncer(i)))
case 2 then
r=val(i)+grand(1,NP,'exp',uncer(i));
//
//
end
str2=part(str1,1:bi)+'r'+part(str1,(kk(i):length(str1)));//disp(str2)
bi=kk(i);//disp(str2)
execstr(str2);
unc.py(i)=mean(y);
unc.pdy(i)=stdev(y);
yhist1=hist_LM(x,y,0)/(NP*dx);
col=rotcol(i);
plot2d2('nl',x(1:length(x)-1),yhist1+0.5),gridon // ATTENZIONE WORKAROUND
aaa=gca();
poly1= aaa.children(1).children(1);
polyl.foreground=col;
yhist1=gd(yhist1);
yhist1=edit_gd(yhist1,'ini',x(1),'dx',x(2)-x(1));
yphist(i)=yhist1;
end
title('Dispertion due to single variables')
unc.vars=vars;
unc.varsval=val;
unc.varsunc=uncer;
unc.varstyp=typ;
mprintf('\n')
mprintf('
Output value: %f \n',unc.y)
mprintf('
mean value: %f \n',unc.yy)
mprintf('
median: %f \n',unc.ymedian)
mprintf('
symmetrical uncertainty: %f \n',unc.dy)
mprintf('asymmetrical uncertainties: %f %f\n',unc.sig1)
if unc.y ~= 0
mprintf('
relative uncertainty: %f \n\n',unc.dy/abs(unc.y))
end
mprintf('
mprintf('
relunc
part.unc.
weight\n')
for i = 1:nvar
select typ(i)
case 1 then
str='uniform';
//
un=uncer(i)/sqrt(3);
else
str='normal ';
//
un=uncer(i);
end
un=uncer(i);
relun=un/abs(val(i));
weig=unc.pdy(i)/(relun*unc.y);
mprintf(' %7s
%f
%s %f
%f
%f
%f\n',vars(i),val(i),str,un,relun,unc.pdy(i),weig)
end
endfunction
48
g=4*%pi.^2.*I./(T0.^2..*M0.*r);
endfunction
// driver_exfun_lm_uncert
arginp='...
Ix=[42.1 2.6 0];...
Mb=[27.23 0.01 1];...
lb=[38.10 0.01 1];...
b=[16.50 0.01 1];...
M1=[75.51 0.01 1];...
r1=[0.79/2 0.01 1];...
r2=[2.53/2 0.01 1];...
h=[2.025 0.010 1];...
T0=[1.1545 0.0002 0];'
funinp='y=exfun_lm_uncert('
funinp='exfun_lm_uncert'
[unc,yhist,yphist]=lm_uncert(funinp,arginp);
execstr(arginp);
[g,I,M0,x0,r]=exfun_lm_uncert(Ix(1),Mb(1),lb(1),b(1),M1(1),r1(1),r2(1),h(1),T0(1))
Ed ecco I risultati:
Output value:
mean value:
median:
symmetrical uncertainty:
asymmetrical uncertainties:
relative uncertainty:
977.346230
977.346515
977.346561
0.389589
0.391204 -0.392572
0.000399
Partial uncertainties
variable
Ix
Mb
lb
b
M1
r1
r2
h
T0
value
42.100000
27.230000
38.100000
16.500000
75.510000
0.395000
1.265000
2.025000
1.154500
type
normal
uniform
uniform
uniform
uniform
uniform
uniform
uniform
normal
unc.
2.600000
0.010000
0.010000
0.010000
0.010000
0.010000
0.010000
0.010000
0.000200
49
relunc
0.061758
0.000367
0.000262
0.000606
0.000132
0.025316
0.007905
0.004938
0.000173
part.unc.
0.025056
0.008527
0.085872
0.152624
0.003012
0.000836
0.002677
0.074504
0.338662
weight
0.000415
0.023757
0.334757
0.257667
0.023272
0.000034
0.000347
0.015437
2.000239
50
Function di servizio
Altre funzioni usate negli esempi:
m=nfreq(x) calcola la frequenza dei valori nel vettore x; se in x ci sono n diversi valori,
eventualmente pi volte ripetuti, la matrice m ha n righe e 2 colonne, nella prima delle
quali ci sono i vari valori, nellordine in cui si sono presentati la prima volta, e nella
seconda quante volte ciascun valore presente.
Funzioni utili:
gridon() pone una griglia nella figura corrente; equivalente al grid on di Matlab.
holdon() permette di aggiungere dati da plottare in una figura.
holdoff() non permette di aggiungere dati da plottare in una figura, cancella i precedenti.
51
Esperienze
Sono qui riportate alcune procedure delluso di Scilab e delle funzioni sviluppate per questo
corso, come ausilio allo svolgimento di alcune prove di laboratorio.
Per la descrizione delle prove di laboratorio, si fa riferimento alle dispense del corso.
Molla
Vediamo come graficare le misure per il caso di T2 vs M e L vs M. Innanzitutto vanno
fatte le misure e messe in un file testo del tipo leggibile con leggi_xyinc.sce, quindi si realizza
uno script del tipo:
// analisi_molla
[DM,uncDM,DL,uncDL]=leggi_xyinc('DLvsDM.dat');
plot_unc(DM,uncDM,DL,uncDL);xlabel('Delta M (g)'),ylabel('Delta L (cm)')
[a1,covarout1,F1,res1,chiq1,ndof1,err1,errel1] = gen_lin_fit(DM,DL,uncDL,1,1,0)
x1=0:max(DM)+20;
y1=a1(1)*x1+a1(2);
plot(x1,y1,'r')
[M,uncM,T,uncT]=leggi_xyinc('TvsM.dat');
plot_unc(M,uncM,T.^2,2*uncT.*T);xlabel('M (g)'),ylabel('T^2 (s^2)')
a=get("current_axes");
b=a.data_bounds;
mpmax=50;
limx=-mpmax*1.5;
b(1,1)=limx;
b(1,2)=0;
a.data_bounds=b;
[a2,covarout2,F2,res2,chiq2,ndof2,err2,errel2] = gen_lin_fit(M,T.^2,2*uncT.*T,1,1,0)
x2=limx:max(M)+20;
y2=a2(1)*x2+a2(2);
plot(x2,y2,'r')
ksp=4*%pi^2/a2(1);
gsp=ksp*a1(1);
mpsp=a2(2)/a2(1);
mprintf('k = %f
g = %f
mp = %f',ksp,gsp,mpsp)
Usando i dati di simulati che sono nei file DLvsDM.dat e TvsM.dat (con parametri diversi
da quelli della vera esperienza), troviamo
52
g = 983.762410
53
m_parass = 39.834967
Fluidi
Nellesperienza dei fluidi si devono identificare i regimi laminare e vorticoso nel moto di
acqua in alcuni tubicini.
Le misure sperimentali sono le misure della massa dellacqua uscita dai tubicini. Da queste si
ricava laltezza dellacqua nel serbatoio (tubo verticale) e quindi la pressione allingresso dei
tubicini, la velocit del flusso dellacqua nei tubicini e da questa il Numero di Reynolds.
Quindi, essendo S la sezione del tubo verticale, h0 il livello iniziale dellacqua, s la sezione del
tubicino orizzontale, d la sua lunghezza e avendo preso 1 g/cm3 la densit dellacqua,
eta=0.009 poise la sua viscosit a 25 e laccelerazione di gravit g=980.35 cm/s2, possiamo
procedere come segue4:
Se si vogliono fare grafici singoli per pi tubicini, si possono assegnare per ciascun tubicino
nomi diversi per le varie misure; per esempio per il primo s1, d1, m1, h1, P1, v1, Re1, per il
secondo s2, d2, m2, h2, P2, v2, Re2, e cos via.
54
Pendolo fisico
Volano
55
Uso avanzato
Per una programmazione avanzata in Scilab si consiglia Programming in Scilab
di Michael Baudin, che si trova in rete. Qui riportiamo alcuni comandi e spunti per un uso pi
avanzato di Scilab.
Alcuni comandi
56
1.
3.
6.
=
1.
3.
=
a(1)
1.
a(2)
2.
a(3)
3.
Gli argomenti in ingresso a una funzione possono essere variabili non solo in numero, ma
anche in tipo, e si pu far s che esegua procedure diverse a seconda del tipo di un argomento.
57
Efficienza
Quando si devono fare calcoli complessi o comunque lunghi, occorre una programmazione
efficiente. Per ci innanzitutto si devono, per quanto possibile, eseguire i calcoli in forma
vettorializzata, e non con loop tipo for. Ecco un esempio sulla differenza di velocit tra la
modalit vettorializzata e tramite un ciclo for:
// test_veloc
N=100000;
tic()
x1=1:N;
t1=toc()
tic()
for i = 1:N
x2(i)=i;
end
t2=toc()
mprintf('t1 = %f
t2 = %f
rapporto = %f\n',t1,t2,t2/t1)
Il risultato
t1 = 0.002000 t2 = 25.402000 rapporto = 12701.000000
cio il calcolo vettorializzato , in questo caso, oltre 10000 pi veloce delluso del for.
58
Notare luso dei comandi tic e toc per far partire e fermare un cronometro e quindi valutare
quantitativamente la velocit di esecuzione di un codice. Una valutazione pi completa
dellefficienza di un codice pu ottenersi tramite il profiling interno di Scilab.
59
GUI
Luso standard di Scilab prevede linterazione con i programmi tramite il terminale (la
finestra principale di Scilab).
Scilab offre tuttavia varie funzioni per interagire graficamente con un programma. Una
Graphical User Interface (GUI) rende pi comodo luso di un programma.
Per esempio, tramite luso di x_mdialog ,
answ = x_mdialog('Parametri di misure ripetute',["Numero misure";"Valore vero";"Errore di
lettura";"Errore sistematico (alfa)";"Errore sistematico (beta)";"Errore
casuale";"Trend";"Probabilit disturbi";"Ampiezza
disturbi"],["60";"10";"0.1";"0.2";"0.01";"0.4";"0.0";"0.04";"3"]);
Nmis = evstr(answ(1));
valv = evstr(answ(2));
errlet = evstr(answ(3));
esalf = evstr(answ(4));
esbet = evstr(answ(5));
errcas = evstr(answ(6));
trend = evstr(answ(7));
pr_dist = evstr(answ(8));
amp_dist = evstr(answ(9));
si apre una finestra grafica che richiede alcuni parametri, offrendone i valori di default:
61
62
63
Appendici
Consigli pratici
importante strutturare in modo comodo per le proprie necessit la cartella di lavoro base
Per esempio, per Windows, usando la cartella Scilab creata automaticamente in Documenti,
copiarci le cartelle e i file contenuti in Per_LM_Scilab.zip (cartella LM) e aggiungere una o pi
cartelle di lavoro personali. Evitare quindi di mettere o modificare file nella cartella LM e
sottocartelle, in modo da fare confusione, soprattutto per le modifiche future che potrebbero
esserci nei file di LM (creati per questo corso).
poi conveniente costruire librerie delle funzioni normalmente usate con, per esempio:
genlib('baselib','C:\Users\SergioF\Documents\Scilab\LM\base\')
e quindi creare un file di startup in SCIHOME/scilab.ini , dove SCIHOME una cartella che
dipende dal sistema e che pu essere identificata dando il comando SCIHOME da Scilab. Nel
file scilab.ini vanno messi i comandi che si vuole siano eseguiti automaticamente allapertura
di Scilab. Per esempio scilab.ini pu contenere
cd C:\Users\SergioF\Documents\Scilab
baselib=lib('C:\Users\SergioF\Documents\Scilab\LM\base')
simlib=lib('C:\Users\SergioF\Documents\Scilab\LM\sim')
che automaticamente apre Scilab nella cartella di lavoro voluta e carica le librerie.
64
Scilab
mtlb_exist
evstr
mopen
mgetl
mtlb_fscanf
mclose
msscanf
strsubst
matrix
set(gca(),"grid",[1 1])
set(gca(),"auto_clear","off")
argn(2)
str_out=part(str_in, v)
x_dialog o x_mdialog
messagebox
mfprintf,mprintf,msprintf
Note
diversa
Per le stringhe
C una funzione di Scilab, mfile2sci, che traduce un m-file di Matlab in una funzione (o in uno
script) di Scilab.
65
Esercizi
1. Realizzare una function in grado di leggere dati da un file contenente nella prima riga
lincertezza comune per tutti i dati, e nelle altre i dati stessi, uno per ogni riga.
66
http://www.scilab.org/resources/documentation/tutorials
Manuali in Italiano:
http://www.docente.unicas.it/gianluca_antonelli/scilab
http://www.dii.unisi.it/~giannibi/teaching/materiale/psc/dispensascilab.pdf
Manuali in Inglese:
http://forge.scilab.org/index.php/p/docintrotoscilab/downloads/
http://forge.scilab.org/index.php/p/docprogscilab/downloads/
Altro:
http://wiki.scilab.org/Tutorials
Help online http://help.scilab.org/docs/5.4.0/en_US/index.html
Scilab da Matlab
http://wiki.scilab.org/Tutorials?action=AttachFile&do=get&target=Scilab4Matlab.pdf
67