===== wxMaxima =====


Maxima è un manipolatore algebrico che può funzionare con varie modalità:
  *E’ utilizzabile come terminale che interpreta comandi in modo interattivo.
  *E’ utilizzabile come un vero e proprio linguaggio di programmazione (interpretato, non compilato come il c).
  *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.

**Come funziona il programma**

  * Si scrivono i comandi sulle righe di input (%i1), (%i2) numerate progressivamente; alla fine di ogni riga di input premendo i tasti //shift+invio//, wxMaxima estrapola una riga di output indicata con (%o1), (%o2), con numerazione corrispondente.È inoltre possibile richiamare ogni singola riga attraverso tale etichetta.
  * % : il comando viene applicato alla stringa precedente.
  * Bisogna sempre terminare i comandi con un “;”. Si noti che wxMaxima inserisce in automatico “;”, possiamo anche terminare un comando con “$”, però in questo caso non ci mostra l’output del comando.
  * Premendo solo //invio// possiamo dividere il comando su più righe.
  * La “spaziatura” non implica alcun effetto sul codice, mentre il software distingue tra minuscolo/maiuscolo.
  * Premendo //Ctrl+R// prendiamo in considerazione tutte le caselle di testo.
  * Le costanti standard sono entità predefinite nel programma , e si richiamano scrivendo ‘%e’ (numero di Nepero), ‘%pi’ (pi greco), etc.
  * wxMaxima distingue l’inserimento di un numero implicitamente esatto (7/2) da un numero reale a precisione finita (3.5), e restituisce coerentemente il valore qualora sia un risultato esatto.
     {{:wikitelaio2015:01.png?200|}}
  * Possiamo inserire anche celle di testo, dove indicare ciò che stiamo eseguendo.

**Alcuni comandi principali**

- Per eliminare tutto dobbiamo dare il comando:
  Kill (all);
è indicato dare tale comando ogni qual volta si inizia un nuovo lavoro, questo ci permette di eseguire la pulizia della memoria (il server mantiene la memoria dei lanci precedenti). Questo è necessario perché nella memoria vengono tenute tutte le variabili utilizzate ed il sistema non viene riavviato ogni volta che effettuiamo un comando. Con //kill (all)// andiamo a lavorare in un ambiente vergine.

- Possiamo definire noi stessi delle variabili standard, tipo :
  pippo : 3*pluto
In questo modo possiamo richiamare //pippo// ogni qual volta ci serve.

- Se ad un certo punto vogliamo eliminare la variabile definita, diamo il comando :
  kill ( pippo )
- Possiamo eseguire anche valutazioni concatenate, del tipo :

{{:wikitelaio2015:02.png?200|}}

La valutazione di una riga è un operazione implicita del Maxima, che processa ('valuta') ogni riga secondo le sue regole interne. Posso però chiedere di valutare una determinata espressione in un certo modo aggiungendo delle opzioni o delle ipotesi.

- Se dobbiamo eseguire più valutazioni concatenate possiamo dare il comando :
  ev ( ev ( ev (………..)));
- Esiste un alternativa per non scrivere più volte //ev// :
  ev ( pippo + 2 , infeval );
il comando //infeval//  va ad applicare tutte le valutazioni concatenate, questo comando pero può provocare un ciclo di valutazioni infinito se andiamo a definire due variabili allo stesso modo.
Si possono fare anche infinite valutazioni finché il programma non confronta due valori uguali e si ferma.
Tale comando è tanto comodo quanto pericoloso, infatti può capitare che Maxima si 'blocchi' poiché il programma continua ad effettuare valutazioni fino a che non trova due valutazioni successive uguali e nel caso queste non si trovino mai, il programma si inceppa.

- E’ possibile richiedere ulteriori valutazioni utilizzando l'opzione “//eval//” all’ interno di “//ev//” :
  ev ( pippo + 2 , eval );
//eval// = richiesta esplicita di una seconda valutazione (una valutazione in più).

**Definizione di una funzione e un espressione :**

- L’ operatore “:” definisce un espressione, l’operatore “:=” definisce una funzione.

- Definiamo un espressione :

{{:wikitelaio2015:03.jpg?200|}}

- Definiamo una funzione:

{{:wikitelaio2015:04.jpg?200|}}

Per valutare l’espressione è necessario richiamarla tramite il comando //ev// (prima l’espressione da richiamare e poi ”,” l’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 all’ atto della definizione, si usa il comando “//define//” al posto di “:=”.

{{:wikitelaio2015:05.jpg?200|}}

In questo modo alla variabile “a” è stata sostituito immediatamente il valore //pluto//, cosa che non avveniva con l’ operatore “:=”.

=====ESEMPIO:=====
**Programma che calcola i coefficienti della forma lineare degli spostamenti in un elemento TRIA3:**

{{:wikitelaio2015:06.jpg?200|}}

- lista [ ,  ,   ,] : è il comando che ci permette di implementare una serie di entità.
A differenza dell’array la sua dimensione non deve essere definita: gli elementi possono essere aggiunti in qualsiasi momento tramite il comando “append”.

{{:wikitelaio2015:07.jpg?200|}}

- Per l’estrazione dell’ i-esimo elemento della lista è sufficiente richiamare, nelle parentesi quadre, la posizione dell’elemento all’interno della stessa:

{{:wikitelaio2015:08.jpg?200|}}

- A partire dallo stesso concetto, è possibile sfruttare la sintassi vista per riassegnare il valore di una specifica posizione:

{{:wikitelaio2015:09.jpg?200|}}

- //linsolve// : è il comando per risolvere un sistema lineare di //n// equazioni in //m// incognite, da definire.

La sintassi generale del comando //linsolve// è **linsolve ([equazione 1,equazione 2,...,equazione N] , [variabile 1, variabile 2, ..., variabile M])**; ovvero si scrivono all'interno delle parentesi tonde prima la lista di equazioni lineari da risolvere separate da una virgola e poi la lista delle incognite.
Entrambe le liste vanno racchiuse tra parentesi quadre e separate da una virgola.

In alternativa si possono definire le liste in precedenza e utilizzare queste all'interno del comando //linsolve//.

Ad esempio:

  eqns : [equazione 1,equazione 2,...,equazione N];
  var : [variabile 1, variabile 2, ..., variabile M];
  linsolve ( eqns , var );
  
{{:wikitelaio2015:10.jpg?200|}}

- //globalsolve// : aggiungendo al comando //linsolve//, l’opzione: //globalsolve=true// , assegniamo automaticamente al parametro a<sub>i</sub> la sua soluzione.

{{:wikitelaio2015:11.jpg?200|}}

- Operazione di differenziazione : comando //diff// ( espressione da derivare, variabile di derivazione , ordine di derivazione ). 

Ad esempio: 

  diff ( sin(x)/x , x , 2 );
  deriva l'espressione due volte rispetto ad x 
  diff ( sin(x)/(x+y) , x , 1 , y , 1 ); 
  deriva l'espressione una volta in x e una volta in y. 

Se non si specifica l'ordine di derivazione si sottintende ordine 1. 

{{:wikitelaio2015:12.jpg?200|}}

- //coefmatrix// : permette di costruire una matrice tramite gli elementi di un vettore (lista), precedentemente definito.

{{:wikitelaio2015:13.jpg?200|}}

- //ratsubst// : sostituisce gli elementi indicati con un nuovo parametro fornito in input.

{{:wikitelaio2015:14.jpg?200|}}

{{:wikitelaio2015:16.jpg?200|}}


----
----

file postazione cattedra

{{:wikitelaio2015:matrice_b_tria3_.wxm|}}

{{:wikitelaio2015:primipassi.wxm|}}