Discussion :

[Seabirds]

Salut!

Je m'aventure gentiment vers le codage de modèles d'évolution de l'ADN (après pas mal de temps passé à coder tout ce qu'il y a autour c'est pas trop tôt me direz vous lol).
L'idée générale c'est de définir quelques concepts de base:

- les éléments de bases sont les quatres bases de la molecule d'ADN: adenine (A), cytosine (C), guanine (G), and thymine (T).
- Une séquence d'ADN est un motif répété de ces bases qui a une longueur n
- Si on laisse passer un temps t, un motif est soumis à des probabilités de modifications ( de A -> T, de T <- A etc)
- L'alphabet ADN (ATGC) peut etre traduit vers un second alphabet (ARN) en remplaçant le T (thymine) par un U (uracile).
- Puis après il y a des correspondances qui traduisent des triplets d'ARN (eg AUU) vers des acides aminés (eg la leucine bien connue de nos potes de musculation adeptes de shakers protéinés).
- Tout ça est blindé de redondances (les traductions ne sont pas uniques)

L'idée (en commençant très simple) c'est de prendre une séquence de lettres et de les muter aléatoirement au cours du temps. Fastoche.
Plus tard faudra commencer à recombiner les séquences en découpant/recollant des morceaux de taille variable.

Quels sont les pièges évidents qui vous viennent à l'esprit et que vous éviteriez et les outils évidents de C++20 pour rester sympa du coté des performances ?

Je pense à:
- utiliser des enums plutôt que des strings/char
- bien sur éviter de copier la séquence tout partout
- definir constexpr certains objets connus à la compilation (comme les matrices de transitions A <-> T <-> G <-> C qui sont connues empiriquement).
- c'est pour les futurs découpages que je suis moins confortable. On veut j'imagine éviter de litteralement tout en petits bouts en mode std::string::substr et std::string::replace ?

Plus généralement, ça vous évoque une ressource évidente à utiliser pour ce genre de problème?

[skeud]

Tu as très bien décris et découper ton problème, tu as donc fait 80% du boulot, il ne te reste plus qu'à suivre ce que tu as écris.
On peut le voir comme ça du coup:

class base -> ton élément de base qui contient un enum pour définir son type et tes paramètres de mutation par exemple
class sequence -> un enchainement de base (penser à std::list de base par exemple)
class modifier -> une classe qui va lire un brin et modifier les bases selon les critères de mutation
class converter -> une classe qui lit un brin et le transforme en ARN (c'est cette classe qui connait saura reconnaitre un enchainement de plusieurs base, pour ça fait toi une matrice en deux dimension)


pour la matrice en deux dimensions, tu pourrais avoir ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
A
-A
--A
--C
--G
--T -> donne un acide aminé quelquonque
-C
-G
-T
C
-A
-C
-G
-T
...

Pour ça tu peux utiliser des map de map:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
std::map<char, std::map<char, std::map<char, std::string>>> map;
map['A']['T']['C'] = "acide quelquonque";

Voilà pour les quelques idées que j'avais ^^


Et ne pas oublié 2 principes de bases:
1) KISS -> Keep it simple, stupid
2) On code d'abord un truc qui marche avant de l'optimiser

[Seabirds]

Oui mais les maps, c'est pas effica ... je plaisante, je plaisante
Ok donc c'est conceptually approved!
Merci beaucoup, on se retrousse les manches et on y passe le week end ahaha!