Merge pull request #1 from adambard/master

update

1 files changed, 526 insertions, 0 deletions

diff --git a/it-it/matlab-it.html.markdown b/it-it/matlab-it.html.markdown
new file mode 100644
index 00000000..8d6d4385
--- /dev/null
+++ b/it-it/matlab-it.html.markdown
@@ -0,0 +1,526 @@
+---
+language: Matlab
+contributors:
+    - ["mendozao", "http://github.com/mendozao"]
+    - ["jamesscottbrown", "http://jamesscottbrown.com"]
+    - ["Colton Kohnke", "http://github.com/voltnor"]
+translators:
+    - ["Samuele Gallerani", "http://github.com/fontealpina"]
+lang: it-it
+filename: matlab-it.md
+---
+
+MATLAB sta per MATrix LABoratory ed è un potente linguaggio per il calcolo numerico comunemente usato in ingegneria e matematica.
+
+```matlab
+% I commenti iniziano con il segno percentuale.
+
+%{
+I commenti multilinea
+assomigliano a
+qualcosa
+del genere
+%}
+
+% i comandi possono essere spezzati su più linee, usando '...':
+ a = 1 + 2 + ...
+ + 4
+
+% i comandi possono essere passati al sistema operativo
+!ping google.com
+
+who % Mostra tutte le variabili in memoria
+whos % Mostra tutte le variabili in memoria, con i loro tipi
+clear % Cancella tutte le tue variabili dalla memoria
+clear('A') % Cancella una particolare variabile
+openvar('A') % Apre la variabile in un editor di variabile
+
+clc % Cancella il contenuto della Command Window
+diary % Attiva il log della Command Window su file
+ctrl-c % Interrompe il calcolo corrente
+
+edit('myfunction.m') % Apre la funzione/script nell'editor
+type('myfunction.m') % Stampa il codice della funzione/script sulla Command Window
+
+profile on 	% Attiva la profilazione del codice
+profile off 	% Disattiva la profilazione del codice
+profile viewer 	% Apre il profilatore
+
+help comando 	% Mostra la documentazione di comando sulla Command Window
+doc comando 	% Mostra la documentazione di comando sulla Help Window
+lookfor comando % Cerca comando nella prima linea di commento di tutte le funzioni
+lookfor comando -all % Cerca comando in tutte le funzioni
+
+
+% Formattazione dell'output
+format short 	% 4 decimali in un numero float
+format long 	% 15 decimali
+format bank 	% Solo due cifre decimali - per calcoli finaziari
+fprintf('text') % Stampa "text" a terminale
+disp('text') 	% Stampa "text" a terminale
+
+% Variabili ed espressioni
+miaVariabile = 4 % Il pannello Workspace mostra la nuova variabile creata
+miaVariabile = 4; % Il punto e virgola evita che l'output venga stampato sulla Command Window
+4 + 6  		% ans = 10
+8 * myVariable 	% ans = 32
+2 ^ 3 		% ans = 8
+a = 2; b = 3;
+c = exp(a)*sin(pi/2) % c = 7.3891
+
+% La chiamata di funzioni può essere fatta in due modi differenti:
+% Sintassi standard di una funzione:
+load('myFile.mat', 'y') % argomenti tra parentesi, separati da virgole
+% Sintassi di tipo comando:
+load myFile.mat y 	% Non ci sono parentesi e gli argometi sono separati da spazi
+% Notare la mancanza di apici nella sintassi di tipo comando: gli input sono sempre passati come
+% testo letterale - non è possibile passare valori di variabili. Inoltre non può ricevere output:
+[V,D] = eig(A);  % Questa non ha una forma equivalente con una sintassi di tipo comando
+[~,D] = eig(A);  % Se si vuole solo D e non V
+
+
+
+% Operatori logici
+1 > 5 % ans = 0
+10 >= 10 % ans = 1
+3 ~= 4 % Not equal to -> ans = 1
+3 == 3 % equal to -> ans = 1
+3 > 1 && 4 > 1 % AND -> ans = 1
+3 > 1 || 4 > 1 % OR -> ans = 1
+~1 % NOT -> ans = 0
+
+% Gli operatori logici possono essere applicati alle matrici:
+A > 5
+% Per ogni elemento, se la condizione è vera, quell'elemento vale 1 nella matrice risultante
+A( A > 5 )
+% Restituisce un vettore contenente gli elementi in A per cui la condizione è vera
+
+% Stringhe
+a = 'MyString'
+length(a) % ans = 8
+a(2) % ans = y
+[a,a] % ans = MyStringMyString
+
+
+% Celle
+a = {'one', 'two', 'three'}
+a(1) % ans = 'one' - ritorna una cella
+char(a(1)) % ans = one - ritorna una stringa
+
+% Strutture
+A.b = {'one','two'};
+A.c = [1 2];
+A.d.e = false;
+
+% Vettori
+x = [4 32 53 7 1]
+x(2) % ans = 32, gli indici in Matlab iniziano da 1, non da 0
+x(2:3) % ans = 32 53
+x(2:end) % ans = 32 53 7 1
+
+x = [4; 32; 53; 7; 1] % Vettore colonna
+
+x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10
+
+% Matrici
+A = [1 2 3; 4 5 6; 7 8 9]
+% Le righe sono separate da punto e virgola, mentre gli elementi sono separati da spazi
+% A =
+
+%     1     2     3
+%     4     5     6
+%     7     8     9
+
+A(2,3) % ans = 6, A(row, column)
+A(6) % ans = 8
+% (implicitamente concatena le colonne in un vettore, e quindi gli indici sono riferiti al vettore)
+
+
+A(2,3) = 42 % Aggiorna riga 2 colonna 3 con 42
+% A =
+
+%     1     2     3
+%     4     5     42
+%     7     8     9
+
+A(2:3,2:3) % Crea una nuova matrice a partire da quella precedente
+%ans =
+
+%     5     42
+%     8     9
+
+A(:,1) % Tutte le righe nella colonna 1
+%ans =
+
+%     1
+%     4
+%     7
+
+A(1,:) % Tutte le colonne in riga 1
+%ans =
+
+%     1     2     3
+
+[A ; A] % Concatenazione di matrici (verticalmente)
+%ans =
+
+%     1     2     3
+%     4     5    42
+%     7     8     9
+%     1     2     3
+%     4     5    42
+%     7     8     9
+
+% è equivalente a
+vertcat(A,A);
+
+
+[A , A] % Concatenazione di matrici (orrizontalmente)
+
+%ans =
+
+%     1     2     3     1     2     3
+%     4     5    42     4     5    42
+%     7     8     9     7     8     9
+
+% è equivalente a
+horzcat(A,A);
+
+
+A(:, [3 1 2]) % Ripristina le colonne della matrice originale
+%ans =
+
+%     3     1     2
+%    42     4     5
+%     9     7     8
+
+size(A) % ans = 3 3
+
+A(1, :) =[] % Rimuove la prima riga della matrice
+A(:, 1) =[] % Rimuove la prima colonna della matrice
+
+transpose(A) % Traspone la matrice, equivale a:
+A one
+ctranspose(A) % Trasposizione hermitiana della matrice
+% (ovvero il complesso coniugato di ogni elemento della matrice trasposta)
+
+
+
+
+% Aritmetica Elemento per Elemento vs. Artimetica Matriciale
+% Gli operatori aritmetici da soli agliscono sull'intera matrice. Quando sono preceduti
+% da un punto, allora agiscono su ogni elemento. Per esempio:
+A * B % Moltiplicazione matriciale
+A .* B % Moltiplica ogni elemento di A per il corrispondente elemento di B
+
+% Ci sono diverse coppie di funzioni, in cui una agisce su ogni elemento, e
+% l'altra (il cui nome termina con m) agisce sull'intera matrice.
+exp(A) % Calcola l'esponenziale di ogni elemento
+expm(A) % Calcola la matrice esponenziale
+sqrt(A) % Calcola la radice quadrata di ogni elemento
+sqrtm(A) % Trova la matrice di cui A nè è la matrice quadrata
+
+
+% Plot di grafici
+x = 0:.10:2*pi; % Crea un vettore che inizia a 0 e termina 2*pi con incrementi di .1
+y = sin(x);
+plot(x,y)
+xlabel('x axis')
+ylabel('y axis')
+title('Plot of y = sin(x)')
+axis([0 2*pi -1 1]) % x range da 0 a 2*pi, y range da -1 a 1
+
+plot(x,y1,'-',x,y2,'--',x,y3,':') % Per stampare più funzioni in unico plot
+legend('Line 1 label', 'Line 2 label') % Aggiunge un etichetta con il nome delle curve
+
+% Metodo alternativo per stampare funzioni multiple in un unico plot.
+% mentre 'hold' è on, i comandi sono aggiunti al grafico esistene invece di sostituirlo
+plot(x, y)
+hold on
+plot(x, z)
+hold off
+
+loglog(x, y) % Un plot di tipo log-log
+semilogx(x, y) % Un plot con asse x logaritmico
+semilogy(x, y) % Un plot con asse y logaritmico
+
+fplot (@(x) x^2, [2,5]) % Stampa la funzione x^2 da x=2 a x=5
+
+grid on % Mostra la griglia, disattivare con 'grid off'
+axis square % Rende quadrata la regione individuata dagli assi
+axis equal % Iposta l'aspetto del grafico in modo che le unità degli assi siano le stesse
+
+scatter(x, y); % Scatter-plot
+hist(x); % Istogramma
+
+z = sin(x);
+plot3(x,y,z); % Stampa una linea 3D
+
+pcolor(A) % Heat-map di una matrice: stampa una griglia di rettangoli, colorati in base al valore
+contour(A) % Contour plot di una matrice
+mesh(A) % Stampa come una superfice di mesh
+
+h = figure	% Crea un nuovo oggetto figura, con handle f
+figure(h) % Rende la figura corrispondente al handle h la figura corrente
+close(h) % Chiude la figura con handle h
+close all % Chiude tutte le figure
+close % Chiude la figura corrente
+
+shg % Riutilizza una finestra grafica già esistente, o se necessario ne crea una nuova
+clf clear % Pulisce la figura corrente, e resetta le proprietà della figura
+
+% Le proprietà possono essere impostate e modificate attraverso l'handle della figura.
+% Si può salvare l'handle della figura quando viene creata.
+% La funzione gcf restituisce un handle alla figura attuale.
+h = plot(x, y); % Si può salvare un handle della figura quando viene creata
+set(h, 'Color', 'r')
+% 'y' yellow; 'm' magenta, 'c' cyan, 'r' red, 'g' green, 'b' blue, 'w' white, 'k' black
+set(h, 'LineStyle', '--')
+ % '--' linea continua, '---' tratteggiata, ':' puntini, '-.' trattino-punto, 'none' nessuna linea
+get(h, 'LineStyle')
+
+
+% La funzione gca restituisce un handle degli assi della figura corrente
+set(gca, 'XDir', 'reverse'); % Inverte la direzione dell'asse x
+
+% Per creare una figura che contiene diverse sottofigure, usare subplot
+subplot(2,3,1); % Seleziona la prima posizione in una griglia 2 per 3 di sottofigure
+plot(x1); title('First Plot') % Stampa qualcosa in questa posizione
+subplot(2,3,2); % Seleziona la seconda posizione nella griglia
+plot(x2); title('Second Plot') % Stampa qualcosa in questa posizione
+
+
+% Per usare funzioni o script, devono essere nel tuo path o nella directory corrente
+path % Mostra il path corrente
+addpath /path/to/dir % Aggiunge al path
+rmpath /path/to/dir % Rimuove dal path
+cd /path/to/move/into % Cambia directory
+
+
+% Le variabili possono essere salvate in file .mat
+save('myFileName.mat') % Salva le variabili nel tuo Workspace
+load('myFileName.mat') % Carica variabili salvate nel tuo Workspace
+
+% M-file Scripts
+% I file di script sono file esterni che contengono una sequenza di istruzioni.
+% Permettono di evitare di scrivere ripetutamente lo stesso codice nella Command Window
+% Hanno estensione .m
+
+% M-file Functions
+% Come gli script, hanno la stessa estensione .m
+% Ma possono accettare argomenti di input e restituire un output.
+% Inoltre, hanno un proprio workspace (differente scope delle variabili).
+% Il nome della funzione dovrebbe coincidere con il nome del file (quindi salva questo esempio come double_input.m).
+% 'help double_input.m' restituisce i commenti sotto alla linea iniziale della funzione
+function output = double_input(x)
+	%double_input(x) restituisce il doppio del valore di x
+	output = 2*x;
+end
+double_input(6) % ans = 12
+
+
+% Si possono anche avere sottofunzioni e funzioni annidate.
+% Le sottofunzioni sono nello stesso file della funzione primaria, e possono solo essere
+% chiamate da funzioni nello stesso file. Le funzioni annidate sono definite dentro ad altre
+% funzioni, e hanno accesso ad entrambi i workspace.
+
+% Se si vuole creare una funzione senza creare un nuovo file si può usare una
+% funzione anonima. Utile quando si vuole definire rapidamente una funzione da passare ad
+% un'altra funzione (es. stampa con fplot, valutare un integrale indefinito
+% con quad, trovare le radici con fzenzro, o trovare il minimo con fminsearch).
+% Esempio che restituisce il quadrato del proprio input, assegnato all'handle sqr:
+sqr = @(x) x.^2;
+sqr(10) % ans = 100
+doc function_handle % scopri di più
+
+% Input dell'utente
+a = input('Enter the value: ')
+
+% Ferma l'esecuzione del file e cede il controllo alla tastiera: l'utente può esaminare
+% o cambiare variabili. Digita 'return' per continuare l'esecuzione, o 'dbquit' per uscire
+keyboard
+
+% Importarare dati (anche xlsread/importdata/imread per excel/CSV/image file)
+fopen(filename)
+
+% Output
+disp(a) % Stampa il valore della variabile a
+disp('Hello World') % Stampa una stringa
+fprintf % Stampa sulla Command Window con più controllo
+
+% Istruzioni condizionali (le parentesi sono opzionali, ma un buon stile)
+if (a > 15)
+	disp('Maggiore di 15')
+elseif (a == 23)
+	disp('a è 23')
+else
+	disp('nessuna condizione verificata')
+end
+
+% Cicli
+% NB. Ciclare su elementi di vettori/matrici è lento!
+% Dove possibile, usa funzioni che agiscono sull'intero vettore/matrice
+for k = 1:5
+	disp(k)
+end
+
+k = 0;
+while (k < 5)
+	k = k + 1;
+end
+
+% Misurare la durata dell'esecuzione del codice: 'toc' stampa il tempo trascorso da quando 'tic' è stato chiamato
+tic
+A = rand(1000);
+A*A*A*A*A*A*A;
+toc
+
+% Connessione a un Database MySQL
+dbname = 'database_name';
+username = 'root';
+password = 'root';
+driver = 'com.mysql.jdbc.Driver';
+dburl = ['jdbc:mysql://localhost:8889/' dbname];
+javaclasspath('mysql-connector-java-5.1.xx-bin.jar');
+% xx dipende dalla versione, download disponibile all'indirizzo http://dev.mysql.com/downloads/connector/j/
+conn = database(dbname, username, password, driver, dburl);
+sql = ['SELECT * from table_name where id = 22'] % Esempio istruzione sql
+a = fetch(conn, sql) % conterra i tuoi dati
+
+
+% Funzioni matematiche comuni
+sin(x)
+cos(x)
+tan(x)
+asin(x)
+acos(x)
+atan(x)
+exp(x)
+sqrt(x)
+log(x)
+log10(x)
+abs(x)
+min(x)
+max(x)
+ceil(x)
+floor(x)
+round(x)
+rem(x)
+rand % Numeri pseudocasuali uniformemente distribuiti
+randi % Numeri interi pseudocasuali uniformemente distrubuiti
+randn % Numeri pseudocasuali distrbuiti normalmente
+
+% Costanti comuni
+pi
+NaN
+inf
+
+% Risolvere equazioni matriciali
+% Gli operatori \ e / sono equivalenti alle funzioni mldivide e mrdivide
+x=A\b % Risolve Ax=b. Più veloce e più accurato numericamente rispetto ad usare inv(A)*b.
+x=b/A % Risolve xA=b
+
+inv(A) % Calcola la matrice inversa
+pinv(A) % Calcola la matrice pseudo-inversa
+
+% Funzioni comuni su matrici
+zeros(m,n) % Matrice m x n di zeri
+ones(m,n) % Matrice m x n di uni
+diag(A) % Estrae gli elementi della diagonale della matrice A
+diag(x) % Costruisce una matrice con elementi diagonali uguali agli elementi di x, e zero negli altri elementi
+eye(m,n) % Matrice identità
+linspace(x1, x2, n) % Ritorna n punti equamente distanziati, con minimo x1 e massimo x2
+inv(A) % Matrice inversa di A
+det(A) % Determinante di A
+eig(A) % Autovalori e autovettori di A
+trace(A) % Traccia della matrice -  equivalente a sum(diag(A))
+isempty(A) % Verifica se l'array è vuoto
+all(A) % Verifica se tutti gli elementi sono nonzero o veri
+any(A) % Verifica se almento un elemento è nonzero o vero
+isequal(A, B) % Verifica l'uguaglianza di due array
+numel(A) % Numero di elementi nella matrice
+triu(x) % Ritorna la parte triangolare superiore di x
+tril(x) % Ritorna la parte triangolare inferiore di x
+cross(A,B) %  Ritorna il prodotto vettoriale dei vettori A e B
+dot(A,B) % Ritorna il prodotto scalare di due vettori (devono avere la stessa lunghezza)
+transpose(A) % Ritorna la trasposta di A
+fliplr(A) % Capovolge la matrice da sinistra a destra
+flipud(A) % Capovolge la matrice da sopra a sotto
+
+% Fattorizzazione delle matrici
+[L, U, P] = lu(A) % Decomposizione LU: PA = LU, L è il triangolo inferiore, U è il triangolo superiore, P è la matrice di permutazione
+[P, D] = eig(A) % Auto-decomposizione: AP = PD, le colonne di P sono autovettori e gli elementi sulle diagonali di D sono autovalori
+[U,S,V] = svd(X) % SVD: XV = US, U e V sono matrici unitarie, S ha gli elementi della diagonale non negativi in ordine decrescente
+
+% Funzioni comuni su vettori
+max     % elemento più grande
+min     % elemento più piccolo
+length  % lunghezza del vettore
+sort    % ordina in modo crescente
+sum     % somma degli elementi
+prod    % prodotto degli elementi
+mode	% valore moda
+median  % valore mediano
+mean    % valore medio
+std     % deviazione standard
+perms(x) % lista tutte le permutazioni di elementi di x
+
+
+% Classi
+% Matlab supporta la programmazione orientata agli oggetti.
+% La classe deve essere messa in un file con lo stesso nome della classe e estensione .m
+% Per iniziare, creiamo una semplice classe per memorizzare waypoint GPS
+% Inizio WaypointClass.m
+classdef WaypointClass % Il nome della classe.
+  properties % Le proprietà della classe funzionano come Strutture
+    latitude
+    longitude
+  end
+  methods
+    % Questo metodo che ha lo stesso nome della classe è il costruttore
+    function obj = WaypointClass(lat, lon)
+      obj.latitude = lat;
+      obj.longitude = lon;
+    end
+
+    % Altre funzioni che usano l'oggetto Waypoint
+    function r = multiplyLatBy(obj, n)
+      r = n*[obj.latitude];
+    end
+
+    % Se si vuole aggiungere due oggetti Waypoint insieme senza chiamare
+    % una funzione speciale si può sovradefinire una funzione aritmetica di Matlab come questa:
+    function r = plus(o1,o2)
+      r = WaypointClass([o1.latitude] +[o2.latitude], ...
+                        [o1.longitude]+[o2.longitude]);
+    end
+  end
+end
+% End WaypointClass.m
+
+% Si può creare un oggetto della classe usando un costruttore
+a = WaypointClass(45.0, 45.0)
+
+% Le proprietà della classe si comportano esattamente come una Struttura Matlab.
+a.latitude = 70.0
+a.longitude = 25.0
+
+% I metodi possono essere chiamati allo stesso modo delle funzioni
+ans = multiplyLatBy(a,3)
+
+% Il metodo può anche essere chiamato usando una notazione con punto. In questo caso, l'oggetto
+% non necessita di essere passato al metodo.
+ans = a.multiplyLatBy(a,1/3)
+
+% Le funzioni Matlab possono essere sovradefinite per gestire oggetti.
+% Nel metodo sopra, è stato sovradefinito come Matlab gestisce
+% l'addizione di due oggetti Waypoint.
+b = WaypointClass(15.0, 32.0)
+c = a + b
+
+```
+
+## Di più su Matlab
+
+* Sito ufficiale [http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/)
+* Forum ufficiale di MATLAB: [http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/)