Didattica & Progetti

import numpy as np

# Definizione della matrice 2x2
A = np.array([[3, 8],
              [4, 6]])

# Metodo 1: usando numpy
det_numpy = np.linalg.det(A)
print(f"det(A) usando numpy: {det_numpy}")

# Metodo 2: calcolo manuale con la formula
a, b = A[0, 0], A[0, 1]
c, d = A[1, 0], A[1, 1]
det_manuale = a*d - b*c
print(f"det(A) calcolo manuale: {det_manuale}")

# Output:
# det(A) usando numpy: -14.000000000000002
# det(A) calcolo manuale: -14

import numpy as np

# Definizione della matrice 3x3
A = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

# Metodo 1: usando numpy
det_numpy = np.linalg.det(A)
print(f"det(A) usando numpy: {det_numpy}")

# Metodo 2: Regola di Sarrus (manuale)
def sarrus(A):
    """Calcola il determinante 3x3 con la regola di Sarrus"""
    # Diagonali discendenti
    pos = (A[0,0]*A[1,1]*A[2,2] +
           A[0,1]*A[1,2]*A[2,0] +
           A[0,2]*A[1,0]*A[2,1])

    # Diagonali ascendenti
    neg = (A[0,2]*A[1,1]*A[2,0] +
           A[0,0]*A[1,2]*A[2,1] +
           A[0,1]*A[1,0]*A[2,2])

    return pos - neg

det_sarrus = sarrus(A)
print(f"det(A) con Sarrus: {det_sarrus}")

# Metodo 3: Sviluppo di Laplace (prima riga)
def laplace_3x3(A):
    """Calcola il determinante 3x3 con sviluppo di Laplace"""
    # Cofattori rispetto alla prima riga
    C11 = A[1,1]*A[2,2] - A[1,2]*A[2,1]
    C12 = -(A[1,0]*A[2,2] - A[1,2]*A[2,0])
    C13 = A[1,0]*A[2,1] - A[1,1]*A[2,0]

    return A[0,0]*C11 + A[0,1]*C12 + A[0,2]*C13

det_laplace = laplace_3x3(A)
print(f"det(A) con Laplace: {det_laplace}")

# Output:
# det(A) usando numpy: -9.51619735392994e-16  (≈ 0)
# det(A) con Sarrus: 0
# det(A) con Laplace: 0

import numpy as np

def det_gauss(A):
    """
    Calcola il determinante usando eliminazione di Gauss
    con riduzione a forma triangolare
    """
    # Copia della matrice per non modificare l'originale
    U = A.astype(float).copy()
    n = len(U)
    det = 1.0

    for i in range(n):
        # Trova il pivot (elemento massimo in valore assoluto)
        max_row = i + np.argmax(np.abs(U[i:, i]))

        # Se il pivot è zero, il determinante è zero
        if abs(U[max_row, i]) < 1e-10:
            return 0.0

        # Scambia le righe se necessario
        if max_row != i:
            U[[i, max_row]] = U[[max_row, i]]
            det *= -1  # Cambio segno per lo scambio

        # Elimina gli elementi sotto il pivot
        for j in range(i + 1, n):
            factor = U[j, i] / U[i, i]
            U[j, i:] -= factor * U[i, i:]

    # Il determinante è il prodotto della diagonale
    for i in range(n):
        det *= U[i, i]

    return det

# Test con diverse matrici
A = np.array([[2, 1, 3],
              [4, -1, 2],
              [1, 2, 1]])

print("Matrice A:")
print(A)
print(f"\ndet(A) con numpy: {np.linalg.det(A):.4f}")
print(f"det(A) con Gauss: {det_gauss(A):.4f}")

# Matrice 4x4
B = np.array([[1, 2, 3, 4],
              [5, 6, 7, 8],
              [9, 10, 11, 12],
              [13, 14, 15, 16]])

print("\n\nMatrice B (4x4):")
print(B)
print(f"\ndet(B) con numpy: {np.linalg.det(B):.4f}")
print(f"det(B) con Gauss: {det_gauss(B):.4f}")

# Output:
# Matrice A:
# [[ 2  1  3]
#  [ 4 -1  2]
#  [ 1  2  1]]
#
# det(A) con numpy: 15.0000
# det(A) con Gauss: 15.0000
#
#
# Matrice B (4x4):
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]
#  [13 14 15 16]]
#
# det(B) con numpy: 0.0000
# det(B) con Gauss: 0.0000

import numpy as np

A = np.array([[1, 2],
              [3, 4]])

B = np.array([[5, 6],
              [7, 8]])

print("Proprietà 1: det(I) = 1")
I = np.eye(2)
print(f"det(I) = {np.linalg.det(I)}")

print("\nProprietà 2: det(AB) = det(A) * det(B)")
det_A = np.linalg.det(A)
det_B = np.linalg.det(B)
det_AB = np.linalg.det(A @ B)
print(f"det(A) = {det_A:.4f}")
print(f"det(B) = {det_B:.4f}")
print(f"det(AB) = {det_AB:.4f}")
print(f"det(A)*det(B) = {det_A * det_B:.4f}")

print("\nProprietà 3: det(A^T) = det(A)")
det_AT = np.linalg.det(A.T)
print(f"det(A) = {det_A:.4f}")
print(f"det(A^T) = {det_AT:.4f}")

print("\nProprietà 5: det(kA) = k^n * det(A)")
k = 2
n = 2  # dimensione matrice
det_kA = np.linalg.det(k * A)
print(f"k = {k}, n = {n}")
print(f"det({k}A) = {det_kA:.4f}")
print(f"{k}^{n} * det(A) = {k**n * det_A:.4f}")

# Output:
# Proprietà 1: det(I) = 1
# det(I) = 1.0
#
# Proprietà 2: det(AB) = det(A) * det(B)
# det(A) = -2.0000
# det(B) = -2.0000
# det(AB) = 4.0000
# det(A)*det(B) = 4.0000
#
# Proprietà 3: det(A^T) = det(A)
# det(A) = -2.0000
# det(A^T) = -2.0000
#
# Proprietà 5: det(kA) = k^n * det(A)
# k = 2, n = 2
# det(2A) = -8.0000
# 2^2 * det(A) = -8.0000