Comment découper une ellipse en 36 cordes?

Bonjour,
Nous cherchons à découper une ellipse en 36 cordes. Pour cela on se place dans le quart supérieur droit de l'ellipse centrée en (0,0). On a fait un algorithme qui utilise la méthode Newton pour placer les 9 points dans ce quart d'ellipse, Pour placer les 9 points notre algorithme utilise une longueur de corde donné par l'utilisateur.(fonction ptellipse plus bas)
Ensuite nous avons une deuxième fonction qui utilise le principe de dichotomie pour approcher au mieux la longueur de la corde. Mais on a un problème. Il y trop d'itération à un moment qui fait que l'algo ne tourne pas. Mais on arrive à vous l'envoyer l'erreur et l'algorithme dans un fichier donc on le fait comme ça désolé.
PS. On travaillera sur la complexité plus tard et il n'est pas très écrit parce qu'on n'est très calé en informatique mais on travaillera sur ça plus tard !
Voici nos fonction sur python.

from math import pi
import numpy as np
import scipy.optimize as op

#attention il reste un pb avec newton mais on peu essayer avec mathématica allez voir à la fonction

##cette fonction calcule l'intersection entre l'ellipse et une droite
def inter(a,b,l,E):
   f= lambda x: (x-E[0])**2 +(sqrt(1-(x/a)**2)*b-E[1])**2 -l**2
   return f
   
    
    
##Fonction qui retourne une liste de 10 points sur une ellipse espacés d'une longueur l de corde
def ptellipse(a,b,l):
    i=1; #incrémentation
    T=[[a,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0]];# Liste de 11 cases contenants les 10 points 
    E=T[0];#Une liste de 2 cases qui contient les coordonnées
    M=a # valeur approchée du point qu'on cherche avec l'algorithme de newton
    for i in range(1,10):
        T[ i][0]=op.newton(inter(a,b,l,E),M);
        T[ i][1]=(1-(T[ i][0]/a)**(2))**(0.5)*b
        if abs((-T[ i][0]-T[ i-1][0])**(2)+(T[ i][1]-T[ i-1][1])**(2)-(T[1][0]-T[0][0])**(2)-(T[1][1]-T[0][1])**(2))<abs((T[ i][0]-T[ i-1][0])**(2)+(T[ i][1]-T[ i-1][1])**(2)-(T[1][0]-T[0][0])**(2)-(T[1][1]-T[0][1])**(2)):
           #Détermine si x est positif ou négatif
            T[ i][0]=-T[ i][0];
        E=T[ i];
        i=i+1;
        M=T[ i][0]
    return(T)
    
##Algorithme dichotomie: Qui retourne les 10 points recherchés
def dicho(a,b,err):#Err est la moitié de la longueur de notre intervalle ie: la précision
    lb=(pi/18)*((a*a+b*b)/2)**(1/2);#lb est une longueur de corde de départ plus grande que la vraie longueur de corde recherchée
    la=(pi*4/9*9)*((a*a+b*b)/2)**(1/2);# la est une longueur de corde cette fois plus petite que la vraie longueur de corde recherchée
    tabB=ptellipse(a,b,lb);#Tableau avec les points 10 de l'ellipse calculé à partir de la corde lb
    tabA=ptellipse(a,b,la);# idem avec la corde la
    while (-err>tabA[9][0])and(-err>tab[9][0])and(err<tabA[9][0])and(err<tab[9][0]): #Tant que l'intervalle [la,lb] n'est pas inclu dans l'intervalle [-err;err]
        lc=(la+lb)/2;#principe de dichotomie dans le but d'avoir un intervalle de plus en plus petit de [la,lb]
        tabc=ptellipse(a,b,lc);#Liste avec les 10 points de l'ellipse calculé avec la corde lc
        if tabc[9][0]==0:#si la coordonnée en x du dernier point est 0 alors c'est terminé!
            return tabc[9]
        else:#sinon on entre dans une nouvelle conditionelle 
            if tabc[9][0]>0:# si la coordonnée en x du dernier point est positive alors on raccourci l'intervalle du coté de la
                la=lc;
            else:#sinon la coordonnée en x  du point est négative alors on raccourci l'intervalle du coté lb
                lb=lc;
    k=ptellipse(a,b,(la+lb)/2)
    return k# on retourne les 10 points calculés avec un intervalle précis

[Du python sans indentation c'est bidon. :-) AD]