Нахождение квадратного корня по методу Ньютона (ошибки!)

я работаю, чтобы закончить математическую задачу, которая приближается к квадратному корню из числа, используя Ньютонаугадать и проверить метод в Python. Предполагается, что пользователь вводит число, начальное предположение о числе и сколько раз он хочет проверить свой ответ, прежде чем вернуться. Чтобы сделать вещи проще и познакомиться с Python (ямы только начали изучать язык пару месяцев назад) я разбил его на несколько небольших функций; проблема сейчас в том, что яУ меня проблемы с вызовом каждой функции и передачей чисел.

Вот мой код с комментариями, чтобы помочь (каждая функция в порядке использования):

# 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. i.e. 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()

В настоящее время я получаю эту ошибку:g, avg = improveG(guess, x) TypeError: 'float' object is not iterable. Последняя функция использует последнюю итерацию предположения для вычитания из метода математического квадратного корня и возвращает общую разницу. Я даже делаю это правильно? Рабочий код будет оценен, с предложениями, если вы можете предоставить его. Опять яЯ новичок, поэтому я прошу прощения за неправильные представления или слепые очевидные ошибки.

 root12 окт. 2012 г., 01:29
ты смотрел наradiantbytes.com/books/python-latex/src/chap9.html - Это'все там :)

Ответы на вопрос(5)

s довольно другая функция для вычисления квадратных корней; это предполагает неотрицательно:

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

Этот алгоритм похож на Ньютонас, но не идентичны. Он был изобретен греческим математиком по имени Герон (его иногда называют Герой), жившим в Александрии, Египет, в первом веке (около двух тысяч лет назад). цапля»формула повторения проще, чем Ньютонаs; Цапля бx' = (x + n/x) / 2 где Ньютон использовал.x' = x - (x^2 - n) / 2x

Первый тест - это особый случай на нуле; без этого(n < 1) Тест вызывает бесконечный цикл. Следующие два теста нормализуют к диапазону1 < n <= 4; уменьшение диапазона означает, что мы можем легко вычислить начальное приближение к квадратному корню из n, что делается в первом вычислении х, а потом "разверните петлю и повторять уравнение повторения фиксированное число раз, что устраняет необходимость в тестировании и повторении, если разница между двумя последовательными циклами слишком велика.

Кстати, Цапля была довольно интересным парнем. В дополнение к изобретению метода вычисления квадратных корней, он построил работающий реактивный двигатель, торговый автомат, управляемый монетами, и много других интересных вещей!

Вы можете прочитать больше о вычислении квадратных корней намой блог.

 user173953720 окт. 2012 г., 20:13
Спасибо! Добавлю, что в комментариях моего кода; довольно полезно

это не должно быть так сложно, я написал это

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)

или вы могли бы изменить это так

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)
Решение Вопроса

Это должно быть довольно легко добавить небольшие настройки, когда это необходимо. Попробуйте и расскажите нам, когда застрянете.

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

ПРИМЕЧАНИЕ: вы найдете достаточно примеров того, как использовать необработанный ввод здесь в SO или googling, НО, если вы считаете циклы,c=0 должен быть вне цикла, иначе вы застрянете в бесконечном цикле.

Quiqk и грязный, много способов улучшить:

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))
 root12 окт. 2012 г., 01:48
@ duffymo - да, это так :)
 user173953719 окт. 2012 г., 21:58
@root сделает! Спасибо!
 user173953714 окт. 2012 г., 17:59
Спасибо, рут! Я должен сказать, что ям с использованием Python версии 3.30, поэтому я внес соответствующие изменения. Я предполагаю, что мог бы также вычесть предположение из числа, возвращенного Math.sqrt. Опять же, это было очень полезно; действительно ценю это!
 duffymo12 окт. 2012 г., 01:45
+1 - красиво сделано. Я неПредположим, что Ник дает вам преимущество над такими проблемами. 8)

что вам нужно знать, это n-й член в последовательности. Из ряда Лейбница мы знаем, что это ((-1) ** n) / ((2 * n) +1). Просто сложите эту серию для всех я с начальным условием ноль, и высброс.

def myPi(n):

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

Для тех, кто когда-либо гуглит это в будущем, это мое решение:

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)

Ваш ответ на вопрос