Ellipse en 36 cordes

15011997
15011997
dans Géométrie
Bonjour,
Je me demandais s'il était possible de découper une ellipse en 36 cordes de mêmes longueurs (36 segments de même longueur ) ?
Je ne sais pas calculer l'intégrale curviligne et la formule du périmètre est approximative.
J'ai essayé avec la construction d'une ellipse avec des cercles mais je n'arrive pas à aboutir sur un cas général.
Et à partir d'une vraie ellipse j'ai essayé la projection stéréographique mais ça ne me sert finalement à rien... Quelqu'un a-t-il quelque chose à me proposer ?
Ou alors une démonstration pour montrer que ce n'est pas possible ?

Réponses

  • pappus
    pappus
    Bonjour
    Essaye dèjà de le faire pour un cercle et envoie nous ta figure pourqu’on sache ce que tu veux faire exactement.
    Amicalement
    [small]p[/small]appus
  • jelobreuil
    jelobreuil
    Bonjour 15051997,
    Si je comprends bien, tu veux trouver comment placer sur une ellipse 36 points tels que les 36 arcs d'ellipse aient tous la même longueur ? Si tu peux assimiler les arcs avec les cordes, cela revient à inscrire dans une ellipse un polygone de 36 côtés, tous égaux.
    Tu veux le faire avec un ordinateur, j'imagine ?
    Dans ce cas, je me permets de joindre un fichier qui pourra peut-être te donner des idées pour y arriver. Ce travail concerne le cercle, mais je pense qu'il peut très bien s'adapter à une ellipse.
    Je résume l'idée qui en découle, qui consiste à opérer par itération.
    Tu commences par définir sur ton ellipse 36 points quelconques, assez régulièrement espacés. Tu détermines les milieux de chaque arc ou de chaque corde ainsi défini(e), cela te donne un nouveau polygone à 36 côtés. Et tu recommences l'opération sur ce nouveau polygone, et tu répètes l'opération autant de fois que tu veux, jusqu'à ce que tu sois satisfait de l'approximation obtenue.
    Comme tu pourras le voir dans le fichier joint, les longueurs des 36 côtés doivent s'uniformiser à la longue ... Toutefois, comme ce processus est asymptotique, tu n'obtiendras pas quelque chose de parfaitement exact, mais comme on ne peut pas calculer la longueur vraiment exacte d'une ellipse, je pense que si tu pars d'une configuration déjà assez régulière de tes 36 points, tu devrais, au bout de 5 ou 6 itérations, obtenir quelque chose de tout à fait acceptable ...
    Bien cordialement
    JLB
  • Math Coss
    Math Coss
    Aparté : voici une réponse approchée en Sage à une autre question : découper une ellipse en $n$ arcs de même longueur. 
    def f(t,a=3,b=2):
    """ longueur de l'ellipse x^2/a^2 + y^2/b^2 = 1 entre (a,0) et (a\cos t, b\sin t)"""
    res = numerical_integral(sqrt((a*sin(x))^2+(b*cos(x))^2),0,t)
    return res[0]

def dicho(f,a,b,e=1e-6):
    """ dichotomie : f = fonction ; a,b = extrémités de l'intervalle ; e = précision """
    if f(a)*f(b)>0:
        print "Pas de solutions a priori"
        return
    while b-a>e:
        c = (a+b)/2.
        if f(a)*f(c)<=0:
            a, b = a, c
        else:
            a, b = c, b
    return (a+b)/2.

def decoupe(n,a,b):
    """ renvoie n-1 couples (t,a\cos t,b\sin t) correspondant au découpage
        de l'ellipse en n arcs de même longueur """
    l = f(2*pi,a,b)
    L = []
    for k in range(1,n):
        g = lambda x: f(x,a,b)-k*l/n
        t = dicho(g,0,2*pi.n(),1e-6)
        L.append([t,(a*cos(t),b*sin(t))])
    return L

def dessin(n,a,b):
    D = decoupe(n,a,b)
    G = parametric_plot([a*cos(x),b*sin(x)],(x,0,2*pi))
    G+= point((a,0),color="red",size=10)
    for d in D:
        G+= point(d[1],color="red",size=10)
        G+= point((d[1][0],-d[1][1]),color="red",size=10)
    return G
    74662
  • jelobreuil
    jelobreuil
    Bonsoir,
    Voici un essai avec 10 points sur une ellipse, où je me suis limité à trois itérations effectuées sur les cordes et les segments dérivés : points bleux sur ellipse initiale, milieux de premier ordre = points noirs, milieux de deuxième ordre = points rouges, milieux de troisième ordre = points verts (avec ellipse passant par cinq de ces points). Visiblement, les valeurs des distances entre les points verts sont moins dispersées que celles des distances entre les points bleus, n'est-ce pas?
    Bien sûr, pour faire plus rigoureux, il faudrait sans doute projeter chaque point-milieu sur l'ellipse initiale selon la bissectrice de l'angle formé par les rayons associés au point respectif ...
    Math Coss, sur quel principe ce programme Sage est-il basé ? si j'en crois l'expression c = (a + b) / 2, j'ai l'impression que c'est assez voisin de la méthode que je propose ...
    Bien cordialement
    JLB74664
  • Math Coss
    Math Coss
    Ce n'est sans doute la même méthode parce que ce n'est pas le même problème : arcs ou cordes égales ?
    Le c=(a+b)/2 apparaît dans une procédure de résolution d'une équation numérique par dichotomie (la procédure intégrée find_root de Sage ne semble pas apprécier une fonction définie par une intégrale, ça me coûtait moins d'efforts d'écrire une dichotomie que de résoudre un problème peut-être seulement de syntaxe).
    Le principe pour partager une ellipse en $n$ arcs de même longueur, c'est de la paramétrer et de calculer (approximativement, obligatoirement) la longueur totale $L$, puis de trouver numériquement (par dichotomie donc) les paramètres où la longueur depuis un sommet fixé vaut $L/n$, $2L/n$, etc. De là au dessin il n'y a qu'un pas. Bourrinage pur, quoi.
  • jelobreuil
    jelobreuil
    Math Coss, tu as raison, je viens de regarder sur Wikipedia ce qu'est cette méthode de dichotomie : en effet, cela ne ressemble pas à ce que je propose ...
    Il y a quand même un point commun, on détermine les milieux d'intervalles successifs, mais c'est bien le seul ! Ce qu'on en fait, c'est là que ça diverge ...
    D'un autre côté, pour le problème posé, avec 36 points dans une ellipse, soit des intervalles angulaires de 10°, cordes et arcs devraient être assez proches, non ? surtout autour des sommets placés sur le petit axe ?
    bien cordialement
    JLB
  • 15011997
    15011997
    Bonjour,

    On cherche a faire un polygone (pas régulier du coup ?) de 36 côtés égaux dans une ellipse.
    Sur un cercle ça donne un polygone régulier avec 36 cotés.(pièce jointe)
    Merci de vos réponses !
    Si j'ai bien compris Math coss ce que tu proposes c'est :
    1) on calcul la longueur de l'ellipse (avec l'ordi ) et on la divise par 36 pour placer 36 points sur l'ellipse.
    2) on calcul la longueur de chaque morceau d'ellipse et on la divise par 2 pour placer poser un nouveau point à mi-distance (le long de l'ellipse) et on obtient 36 nouveaux points.
    3) On recommence jusqu'à ce qu'on soit contente.
    Est ce que c'est ça ?
    Je vais prendre le temps de lire le dossier jelobreuil merci.74750
  • Math Coss
    Math Coss
    En gros, c'est ça. Soit $f:t\mapsto f(t)$ la longueur de l'arc de l'ellipse entre les paramètres $0$ et $t$ (l'ellipse est paramétrée par $t\mapsto (a\cos t,b\sin t)$). On calcule une valeur approchée de la longueur $L=f(2\pi)$ puis on calcule $t_k$ tel que $f(t_k)=kL/n$.

    Encore une fois, ce ne sont pas les cordes qui mesurent $L/n$ mais les arcs d'ellipse. Voici un programme qui coupe en arcs cordes de même longueur. L'idée est naïve : on part d'une division en paramètres égaux, c'est-à-dire $M_k(a\cos t_k,b\sin t_k)$ où $t_k=2\pi k/n$ ; de façon itérative, on suit la ligne de plus grande pente de la fonction « variance » de la distribution des distance $(M_kM_{k+1})_{0\le k\le n-1}$. 
    tau = 2*pi.n()
def X(s,a,b):
    return vector([a*cos(tau*s),b*sin(tau*s)])
def V(t,a,b):
    tt = copy(t)
    tt.append(0)
    n = len(tt)
    N = [(X(tt[k],a,b)-X(tt[(k+1)%n],a,b)).norm() for k in range(n)]
    S = 1/n * sum(N)-(1/n*add(sqrt(u) for u in N))^2
    return S
def dV(t,k,a,b,eps=1e-6):
    eeps = 1e-6
    v = V(t,a,b)
    t[k]+= eeps
    w = V(t,a,b)
    return (w-v)/eeps
def gradV(t,a,b,eps=1e-8):
    return vector([dV(t,k,a,b,eps) for k in range(len(t))])
def unpas(t,a=3,b=2,eps=1e-8):
    g = gradV(t,a,b,eps)
    h = -1/g.dot_product(g)*V(t,a,b)*g
    return h
def resout(n,a,b,eps=1e-6):
    t, cpt = [1.*k/n for k in range(1,n)], 0
    while V(t,a,b)>eps and cpt<20:
        h = unpas(t,a,b,eps)
        t = list(vector(t)+h)
        cpt+= 1
    return [0]+t
def dessin(n,a,b):
    G = parametric_plot(X(x,a,b),(x,0,1))
    G+= polygon([X(k/n,a,b) for k in range(n)],color="lightgray",fill=False)
    G+= polygon([X(t,a,b) for t in resout(n,a,b)],color="black",fill=False)
    G+= polygon([p[1] for p in decoupe(n,a,b)+[(0,(a,0))]], color="green",fill=False)
    return G
    J'ajoute un exemple avec trois polygones pour une ellipse bien allongée, $\frac{x^2}{6^2}+y^2=1$ :
    • en gris, le polygone de sommets $(6\cos\frac{k}9,\sin\frac{2\pi k}9)$ ($0\le k\le 8$) ;
    • en noir, le découpage en $9$ cordes égales ;
    • en vers, le découpage en 9 arcs égaux.
    Edit : L'exemple ci-dessous montre que ça ne va pas du tout, justement, si l'ellipse est trop aplatie par rapport au nombre de cordes : pas d'espoir de trouver une solution avec un sommet du polygone en $(a,0)$. Si on coupe en $9$ par exemple, la cinquième corde est oblique, ce qui force une dissymétrie par rapport à $(Ox)$ et donc les cordes n'ont pas la même longueur. À reprendre...74884
  • Math Coss
    Math Coss
    Version modifiée. Notez que je ne sais pas s'il y a une solution pour tout $n$, sauf cas particuliers (puissances de $2$ ou $3$ par exemple). 
    tau = 2*pi.n()
def X(s,a,b):
    return vector([a*cos(tau*s),b*sin(tau*s)])
def V(t,a,b):
    tt = copy(t)
    # tt.append(0)
    n = len(tt)
    N = [(X(tt[k],a,b)-X(tt[(k+1)%n],a,b)).norm() for k in range(n)]
    S = 1/n * sum(N)-(1/n*add(sqrt(u) for u in N))^2
    return sqrt(S)
def dV(t,k,a,b,eps=1e-8):
    eeps = 1e-8
    v = V(t,a,b)
    t[k]+= eeps
    w = V(t,a,b)
    return (w-v)/eeps
def gradV(t,a,b,eps=1e-8):
    return vector([dV(t,k,a,b,eps) for k in range(len(t))])
def unpas(t,a=3,b=2,eps=1e-8):
    g = gradV(t,a,b,eps)
    h = -1/g.dot_product(g)*V(t,a,b)*g
    return h
def resout(n,a,b,eps=1e-6):
    t, cpt = [1.*k/n for k in range(n)], 0
    while V(t,a,b)>eps and cpt<1590:
        h = unpas(t,a,b,eps)
        t = list(vector(t)+h)
        cpt+= 1
    print "Valeur atteinte : %s  (en %s coups)" % (V(t,a,b),cpt)
    return t
def dess(n,a,b):
    G = parametric_plot(X(x,a,b),(x,0,1))
    G+= polygon([X(k/n,a,b) for k in range(n)],color="lightgray",fill=False)
    G+= polygon([X(t,a,b) for t in resout(n,a,b)],color="black",fill=False)
    G+= polygon([p[1] for p in decoupe(n,a,b)+[(0,(a,0))]], color="green",fill=False)
    return G
    PS : Même pas clair pour une puissance de $2$ en fait !74890
Connectez-vous ou Inscrivez-vous pour répondre.

Bonjour!

Pour participer au forum, cliquer sur l'un des boutons :

Connexion S'inscrire

Catégories

In this Discussion

Qui est en ligne 28

CongruDomJLTgai requinigrec27micheltombroffstfj +21 Invités