# LDD Projet Math-Info -- QUESTIONS TP

## TP1 FAQ

**Question :** en exécutant la commande f. dans le TP1 j'ai une erreur de syntaxe qui est affiché, je n'ai rien modifié dans la cellule avant de l'exécuter.

**Réponse :** C'est normal, dans cette cellule, il faut juste appuyer sur tabulation pour voir ce qui est proposé par Sage

**Question :** quand on demande la droite tangente de h en 0, il faut juste définir une nouvelle fonction ?

**Réponse :** oui

**Question :** C'est quoi la différence entre f.integrate(x) et f.integral(x)

**Réponse :** En regardant la documentation, on découvre... qu'il n'y a pas de différence ! Ce sont juste deux mots clés qui renvoient à la même fonction.

**Question:** J'ai un soucis pour tracer l'hexagone

**Réponse :** Faire attention à bien mettre les 6 points de l'hexagone DANS L'ORDRE dans lequel ils appaissent le long du polygone, sinon ça vous fait un hexagone tout cassé

**Question :** pour tracer le cercle rouge il faut remettre polygon2d ou pas ?

**Réponse :** Oui il faut mettre les 2 de cette façon, `polygon2D(...) + circle(..)`

## TP2 FAQ

### Polygone régulier

**Question** J'ai fait l'hexagone dans le TP1 mais je ne vois pas comment faire la fonction qui fait un polygone régulier avec un nombre quelconque de côté

**Réponse** Il faut créer une liste qui va contenir tous les "tuple" `(cos(k*2*pi/n), sin(k*2*pi/n))` pour `k` allant de 1 à `n`. Apres avoir créé la liste, on pourra faire `return polygon2d(ma_liste) + circle(...)`

### Sur les dictionnaires

**Question** J'ai l'erreur suivante. TypeError: 'dict_values' object is not subscriptable

**Réponse** En effet, on ne peut pas écrire `d.value()[0]` (par exemple). Pour parcourir les valeurs du dictionnaire (et effectuer les calculs), on peut faire

for nom in d:
    d[nom] # faire votre calcul

Par exemple, pour faire la somme de toutes les notes

somme = 0
for nom in d:
    somme += d[nom]

**Question :** où est ce que les keys du dico on été appelées "nom"?

**Réponse** : au moment où on écrit "for nom in d", cela signifie que l'on va parcourir les clés du dictionnaire une à une et les mettre dans la variable `nom`. Donc à chaque iterration de liste, la variable `nom` contient une clé du dictionnaire

**Question** je comprends pas ce que on doit faire dans `compte[animal]`

**Réponse** `compte["kangourou"]` <<- le nombre de fois où on a kangourou dans la liste. Le principe est de parcourir la liste d'animaux et, à chaque fois qu'on voit un animal, on augmente sa valeur dans le dictionnaire.

### Sur l'interaction

**Question** pour la derniere interaction du tp2 je ne vois pas ce qu'on doit faire

**Réponse** On a calculé toutes les positions de la bille en fonction de la liste des mouvements. Dans l'animation, on doit voir la bille se déplacer. Dans l'interaction, c'est pareil, sauf qu'on veut controler à quel moment on est.

Ca ressemble à ça :

chemin = chemin_boule(mouvements)

def show_boule(i =...):
    dessign_boule(...)

**étudiant** j'ai fait

def interact_boule(t = slider(chemin)):
  show(dessine_boule(t))

ca marche pas

**Réponse** Je comprends l'idée, c'est pas mal. Mais le slider ne peut pas prendre directement l'objet, il a besoin de nombres entiers. Par exemple
`i = slider(range(len(chemin)))`

[Voilà la doc de interact](https://doc.sagemath.org/html/en/prep/Quickstarts/Interact.html)

**étudiant** ca fonctionne toujours pas je comprends vraiment pas

@interact
def interact_boule(t = slider(range(len(chemin)))):
    show(dessine_boule(t))

**Réponse** C'est presque ça, sauf que c'est `dessine_boule(chemin[t])`

## TP3 FAQ

**Question** Je suis bloqué sur la première question, je ne sais pas comment faire les plots ensemble sur le même dessin

**Réponse** il faut les relier avec des + plot(...) + plot(...)

**Question** Je comprends pas ce que je fais de mal pour la résolution d'une équation avec sage mais les résultats sont incompréhensible

J'ai fais: solve([x1^2 + y1^2 == 4, (x2 - 0.5)^2 + (y2 - 0.75)^2 == 4], x1, y1, x2, y2)

**Réponse** parce qu'en fait, tu cherches les points qui sont à la fois d'un côté et de l'autre, donc c'est le même x et y des deux côtes

tu veux x et y qui vérifient les équations des 2 cercles

**Question** sur les valeurs initiales pour le ressort, je vois pas du tout ce que ça peut être. J'obtiens "1" comme solution

**Mise à jour de l'énoncé pour que ce soit plus clair**

**Que choisir pour les conditions initiales ?** La solution que vous allez obtenir va dépendre des conditions initiales choisies. Si vous faites partir le ressort de sa position stable (à distance 1) sans vitesse, alors il restera sur place. **Choisissez des conditions initiales à $t=0$ pour que le ressort bouge, c'est-à-dire `ics = [0, ?, ?]` à vous de choisir les `?` pour que le ressort bouge**

**Réponse** Il faut regarder ce que signifie ces valeurs. Les valeurs initiales donnent la position et la vitesse du ressort au départ. Si le ressort est dans sa position "au repos" (à 1) et n'a pas de vitesse, il ne va pas bouger. Pour avoir un mouvement, il faut le faire commencer à 0 ou à 2 (on ressert le ressort ou on le tire) ou bien lui donner une vitesse initiale

**Question**
Pour le double ressort, comment on écrit le systeme sur papier ? Je ne comprends pas ce qu'il faut faire et je n'ai jamais fait d'équation différentielle

**Réponse**
Justement, c'est Sage qui résout les équations ici. Le système est un système d'équation classique. C'est juste une ré-écriture de ce que vous avez au dessus avec les variable a1 a2 a3 a4.

Par exemple, comme a1 est x1 et a3 est v1 alors a1' = a3

et a3' c'est la dérivée seconde de x1 qui est donnée plus haut

Il y a 0 maths à faire, juste comprendre ce que signifie les valeurs pour les donner à Sage

## TP Avancé Géologie FAQ

**Question** pour la fonction milieu_continu est ce qu'il faut mettre r en argument ? parce que dans votre fonction test juste dessous vous n'avez pas mis cet argument

**Réponse** non, la fonction ne peut pas prendre d'arguments autre que la position donc c'est vous qui fixez le r que vous voulez une fois pour toute

**Question**

Avec la fonction suivante, l'appel de `density_plot` ne fonctionne pas

def milieu_continu(x,y):
    f(t) = t^2
    C = (0,-0.5)
    r = 2
    d = sqrt((x-C[0])^2+(y-C[1])^2)
    if d > r: return 1
    else: return f(d/r)

**Réponse** Cela vient d'un bug très subtil. Il faut éviter d'utiliser des fonctions formelle à l"intérieur d'une autre fonction car cela "transforme" la variable t en variable formelle de façon globale. Ici, il y a sans doute quelque chose comme ça d'écrit dans `density_plot`

t = 100
for deltax in range(t):
    for deltay in range(t):
        x = -0.5 + deltax*1/t
        y = -1 + deltay*1/t
        v = milieu_continu(x,y)
        ...

Dès la deuxième itération de boucle, `t` n'a plus la valeur souhaitée et cela fait planter le calcul. Le mieux est de remplacer `f` par une fonction python, par exemple

def milieu_continu(x,y):
    def f(t):
        return t^2
    C = (0,-0.5)
    r = 2
    d = sqrt((x-C[0])^2+(y-C[1])^2)
    if d > r: return 1
    else: return f(d/r)

On peut aussi écrire de façon compacte :

`f = lambda t: t^2`

### fonction rayons

**Question / problème**
- je ne comprends pas le role de T ni où je dois arrêter la boucle.
- J'ai écrit ceci mais ensuite mes rayons ne font pas fous la même taille

def rayons(milieu, theta, T, delta):
    """
    Renvoie la liste des rayons r(t_0 = 0)...r(t_n > T) dans la direction theta par la méthode d'Euler explicite selon le milieu donné
    
    INPUT :
        - milieu, une fonction python
        - theta une valeur entre pi et 2*pi
        - T le temps T maximal
        - la variation de temps à chaque étape
    """
    tab = [0]
    r = 0
    while r < T:
        #print("theta =", theta)
        #print("r =", r)
        v = vitesse(milieu,r,theta)
        #print("vitesse = ",v)
        r = delta*v + r
        tab.append(r)
    return tab

La boucle while doit dépendre de temps $t$ par du rayon $r$. Au départ, le temps est à $t_0 = 0$. On s'arrête quand $t > T$. A chaque fois qu'on calcule un nouveau $r$, alors $t$ augmente de $\delta_t$.

## TP Avancé Jeu de dés

**Question** dans la question sur def proba_sommeDes(n): du tp jeu des dés, j'ai fait

res = 0

   for _ in range(10000):

       if sommeDes() == n :

           res += 1

   return res/10000

cela me donne des approximations mais pas des valeurs exacte donc les asserts ne passent pas

**Réponse** c'est parce qu'il faut calculer la proba exacte.
il y a 36 résultats possible (6 valeurs pour le dé 1 * 6 valeurs pour le dé 2). La proba sera donnée par (nombre de sommes égales à ...) / 36

par exemple, la proba d'avoir 2 est 1/36 car il n'y a qu'une eule façon d'obteir le 2

**Question** J'en suis à `meilleur_choix` je ne comprends pas les calculs d'esperence pour les dès a quoi corresponde les valeurs ?

**Réponse** le dictionnaire correspond à ça : pour chqaue configuration, quelle est la moyenne de ton score si tu joues bien. Par exemple, pour la configuration avec juste le jeton 1, la partie va s'arrếter dans tous les cas et on terminera avec le score 1.

Le reste de l'exercice permet de calculer le dictionnaire grâce à un algorithme de programmation dynamique mais comme on a besoin de la fonction `meilleur_choix`, je vous donne un exemple pour tester.

## TP Chemin Recursif

**Question / problème** Dans `chemins2` Je ne comprend pas ce que fait `list` , est-ce que le résultat de `chemins1` n'est pas déjà une liste ?

`list` permet de fabriquer ou copier une liste. `chemins1` renvoie une liste de chemins, mais aussi, chaque chemin est une liste.

for chemin in chemins1(): 

cette boucle parcours chaque chemin de la liste renvoyée par `chemins1` ensuite

chemin_a = list(chemin)

on copie le chemin pour pouvoir lui rajouter un pas et l'ajouter aux résultats.

**Question / Problème** Je ne comprends pas comment faire la fonction `chemin_end_point` j'ai écrit ça mais ça ne marche pas

def chemins_end_point(a,b):
    """
    Retourne la liste des chemins terminant au point (a,b)
    """
    # ecire le code
    
    R = []
    if (a < 0 or b < 0):
        return R
    elif a == 0 and b == 0:
        R = [[]]
    else:
        for i in range(a):
            chemin.append((i+1,0)) # on lui ajoute le pas (1,0)
        for i in range(b):
            chemin.append((0,i+1)) # on lui ajoute le pas (1,0)
    return R

le problème ici, c'est que vous n'utilisez pas la récursivité de la fonction. Il faut réutiliser l'idée qu'on a vu plus hauts avec `chemins(n)`. Dans `chemins(n)` on parcourt tous les chemins de taille $n-1$. Ici, je veux la liste de tous les chemins finissant en $(a,b)$.
Il me faut donc la liste de tous les chemins finissiant en $(a-1, b)$ (et je rajoute un pas horizonal) et la liste de tous les chemins finissants en $(a, b-1)$ et je rajoute un pas vertical.

## TP Jeu de dés

**Question** la fonction evalProba évalue la proba théorique ou expérimental?

Réponse : probabilité expérimentale donc en la rappelant plusieurs fois avec les mêmes paramètres, vous aurez des résultats légèrement différents.

**Question / problème** Qu'est-ce que `fonctionScore` dans `esperanceScore` ?

La fonction `fonctionScore` est passée en paramètre de la fonction esperance. C'est la fonction qui calcule le score asscocié à une configuration à la fin d'une partie. Dans les exemples d'appels en dessous, c'est `scoreLongueur` mais on écrit pas `scoreLongueur` dans la fonction espérance, on écrit bien `fonctionScore` comme c'est expliqué dans l'exemple

C'est juste la longueur de la configuration en fait... Mais en l'écrivant de cette façon, ça permet de réutiliser la même logique si on change la façon de calculer le score final

## Projet Labyrinthe

**Question** pour la question 3 il faut calculer le nombre de pseudo labyrinthes ou de labyrinthes?

Réponse : nombre de pseudo labyrinthe en fonction de la taille $n$.

## Submit

**Question** Je n'arrive pas a submit mes Tp, le problème semble venir de de course.py, a qui puis-je envoyer mes TP ?