Lezione 13 – Analisi spettrale: FFT, campionamento e finestre con GNU Octave e GX-TXT
Dal segnale nel tempo alle sue componenti in frequenza
Un segnale elettrico può apparire complesso quando lo osserviamo nel dominio del tempo, ma essere costituito dalla somma di poche oscillazioni semplici. Questa lezione insegna a usare la trasformata discreta di Fourier, calcolare uno spettro monolatero delle ampiezze, riconoscere un errore nella frequenza di campionamento e comprendere la dispersione spettrale (spectral leakage). I risultati saranno salvati come Dataset GX-TXT e rappresentati con grafici persistenti.
L’esperimento impiega esclusivamente dati sintetici, così da conoscere esattamente le frequenze e le ampiezze che dobbiamo recuperare.
Versione di riferimento: GX-TXT 0.9.8.10-dev-112, Release 2, patch P008, release GitHub. Commit dei sorgenti verificati: 17ff2a7f93de0612015a873e626f87dbeb56b6a2. Linguaggio: GNU Octave. Gli script sono concessi in licenza GPL-3.0-or-later e contengono commenti in inglese.
Cosa impareremo
Al termine della lezione sapremo definire un vettore temporale in Octave, sommare sinusoidi, calcolare frequenza di campionamento e intervallo spettrale, leggere Dataset canonici con gli identificativi delle variabili, applicare trasformazioni numeriche attraverso le API pubbliche, gestire numeri complessi e controllare l’attendibilità di uno spettro. Useremo inoltre il debugger di GX-TXT per esaminare un errore intenzionale e pubblicheremo gli elaborati senza manipolare file interni.
Collegamento con le dodici lezioni precedenti
Nelle Lezioni 01–04 abbiamo appreso sintassi, tipi numerici, numeri complessi, vettori, matrici, condizioni, cicli e funzioni. Le Lezioni 05–07 hanno introdotto Dataset, Variable ID, lettura canonica e pubblicazione; la Lezione 07 ha già costruito sinusoidi campionate con GNU Octave. La Lezione 08 ha introdotto i grafici persistenti e il debugging, ripresi nelle Lezioni 09–12 per statistica, regressione, calcolo numerico e algebra lineare.
La novità della Lezione 13 non è generare un’altra sinusoide: è scoprire quali oscillazioni compongono una misura, interpretare le informazioni di frequenza e comprendere i limiti dei risultati. Riutilizzeremo senza ridefinirli i concetti di vettore, struttura Octave, cell array, Dataset ID, Variable ID e grafico persistente. Studieremo invece passo passo FFT, frequenze discrete, normalizzazione, finestre e ricostruzione.
| Conoscenza già acquisita | Come la utilizziamo qui | Nuovo concetto |
|---|---|---|
| Vettori, operazioni elemento per elemento (03, 07) | Generiamo campioni temporali | Corrispondenza fra campioni e frequenze |
| Numeri complessi (02) | Ricostruiamo coefficienti da parti reale e immaginaria | Modulo, fase e simmetria della FFT |
| Dataset canonici (05–07) | Leggiamo tempo e tensione usando Variable ID | Controllo del passo di campionamento |
| Debugger GX-TXT (08–12) | Ispezioniamo un parametro scorretto | Errore fisico nell’asse delle frequenze |
| Pubblicazione e Plot Dataset (07–12) | Salviamo spettri e grafici | Dataset nel dominio della frequenza |
L’esperimento: due componenti sinusoidali
La prima traccia è definita da
\[
v(t)=0{,}20+1{,}25\sin(2\pi\,50t+0{,}15)+0{,}50\sin(2\pi\,120t-0{,}30).
\]
La tensione è espressa in volt, il tempo in secondi. Il segnale contiene una componente continua di 0,20 V, una sinusoide di 50 Hz con ampiezza di picco 1,25 V e una sinusoide di 120 Hz con ampiezza di picco 0,50 V. Le fasi sono espresse in radianti.
Una seconda traccia conserva ampiezze e frequenza superiore, ma sostituisce la prima componente con 50,5 Hz. Questa piccola modifica permette di osservare cosa accade quando una frequenza non coincide con un bin della FFT.
La Lezione 13 usa i seguenti parametri:
| Grandezza | Simbolo | Valore |
|---|---|---|
| Frequenza di campionamento | \(f_s\) | 1024 Hz |
| Numero di campioni | \(N\) | 1024 |
| Intervallo tra campioni | \(\Delta t=1/f_s\) | 0,0009765625 s |
| Durata della registrazione | \(T=N/f_s\) | 1 s |
| Distanza tra bin | \(\Delta f=f_s/N\) | 1 Hz |
| Frequenza di Nyquist | \(f_N=f_s/2\) | 512 Hz |
In Octave la sequenza temporale si costruisce con:
sample_rate_hz = 1024;
sample_count = 1024;
time_s = (0:sample_count - 1)' / sample_rate_hz;
L’operatore : genera una sequenza, l’apostrofo ' la trasforma in vettore colonna e la divisione per la frequenza di campionamento converte gli indici in secondi. La notazione sin(2*pi*f*time_s + phase) calcola la sinusoide in ogni istante.

Dal numero del campione all’istante fisico
Nel nostro esperimento il campione con indice matematico \(n\) è osservato all’istante \(t_n=n/f_s\). Per \(n=0,\ldots,1023\) otteniamo 1024 campioni, ma l’ultimo istante è \(1023/1024=0{,}9990234375\) s. Non dobbiamo aggiungere un campione a \(t=1\) s: ripeteremmo il punto iniziale del periodo, ottenendo 1025 valori e modificando la griglia spettrale.
La durata della registrazione usata nella DFT è \(T=N/f_s=1\) s. Non va confusa con la differenza tra il primo e l’ultimo timestamp, pari a \((N-1)/f_s\). Questa distinzione rende coerenti la costruzione del vettore temporale e i bin della FFT.
Per la traccia a 50 Hz la registrazione contiene esattamente 50 periodi, e per quella a 120 Hz ne contiene 120: entrambe sono coerenti con la finestra temporale osservata. La seconda traccia contiene invece 50,5 periodi della componente inferiore. Sarà la nostra prova controllata della dispersione spettrale.
Dal tempo alla frequenza: un cambiamento di rappresentazione
L’ascissa del primo grafico è il tempo (s), l’ordinata è la tensione (V). Dopo la DFT, l’ascissa diventa la frequenza (Hz). I dati non sono nuove misure: sono una diversa rappresentazione matematica della stessa sequenza di campioni.
Il bin \(k\), per la metà non negativa dello spettro, corrisponde a \(f_k=kf_s/N\). Qui la distanza fra bin è 1 Hz. I bin 50 e 120 rappresentano quindi esattamente le due frequenze della prima traccia. Lo zero indica la componente continua; il bin 512 è la frequenza di Nyquist.
Che cosa calcola la FFT
La trasformata discreta di Fourier di \(N\) campioni è
\[
X[k]=\sum_{n=0}^{N-1}x[n]\,e^{-i\,2\pi kn/N},\qquad k=0,\ldots,N-1.
\]
In Octave gli indici degli array partono da 1, mentre nella formula matematica iniziano da 0. Pertanto il bin di 50 Hz, quando \(\Delta f=1\) Hz, si trova in X(51); quello di 120 Hz si trova in X(121).
Coefficienti complessi, modulo e fase
Il risultato della DFT non è direttamente una lista di ampiezze in volt: ogni coefficiente \(X[k]\) è un numero complesso. La sua parte reale e quella immaginaria contengono insieme le informazioni su ampiezza e fase. In Octave il modulo si ottiene con abs(z), mentre l’angolo si ottiene con angle(z) (radianti). Per esempio, il coefficiente della componente a 50 Hz si trova in posizione 51, perché l’indicizzazione Octave parte da uno.
Per una sinusoide reale, \(X[N-k]\) è il complesso coniugato di \(X[k]\) (quando \(k\) non è un estremo). La metà a frequenze negative ripete pertanto l’informazione della metà positiva. Questo giustifica lo spettro monolatero. Tuttavia, costruire il solo modulo \(|X[k]|\) perde le informazioni di fase: non è possibile ricostruire univocamente il segnale usando esclusivamente le ampiezze.
Un esempio pratico: due sinusoidi con la stessa ampiezza e la stessa frequenza ma fasi differenti hanno picchi di ampiezza uguale; i coefficienti complessi, invece, sono diversi.
Per segnali reali, i coefficienti della FFT sono complessi e mostrano simmetria coniugata. Uno spettro monolatero conserva soltanto le frequenze non negative. Per la normalizzazione FFT standard (backward, ossia trasformata diretta non scalata) la corretta ampiezza di picco di un tono coerente in un bin interno è
\[
A_k=\frac{2|X[k]|}{N\,G_c},
\]
dove \(G_c\) è il guadagno coerente della finestra. Il fattore 2 non va applicato alla componente continua né al bin di Nyquist, quando presente.
Perché normalizziamo lo spettro
Con l’opzione normalization = backward la trasformata diretta non viene divisa per \(N\); la normalizzazione dell’inversa è gestita dalla trasformata inversa. Per leggere un’ampiezza fisica dobbiamo perciò dividere il modulo FFT per \(N\) e correggere il guadagno coerente \(G_c\) della finestra.
Per i bin interni dello spettro monolatero si moltiplica inoltre per due: in un segnale reale la componente sinusoidale è distribuita fra le due frequenze simmetriche. Il bin DC e il bin di Nyquist non vanno raddoppiati. L’operazione pubblica oneSided applica questo trattamento; lo script divide poi il modulo per \(N G_c\).
Nel caso rettangolare, \(G_c=1\), e per le componenti esattamente centrate sui bin recuperiamo 1,25 V e 0,50 V di picco, non RMS. Per convertirle in RMS, nel caso di singole sinusoidi, occorre dividere per \(\sqrt{2}\): circa 0,884 V e 0,354 V. Il valore RMS del segnale completo richiede invece di considerare tutte le componenti e l’eventuale offset.
La PSD è un’altra grandezza, con una diversa normalizzazione e unità tipiche \(V^2/Hz\), utilizzata per studiare la distribuzione di potenza o rumore. Un grafico in V di picco non è una PSD, anche se sull’asse orizzontale compare la frequenza.
Attenzione: uno spettro delle ampiezze non è una densità spettrale di potenza (PSD). Non chiameremo PSD il risultato di questa esercitazione.

Il percorso negli script
Preparazione – L13_00_Prepare_Two_Tone_Signals.m
Il primo script genera i due segnali, pubblica due Dataset canonici e li rilegge tramite le API pubbliche per verificare che la memorizzazione abbia conservato i campioni. La transazione di pubblicazione è atomica.

Debugger – L13_01_Debug_Wrong_Sampling_Rate.m
Il secondo script contiene un errore scientifico intenzionale: usa \(f_s=512\) Hz per costruire l’asse delle frequenze, nonostante il vettore temporale dimostri che \(f_s=1024\) Hz. Le ampiezze dei coefficienti FFT non cambiano, ma la frequenza riportata per il massimo principale diventa 25 Hz invece di 50 Hz.
Nel GX-TXT Octave Script Workspace importiamo il file con un identificativo distinto e avviamo Run → Debug Session script. Impostiamo un breakpoint presso il commento BREAKPOINT, quindi ispezioniamo correct_sample_rate_hz, wrong_sample_rate_hz, measured_step_s e dominant_frequency_hz. Dopo Continue il Job deve terminare con l’errore didattico atteso: non è un bug del framework, ma la corretta rilevazione di un’ipotesi sbagliata.
Questo esempio non simula il fenomeno fisico dell’aliasing: modifica soltanto la frequenza usata per etichettare i bin. L’aliasing nasce invece quando il segnale viene realmente campionato a una frequenza insufficiente.


Capire l’errore prima di correggerlo
Nella prova intenzionalmente errata il vettore dei campioni rimane lo stesso e la FFT produce gli stessi coefficienti. Cambia solo il valore passato a frequencyGrid: con \(f_s=512\) Hz al posto di 1024 Hz, la distanza fra bin diventa \(0{,}5\) Hz. Di conseguenza il bin \(k=50\), che dovrebbe essere etichettato 50 Hz, viene mostrato a 25 Hz.
Il debugger serve a confrontare il passo temporale realmente letto dal Dataset, la frequenza ricavata da quel passo e la frequenza introdotta erroneamente. Il controllo che genera il fallimento intenzionale è una verifica di coerenza scientifica, non un guasto dell’algoritmo FFT.
È essenziale distinguere questo errore dall’aliasing: l’aliasing si verifica durante il campionamento reale, quando frequenze troppo alte non sono distinguibili con la frequenza \(f_s\) scelta. Con \(f_s=1024\) Hz, per esempio, una componente a 700 Hz può ripiegarsi a 324 Hz: \(1024-700=324\). Il valore mostrato a 25 Hz in questa lezione non è un alias.
Analisi corretta – L13_02_FFT_Spectrum_Correct.m
Il terzo script ricava la frequenza di campionamento direttamente dagli istanti del Dataset, verifica l’uniformità degli intervalli, rimuove la media, calcola FFT e asse delle frequenze mediante i servizi GX-TXT, seleziona i coefficienti monolateri e recupera le ampiezze fisiche. Confronta anche una finestra rettangolare e una finestra di Hann periodica per il segnale da 50,5 Hz, e controlla l’inversa IFFT.
Al termine crea quattro Dataset derivati e tre grafici GX-TXT persistenti: segnali nel tempo, spettro delle frequenze coerenti e confronto tra finestre.
Le API pubbliche GX-TXT impiegate
Le operazioni seguenti sono descritte nei contratti pubblici della versione indicata. In questa lezione non sono semplici nomi da copiare: costituiscono il collegamento tra codice Octave e infrastruttura scientifica.
| API / operazione | Scopo e significato didattico |
|---|---|
gxtxt_api_require, gxtxt_api_has_operation | Verificano che la Session esponga i contratti e le operazioni necessari prima di eseguire il calcolo |
gxtxt_api_call(api, operation, args) | Invoca un servizio pubblico, passando gli argomenti in una cell array |
CANONICAL_DATASET_API_v2 / list | Elenca gli identificativi stabili dei Dataset pubblicati |
CANONICAL_DATASET_API_v2 / read_range | Legge campioni di variabili note tramite Dataset ID, Variable ID, offset e numero di righe |
NUMERIC_API_v1 / detrend | Rimuove una media o una tendenza, senza modificare implicitamente gli istanti di campionamento |
NUMERIC_API_v1 / window | Genera i pesi della finestra e fornisce il guadagno coerente necessario per correggere le ampiezze |
NUMERIC_API_v1 / fft | Calcola la trasformata senza normalizzazioni scientifiche nascoste; restituisce parti reale e immaginaria |
NUMERIC_API_v1 / frequencyGrid | Calcola frequenze, \(\Delta f\) e Nyquist a partire da \(f_s\) e \(N\) |
NUMERIC_API_v1 / oneSided | Seleziona le frequenze non negative e, con scaling=amplitude, raddoppia solo i bin interni |
NUMERIC_API_v1 / ifft | Calcola l’inversa, utile a verificare che la trasformazione conservi i dati |
DATASET_PUBLICATION_API_v2 / publish_series_batch | Pubblica insieme serie scientifiche, metadati e provenienza |
PLOT_DATASET_API_v4 | Crea, valida, registra, renderizza e rende consultabili grafici che puntano a Dataset canonici |
Le nuove operazioni numeriche, chiamata per chiamata
Le precedenti lezioni hanno già spiegato come verificare le dipendenze e chiamare un servizio attraverso gxtxt_api_call. Qui concentriamoci sui contratti numerici introdotti per la prima volta. In tutti gli esempi il terzo argomento di gxtxt_api_call è una cell array Octave che contiene gli argomenti dell’operazione, nell’ordine previsto dal contratto.
| Operazione pubblica | Argomenti usati nello script | Risultato utilizzato | Perché serve |
|---|---|---|---|
| detrend | vettore di tensioni; struttura con method = mean | values | Rimuove il valore medio prima dello spettro |
| window | nome rectangular oppure hann; N; struttura con sampling = periodic | values; coherent_gain | Fornisce i pesi e il fattore correttivo delle ampiezze |
| fft | vettore; struttura con nfft = N e normalization = backward | real; imaginary | Calcola i coefficienti complessi della DFT |
| frequencyGrid | frequenza di campionamento; N; struttura con representation = one_sided | frequencies; df e altre informazioni di griglia | Associa unità fisiche ai bin |
| oneSided | real; imaginary; struttura con scaling = amplitude e nfft = N | real; imaginary | Seleziona la metà non negativa e tratta correttamente i bin interni |
| ifft | parti real e imaginary; struttura con nfft = N e normalization = backward | real; imaginary | Ricostruisce il segnale per controllare la trasformazione |
Controlli prima della FFT. Lo script confronta gli assi temporali dei due Dataset; calcola gli intervalli con la funzione Octave diff; ne stima il passo con median; verifica che siano positivi e uniformi; infine usa \(f_s=1/\Delta t\). In questo modo non scambia un parametro di elaborazione per una proprietà realmente osservata.
Controlli sulle risposte. I valori devono avere lunghezze coerenti; frequenze e ampiezze devono riferirsi agli stessi bin; le parti reale e immaginaria devono essere combinate nello stesso ordine. L’operazione complex(re, im) è una funzione nativa Octave, mentre fft invocata attraverso NUMERIC_API_v1 è un servizio pubblico GX-TXT.
Errori da prevenire. Non confondere un Dataset ID con un file, non cambiare l’ordine degli argomenti della cell array, non chiamare frequencyGrid con una frequenza presunta, non moltiplicare una seconda volta per due lo spettro già convertito da oneSided e non applicare due volte la divisione per \(N\).
Tre chiamate da leggere nel codice
Consideriamo tre operazioni introdotte in questa lezione. Il primo argomento individua il servizio pubblico, il secondo l’operazione e il terzo racchiude i parametri in una cell array Octave.
centered = gxtxt_api_call('NUMERIC_API_v1', 'detrend', ...
{voltage_values, struct('method', 'mean')});
grid = gxtxt_api_call('NUMERIC_API_v1', 'frequencyGrid', ...
{1024, 1024, struct('representation', 'one_sided')});
hann_window = gxtxt_api_call('NUMERIC_API_v1', 'window', ...
{'hann', 1024, struct('sampling', 'periodic')});
Nella prima chiamata voltage_values rappresenta il vettore di dati e centered.values contiene i valori senza media. Nella seconda chiamiamo la griglia indicando esplicitamente frequenza di campionamento e numero di campioni, entrambi necessari per interpretare le ascisse. Nella terza chiediamo i 1024 pesi della Hann periodica e il relativo coherent_gain, che useremo per esprimere le ampiezze nelle unità fisiche originali.
Nessuna di queste tre chiamate legge file interni GX-TXT: i dati provengono dalle API canoniche e l’elaborazione è affidata al contratto pubblico del servizio numerico.
Per esempio, la chiamata
fft_result = gxtxt_api_call('NUMERIC_API_v1', 'fft', ...
{voltage_values, struct('nfft', 1024, 'normalization', 'backward')});
complex_bins = complex(fft_result.real, fft_result.imaginary);
mostra che gxtxt_api_call non riceve direttamente una lista variabile di argomenti Octave: l’ultimo parametro è una cell array. Il servizio restituisce parti reale e immaginaria separate; con complex ricostruiamo i coefficienti complessi per il calcolo di abs.
La funzione frequencyGrid non può ricavare automaticamente \(f_s\) dal solo array FFT: la frequenza di campionamento è un’informazione proveniente dall’acquisizione. Per questo la ricaviamo e la controlliamo sul Dataset temporale.
Finestratura: perché cambiare i pesi ai campioni?
La DFT interpreta i \(N\) campioni come un periodo di una sequenza che si ripete indefinitamente. Se il segnale contiene un numero intero di periodi nella registrazione, i due estremi si raccordano periodicamente e il tono si concentra su un bin. Se la sinusoide contiene 50,5 periodi, il raccordo presenta una discontinuità: la sua energia si distribuisce su numerosi bin. È la dispersione spettrale (spectral leakage).
La finestra rettangolare assegna peso 1 a ogni campione. La Hann periodica applica invece, per \(n=0,\ldots,N-1\),
\[
w[n]=\frac12-\frac12\cos\!\left(\frac{2\pi n}{N}\right).
\]
I campioni vicini agli estremi vengono attenuati, limitando la discontinuità del raccordo. Il risultato ha code laterali più basse, ma un lobo principale più largo: non è una trasformazione gratuita. Per la Hann periodica il guadagno coerente è \(G_c=0{,}5\); per la rettangolare è 1.
Guadagno coerente e scalloping loss non sono la stessa cosa. La correzione con \(G_c\) ripristina l’ampiezza di un tono allineato al bin dopo la finestratura. Se il tono cade tra due bin, il massimo può risultare inferiore al valore reale anche dopo questa correzione: è la scalloping loss. Perciò non bisogna leggere il massimo di un solo bin come misura esatta di un tono non coerente.
Un secondo compromesso riguarda l’identificazione di due frequenze vicine. La larghezza del lobo principale può far apparire meno separati due toni; la soppressione delle code laterali può invece rendere visibile una componente debole accanto a una forte. La finestra si sceglie in base allo scopo dell’analisi.
Finestratura e dispersione spettrale
La traccia a 50,5 Hz non contiene un numero intero di cicli nel secondo osservato; con la finestra rettangolare l’energia si distribuisce su più bin. Una finestra Hann periodica attenua le code laterali ma allarga il lobo principale. Il suo guadagno coerente, qui pari a 0,5, va considerato nella scala delle ampiezze.
La finestra Hann non rende perfettamente esatta l’ampiezza di un tono non centrato su un bin: rimane una perdita dovuta al disallineamento (scalloping loss). Non bisogna interpretare l’altezza del massimo isolato come stima esatta in ogni situazione.
Nella nostra verifica numerica, per il solo esempio sintetico e al bin di 70 Hz, l’ampiezza associata alla dispersione scende da circa \(0{,}0170\) V (rettangolare) a \(0{,}0000536\) V (Hann). Questo confronto riguarda quel bin, non una promessa di riduzione uniforme sull’intero spettro.

Risoluzione spettrale, durata e zero-padding
La distanza fra bin è \(\Delta f=f_s/N=1/T\). Se manteniamo \(f_s=1024\) Hz e osserviamo per 2 s, useremo 2048 campioni e otterremo \(\Delta f=0{,}5\) Hz. Cambia la durata dell’osservazione; la frequenza di Nyquist rimane invece \(512\) Hz, perché dipende da \(f_s\).
Portare nfft a un valore superiore al numero di campioni, riempiendo il segnale con zeri (zero-padding), crea una griglia più fitta, ma non aggiunge informazione temporale. Può facilitare la lettura e l’interpolazione dei picchi; non ha lo stesso effetto di raddoppiare la durata della misura. Nello script utilizziamo \(nfft=N=1024\), così campionamento, durata e griglia mantengono un legame trasparente.
Inversa FFT
Con ifft ricostruiamo il segnale centrato sui dati, quindi ripristiniamo la componente continua. La differenza massima tra campioni originari e ricostruiti deve risultare prossima alla precisione numerica della macchina. Questa verifica controlla coerenza e ordine dei coefficienti, non dimostra da sola che la nostra interpretazione fisica dello spettro sia corretta.
Come valutiamo la ricostruzione
Per il segnale coerente lo script rimuove il valore medio prima di calcolare la FFT, passa all’IFFT i coefficienti complessi non limitati alla metà positiva e somma nuovamente la media al vettore ricostruito. La prova consiste nel calcolare il massimo valore assoluto della differenza campione per campione.
Un errore molto piccolo verifica che le due trasformate sono coerenti nella precisione numerica disponibile. Non dimostra, da solo, che il campionamento iniziale abbia rispettato Nyquist o che uno spettro descriva fedelmente un sistema fisico reale: l’IFFT sa ricostruire anche una sequenza campionata male.
Risultati numerici attesi
| Verifica | Risultato atteso |
|---|---|
| Frequenza principale | 50,000 Hz |
| Seconda frequenza | 120,000 Hz |
| Ampiezza principale | 1,250 V di picco |
| Seconda ampiezza | 0,500 V di picco |
| Intervallo dei bin | 1 Hz |
| Nyquist | 512 Hz |
| Guadagno coerente Hann periodica | 0,5 |
| Dataset di ingresso / derivati | 2 / 4 |
| Grafici persistenti | 3 |
Questi valori costituiscono un riferimento per controllare i risultati della propria esecuzione, distinguendo la correttezza del calcolo dall’interpretazione fisica dello spettro.

Come riprodurre la lezione
Creare una nuova Session autonoma in GX-TXT, aprire Viewers → Octave Scripts, importare L13_00, assegnare un identificativo Script distinto e salvarlo. Eseguire lo script da Run → Open Script Runner e verificarne il completamento. Aprire L13_01 in un secondo Script ID e osservare, mediante il debugger, l’errore intenzionale. Infine importare ed eseguire L13_02 con un terzo Script ID; controllare i Dataset e i grafici nella finestra principale.
Gli script pubblicano identificativi canonici in modalità create-only. Per ripetere l’esperimento completo occorre una nuova Session, senza eliminare o modificare i file di registrazione interni.

Che cosa rende questo esperimento riproducibile
La sequenza da controllare è: descrizione del segnale sintetico e della sua frequenza di campionamento, pubblicazione dei due Dataset con unità fisiche, lettura canonica senza accedere ai file interni, verifica degli intervalli temporali, analisi numerica mediante API pubbliche, pubblicazione dei quattro Dataset derivati e registrazione dei tre grafici persistenti.
Il confronto fra valori previsti e osservati distingue la correttezza delle operazioni matematiche dall’interpretazione della misura. Una frequenza mostrata sull’asse X ha significato solo se deriva dal reale passo temporale; un’ampiezza espressa in V richiede una normalizzazione coerente con la convenzione adottata.
Esercizi
- Modificare l’ampiezza della componente a 120 Hz e prevedere come cambierà il bin corrispondente.
- Aumentare \(N\) mantenendo la stessa \(f_s\). Che cosa accade alla durata e alla distanza tra bin?
- Confrontare una finestra rettangolare e una Hann su una frequenza non coerente; spiegare perché il lobo principale cambia larghezza.
- Aggiungere una componente a 700 Hz, campionata realmente a 1024 Hz, e prevedere la frequenza alias \(1024-700=324\) Hz. Distinguere questo fenomeno dall’errore intenzionale nel secondo script.
Riferimenti ai sorgenti pubblici
- Octave Script Bridge API v1
- Canonical Dataset API v2
- Dataset Publication API v2
- Numeric API v1
- Plot Dataset API v4
Gli script completi, con commenti in inglese, sono disponibili nei riquadri espandibili in fondo all’articolo e nel materiale scaricabile del corso.
Script GNU Octave completi
Aprire i riquadri per consultare o copiare i tre script. I commenti del codice sono in inglese.
L13_00_Prepare_Two_Tone_Signals.m
% Lesson 13 - Publish synthetic signals for the Fourier transform.
% Course: GNU Octave with GX-TXT | DEV112 Release 2 + P008
% GitHub commit: 17ff2a7f93de0612015a873e626f87dbeb56b6a2
% SPDX-License-Identifier: GPL-3.0-or-later
%
% Execute once in a new managed GX-TXT Session.
% The two traces are deterministic synthetic examples, not measurements.
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'));
sample_rate_hz = 1024;
sample_count = 1024;
time_s = (0:sample_count - 1)' / sample_rate_hz;
fundamental_amplitude_v = 1.25;
second_amplitude_v = 0.50;
offset_v = 0.20;
% Integer-cycle tones occupy exactly one FFT bin per component.
coherent_v = offset_v + ...
fundamental_amplitude_v * sin(2*pi*50*time_s + 0.15) + ...
second_amplitude_v * sin(2*pi*120*time_s - 0.30);
% A half-bin frequency demonstrates spectral leakage without random noise.
offbin_v = offset_v + ...
fundamental_amplitude_v * sin(2*pi*50.5*time_s + 0.15) + ...
second_amplitude_v * sin(2*pi*120*time_s - 0.30);
assert(numel(time_s) == sample_count);
assert(all(isfinite(coherent_v)) && all(isfinite(offbin_v)));
ids = {'lesson13_signal_coherent', 'lesson13_signal_offbin'};
existing = gxtxt_api_call(dataset_api, 'list', {});
for k = 1:numel(ids)
if any(strcmp(existing, ids{k}))
error('Source Dataset already exists: %s. Use a fresh Session.', ids{k});
endif
endfor
time_var = struct('variable_id', 'time_s', ...
'name', 'time_s', 'display_label', 'Elapsed time', ...
'unit', 's', 'dtype', 'float64', 'value_kind', 'number', ...
'semantic_source', 'generator');
voltage_var = struct('variable_id', 'voltage_V', ...
'name', 'voltage_V', 'display_label', 'Synthetic voltage', ...
'unit', 'V', 'dtype', 'float64', 'value_kind', 'number', ...
'semantic_source', 'generator');
all_values = {coherent_v, offbin_v};
all_labels = {'Two coherent sinusoids at 50 and 120 Hz', ...
'Half-bin tone at 50.5 Hz plus coherent 120 Hz'};
series = cell(1, 2);
for k = 1:2
metadata = struct();
metadata.('simulation.synthetic') = true;
metadata.('simulation.sample_rate_hz') = sample_rate_hz;
metadata.('simulation.sample_count') = sample_count;
metadata.('simulation.offset_v') = offset_v;
metadata.('simulation.description') = all_labels{k};
series{k} = struct('dataset_id', ids{k}, 'contract', 'table.generic', ...
'storage', 'auto', 'x_values', time_s, 'y_values', all_values{k}, ...
'x_variable', time_var, 'y_variable', voltage_var, ...
'producer_version', '1.0.0', ...
'source', 'GX-TXT GNU Octave Lesson 13', ...
'provenance', 'Deterministic simulated two-tone voltage records', ...
'notes', all_labels{k}, 'structured_metadata', metadata);
endfor
receipt = gxtxt_api_call(publication_api, 'publish_series_batch', ...
{struct('series', {series})});
if !receipt.atomic || receipt.output_count != 2
error('Atomic publication failed to confirm two source Datasets.');
endif
% Read back through the canonical public Dataset API, not the storage files.
for k = 1:2
result = gxtxt_api_call(dataset_api, 'read_range', ...
{ids{k}, {'time_s', 'voltage_V'}, 0, sample_count});
assert(numel(result.time_s.values) == sample_count);
assert(max(abs(result.time_s.values(:) - time_s)) < 1e-12);
assert(max(abs(result.voltage_V.values(:) - all_values{k})) < 1e-10);
endfor
fprintf('PASS: 2 canonical synthetic source Datasets published.\n');
fprintf('Sampling: fs=%g Hz, N=%d, duration=%.3f s, df=%.3f Hz.\n', ...
sample_rate_hz, sample_count, ...
sample_count/sample_rate_hz, sample_rate_hz/sample_count);
L13_01_Debug_Wrong_Sampling_Rate.m
% Lesson 13 - An intentional sampling-frequency error for the debugger.
% Course: GNU Octave with GX-TXT | DEV112 Release 2 + P008
% GitHub commit: 17ff2a7f93de0612015a873e626f87dbeb56b6a2
% SPDX-License-Identifier: GPL-3.0-or-later
%
% Run after L13_00. Set a breakpoint at the marked line.
% This program MUST fail its scientific frequency validation.
% It publishes no Dataset and creates no plot.
dataset_api = 'CANONICAL_DATASET_API_v2';
numeric_api = 'NUMERIC_API_v1';
gxtxt_api_require({dataset_api, numeric_api});
assert(gxtxt_api_has_operation(dataset_api, 'read_range'));
assert(gxtxt_api_has_operation(numeric_api, 'fft'));
assert(gxtxt_api_has_operation(numeric_api, 'frequencyGrid'));
assert(gxtxt_api_has_operation(numeric_api, 'oneSided'));
n = 1024;
data = gxtxt_api_call(dataset_api, 'read_range', ...
{'lesson13_signal_coherent', {'time_s', 'voltage_V'}, 0, n});
t = data.time_s.values(:);
v = data.voltage_V.values(:);
if numel(t) != n || numel(v) != n || any(diff(t) <= 0)
error('Missing or invalid source record: run L13_00 first.');
endif
measured_step_s = median(diff(t));
correct_sample_rate_hz = 1 / measured_step_s;
% INTENTIONAL ERROR: the assumed sample rate is half the true value.
% Fourier coefficients remain unchanged, but every displayed Hz value halves.
wrong_sample_rate_hz = 512;
raw_fft = gxtxt_api_call(numeric_api, 'fft', ...
{v - mean(v), struct('nfft', n, 'normalization', 'backward')});
wrong_grid = gxtxt_api_call(numeric_api, 'frequencyGrid', ...
{wrong_sample_rate_hz, n, struct('representation', 'one_sided')});
positive = gxtxt_api_call(numeric_api, 'oneSided', ...
{raw_fft.real, raw_fft.imaginary, struct('scaling', 'amplitude')});
amplitude_v = abs(complex(positive.real(:),positive.imaginary(:))) / n;
frequency_hz = wrong_grid.frequency(:);
[~, idx] = max(amplitude_v(2:end));
dominant_frequency_hz = frequency_hz(idx + 1);
wrong_df_hz = wrong_grid.df;
% BREAKPOINT: inspect correct_sample_rate_hz, wrong_sample_rate_hz,
% measured_step_s, dominant_frequency_hz, wrong_df_hz, frequency_hz.
fprintf('Measured sample rate: %.1f Hz; assumed: %.1f Hz.\n', ...
correct_sample_rate_hz, wrong_sample_rate_hz);
fprintf('Incorrect dominant peak: %.2f Hz (expected 50.00 Hz).\n', ...
dominant_frequency_hz);
% Expected FAILED Job: a scientifically invalid frequency axis is rejected.
if abs(dominant_frequency_hz - 50.0) > 0.5
error('GXTXT:Lesson13:WrongSamplingRate', ...
'FFT frequency axis is wrong: verify dt and fs = 1/dt.');
endif
error('Unexpected success: intentional sampling-rate error escaped detection.');
L13_02_FFT_Spectrum_Correct.m
% Lesson 13 - Public FFT, frequency grids, windows and persistent plots.
% 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 commit: 17ff2a7f93de0612015a873e626f87dbeb56b6a2
% SPDX-License-Identifier: GPL-3.0-or-later
%
% Execute after L13_00 in the same fresh managed GX-TXT Session.
% All Dataset, numerical-service and plot calls use public GX-TXT APIs.
dataset_api = 'CANONICAL_DATASET_API_v2';
numeric_api = 'NUMERIC_API_v1';
publication_api = 'DATASET_PUBLICATION_API_v2';
plot_api = 'PLOT_DATASET_API_v4';
gxtxt_api_require({dataset_api, numeric_api, publication_api, plot_api});
required = {
dataset_api, 'list'; dataset_api, 'read_range';
numeric_api, 'fft'; numeric_api, 'ifft';
numeric_api, 'frequencyGrid'; numeric_api, 'oneSided';
numeric_api, 'detrend'; numeric_api, 'window';
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 GX-TXT public operation: %s/%s.', ...
required{k, 1}, required{k, 2});
endif
endfor
% Step 1: read and verify both canonical sample records.
n = 1024;
source_ids = {'lesson13_signal_coherent', 'lesson13_signal_offbin'};
dataset_ids = gxtxt_api_call(dataset_api, 'list', {});
signals = cell(1, 2);
time_s = [];
for k = 1:2
if !any(strcmp(dataset_ids, source_ids{k}))
error('Missing %s: run L13_00 in this Session first.', source_ids{k});
endif
data = gxtxt_api_call(dataset_api, 'read_range', ...
{source_ids{k}, {'time_s', 'voltage_V'}, 0, n});
t = data.time_s.values(:);
v = data.voltage_V.values(:);
if numel(t) != n || numel(v) != n || ...
!all(isfinite(t)) || !all(isfinite(v))
error('Source Dataset contains incomplete or nonfinite samples.');
endif
if k == 1
time_s = t;
elseif max(abs(time_s - t)) > 1e-12
error('Source signals use different sample-time grids.');
endif
signals{k} = v;
endfor
% Step 2: derive fs from the actual Dataset time axis.
sample_steps = diff(time_s);
sample_step_s = median(sample_steps);
if sample_step_s <= 0 || ...
max(abs(sample_steps - sample_step_s)) > 1e-10 * sample_step_s
error('FFT requires a strictly uniform sample-time grid.');
endif
sample_rate_hz = 1 / sample_step_s;
record_duration_s = n * sample_step_s;
nyquist_hz = sample_rate_hz / 2;
grid = gxtxt_api_call(numeric_api, 'frequencyGrid', ...
{sample_rate_hz, n, struct('representation', 'one_sided')});
frequency_hz = grid.frequency(:);
if length(frequency_hz) != n/2 + 1 || ...
abs(grid.df - 1.0) > 1e-10 || abs(grid.nyquist - 512) > 1e-9
error('Public FFT grid differs from the expected 1-Hz frequency bins.');
endif
% Step 3: remove the mean and compute the coherent rectangular spectrum.
centered = gxtxt_api_call(numeric_api, 'detrend', ...
{signals{1}, struct('method', 'mean')});
rect_window = gxtxt_api_call(numeric_api, 'window', ...
{'rectangular', n, struct('sampling', 'periodic')});
coherent_fft = gxtxt_api_call(numeric_api, 'fft', ...
{centered.values(:) .* rect_window.values(:), ...
struct('nfft', n, 'normalization', 'backward')});
coherent_positive = gxtxt_api_call(numeric_api, 'oneSided', ...
{coherent_fft.real, coherent_fft.imaginary, ...
struct('scaling', 'amplitude', 'nfft', n)});
coherent_amp_v = abs(complex(coherent_positive.real(:), ...
coherent_positive.imaginary(:))) / (n * rect_window.coherent_gain);
% FFT indices start at 1 in Octave: frequency 50 Hz corresponds to index 51.
a50_v = coherent_amp_v(51);
a120_v = coherent_amp_v(121);
if abs(a50_v - 1.25) > 1e-9 || abs(a120_v - 0.50) > 1e-9
error('Recovered coherent tone amplitudes differ from the known source.');
endif
% Step 4: demonstrate off-bin leakage and periodic Hann-window correction.
offbin_centered = gxtxt_api_call(numeric_api, 'detrend', ...
{signals{2}, struct('method', 'mean')});
hann_window = gxtxt_api_call(numeric_api, 'window', ...
{'hann', n, struct('sampling', 'periodic')});
rect_fft = gxtxt_api_call(numeric_api, 'fft', ...
{offbin_centered.values(:), ...
struct('nfft', n, 'normalization', 'backward')});
hann_fft = gxtxt_api_call(numeric_api, 'fft', ...
{offbin_centered.values(:) .* hann_window.values(:), ...
struct('nfft', n, 'normalization', 'backward')});
rect_positive = gxtxt_api_call(numeric_api, 'oneSided', ...
{rect_fft.real, rect_fft.imaginary, ...
struct('scaling', 'amplitude', 'nfft', n)});
hann_positive = gxtxt_api_call(numeric_api, 'oneSided', ...
{hann_fft.real, hann_fft.imaginary, ...
struct('scaling', 'amplitude', 'nfft', n)});
rect_amp_v = abs(complex(rect_positive.real(:), ...
rect_positive.imaginary(:))) / n;
hann_amp_v = abs(complex(hann_positive.real(:), ...
hann_positive.imaginary(:))) / (n * hann_window.coherent_gain);
if rect_amp_v(71) < hann_amp_v(71) * 10
error('The expected far-bin Hann leakage reduction was not observed.');
endif
% Step 5: verify FFT/IFFT reversibility through the public Numeric API.
inverse = gxtxt_api_call(numeric_api, 'ifft', ...
{coherent_fft.real, coherent_fft.imaginary, ...
struct('nfft', n, 'normalization', 'backward')});
reconstructed_v = inverse.real(:) + mean(signals{1});
inverse_max_error_v = max(abs(reconstructed_v - signals{1}));
if inverse_max_error_v > 1e-10 || ...
max(abs(inverse.imaginary(:))) > 1e-10
error('Public FFT/IFFT reconstruction failed.');
endif
fprintf('Correct fs=%.1f Hz, N=%d, duration=%.3f s, df=%.1f Hz.\n', ...
sample_rate_hz, n, record_duration_s, grid.df);
fprintf('Nyquist=%.1f Hz; recovered amplitudes: 50 Hz=%.6f V, 120 Hz=%.6f V.\n', ...
nyquist_hz, a50_v, a120_v);
fprintf('Hann coherent gain=%.6f; reconstruction error=%.3g V.\n', ...
hann_window.coherent_gain, inverse_max_error_v);
% Step 6: atomically publish the derived spectral and time-domain results.
derived_ids = {'lesson13_coherent_amplitude', ...
'lesson13_offbin_rectangular', ...
'lesson13_offbin_hann', ...
'lesson13_ifft_reconstruction'};
for k = 1:numel(derived_ids)
if any(strcmp(dataset_ids, derived_ids{k}))
error('Derived Dataset exists: %s. Start a fresh Session.', derived_ids{k});
endif
endfor
frequency_var = struct('variable_id', 'frequency_hz', ...
'name', 'frequency_hz', 'display_label', 'Fourier frequency', ...
'unit', 'Hz', 'dtype', 'float64', 'value_kind', 'number', ...
'semantic_source', 'plugin');
time_var = struct('variable_id', 'time_s', ...
'name', 'time_s', 'display_label', 'Elapsed time', ...
'unit', 's', 'dtype', 'float64', 'value_kind', 'number', ...
'semantic_source', 'plugin');
amplitude_var = struct('variable_id', 'amplitude_V', ...
'name', 'amplitude_V', 'display_label', 'One-sided peak amplitude', ...
'unit', 'V', 'dtype', 'float64', 'value_kind', 'number', ...
'semantic_source', 'plugin');
reconstruction_var = struct('variable_id', 'voltage_V', ...
'name', 'voltage_V', 'display_label', 'Inverse Fourier reconstruction', ...
'unit', 'V', 'dtype', 'float64', 'value_kind', 'number', ...
'semantic_source', 'plugin');
x_values = {frequency_hz, frequency_hz, frequency_hz, time_s};
y_values = {coherent_amp_v, rect_amp_v, hann_amp_v, reconstructed_v};
x_vars = {frequency_var, frequency_var, frequency_var, time_var};
y_vars = {amplitude_var, amplitude_var, amplitude_var, reconstruction_var};
descriptions = {'Coherent rectangular one-sided amplitude spectrum', ...
'Off-bin rectangular spectrum with leakage', ...
'Off-bin periodic Hann spectrum with coherent-gain correction', ...
'Inverse FFT reconstruction of the coherent time signal'};
series = cell(1, numel(derived_ids));
for k = 1:numel(derived_ids)
metadata = struct();
metadata.('analysis.synthetic') = true;
metadata.('analysis.sample_rate_hz') = sample_rate_hz;
metadata.('analysis.nfft') = n;
metadata.('analysis.frequency_resolution_hz') = grid.df;
metadata.('analysis.nyquist_hz') = grid.nyquist;
metadata.('analysis.method') = descriptions{k};
series{k} = struct('dataset_id', derived_ids{k}, ...
'contract', 'table.generic', 'storage', 'auto', ...
'x_values', x_values{k}, 'y_values', y_values{k}, ...
'x_variable', x_vars{k}, 'y_variable', y_vars{k}, ...
'producer_version', '1.0.0', ...
'source', 'GX-TXT GNU Octave Lesson 13', ...
'source_dataset_ids', {source_ids}, ...
'provenance', 'Published from public NUMERIC_API_v1 Fourier transforms', ...
'notes', descriptions{k}, 'structured_metadata', metadata);
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 four derived Datasets.');
endif
for k = 1:numel(derived_ids)
recovered = gxtxt_api_call(dataset_api, 'read_range', ...
{derived_ids{k}, {x_vars{k}.variable_id, y_vars{k}.variable_id}, ...
0, numel(y_values{k})});
saved = recovered.(y_vars{k}.variable_id).values(:);
if length(saved) != length(y_values{k}) || ...
max(abs(saved - y_values{k})) > 1e-9
error('Public Dataset read-back mismatch: %s.', derived_ids{k});
endif
endfor
% Step 7: build three persistent GX-TXT Plot Dataset v4 graphics.
time_plot = gxtxt_api_call(plot_api, 'new_spec', ...
{'plot.dataset.xy', 'Lesson 13: Two-tone signals'});
tp = time_plot.panels{1};
tp.id = 'two_tone_time';
tp.title = 'Synthetic coherent and off-bin voltage signals';
tp.axes = struct('x', struct('label', 'Time [s]', 'scale', 'linear'), ...
'y_left', struct('label', 'Voltage [V]', 'scale', 'linear'));
tp.series = {
struct('id', 'coherent_time', 'label', 'Coherent 50 + 120 Hz', ...
'dataset_id', source_ids{1}, 'x_variable_id', 'time_s', ...
'y_variable_id', 'voltage_V', 'axis', 'left', 'kind', 'line'),
struct('id', 'offbin_time', 'label', 'Off-bin 50.5 + 120 Hz', ...
'dataset_id', source_ids{2}, 'x_variable_id', 'time_s', ...
'y_variable_id', 'voltage_V', 'axis', 'left', 'kind', 'line')
};
time_plot.panels = {tp};
if !gxtxt_api_call(plot_api, 'validate_spec', {time_plot})
error('Time-domain PlotSpec failed validation.');
endif
time_ref = gxtxt_api_call(plot_api, 'upsert_plot', ...
{'lesson13_two_tone_time', time_plot});
gxtxt_api_call(plot_api, 'render', {time_ref});
time_artifacts = gxtxt_api_call(plot_api, 'artifacts', {time_ref});
spectrum_plot = gxtxt_api_call(plot_api, 'new_spec', ...
{'plot.dataset.xy', 'Lesson 13: Coherent FFT amplitude'});
sp = spectrum_plot.panels{1};
sp.id = 'coherent_fft';
sp.title = 'One-sided spectrum: 50 and 120 Hz';
sp.axes = struct('x', struct('label', 'Frequency [Hz]', 'scale', 'linear'), ...
'y_left', struct('label', 'Peak amplitude [V]', 'scale', 'linear'));
sp.series = {struct('id', 'coherent_fft', ...
'label', 'Coherent rectangular spectrum', ...
'dataset_id', derived_ids{1}, 'x_variable_id', 'frequency_hz', ...
'y_variable_id', 'amplitude_V', 'axis', 'left', 'kind', 'line')};
spectrum_plot.panels = {sp};
if !gxtxt_api_call(plot_api, 'validate_spec', {spectrum_plot})
error('Coherent-spectrum PlotSpec failed validation.');
endif
spectrum_ref = gxtxt_api_call(plot_api, 'upsert_plot', ...
{'lesson13_coherent_spectrum', spectrum_plot});
gxtxt_api_call(plot_api, 'render', {spectrum_ref});
spectrum_artifacts = gxtxt_api_call(plot_api, 'artifacts', {spectrum_ref});
leakage_plot = gxtxt_api_call(plot_api, 'new_spec', ...
{'plot.dataset.xy', 'Lesson 13: Leakage and Hann window'});
lp = leakage_plot.panels{1};
lp.id = 'fft_leakage';
lp.title = 'Off-bin 50.5 Hz: rectangular versus periodic Hann';
lp.axes = struct('x', struct('label', 'Frequency [Hz]', 'scale', 'linear'), ...
'y_left', struct('label', 'Peak amplitude [V]', 'scale', 'linear'));
lp.series = {
struct('id', 'rectangular', 'label', 'Rectangular window', ...
'dataset_id', derived_ids{2}, 'x_variable_id', 'frequency_hz', ...
'y_variable_id', 'amplitude_V', 'axis', 'left', 'kind', 'line'),
struct('id', 'hann', 'label', 'Periodic Hann window', ...
'dataset_id', derived_ids{3}, 'x_variable_id', 'frequency_hz', ...
'y_variable_id', 'amplitude_V', 'axis', 'left', 'kind', 'line')
};
leakage_plot.panels = {lp};
if !gxtxt_api_call(plot_api, 'validate_spec', {leakage_plot})
error('Leakage PlotSpec failed validation.');
endif
leakage_ref = gxtxt_api_call(plot_api, 'upsert_plot', ...
{'lesson13_leakage_windows', leakage_plot});
gxtxt_api_call(plot_api, 'render', {leakage_ref});
leakage_artifacts = gxtxt_api_call(plot_api, 'artifacts', {leakage_ref});
fprintf('PASS: 4 derived Datasets, 3 native plots, public FFT/IFFT checks.\n');
disp(time_artifacts);
disp(spectrum_artifacts);
disp(leakage_artifacts);
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