Pythonで近似値を求める方法と活用例10選

# 円周率の近似値を計算する
import math

# 正確な円周率（math.piは組み込みの定数）
exact_pi = math.pi

# 小数点以下3桁に丸める
approx_pi = round(exact_pi, 3)

print(f"正確な円周率: {exact_pi}")
print(f"近似した円周率: {approx_pi}")
print(f"誤差: {abs(exact_pi - approx_pi)}")

正確な円周率: 3.141592653589793
近似した円周率: 3.142
誤差: 0.0004073464102069406

import numpy as np

def find_nearest(array, value):
    array = np.asarray(array)
    idx = (np.abs(array - value)).argmin()
    return array[idx]

# テストデータ
data = [1.1, 1.3, 2.7, 3.5, 4.1, 5.0]
target = 3.8

nearest = find_nearest(data, target)
print(f"{target}に最も近い値は {nearest} です。")

import numpy as np
import matplotlib.pyplot as plt

def euler_method(f, y0, x0, x1, h):
    x = np.arange(x0, x1 + h, h)
    y = np.zeros(len(x))
    y[0] = y0
    for i in range(1, len(x)):
        y[i] = y[i-1] + h * f(x[i-1], y[i-1])
    return x, y

# 微分方程式 dy/dx = x
def f(x, y):
    return x

x, y = euler_method(f, 1, 0, 2, 0.1)

plt.plot(x, y, 'b-', label='Numerical')
plt.plot(x, 1 + x**2/2, 'r--', label='Analytical')
plt.legend()
plt.xlabel('x')
plt.ylabel('y')
plt.title('Euler Method: dy/dx = x, y(0) = 1')
plt.show()

def newton_method(f, df, x0, epsilon, max_iter):
    x = x0
    for _ in range(max_iter):
        fx = f(x)
        if abs(fx) < epsilon:
            return x
        dfx = df(x)
        if dfx == 0:
            return None  # 導関数がゼロになる場合は収束しない
        x = x - fx / dfx
    return None  # 最大反復回数に達しても収束しない場合

# f(x) = x^2 - 2 の根を求める
f = lambda x: x**2 - 2
df = lambda x: 2*x  # fの導関数

root = newton_method(f, df, 1.0, 1e-6, 100)
print(f"√2の近似値: {root}")
print(f"実際の√2: {2**0.5}")
print(f"誤差: {abs(root - 2**0.5)}")

√2の近似値: 1.4142135623730951
実際の√2: 1.4142135623730951
誤差: 2.220446049250313e-16

import math

def bisection_method(f, a, b, tol):
    if f(a) * f(b) >= 0:
        print("二分法の前提条件を満たしていません。")
        return None

    while (b - a) / 2 > tol:
        c = (a + b) / 2
        if f(c) == 0:
            return c
        elif f(a) * f(c) < 0:
            b = c
        else:
            a = c

    return (a + b) / 2

# f(x) = cos(x) - x の根を求める
f = lambda x: math.cos(x) - x

root = bisection_method(f, 0, 1, 1e-6)
print(f"cos(x) - x = 0 の解の近似値: {root}")
print(f"f({root}) = {f(root)}")

cos(x) - x = 0 の解の近似値: 0.7390851332015305
f(0.7390851332015305) = -2.3147478754893852e-07

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# サンプルデータの作成
dates = pd.date_range(start='2023-01-01', end='2023-12-31', freq='D')
prices = np.random.randint(100, 200, size=len(dates))
df = pd.DataFrame({'Date': dates, 'Price': prices})
df.set_index('Date', inplace=True)

# 移動平均の計算
df['MA7'] = df['Price'].rolling(window=7).mean()
df['MA30'] = df['Price'].rolling(window=30).mean()

# グラフの描画
plt.figure(figsize=(12, 6))
plt.plot(df.index, df['Price'], label='実際の価格')
plt.plot(df.index, df['MA7'], label='7日移動平均')
plt.plot(df.index, df['MA30'], label='30日移動平均')
plt.legend()
plt.title('株価と移動平均')
plt.xlabel('日付')
plt.ylabel('価格')
plt.show()

print(df.head(10))

import numpy as np
import matplotlib.pyplot as plt

def taylor_sin(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(-np.pi, np.pi, 100)
y_exact = np.sin(x)

plt.figure(figsize=(12, 8))
for terms in [1, 3, 5, 7]:
    y_approx = taylor_sin(x, terms)
    plt.plot(x, y_approx, label=f'項数 {terms}')

plt.plot(x, y_exact, 'k--', label='正確な sin(x)')
plt.legend()
plt.title('テイラー級数による sin(x) の近似')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()

# 誤差の計算
x_test = np.pi/4
print(f"x = π/4 での比較:")
print(f"正確な値: {np.sin(x_test)}")
print(f"7項での近似値: {taylor_sin(x_test, 7)}")
print(f"誤差: {abs(np.sin(x_test) - taylor_sin(x_test, 7))}")

import numpy as np
import pandas as pd
import time

# 大規模データの生成
n = 1_000_000
dates = pd.date_range(start='2000-01-01', periods=n, freq='T')
values = np.cumsum(np.random.randn(n)) + 1000  # ランダムウォーク

df = pd.DataFrame({'value': values}, index=dates)

# 移動平均の計算（時間計測付き）
start_time = time.time()
df['MA_100'] = df['value'].rolling(window=100).mean()
df['MA_1000'] = df['value'].rolling(window=1000).mean()
end_time = time.time()

print(f"データ数: {n}")
print(f"計算時間: {end_time - start_time:.2f} 秒")
print("\nデータの先頭:")
print(df.head())
print("\nデータの末尾:")
print(df.tail())

from decimal import Decimal, getcontext
import time

def calculate_pi(precision):
    getcontext().prec = precision

    pi = Decimal(0)
    k = 0
    x = Decimal(1)
    while k < precision:
        pi += (x / (10 * k + 1) - x / (10 * k + 3) - x / (10 * k + 5) - x / (10 * k + 7) + x / (10 * k + 9)) / 64 ** k
        k += 1
        x = x / Decimal(-64)

    return pi * Decimal(1)

start_time = time.time()
pi = calculate_pi(1000)
end_time = time.time()

print(f"計算された π の値 (1000桁):")
print(pi)
print(f"\n計算時間: {end_time - start_time:.2f} 秒")

import numpy as np
from scipy import optimize
import matplotlib.pyplot as plt

def f(x):
    return x**3 - x**2 + 2

# 方程式の解を求める
solution = optimize.root(f, x0=0)

print("方程式 x^3 - x^2 + 2 = 0 の解:")
print(f"x = {solution.x[0]}")
print(f"f(x) = {f(solution.x[0])}")

# グラフの描画
x = np.linspace(-3, 3, 100)
y = f(x)

plt.figure(figsize=(10, 6))
plt.plot(x, y, label='f(x) = x^3 - x^2 + 2')
plt.axhline(y=0, color='r', linestyle='--', label='y = 0')
plt.plot(solution.x[0], f(solution.x[0]), 'ro', label='解')
plt.legend()
plt.title('非線形方程式とその解')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()

import numpy as np
from scipy import optimize
import matplotlib.pyplot as plt

def f(x):
    return (x - 2) ** 2 + 1

# 最小値を求める
result = optimize.minimize_scalar(f)

print("関数 f(x) = (x - 2)^2 + 1 の最小値:")
print(f"x = {result.x}")
print(f"f(x) = {result.fun}")

# グラフの描画
x = np.linspace(-1, 5, 100)
y = f(x)

plt.figure(figsize=(10, 6))
plt.plot(x, y, label='f(x) = (x - 2)^2 + 1')
plt.plot(result.x, result.fun, 'ro', label='最小値')
plt.legend()
plt.title('関数と最小値')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from scipy import interpolate

# データ点の生成
x = np.linspace(0, 10, 10)
y = np.sin(x) + np.random.normal(0, 0.1, x.shape)

# 補間手法
x_new = np.linspace(0, 10, 100)
f_linear = interpolate.interp1d(x, y, kind='linear')
f_cubic = interpolate.interp1d(x, y, kind='cubic')
f_nearest = interpolate.interp1d(x, y, kind='nearest')

plt.figure(figsize=(12, 8))
plt.plot(x, y, 'o', label='データ点')
plt.plot(x_new, f_linear(x_new), label='線形補間')
plt.plot(x_new, f_cubic(x_new), label='3次スプライン補間')
plt.plot(x_new, f_nearest(x_new), label='最近傍補間')
plt.legend()
plt.title('異なる補間手法の比較')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

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

x = np.linspace(-2, 2, 100)
y_exact = np.exp(x)

plt.figure(figsize=(12, 10))

# 近似値の計算と描画
for terms in [1, 2, 3, 5, 10]:
    y_approx = taylor_exp(x, terms)
    plt.subplot(2, 1, 1)
    plt.plot(x, y_approx, label=f'項数 {terms}')

    # 誤差の計算と描画
    error = np.abs(y_exact - y_approx)
    plt.subplot(2, 1, 2)
    plt.semilogy(x, error, label=f'項数 {terms}')

# グラフの設定
plt.subplot(2, 1, 1)
plt.plot(x, y_exact, 'k--', label='正確な exp(x)')
plt.legend()
plt.title('テイラー級数による exp(x) の近似')
plt.ylabel('y')

plt.subplot(2, 1, 2)
plt.legend()
plt.title('近似の誤差（対数スケール）')
plt.xlabel('x')
plt.ylabel('誤差')

plt.tight_layout()
plt.show()

# 特定の点での誤差評価
x_test = 1.0
print(f"x = {x_test} での比較:")
for terms in [1, 2, 3, 5, 10]:
    approx = taylor_exp(x_test, terms)
    error = abs(np.exp(x_test) - approx)
    print(f"項数 {terms}: 近似値 = {approx:.6f}, 誤差 = {error:.6e}")

def piecewise_taylor_exp(x, terms, intervals):
    result = np.zeros_like(x)
    interval_size = 4 / intervals  # 範囲を-2から2とする
    for i in range(intervals):
        start = -2 + i * interval_size
        end = start + interval_size
        mask = (x >= start) & (x < end)
        x_shifted = x[mask] - (start + end) / 2  # 区間の中心を0とする
        result[mask] = taylor_exp(x_shifted, terms) * np.exp((start + end) / 2)
    return result

intervals = 10
y_piecewise = piecewise_taylor_exp(x, terms=5, intervals=intervals)

plt.figure(figsize=(12, 6))
plt.plot(x, y_exact, 'k--', label='正確な exp(x)')
plt.plot(x, y_approx, label='通常の近似 (項数 5)')
plt.plot(x, y_piecewise, label=f'区間分割近似 (項数 5, 区間数 {intervals})')
plt.legend()
plt.title('区間分割による近似精度の改善')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)
plt.show()

# 誤差の比較
error_normal = np.max(np.abs(y_exact - y_approx))
error_piecewise = np.max(np.abs(y_exact - y_piecewise))
print(f"通常の近似の最大誤差: {error_normal:.6e}")
print(f"区間分割近似の最大誤差: {error_piecewise:.6e}")

import sys

print(sys.float_info)

from decimal import Decimal, getcontext

# 精度を28桁に設定
getcontext().prec = 28

a = Decimal('0.1')
b = Decimal('0.2')
c = a + b

print(f"0.1 + 0.2 = {c}")
print(f"0.1 + 0.2 == 0.3: {c == Decimal('0.3')}")

import math

# オーバーフローの例
try:
    result = math.exp(1000)
    print(result)
except OverflowError as e:
    print(f"オーバーフローが発生しました: {e}")

# アンダーフローの例
small_number = 1e-324
print(f"非常に小さな数: {small_number}")
print(f"0との比較: {small_number == 0}")

import matplotlib.pyplot as plt

def newton_sqrt(x, max_iter=100, tol=1e-6):
    guess = x / 2  # 初期推定値
    iterations = []
    for i in range(max_iter):
        next_guess = (guess + x / guess) / 2
        iterations.append(next_guess)
        if abs(next_guess - guess) < tol:
            return next_guess, iterations
        guess = next_guess
    return guess, iterations

# 正常に収束するケース
result, iterations = newton_sqrt(16)
print(f"√16の近似値: {result}")

# 収束しないケース（初期値が不適切）
result, iterations = newton_sqrt(0)
print(f"√0の計算結果: {result}")

# 結果の可視化
plt.figure(figsize=(10, 6))
plt.plot(range(len(iterations)), iterations, 'b.-')
plt.title('ニュートン法による平方根計算の収束性')
plt.xlabel('反復回数')
plt.ylabel('推定値')
plt.grid(True)
plt.show()

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# サンプルデータの生成
np.random.seed(0)
dates = pd.date_range(start='2023-01-01', end='2023-12-31', freq='D')
temperatures = 20 + 10 * np.sin(np.arange(len(dates)) * 2 * np.pi / 365) + np.random.normal(0, 2, len(dates))
df = pd.DataFrame({'date': dates, 'temperature': temperatures})

# 特徴量の作成
df['day_of_year'] = df['date'].dt.dayofyear

# データの分割
X = df[['day_of_year']]
y = df['temperature']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# モデルの学習
model = LinearRegression()
model.fit(X_train, y_train)

# 予測
y_pred = model.predict(X_test)

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.scatter(df['date'], df['temperature'], label='実際の気温', alpha=0.5)
plt.scatter(df.loc[X_test.index, 'date'], y_pred, color='red', label='予測気温')
plt.title('気温予測モデル')
plt.xlabel('日付')
plt.ylabel('気温 (°C)')
plt.legend()
plt.grid(True)
plt.show()

# モデルの性能評価
from sklearn.metrics import mean_squared_error, r2_score
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
print(f"平均二乗誤差: {mse:.2f}")
print(f"決定係数 R²: {r2:.2f}")

import numpy as np
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt

# Yahoo Financeから株価データを取得
ticker = "AAPL"  # Apple Inc.の株価を例として使用
data = yf.download(ticker, start="2022-01-01", end="2023-12-31")

# 移動平均の計算
data['MA50'] = data['Close'].rolling(window=50).mean()
data['MA200'] = data['Close'].rolling(window=200).mean()

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.plot(data.index, data['Close'], label='終値')
plt.plot(data.index, data['MA50'], label='50日移動平均')
plt.plot(data.index, data['MA200'], label='200日移動平均')
plt.title(f'{ticker}の株価トレンド分析')
plt.xlabel('日付')
plt.ylabel('株価 (USD)')
plt.legend()
plt.grid(True)
plt.show()

# 最新の移動平均値を表示
latest_date = data.index[-1]
print(f"最新日付: {latest_date.date()}")
print(f"終値: ${data['Close'].iloc[-1]:.2f}")
print(f"50日移動平均: ${data['MA50'].iloc[-1]:.2f}")
print(f"200日移動平均: ${data['MA200'].iloc[-1]:.2f}")

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint

def pendulum_ode(y, t, L, g):
    theta, omega = y
    dydt = [omega, -g/L * np.sin(theta)]
    return dydt

# パラメータ設定
L = 1.0  # 振り子の長さ (m)
g = 9.8  # 重力加速度 (m/s^2)
theta0 = np.pi/4  # 初期角度 (rad)
omega0 = 0.0  # 初期角速度 (rad/s)

# 時間範囲
t = np.linspace(0, 10, 1000)

# ODEの解法
sol = odeint(pendulum_ode, [theta0, omega0], t, args=(L, g))
theta = sol[:, 0]

# 結果の可視化
plt.figure(figsize=(12, 6))
plt.plot(t, theta)
plt.title('単振り子のシミュレーション')
plt.xlabel('時間 (s)')
plt.ylabel('角度 (rad)')
plt.grid(True)
plt.show()

# アニメーションの作成
from matplotlib.animation import FuncAnimation

fig, ax = plt.subplots()
ax.set_xlim(-L, L)
ax.set_ylim(-L, L)
line, = ax.plot([], [], 'o-', lw=2)
time_text = ax.text(0.02, 0.95, '', transform=ax.transAxes)

def init():
    line.set_data([], [])
    time_text.set_text('')
    return line, time_text

def animate(i):
    x = L * np.sin(theta[i])
    y = -L * np.cos(theta[i])
    line.set_data([0, x], [0, y])
    time_text.set_text(f'時間 = {t[i]:.2f} s')
    return line, time_text

anim = FuncAnimation(fig, animate, init_func=init, frames=len(t), interval=20, blit=True)
plt.show()

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report
import numpy as np
import matplotlib.pyplot as plt

# データの読み込みと分割
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.3, random_state=42)

# パラメータグリッドの定義
param_grid = {
    'C': [0.1, 1, 10, 100],
    'gamma': [0.01, 0.1, 1, 10],
    'kernel': ['rbf', 'poly']
}

# グリッドサーチの実行
svm = SVC()
grid_search = GridSearchCV(svm, param_grid, cv=5, scoring='accuracy')
grid_search.fit(X_train, y_train)

# 最適パラメータと最高スコアの表示
print("最適パラメータ:", grid_search.best_params_)
print("最高スコア:", grid_search.best_score_)

# テストデータでの評価
best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test)
print("\nテストデータでの精度:", accuracy_score(y_test, y_pred))
print("\n分類レポート:\n", classification_report(y_test, y_pred))

# パラメータの重要度可視化
results = grid_search.cv_results_
C_values = param_grid['C']
gamma_values = param_grid['gamma']

scores = np.array(results['mean_test_score']).reshape(len(C_values), len(gamma_values))

plt.figure(figsize=(10, 8))
plt.imshow(scores, interpolation='nearest', cmap=plt.cm.hot)
plt.xlabel('gamma')
plt.ylabel('C')
plt.colorbar()
plt.xticks(np.arange(len(gamma_values)), gamma_values)
plt.yticks(np.arange(len(C_values)), C_values)
plt.title("グリッドサーチのスコアマップ")
plt.show()