import numpy as np
from .config import obtenir_precision
[docs]
def print_table(donnees, entetes=None):
"""
Affiche une table de maniere formatee dans la console.
Args:
donnees (list): Liste de listes ou liste de dictionnaires.
entetes (list, optional): Liste des noms de colonnes.
"""
if not donnees:
print("Table vide.")
return
prec = obtenir_precision()
if isinstance(donnees[0], dict):
if entetes is None: entetes = list(donnees[0].keys())
lignes = [[row.get(h, "") for h in entetes] for row in donnees]
else:
lignes = donnees
lignes_formatees = []
for ligne in lignes:
f_ligne = []
for val in ligne:
if isinstance(val, (float, np.float64, np.float32)):
f_ligne.append(f"{val:.{prec}f}")
else:
f_ligne.append(str(val))
lignes_formatees.append(f_ligne)
entetes_f = [str(h) for h in entetes] if entetes else None
# Largeurs
toutes = ([entetes_f] if entetes_f else []) + lignes_formatees
largeurs = [max(len(str(item)) for item in col) for col in zip(*toutes)]
def print_ligne(ligne):
print(" | ".join(f"{str(item):<{largeurs[i]}}" for i, item in enumerate(ligne)))
if entetes_f:
print_ligne(entetes_f)
print("-+-".join("-" * w for w in largeurs))
for row in lignes_formatees:
print_ligne(row)
[docs]
def divided_difference_table(x, y):
"""
Calcule et affiche le tableau des differences divisees.
Args:
x (ndarray): Points d'abscisse.
y (ndarray): Points d'ordonnee.
Returns:
ndarray: La table complete des differences divisees.
"""
n = len(y)
table = np.zeros((n, n))
table[:, 0] = y
for j in range(1, n):
for i in range(n - j):
table[i, j] = (table[i + 1, j - 1] - table[i, j - 1]) / (x[i + j] - x[i])
print("\n--- Table des Differences Divisees ---")
headers = ["xi", "f[xi]"] + [f"f[{'x'* (k+1)}]" for k in range(1, n)]
data = []
for i in range(n):
row = [x[i]] + [table[i, j] if j < n-i else "" for j in range(n)]
data.append(row)
print_table(data, headers)
return table
[docs]
def interpolation_table(x, y):
print("\n--- Donnees d'interpolation ---")
data = [[i, x[i], y[i]] for i in range(len(x))]
print_table(data, ["i", "xi", "yi"])
[docs]
def integration_table(f, a, b, ns):
from .integration import trapeze_compose, simpson_compose
print("\n--- Convergence Integration ---")
data = []
for n in ns:
t_val = trapeze_compose(f, a, b, n)
try:
s_val = simpson_compose(f, a, b, n)
data.append([n, t_val, s_val])
except:
data.append([n, t_val, "N/A"])
print_table(data, ["n", "Trapeze", "Simpson"])
[docs]
def iteration_table(vals, labels=None):
print("\n--- Table des Iterations ---")
print_table(vals, labels)