Encontrando la raíz cuadrada usando el método de Newton (¡errores!)

Estoy trabajando para terminar un problema matemático que se aproxima a la raíz cuadrada de un número utilizando el método de verificación y conjetura de Newton en Python. Se supone que el usuario debe ingresar un número, una estimación inicial del número y la cantidad de veces que desea verificar su respuesta antes de regresar. Para facilitar las cosas y conocer Python (hace un par de meses, apenas comencé a aprender el idioma), lo dividí en varias funciones más pequeñas; Sin embargo, el problema ahora es que estoy teniendo problemas para llamar a cada función y pasar los números.

Aquí está mi código, con comentarios para ayudar (cada función está en orden de uso):

# This program approximates the square root of a number (entered by the user) # using Newton's method (guess-and-check). I started with one long function, # but after research, have attempted to apply smaller functions on top of each # other. # * NEED TO: call functions properly; implement a counting loop so the # goodGuess function can only be accessed the certain # of times the user # specifies. Even if the - .001 range isn't reached, it should return. # sqrtNewt is basically the main, which initiates user input. def sqrtNewt(): # c equals a running count initiated at the beginning of the program, to # use variable count. print("This will approximate the square root of a number, using a guess-and-check process.") x = eval(input("Please type in a positive number to find the square root of: ")) guess = eval(input("Please type in a guess for the square root of the number you entered: ")) count = eval(input("Please enter how many times would you like this program to improve your initial guess: ")) avg = average(guess, x) g, avg = improveG(guess, x) final = goodGuess(avg, x) guess = square_root(guess, x, count) compare(guess, x) # Average function is called; is the first step that gives an initial average, # which implements through smaller layers of simple functions stacked on each # other. def average(guess, x) : return ((guess + x) / 2) # An improvement function which builds upon the original average function. def improveG(guess, x) : return average(guess, x/guess) # A function which determines if the difference between guess X guess minus the # original number results in an absolute vale less than 0.001. Not taking # absolute values (like if guess times guess was greater than x) might result # in errors from math import * def goodGuess(avg, x) : num = abs(avg * avg - x) return (num < 0.001) # A function that, if not satisfied, continues to "tap" other functions for # better guess outputs. ie as long as the guess is not good enough, keep # improving the guess. def square_root(guess, x, count) : while(not goodGuess(avg, x)): c = 0 c = c + 1 if (c < count): guess = improveG(guess, x) elif (c == count): return guess else : pass # Function is used to check the difference between guess and the sqrt method # applied to the user input. import math def compare(guess, x): diff = math.sqrt(x) - guess print("The following is the difference between the approximation") print("and the Math.sqrt method, not rounded:", diff) sqrtNewt() 

Actualmente, recibo este error: g, avg = improveG(guess, x) TypeError: 'float' object is not iterable. La función final usa la iteración final de la conjetura para restar del método matemático de la raíz cuadrada y devuelve la diferencia general. ¿Estoy haciendo esto bien? Se agradecería el código de trabajo, con sugerencias, si puede proporcionarlo. Nuevamente, soy un novato, así que me disculpo por los conceptos erróneos o los errores obvios ciegos.

Implementación del método newton:

Debería ser bastante fácil añadirle pequeños retoques cuando sea necesario. Intenta, y dinos cuando te quedas atascado.

 from math import * def average(a, b): return (a + b) / 2.0 def improve(guess, x): return average(guess, x/guess) def good_enough(guess, x): d = abs(guess*guess - x) return (d < 0.001) def square_root(guess, x): while(not good_enough(guess, x)): guess = improve(guess, x) return guess def my_sqrt(x): r = square_root(1, x) return r >>> my_sqrt(16) 4.0000006366929393 

NOTA: encontrará ejemplos suficientes sobre cómo utilizar la entrada en bruto aquí en SO o en google, PERO, si está contando bucles, c=0 debe estar fuera del bucle, o quedará atrapado en un bucle infinito.

Quiqk y sucio, muchas formas de mejorar:

 from math import * def average(a, b): return (a + b) / 2.0 def improve(guess, x): return average(guess, x/guess) def square_root(guess, x, c): guesscount=0 while guesscount < c : guesscount+=1 guess = improve(guess, x) return guess def my_sqrt(x,c): r = square_root(1, x, c) return r number=int(raw_input('Enter a positive number')) i_guess=int(raw_input('Enter an initial guess')) times=int(raw_input('How many times would you like this program to improve your initial guess:')) answer=my_sqrt(number,times) print 'sqrt is approximately ' + str(answer) print 'difference between your guess and sqrt is ' + str(abs(i_guess-answer)) 

La respuesta elegida es un poco complicada … sin faltarle el respeto al OP.

Para cualquiera que haya buscado en Google esto en el futuro, esta es mi solución:

 def check(x, guess): return (abs(guess*guess - x) < 0.001) def newton(x, guess): while not check(x, guess): guess = (guess + (x/guess)) / 2.0 return guess print newton(16, 1) 

Aquí hay una función bastante diferente para calcular raíces cuadradas; asume que n es no negativo:

 def mySqrt(n): if (n == 0): return 0 if (n < 1): return mySqrt(n * 4) / 2 if (4 <= n): return mySqrt(n / 4) * 2 x = (n + 1.0) / 2.0 x = (x + n/x) / 2.0 x = (x + n/x) / 2.0 x = (x + n/x) / 2.0 x = (x + n/x) / 2.0 x = (x + n/x) / 2.0 return x 

Este algoritmo es similar al de Newton, pero no idéntico. Fue inventado por un matemático griego llamado Heron (su nombre a veces se llama Héroe) que vive en Alejandría, Egipto, en el primer siglo (hace unos dos mil años). La fórmula de recurrencia de Heron es más simple que la de Newton; Heron usó x' = (x + n/x) / 2 donde Newton usó x' = x - (x^2 - n) / 2x .

La primera prueba es un caso especial en cero; sin ella, la prueba (n < 1) provoca un bucle infinito. Las siguientes dos pruebas normalizan n en el rango 1 < n <= 4 ; hacer el rango más pequeño significa que podemos calcular fácilmente una aproximación inicial a la raíz cuadrada de n , que se realiza en el primer cálculo de x , y luego "desenrollar el bucle" e iterar la ecuación de recurrencia un número fijo de veces, eliminando así la necesidad de pruebas y repeticiones si la diferencia entre dos bucles sucesivos es demasiado grande.

Por cierto, Heron era un tipo bastante interesante. Además de inventar un método para calcular raíces cuadradas, construyó un motor a reacción, una máquina expendedora que funciona con monedas y muchas otras cosas interesantes.

Puedes leer más sobre la computación de raíces cuadradas en mi blog .

No debería ser tan complicado. Escribí esto.

 def squareroot(n,x): final = (0.5*(x+(n/x))) print (final) for i in range(0,10): final = (0.5*(final+(n/final))) print (final) 

o podrias cambiarlo para ser asi

 n = float(input('What number would you like to squareroot?')) x = float(input('Estimate your answer')) final = (0.5*(x+(n/x))) print (final) for i in range(0,10): final = (0.5*(final+(n/final))) print (final) 

Todo lo que necesitas saber es el enésimo término en la secuencia. De la serie Leibniz, sabemos que esto es ((-1) ** n) / ((2 * n) +1). Solo sum esta serie para todo i con una condición inicial de cero y listo.

 def myPi(n): pi=0 for i in range(0,n): pi=pi+((-1)**i)/((2*i)+1) return 4*pi print (myPi(10000))