simalleles 0.9.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- simalleles/__init__.py +57 -0
- simalleles/__main__.py +8 -0
- simalleles/core/__init__.py +24 -0
- simalleles/core/allele.py +44 -0
- simalleles/core/config.py +92 -0
- simalleles/core/generation.py +81 -0
- simalleles/core/individu.py +102 -0
- simalleles/core/population.py +137 -0
- simalleles/core/simulation.py +108 -0
- simalleles/core/utils.py +63 -0
- simalleles/core/world.py +124 -0
- simalleles/web/__init__.py +27 -0
- simalleles/web/__main__.py +96 -0
- simalleles/web/app.py +342 -0
- simalleles/web/charts.py +64 -0
- simalleles/web/export.py +58 -0
- simalleles/web/state.py +84 -0
- simalleles/web/tasks.py +60 -0
- simalleles-0.9.0.dist-info/METADATA +156 -0
- simalleles-0.9.0.dist-info/RECORD +24 -0
- simalleles-0.9.0.dist-info/WHEEL +5 -0
- simalleles-0.9.0.dist-info/entry_points.txt +2 -0
- simalleles-0.9.0.dist-info/licenses/LICENSE +665 -0
- simalleles-0.9.0.dist-info/top_level.txt +1 -0
simalleles/__init__.py
ADDED
|
@@ -0,0 +1,57 @@
|
|
|
1
|
+
# encode : utf-8
|
|
2
|
+
# Python 3.10
|
|
3
|
+
# ----------------------------------------------------------------------------
|
|
4
|
+
|
|
5
|
+
import re
|
|
6
|
+
from importlib.metadata import PackageNotFoundError, version
|
|
7
|
+
from pathlib import Path
|
|
8
|
+
|
|
9
|
+
from .core.allele import Allele
|
|
10
|
+
from .core.config import SimulationConfig
|
|
11
|
+
from .core.generation import Generation
|
|
12
|
+
from .core.individu import Individu
|
|
13
|
+
from .core.population import Population
|
|
14
|
+
from .core.simulation import Simulation
|
|
15
|
+
from .core.utils import calc_nbr_type_allele, to_purcent
|
|
16
|
+
from .core.world import World
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
def _read_version() -> str:
|
|
20
|
+
"""Lit la version du projet, avec priorité au `pyproject.toml` local.
|
|
21
|
+
|
|
22
|
+
En exécution depuis les sources,
|
|
23
|
+
une ancienne distribution installée dans l'environnement
|
|
24
|
+
ne doit pas masquer la version du dépôt.
|
|
25
|
+
Dans une wheel installée,
|
|
26
|
+
le `pyproject.toml` n'est pas présent
|
|
27
|
+
et les métadonnées `importlib.metadata` sont utilisées.
|
|
28
|
+
"""
|
|
29
|
+
pyproject = Path(__file__).resolve().parent.parent / "pyproject.toml"
|
|
30
|
+
if pyproject.is_file():
|
|
31
|
+
match = re.search(
|
|
32
|
+
r'^version\s*=\s*"([^"]+)"',
|
|
33
|
+
pyproject.read_text(encoding="utf-8"),
|
|
34
|
+
re.MULTILINE,
|
|
35
|
+
)
|
|
36
|
+
if match:
|
|
37
|
+
return match.group(1)
|
|
38
|
+
try:
|
|
39
|
+
return version("simalleles")
|
|
40
|
+
except PackageNotFoundError: # pragma: no cover - source sans métadonnées
|
|
41
|
+
return "0.9.0"
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
__version__ = _read_version()
|
|
45
|
+
|
|
46
|
+
__all__ = [
|
|
47
|
+
"__version__",
|
|
48
|
+
"Allele",
|
|
49
|
+
"Simulation",
|
|
50
|
+
"SimulationConfig",
|
|
51
|
+
"World",
|
|
52
|
+
"Population",
|
|
53
|
+
"Generation",
|
|
54
|
+
"Individu",
|
|
55
|
+
"calc_nbr_type_allele",
|
|
56
|
+
"to_purcent",
|
|
57
|
+
]
|
simalleles/__main__.py
ADDED
|
@@ -0,0 +1,24 @@
|
|
|
1
|
+
# encode : utf-8
|
|
2
|
+
# Python 3.10
|
|
3
|
+
# ----------------------------------------------------------------------------
|
|
4
|
+
|
|
5
|
+
from .allele import Allele
|
|
6
|
+
from .config import SimulationConfig
|
|
7
|
+
from .generation import Generation
|
|
8
|
+
from .individu import Individu
|
|
9
|
+
from .population import Population
|
|
10
|
+
from .simulation import Simulation
|
|
11
|
+
from .utils import calc_nbr_type_allele, to_purcent
|
|
12
|
+
from .world import World
|
|
13
|
+
|
|
14
|
+
__all__ = [
|
|
15
|
+
"Allele",
|
|
16
|
+
"Simulation",
|
|
17
|
+
"SimulationConfig",
|
|
18
|
+
"World",
|
|
19
|
+
"Population",
|
|
20
|
+
"Generation",
|
|
21
|
+
"Individu",
|
|
22
|
+
"calc_nbr_type_allele",
|
|
23
|
+
"to_purcent",
|
|
24
|
+
]
|
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
# encode : utf-8
|
|
2
|
+
# Python 3.10
|
|
3
|
+
# ----------------------------------------------------------------------------
|
|
4
|
+
|
|
5
|
+
from __future__ import annotations
|
|
6
|
+
|
|
7
|
+
|
|
8
|
+
class Allele:
|
|
9
|
+
"""Allèle d'un locus diploïde, caractérisé par sa valeur et son poids.
|
|
10
|
+
|
|
11
|
+
Le poids est utilisé au moment du tirage des gamètes :
|
|
12
|
+
un allèle de poids plus élevé est transmis plus souvent.
|
|
13
|
+
Il ne s'agit pas d'une probabilité et il doit rester strictement positif.
|
|
14
|
+
|
|
15
|
+
Attributes:
|
|
16
|
+
value: Valeur de l'allèle (`"A"` ou `"a"` dans le modèle actuel).
|
|
17
|
+
weight: Poids de transmission utilisé par :meth:`World.choice_allele`.
|
|
18
|
+
"""
|
|
19
|
+
|
|
20
|
+
__slots__ = ("value", "weight")
|
|
21
|
+
|
|
22
|
+
def __init__(self, value: str, weight: float = 1.0) -> None:
|
|
23
|
+
"""Crée un allèle.
|
|
24
|
+
|
|
25
|
+
Args:
|
|
26
|
+
value: Valeur de l'allèle, par exemple `"A"` ou `"a"`.
|
|
27
|
+
weight: Poids de transmission strictement positif (1.0 par défaut).
|
|
28
|
+
"""
|
|
29
|
+
self.value = value
|
|
30
|
+
self.weight = weight
|
|
31
|
+
|
|
32
|
+
def __repr__(self) -> str:
|
|
33
|
+
"""Retourne une représentation lisible de l'allèle."""
|
|
34
|
+
return f"Allele(value={self.value!r}, weight={self.weight})"
|
|
35
|
+
|
|
36
|
+
def __eq__(self, other: object) -> bool:
|
|
37
|
+
"""Compare deux allèles par valeur et par poids."""
|
|
38
|
+
if not isinstance(other, Allele):
|
|
39
|
+
return NotImplemented
|
|
40
|
+
return self.value == other.value and self.weight == other.weight
|
|
41
|
+
|
|
42
|
+
def __hash__(self) -> int:
|
|
43
|
+
"""Rend les allèles utilisables comme clés de dictionnaire ou dans un set."""
|
|
44
|
+
return hash((self.value, self.weight))
|
|
@@ -0,0 +1,92 @@
|
|
|
1
|
+
# encode : utf-8
|
|
2
|
+
# Python 3.10
|
|
3
|
+
# ----------------------------------------------------------------------------
|
|
4
|
+
|
|
5
|
+
from __future__ import annotations
|
|
6
|
+
|
|
7
|
+
from dataclasses import dataclass
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
@dataclass
|
|
11
|
+
class SimulationConfig:
|
|
12
|
+
"""Paramètres validés d'une simulation d'allèles à deux allèles.
|
|
13
|
+
|
|
14
|
+
Les pourcentages (`inceste`, `migration`, `mutation`)
|
|
15
|
+
sont exprimés en points de pourcentage,
|
|
16
|
+
entre 0 et 100 dans l'interface.
|
|
17
|
+
Le moteur les compare à un tirage entier de 1 à 100.
|
|
18
|
+
|
|
19
|
+
Attributes:
|
|
20
|
+
nbr_generations: Nombre de générations à simuler (>= 1).
|
|
21
|
+
nbr_populations: Nombre de populations indépendantes (>= 1).
|
|
22
|
+
nbr_individus: Effectif initial de chaque population (>= 1).
|
|
23
|
+
taux: Nombre d'enfants produits par individu et par génération (> 0).
|
|
24
|
+
inceste: Probabilité, en pourcentage, de choisir un partenaire apparenté.
|
|
25
|
+
migration: Probabilité, en pourcentage, qu'un individu change de population.
|
|
26
|
+
mutation: Probabilité, en pourcentage, qu'un individu subisse une mutation.
|
|
27
|
+
weight_A: Poids de transmission de l'allèle `A` (> 0).
|
|
28
|
+
weight_a: Poids de transmission de l'allèle `a` (> 0).
|
|
29
|
+
allow_AA: Autorise les croisements A/A.
|
|
30
|
+
allow_Aa: Autorise les croisements A/a (dans les deux sens).
|
|
31
|
+
allow_aa: Autorise les croisements a/a.
|
|
32
|
+
seed: Graine du générateur aléatoire ; `None` pour un tirage non reproductible.
|
|
33
|
+
"""
|
|
34
|
+
|
|
35
|
+
nbr_generations: int = 10
|
|
36
|
+
nbr_populations: int = 1
|
|
37
|
+
nbr_individus: int = 1000
|
|
38
|
+
taux: float = 1.0
|
|
39
|
+
inceste: int = 0
|
|
40
|
+
migration: int = 0
|
|
41
|
+
mutation: int = 0
|
|
42
|
+
weight_A: float = 1.0
|
|
43
|
+
weight_a: float = 1.0
|
|
44
|
+
allow_AA: bool = True
|
|
45
|
+
allow_Aa: bool = True
|
|
46
|
+
allow_aa: bool = True
|
|
47
|
+
seed: int | None = None
|
|
48
|
+
|
|
49
|
+
def __post_init__(self) -> None:
|
|
50
|
+
"""Valide les bornes et la cohérence des paramètres.
|
|
51
|
+
|
|
52
|
+
Raises:
|
|
53
|
+
ValueError: Si un effectif est nul, si le taux ou un poids est
|
|
54
|
+
négatif ou nul, ou si aucun croisement n'est autorisé.
|
|
55
|
+
"""
|
|
56
|
+
if self.nbr_populations < 1:
|
|
57
|
+
raise ValueError("nbr_populations doit être >= 1")
|
|
58
|
+
if self.nbr_individus < 1:
|
|
59
|
+
raise ValueError("nbr_individus doit être >= 1")
|
|
60
|
+
if self.nbr_generations < 1:
|
|
61
|
+
raise ValueError("nbr_generations doit être >= 1")
|
|
62
|
+
if self.taux <= 0:
|
|
63
|
+
raise ValueError("taux doit être > 0")
|
|
64
|
+
if self.weight_A <= 0 or self.weight_a <= 0:
|
|
65
|
+
raise ValueError("les poids des allèles doivent être > 0")
|
|
66
|
+
if not (self.allow_AA or self.allow_Aa or self.allow_aa):
|
|
67
|
+
raise ValueError(
|
|
68
|
+
"au moins un croisement parmi A/A, A/a, a/a doit être autorisé"
|
|
69
|
+
)
|
|
70
|
+
|
|
71
|
+
@property
|
|
72
|
+
def weights(self) -> dict[str, float]:
|
|
73
|
+
"""Retourne les poids de transmission sous la forme `{"A": ..., "a": ...}`."""
|
|
74
|
+
return {"A": self.weight_A, "a": self.weight_a}
|
|
75
|
+
|
|
76
|
+
@property
|
|
77
|
+
def allele_pairs(self) -> list[tuple[str, str]]:
|
|
78
|
+
"""Paires d'allèles utilisées pour construire la génération initiale.
|
|
79
|
+
|
|
80
|
+
Chaque paire représente un génotype possible.
|
|
81
|
+
A/a est ajouté dans les deux ordres
|
|
82
|
+
pour conserver une répartition homogène des hétérozygotes.
|
|
83
|
+
"""
|
|
84
|
+
pairs: list[tuple[str, str]] = []
|
|
85
|
+
if self.allow_AA:
|
|
86
|
+
pairs.append(("A", "A"))
|
|
87
|
+
if self.allow_Aa:
|
|
88
|
+
pairs.append(("A", "a"))
|
|
89
|
+
pairs.append(("a", "A"))
|
|
90
|
+
if self.allow_aa:
|
|
91
|
+
pairs.append(("a", "a"))
|
|
92
|
+
return pairs
|
|
@@ -0,0 +1,81 @@
|
|
|
1
|
+
# encode : utf-8
|
|
2
|
+
# Python 3.10
|
|
3
|
+
# ----------------------------------------------------------------------------
|
|
4
|
+
|
|
5
|
+
import random
|
|
6
|
+
|
|
7
|
+
from .individu import Individu
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
class Generation:
|
|
11
|
+
"""Une génération d'individus appartenant à une même population.
|
|
12
|
+
|
|
13
|
+
Attributes:
|
|
14
|
+
females: Individus de sexe féminin.
|
|
15
|
+
males: Individus de sexe masculin.
|
|
16
|
+
population: Population propriétaire, ou `None` pour une génération
|
|
17
|
+
transitoire en cours de construction.
|
|
18
|
+
rng: Générateur aléatoire (`World` ou module `random`).
|
|
19
|
+
"""
|
|
20
|
+
|
|
21
|
+
def __init__(
|
|
22
|
+
self,
|
|
23
|
+
count:int = 0,
|
|
24
|
+
*,
|
|
25
|
+
population = None,
|
|
26
|
+
alleles_predefinies = None,
|
|
27
|
+
rng: object = None,
|
|
28
|
+
):
|
|
29
|
+
"""Construit une génération.
|
|
30
|
+
|
|
31
|
+
Args:
|
|
32
|
+
count: Nombre d'individus à créer. Zéro crée une génération vide,
|
|
33
|
+
utile pour recevoir les enfants d'une reproduction.
|
|
34
|
+
population: Population à laquelle rattacher les individus.
|
|
35
|
+
alleles_predefinies: Paires d'allèles imposées pour la génération
|
|
36
|
+
initiale. `None` laisse chaque allèle être tiré au hasard.
|
|
37
|
+
rng: Générateur aléatoire exposant `_choice` ; par défaut le
|
|
38
|
+
module :mod:`random` global.
|
|
39
|
+
"""
|
|
40
|
+
# Séparations des individus féminins et masculins
|
|
41
|
+
# dans le but d'optimiser la reproduction,
|
|
42
|
+
# cela évite de vérifier le sexe.
|
|
43
|
+
self.females = []
|
|
44
|
+
self.males = []
|
|
45
|
+
|
|
46
|
+
self.population = population
|
|
47
|
+
self.rng = rng or random
|
|
48
|
+
|
|
49
|
+
if count:
|
|
50
|
+
for _ in range(count):
|
|
51
|
+
if alleles_predefinies:
|
|
52
|
+
Individu(*self.rng._choice(alleles_predefinies), generation=self)
|
|
53
|
+
else:
|
|
54
|
+
Individu(generation=self)
|
|
55
|
+
|
|
56
|
+
def __iter__(self):
|
|
57
|
+
"""Itère sur tous les individus, femmes puis hommes."""
|
|
58
|
+
return self.individus
|
|
59
|
+
|
|
60
|
+
@property
|
|
61
|
+
def individus(self):
|
|
62
|
+
"""Générateur parcourant les femelles puis les mâles."""
|
|
63
|
+
for i in self.females:
|
|
64
|
+
yield i
|
|
65
|
+
for i in self.males:
|
|
66
|
+
yield i
|
|
67
|
+
|
|
68
|
+
def append(self, i):
|
|
69
|
+
"""Ajoute un individu dans la liste correspondant à son sexe."""
|
|
70
|
+
if i.sexe == 'F':
|
|
71
|
+
self.females.append(i)
|
|
72
|
+
if i.sexe == 'M':
|
|
73
|
+
self.males.append(i)
|
|
74
|
+
|
|
75
|
+
def remove(self, i):
|
|
76
|
+
"""Retire un individu de la liste correspondant à son sexe."""
|
|
77
|
+
if i.sexe == 'F':
|
|
78
|
+
self.females.remove(i)
|
|
79
|
+
if i.sexe == 'M':
|
|
80
|
+
self.males.remove(i)
|
|
81
|
+
|
|
@@ -0,0 +1,102 @@
|
|
|
1
|
+
# encode : utf-8
|
|
2
|
+
# Python 3.10
|
|
3
|
+
# ----------------------------------------------------------------------------
|
|
4
|
+
|
|
5
|
+
from __future__ import annotations
|
|
6
|
+
|
|
7
|
+
import random
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
class Individu:
|
|
11
|
+
"""Individu diploïde portant deux allèles et un sexe.
|
|
12
|
+
|
|
13
|
+
Attributes:
|
|
14
|
+
generation: Génération à laquelle l'individu appartient.
|
|
15
|
+
allele_1: Premier allèle du génotype.
|
|
16
|
+
allele_2: Second allèle du génotype.
|
|
17
|
+
sexe: `"F"` pour femelle, `"M"` pour mâle.
|
|
18
|
+
parents: Liste des deux parents, vide pour la génération initiale.
|
|
19
|
+
children: Enfants produits par cet individu.
|
|
20
|
+
population: Population courante (utile après une migration).
|
|
21
|
+
old_population: Ancienne population et génération d'origine, renseignée
|
|
22
|
+
lors d'une migration.
|
|
23
|
+
"""
|
|
24
|
+
|
|
25
|
+
__slots__ = (
|
|
26
|
+
'generation',
|
|
27
|
+
'allele_1',
|
|
28
|
+
'allele_2',
|
|
29
|
+
'sexe',
|
|
30
|
+
'parents',
|
|
31
|
+
'children',
|
|
32
|
+
'history',
|
|
33
|
+
'population',
|
|
34
|
+
'old_population'
|
|
35
|
+
)
|
|
36
|
+
|
|
37
|
+
def __init__(
|
|
38
|
+
self,
|
|
39
|
+
allele_1:str = None,
|
|
40
|
+
allele_2:str = None,
|
|
41
|
+
sexe:str = None,
|
|
42
|
+
*,
|
|
43
|
+
generation:Generation,
|
|
44
|
+
parents:list = None
|
|
45
|
+
):
|
|
46
|
+
"""Crée un individu.
|
|
47
|
+
|
|
48
|
+
Les allèles et le sexe absents sont tirés au hasard
|
|
49
|
+
via le générateur de la génération.
|
|
50
|
+
Un individu est immédiatement inscrit dans la liste
|
|
51
|
+
des femelles ou des mâles de sa génération.
|
|
52
|
+
|
|
53
|
+
Args:
|
|
54
|
+
allele_1: Premier allèle, ou `None` pour un tirage aléatoire.
|
|
55
|
+
allele_2: Second allèle, ou `None` pour un tirage aléatoire.
|
|
56
|
+
sexe: `"F"` ou `"M"`, ou `None` pour un tirage aléatoire.
|
|
57
|
+
generation: Génération de rattachement (obligatoire).
|
|
58
|
+
parents: Parents de l'individu, vide pour la génération initiale.
|
|
59
|
+
"""
|
|
60
|
+
self.generation = generation
|
|
61
|
+
|
|
62
|
+
self.allele_1 = allele_1 or self.generation.rng._choice(['A', 'a'])
|
|
63
|
+
self.allele_2 = allele_2 or self.generation.rng._choice(['A', 'a'])
|
|
64
|
+
|
|
65
|
+
self.sexe = sexe or self.generation.rng._choice(['F', 'M'])
|
|
66
|
+
|
|
67
|
+
if self.sexe == 'F':
|
|
68
|
+
self.generation.females.append(self)
|
|
69
|
+
if self.sexe == 'M':
|
|
70
|
+
self.generation.males.append(self)
|
|
71
|
+
|
|
72
|
+
self.parents = parents or []
|
|
73
|
+
self.children = []
|
|
74
|
+
self.history = []
|
|
75
|
+
|
|
76
|
+
def reproduce_with(self, i, generation=None):
|
|
77
|
+
"""Crée un enfant avec un autre individu.
|
|
78
|
+
|
|
79
|
+
Un allèle est tiré dans chacun des deux génotypes parentaux
|
|
80
|
+
via :meth:`World.choice_allele`,
|
|
81
|
+
puis l'enfant est rattaché à `generation`.
|
|
82
|
+
L'enfant est ajouté aux listes `children` des deux parents.
|
|
83
|
+
|
|
84
|
+
Args:
|
|
85
|
+
i: Second parent.
|
|
86
|
+
generation: Génération qui doit recevoir l'enfant.
|
|
87
|
+
|
|
88
|
+
Returns:
|
|
89
|
+
L'individu enfant nouvellement créé.
|
|
90
|
+
"""
|
|
91
|
+
choice_allele = self.generation.population.world.choice_allele
|
|
92
|
+
|
|
93
|
+
child = Individu(
|
|
94
|
+
choice_allele(self.allele_1, self.allele_2),
|
|
95
|
+
choice_allele(i.allele_1, i.allele_2),
|
|
96
|
+
generation = generation,
|
|
97
|
+
parents = [self, i]
|
|
98
|
+
)
|
|
99
|
+
|
|
100
|
+
self.children.append(child)
|
|
101
|
+
i.children.append(child)
|
|
102
|
+
return child
|
|
@@ -0,0 +1,137 @@
|
|
|
1
|
+
# encode : utf-8
|
|
2
|
+
# Python 3.10
|
|
3
|
+
# ----------------------------------------------------------------------------
|
|
4
|
+
|
|
5
|
+
from __future__ import annotations
|
|
6
|
+
|
|
7
|
+
from .generation import Generation
|
|
8
|
+
|
|
9
|
+
import random
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
class Population:
|
|
13
|
+
"""Population nommée, constituée d'une suite de générations.
|
|
14
|
+
|
|
15
|
+
Attributes:
|
|
16
|
+
name: Identifiant de la population (`"P1"`, `"P2"`, ...).
|
|
17
|
+
world: Monde qui contient la population et fournit le générateur.
|
|
18
|
+
generations: Historique des générations, de la plus ancienne à la plus récente.
|
|
19
|
+
"""
|
|
20
|
+
|
|
21
|
+
def __init__(
|
|
22
|
+
self,
|
|
23
|
+
name:str,
|
|
24
|
+
generation:Generation = None,
|
|
25
|
+
world:World = None
|
|
26
|
+
):
|
|
27
|
+
"""Crée une population et l'enregistre dans son monde.
|
|
28
|
+
|
|
29
|
+
Args:
|
|
30
|
+
name: Nom unique de la population.
|
|
31
|
+
generation: Génération initiale ; elle est obligatoire en pratique.
|
|
32
|
+
world: Monde de rattachement ; il est obligatoire en pratique.
|
|
33
|
+
"""
|
|
34
|
+
self.name = name
|
|
35
|
+
self.world = world
|
|
36
|
+
self.generations = [generation] if generation else []
|
|
37
|
+
|
|
38
|
+
generation.population = self
|
|
39
|
+
world.populations[self.name] = self
|
|
40
|
+
|
|
41
|
+
def new_generation(
|
|
42
|
+
self,
|
|
43
|
+
*,
|
|
44
|
+
taux:float = 1.0,
|
|
45
|
+
inceste:int = 0,
|
|
46
|
+
migration:int = 0,
|
|
47
|
+
):
|
|
48
|
+
"""Produit la génération suivante par reproduction des individus.
|
|
49
|
+
|
|
50
|
+
Le nombre d'enfants créés vaut `int(effectif_courant * taux)`.
|
|
51
|
+
Chaque enfant reçoit un allèle de chaque parent.
|
|
52
|
+
Le premier parent est tiré au hasard,
|
|
53
|
+
le second est choisi parmi les individus de sexe opposé
|
|
54
|
+
de la même génération.
|
|
55
|
+
|
|
56
|
+
Args:
|
|
57
|
+
taux: Nombre d'enfants produits par individu (1.0 conserve
|
|
58
|
+
globalement l'effectif).
|
|
59
|
+
inceste: Probabilité, en pourcentage, de chercher le second parent
|
|
60
|
+
dans la famille du premier. Si aucun apparenté n'est disponible,
|
|
61
|
+
la reproduction est ignorée.
|
|
62
|
+
migration: Conservé pour compatibilité ; la migration est appliquée
|
|
63
|
+
en amont par :meth:`World.new_generation`.
|
|
64
|
+
|
|
65
|
+
Returns:
|
|
66
|
+
`None`. La nouvelle génération est ajoutée à l'historique.
|
|
67
|
+
"""
|
|
68
|
+
children = Generation(population=self, rng=self.world)
|
|
69
|
+
|
|
70
|
+
individus = list(self.last_generation)
|
|
71
|
+
|
|
72
|
+
try: individus_with_parent = set(
|
|
73
|
+
individus + list(self.generations[-2])
|
|
74
|
+
)
|
|
75
|
+
except:
|
|
76
|
+
individus_with_parent = individus
|
|
77
|
+
|
|
78
|
+
for _ in range(int(len(individus) * taux)):
|
|
79
|
+
|
|
80
|
+
i1 = self.world._choice(individus)
|
|
81
|
+
|
|
82
|
+
|
|
83
|
+
### Inceste
|
|
84
|
+
#
|
|
85
|
+
|
|
86
|
+
if (
|
|
87
|
+
not inceste
|
|
88
|
+
or self.world._randint(0, 100) > inceste
|
|
89
|
+
or not i1.parents # When first generation
|
|
90
|
+
):
|
|
91
|
+
if i1.sexe == 'F':
|
|
92
|
+
if not i1.generation.males:
|
|
93
|
+
continue
|
|
94
|
+
i2 = self.world._choice(i1.generation.males)
|
|
95
|
+
if i1.sexe == 'M':
|
|
96
|
+
if not i1.generation.females:
|
|
97
|
+
continue
|
|
98
|
+
i2 = self.world._choice(i1.generation.females)
|
|
99
|
+
else:
|
|
100
|
+
family = [
|
|
101
|
+
i
|
|
102
|
+
for i in set([
|
|
103
|
+
*i1.parents,
|
|
104
|
+
*[c for p in i1.parents for c in p.children]
|
|
105
|
+
])
|
|
106
|
+
if
|
|
107
|
+
# Permet de vérifier si une personne de sa famille est dans
|
|
108
|
+
# la même population que l'individu,
|
|
109
|
+
# il ne peut pas se reproduire si elle n'est pas là.
|
|
110
|
+
i in individus_with_parent
|
|
111
|
+
and (
|
|
112
|
+
(i1.sexe == 'F' and i.sexe == 'M')
|
|
113
|
+
or
|
|
114
|
+
(i1.sexe == 'M' and i.sexe == 'F')
|
|
115
|
+
)
|
|
116
|
+
]
|
|
117
|
+
|
|
118
|
+
if not family:
|
|
119
|
+
continue
|
|
120
|
+
else:
|
|
121
|
+
i2 = self.world._choice(family)
|
|
122
|
+
|
|
123
|
+
#
|
|
124
|
+
###
|
|
125
|
+
|
|
126
|
+
i1.reproduce_with(i2, generation=children)
|
|
127
|
+
|
|
128
|
+
self.add_generation(children)
|
|
129
|
+
|
|
130
|
+
def add_generation(self, individus):
|
|
131
|
+
"""Ajoute une génération à l'historique de la population."""
|
|
132
|
+
self.generations.append(individus)
|
|
133
|
+
|
|
134
|
+
@property
|
|
135
|
+
def last_generation(self):
|
|
136
|
+
"""Retourne la génération la plus récente."""
|
|
137
|
+
return self.generations[-1]
|
|
@@ -0,0 +1,108 @@
|
|
|
1
|
+
# encode : utf-8
|
|
2
|
+
# Python 3.10
|
|
3
|
+
# ----------------------------------------------------------------------------
|
|
4
|
+
|
|
5
|
+
from __future__ import annotations
|
|
6
|
+
|
|
7
|
+
from .config import SimulationConfig
|
|
8
|
+
from .generation import Generation
|
|
9
|
+
from .population import Population
|
|
10
|
+
from .utils import calc_nbr_type_allele, to_purcent
|
|
11
|
+
from .world import World
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
class Simulation:
|
|
15
|
+
"""Moteur d'exécution d'une simulation d'évolution d'allèles.
|
|
16
|
+
|
|
17
|
+
Les résultats sont retournés sous forme de dictionnaire structuré.
|
|
18
|
+
"""
|
|
19
|
+
|
|
20
|
+
def __init__(self, config: SimulationConfig) -> None:
|
|
21
|
+
"""Prépare une simulation à partir d'une configuration validée.
|
|
22
|
+
|
|
23
|
+
Args:
|
|
24
|
+
config: Paramètres de la simulation.
|
|
25
|
+
"""
|
|
26
|
+
self.config = config
|
|
27
|
+
|
|
28
|
+
def run(self) -> dict[str, list[dict]]:
|
|
29
|
+
"""Exécute la simulation et retourne l'historique par population.
|
|
30
|
+
|
|
31
|
+
Structure retournée :
|
|
32
|
+
{
|
|
33
|
+
"P1": [
|
|
34
|
+
{"generation": 0, "a_a": int, "A_A": int, "a_A": int,
|
|
35
|
+
"A_a": int, "pourcentages": (int, int, int)},
|
|
36
|
+
...
|
|
37
|
+
],
|
|
38
|
+
...
|
|
39
|
+
}
|
|
40
|
+
"""
|
|
41
|
+
import random
|
|
42
|
+
|
|
43
|
+
rng = random.Random(self.config.seed) if self.config.seed is not None else None
|
|
44
|
+
|
|
45
|
+
world = World(self.config.weights, rng=rng)
|
|
46
|
+
|
|
47
|
+
for i in range(self.config.nbr_populations):
|
|
48
|
+
Population(
|
|
49
|
+
f"P{i + 1}",
|
|
50
|
+
Generation(
|
|
51
|
+
count=self.config.nbr_individus,
|
|
52
|
+
alleles_predefinies=(
|
|
53
|
+
self.config.allele_pairs
|
|
54
|
+
if len(self.config.allele_pairs) != 3
|
|
55
|
+
else None
|
|
56
|
+
),
|
|
57
|
+
rng=world,
|
|
58
|
+
),
|
|
59
|
+
world=world,
|
|
60
|
+
)
|
|
61
|
+
|
|
62
|
+
for _ in range(self.config.nbr_generations):
|
|
63
|
+
world.new_generation(
|
|
64
|
+
taux=self.config.taux,
|
|
65
|
+
inceste=self.config.inceste,
|
|
66
|
+
migration=self.config.migration,
|
|
67
|
+
mutation=self.config.mutation,
|
|
68
|
+
)
|
|
69
|
+
|
|
70
|
+
return build_history(world)
|
|
71
|
+
|
|
72
|
+
|
|
73
|
+
def build_history(world: World) -> dict[str, list[dict]]:
|
|
74
|
+
"""Convertit un `World` en historique sérialisable (picklable).
|
|
75
|
+
|
|
76
|
+
Le `World` contient des références croisées
|
|
77
|
+
(individu <-> génération <-> population)
|
|
78
|
+
qui ne peuvent pas traverser une frontière de processus.
|
|
79
|
+
L'interface n'a besoin que des comptes par génération.
|
|
80
|
+
|
|
81
|
+
Args:
|
|
82
|
+
world: Monde dont les populations viennent d'être simulées.
|
|
83
|
+
|
|
84
|
+
Returns:
|
|
85
|
+
Un dictionnaire `population -> liste de générations` ne contenant que
|
|
86
|
+
des types simples (entiers et tuples).
|
|
87
|
+
"""
|
|
88
|
+
history: dict[str, list[dict]] = {}
|
|
89
|
+
for name, pop in world.populations.items():
|
|
90
|
+
pop_history: list[dict] = []
|
|
91
|
+
for generation_index, gen in enumerate(pop.generations):
|
|
92
|
+
a_a, A_A, a_A, A_a = calc_nbr_type_allele(gen)
|
|
93
|
+
pct = to_purcent(a_a, A_A, a_A, A_a)
|
|
94
|
+
pop_history.append(
|
|
95
|
+
{
|
|
96
|
+
"generation": generation_index,
|
|
97
|
+
"a_a": a_a,
|
|
98
|
+
"A_A": A_A,
|
|
99
|
+
"a_A": a_A,
|
|
100
|
+
"A_a": A_a,
|
|
101
|
+
"pourcentages": pct,
|
|
102
|
+
}
|
|
103
|
+
)
|
|
104
|
+
history[name] = pop_history
|
|
105
|
+
return history
|
|
106
|
+
|
|
107
|
+
|
|
108
|
+
__all__ = ["Simulation", "build_history"]
|