Calcolare Una Funzione In Un Vettore Matlab

Inserisci la tua funzione MATLAB e il vettore per visualizzare risultati e grafici interattivi

Guida Completa: Come Calcolare una Funzione su un Vettore in MATLAB

MATLAB è uno degli strumenti più potenti per il calcolo numerico e l’analisi dati, particolarmente apprezzato in ambito ingegneristico e scientifico. Una delle operazioni fondamentali in MATLAB è l’applicazione di funzioni a vettori di dati. Questa guida approfondita ti condurrà attraverso tutti gli aspetti del calcolo di funzioni su vettori in MATLAB, dalle basi alle tecniche avanzate.

1. Fondamenti delle Operazioni su Vettori in MATLAB

In MATLAB, i vettori sono array monodimensionali che possono contenere numeri reali, complessi o dati di altri tipi. La potenza di MATLAB risiede nella sua capacità di applicare operazioni a interi vettori senza la necessità di cicli espliciti (vectorization).

1.1 Creazione di Vettori

Esistono diversi metodi per creare vettori in MATLAB:

• Notazione esplicita: v = [1, 2, 3, 4, 5]
• Operatore due punti: v = 1:5 (crea [1, 2, 3, 4, 5])
• Funzione linspace: v = linspace(0, 10, 100) (100 punti tra 0 e 10)
• Funzione logspace: v = logspace(0, 2, 50) (50 punti log-spaziati tra 10^0 e 10^2)

// Esempio di creazione vettori x1 = 0:0.1:10; % Da 0 a 10 con passo 0.1 x2 = linspace(0, 10, 50); % 50 punti equispaziati x3 = [1.2, 3.4, 5.6, 7.8]; % Vettore esplicito

1.2 Operazioni Element-wise

MATLAB distingue tra operazioni matriciali (che seguono le regole dell’algebra lineare) e operazioni element-wise (applicate elemento per elemento). Per le operazioni element-wise si usa il punto (.) prima dell’operatore:

• .* Moltiplicazione element-wise
• ./ Divisione element-wise
• .^ Elevamento a potenza element-wise

% Esempi di operazioni element-wise a = [1, 2, 3]; b = [4, 5, 6]; c = a .* b; % [4, 10, 18] d = a.^2; % [1, 4, 9] e = 1./a; % [1, 0.5, 0.333…]

2. Applicazione di Funzioni a Vettori

MATLAB fornisce centinaia di funzioni matematiche pronte all’uso che possono essere applicate direttamente a vettori. Queste funzioni operano element-wise per default.

2.1 Funzioni Matematiche di Base

Funzione	Descrizione	Esempio con x = [0, π/2, π]
sin(x)	Seno	[0, 1, 1.22e-16]
cos(x)	Coseno	[1, 6.12e-17, -1]
exp(x)	Esponenziale (e^x)	[1, 4.8105, 23.1407]
log(x)	Logaritmo naturale	[NaN, 0, 1.1442]
sqrt(x)	Radice quadrata	[0, 1.2533, 1.7725]

2.2 Funzioni Personalizzate

Per applicare funzioni personalizzate a vettori, puoi:

1. Definire una function in un file .m separato
2. Usare function handle anonime
3. Usare arrayfun per operazioni più complesse

% Metodo 1: Function handle anonima square = @(x) x.^2; result = square([1, 2, 3, 4]); % [1, 4, 9, 16] % Metodo 2: arrayfun (per operazioni più complesse) complexOp = @(x) sin(x) + log(x+1); result = arrayfun(complexOp, linspace(0, 5, 10));

3. Ottimizzazione delle Prestazioni

Quando lavori con vettori di grandi dimensioni in MATLAB, le prestazioni diventano cruciali. Ecco alcune tecniche per ottimizzare i tuoi calcoli:

3.1 Preallocazione della Memoria

La preallocazione è una delle tecniche più importanti per migliorare le prestazioni. MATLAB ottimizza le operazioni quando sa in anticipo le dimensioni degli array.

% Cattiva pratica (memoria allocata dinamicamente) result = []; for i = 1:10000 result(i) = sin(i/100); end % Buona pratica (preallocazione) result = zeros(1, 10000); for i = 1:10000 result(i) = sin(i/100); end

3.2 Vectorization vs Cicli

La vectorization (evitare cicli espliciti) è generalmente più efficiente in MATLAB:

Metodo	Tempo di Esecuzione (1M elementi)	Leggibilità
Ciclo for	~0.8 secondi	Alta
Vectorization	~0.05 secondi	Media
arrayfun	~0.3 secondi	Alta

% Confronto prestazioni x = linspace(0, 10, 1e6); % Metodo 1: Ciclo for (lento) tic; result1 = zeros(size(x)); for i = 1:length(x) result1(i) = sin(x(i)) + x(i)^2; end toc; % ~0.8s % Metodo 2: Vectorization (veloce) tic; result2 = sin(x) + x.^2; toc; % ~0.05s

4. Visualizzazione dei Risultati

La visualizzazione è fondamentale per comprendere i risultati dei calcoli su vettori. MATLAB offre potenti strumenti di plotting attraverso funzioni come plot, scatter, bar, ecc.

4.1 Tipi di Grafici Comuni

• plot(x, y): Grafico a linea (ideale per funzioni continue)
• scatter(x, y): Grafico a dispersione (per dati discreti)
• bar(x, y): Grafico a barre (per confronti)
• stem(x, y): Grafico a stelo (per sequenze discrete)

x = linspace(0, 2*pi, 100); y1 = sin(x); y2 = cos(x); figure; subplot(2,1,1); plot(x, y1, ‘b-‘, ‘LineWidth’, 2); title(‘Funzione Seno’); xlabel(‘x’); ylabel(‘sin(x)’); grid on; subplot(2,1,2); plot(x, y2, ‘r–‘, ‘LineWidth’, 2); title(‘Funzione Coseno’); xlabel(‘x’); ylabel(‘cos(x)’); grid on;

4.2 Personalizzazione dei Grafici

MATLAB permette una personalizzazione estesa dei grafici:

x = linspace(0, 4*pi, 200); y = exp(-0.1*x) .* sin(x); figure; plot(x, y, ‘Color’, [0.85, 0.33, 0.1], ‘LineWidth’, 2); title(‘Funzione Smorzata: e^{-0.1x} \cdot sin(x)’, ‘FontSize’, 14); xlabel(‘Tempo (s)’, ‘FontWeight’, ‘bold’); ylabel(‘Ampiezza’, ‘FontWeight’, ‘bold’); grid on; set(gca, ‘GridAlpha’, 0.3); legend(‘Segnale smorzato’, ‘Location’, ‘northeast’);

5. Applicazioni Avanzate

5.1 Operazioni su Vettori Complessi

MATLAB gestisce nativamente i numeri complessi, permettendo operazioni avanzate su vettori complessi:

% Creazione di un vettore complesso t = linspace(0, 2*pi, 100); z = exp(1i*t); % Vettore sulla circonferenza unitaria % Operazioni su vettori complessi magnitude = abs(z); % Modulo phase = angle(z); % Fase real_part = real(z); % Parte reale imag_part = imag(z); % Parte immaginaria % Visualizzazione figure; subplot(2,2,1); plot(z, ‘b.’, ‘MarkerSize’, 10); title(‘Punti nel piano complesso’); axis equal; grid on; subplot(2,2,2); plot(t, magnitude); title(‘Modulo’); subplot(2,2,3); plot(t, real_part, ‘r’, t, imag_part, ‘b’); title(‘Parti reale e immaginaria’); legend(‘Reale’, ‘Immaginaria’);

5.2 Elaborazione di Segnali

Un’applicazione comune dei vettori in MATLAB è l’elaborazione dei segnali. Ecco un esempio di filtraggio di un segnale:

% Generazione di un segnale con rumore Fs = 1000; % Frequenza di campionamento t = 0:1/Fs:1; % Vettore tempo f = 50; % Frequenza del segnale signal = sin(2*pi*f*t); noise = 0.5*randn(size(t)); noisy_signal = signal + noise; % Filtro passa-basso (media mobile) windowSize = 5; b = (1/windowSize)*ones(1, windowSize); filtered_signal = filter(b, 1, noisy_signal); % Visualizzazione figure; subplot(3,1,1); plot(t, signal); title(‘Segnale pulito’); subplot(3,1,2); plot(t, noisy_signal); title(‘Segnale con rumore’); subplot(3,1,3); plot(t, filtered_signal); title(‘Segnale filtrato’);

6. Errori Comuni e Soluzioni

Quando si lavorano con funzioni su vettori in MATLAB, è facile incorrere in alcuni errori comuni. Ecco i più frequenti e come evitarli:

1. Dimensione incompatibile degli array

   Errore: Matrix dimensions must agree

   Soluzione: Assicurati che tutti i vettori coinvolti nelle operazioni abbiano la stessa dimensione. Usa length(vettore) per verificare.

2. Operazioni matriciali vs element-wise

   Errore: Risultati inattesi quando si usa * invece di .*

   Soluzione: Ricorda che A*B è prodotto matriciale, mentre A.*B è prodotto element-wise.

3. Divisione per zero

   Errore: Warning: Divide by zero

   Soluzione: Usa find per identificare e gestire i valori problematici:

   x = -5:0.1:5; y = 1./x; % Genera warning per x=0 % Soluzione alternativa y = zeros(size(x)); valid = x ~= 0; y(valid) = 1./x(valid); y(~valid) = Inf; % o NaN
4. Precisione numerica

   Errore: Risultati inattesi dovuti alla precisione finita dei float

   Soluzione: Usa format long per visualizzare più decimali e considera l’uso di vpa (Variable Precision Arithmetic) per calcoli ad alta precisione.

7. Best Practices per il Codice MATLAB

Seguire queste best practices ti aiuterà a scrivere codice MATLAB più efficiente, leggibile e manutenibile:

• Commenta il tuo codice: Spiega lo scopo di ogni sezione e delle operazioni più complesse.
• Usa nomi significativi: tempo_ms è meglio di t o x.
• Modularizza il codice: Dividi il codice in funzioni più piccole con scopi ben definiti.
• Valida gli input: Controlla che i vettori in input abbiano le dimensioni e i valori attesi.
• Prealloca la memoria: Come mostrato precedentemente, questo migliorerà significativamente le prestazioni.
• Usa la vectorization: Evita cicli for quando possibile.
• Documenta le funzioni: Usa la sintassi di help di MATLAB per documentare le tue funzioni.

% Esempio di funzione ben documentata function y = applyFunctionToVector(fhandle, x) % APPLYFUNCTIONTOVECTOR Applica una funzione a un vettore % y = APPLYFUNCTIONTOVECTOR(fhandle, x) applica la funzione fhandle % a ciascun elemento del vettore x e restituisce il risultato y. % % Input: % fhandle – handle alla funzione da applicare (es: @sin) % x – vettore di input (deve essere numerico) % % Output: % y – vettore risultato della stessa dimensione di x % % Esempio: % y = applyFunctionToVector(@(x)x.^2, 1:10); % % Calcola il quadrato di ciascun elemento da 1 a 10 % Validazione input if ~isa(fhandle, ‘function_handle’) error(‘Il primo argomento deve essere un function handle’); end if ~isnumeric(x) error(‘Il secondo argomento deve essere un array numerico’); end % Applicazione della funzione (vectorized) y = fhandle(x); end

8. Risorse Esterne e Approfondimenti

Per approfondire l’argomento, consulta queste risorse autorevoli:

Documentazione Ufficiale MATLAB:

La documentazione completa sugli array e le operazioni vettoriali è disponibile sul sito ufficiale di MathWorks. Include esempi pratici e spiegazioni dettagliate su tutte le funzioni matematiche disponibili.

MathWorks: Array vs Matrix Operations

Corsi Universitari su MATLAB:

Il Massachusetts Institute of Technology (MIT) offre materiali didattici gratuiti su MATLAB attraverso il suo programma OpenCourseWare. Questi includono esercitazioni specifiche sulle operazioni vettoriali.

MIT OpenCourseWare: Introduction to MATLAB

Standard IEEE per il Calcolo Numerico:

Lo standard IEEE 754 definisce l’aritmetica in virgola mobile utilizzata da MATLAB. Comprenderne i principi è fondamentale per lavorare con precisione numerica in applicazioni scientifiche.

IEEE Standard 754 for Floating-Point Arithmetic

9. Esempi Pratici Completi

Vediamo alcuni esempi completi che combinano diversi concetti discussi:

9.1 Analisi di una Funzione Polinomiale

% Definizione del polinomio: p(x) = 2x^3 – 6x^2 + 2x + 1 p = @(x) 2*x.^3 – 6*x.^2 + 2*x + 1; % Dominio x = linspace(-2, 4, 200); % Calcolo della funzione e della sua derivata y = p(x); dy = @(x) 6*x.^2 – 12*x + 2; % Derivata di p(x) dy_val = dy(x); % Punti critici (dove dy = 0) critical_points = roots([6, -12, 2]); % Visualizzazione figure; subplot(2,1,1); plot(x, y, ‘LineWidth’, 2); hold on; plot(critical_points, p(critical_points), ‘ro’, ‘MarkerSize’, 10); title(‘Funzione Polinomiale e Punti Critici’); xlabel(‘x’); ylabel(‘p(x)’); grid on; legend(‘p(x)’, ‘Punti critici’); subplot(2,1,2); plot(x, dy_val, ‘LineWidth’, 2); title(‘Derivata della Funzione’); xlabel(‘x’); ylabel(‘p”(x)’); grid on;

9.2 Simulazione di un Sistema Fisico

Esempio di simulazione del moto di un proiettile con resistenza dell’aria:

% Parametri fisici g = 9.81; % Accelerazione di gravità (m/s^2) m = 0.1; % Massa del proiettile (kg) k = 0.01; % Coefficiente di resistenza v0 = 50; % Velocità iniziale (m/s) theta = pi/4; % Angolo di lancio (45 gradi) % Componenti della velocità iniziale v0x = v0 * cos(theta); v0y = v0 * sin(theta); % Simulazione con metodo di Eulero dt = 0.01; % Passo temporale t_max = 10; % Tempo massimo di simulazione t = 0:dt:t_max; % Inizializzazione vettori x = zeros(size(t)); y = zeros(size(t)); vx = zeros(size(t)); vy = zeros(size(t)); % Condizioni iniziali x(1) = 0; y(1) = 0; vx(1) = v0x; vy(1) = v0y; % Simulazione for i = 1:length(t)-1 % Forze (resistenza proporzionale al quadrato della velocità) Fx = -k * vx(i) * sqrt(vx(i)^2 + vy(i)^2); Fy = -m*g – k * vy(i) * sqrt(vx(i)^2 + vy(i)^2); % Aggiornamento velocità (F = ma) vx(i+1) = vx(i) + Fx/m * dt; vy(i+1) = vy(i) + Fy/m * dt; % Aggiornamento posizione x(i+1) = x(i) + vx(i) * dt; y(i+1) = y(i) + vy(i) * dt; % Condizione di arresto (y < 0) if y(i+1) < 0 x(i+1:end) = x(i); y(i+1:end) = 0; break; end end % Visualizzazione figure; plot(x, y, 'LineWidth', 2); title('Traiettoria del Proiettile con Resistenza dell''Aria'); xlabel('Distanza Orizontale (m)'); ylabel('Altezza (m)'); grid on; axis equal; % Calcolo della gittata range = x(y >= 0); fprintf(‘Gittata massima: %.2f metri\n’, max(range));

10. Conclusione

L’applicazione di funzioni a vettori è una delle operazioni più fondamentali e potenti in MATLAB. Questa guida ha coperto:

• Le basi della creazione e manipolazione di vettori
• L’applicazione di funzioni matematiche built-in e personalizzate
• Tecniche di ottimizzazione per migliorare le prestazioni
• Metodi avanzati per operazioni complesse e elaborazione dei segnali
• Best practices per scrivere codice MATLAB efficiente e manutenibile
• Esempi pratici completi che combinano diversi concetti

Ricorda che la chiave per diventare proficiente con MATLAB è la pratica. Sperimenta con i concetti presentati in questa guida, modifica gli esempi e applicali ai tuoi specifici problemi ingegneristici o scientifici. La documentazione ufficiale di MATLAB è una risorsa inestimabile per approfondire qualsiasi argomento trattato.

Per problemi complessi, considera di suddividere il problema in parti più piccole, testare ciascuna parte individualmente, e poi combinarle. Questo approccio modulare non solo semplifica il debugging, ma rende anche il tuo codice più riutilizzabile per progetti futuri.