[Python] 機械イプシロン(計算イプシロン)を用いた誤差許容

import sys
# 機械イプシロンの取得
machine_epsilon = sys.float_info.epsilon
print("機械イプシロン:", machine_epsilon)

機械イプシロン: 2.220446049250313e-16

def are_almost_equal(a, b):
    return abs(a - b) < sys.float_info.epsilon
# 使用例
result = are_almost_equal(0.1 + 0.2, 0.3)
print("ほぼ等しい:", result)

ほぼ等しい: True

import math
# 使用例
result = math.isclose(0.1 + 0.2, 0.3)
print("ほぼ等しい:", result)

ほぼ等しい: True

def custom_compare(a, b, epsilon=None):
    if epsilon is None:
        epsilon = sys.float_info.epsilon
    return abs(a - b) < epsilon
# 使用例
result = custom_compare(1.0, 1.0 + sys.float_info.epsilon / 2)
print("カスタム比較結果:", result)

カスタム比較結果: True

# 丸め誤差の例
result = 0.1 + 0.2
print("0.1 + 0.2 =", result)

0.1 + 0.2 = 0.30000000000000004

# 桁落ちの例
a = 1.0
b = 1.0e-10
result = a - b
print("1.0 - 1.0e-10 =", result)

1.0 - 1.0e-10 = 1.0

# 誤差の蓄積の例
total = 0.0
for i in range(1000000):
    total += 0.1
print("合計:", total)

合計: 100000.0

import sys
def are_almost_equal(a, b):
    return abs(a - b) < sys.float_info.epsilon
# 使用例
result = are_almost_equal(0.1 + 0.2, 0.3)
print("0.1 + 0.2 は 0.3 にほぼ等しい:", result)

0.1 + 0.2 は 0.3 にほぼ等しい: True

import sys
total = 0.0
for i in range(1000000):
    total += 0.1
# 誤差を許容して結果を確認
is_correct = abs(total - 100000.0) < sys.float_info.epsilon
print("合計は100000にほぼ等しい:", is_correct)

合計は100000にほぼ等しい: True

import sys
def calculate(a, b):
    return a / b
result = calculate(1.0, 3.0) + calculate(2.0, 6.0)
expected = 1.0 / 3.0 + 1.0 / 3.0
# 誤差を許容して結果を確認
is_correct = abs(result - expected) < sys.float_info.epsilon
print("計算結果は期待値にほぼ等しい:", is_correct)

計算結果は期待値にほぼ等しい: True

import sys
import math
# 例: 円周率の近似計算
def approximate_pi(n_terms):
    pi_approx = 0.0
    for k in range(n_terms):
        pi_approx += (4.0 * (-1)**k) / (2 * k + 1)
    return pi_approx
# 計算
pi_value = approximate_pi(1000000)
expected_pi = math.pi
# 誤差を許容して結果を確認
is_correct = abs(pi_value - expected_pi) < sys.float_info.epsilon
print("近似した円周率は正確な値にほぼ等しい:", is_correct)

近似した円周率は正確な値にほぼ等しい: True

import sys
def simulate_motion(initial_position, velocity, time):
    return initial_position + velocity * time
# シミュレーションの実行
position = simulate_motion(0.0, 9.81, 1.0)  # 1秒後の位置
expected_position = 9.81
# 誤差を許容して結果を確認
is_correct = abs(position - expected_position) < sys.float_info.epsilon
print("シミュレーション結果は期待値にほぼ等しい:", is_correct)

シミュレーション結果は期待値にほぼ等しい: True

import sys
def calculate_interest(principal, rate, time):
    return principal * (1 + rate) ** time
# 利息計算
interest = calculate_interest(1000, 0.05, 1)  # 1年後の利息
expected_interest = 1050.0
# 誤差を許容して結果を確認
is_correct = abs(interest - expected_interest) < sys.float_info.epsilon
print("利息計算結果は期待値にほぼ等しい:", is_correct)

利息計算結果は期待値にほぼ等しい: True

import sys
import numpy as np
# シンプルな線形回帰モデルの例
def linear_regression(X, y):
    # 最小二乗法による重みの計算
    return np.linalg.inv(X.T @ X) @ X.T @ y
# データの生成
X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
y = np.array([1, 2, 2, 3])
# モデルの学習
weights = linear_regression(X, y)
print("学習した重み:", weights)
# 誤差を許容して結果を確認
expected_weights = np.array([0.0, 1.0])
is_correct = np.all(abs(weights - expected_weights) < sys.float_info.epsilon)
print("重みは期待値にほぼ等しい:", is_correct)

学習した重み: [1.77635684e-15 1.00000000e+00]
重みは期待値にほぼ等しい: False

import sys
def render_point(x, y):
    # 点を描画する処理(仮想的な処理)
    return (x, y)
# 描画する点の位置
point_a = render_point(0.1, 0.2)
point_b = render_point(0.1 + sys.float_info.epsilon, 0.2)
# 誤差を許容して結果を確認
is_correct = abs(point_a[0] - point_b[0]) < sys.float_info.epsilon
print("描画した点はほぼ等しい:", is_correct)

描画した点はほぼ等しい: False