Nano Hash - криптовалюты, майнинг, программирование

Расчет полинома Тейлора

В настоящее время я делаю упражнение на питоне для учебы в университете. Я очень застрял в этой задаче:

Полином Тейлора степени N для экспоненциальной функции e^x определяется выражением:

        N
p(x) = Sigma  x^k/k!  
k = 0

Создайте программу, которая (i) импортирует класс Polynomial (находится в разделе), (ii) считывает x и ряд значений N из командной строки, (iii) создает экземпляр Polynomial, представляющий полином Тейлора, и (iv) печатает значения p(x) для заданных значений N, а также точное значение e^x. Попробуйте программу с x = 0,5, 3, 10 и N = 2, 5, 10, 15, 25.

Полином.py

import numpy

class Polynomial:
def __init__(self, coefficients):
    self.coeff = coefficients

def __call__(self, x):
    """Evaluate the polynomial."""
    s = 0
    for i in range(len(self.coeff)):
        s += self.coeff[i]*x**i
    return s

def __add__(self, other):
    # Start with the longest list and add in the other
    if len(self.coeff) > len(other.coeff):
        result_coeff = self.coeff[:]  # copy!
        for i in range(len(other.coeff)):
            result_coeff[i] += other.coeff[i]
    else:
        result_coeff = other.coeff[:] # copy!
        for i in range(len(self.coeff)):
            result_coeff[i] += self.coeff[i]
    return Polynomial(result_coeff)

def __mul__(self, other):
    c = self.coeff
    d = other.coeff
    M = len(c) - 1
    N = len(d) - 1
    result_coeff = numpy.zeros(M+N+1)
    for i in range(0, M+1):
        for j in range(0, N+1):
            result_coeff[i+j] += c[i]*d[j]
    return Polynomial(result_coeff)

def differentiate(self):
    """Differentiate this polynomial in-place."""
    for i in range(1, len(self.coeff)):
        self.coeff[i-1] = i*self.coeff[i]
    del self.coeff[-1]

def derivative(self):
    """Copy this polynomial and return its derivative."""
    dpdx = Polynomial(self.coeff[:])  # make a copy
    dpdx.differentiate()
    return dpdx

def __str__(self):
    s = ''
    for i in range(0, len(self.coeff)):
        if self.coeff[i] != 0:
            s += ' + %g*x^%d' % (self.coeff[i], i)
    # Fix layout
    s = s.replace('+ -', '- ')
    s = s.replace('x^0', '1')
    s = s.replace(' 1*', ' ')
    s = s.replace('x^1 ', 'x ')
    #s = s.replace('x^1', 'x') # will replace x^100 by x^00
    if s[0:3] == ' + ':  # remove initial +
        s = s[3:]
    if s[0:3] == ' - ':  # fix spaces for initial -
        s = '-' + s[3:]
    return s

def simplestr(self):
    s = ''
    for i in range(0, len(self.coeff)):
        s += ' + %g*x^%d' % (self.coeff[i], i)
    return s


def _test():
    p1 = Polynomial([1, -1])
    p2 = Polynomial([0, 1, 0, 0, -6, -1])
    p3 = p1 + p2
print p1, '  +  ', p2, '  =  ', p3
p4 = p1*p2
print p1, '  *  ', p2, '  =  ', p4
print 'p2(3) =', p2(3)
p5 = p2.derivative()
print 'd/dx', p2, '  =  ', p5
print 'd/dx', p2,
p2.differentiate()
print '  =  ', p5
p4 = p2.derivative()
print 'd/dx', p2, '  =  ', p4

if __name__ == '__main__':
_test()

Теперь я действительно застрял в этом, и я хотел бы получить объяснение! Я должен написать свой код в отдельном файле. Я думаю о создании экземпляра класса Polynomial и отправке списка в argv[2:], но, похоже, это не работает. Должен ли я сделать определение, чтобы вычислить полином Тейлора для различных значений N, прежде чем отправлять его в класс Polynomial?

Любая помощь очень важна, заранее спасибо :)

01.11.2012

Ответы:


1

Не совсем закончено, но я считаю, что это отвечает на ваш главный вопрос. Поместите класс Polynomial в poly.p и импортируйте его.

from poly import Polynomial as p
from math import exp,factorial

def get_input(n):
    ''' get n numbers from stdin '''
    entered = list()
    for i in range(n):
        print 'input number '
    entered.append(raw_input())
    return entered

def some_input():
    return [[2,3,4],[4,3,2]]



get input from cmd line                                                                                                                                   
n = 3                                                                                                                                                     
a = get_input(n)                                                                                                                                          
b = get_input(n)                                                                                                                                          


#a,b = some_input()

ap = p(a)
bp = p(b)


print 'entered : ',a,b

c = ap+bp

print 'a + b = ',c

print exp(3)

x = ap
print x

sum = p([0])
for k in range(1,5):
    el = x
    for j in range(1,k):
        el  el * x
        print 'el: ',el
    if el!=None and sum!=None:
        sum = sum + el
        print 'sum ',sum

выход

entered :  [2, 3, 4] [4, 3, 2]
a + b =  6*1 + 6*x + 6*x^2
20.0855369232
2*1 + 3*x + 4*x^2
sum  2*1 + 3*x + 4*x^2
el:  4*1 + 12*x + 25*x^2 + 24*x^3 + 16*x^4
sum  6*1 + 15*x + 29*x^2 + 24*x^3 + 16*x^4
el:  4*1 + 12*x + 25*x^2 + 24*x^3 + 16*x^4
el:  8*1 + 36*x + 102*x^2 + 171*x^3 + 204*x^4 + 144*x^5 + 64*x^6
sum  14*1 + 51*x + 131*x^2 + 195*x^3 + 220*x^4 + 144*x^5 + 64*x^6
el:  4*1 + 12*x + 25*x^2 + 24*x^3 + 16*x^4
el:  8*1 + 36*x + 102*x^2 + 171*x^3 + 204*x^4 + 144*x^5 + 64*x^6
el:  16*1 + 96*x + 344*x^2 + 792*x^3 + 1329*x^4 + 1584*x^5 + 1376*x^6 + 768*x^7 + 256*x^8
sum  30*1 + 147*x + 475*x^2 + 987*x^3 + 1549*x^4 + 1728*x^5 + 1440*x^6 + 768*x^7 + 256*x^8
01.11.2012
  • Вау, большое спасибо. Это действительно ответило на мой вопрос. Спасибо! :) 02.11.2012

  • 2

    Я решил задачу следующим образом, хотя я не уверен, отвечает ли она на вопрос (iv). Вывод просто сравнивает точное значение e ** x с вычисленным значением из модуля Polynomial.

    from math import factorial, exp
    from Polynomial import *
    from sys import *
    
    #Reads x and N from the command line on the form [filename.py, x-value, N-value]
    x = eval(argv[1])
    N = eval(argv[2])
    
    #Creating list of coefficients on the form [1 / i!]
    list_coeff = [1./factorial(i) for i in range(N)]
    
    print list_coeff
    
    #Creating an instance of class Polynomial
    p1 = Polynomial(list_coeff)
    
    print 'Calculated value of e**%f = %f ' %(x, p1.__call__(x))
    print 'Exact value of e**%f = %f'% (x, exp(x))
    
    """Test Execution
    Terminal > python Polynomial_exp.py 0.5 5
    [1.0, 1.0, 0.5, 0.16666666666666666, 0.041666666666666664]
    Calculated value of e**0.500000 = 1.648438 
    Exact value of e**0.500000 = 1.648721
    """
    
    04.11.2012
    Новые материалы

    Кластеризация: более глубокий взгляд
    Кластеризация — это метод обучения без учителя, в котором мы пытаемся найти группы в наборе данных на основе некоторых известных или неизвестных свойств, которые могут существовать. Независимо от..

    Как написать эффективное резюме
    Предложения по дизайну и макету, чтобы представить себя профессионально Вам не позвонили на собеседование после того, как вы несколько раз подали заявку на работу своей мечты? У вас может..

    Частный метод Python: улучшение инкапсуляции и безопасности
    Введение Python — универсальный и мощный язык программирования, известный своей простотой и удобством использования. Одной из ключевых особенностей, отличающих Python от других языков, является..

    Как я автоматизирую тестирование с помощью Jest
    Шутка для победы, когда дело касается автоматизации тестирования Одной очень важной частью разработки программного обеспечения является автоматизация тестирования, поскольку она создает..

    Работа с векторными символическими архитектурами, часть 4 (искусственный интеллект)
    Hyperseed: неконтролируемое обучение с векторными символическими архитектурами (arXiv) Автор: Евгений Осипов , Сачин Кахавала , Диланта Хапутантри , Тимал Кемпития , Дасвин Де Сильва ,..

    Понимание расстояния Вассерштейна: мощная метрика в машинном обучении
    В обширной области машинного обучения часто возникает необходимость сравнивать и измерять различия между распределениями вероятностей. Традиционные метрики расстояния, такие как евклидово..

    Обеспечение масштабируемости LLM: облачный анализ с помощью AWS Fargate и Copilot
    В динамичной области искусственного интеллекта все большее распространение получают модели больших языков (LLM). Они жизненно важны для различных приложений, таких как интеллектуальные..