Lezione 14 — Equazioni differenziali: cinetica chimica con GNU Octave e GX-TXT
La velocità di una reazione chimica può essere descritta da una derivata. Quando più specie si trasformano contemporaneamente, il problema diventa un sistema di equazioni differenziali ordinarie (ODE). In questa lezione costruiamo un modello cinetico completo, lo risolviamo con GNU Octave, verifichiamo le leggi di conservazione e pubblichiamo i risultati come Dataset e grafici scientifici di GX-TXT.
Avvertenza sulla versione: nella release GX-TXT P008 usata per i test, la capacità ODE pubblica del framework presentava un problema nel trasporto dei callback. Gli script pubblicati eseguono perciò la soluzione con GNU Octave ode45; più avanti illustreremo l’API GX-TXT prevista, distinguendo il suo contratto documentato dal risultato sperimentale qui verificato.

Obiettivi
Al termine della lezione sapremo rappresentare un sistema di ODE mediante un vettore di stato, definire una funzione anonima Octave, integrare con ode45, impostare tolleranze numeriche, confrontare una soluzione numerica con una soluzione analitica, applicare un controllo di consistenza fisica e pubblicare risultati riproducibili mediante le API pubbliche di GX-TXT. Riutilizzeremo inoltre il debugger già introdotto nelle lezioni precedenti.
Che cosa sappiamo già e che cosa impariamo di nuovo
Nelle prime tredici lezioni abbiamo imparato a costruire script Octave, usare vettori e matrici, organizzare Dataset GX-TXT, pubblicare grafici persistenti e controllare gli errori. Nella Lezione 04 abbiamo persino simulato il raffreddamento con un metodo di Eulero; nella Lezione 11 abbiamo calcolato derivate e integrali di dati già disponibili. Il passo successivo è differente: partiamo da una legge che descrive una derivata e cerchiamo l’evoluzione temporale incognita.
La Lezione 12 ci ha fornito il linguaggio delle matrici per rappresentare più quantità accoppiate; la 13 ha mostrato che una stessa realtà può essere studiata in rappresentazioni diverse, come tempo e frequenza. Qui, invece, introduciamo un problema ai valori iniziali, un sistema dinamico e un solutore numerico adattivo. Le API GX-TXT per Dataset, pubblicazione e grafici sono strumenti già incontrati: le riprendiamo soltanto per mostrare come rendere riproducibile una simulazione di equazioni differenziali.
| Conoscenza precedente | Nuovo passo della Lezione 14 |
|---|---|
| Lezione 04: integrazione di Eulero per il raffreddamento | Integrazione adattiva di tre equazioni accoppiate con ode45 |
| Lezione 11: derivata/integrale da campioni | Ricostruzione della traiettoria a partire dalla legge differenziale |
| Lezione 12: algebra matriciale | Vettore di stato e contributi di produzione/consumo |
| Lezione 13: confronto di metodi e ricostruzione | Validazione fisica con bilancio di materia e soluzione analitica |
Esperimento: due reazioni consecutive
Consideriamo due trasformazioni irreversibili del primo ordine:
\[ A \xrightarrow{k_1} B \xrightarrow{k_2} C \]
Le velocità di reazione sono \(v_1=k_1[A]\) e \(v_2=k_2[B]\). Di conseguenza:
\[ \frac{d[A]}{dt}=-k_1[A],\qquad \frac{d[B]}{dt}=k_1[A]-k_2[B],\qquad \frac{d[C]}{dt}=k_2[B]. \]
Il primo termine fa diminuire A; B viene prodotto nella prima reazione e consumato nella seconda; C si accumula. Il segno meno davanti al consumo di B non è un dettaglio di sintassi: è una conseguenza fisica del meccanismo.
Assumiamo \(k_1=0{,}240\ \mathrm{min^{-1}}\), \(k_2=0{,}075\ \mathrm{min^{-1}}\) e le condizioni iniziali \([A](0)=2{,}000\ \mathrm{mmol/L}\), \([B](0)=[C](0)=0\). Studieremo l’intervallo da 0 a 40 minuti, campionato ogni 0,5 minuti: 81 istanti.
Che cosa si conserva? Poiché A, B e C rappresentano la stessa quantità di materia trasferita tra tre forme, senza afflusso o perdita e con stechiometria unitaria,
\[ [A](t)+[B](t)+[C](t)=[A](0)=2{,}000\ \mathrm{mmol/L}. \]
Questa uguaglianza consente un controllo indipendente dall’algoritmo numerico.
Dalle velocità di reazione alle equazioni
Una reazione del primo ordine ha velocità proporzionale alla concentrazione del reagente. Nel nostro caso, la trasformazione A → B ha velocità \(v_1=k_1 A\), mentre B → C ha velocità \(v_2=k_2 B\). A scompare soltanto nella prima reazione, B nasce nella prima e scompare nella seconda, C nasce soltanto nella seconda.
Possiamo tradurre queste regole in una matrice stechiometrica, riutilizzando le conoscenze di algebra lineare:
\[ \frac{d\mathbf y}{dt}= \underbrace{\begin{bmatrix}-1&0\\1&-1\\0&1\end{bmatrix}}_{S} \underbrace{\begin{bmatrix}k_1 A\\k_2 B\end{bmatrix}}_{\mathbf v}. \]
La somma degli elementi di ciascuna colonna di \(S\) è zero: ogni trasformazione sottrae materia a una specie e la aggiunge a un’altra. Sommando le tre equazioni si ottiene perciò \(\frac{d}{dt}(A+B+C)=0\). Questa è un’invariante del modello, non un risultato casuale del software. Il bilancio vale perché abbiamo adottato stechiometria unitaria e un sistema chiuso.
Le costanti cinetiche hanno unità \(\mathrm{min}^{-1}\), le concentrazioni \(\mathrm{mmol/L}\), e le loro derivate \(\mathrm{mmol\,L^{-1}\,min^{-1}}\). L’analisi dimensionale è un primo controllo del modello prima ancora di eseguire il codice.
Il vettore di stato in GNU Octave
Per risolvere un sistema accoppiato raccogliamo le concentrazioni in un vettore colonna:
\[ \mathbf y(t)= \begin{bmatrix} A(t)\\B(t)\\C(t)\end{bmatrix}, \qquad \frac{d\mathbf y}{dt}=f(t,\mathbf y). \]
In GNU Octave scriviamo:
k1 = 0.24;
k2 = 0.075;
initial_state = [2; 0; 0];
rhs = @(t,y) [-k1*y(1); k1*y(1)-k2*y(2); k2*y(2)];
I punti e virgola dentro le parentesi quadre producono un vettore colonna. Le espressioni y(1), y(2) e y(3) accedono rispettivamente alle tre concentrazioni. La sintassi @(t,y) crea una funzione anonima, cioè una funzione utilizzabile come argomento di un’altra funzione; in questo caso dipende dal tempo e dal vettore di stato. Anche se le nostre velocità non dipendono esplicitamente dal tempo, la firma richiesta dal solutore lo include.
Perché il solutore richiede una funzione anonima
L’espressione rhs = @(t,y) ... non calcola subito tutte le concentrazioni: definisce un function handle, una funzione che Octave potrà chiamare ripetutamente con un tempo e uno stato di prova. Le costanti k1 e k2 appartengono all’ambiente in cui la funzione viene definita; Octave ne conserva i valori necessari. Il nome rhs significa right-hand side, cioè membro destro dell’equazione differenziale.
Non inseriamo la soluzione analitica dentro questa funzione: descriviamo soltanto la velocità di variazione locale. Il compito di ode45 è ricostruire la traiettoria a partire da quella regola e dallo stato iniziale.
Risolvere il sistema con ode45
La funzione GNU Octave ode45 applica un metodo adattivo di Runge–Kutta per problemi non rigidi (non-stiff). Non calcola semplicemente un passo fisso di 0,5 minuti: modifica internamente la lunghezza dei passi per soddisfare le tolleranze richieste e restituisce la soluzione negli istanti richiesti.
time_min = (0:0.5:40)';
options = odeset('RelTol',1e-8, ...
'AbsTol',1e-10, ...
'MaxStep',0.25);
[solved_time, state] = ode45(rhs,time_min,initial_state,options);
odeset prepara le opzioni del solutore. RelTol controlla l’errore relativo, AbsTol quello assoluto e MaxStep limita il passo interno massimo. Sono impostazioni numeriche, non incertezze sperimentali. Il risultato state ha una riga per istante e tre colonne: A, B, C. Non basta constatare che il solutore termina senza errori: occorre verificare che il risultato sia plausibile.
Passi interni, tempi richiesti e tolleranze
È importante distinguere tre livelli. Il vettore time_min = (0:0.5:40)' indica gli 81 istanti nei quali vogliamo i risultati; non impone che il solutore integri con passi fissi da 0,5 min. Il metodo Runge–Kutta 4(5), usato da ode45, stima l’errore locale e sceglie passi interni più piccoli o più grandi. L’opzione MaxStep = 0.25 pone un limite superiore ai passi interni, non alla distanza fra righe dei risultati.
| Opzione | Significato didattico |
|---|---|
RelTol = 1e-8 | Obiettivo relativo sul controllo dell’errore locale |
AbsTol = 1e-10 | Scala assoluta sotto la quale un componente piccolo non può essere trattato solo in termini relativi |
MaxStep = 0.25 | Passo interno massimo consentito (nell’unità del tempo: minuti) |
Queste impostazioni influenzano accuratezza e costo del calcolo, ma non equivalgono all’incertezza delle concentrazioni misurate. ode45 è appropriato qui per un problema non rigido; con cinetiche che presentano scale temporali molto diverse può diventare opportuno valutare un solutore per problemi rigidi, come ode15s, dopo aver verificato disponibilità e comportamento nella propria installazione Octave.
La matrice state restituita contiene 81 righe e tre colonne. state(:,1) è la traiettoria di A, state(:,2) quella di B e state(:,3) quella di C. L’apostrofo dopo l’espressione temporale crea un vettore colonna; non va confuso con una derivata rispetto al tempo.

Nel grafico A diminuisce, C cresce e B mostra un massimo intermedio. È il comportamento atteso di una specie prodotta da una reazione e consumata da un’altra.
Una soluzione analitica come riferimento
Per \(k_1\ne k_2\), il sistema ammette una soluzione chiusa:
\[ A(t)=A_0e^{-k_1t}, \]
\[ B(t)=A_0\frac{k_1}{k_2-k_1} \left(e^{-k_1t}-e^{-k_2t}\right), \]
\[ C(t)=A_0-A(t)-B(t). \]
Nel primo script della lezione generiamo da queste formule tre Dataset di riferimento. Nel terzo li rileggiamo attraverso i loro Variable ID e confrontiamo, campione per campione, la soluzione ode45 con le formule.
Il tempo del massimo di B si calcola imponendo \(dB/dt=0\):
\[ t_{\max,B}=\frac{\ln(k_1/k_2)}{k_1-k_2}. \]
Con i parametri scelti è circa 7,05 minuti. La concentrazione al massimo è circa 1,18 mmol/L. Il massimo individuato sui campioni discreti può cadere a un istante leggermente diverso: il grafico viene campionato ogni mezzo minuto, mentre l’estremo analitico si trova tra due campioni.
Perché B ha un massimo
All’inizio B è assente, quindi il termine di produzione \(k_1A\) domina. Più tardi A si esaurisce e il termine di consumo \(k_2B\) prevale. Nel punto di massimo le due velocità sono uguali: \(k_1A=k_2B\). È un confronto tra velocità istantanee, non tra quantità totali.
La formula analitica fornisce circa 7,049399 min e 1,178736 mmol/L. Sul reticolo di uscita da mezzo minuto il massimo osservato cade invece vicino a 7,0 min. Questo scarto di posizione non prova un errore di integrazione: dipende dalla discretizzazione della lettura della curva e va distinto dall’errore del solutore.

Per effettuare una verifica quantitativa usiamo la norma dell’errore massimo: calcoliamo max(abs(state-reference)) su tutte le tre specie e tutti gli istanti. Nell’esecuzione della lezione lo scostamento è dell’ordine di \(10^{-10}\ \mathrm{mmol/L}\), molto inferiore alla soglia didattica di \(10^{-5}\ \mathrm{mmol/L}\).
Validazione numerica e validazione fisica
La prima verifica misura l’errore della soluzione numerica rispetto a una soluzione analitica indipendente. La seconda misura il residuo di una legge fisica: entrambe sono necessarie. Nel codice corretto formiamo una matrice model_difference = state - reference e la appiattiamo con model_difference(:) per trovare un solo massimo sull’intero insieme di 81 × 3 valori:
model_difference = state - reference;
maximum_reference_error = max(abs(model_difference(:)));
conservation_error = sum(state, 2) - initial_state(1);
maximum_conservation_error = max(abs(conservation_error));
Attenzione: max(abs(state-reference)) applicato direttamente a una matrice restituisce i massimi per colonna, non automaticamente un unico scalare. Il suffisso (:) è quindi un passaggio importante, non un abbellimento sintattico.
| Controllo | Risultato della lezione | Interpretazione |
|---|---|---|
| Scostamento massimo dalla soluzione analitica | ≈ 2,98 × 10−10 mmol/L | Integrazione numerica coerente con il riferimento |
| Massimo residuo di conservazione | ≈ 8,88 × 10−16 mmol/L | Concentrazione totale costante entro l’arrotondamento |
| Campioni restituiti | 81 | 0–40 min, intervallo di uscita 0,5 min |
Il residuo di conservazione non deve essere interpretato come una massa scomparsa misurata sperimentalmente: valori prossimi alla precisione di macchina riflettono l’aritmetica in virgola mobile.
Debugging: una reazione che crea materia dal nulla
Il secondo script contiene un errore progettato per essere individuato:
wrong_rhs = @(t,y) [-k1*y(1); ...
k1*y(1)+k2*y(2); ...
k2*y(2)];
Nel secondo componente abbiamo scritto +k2*y(2) invece di -k2*y(2). La sostanza B viene erroneamente prodotta anziché consumata nel secondo passaggio; C continua a formarsi. Il calcolo può produrre numeri finiti e una curva regolare, ma il modello è falso.
Calcoliamo il totale in ciascun istante:
total = sum(state,2);
maximum_conservation_error = ...
max(abs(total-initial_state(1)));
sum(state,2) somma le tre concentrazioni per riga. Se il totale cresce invece di restare costante, il bilancio di materia è violato. Lo script provoca allora un errore esplicito con identificatore GXTXT:Lesson14:MassConservation, così il Job è marcato come fallito per una ragione scientifica verificabile.
Avviamo il debugger dal menu Run → Debug Session script, collochiamo un breakpoint prima della stampa del bilancio e controlliamo la variabile maximum_conservation_error nell’elenco delle variabili. Usiamo Continue per proseguire fino al controllo che genera l’errore. Nella prova il modello scorretto produce una concentrazione totale finale di circa 59,21 mmol/L, invece di 2,00: una contraddizione fisica evidente.
Individuare il segno errato passo dopo passo
- Eseguire prima lo script di preparazione: il debugger avrà così il Dataset temporale di riferimento da leggere con le API pubbliche.
- Aprire
L14_01_Debug_Wrong_ODE_Sign.mnello Script Workspace e avviare Run → Debug Session script. - Collocare il breakpoint immediatamente prima della valutazione del bilancio e osservare
state,total,maximum_conservation_erroreinitial_state. - Confrontare nella funzione anonima il termine di produzione di B con il termine di consumo: il segno del contributo
k2*y(2)è l’unico elemento intenzionalmente errato. - Proseguire fino all’errore
GXTXT:Lesson14:MassConservation. Il risultato FAILED è atteso in questa esercitazione; non indica un guasto del framework.
Il modello scorretto arriva a circa 59,213129 mmol/L di concentrazione totale, partendo da 2 mmol/L. Il fatto che ode45 abbia restituito una soluzione regolare non rende corretta la fisica: il solutore risolve le equazioni che abbiamo scritto, non quelle che avremmo voluto scrivere.


Pubblicare risultati canonici dentro GX-TXT
Le routine Octave operano sui numeri; i servizi GX-TXT attribuiscono ai dati identità, unità e provenienza scientifica. La distinzione è fondamentale: uno script non deve aprire o modificare direttamente gli archivi interni della Session.
CANONICAL_DATASET_API_v2 serve a scoprire e leggere i Dataset. Utilizziamo list per verificare la presenza dei Dataset e read_range per recuperare le colonne per Variable ID, con un intervallo di righe esplicito. L’identificativo concentration_mmol_L rappresenta la colonna fisica, indipendentemente dal titolo visualizzato nell’interfaccia.
data = gxtxt_api_call('CANONICAL_DATASET_API_v2', ...
'read_range', ...
{'lesson14_reference_b', ...
{'time_min','concentration_mmol_L'},0,81});
reference_b = data.concentration_mmol_L.values(:);
DATASET_PUBLICATION_API_v2 crea Dataset canonici da valori e dichiarazioni di variabili. Usiamo publish_series_batch, che pubblica un insieme coerente di serie come una singola operazione atomica. I metadati dichiarano unità, metodo, modello, parametri, natura sintetica e provenienza. Gli output vengono poi riletti e verificati, senza presumere che una chiamata riuscita garantisca da sola la correttezza dei valori.
PLOT_DATASET_API_v4 crea rappresentazioni persistenti a partire dai Dataset pubblicati. Il ciclo è new_spec (creazione di uno schema di grafico), validate_spec (validazione della struttura), upsert_plot (registrazione o aggiornamento), render (rappresentazione) e artifacts (riferimenti agli output). Le curve sono associate a Dataset ID e Variable ID: non creiamo immagini scollegate dai dati.
La terza rappresentazione illustra l’errore \(A+B+C-A_0\), che rimane prossimo allo zero nella simulazione corretta.

Cosa fanno le API pubbliche in questo esperimento
Queste API non sono novità assolute del corso. Qui, però, hanno una funzione scientifica precisa: separare calcolo, identità del dato e sua rappresentazione. Il solutore ode45 e odeset appartengono a GNU Octave; non sono chiamate GX-TXT.
| API e operazione | Scopo e controllo |
|---|---|
gxtxt_api_require({...}) | Verifica prima del calcolo che gli ID delle API necessarie siano registrati nel Script Bridge |
gxtxt_api_has_operation(id, op) | Verifica che l’operazione richiesta sia effettivamente disponibile |
CANONICAL_DATASET_API_v2 / list | Controlla l’esistenza dei Dataset di riferimento o possibili collisioni degli ID |
CANONICAL_DATASET_API_v2 / read_range | Legge tempi e concentrazioni per Variable ID e intervallo di righe, senza aprire archivi privati |
DATASET_PUBLICATION_API_v2 / publish_series_batch | Pubblica più serie con unità e provenienza in un’operazione atomica, poi verifica receipt.atomic e receipt.output_count |
PLOT_DATASET_API_v4 / new_spec, validate_spec, upsert_plot, render, artifacts | Definisce, controlla, registra e visualizza grafici persistenti che puntano agli ID dei Dataset e delle variabili |
La chiamata a gxtxt_api_call usa tre argomenti: identificatore dell’API, nome dell’operazione e cell array di argomenti posizionali. Per esempio, {'lesson14_reference_b', {'time_min','concentration_mmol_L'}, 0, 81} chiede di leggere 81 righe del Dataset della specie B, selezionando due variabili. Il controllo delle dimensioni, degli istanti crescenti e delle unità previene confronti numerici non significativi.
Risolvere le ODE tramite l’API pubblica GX-TXT: il percorso previsto
Finora abbiamo integrato il sistema con ode45, una funzione nativa di GNU Octave. GX-TXT mette a disposizione anche l’interfaccia pubblica NUMERIC_API_v1, che espone la famiglia ode e l’operazione solve attraverso lo Script Bridge. È importante conoscere entrambe le possibilità: la prima permette di studiare direttamente il linguaggio, la seconda consente di utilizzare il servizio numerico del framework mantenendo un contratto API comune ai linguaggi supportati.
Nota di compatibilità, riferita alla versione usata per questa lezione. Nei test del 14 novembre 2026 con GX-TXT DEV112 Release 2 P008, la chiamata ODE attraverso un callback registrato non ha completato il Job: il Bridge ha restituito GXTXT:ScriptBridge:Transport e BrokenPipeError durante il rilascio del callback. Per questa ragione i tre script eseguibili distribuiti qui impiegano ode45 e odeset, che sono stati effettivamente verificati. Il seguente esempio illustra invece il contratto API pubblico documentato su GitHub, ma non è presentato come codice testato con successo in P008. Il problema potrebbe essere stato corretto in versioni successive: chi riproduce l’esperimento deve verificare la versione installata.
Le funzioni e il loro ruolo
| Funzione / operazione pubblica | Perché serve |
|---|---|
gxtxt_api_require({'NUMERIC_API_v1'}) | Richiede al Bridge la presenza del servizio numerico prima dell’esecuzione. |
gxtxt_api_has_operation('NUMERIC_API_v1','foundation') | Verifica la disponibilità del punto d’accesso alle operazioni numeriche di base. |
gxtxt_callback_register(rhs) | Registra una funzione GNU Octave che calcola le derivate dello stato; restituisce un handle opaco, valido nell’esecuzione corrente. |
gxtxt_api_call('NUMERIC_API_v1','foundation',args) | Invoca ode/solve passando il callback, la griglia temporale, lo stato iniziale e le opzioni numeriche. |
gxtxt_callback_release(handle) | Libera il callback registrato al termine dell’operazione, secondo il contratto di ciclo di vita del Bridge. |
La funzione delle derivate rhs(t,y) restituisce un vettore di tre componenti, una per ciascuna concentrazione. Il Bridge non trasferisce il codice sorgente della funzione a un interprete esterno: usa un identificatore opaco e richiama la funzione nel runtime Octave che ha avviato lo script. Il percorso con callback del provider numerico utilizza SciPy per l’integrazione; ciò non va confuso con l’esecuzione diretta di ode45 in Octave.
Esempio didattico del contratto pubblico
Questo frammento mostra come si dovrebbe invocare il servizio una volta verificata la correzione del problema nella propria versione GX-TXT. I commenti all’interno del codice sono in inglese, come in tutti gli script del corso. Non sostituisce gli script integrali verificati riportati in fondo all’articolo.
% GX-TXT public ODE example: documented interface, not tested in P008.
numeric_api = 'NUMERIC_API_v1';
gxtxt_api_require({numeric_api});
assert(gxtxt_api_has_operation(numeric_api, 'foundation'));
k1 = 0.24;
k2 = 0.075;
time_min = (0:0.5:40)';
initial_state = [2; 0; 0];
rhs = @(t,y) [-k1*y(1); k1*y(1)-k2*y(2); k2*y(2)];
callback = gxtxt_callback_register(rhs);
try
solution = gxtxt_api_call(numeric_api, 'foundation', ...
{'ode', 'solve', callback, time_min, initial_state, ...
struct('reltol', 1e-8, 'abstol', 1e-10, 'max_step', 0.25)});
catch original_error
% Preserve the initial failure if callback cleanup also fails.
try
gxtxt_callback_release(callback);
catch cleanup_error
fprintf(2, 'Callback cleanup failed: %s\n', cleanup_error.message);
end_try_catch
rethrow(original_error);
end_try_catch
gxtxt_callback_release(callback);
% Inspect the documented result structure before using its numeric fields.
disp(solution);
Gli argomenti posizionali del cell array sono, nell’ordine: 'ode' (famiglia numerica), 'solve' (azione), handle del callback, tempi richiesti, vettore delle condizioni iniziali e struttura delle opzioni. reltol è la tolleranza relativa, abstol quella assoluta e max_step limita il passo temporale interno. Non sono stime dell’incertezza sperimentale. Il contratto prevede informazioni sui tempi, sullo stato calcolato, sul numero di valori restituiti e sugli esiti di successo/annullamento; forma e campi del risultato vanno controllati nella release effettivamente utilizzata prima di pubblicare i dati.
Il blocco try/catch ha anche uno scopo didattico: un errore durante gxtxt_callback_release non deve cancellare la diagnostica dell’eventuale errore numerico originale. Non si devono effettuare chiamate Bridge annidate all’interno della funzione rhs: il Bridge attende che il callback restituisca il vettore delle derivate per proseguire l’operazione in corso.
Come verificare la correzione nelle release successive
Quando la propria installazione supporta correttamente questo percorso, si può iniziare dall’esempio minimo a una variabile della documentazione y'=-2y, poi ripetere il modello a tre specie. Prima di sostituire ode45 nello script principale occorre confrontare le curve con la soluzione analitica, verificare A+B+C=2 mmol/L entro la tolleranza numerica scelta e controllare che il rilascio del callback avvenga senza errori sia in esecuzione normale sia tramite debugger.
Documentazione pubblica, riferita al commit della lezione: Script Callback API v1, Octave Script Bridge API v1 e Numeric API v1.
Quali risultati persistenti vengono creati
Lo script 00 pubblica tre Dataset analitici: lesson14_reference_a, lesson14_reference_b, lesson14_reference_c. Lo script corretto pubblica cinque Dataset derivati: lesson14_ode_a, lesson14_ode_b, lesson14_ode_c, lesson14_mass_balance e lesson14_b_absolute_error. Oltre alle tre concentrazioni, conserviamo dunque il residuo del bilancio e l’errore assoluto dell’intermedio B.
La pubblicazione in batch non sostituisce la verifica: ciascuna serie viene riletta tramite read_range e confrontata con i valori originari. Tre Plot Dataset persistenti visualizzano la cinetica completa, il confronto B analitica/numerica e il residuo di conservazione. Le variabili temporali hanno unità min, quelle di concentrazione e di errore mmol/L. Non è necessario generare immagini autonome con comandi di plotting esterni a GX-TXT.
Tre script, tre scopi
| Script | Contenuto | Risultato |
|---|---|---|
L14_00_Prepare_Analytical_Reference.m |
Formula analitica e pubblicazione atomica | 3 Dataset di riferimento |
L14_01_Debug_Wrong_ODE_Sign.m |
Errore di segno, debugger e bilancio di massa | Job intenzionalmente fallito, nessun Dataset |
L14_02_Kinetics_ODE_Correct.m |
Integrazione ode45, verifica, pubblicazione e grafici |
5 Dataset derivati e 3 Plot Dataset |
I tre script vanno importati nello Script Workspace Octave di GX-TXT e salvati con identificativi distinti. Si esegue prima lo script 00, poi lo script 01 in modalità Debug, infine lo script 02. Il secondo script fallisce per progetto: è la condizione che consente di correggere una legge fisica errata. Per ripetere l’intero esperimento senza collisioni di Dataset, si crea una nuova Session.

Come riprodurre la lezione in GX-TXT
- Creare una nuova Session nella versione GX-TXT indicata nei riferimenti finali e aprire l’Octave Script Workspace.
- Importare e salvare i tre file
.mcon nomi/ID distinti, mantenendo il codice originale. - Eseguire
L14_00_Prepare_Analytical_Reference.m. Controllare la conferma di tre Dataset pubblicati. - Avviare in modalità Debug
L14_01_Debug_Wrong_ODE_Sign.me osservare il fallimento scientifico programmato. - Eseguire
L14_02_Kinetics_ODE_Correct.m. Verificare la comparsa dei cinque Dataset e dei tre grafici nell’interfaccia di GX-TXT. - Aprire i Plot Dataset per confrontare le concentrazioni, verificare la sovrapposizione delle curve B e osservare un residuo totale prossimo allo zero.
Per ripetere integralmente l’esperimento senza riutilizzare gli stessi ID, avviare una nuova Session. Gli script non scrivono direttamente nel filesystem interno di GX-TXT e non richiedono modifiche al CORE.
Interpretazione e limiti del modello
Questi dati sono sintetici, generati da una legge cinetica specificata. Le costanti sono assunte note, non ricavate da misure. Non stiamo stimando incertezze, intervalli di confidenza o parametri da un esperimento: ciò richiederebbe un modello di rumore e procedure di fitting dedicate. Il controllo del bilancio verifica la coerenza interna di questo modello; non dimostra da solo che un meccanismo chimico sia corretto per una reazione reale.
Un controllo utile è rifare il calcolo aumentando RelTol (riducendo così la precisione richiesta) e confrontare gli scostamenti; un altro è cambiare \(k_2\) e osservare quando si sposta il massimo dell’intermedio.
Esercizi
- Modificare la velocità \(k_2\) e confrontare il tempo del massimo di B con l’espressione analitica.
- Impostare \([B](0)>0\): in questo caso occorre ricalcolare la soluzione analitica, che non coincide più con quella proposta per le condizioni iniziali originarie.
- Risolvere il problema con tolleranze più larghe e confrontare l’errore massimo sullo stesso reticolo di tempi.
- Simulare un sistema con perdita della specie C e spiegare perché \(A+B+C\) non è più una quantità conservata nel modello modificato.
- Discutere perché le unità di \(k_1\) e \(k_2\) sono inverse del tempo e perché le derivate di concentrazione hanno unità \(\mathrm{mmol\,L^{-1}\,min^{-1}}\).
Versione GX-TXT e sorgenti
La lezione è stata eseguita con GX-TXT 0.9.8.10-dev-112 Release 2 P008 (riferimento congelato per la riproducibilità della lezione, verifica del 14 novembre 2026), commit 17ff2a7f93de0612015a873e626f87dbeb56b6a2. Le operazioni GX-TXT impiegate sono pubbliche e descritte nei contratti GitHub:
Il solutore ode45 e odeset sono funzioni native GNU Octave, non operazioni GX-TXT. Nella release P008 il percorso NUMERIC_API_v1 / foundation / ode/solve con callback registrato non ha superato i test, quindi gli script distribuiti impiegano il metodo Octave effettivamente collaudato; ogni accesso ai Dataset e ai grafici passa esclusivamente attraverso API pubbliche GX-TXT. La sezione dedicata al solutore pubblico presenta documentazione e codice illustrativo non ancora verificato, separati dai risultati della simulazione realmente eseguita.
Materiali
I tre sorgenti GNU Octave sono disponibili in fondo all’articolo in riquadri espandibili. Tutti i commenti degli script sono in inglese, mentre le spiegazioni didattiche sono in italiano. I risultati numerici e i grafici si possono rigenerare dentro una nuova Session GX-TXT utilizzando gli stessi parametri.
Script GNU Octave completi
Apri i riquadri per consultare o copiare i sorgenti completi. Tutti i commenti del codice sono in inglese.
00 — L14_00_Prepare_Analytical_Reference.m
% Lesson 14 - Publish analytical reference kinetics for A -> B -> C.
% Course: GNU Octave with GX-TXT | DEV112 Release 2 + P008
% Source commit: 17ff2a7f93de0612015a873e626f87dbeb56b6a2
% SPDX-License-Identifier: GPL-3.0-or-later
%
% Run once in a fresh managed GX-TXT Session.
% These are deterministic reference profiles, not measured concentrations.
dataset_api = 'CANONICAL_DATASET_API_v2';
publication_api = 'DATASET_PUBLICATION_API_v2';
gxtxt_api_require({dataset_api, publication_api});
assert(gxtxt_api_has_operation(dataset_api, 'list'));
assert(gxtxt_api_has_operation(dataset_api, 'read_range'));
assert(gxtxt_api_has_operation(publication_api, 'publish_series_batch'));
k1_per_min = 0.24;
k2_per_min = 0.075;
initial_concentration = 2.0;
time_min = (0:0.5:40)';
n = numel(time_min);
% Closed-form solution of two consecutive first-order reactions.
reference_a = initial_concentration * exp(-k1_per_min * time_min);
reference_b = initial_concentration * k1_per_min / ...
(k2_per_min - k1_per_min) .* ...
(exp(-k1_per_min * time_min) - exp(-k2_per_min * time_min));
reference_c = initial_concentration - reference_a - reference_b;
assert(all(reference_a >= 0) && all(reference_b >= 0));
assert(all(reference_c > -1e-12));
assert(max(abs(reference_a + reference_b + reference_c - ...
initial_concentration)) < 1e-12);
dataset_ids = {'lesson14_reference_a', ...
'lesson14_reference_b', 'lesson14_reference_c'};
existing_ids = gxtxt_api_call(dataset_api, 'list', {});
for i = 1:numel(dataset_ids)
if any(strcmp(existing_ids, dataset_ids{i}))
error('Reference Dataset already exists: %s. Start a new Session.', ...
dataset_ids{i});
endif
endfor
time_variable = struct('variable_id', 'time_min', ...
'name', 'time_min', 'display_label', 'Reaction time', ...
'unit', 'min', 'dtype', 'float64', 'value_kind', 'number', ...
'semantic_source', 'generator');
concentration_variable = struct('variable_id', 'concentration_mmol_L', ...
'name', 'concentration_mmol_L', 'display_label', 'Concentration', ...
'unit', 'mmol/L', 'dtype', 'float64', 'value_kind', 'number', ...
'semantic_source', 'generator');
values = {reference_a, reference_b, reference_c};
species = {'A', 'B', 'C'};
series = cell(1, 3);
for i = 1:3
meta = struct();
meta.('kinetics.synthetic') = true;
meta.('kinetics.reaction') = 'A -> B -> C';
meta.('kinetics.k1_per_min') = k1_per_min;
meta.('kinetics.k2_per_min') = k2_per_min;
meta.('kinetics.initial_mmol_L') = initial_concentration;
meta.('kinetics.species') = species{i};
meta.('kinetics.method') = 'analytical_reference';
series{i} = struct('dataset_id', dataset_ids{i}, ...
'contract', 'table.generic', 'storage', 'auto', ...
'x_values', time_min, 'y_values', values{i}, ...
'x_variable', time_variable, 'y_variable', concentration_variable, ...
'source', 'GX-TXT GNU Octave Lesson 14', ...
'producer_version', '1.0.0', ...
'provenance', 'Deterministic analytical consecutive reaction model', ...
'notes', ['Analytical reference concentration for species ', species{i}], ...
'structured_metadata', meta);
endfor
receipt = gxtxt_api_call(publication_api, 'publish_series_batch', ...
{struct('series', {series})});
if !receipt.atomic || receipt.output_count != 3
error('Atomic publication did not confirm three reference Datasets.');
endif
for i = 1:3
saved = gxtxt_api_call(dataset_api, 'read_range', ...
{dataset_ids{i}, {'time_min','concentration_mmol_L'}, 0, n});
assert(max(abs(saved.time_min.values(:) - time_min)) < 1e-12);
assert(max(abs(saved.concentration_mmol_L.values(:) - values{i})) < 1e-10);
endfor
peak_time_min = log(k1_per_min / k2_per_min) / ...
(k1_per_min - k2_per_min);
peak_b_mmol_L = initial_concentration * k1_per_min / ...
(k2_per_min - k1_per_min) * ...
(exp(-k1_per_min * peak_time_min) - ...
exp(-k2_per_min * peak_time_min));
fprintf('PASS: 3 analytical reference Datasets published.\n');
fprintf('k1 = %.3f min^-1, k2 = %.3f min^-1, initial = %.3f mmol/L.\n', ...
k1_per_min, k2_per_min, initial_concentration);
fprintf('Analytical B peak: t = %.6f min, B = %.6f mmol/L.\n', ...
peak_time_min, peak_b_mmol_L);
01 — L14_01_Debug_Wrong_ODE_Sign.m
% Lesson 14 - Debug a deliberately wrong sign in a kinetic ODE.
% Course: GNU Octave with GX-TXT | DEV112 Release 2 + P008
% Source commit: 17ff2a7f93de0612015a873e626f87dbeb56b6a2
% SPDX-License-Identifier: GPL-3.0-or-later
%
% Run after L14_00. Set a native debugger breakpoint near BREAKPOINT.
% An unphysical creation of matter MUST be detected as an expected failure.
% This script publishes no Dataset and no Plot Dataset.
dataset_api = 'CANONICAL_DATASET_API_v2';
gxtxt_api_require({dataset_api});
assert(gxtxt_api_has_operation(dataset_api, 'read_range'));
reference = gxtxt_api_call(dataset_api, 'read_range', ...
{'lesson14_reference_a', {'time_min'}, 0, 81});
time_min = reference.time_min.values(:);
assert(numel(time_min) == 81 && all(diff(time_min) > 0));
k1 = 0.24;
k2 = 0.075;
initial_state = [2;0;0];
% INTENTIONAL ERROR: B incorrectly gains +k2*B instead of losing k2*B.
% The C product still gains k2*B, so the total concentration increases.
wrong_rhs = @(t,y) [-k1*y(1); k1*y(1) + k2*y(2); k2*y(2)];
% GNU Octave ode45 integrates the intentionally incorrect ODE.
% All GX-TXT access continues exclusively through its public APIs.
ode_options = odeset('RelTol', 1e-8, 'AbsTol', 1e-10, 'MaxStep', 0.25);
[solved_time, state_native] = ode45(wrong_rhs, time_min, initial_state, ...
ode_options);
solution = struct('time', solved_time, 'state_real', state_native, ...
'success', true, 'output_count', numel(solved_time));
state = solution.state_real;
if !solution.success || rows(state) != 81 || columns(state) != 3
error('The GNU Octave ODE solver returned an unexpected result.');
endif
total = sum(state, 2);
maximum_conservation_error = max(abs(total - initial_state(1)));
% BREAKPOINT: inspect wrong_rhs, state, total,
% maximum_conservation_error, and initial_state.
fprintf('Final total = %.6f mmol/L; initial total = %.6f mmol/L.\n', ...
total(end), initial_state(1));
fprintf('Maximum mass-balance error = %.6f mmol/L.\n', ...
maximum_conservation_error);
% Expected FAILED Job: the flawed chemical model violates conservation.
if maximum_conservation_error > 1e-5
error('GXTXT:Lesson14:MassConservation', ...
'Conservation failed. Inspect the sign of the B consumption term.');
endif
error('Unexpected success: the intentional reaction-balance error escaped.');
02 — L14_02_Kinetics_ODE_Correct.m
% Lesson 14 - Solve kinetics with Octave ode45 and public GX-TXT Dataset/Plot APIs.
% Course: GNU Octave with GX-TXT | DEV112 Release 2 + P008
% GitHub release: https://github.com/giuxlab-hub/GX-TXT/releases/tag/v0.9.8.10-dev-112-r2-p008
% Pinned source: 17ff2a7f93de0612015a873e626f87dbeb56b6a2
% SPDX-License-Identifier: GPL-3.0-or-later
%
% Run after L14_00 in the same fresh managed GX-TXT Session.
% ODE integration uses GNU Octave ode45 (native numerical language API).
% Publication and plots use public Session-bound GX-TXT APIs only.
dataset_api = 'CANONICAL_DATASET_API_v2';
publication_api = 'DATASET_PUBLICATION_API_v2';
plot_api = 'PLOT_DATASET_API_v4';
gxtxt_api_require({dataset_api, publication_api, plot_api});
required = {
dataset_api, 'list'; dataset_api, 'read_range';
publication_api, 'publish_series_batch';
plot_api, 'new_spec'; plot_api, 'validate_spec';
plot_api, 'upsert_plot'; plot_api, 'render'; plot_api, 'artifacts'
};
for k = 1:rows(required)
if !gxtxt_api_has_operation(required{k,1}, required{k,2})
error('Missing public GX-TXT operation: %s/%s.', ...
required{k,1}, required{k,2});
endif
endfor
% Read each analytical reference through canonical Dataset and Variable IDs.
source_ids = {'lesson14_reference_a', ...
'lesson14_reference_b', 'lesson14_reference_c'};
existing_ids = gxtxt_api_call(dataset_api, 'list', {});
n = 81;
time_min = [];
reference = zeros(n, 3);
for i = 1:3
if !any(strcmp(existing_ids, source_ids{i}))
error('Missing source Dataset %s. Execute L14_00 first.', source_ids{i});
endif
data = gxtxt_api_call(dataset_api, 'read_range', ...
{source_ids{i}, {'time_min','concentration_mmol_L'}, 0, n});
current_time = data.time_min.values(:);
if numel(current_time) != n || any(diff(current_time) <= 0)
error('Invalid strictly increasing time grid in source %s.', source_ids{i});
endif
if i == 1
time_min = current_time;
elseif max(abs(time_min - current_time)) > 1e-12
error('Reference Datasets have incompatible time coordinates.');
endif
reference(:,i) = data.concentration_mmol_L.values(:);
endfor
% Define a coupled system dY/dt = F(t,Y) in physical concentration units.
% Reaction 1: A -> B, rate k1*A. Reaction 2: B -> C, rate k2*B.
k1 = 0.24;
k2 = 0.075;
initial_state = [2;0;0];
rhs = @(t,y) [-k1*y(1); k1*y(1) - k2*y(2); k2*y(2)];
% The ODE solver is GNU Octave's documented adaptive Runge-Kutta ode45.
% GX-TXT Dataset and Plot operations continue via public Script Bridge APIs.
ode_options = odeset('RelTol',1e-8,'AbsTol',1e-10,'MaxStep',0.25);
[solved_time_native, state_native] = ode45(rhs,time_min,initial_state, ...
ode_options);
solution = struct('time',solved_time_native,'state_real',state_native, ...
'success',true,'cancelled',false, ...
'output_count',numel(solved_time_native),'method','ode45');
if !solution.success || solution.cancelled || ...
solution.output_count != n
error('The GNU Octave ODE solve did not complete on the requested time grid.');
endif
solved_time = solution.time(:);
state = solution.state_real;
if rows(state) != n || columns(state) != 3 || ...
max(abs(solved_time - time_min)) > 1e-10 || ...
any(!isfinite(state(:)))
error('The ODE result does not match the source time and state dimensions.');
endif
% Independent scientific checks: reference solution and conserved total.
total = sum(state, 2);
conservation_error = total - initial_state(1);
model_difference = state - reference;
maximum_reference_error = max(abs(model_difference(:)));
maximum_conservation_error = max(abs(conservation_error));
minimum_state = min(state(:));
if minimum_state < -1e-9
error('The calculated concentrations are negative beyond tolerance.');
endif
if maximum_reference_error > 1e-5
error('Numerical solution differs from the analytical reference.');
endif
if maximum_conservation_error > 1e-6
error('Reaction mass balance is not conserved.');
endif
% The intermediate B concentration has an exactly known peak time.
analytical_peak_time = log(k1/k2)/(k1-k2);
analytical_peak_b = initial_state(1)*k1/(k2-k1) * ...
(exp(-k1*analytical_peak_time)-exp(-k2*analytical_peak_time));
[observed_peak_b,peak_index] = max(state(:,2));
sampled_peak_time = time_min(peak_index);
if abs(sampled_peak_time - analytical_peak_time) > 0.26
error('The sampled intermediate peak does not match the kinetic model.');
endif
fprintf('ODE solver method: %s; output times: %d.\n', ...
solution.method, solution.output_count);
fprintf('B peak: analytical t = %.6f min, sampled t = %.6f min.\n', ...
analytical_peak_time, sampled_peak_time);
fprintf('Analytical B peak %.6f; sampled B peak %.6f mmol/L.\n', ...
analytical_peak_b, observed_peak_b);
fprintf('Maximum reference error = %.3g mmol/L.\n', maximum_reference_error);
fprintf('Maximum mass-balance error = %.3g mmol/L.\n', ...
maximum_conservation_error);
% Publish the three computed species plus two diagnostic series atomically.
derived_ids = {'lesson14_ode_a','lesson14_ode_b', 'lesson14_ode_c', ...
'lesson14_mass_balance', 'lesson14_b_absolute_error'};
for i = 1:numel(derived_ids)
if any(strcmp(existing_ids, derived_ids{i}))
error('Derived Dataset already exists: %s. Use a fresh Session.', ...
derived_ids{i});
endif
endfor
time_variable = struct('variable_id', 'time_min', ...
'name', 'time_min', 'display_label', 'Reaction time', ...
'unit', 'min', 'dtype', 'float64', 'value_kind', 'number', ...
'semantic_source', 'plugin');
concentration_variable = struct('variable_id', 'concentration_mmol_L', ...
'name', 'concentration_mmol_L', 'display_label', 'Concentration', ...
'unit', 'mmol/L', 'dtype', 'float64', 'value_kind', 'number', ...
'semantic_source', 'plugin');
mass_variable = struct('variable_id', 'mass_balance_error_mmol_L', ...
'name', 'mass_balance_error_mmol_L', ...
'display_label', 'Mass balance error', ...
'unit', 'mmol/L', 'dtype', 'float64', 'value_kind', 'number', ...
'semantic_source', 'plugin');
difference_variable = struct('variable_id', 'abs_error_mmol_L', ...
'name', 'abs_error_mmol_L', 'display_label', 'Absolute B error', ...
'unit', 'mmol/L', 'dtype', 'float64', 'value_kind', 'number', ...
'semantic_source', 'plugin');
values = {state(:,1),state(:,2),state(:,3), ...
conservation_error,abs(model_difference(:,2))};
variable_defs = {concentration_variable,concentration_variable, ...
concentration_variable,mass_variable,difference_variable};
descriptions = {'ODE simulated A','ODE simulated B','ODE simulated C', ...
'Conservation residual A + B + C - total initial', ...
'Absolute ODE-minus-analytical error for B'};
series = cell(1,numel(derived_ids));
for i = 1:numel(derived_ids)
meta = struct();
meta.('kinetics.synthetic') = true;
meta.('kinetics.model') = 'consecutive_first_order';
meta.('kinetics.k1_per_min') = k1;
meta.('kinetics.k2_per_min') = k2;
meta.('kinetics.solver') = solution.method;
meta.('kinetics.initial_mmol_L') = initial_state(1);
meta.('kinetics.method') = descriptions{i};
series{i} = struct('dataset_id',derived_ids{i}, ...
'contract','table.generic','storage','auto', ...
'x_values',time_min,'y_values',values{i}, ...
'x_variable',time_variable,'y_variable',variable_defs{i}, ...
'source','GX-TXT GNU Octave Lesson 14', ...
'producer_version','1.0.0', ...
'source_dataset_ids',{source_ids}, ...
'provenance','GNU Octave ode45 with public GX-TXT Dataset services', ...
'notes',descriptions{i},'structured_metadata',meta);
endfor
receipt = gxtxt_api_call(publication_api,'publish_series_batch', ...
{struct('series',{series})});
if !receipt.atomic || receipt.output_count != numel(derived_ids)
error('Atomic publication did not confirm five output Datasets.');
endif
for i = 1:numel(derived_ids)
data = gxtxt_api_call(dataset_api, 'read_range', ...
{derived_ids{i},{'time_min',variable_defs{i}.variable_id},0,n});
actual = data.(variable_defs{i}.variable_id).values(:);
if numel(actual) != n || max(abs(actual-values{i})) > 1e-9
error('Published numerical data failed read-back verification.');
endif
endfor
% Three persistent Plot Dataset v4 graphs refer to canonical variable IDs.
plot_definitions = {
'lesson14_species_kinetics', 'Consecutive reaction: A, B, C', ...
{'ODE A','ODE B','ODE C'}, derived_ids(1:3), ...
{'concentration_mmol_L','concentration_mmol_L', ...
'concentration_mmol_L'}, 'Concentration [mmol/L]';
'lesson14_intermediate_comparison', 'Intermediate B: model validation', ...
{'Numerical B','Analytical B'}, ...
{'lesson14_ode_b','lesson14_reference_b'}, ...
{'concentration_mmol_L','concentration_mmol_L'}, ...
'Concentration [mmol/L]';
'lesson14_conservation_error', 'Reaction mass-balance residual', ...
{'A + B + C - initial total'}, {'lesson14_mass_balance'}, ...
{'mass_balance_error_mmol_L'}, 'Residual [mmol/L]'
};
for p = 1:rows(plot_definitions)
plot_id = plot_definitions{p,1};
title_text = plot_definitions{p,2};
labels = plot_definitions{p,3};
dataset_list = plot_definitions{p,4};
variable_list = plot_definitions{p,5};
y_label = plot_definitions{p,6};
spec = gxtxt_api_call(plot_api,'new_spec',{'plot.dataset.xy',title_text});
panel = spec.panels{1};
panel.id = ['panel_',num2str(p)];
panel.title = title_text;
panel.axes = struct('x', ...
struct('label','Time [min]','scale','linear'), ...
'y_left',struct('label',y_label,'scale','linear'));
curves = cell(1,numel(labels));
for k = 1:numel(labels)
curves{k} = struct('id',['trace_',num2str(k)], ...
'label',labels{k},'dataset_id',dataset_list{k}, ...
'x_variable_id','time_min', ...
'y_variable_id',variable_list{k},'axis','left','kind','line');
endfor
panel.series = curves;
spec.panels = {panel};
if !gxtxt_api_call(plot_api,'validate_spec',{spec})
error('PlotSpec validation failed: %s.',plot_id);
endif
plot_ref = gxtxt_api_call(plot_api,'upsert_plot',{plot_id,spec});
gxtxt_api_call(plot_api,'render',{plot_ref});
plot_artifacts = gxtxt_api_call(plot_api,'artifacts',{plot_ref});
fprintf('Created Plot Dataset: %s.\n', plot_id);
disp(plot_artifacts);
endfor
fprintf('PASS: 5 canonical derived Datasets, 3 persistent plots.\n');
fprintf('PASS: GNU Octave ODE, analytical validation and conservation.\n');
Altre tappe del progetto
- Lezione 01 — Il primo script GNU Octave in GX-TXT
- Lezione 02 — Variabili, tipi di dati e operatori in GNU Octave con GX-TXT
- Lezione 03 — Vettori e matrici in GNU Octave con GX-TXT: analisi di misure di temperatura
- Lezione 04 — condizioni, cicli e funzioni. Simuliamo la legge di raffreddamento di Newton
- Lezione 05: Dataset scientifici e Variable ID
- Lezione 06 — Selezione e lettura dei dati sperimentali con GNU Octave e GX-TXT