next up previous contents index
Next: Memoria dinamica. Strutture. Liste Up: Matrici Previous: Operazioni base sulle matrici   Indice   Indice analitico

Operazioni avanzate su matrici 3 $\times$ 3

In questa sottosezione vedremo come calcolare il determinante di una matrice quadrata 3 $\times$ 3 e l'inversa di essa. Il determinante di una matrice 2 $\times$ 2 è definito come:

\begin{displaymath}
\left\vert \begin{array}{ll}
a_{11} & a_{12} \\
a_{21} & a_{22} \\
\end{array} \right\vert = a_{11}a_{22} - a_{12}a_{21}
\end{displaymath}

Mentre per una matrice 3 $\times$ 3 abbiamo

\begin{eqnarray*}
\left\vert \begin{array}{lll}
a_{11} & a_{12} & a_{13} \\
a_{...
...
& - & a_{13}a_{22}a_{31}-a_{21}a_{12}a_{33}-a_{23}a_{32}a_{11}
\end{eqnarray*}




// ex6_7_6
#include <iostream.h>

double determinante2 (double m[2][2]) {
  return m[0][0] * m[1][1] -
    m[0][1] * m[1][0];
}

double determinante3 (double m[3][3]) {
  return m[0][0] * m[1][1] * m[2][2] +
    m[0][1] * m[1][2] * m[2][0] +
    m[1][0] * m[2][1] * m[0][2] -
    m[0][2] * m[1][1] * m[2][0] -
    m[1][0] * m[0][1] * m[2][2] -
    m[1][2] * m[2][1] * m[0][0];
}

void main() {
  double m2[2][2];
  double m3[3][3];
  cout << "matrice 2x2:\n";
  for (int i = 0; i < 2; i++)
    for (int j = 0; j < 2; j++) {
      cout << "(" << i << " , " << j << ")? ";
      cin >> m2[i][j];
    }
  cout << "matrice 3x3:\n";
  for (int i = 0; i < 3; i++)
    for (int j = 0; j < 3; j++) {
      cout << "(" << i << " , " << j << ")? ";
      cin >> m3[i][j];
    }
  cout << "det(2x2): " << determinante2 (m2);
  cout << "\ndet(3x3): " <<  determinante3 (m3);
}

esempio di output:
matrice 2x2:
(0 , 0)? 2
(0 , 1)? 1
(1 , 0)? -1
(1 , 1)? .5
matrice 3x3:
(0 , 0)? 0
(0 , 1)? 1
(0 , 2)? -1
(1 , 0)? 2
(1 , 1)? 2
(1 , 2)? 1
(2 , 0)? -1
(2 , 1)? 0
(2 , 2)? 1
det(2x2): 2
det(3x3): -5

Passiamo ora alla costruzione della matrice inversa di una matrice quadrata; in generale, data

\begin{displaymath}
A = \left( \begin{array}{llll}
a_{11} & a_{12} & \ldots & a_...
...dots \\
a_{n1} & a_{n2} & \ldots & a_{nn}
\end{array} \right)
\end{displaymath}

la matrice inversa $A^{-1}$ è:

\begin{displaymath}
A^{-1} = \frac{1}{\vert A\vert} \cdot \left( \begin{array}{l...
...dots \\
A_{1n} & A_{2n} & \ldots & A_{nn}
\end{array} \right)
\end{displaymath}

cosicché si ha $A \cdot A^{-1} = I$; ove $I$ è la matrice identità (quella cioè che ha tutti $1$ sulla diagonale principale e $0$ altrove), $\vert A\vert$ è il determinante di $A$, e $A_{ij}$ è il determinante della matrice ottenuta cancellando la colonna $i$-esima e la riga $j$-esima dalla matrice $A$.

Nel caso di matrice 3 $\times$ 3, è possibile impostare un algoritmo semplice6.5:


// ex6_7_6
// calcola l'inversa di una matrice reale 3x3
#include <iostream.h>

double determinante2 (double m[3][3], int i, int j) {
  double v[4];
  int k = 0;
  for (int x = 0; x < 3; x++)
    for (int y = 0; y < 3; y++)
      if (y != i && x != j) {
        v[k] = m[x][y];
        k++;
      }
  return v[0] * v[3] - v[1] * v[2];
}

double determinante3 (double m[3][3]) {
  return m[0][0] * m[1][1] * m[2][2] +
    m[0][1] * m[1][2] * m[2][0] +
    m[1][0] * m[2][1] * m[0][2] -
    m[0][2] * m[1][1] * m[2][0] -
    m[1][0] * m[0][1] * m[2][2] -
    m[1][2] * m[2][1] * m[0][0];
}

void inverti (double m[3][3]) {
  // matrice ausiliaria
  double aux[3][3];
  double d = determinante3 (m);
  for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
      double Aji = determinante2 (m, i, j);
      aux[i][j] = Aji / d;
    }
  }
  // copiamo la matrice ausiliaria in m
  for (int i = 0; i < 3; i++)
    for (int j = 0; j < 3; j++)
      m[i][j] = aux[i][j];
}

void stampa (double m[3][3]) {
  for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++)
      cout << m[i][j] << "\t";
    cout << "\n";
  }
}

void main() {
  double m[3][3];
  for (int i = 0; i < 3; i++)
    for (int j = 0; j < 3; j++) {
      cout << "(" << i << " , " << j << ")? ";
      cin >> m[i][j];
    }
  stampa (m);
  inverti (m);
  cout << "inversa:\n";
  stampa (m);
}

esempio di output:
(0 , 0)? 1
(0 , 1)? 0
(0 , 2)? 1
(1 , 0)? 2
(1 , 1)? -1
(1 , 2)? 0
(2 , 0)? 2
(2 , 1)? 2
(2 , 2)? 1
 1 0 1
 2 -1 0
 2 2 1

inversa:
 -0.2 -0.4 0.2
 0.4 -0.2 -0.4
 1.2 0.4 -0.2

La funzione più difficile da costruire è forse determinante2; all'interno di essa creiamo un vettore di quattro elementi, inserendo solo i termini della matrice che non appartengono alla riga e alla colonna da eliminare; infine poi torniamo il determinante della matrice 2 $\times$ 2 costruita prendendo in sequenza i quattro elementi del vettore.

ex-2
si scriva una funzione che calcoli la traccia di una matrice 4 $\times$ 4;
ex-3
si scriva un programma che accetti due matrici 3 $\times$ 3 e ne stampi il prodotto;
ex-4
si scriva un programma che generi una matrice 3 $\times$ 4 e calcoli (tramite una apposita funzione) l'arcoseno di ogni elemento; si stampi infine la matrice risultante


next up previous contents index
Next: Memoria dinamica. Strutture. Liste Up: Matrici Previous: Operazioni base sulle matrici   Indice   Indice analitico
Claudio Cicconetti
2000-09-06