Category Archives: Scilab

Grafici con Scilab

Scilab è ottimo. Per tante cose. Io l’ho scoperto per i grafici, lo sto utilizzando e in questo post vorrei riassumere cosa ho scoperto.
Intanto è ottimo, lo uso e lo consiglio a tutti.

Pero non è facilissimo, è un prodotto grosso (proteiforme), si evolve (giustamente) e qualche istruzione diventa obsoleta (com’è giusto che sia).
Non sempre i manuali sono aggiornati e per quel che ho trovato manca un “Getting Started” o un “How To” per le singole branche in cui può essere suddiviso. In particolare per il plotting ho dovuto scorrere bazillioni di files .html e .pdf e in nessuno ho trovato tutto quello che cercavo.

Tra i tanti considero fondamentali:

  1. Scilab: Graphics di Anuradha Amrutkar dell’Indian Institute Of Technology, Bombay, 15th April, 2010, disponibile qui;
  2. Graphics: Getting started, qui e naturalmente qui cercando Graphics Library (e c’è tutto il resto del manuale online, da perdersi).

Allora ecco cosa ho ottenuto. Il mio sogno sarebbe stato quello di costruire uno script che, lanciato da terminale, generasse automaticamente il grafico richiesto; non è esattamente quello che sono riuscito a fare, difatti lanciando l’interprete di Scilab ottengo:
e, ovviamente, si apre il terminale di Scilab. Trascinando uno script, qualunque script, su quest’ultimo mi compare questo messaggio d’errore:
Ci sono due cose: 1) un messaggio solo parzialmente visibile, che fa riferimento a ecanvas"* che non so cosa sia, e 2) la variabile mostra non definita. Strano che c’entri una variabile con il nome italiano, non citata da nessuna parte.
Ho provato a inserire istruzioni relative a driver(), xinit() e usecanvas() senza risultato. Per mostra basta settarla a %t o %f (non so qualse sia quella giusta).

In genere la prima esecuzione dello script abortisce, completamente o produce solo parte del grafico, basta ridroppare lo script una seconda volta e tutto funziona.

Questi sono alcuni esempi, presi dalla documentazione citata.

mostra = %T;
t=linspace(0,%pi,20);
a=gca();a.data_bounds=[t(1) -1.8;t($) 1.8];

plot2d(t,[cos(t'),cos(2*t'),cos(3*t')],[-5,2 3]);
e=gce();
e1=e.children(1);e1.thickness=2;e1.polyline_style=4;e1.arrow_size_factor = 1/2;
e2=e.children(2);e2.line_style=4;e2.thickness=3;
e3=e.children(3);e3.line_mode='on';e3.mark_background=5;

hl=legend(['cos(t)';'cos(2*t)';'cos(3*t)']);

xs2png(0, "e4.png")

mostra = %F;
t = linspace(-%pi, %pi,30);
function z = mysurface(x,y);
    z = x * sin(x) ^ 2 * cos(y);
endfunction
contour(t,t,mysurface,10)
xs2png(0, "aa2.png")

mostra = %F;
x = [0 : 0.1 : 2 * %pi]';
plot2d(x, [sin(x) sin(2*x) sin(3*x)], ..
       [1,2,3], leg = "L1@L2@L3", nax = [2,10,2,10],rect = [0,-2,2*%pi,2]);
xs2png(0, "scp4.png")

mostra = %f;
t=-%pi:0.1:%pi; m=sin(t)'*cos(t);
clf()
xset("colormap",jetcolormap(64))
colorbar(-1,1)
Sgrayplot(t,t,m, strf="041")
xs2png(0, "scp6.png")

mostra = %f;
n = 30;
nt = 100;
x = linspace(0,2*%pi,n);
y = linspace(0,%pi,n/2);
z = sin(x')*sin(y);
t = linspace(0,4*%pi,nt);
show_window(); clf()
f=gcf();
f.color_map=jetcolormap(64);
f.pixmap='on';
colorbar(-1,1)
Sgrayplot(x,y,cos(t(1))*z, strf="042", zminmax=[-1,1])
c=gce(),e=c.children
xtitle("Kaa''s eyes")
for i = 1:nt
  e.data(:,3)=matrix(cos(t(i))*z,-1,1);
  show_pixmap()
end
f.pixmap='off';
xs2png(0, "scp7.png")

(quest’ultima è dinamica, provate…).

Bon. Per adesso Scilab lo uso così.
Ho trascurato altre cose, per esempio lo sapete che è uscita la nuova versione di newLISP, la 10.3? Lo sapevo che non interessa nessuno :-(
Ho trascurato anche Python, ma restate sintonizzati, prossimamente…
E poi tante altre cose nuove 8) e nuovi collaboratori 8)

Scilab, le funzioni e tutte le altre meraviglie

In questo post, continuazione del precedente,si coninua l’esame del pdf progscilab per un illustrazione veloce delle notevoli capacità del package. È utile per arrivare a una mia conclusione, giù in fondo in “Conclusione;-)

In Scilab le funzioni sono estremamente flessibili. Intanto si distinguono in macro, scritte nel linguaggio di Scilab e primitive, scritte in qualche altro linguaggio (per esempio C, C++, Fortran) e compilate.
Nella maggior parte dei casi non c’è differenza tra i due tipi e per questo si usa il termine generico function. Ovviamente la cosa cambia nel debug.
Le funzioni sono variabili: non male per un progetto partito avendo come riferimento il Fortran :-D
D’altronde oggi è una cosa abbastanza comune, a me capita di farla anche senza volerlo: in Python basta dimenticare le parentesi. Ma è di una comodità unica, conosciuta come callback.
A p.57 e ssg viene spiegato molto bene, con esempi, come creare funzioni con numero di argomenti variabili, sia in input che in output, cose tecniche: se servono leggetevele e sapetele ;-)
A p.81 si parla dello scope delle variabili. Diversi casi sono possibili, attenzione! La soluzione più semplice (il livello dello stack) di p.82 può creare problemi, raccontati nelle pagine successive. A me casi del genere sono capitati più volte, provo una discreta Schadenfreude venire a conoscenza che succede anche a altri, tanto spesso che vale la pena di riportarli in un manuale 8)
A p.93 e ssg viene descritto come sia possibile generare dinamicamente le funzioni come stringhe cosa che conferisce a Scilab un livello di flessibilità altrimenti irraggiungibile (ma a me comincia a frullarmi in t’a capa il Lisp).
Le tecniche per rendere l’esecuzione veloce sono descritte a partire da p.99, Performances.
Da copiare l’idea della coppia di funzioni gemelle tic() e toc(): la prima fa partire il cronometro, la seconda lo blocca. In uno dei prossimi post le faccio in Python, newLISP e Fortran, forse, se nel frattempo non me ne sono dimenticato o sono stato attratto da qualcos’altro.
Bello l’esempio d’uso del profiling, da p.102 (profilaggio? la banda del nano usa “briffare” addirittura!).
A p.110 inizia la vettorizzazione, da leggere. Poi vengono i trucchi per ottimizzare il codice, p.115. Regola aurea: usare le funzioni di Scilab e evitare come la peste i cicli for.
Poi basta. Il discorso diventa troppo tecnico e mi sono addormentato :-(

Il pdf 419922 An Introduction to Scilab (un’altra) di Satish Annigeri
(prof. per ingegneri civili) è conciso (55 pagine) e pratico: a p.35 ci dice come gestire file su disco, nella pagina successiva già si occupa di plottaggio di curve polinomiali e poi passa a leggere file di Excel.
A p.47 passa a un caso pratico da ingegneri civili, calcolo di una struttura reticolare piana arrivando a determinare le sollecitazioni nelle aste. Notevole.

Il pdf intro dello Scilab group a p.87 e ssg ci illustra come gestire i grafici.
L’esempio di p.81 mi da errore e allora ho provato a dare le istruzioni direttamente dentro al Terminale si Scilab. Comodissimo il comando xset() che apre la finestra grafica e permette di modificare il grafico. Ecco il mio risultato:

Proseguendo con gli esempi non tutti vengono, ci sono errori nei comandi, alcuni di difficile individuazione, i font sono diversi da quelli del manuale (Windoze strike again!), …
Ci sono però numerosi file di esempi, richiamabili direttamente anche all’interno dell’editor (alle volte sono davvero gnugnu).

Il capitolo 6 a p.101 ci introduce a una delle caratteristiche più avanzate di Scilab: Interfacing C or Fortran programs with Scilab. Chiaramente questo sarà usato solo da utenti skillati per task non banali ma sembra fattibile, semplice e ci sono esempi. No non ci provo, sono troppo vecchio per quest cose. Però: avete nai provato a farlo con M$ DOS (sto parlando quando ancora non si usava Windoze): frustrante. Molto meglio la filosofia *NIX/Linux.

Per la parte matematica sono naturalmente previsti collegamenti con Matlab e Maple.

Conclusione

Il manuale Programming in Scilab di Michaël Baudin, contenuto nel file progscilab-so-v0.6.pdf è fondamentale.
Riassumerlo è impossibile 8)
Ciò porta a una conclusione: questi post su Scilab non possono sostituire il manuale. Per diversi motivi:

  • il manuale è ottimo;
  • Scilab è un tool molto grande e completo, il suo linguaggio di programmazione anche;
  • compito del blog non è fare un corso bensì segnalare le chicche che trovo, anzi che mi piacciono;
  • quando possibile adoro proporre script che per questioni oggettive debbono essere piccoli, se piacciono sarà il lettore a completarli.

Prossimamente

Il modulo Plot2d mi attira. Ma ci sono anche altre cose nel mondo della programmazione. È da parecchio che non nomino il newLISP, Pyhton idem. Poi ci sarebbero altri linguaggi, non quelli predominanti C++ e Java, su quelli c’è già troppa roba, altri meno noti e pubblicizati ma intriganti. E poi ci sarebbe da considerare anche gli utenti di Windows: alcune cosa che con Linux si danno per scontate lì mancano, o co$tano.
Prossimamente, se non mi sto beccando l’influenza, sempre su questo canale :-D

Scilab – polinomi e matrici

Dopo l’intro e aver visto come usare Scilab per fare un grafico oggi racconterò di come usarlo per fare calcoli. Scilab adora contare e allora via con i calcoli.

Intanto sto ancora imparando ma è disponibile tutto quello che serve, anzi molto di più. Parecchi documenti si trovano a Scilab Wiki. In particolare Tutorials and documentations dove c’è, tra un mucchio di altre cose, Programming in Scilab di Michaël Baudin.

A p.22 introduce i polinomi. Seguendolo definiamo un polinomio in funzione delle sue radici 1 e 2: p(x) = (x-1)(x-2) con

p = poly([1,2], "x")

Si può definire il polinomio in funzione dei suoi coefficienti (in ordine crescente): q(x) = 1 + 2x sarà

q = poly([1,2], "x", "coeff")

A questo punto i polinomi si possono sommare, sottrarre, moltiplicare:

-->m = p * q
 m  =

              2    3
    2 + x - 5x + 2x   

-->

Per valutare il valore del polinomio in un dato punto si usa horner. Ecco, niente panico!, un po’ di sano terrorismo matematico, qui su wikipedia, ma con Scilab niente panico!

:-->p = poly([1,2], "x")
p  =

          2
2 - 3x + x

-->horner(p, [0 1 2 3])
ans  =

2.    0.    0.    2.

che sono, ovviamente, i valori per x = 0, 1, 2, 3. Quindi dimenticate la pagina di wiki: con Scilab i calcoli (noiosi e (dai) astrusi) li fa lui.

roots ci da le radici, verifica:

-->p = poly([1,2,3,4,5], "x")
 p  =

                     2     3     4   5
  - 120 + 274x - 225x + 85x - 15x + x   

-->roots(p)
 ans  =

    1.
    2.
    3.
    4.
    5.    

OK, viso che funziona

-->p = poly([1,2,3,4,5], "x", "coeff")
 p  =

               2    3    4
    1 + 2x + 3x + 4x + 5x   

-->roots(p)
 ans  =

    0.1378323 + 0.6781544i
    0.1378323 - 0.6781544i
  - 0.5378323 + 0.3582847i
  - 0.5378323 - 0.3582847i  

numeri brutticomplessi, ma ecco:

-->t = poly([24, -50, 35, -10, 1], "x", "coeff")
 t  =

                  2     3   4
    24 - 50x + 35x - 10x + x   

-->roots(t)
 ans  =

    1.
    2.
    3.
    4.  

Scilab è sempre più simpatico :-D
Uno (cioè a dire il vero io, fino a un istante fa) potrebbe pensare che Scilab tratti solo matrici bidimensionali: falso, c’è l’ipermatrice (hypermatrix)

This feature is familiar to Fortran developers, where the multi-dimensional array is one of the basic data structures.

Quindi la volta scorsa ho detto una cosa non vera: chiedo venia ma mi verrebbe voglia di dare la colpa al Fortran :-(

A p.51 di progscilab si inizia a parlare delle funzioni. Potrebbe essere l’argomento di un prossimo post, forse…

Introduzione a Scilab

Scilab è una meraviglia. Molto di più di quello che avevo immaginato, ma c’è sempre un punto di partenza e che io sono n00b (niubbo) di prima categoria non è una novità. Per cui questo post va preso come un primo assaggio, assolutamente parziale e non esaustivo, diciamo un assaggino.

L’installazione di Scilab è davvero all’antica: scompattate il file tar o zip o quello che è (naturalmente è multipiattaforma: Linux, Windows e MacOS) dove vi pare e piace e avrete la subdirectory bin con lo script scilab per aprire il terminale.

È luogo comune trito e ritrito che Ankh-Morpork non è stata costruita in un giorno, ogni cosa richiede tempo. E bisogna ambientarsi. E con calma, arrabbiarsi non serva anzi è controproducente.

Allora io ho scompattato il tar il ~/apps; ho creato nella directory ~/bin il symlink per scilab trovato in bin di Scilab  ed eccomi pronto.
A dire il vero un geek lo installerebbe in /usr ma Ubuntu ti obbliga ogni sei mesi a reinstallare tutto; in questo caso basta backuppare la directory ~/apps 8)

Da quando K&R hanno inondato il mondo (la parte di esso che ci interessa) con “The C Programming Language” si deve partire con “Hello World!“. Non sono solo: il pdf introscilab.pdf scaricato dalla pagina della documentazione mi guida passo-passo. Quindi apro il terminale nella dir dove provo i miei pasticci e lancio il comando

scilab

che apre il Teminale di Scilab nel quale posso sbizzarrirmi come da figura


Visto che tutto è OK posso scrivere quit per uscire. E per oggi basta. No! fermi lì! scherzavo.

Intanto per non bloccare il terminale conviene dare il comando scilab & cosa di cui mi ricordo sempre un secondo dopo aver premuto Invio.

Dal Terminale di Scilab lancio Applicazioni/SciNotes che mi apre l’editor dentro al quale posso scrivere il mio script hello.sce, come in figura


A questo punto posso, dopo aver salvato lo script posso trascinare (draggare) il file da Nautilus alla finestra del Terminale che lo esegue, fin troppo bene: l’istruzione finale quit chiude il terminale stesso! Allora i casi sono due: 1) commentare l’istruzione quit inserrendo // all’inizio della riga in modo che la sua esecuzione nel Teminale (di Scilab) non lo chiuda; oppure 2) lanciare da terminale (quello della shell) il comando scilab -nwni -nb -f hello.sce
Chiaramente preferisco la soluzione 2. Le opzioni sono elencate in fig. 11, p. 20 di introscilab.

il mio desktop è sempre molto affollato

OK, funziona. I file .sce si possono benissimo editare con gedit, vi, Emacs anche se l’editor di Scilab colora la sintassi, ha l’help, etc.

Una delle caratteristiche peculiari di Scilab è il tipo di dati che predilige. Qui le alternative operate dai vari linguaggi sono innumeri: il Forth ha solo gli interi, il Basic preferisce i reali, il Lisp parla di atomi e liste, nel C tutto quello che non è intero è un puntatore (sì, lo so semplifico, dai! non ho mai capito a fondo la cosa :-( ma non mi cazziate che tanto cancellerò i commenti). Scilab usa le matrici, p.31. Inoltre, anche se non detto esplicitamente sono matrici bidimensionali.
Ah se l’avessi avuto 25 anni fa! Quanti cicli mi sarei risparmiato! Inoltre è veloce a trattarle:

a Scilab script which performs the same operations with loops is
typically from 10 to 100 times slower.

Una cosa divertente: la matrice Identità come la chiamiamo? I può generare confusione, sembra una variabile o, peggio ancora, un indice. Pas de panique: la chiamiamo eye, ingénieux! vraiment.

Una cosa che può creare confusione è l’interpretazione come interi di numeri float (p.45): l’interpretazione avviene sempre per troncamento e non per arrotondamento. Da ricordarsene.

L’istruzione for (p.52) usa una sintassi sua quando si precisa il passo; d’altronde capita la stessa cosa con le sequenze. E qui anche Python è particolare e a volte me ne dimentico. Ma il più balzano di tutti era il Fortran di una volta (prima del 1978) che pretendeva di fare comunque sempre un giro anche quando non doveva e si doveva mettere un if di guardia con relativo goto: be tempi, sigh!

Le funzioni (p.55 e ssg) hanno anche loro una sintassi particolare, ma va bene, basta saperlo. A p.59 racconta come creare le proprie librerie e ci dice che inoltre ci sono i moduli che qui non affronta.

A p.66 inizia il capitolo Plotting. La decisione di esaminare Scilab da parte mia è nata da un post di Gianluigi Filippelli, qui. . Poi ho scoperto che Scilab è ben altro. E dice il dr. prof

Scilab viene usato un bel po’ nel mio laboratorio [...] anche come generatore di codice C per sistemini embedded. Ecco ad esempio un’applicazione:
http://www.evidence.eu.com/content/view/361/432/

Ma per fare grafici è ottimo, poi si possono esportare nel formato voluto (p.74).

Ho provato a giochicchiarci ottenendo questo. Ho dovuto usare il manuale per plot.

// esempio di grafico fatto quasi senza guardare il manuale

xt = linspace(0, 10, 11)
c1 = [0, 10, 8, 6, 4, 2, 4, 6, 8, 5, 8]
plot(xt, c1, "r-o")

xr = linspace(5, 10, 6)
c2 = [3, 2, 1, 5, 4, 6]
plot(xr, c2, "b-p")

m = [4, 3, 2, 4, 2, 2, 6, 8, 6, 5, 2]
plot(xt, m, "k:*")

ps = [4, 4, 3, 2, 5, 6, 4, 3, 5, 7, 5]
plot(xt, ps, "m--d")

xtitle("Ultimi indici rilevati", "tempo", "valore indice")
legend("c1", "c2", "m", "ps")
xs2png(0, "indici.png")

Quant’è grosso il manuale? 4001 pagine! Panico, paura, terrore :-(

Aussi en français

Ho provato a usare livret_lycees_2010.pdf

L’objectif de ce livret est de vous guider pas à pas dans la découverte des différentes fonctionnalités de base du logiciel Scilab dans le cadre d’une utilisation en classes de lycées. Cette présentation se limite volontairement à l’essentiel pour permettre une prise en main facilitée de Scilab.

ho (re)imparato diverse parole nuove (crochet, suite), altre le sapevo già (logiciel, taper) ma poi mi sono perso con afficher (== disp) e histogramme (== histogram). Questi francesi! hanno tradotto anche i comandi; cosa vecchia peraltro, è una loro fissa ;-)

Conclusione

Scilab dell’INRIA è molto di più, ci sono anche altre cose, ad esempio Xcos. Il sito web è bello, chiaro e esaustivo: un modello. Credo che ne parlerò ancora in futuro.

Iscriviti

Ricevi al tuo indirizzo email tutti i nuovi post del sito.

Unisciti agli altri 71 follower