Python Turtle Graphics, comment tracer des fonctions sur un intervalle?

Question

J'ai besoin de tracer une fonction sur un intervalle spécifié. La fonction est f1, représentée ci-dessous dans le code, et l'intervalle est [-7, -3]; [-1, 1]; [3, 7] avec un pas de 0,01. Quand j'exécute le programme, rien n'est dessiné. Des idées?

import turtle 
from math import sqrt 

wn = turtle.Screen() 
wn.bgcolor("white") 
wn.title("Plotting") 
mypen = turtle.Turtle() 
mypen.shape("classic") 
mypen.color("black") 
mypen.speed(10) 

while True: 
try: 
    def f1(x): 
     return 2 * sqrt((-abs(abs(x)-1)) * abs(3 - abs(x))/((abs(x)-1)*(3-abs(x)))) * \ 
(1 + abs(abs(x)-3)/(abs(x)-3))*sqrt(1-(x/7)**2)+(5+0.97*(abs(x-0.5)+abs(x+0.5))-\ 
3*(abs(x-0.75)+abs(x+0.75)))*(1+abs(1-abs(x))/(1-abs(x))) 

    mypen.penup() 

    step=.01 
    startf11=-7 
    stopf11=-3 
    startf12=-1 
    stopf12=1 
    startf13=3 
    stopf13=7 
    def f11 (startf11,stopf11,step): 
     rc=[] 
     y = f1(startf11) 
     while y<=stopf11: 
      rc.append(startf11) 
      #y+=step 
      mypen.setpos(f1(startf11)*25,y*25) 
      mypen.dot() 
    def f12 (startf12,stopf12,step): 
     rc=[] 
     y = f1(startf12) 
     while y<=stopf12: 
      rc.append(startf12) 
      #y+=step 
      mypen.setpos(f1(startf12)*25, y*25) 
      mypen.dot() 
    def f13 (startf13,stopf13,step): 
     rc=[] 
     y = f1(startf13) 
     while y<=stopf13: 
      rc.append(startf13) 
      #y+=step 
      mypen.setpos(f1(startf13)*25, y*25) 
      mypen.dot() 

    f11(startf11,stopf11,step) 
    f12(startf12,stopf12,step) 
    f13(startf13,stopf13,step) 

except ZeroDivisionError: 
    continue 

Answer 1

Je pense que f1 renvoie une valeur imaginaire. J'ai littéralement commencé à apprendre Python comme il y a 15 minutes et je commence avec la tortue. Donc, je ne pourrais pas comprendre complètement et être hors ... mais en général je comprends le code ...

Mais oui quand vous l'avez défini; ce bit votre deuxième terme.

sqrt ((-. Abs (abs (x) -1))

que vous essayez d'obtenir le squareRoot d'un nombre négatif Ce n'est pas sur le plan cartésien Aucune idée comment les mathématiques interprète cela et non. idée comment tortue l'interprète soit mais c'est ma première conjecture ...

Answer 2

Vous essayez de tracer une fonction boguée en utilisant un code de traçage bogué, vous devez les déboguer séparément, pas ensemble. Commençons par la fonction. regardez les départs des trois intervalles en question, -7, -1, et 3 et appelez f1() sur eux, nous obtenons:

-7 -> 0.0 
-1 -> division by zero 
3 -> division by zero 

Dans la première, ploting ne commence que f1(startf11) est > stopf11 aka -3 avant que la boucle commence:

y = f1(startf11) 
while y <= stopf11: 

Dans les deux autres cas, il n'y a pas y en raison de la division par zéro comme

except ZeroDivisionError: 
    continue 

ne résout pas ce problème. Donc pas de complots. Ce qui n'a probablement pas d'importance puisque le code de tracé lui-même ne fonctionne pas. Les trois f1* fonctions (qui sont identiques BTW qui n'a pas de sens) ne:

while y <= stop: 

mais y ne change jamais il est une boucle infinie. Le commenté y += step aiderait, mais dans une position différente dans le code. En outre, il tente de tracer 100 valeurs pour chaque pixel d'écran individuel! Cela peut être accommodé en changeant le système de coordonnées mais je ne vais pas entrer dans cela ici, il suffit de réduire cela à 10 valeurs pour chaque pixel de l'écran pour accélérer le résultat.

Recommençons avec le code en utilisant une fonction traçage de test plus simple:

def f1(x): 
    return x 

et obtenir que pour tracer cela avec succès. Voici mon réusinage du code traçante:

from turtle import Turtle, Screen 

def f1(x): 
    return x # dummy test plot 

wn = Screen() 

mypen = Turtle(visible=False) 
mypen.speed('fastest') 
mypen.penup() 

def f11(start, stop, step): 

    y = f1(start) 

    while y <= stop: 

     try: 
      mypen.setpos(f1(start) * 25, y * 25) 
      mypen.dot() 
      y += step 

     except ZeroDivisionError: 
      continue 

step = 0.1 # increased from 0.01 for debugging/speed 

startf11 = -7 
stopf11 = -3 

f11(startf11, stopf11, step) 

startf12 = -1 
stopf12 = 1 

f11(startf12, stopf12, step) 

startf13 = 3 
stopf13 = 7 

f11(startf13, stopf13, step) 

wn.exitonclick() 

Ce qui nous donne le résultat du test:

Ce qui semble raisonnable pour notre fonction de test. Maintenant, vous êtes en mesure de changer le système de coordonnées pour un tracé de plus haute résolution et/ou déboguer votre fonction f1() en utilisant un traceur de travail.