PYTHON-th-P19

# 001_08 — Simulation et extrapolation des données

## Objectifs

- Générer des données supplémentaires par extrapolation

- Prédire N(i+1) à N(i+k) avec différents modèles

- Comparer modèle théorique vs données observées

- Calculer des intervalles de confiance

## Structure des feuilles

### Feuille "do_observed"

Données observées d'origine :

- i, ttf(i), dN(i), N(i)

- 10 points (i=0 à i=9)

### Feuille "do_extrapolated"

Données extrapolées :

- Extension jusqu'à i=20

- Colonnes : i, ttf_extrap(i), N_extrap(i)

- Plusieurs méthodes d'extrapolation

### Feuille "do_models"

Comparaison de modèles :

- Colonnes : i, N_observed, N_linear, N_expo, N_weibull

- Modèle linéaire : N(i) = N(0) - k×i

- Modèle exponentiel : N(i) = N(0) × exp(-λ×t)

- Modèle de Weibull : N(i) = N(0) × exp(-(t/η)^β)

### Feuille "do_predictions"

Prédictions avec incertitude :

- Colonnes : i, ttf(i), N_pred(i), IC_inf, IC_sup

- IC (Intervalle de Confiance) à 95%

### Feuille "graph_comparison"

Graphe comparatif :

- Courbes multiples sur même graphe

- Données observées (scatter)

- Modèle linéaire (line)

- Modèle exponentiel (line)

- Zone d'incertitude (area chart)

## Méthodes d'extrapolation

### Extrapolation linéaire

```python

# Régression linéaire sur ttf(i)

slope = (ttf[-1] - ttf[0]) / len(ttf)

ttf_extrap = [ttf[-1] + slope * k for k in range(1, n_extra+1)]

```

### Modèle exponentiel

```python

# Décroissance exponentielle de N(i)

λ = -np.log(N[-1] / N[0]) / ttf[-1]

N_expo = N[0] * np.exp(-λ * ttf)

```

### Interpolation pandas

```python

# Utiliser pd.interpolate() pour combler les valeurs manquantes

df_extended = df.reindex(range(n_extended))

df_extended['N(i)'] = df_extended['N(i)'].interpolate(method='polynomial', order=2)

```

## Calcul d'intervalle de confiance

```python

# Écart-type des résidus

std_residuals = np.std(N_observed - N_predicted)

# IC à 95% (1.96 × σ)

IC_inf = N_pred - 1.96 * std_residuals

IC_sup = N_pred + 1.96 * std_residuals

```

## Concepts démontrés

- Régression et ajustement de modèles

- Comparaison de modèles théoriques

- Quantification de l'incertitude

- Visualisation multi-séries

# 001_08 — Simulation et extrapolation des données

## Objectifs
- Générer des données supplémentaires par extrapolation
- Prédire N(i+1) à N(i+k) avec différents modèles
- Comparer modèle théorique vs données observées
- Calculer des intervalles de confiance

## Structure des feuilles

### Feuille "do_observed"
Données observées d'origine :
- i, ttf(i), dN(i), N(i)
- 10 points (i=0 à i=9)

### Feuille "do_extrapolated"
Données extrapolées :
- Extension jusqu'à i=20
- Colonnes : i, ttf_extrap(i), N_extrap(i)
- Plusieurs méthodes d'extrapolation

### Feuille "do_models"
Comparaison de modèles :
- Colonnes : i, N_observed, N_linear, N_expo, N_weibull
- Modèle linéaire : N(i) = N(0) - k×i
- Modèle exponentiel : N(i) = N(0) × exp(-λ×t)
- Modèle de Weibull : N(i) = N(0) × exp(-(t/η)^β)

### Feuille "do_predictions"
Prédictions avec incertitude :
- Colonnes : i, ttf(i), N_pred(i), IC_inf, IC_sup
- IC (Intervalle de Confiance) à 95%

### Feuille "graph_comparison"
Graphe comparatif :
- Courbes multiples sur même graphe
- Données observées (scatter)
- Modèle linéaire (line)
- Modèle exponentiel (line)
- Zone d'incertitude (area chart)

## Méthodes d'extrapolation

### Extrapolation linéaire
```python
# Régression linéaire sur ttf(i)
slope = (ttf[-1] - ttf[0]) / len(ttf)
ttf_extrap = [ttf[-1] + slope * k for k in range(1, n_extra+1)]
```

### Modèle exponentiel
```python
# Décroissance exponentielle de N(i)
λ = -np.log(N[-1] / N[0]) / ttf[-1]
N_expo = N[0] * np.exp(-λ * ttf)
```

### Interpolation pandas
```python
# Utiliser pd.interpolate() pour combler les valeurs manquantes
df_extended = df.reindex(range(n_extended))
df_extended['N(i)'] = df_extended['N(i)'].interpolate(method='polynomial', order=2)
```

## Calcul d'intervalle de confiance
```python
# Écart-type des résidus
std_residuals = np.std(N_observed - N_predicted)
# IC à 95% (1.96 × σ)
IC_inf = N_pred - 1.96 * std_residuals
IC_sup = N_pred + 1.96 * std_residuals
```

## Concepts démontrés
- Régression et ajustement de modèles
- Comparaison de modèles théoriques
- Quantification de l'incertitude
- Visualisation multi-séries

# TD_EDC_01_001_08.py

# Résumé : Simulation et extrapolation - modèles prédictifs et intervalles de confiance

# Génère 5 feuilles : observed, extrapolated, models, predictions, graph_comparison

from pathlib import Path

import subprocess

import pandas as pd

import numpy as np

import xlsxwriter

def build_paths() -> Path:

    """Calcule le chemin du fichier Excel de sortie."""

    script = Path(__file__).resolve()

    root = script.parent.parent

    stem = script.stem

    base_dir_name = script.parent.name

    xlsx_dir = root / f"{base_dir_name}_do"

    xlsx_dir.mkdir(parents=True, exist_ok=True)

    xlsx_path = (xlsx_dir / f"{stem}.xlsx").resolve()

    return xlsx_path

def delete_if_exists(file_path: Path) -> None:

    """Supprime le fichier s'il existe déjà."""

    if file_path.exists():

        file_path.unlink()

def prepare_observed_data(n: int = 9, ttf_values: list = None) -> pd.DataFrame:

    """Prépare les données observées."""

    i_values = list(range(n + 1))

    dN_values = [0] + [1] * n

    N_values = [n - i for i in range(n + 1)]

    df = pd.DataFrame({

        'i': i_values,

        'ttf(i)': ttf_values if ttf_values else [0] * (n + 1),

        'dN(i)': dN_values,

        'N(i)': N_values

    })

    return df

def extrapolate_data(df: pd.DataFrame, n_extra: int = 10) -> pd.DataFrame:

    """Extrapole les données linéairement."""

    ttf = df['ttf(i)'].values

    # Régression linéaire simple

    slope = (ttf[-1] - ttf[0]) / (len(ttf) - 1)

    # Extrapoler ttf

    i_extrap = list(range(len(df), len(df) + n_extra + 1))

    ttf_extrap = [ttf[-1] + slope * k for k in range(1, n_extra + 2)]

    # Extrapoler N (décroissance linéaire)

    N_extrap = [max(0, df['N(i)'].iloc[-1] - k) for k in range(1, n_extra + 2)]

    df_extrap = pd.DataFrame({

        'i': i_extrap,

        'ttf_extrap(i)': ttf_extrap,

        'N_extrap(i)': N_extrap

    })

    return df_extrap

def calculate_models(df: pd.DataFrame) -> pd.DataFrame:

    """Calcule différents modèles prédictifs."""

    ttf = df['ttf(i)'].values

    N_obs = df['N(i)'].values

    N_0 = N_obs[0]

    # Modèle linéaire : N(i) = N(0) - k*i

    k_linear = (N_obs[0] - N_obs[-1]) / len(N_obs)

    N_linear = [max(0, N_0 - k_linear * i) for i in range(len(ttf))]

    # Modèle exponentiel : N(t) = N(0) * exp(-λ*t)

    if ttf[-1] > 0 and N_obs[-1] > 0:

        lambda_exp = -np.log(N_obs[-1] / N_0) / ttf[-1]

        N_expo = [N_0 * np.exp(-lambda_exp * t) for t in ttf]

    else:

        N_expo = N_obs.tolist()

    # Modèle de Weibull simplifié : N(t) = N(0) * exp(-(t/η)^β)

    # Approximation avec β = 2, η calibré

    if ttf[-1] > 0:

        eta = ttf[-1] / np.sqrt(-np.log(N_obs[-1] / N_0)) if N_obs[-1] > 0 else ttf[-1]

        beta = 2

        N_weibull = [N_0 * np.exp(-((t / eta) ** beta)) if t > 0 else N_0 for t in ttf]

    else:

        N_weibull = N_obs.tolist()

    df_models = pd.DataFrame({

        'i': df['i'],

        'ttf(i)': ttf,

        'N_observed': N_obs,

        'N_linear': N_linear,

        'N_expo': N_expo,

        'N_weibull': N_weibull

    })

    return df_models

def calculate_predictions_with_ci(df: pd.DataFrame) -> pd.DataFrame:

    """Calcule les prédictions avec intervalles de confiance."""

    # Utiliser le modèle exponentiel comme prédiction

    ttf = df['ttf(i)'].values

    N_obs = df['N(i)'].values

    N_0 = N_obs[0]

    if ttf[-1] > 0 and N_obs[-1] > 0:

        lambda_exp = -np.log(N_obs[-1] / N_0) / ttf[-1]

        N_pred = [N_0 * np.exp(-lambda_exp * t) for t in ttf]

    else:

        N_pred = N_obs.tolist()

    # Calculer l'écart-type des résidus

    residuals = N_obs - np.array(N_pred)

    std_residuals = np.std(residuals)

    # Intervalle de confiance à 95% (1.96 * σ)

    IC_inf = [max(0, pred - 1.96 * std_residuals) for pred in N_pred]

    IC_sup = [pred + 1.96 * std_residuals for pred in N_pred]

    df_predictions = pd.DataFrame({

        'i': df['i'],

        'ttf(i)': ttf,

        'N_pred(i)': N_pred,

        'IC_inf': IC_inf,

        'IC_sup': IC_sup

    })

    return df_predictions

def write_to_excel(xlsx_path: Path, df_obs: pd.DataFrame, df_extrap: pd.DataFrame,

                   df_models: pd.DataFrame, df_pred: pd.DataFrame) -> None:

    """Écrit toutes les données dans Excel avec graphe comparatif."""

    workbook = xlsxwriter.Workbook(str(xlsx_path))

    # Feuille 1 : Données observées

    ws_obs = workbook.add_worksheet("do_observed")

    for col_num, col_name in enumerate(df_obs.columns):

        ws_obs.write(0, col_num, col_name)

    for row_num, row_data in enumerate(df_obs.values, start=1):

        for col_num, value in enumerate(row_data):

            ws_obs.write(row_num, col_num, value)

    print(f"✓ Feuille 'do_observed' créée ({len(df_obs)} lignes)")

    # Feuille 2 : Données extrapolées

    ws_extrap = workbook.add_worksheet("do_extrapolated")

    for col_num, col_name in enumerate(df_extrap.columns):

        ws_extrap.write(0, col_num, col_name)

    for row_num, row_data in enumerate(df_extrap.values, start=1):

        for col_num, value in enumerate(row_data):

            ws_extrap.write(row_num, col_num, value)

    print(f"✓ Feuille 'do_extrapolated' créée ({len(df_extrap)} lignes)")

    # Feuille 3 : Modèles comparatifs

    ws_models = workbook.add_worksheet("do_models")

    for col_num, col_name in enumerate(df_models.columns):

        ws_models.write(0, col_num, col_name)

    for row_num, row_data in enumerate(df_models.values, start=1):

        for col_num, value in enumerate(row_data):

            ws_models.write(row_num, col_num, value)

    print(f"✓ Feuille 'do_models' créée ({len(df_models)} lignes)")

    # Feuille 4 : Prédictions avec IC

    ws_pred = workbook.add_worksheet("do_predictions")

    for col_num, col_name in enumerate(df_pred.columns):

        ws_pred.write(0, col_num, col_name)

    for row_num, row_data in enumerate(df_pred.values, start=1):

        for col_num, value in enumerate(row_data):

            ws_pred.write(row_num, col_num, value)

    print(f"✓ Feuille 'do_predictions' créée ({len(df_pred)} lignes)")

    # Feuille 5 : Graphe comparatif des modèles

    n_rows = len(df_models)

    chart = workbook.add_chart({'type': 'line'})

    # Série 1 : Données observées (scatter)

    chart.add_series({

        'name': 'Observé',

        'categories': ['do_models', 1, 1, n_rows, 1],  # ttf(i)

        'values': ['do_models', 1, 2, n_rows, 2],      # N_observed

        'line': {'width': 2.5},

        'marker': {'type': 'circle', 'size': 8}

    })

    # Série 2 : Modèle linéaire

    chart.add_series({

        'name': 'Linéaire',

        'categories': ['do_models', 1, 1, n_rows, 1],

        'values': ['do_models', 1, 3, n_rows, 3],      # N_linear

        'line': {'dash_type': 'dash'}

    })

    # Série 3 : Modèle exponentiel

    chart.add_series({

        'name': 'Exponentiel',

        'categories': ['do_models', 1, 1, n_rows, 1],

        'values': ['do_models', 1, 4, n_rows, 4],      # N_expo

        'line': {'dash_type': 'dash_dot'}

    })

    # Série 4 : Modèle Weibull

    chart.add_series({

        'name': 'Weibull',

        'categories': ['do_models', 1, 1, n_rows, 1],

        'values': ['do_models', 1, 5, n_rows, 5],      # N_weibull

        'line': {'dash_type': 'long_dash'}

    })

    chart.set_title({'name': 'Comparaison des modèles prédictifs'})

    chart.set_x_axis({'name': 'ttf(i)'})

    chart.set_y_axis({'name': 'N(i)'})

    chart.set_style(10)

    ws_chart = workbook.add_worksheet("graph_comparison")

    ws_chart.insert_chart('A1', chart, {'x_scale': 2.5, 'y_scale': 2})

    print("✓ Graphe comparatif créé")

    workbook.close()

def open_in_excel(xlsx_path: Path) -> None:

    """Ouvre le classeur généré dans Excel."""

    subprocess.Popen(["start", "excel", str(xlsx_path)], shell=True)

def main() -> None:

    """Pipeline : simulation et extrapolation."""

    xlsx_path = build_paths()

    ttf_i = [0, 250, 400, 550, 700, 850, 1000, 1150, 1300, 1450]

    print("Préparation des données observées...")

    df_obs = prepare_observed_data(n=9, ttf_values=ttf_i)

    print("Extrapolation des données...")

    df_extrap = extrapolate_data(df_obs, n_extra=10)

    print("Calcul des modèles prédictifs...")

    df_models = calculate_models(df_obs)

    print("\nModèles calculés :")

    print(df_models.head())

    print("\nCalcul des prédictions avec intervalles de confiance...")

    df_pred = calculate_predictions_with_ci(df_obs)

    print("\nÉcriture dans Excel...")

    delete_if_exists(xlsx_path)

    write_to_excel(xlsx_path, df_obs, df_extrap, df_models, df_pred)

    print(f"\nFichier créé : {xlsx_path}")

    print("5 feuilles générées + 1 graphe comparatif")

    open_in_excel(xlsx_path)

if __name__ == "__main__":

    main()

# TD_EDC_01_001_08.py
# Résumé : Simulation et extrapolation - modèles prédictifs et intervalles de confiance
# Génère 5 feuilles : observed, extrapolated, models, predictions, graph_comparison
from pathlib import Path
import subprocess
import pandas as pd
import numpy as np
import xlsxwriter


def build_paths() -> Path:
    """Calcule le chemin du fichier Excel de sortie."""
    script = Path(__file__).resolve()
    root = script.parent.parent
    stem = script.stem
    base_dir_name = script.parent.name
    xlsx_dir = root / f"{base_dir_name}_do"
    xlsx_dir.mkdir(parents=True, exist_ok=True)
    
    xlsx_path = (xlsx_dir / f"{stem}.xlsx").resolve()
    return xlsx_path


def delete_if_exists(file_path: Path) -> None:
    """Supprime le fichier s'il existe déjà."""
    if file_path.exists():
        file_path.unlink()


def prepare_observed_data(n: int = 9, ttf_values: list = None) -> pd.DataFrame:
    """Prépare les données observées."""
    i_values = list(range(n + 1))
    dN_values = [0] + [1] * n
    N_values = [n - i for i in range(n + 1)]
    
    df = pd.DataFrame({
        'i': i_values,
        'ttf(i)': ttf_values if ttf_values else [0] * (n + 1),
        'dN(i)': dN_values,
        'N(i)': N_values
    })
    
    return df


def extrapolate_data(df: pd.DataFrame, n_extra: int = 10) -> pd.DataFrame:
    """Extrapole les données linéairement."""
    ttf = df['ttf(i)'].values
    
    # Régression linéaire simple
    slope = (ttf[-1] - ttf[0]) / (len(ttf) - 1)
    
    # Extrapoler ttf
    i_extrap = list(range(len(df), len(df) + n_extra + 1))
    ttf_extrap = [ttf[-1] + slope * k for k in range(1, n_extra + 2)]
    
    # Extrapoler N (décroissance linéaire)
    N_extrap = [max(0, df['N(i)'].iloc[-1] - k) for k in range(1, n_extra + 2)]
    
    df_extrap = pd.DataFrame({
        'i': i_extrap,
        'ttf_extrap(i)': ttf_extrap,
        'N_extrap(i)': N_extrap
    })
    
    return df_extrap


def calculate_models(df: pd.DataFrame) -> pd.DataFrame:
    """Calcule différents modèles prédictifs."""
    ttf = df['ttf(i)'].values
    N_obs = df['N(i)'].values
    N_0 = N_obs[0]
    
    # Modèle linéaire : N(i) = N(0) - k*i
    k_linear = (N_obs[0] - N_obs[-1]) / len(N_obs)
    N_linear = [max(0, N_0 - k_linear * i) for i in range(len(ttf))]
    
    # Modèle exponentiel : N(t) = N(0) * exp(-λ*t)
    if ttf[-1] > 0 and N_obs[-1] > 0:
        lambda_exp = -np.log(N_obs[-1] / N_0) / ttf[-1]
        N_expo = [N_0 * np.exp(-lambda_exp * t) for t in ttf]
    else:
        N_expo = N_obs.tolist()
    
    # Modèle de Weibull simplifié : N(t) = N(0) * exp(-(t/η)^β)
    # Approximation avec β = 2, η calibré
    if ttf[-1] > 0:
        eta = ttf[-1] / np.sqrt(-np.log(N_obs[-1] / N_0)) if N_obs[-1] > 0 else ttf[-1]
        beta = 2
        N_weibull = [N_0 * np.exp(-((t / eta) ** beta)) if t > 0 else N_0 for t in ttf]
    else:
        N_weibull = N_obs.tolist()
    
    df_models = pd.DataFrame({
        'i': df['i'],
        'ttf(i)': ttf,
        'N_observed': N_obs,
        'N_linear': N_linear,
        'N_expo': N_expo,
        'N_weibull': N_weibull
    })
    
    return df_models


def calculate_predictions_with_ci(df: pd.DataFrame) -> pd.DataFrame:
    """Calcule les prédictions avec intervalles de confiance."""
    # Utiliser le modèle exponentiel comme prédiction
    ttf = df['ttf(i)'].values
    N_obs = df['N(i)'].values
    N_0 = N_obs[0]
    
    if ttf[-1] > 0 and N_obs[-1] > 0:
        lambda_exp = -np.log(N_obs[-1] / N_0) / ttf[-1]
        N_pred = [N_0 * np.exp(-lambda_exp * t) for t in ttf]
    else:
        N_pred = N_obs.tolist()
    
    # Calculer l'écart-type des résidus
    residuals = N_obs - np.array(N_pred)
    std_residuals = np.std(residuals)
    
    # Intervalle de confiance à 95% (1.96 * σ)
    IC_inf = [max(0, pred - 1.96 * std_residuals) for pred in N_pred]
    IC_sup = [pred + 1.96 * std_residuals for pred in N_pred]
    
    df_predictions = pd.DataFrame({
        'i': df['i'],
        'ttf(i)': ttf,
        'N_pred(i)': N_pred,
        'IC_inf': IC_inf,
        'IC_sup': IC_sup
    })
    
    return df_predictions


def write_to_excel(xlsx_path: Path, df_obs: pd.DataFrame, df_extrap: pd.DataFrame,
                   df_models: pd.DataFrame, df_pred: pd.DataFrame) -> None:
    """Écrit toutes les données dans Excel avec graphe comparatif."""
    workbook = xlsxwriter.Workbook(str(xlsx_path))
    
    # Feuille 1 : Données observées
    ws_obs = workbook.add_worksheet("do_observed")
    for col_num, col_name in enumerate(df_obs.columns):
        ws_obs.write(0, col_num, col_name)
    for row_num, row_data in enumerate(df_obs.values, start=1):
        for col_num, value in enumerate(row_data):
            ws_obs.write(row_num, col_num, value)
    print(f"✓ Feuille 'do_observed' créée ({len(df_obs)} lignes)")
    
    # Feuille 2 : Données extrapolées
    ws_extrap = workbook.add_worksheet("do_extrapolated")
    for col_num, col_name in enumerate(df_extrap.columns):
        ws_extrap.write(0, col_num, col_name)
    for row_num, row_data in enumerate(df_extrap.values, start=1):
        for col_num, value in enumerate(row_data):
            ws_extrap.write(row_num, col_num, value)
    print(f"✓ Feuille 'do_extrapolated' créée ({len(df_extrap)} lignes)")
    
    # Feuille 3 : Modèles comparatifs
    ws_models = workbook.add_worksheet("do_models")
    for col_num, col_name in enumerate(df_models.columns):
        ws_models.write(0, col_num, col_name)
    for row_num, row_data in enumerate(df_models.values, start=1):
        for col_num, value in enumerate(row_data):
            ws_models.write(row_num, col_num, value)
    print(f"✓ Feuille 'do_models' créée ({len(df_models)} lignes)")
    
    # Feuille 4 : Prédictions avec IC
    ws_pred = workbook.add_worksheet("do_predictions")
    for col_num, col_name in enumerate(df_pred.columns):
        ws_pred.write(0, col_num, col_name)
    for row_num, row_data in enumerate(df_pred.values, start=1):
        for col_num, value in enumerate(row_data):
            ws_pred.write(row_num, col_num, value)
    print(f"✓ Feuille 'do_predictions' créée ({len(df_pred)} lignes)")
    
    # Feuille 5 : Graphe comparatif des modèles
    n_rows = len(df_models)
    
    chart = workbook.add_chart({'type': 'line'})
    
    # Série 1 : Données observées (scatter)
    chart.add_series({
        'name': 'Observé',
        'categories': ['do_models', 1, 1, n_rows, 1],  # ttf(i)
        'values': ['do_models', 1, 2, n_rows, 2],      # N_observed
        'line': {'width': 2.5},
        'marker': {'type': 'circle', 'size': 8}
    })
    
    # Série 2 : Modèle linéaire
    chart.add_series({
        'name': 'Linéaire',
        'categories': ['do_models', 1, 1, n_rows, 1],
        'values': ['do_models', 1, 3, n_rows, 3],      # N_linear
        'line': {'dash_type': 'dash'}
    })
    
    # Série 3 : Modèle exponentiel
    chart.add_series({
        'name': 'Exponentiel',
        'categories': ['do_models', 1, 1, n_rows, 1],
        'values': ['do_models', 1, 4, n_rows, 4],      # N_expo
        'line': {'dash_type': 'dash_dot'}
    })
    
    # Série 4 : Modèle Weibull
    chart.add_series({
        'name': 'Weibull',
        'categories': ['do_models', 1, 1, n_rows, 1],
        'values': ['do_models', 1, 5, n_rows, 5],      # N_weibull
        'line': {'dash_type': 'long_dash'}
    })
    
    chart.set_title({'name': 'Comparaison des modèles prédictifs'})
    chart.set_x_axis({'name': 'ttf(i)'})
    chart.set_y_axis({'name': 'N(i)'})
    chart.set_style(10)
    
    ws_chart = workbook.add_worksheet("graph_comparison")
    ws_chart.insert_chart('A1', chart, {'x_scale': 2.5, 'y_scale': 2})
    print("✓ Graphe comparatif créé")
    
    workbook.close()


def open_in_excel(xlsx_path: Path) -> None:
    """Ouvre le classeur généré dans Excel."""
    subprocess.Popen(["start", "excel", str(xlsx_path)], shell=True)


def main() -> None:
    """Pipeline : simulation et extrapolation."""
    xlsx_path = build_paths()
    
    ttf_i = [0, 250, 400, 550, 700, 850, 1000, 1150, 1300, 1450]
    
    print("Préparation des données observées...")
    df_obs = prepare_observed_data(n=9, ttf_values=ttf_i)
    
    print("Extrapolation des données...")
    df_extrap = extrapolate_data(df_obs, n_extra=10)
    
    print("Calcul des modèles prédictifs...")
    df_models = calculate_models(df_obs)
    print("\nModèles calculés :")
    print(df_models.head())
    
    print("\nCalcul des prédictions avec intervalles de confiance...")
    df_pred = calculate_predictions_with_ci(df_obs)
    
    print("\nÉcriture dans Excel...")
    delete_if_exists(xlsx_path)
    write_to_excel(xlsx_path, df_obs, df_extrap, df_models, df_pred)
    
    print(f"\nFichier créé : {xlsx_path}")
    print("5 feuilles générées + 1 graphe comparatif")
    open_in_excel(xlsx_path)


if __name__ == "__main__":
    main()

# 001_08.py — Simulation et extrapolation

Ce script Python effectue des simulations et extrapolations de données avec modèles prédictifs et intervalles de confiance.

## Objectifs pédagogiques

- Comprendre la différence entre données observées et extrapolées

- Implémenter des modèles prédictifs (régression, tendances)

- Calculer des intervalles de confiance

- Visualiser les prédictions avec graphiques comparatifs

## Fonctionnement

1. **Données observées**

   - Chargement ou génération de données réelles

   - Analyse statistique de base

2. **Extrapolation**

   - Application de modèles mathématiques (linéaire, exponentiel)

   - Projection sur périodes futures

   - Calcul des marges d'erreur

3. **Modèles et prédictions**

   - Comparaison de plusieurs modèles

   - Évaluation de la qualité des prédictions

   - Intervalles de confiance à 95%

4. **Export multi-feuilles**

   - Feuille `observed` : données réelles

   - Feuille `extrapolated` : données projetées

   - Feuille `models` : paramètres des modèles

   - Feuille `predictions` : prédictions comparées

   - Feuille `graph_comparison` : visualisation

## Points techniques

- Utilisation de `numpy` pour calculs matriciels

- Régression linéaire et polynomiale

- Calculs d'écarts-types et intervalles de confiance

- Graphiques avec séries multiples

## Utilisation

Ce script sert de modèle pour effectuer des analyses prédictives et générer des projections avec indicateurs de fiabilité.

---

*Fichier généré automatiquement par GitHub Copilot (GPT-4.1) — 11/12/2025*

# 001_08.py — Simulation et extrapolation

Ce script Python effectue des simulations et extrapolations de données avec modèles prédictifs et intervalles de confiance.

## Objectifs pédagogiques
- Comprendre la différence entre données observées et extrapolées
- Implémenter des modèles prédictifs (régression, tendances)
- Calculer des intervalles de confiance
- Visualiser les prédictions avec graphiques comparatifs

## Fonctionnement
1. **Données observées**
   - Chargement ou génération de données réelles
   - Analyse statistique de base

2. **Extrapolation**
   - Application de modèles mathématiques (linéaire, exponentiel)
   - Projection sur périodes futures
   - Calcul des marges d'erreur

3. **Modèles et prédictions**
   - Comparaison de plusieurs modèles
   - Évaluation de la qualité des prédictions
   - Intervalles de confiance à 95%

4. **Export multi-feuilles**
   - Feuille `observed` : données réelles
   - Feuille `extrapolated` : données projetées
   - Feuille `models` : paramètres des modèles
   - Feuille `predictions` : prédictions comparées
   - Feuille `graph_comparison` : visualisation

## Points techniques
- Utilisation de `numpy` pour calculs matriciels
- Régression linéaire et polynomiale
- Calculs d'écarts-types et intervalles de confiance
- Graphiques avec séries multiples

## Utilisation
Ce script sert de modèle pour effectuer des analyses prédictives et générer des projections avec indicateurs de fiabilité.

---
*Fichier généré automatiquement par GitHub Copilot (GPT-4.1) — 11/12/2025*