GNU Octave

GNU Octave
software
Logo
Logo
GNU Octave in esecuzione su un sistema Linux
GNU Octave in esecuzione su un sistema Linux
GNU Octave in esecuzione su un sistema Linux
GenereAnalisi numerica
SviluppatoreJames B. Rawlings, John W. Eaton
Data prima versione1988
Ultima versione9.1.0 (14 marzo 2024)
Sistema operativoGNU
Multipiattaforma
LinguaggioC++
ToolkitQt
LicenzaGNU GPL v3+
(licenza libera)
LinguaMultilingua
Sito weboctave.org
Modifica dati su Wikidata · Manuale

GNU Octave è un'applicazione software per l'analisi numerica in gran parte[1] compatibile con MATLAB.

Ha un insieme di funzionalità fornite per il calcolo matriciale come rango e determinante o specialistiche come decomposizione ai valori singolari (SVD), fattorizzazione LU; sebbene consenta di trovare la soluzione numerica di sistemi lineari non svolge calcolo simbolico o altre attività tipiche di un sistema di algebra computazionale.

Storia[modifica | modifica wikitesto]

Il progetto fu concepito nel 1988 da John W. Eaton (primo manutentore) e da James B. Rawlings presso l'Università del Texas come strumento di calcolo per l'ingegneria chimica.

Il suo sviluppo vero e proprio partì da John W. Eaton nel 1992. La prima alpha pubblicata è datata 4 gennaio 1993 e il 17 febbraio 1994 fu distribuita la versione 1.0. La versione 3.0 è stata distribuita il 21 dicembre 2007.

Il linguaggio è così chiamato in onore di Octave Levenspiel (†2017), ingegnere chimico e professore alla Oregon State University, noto per la sua abilità nell'eseguire rapidi calcoli.

Dettagli tecnici[modifica | modifica wikitesto]

  • Octave è scritto in conformità dello standard POSIX nel linguaggio C++ usando le librerie Standard Template Library.
  • Octave utilizza un interprete per il suo linguaggio di scripting.
  • Octave è estendibile attraverso moduli o funzioni scritte dall'utente.
  • Octave può lavorare assieme a gnuplot e Grace per disegnare funzioni, grafici, tabelle, consentendo di salvarli o stamparli.

Octave, il linguaggio per scripting numerico[modifica | modifica wikitesto]

Il linguaggio di scripting di Octave supporta svariate librerie del C, e supporta inoltre diverse system calls e funzioni UNIX.

I programmi scritti con Octave sono degli script o liste di chiamate a funzioni. Il linguaggio dispone di diversi tipi di dati, oltre quello numerico esistono anche un tipo logico (true, false), uno di tipo stringa e strutture dati analoghe alle struct del linguaggio C. Esiste anche un altro tipo di dato molto potente ed è la matrice che consente molte operazioni di tipo matriciale. Il linguaggio di Octave non è un linguaggio orientato agli oggetti ma supporta le strutture dati, inoltre mette a disposizione varie strutture per il controllo del flusso, come i test logici if-else e switch ed i cicli while e do-until.

La sintassi è molto simile a quella di MATLAB, ed è possibile scrivere script che girano sia sotto Octave che su MATLAB.

Octave è distribuito sotto licenza GPL, e quindi può essere liberamente copiato e usato. Il programma gira sotto sistemi Unix e Linux, oltre che su Windows e macOS.

Funzionalità distintive[modifica | modifica wikitesto]

Completamento automatico dei comandi e dei nomi delle variabili[modifica | modifica wikitesto]

Digitare un carattere TAB nella riga di comando attiva in GNU Octave la ricerca di possibili completamenti della parte di comando già parzialmente digitata (in modo analogo al completamento automatico della shell Bash).

Command history[modifica | modifica wikitesto]

Quando avviato in modalità interattiva, GNU Octave salva i comandi già eseguiti in un buffer interno così che essi possono essere richiamati ed editati.

Strutture dati[modifica | modifica wikitesto]

GNU Octave include un limitato supporto per organizzare i dati in strutture. Ad esempio: 

octave:1> x.a = 1; x.b = [1, 2; 3, 4]; x.c = "stringa"; octave:2> x.a ans =  1 octave:3> x.b ans =     1   2    3   4  octave:4> x.c ans = stringa octave:5> x x = {   a =  1   b =       1   2      3   4    c = stringa }

Operatori booleani a corto circuito (short-circuit)[modifica | modifica wikitesto]

Gli operatori logici '&&' e '||' di GNU Octave sono valutati in modalità a corto circuito (come i corrispondenti operatori in linguaggio C), a differenza degli operatori '&' e '|', che agiscono elemento per elemento in vettori, matrici e array multi-dimensionali.

Operatori incremento e decremento[modifica | modifica wikitesto]

GNU Octave include gli operatori C-like di incremento '++' e decremento '--', sia nella loro forma prefissa che in quella suffissale.

Unwind-protect[modifica | modifica wikitesto]

GNU Octave supporta una forma basilare di gestione delle eccezioni, modellata sul costrutto unwind-protect del Lisp. La forma generale di un blocco unwind_protect ha questo aspetto: 

unwind_protect   body unwind_protect_cleanup   cleanup end_unwind_protect

Come regola generale, GNU Octave riconosce come terminazione di un dato blocco di codice 'block' sia la parola chiave 'end' (che è compatibile con il linguaggio MATLAB) che l'altra più specifica 'end_block'. Di conseguenza, un blocco 'unwind_protect' può essere terminato sia con la parola chiave 'end_unwind_protect' - come nell'esempio - sia in modo più portabile, con la parola chiave 'end'. Nell'esempio, la parte cleanup del blocco è sempre eseguita. In caso la parte body sollevasse un'eccezione, cleanup sarebbe eseguita immediatamente prima della propagazione dell'eccezione al di fuori del blocco 'unwind_protect'.

GNU Octave supporta anche un'altra forma di gestione delle eccezioni (compatibile con il linguaggio MATLAB): 

try    body catch    exception_handling end

Quest'ultima forma differisce da un blocco 'unwind_protect' per due motivi. Primo, la parte exception_handling viene eseguita soltanto nel caso in cui la parte body sollevi un'eccezione. In secondo luogo, dopo l'esecuzione di exception_handling, l'eccezione è considerata intercettata e gestita, e non viene propagata all'esterno del blocco (a meno che un comando 'rethrow( lasterror )' sia di proposito stato inserito all'interno del codice exception_handling).

Liste di argomenti di lunghezza variabile[modifica | modifica wikitesto]

GNU Octave ha un meccanismo efficace per gestire funzioni che devono ricevere un numero arbitrario (non noto a priori) di argomenti, senza un limite superiore. Per indicare una lista di zero o più argomenti entranti in una funzione, si usa lo speciale argomento varargin, posizionato come ultimo (o solo) argomento nella lista: 

function s = plus (varargin)    if (nargin==0)       s = 0;    else       s = varargin{1} + plus (varargin{2:nargin});    end end

Liste di ritorno di lunghezza variabile[modifica | modifica wikitesto]

Una funzione può essere implementata in modo che ritorni al codice chamante un qualsiasi numero di valori, usando come argomento di uscita la variabile speciale varargout. Ad esempio: 

function varargout = multiassign (data)    for k=1:nargout       varargout{k} = data(:,k);    end end

Integrazione con il linguaggio C++[modifica | modifica wikitesto]

È anche possibile eseguire codice GNU Octave direttamente all'interno di un programma C++. Per esempio, di seguito è riportato un frammento di codice che chiama la funzione rand([10,1]) da C++, facendola interpretare da GNU Octave: 

   #include <octave/oct.h>    ...    ColumnVector NumRands(2);    NumRands(0) = 10;    NumRands(1) = 1;    octave_value_list f_arg, f_ret;    f_arg(0) = octave_value(NumRands);    f_ret = feval("rand",f_arg,1);    Matrix unis(f_ret(0).matrix_value());

Compatibilità con il linguaggio MATLAB[modifica | modifica wikitesto]

GNU Octave è stato progettato avendo tra gli obiettivi la compatibilità con il linguaggio MATLAB, e infatti esso condivide con MATLAB molte funzionalità:

  1. Le matrici come tipi di dato fondamentali.
  2. Il supporto nativo per i numeri complessi.
  3. Potenti funzioni matematiche native e ampie librerie di funzioni.
  4. Estensibilità, che assume la forma di funzioni definite dall'utente.

Rispetto al linguaggio MATLAB, esiste di proposito un insieme ristretto di differenze :

  1. Le righe di commento possono essere prefisse sia con il carattere # che con il carattere % (quest'ultimo compatibile col linguaggio MATLAB).
  2. Sono supportati vari operatori basati sul linguaggio C: ++, --, +=, *=, /=.
  3. È possibile accedere agli elementi di variabili temporanee (vettori, matrici o array multi-dimensionali) senza dover creare nuove variabili, come ad esempio in [1:10](3).
  4. Le stringhe di testo possono essere definite sia con il carattere " che con il carattere ' (quest'ultimo compatibile col linguaggio MATLAB).

Note[modifica | modifica wikitesto]

  1. ^ About Octave, su gnu.org.

Voci correlate[modifica | modifica wikitesto]

Altri progetti[modifica | modifica wikitesto]

Collegamenti esterni[modifica | modifica wikitesto]

Controllo di autoritàVIAF (EN) 311460411 · LCCN (EN) n2014066619 · GND (DE) 102265487X · BNF (FR) cb17876808c (data) · J9U (EN, HE) 987009957423905171
Estratto da "https://it.wikipedia.org/w/index.php?title=GNU_Octave&oldid=137304558"