Differenze

Queste sono le differenze tra la revisione selezionata e la versione attuale della pagina.

--- wikitelaio2015:lez08 [2015/03/30 19:08] – [DEFINIZIONE DI UNA FUNZIONE E DI UNA ESPRESSIONE] 201459
+++ wikitelaio2015:lez08 [2015/04/13 15:48] (versione attuale) – 203797
@@ Linea 1: / Linea 1: @@
+====== Maxima ======
+Maxima è un manipolatore algebrico, disponibile come free software.
+Si attiva dai computer del laboratorio attraverso il menù “Education” presente in Linux e selezionando “wxMaxima”.
+Come principio il software risale ai primi anni 70, ed è stato sviluppato al MIT.
+Il software è scaricabile gratuitamente dal sito http://maxima.sourceforge.net/.
+Sul sito è presente anche della documentazione per un approfondimento ulteriore, nella quale si segnalano “Minimal maxima” di Robert Dodier, “Maxima by Example” di Edwin L. Woollett, oppure il reference manual di maxima, dove sono elencati tutti i comandi in ordine alfabetico.
+E’ utilizzabile come terminale che interpreta comandi in modo interattivo.
+E’ inoltre caratterizzato da un vero e proprio linguaggio di programmazione (interpretato).
+Ha un’interfaccia grafica semplice dal terminale, di nome xMaxima.
+Ha un’interfaccia grafica più evoluta, wxMaxima, che facilita l’inserimento dei comandi dal terminale anche ai non esperti.
+All’apertura si presenta un foglio bianco, che si può riempire con istruzioni o con commenti, che sono gestiti entrambi come sequenza di celle.
+Il menù specifico “Cell” permette di inserire vari tipi di celle, le più interessanti sono la “input cell”, necessaria per inserire un comando, e la “Text Cell”, cella associata a testo che non è un comando, ma semplicemente un commento.
+Per inserire una text cell lo shortcut da tastiera nelle versioni del laboratorio è F6, mentre nelle versioni più recente è Ctrl+1.
+Si può inserire un commento al comando che verrà inserito subito successivamente, ad esempio “pulisco la memoria”.
+===== COMANDI PRINCIPALI =====
+Vediamo alcuni comandi principali per utilizzare WxMaxima.
+Tutti i comandi trattati di seguito sfruttano una semplice sintassi comune per l’esecuzione: devono essere scritti in una cella di imput e terminare con un “;” se si desidera che il programma restituisca un output di conferma, altrimenti con un “$” se non lo si desidera.
+L’esecuzione del comando avviene sempre premendo “shift+invio” da tastiera o selezionando “evalutate cell” dal menu “cells”.
+Maxima  esegue un comando alla volta nell’ordine stabilito dall’utente.
+ In alcune situazioni può essere necessario far rieseguire l’intera lista di comandi utilizzando “ctrl+r” o “evalutate all cells” dal menù “cells”.
+Ciascun comando del programma può essere visto come una funzione che lavora su uno o più argomenti tra parentesi, nella forma
+	Funzione (argomento1, argomento2,…..);
+Maxima valuterà prima l’argomento tra parentesi e successivamente lo applicherà alla specifica funzione per valutarla e restituire un output (se richiesto). Ciò vale sia per le funzioni matematiche che per i comandi di interfaccia.
+	kill (all);
+Il comando esegue la pulizia della memoria di tutte le variabili/funzioni memorizzate precedentemente. Occorre eseguire questo comando ogni volta che si intende lanciare il programma in quanto eliminando i residui in memoria si evitano iterazioni indesiderate in esecuzioni successive. Se si vuole eliminare un’unica variabile basta sostituire all’argomento tra parentesi “all” il nome della variabile da eliminare.
+Maxima riconosce alcune funzioni matematiche di base, tipo
+	sin (%pi/4);
+In questo caso il programma restituisce come output 1/√2 , che è un risultato esatto in quanto π/4 è un angolo notevole per la funzione seno. Se invece digitiamo
+	sin (3);
+l’output fornito dal programma è sin(3). La ragione di queste due tipologie di risposta è da ricercare nella logica del processo di valutazione del programma. Maxima memorizza le espressioni come stringhe di testo con elementi logici e successivamente valuta l’argomento e la funzione.
+Se l’argomento e la funzione ricadono in casi notevoli (già memorizzati) il programma restituisce un valore esatto, altrimenti riporta semplicemente la funzione di imput.
+Si può forzare la valutazione numerica del programma introducendo un reale a precisione limitata tramite un punto nell’argomento della funzione
+	sin (3.0);
+in questo caso la risposta è 0,1411….., un reale a precisione limitata. Vale la regola per cui se si richiede a Maxima di valutare una quantità esatta esso risponde con una quantità esatta, al più uguale all’input se la quantità non è un valore notevole.
+ Se si richiede la valutazione di una quantità reale a precisione limitata la risposta del programma sarà una quantità reale a precisione limitata.
+Le quattro funzioni elementari non hanno bisogno di utilizzare la forma “funzione(argomento1,argomento2…);” ma possono essere scritte in forma simbolica utilizzando gli operatori intermedi +, -, *, /.
+Si possono introdurre variabili definite e non definite con la sintassi
+	nomevariabile : valore;
+come ad esempio
+	x : pippo+1;
+L’assegnazione di una variabile può avvenire in ogni parte del programma ed essere richiamata successivamente, ma sarà necessario far rieseguire l’intero programma con “ctrl+r” per vederla valutata.
+Quando si richiamano variabili esse vengono valutate: se sono assegnate viene sostituito il loro valore, altrimenti no, tipo
+	x : pippo+1;
+	sin(x);
+L’output del programma è “sin(pippo+1)”, “pippo” è una variabile non definita e quindi non è stata sostituita. In questo caso Maxima ha compiuto un'unica valutazione dell’argomento e della funzione.
+Possiamo richiedere al programma un’ulteriore valutazione della funzione con il comando
+	ev(funzione);
+Vediamo l’utilizzo di questo comando con un esempio:
+	x : pippo+pluto;
+	pippo : %pi/8;
+	pluto : %pi/8;
+	sin (x);
+Il programma restituisce come output il valore “sin (pippo+pluto)”. Le due variabili “pippo” e “pluto” sono definite ma il programma non ha sostituito il loro valore. Se forziamo la valutazione con il comando ev
+	ev (sin (x));
+L’output del programma è 1/√2, il risultato aspettato. Nota bene: sfuttando la logica sequenziale di valutazione delle variabili di Maxima avremmo potuto evitare di usare il comando “ev” e ottenere lo stesso risultato. Occorreva far valutare le variabili “pippo” e “pluto” prima della variabile x
+	pippo : %pi/8;
+	pluto : %pi/8;
+	x : pippo+pluto;
+	sin (x);
+Il risultato è 1/√2 senza utilizzare il comando di valutazione.
+Altre varianti del comando sono
+	ev (funzione, eval);
+che esegue un’ulteriore valutazione oltre a quella richiesta dal comando “ev” e
+	ev (funzione, infeval);
+che esegue infinite valutazioni della funzione citata nell’argomento finchè non trova due valutazioni successive uguali. La variante con infeval è da utilizzare con attenzione in quanto manda in loop il programma nel caso in cui non si riesca a trovare due valutazioni uguali successive. Per arrestare l’esecuzione infinita basta entrare nel menù “Maxima” e selezionare “restart Maxima”.
+Con Maxima si possono richiamare le costanti prememorizzate nel programma tramite il simbolo % seguito dal nome della costante
+	%pi;
+	%e;
+Il simbolo “%” è invece utilizzato per richiamare una funzione scritta nella riga precedente:
+	%pi
+	Sin (%);
+L’output restituito dal programma è dunque zero.
+===== Definizione di espressioni e funzioni =====
+- L’ operatore “:” definisce un’espressione, l’operatore “:=” permette di definire una variabile sotto forma di funzione ad una o più variabili, nel caso di più variabili, queste vanno separate da virgola.
+- Definiamo un’espressione:
+  miaexpr : sin (x);
+  ev(miaexpr , x=%pi/6);
+- Definiamo una funzione:
+  miafun(x) := sin (x)/(x);
+  miafun(%pi/4);
+Si noti bene la fifferenza tra il comando ":" e il comando ":=": il primo definisce una espressione, il secondo una funzione.
+Per valutare l’espressione è necessario richiamarla tramite il comando:
+  ev (“espressione da richiamare” , “assegnazione della variabile”)
+Mentre per la funzione la valutazione viene ritardata al momento in cui avviene l’assegnazione del parametro. Questo implica che è possibile richiedere valori diversi della funzione, senza doverla nuovamente valutare. Come notiamo l’operatore “:=” ha la caratteristica di non cambiare il valore alle variabili finché non definiamo il valore della variabile stessa ( nel nostro caso la x).
+- Se vogliamo definire una funzione con valutazione immediata all’atto della definizione, si usa il comando “//define//” al posto di “:=”, quest'ultimo infatti valuta la funzione solo quando questa viene utilizzata.
+  a : pluto;
+  define( altrafun(x) , a*sin(x) );
+ricevendo come output, nel nostro caso:
+  altrafun (x) := "pluto sin(x)" /"x";
+===== Calcolo con wxMAXIMA dei coefficienti degli spostamenti dell’elemento TRIA3 e della matrice B =====
+  Kill(all);
+[definizione generica forma lineare degli spostamenti attraverso i coefficienti incogniti]
+u(x,y) := a1 + a2 * x + a3 * y;
+v(x,y) := a4 + a5 * x + a6 * y;
+[si impone ,ai nodi, la congruenza dei generici spostamenti con quelli nodali ,ottenendo un sistema di 6 equazioni scritte sotto forma di lista]
+  eqns : [
+    u(x_i,y_i)=u_i,
+    v(x_i,y_i)=v_i,
+    u(x_j,y_j)=u_j,
+    v(x_j,y_j)=v_j,
+    u(x_k,y_k)=u_k,
+    v(x_k,y_k)=v_k
+  ];
+[specificazione incognite del sistema]
+  unkn : [ a1,a2,a3,a4,a5,a6 ];
+[soluzione del sistema]
+  linsolve ( eqns , unkn ) , globalsolve=true;
+[definito il campo degli spostamenti, si calcolano le deformazioni ]
+  epsx : diff( u(x,y) , x , 1 );
+  epsy : diff (v(x,y) , y );
+  gammaxy : diff( u(x,y) , y ) + diff( v(x,y) , x );
+[verifica che le deformazioni siano costanti]
+  diff( [ epsx,epsy,gammaxy ] , x);
+  diff( [ epsx,epsy,gammaxy ] , y);
+[lista contenente le deformazioni]
+  eps : [epsx,epsy,gammaxy];
+[lista spostamenti nodali]
+  delta : [u_i,v_i,u_j,v_j,u_k,v_k];
+[def. matrice B a partire dagli elementi delle lista delle deformazioni e degli spostamenti nodali ]
+  coefmatrix(eps,delta);
+  ratsubst ( duearea  ,  (x_j-x_i)*y_k+(x_i-x_k)*y_j+(x_k-x_j)*y_i  , %  );
+==== DETTAGLI DEI COMANDI UTILZZATI ====
+==== Liste e loro manipolazione ====
+In Maxima la lista è una struttura che ci permette di rappresentare  un insieme di elementi non per forza omogenei , che ci permette di racchiudere in un solo pacchetto variabili, valori numerici ,espressioni matematiche ecc.
+La definizione della generica lista ‘aaa’ si effettua semplicemente attraverso la digitazione di
+aaa :[elemento 1,elemento2,…,] ;
+Essendo per natura stessa diverse dai vettori, la loro gestione risulta completamente differente.
+Si riportano di seguito alcuni comandi utili:
+  * nome lista [ x] ; → consente di estrarre l’elemento numero x dalla lista precedentemente definita;
+  * nome lista [x] :alfa  → assegna all’elemento di cui sopra un valore o un’espressione generica alfa;
+  * append (nome lista,[beta],[gamma]) ; → concatena alla lista gli elementi beta e gamma; tale comando  si può utilizzare anche per concatenare una lista già definita ( ‘append(lista1,lista2) ‘) o nuova (‘append(nuova lista,[ccc,ddd]) ‘).
+==== Soluzioni di equazioni o sistemi lineari ====
+La soluzione di un’equazione lineare (o di un sistema analogamente) può essere implementata attraverso il comando linsolve , specificando ,come nel corpo del listato, prima la lista contenente le equazioni poi le incognite.
+L’assegnazione dei risultati alle variabili deve essere fatta manualmente attraverso la specifica ‘ globalsolve=true’ , ovvero utilizzando un interruttore di switch (true /false).
+{{:wikitelaio2015:matrice_b_tria3.wxm| programma matrice B tria3 svolto in aula}}