Pythonで学ぶマクローリン展開の基礎と応用10選

import numpy as np

# 配列の作成
x = np.array([1, 2, 3, 4, 5])

# 数学関数の使用
y = np.sin(x)

print(y)

from scipy import special

# ベッセル関数の計算
x = 1.0
result = special.j0(x)

print(f"J0({x}) = {result}")

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)

plt.plot(x, y)
plt.title("Sine Function")
plt.xlabel("x")
plt.ylabel("sin(x)")
plt.show()

from sympy import symbols, diff, sin

x = symbols('x')
f = sin(x)
df = diff(f, x)

print(f"d/dx(sin(x)) = {df}")

import numpy as np
import matplotlib.pyplot as plt

def sin_maclaurin(x, terms):
    result = 0
    for n in range(terms):
        result += (-1)**n * x**(2*n+1) / np.math.factorial(2*n+1)
    return result

x = np.linspace(-2*np.pi, 2*np.pi, 200)
y_true = np.sin(x)

plt.figure(figsize=(12, 8))
plt.plot(x, y_true, label='True sin(x)')

for terms in [1, 3, 5, 7]:
    y_approx = sin_maclaurin(x, terms)
    plt.plot(x, y_approx, label=f'Maclaurin ({terms} terms)')

plt.legend()
plt.title('Sin Function: True vs Maclaurin Approximations')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def cos_maclaurin(x, terms):
    result = 0
    for n in range(terms):
        result += (-1)**n * x**(2*n) / np.math.factorial(2*n)
    return result

x = np.linspace(-2*np.pi, 2*np.pi, 200)
y_true = np.cos(x)

plt.figure(figsize=(12, 8))
plt.plot(x, y_true, label='True cos(x)')

for terms in [1, 2, 4, 6]:
    y_approx = cos_maclaurin(x, terms)
    plt.plot(x, y_approx, label=f'Maclaurin ({terms} terms)')

plt.legend()
plt.title('Cos Function: True vs Maclaurin Approximations')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def tan_maclaurin(x, terms):
    bernoulli_numbers = [1, -1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0, 5/66, 0, -691/2730, 0, 7/6]
    result = 0
    for n in range(terms):
        result += (2**(2*n) * (2**(2*n) - 1) * bernoulli_numbers[n] * x**(2*n-1)) / np.math.factorial(2*n)
    return result

x = np.linspace(-np.pi/2 + 0.1, np.pi/2 - 0.1, 200)  # avoid singularities
y_true = np.tan(x)

plt.figure(figsize=(12, 8))
plt.plot(x, y_true, label='True tan(x)')

for terms in [2, 4, 6, 8]:
    y_approx = tan_maclaurin(x, terms)
    plt.plot(x, y_approx, label=f'Maclaurin ({terms} terms)')

plt.legend()
plt.title('Tan Function: True vs Maclaurin Approximations')
plt.xlabel('x')
plt.ylabel('y')
plt.ylim(-10, 10)  # limit y-axis for better visibility
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def exp_maclaurin(x, terms):
    result = 0
    for n in range(terms):
        result += x**n / np.math.factorial(n)
    return result

x = np.linspace(-2, 2, 200)
y_true = np.exp(x)

plt.figure(figsize=(12, 8))
plt.plot(x, y_true, label='True exp(x)')

for terms in [1, 2, 4, 8]:
    y_approx = exp_maclaurin(x, terms)
    plt.plot(x, y_approx, label=f'Maclaurin ({terms} terms)')

plt.legend()
plt.title('Exp Function: True vs Maclaurin Approximations')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()

# 誤差分析
x_test = 1.0
terms_range = range(1, 21)
errors = [abs(np.exp(x_test) - exp_maclaurin(x_test, terms)) for terms in terms_range]

plt.figure(figsize=(10, 6))
plt.semilogy(terms_range, errors, 'bo-')
plt.title(f'Error Analysis for exp({x_test})')
plt.xlabel('Number of terms')
plt.ylabel('Absolute error')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def euler_formula(x):
    return np.cos(x) + 1j * np.sin(x)

x = np.linspace(0, 2*np.pi, 100)
y = euler_formula(x)

plt.figure(figsize=(10, 10))
plt.plot(y.real, y.imag)
plt.title("Euler's Formula: e^(ix) = cos(x) + i*sin(x)")
plt.xlabel("Real part")
plt.ylabel("Imaginary part")
plt.grid(True)
plt.axis('equal')
plt.show()

# マクローリン展開との比較
def complex_exp_maclaurin(x, terms):
    result = 0
    for n in range(terms):
        result += (1j*x)**n / np.math.factorial(n)
    return result

y_approx = complex_exp_maclaurin(x, 10)

plt.figure(figsize=(10, 10))
plt.plot(y.real, y.imag, label='True e^(ix)')
plt.plot(y_approx.real, y_approx.imag, label='Maclaurin (10 terms)')
plt.title("Euler's Formula: True vs Maclaurin Approximation")
plt.xlabel("Real part")
plt.ylabel("Imaginary part")
plt.legend()
plt.grid(True)
plt.axis('equal')
plt.show()

e^(ix) = 1 + ix + (ix)^2/2! + (ix)^3/3! + …
= 1 + ix - x^2/2! - ix^3/3! + x^4/4! + …
= (1 - x^2/2! + x^4/4! - …) + i(x - x^3/3! + x^5/5! - …)
= cos(x) + i*sin(x)

import numpy as np
import matplotlib.pyplot as plt

def sin_maclaurin_3rd(x):
    return x - x**3 / 6

def sin_maclaurin_5th(x):
    return x - x**3 / 6 + x**5 / 120

x = np.linspace(-np.pi, np.pi, 200)
y_true = np.sin(x)
y_3rd = sin_maclaurin_3rd(x)
y_5th = sin_maclaurin_5th(x)

plt.figure(figsize=(12, 8))
plt.plot(x, y_true, label='True sin(x)')
plt.plot(x, y_3rd, label='3rd order approximation')
plt.plot(x, y_5th, label='5th order approximation')
plt.legend()
plt.title('Sin Function: True vs 3rd and 5th Order Approximations')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()

# 誤差分析
error_3rd = np.abs(y_true - y_3rd)
error_5th = np.abs(y_true - y_5th)

plt.figure(figsize=(12, 8))
plt.semilogy(x, error_3rd, label='3rd order error')
plt.semilogy(x, error_5th, label='5th order error')
plt.legend()
plt.title('Error Analysis: 3rd vs 5th Order Approximations')
plt.xlabel('x')
plt.ylabel('Absolute error (log scale)')
plt.grid(True)
plt.show()

import numpy as np
import time

# メモ化を使用した階乗計算
factorial_memo = {}
def factorial(n):
    if n in factorial_memo:
        return factorial_memo[n]
    if n == 0 or n == 1:
        return 1
    result = n * factorial(n - 1)
    factorial_memo[n] = result
    return result

def exp_maclaurin_optimized(x, terms):
    result = 0
    for n in range(terms):
        result += x**n / factorial(n)
    return result

def exp_maclaurin_naive(x, terms):
    result = 0
    for n in range(terms):
        result += x**n / np.math.factorial(n)
    return result

# パフォーマンス比較
x = 2.0
terms = 100

start_time = time.time()
result_optimized = exp_maclaurin_optimized(x, terms)
time_optimized = time.time() - start_time

start_time = time.time()
result_naive = exp_maclaurin_naive(x, terms)
time_naive = time.time() - start_time

print(f"Optimized result: {result_optimized}")
print(f"Optimized time: {time_optimized:.6f} seconds")
print(f"Naive result: {result_naive}")
print(f"Naive time: {time_naive:.6f} seconds")
print(f"Speedup: {time_naive / time_optimized:.2f}x")

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_maclaurin(x, terms):
    result = 0.5
    for n in range(1, terms):
        coefficient = (-1)**(n+1) / (2**n * np.math.factorial(n))
        result += coefficient * x**n
    return result

x = np.linspace(-5, 5, 200)
y_true = sigmoid(x)

plt.figure(figsize=(12, 8))
plt.plot(x, y_true, label='True sigmoid')

for terms in [1, 3, 5, 7]:
    y_approx = sigmoid_maclaurin(x, terms)
    plt.plot(x, y_approx, label=f'Maclaurin ({terms} terms)')

plt.legend()
plt.title('Sigmoid Function: True vs Maclaurin Approximations')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()

# 誤差分析
plt.figure(figsize=(12, 8))
for terms in [1, 3, 5, 7]:
    y_approx = sigmoid_maclaurin(x, terms)
    error = np.abs(y_true - y_approx)
    plt.semilogy(x, error, label=f'Error ({terms} terms)')

plt.legend()
plt.title('Error Analysis: Sigmoid Approximations')
plt.xlabel('x')
plt.ylabel('Absolute error (log scale)')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def f(x):
    return np.exp(x) * np.sin(x)

def taylor_expansion(x, a, terms):
    result = 0
    for n in range(terms):
        derivative = sum([(-1)**(k) * (n-k) * a**(n-k) / np.math.factorial(k) for k in range(n+1)])
        result += derivative * (x - a)**n / np.math.factorial(n)
    return result

x = np.linspace(-2*np.pi, 2*np.pi, 200)
y_true = f(x)

plt.figure(figsize=(12, 8))
plt.plot(x, y_true, label='True f(x)')

# マクローリン展開（a=0）
y_maclaurin = taylor_expansion(x, 0, 7)
plt.plot(x, y_maclaurin, label='Maclaurin (7 terms)')

# 他の点でのテイラー展開
for a in [np.pi/2, np.pi, 3*np.pi/2]:
    y_taylor = taylor_expansion(x, a, 7)
    plt.plot(x, y_taylor, label=f'Taylor (a={a:.2f}, 7 terms)')

plt.legend()
plt.title('f(x) = e^x * sin(x): True vs Taylor/Maclaurin Approximations')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def geometric_series(x, n):
    return sum(x**k for k in range(n))

def harmonic_series(n):
    return sum(1/k for k in range(1, n+1))

def alternating_harmonic_series(n):
    return sum((-1)**(k+1)/k for k in range(1, n+1))

n_values = np.arange(1, 101)

plt.figure(figsize=(15, 5))

# 等比級数
plt.subplot(131)
for x in [0.5, 0.9, 1.1]:
    y = [geometric_series(x, n) for n in n_values]
    plt.plot(n_values, y, label=f'x={x}')
plt.title('Geometric Series')
plt.legend()

# 調和級数
plt.subplot(132)
y = [harmonic_series(n) for n in n_values]
plt.plot(n_values, y)
plt.title('Harmonic Series')

# 交代調和級数
plt.subplot(133)
y = [alternating_harmonic_series(n) for n in n_values]
plt.plot(n_values, y)
plt.title('Alternating Harmonic Series')

plt.tight_layout()
plt.show()

import numpy as np

def exp_maclaurin_adaptive(x, target_error):
    result = 0
    term = 1
    n = 0
    while abs(term) > target_error:
        result += term
        n += 1
        term = x**n / np.math.factorial(n)
    return result, n

x = 1.0
target_error = 1e-10

result, terms_used = exp_maclaurin_adaptive(x, target_error)
true_value = np.exp(x)

print(f"Approximation: {result}")
print(f"True value: {true_value}")
print(f"Absolute error: {abs(result - true_value)}")
print(f"Number of terms used: {terms_used}")

import numpy as np
import matplotlib.pyplot as plt
from scipy.special import factorial

def maclaurin_exp(x, n):
    return sum(x**k / factorial(k) for k in range(n))

def pade_exp(x, m, n):
    def coeff(k):
        return factorial(m + n - k) * factorial(m) // (factorial(m + n) * factorial(k) * factorial(m - k))
    num = sum(coeff(k) * x**k for k in range(m + 1))
    den = sum((-1)**k * coeff(k) * x**k for k in range(n + 1))
    return num / den

x = np.linspace(-5, 5, 1000)
true_exp = np.exp(x)

plt.figure(figsize=(12, 8))
plt.plot(x, true_exp, label='True exp(x)')
plt.plot(x, maclaurin_exp(x, 5), label='Maclaurin (5 terms)')
plt.plot(x, pade_exp(x, 2, 2), label='Pade [2/2]')

plt.legend()
plt.title('Comparison of Maclaurin and Pade Approximations for exp(x)')
plt.xlabel('x')
plt.ylabel('y')
plt.ylim(-10, 150)
plt.grid(True)
plt.show()