# 經(jīng)典精度問題示例
a = 0.1 + 0.2
b = 0.3
print(a == b)  # False
print(f"{a:.20f}")  # 0.30000000000000004441

from decimal import Decimal, getcontext

# 精確計(jì)算
a = Decimal('0.1')
b = Decimal('0.2')
c = a + b  # Decimal('0.3')

# 設(shè)置全局精度
getcontext().prec = 6  # 6位有效數(shù)字

# 精度控制計(jì)算
x = Decimal('1') / Decimal('7')  # Decimal('0.142857')

# 比較操作
print(Decimal('0.3') == a + b)  # True

from decimal import localcontext

# 局部精度設(shè)置
with localcontext() as ctx:
    ctx.prec = 10
    result = Decimal('1') / Decimal('7')  # 0.1428571429

# 恢復(fù)全局精度
print(Decimal('1') / Decimal('7'))  # 0.142857

from decimal import ROUND_HALF_UP, ROUND_DOWN, ROUND_CEILING

# 設(shè)置舍入模式
getcontext().rounding = ROUND_HALF_UP

# 計(jì)算示例
num = Decimal('1.555')
print(num.quantize(Decimal('0.00')))  # 1.56

# 不同舍入模式
getcontext().rounding = ROUND_DOWN
print(num.quantize(Decimal('0.00')))  # 1.55

getcontext().rounding = ROUND_CEILING
print(num.quantize(Decimal('0.00')))  # 1.56

from fractions import Fraction

# 精確分?jǐn)?shù)計(jì)算
a = Fraction(1, 10)  # 1/10
b = Fraction(2, 10)  # 1/5
c = a + b  # Fraction(3, 10)

# 轉(zhuǎn)換小數(shù)
float_c = float(c)  # 0.3

# 復(fù)雜計(jì)算
result = Fraction(1, 3) * Fraction(3, 4)  # 1/4

import mpmath

# 設(shè)置任意精度
mpmath.mp.dps = 50  # 50位小數(shù)精度

# 高精度計(jì)算
a = mpmath.mpf('0.1')
b = mpmath.mpf('0.2')
c = a + b  # 0.3 (精確值)

# 復(fù)雜函數(shù)計(jì)算
sin_val = mpmath.sin(mpmath.pi / 4)  # 0.70710678118654752440084436210484903928483593768847

class FixedPoint:
    """定點(diǎn)數(shù)實(shí)現(xiàn)"""
    def __init__(self, value, scale=10000):
        self.scale = scale
        self.value = int(value * scale)
    
    def __add__(self, other):
        if isinstance(other, FixedPoint):
            return FixedPoint((self.value + other.value) / self.scale, self.scale)
        return FixedPoint((self.value + int(other * self.scale)) / self.scale, self.scale)
    
    def __mul__(self, other):
        if isinstance(other, FixedPoint):
            return FixedPoint((self.value * other.value) / (self.scale * self.scale), self.scale)
        return FixedPoint((self.value * other) / self.scale, self.scale)
    
    def __str__(self):
        return f"{self.value / self.scale:.4f}"

# 使用示例
a = FixedPoint(0.1)
b = FixedPoint(0.2)
c = a + b  # 0.3000
d = a * b  # 0.0200

def compound_interest(principal, rate, periods, precision=2):
    """精確復(fù)利計(jì)算"""
    # 使用Decimal確保精度
    r = Decimal(str(rate))
    n = Decimal(str(periods))
    p = Decimal(str(principal))
    
    # 復(fù)利公式: A = P(1 + r)^n
    amount = p * (1 + r) ** n
    
    # 四舍五入到指定精度
    return amount.quantize(Decimal(f"1.{'0' * precision}"))

# 測(cè)試
print(compound_interest(1000, 0.05, 5))  # 1276.28

def loan_payment(principal, annual_rate, years, payments_per_year=12):
    """精確貸款分期計(jì)算"""
    # 轉(zhuǎn)換為Decimal
    p = Decimal(str(principal))
    r = Decimal(str(annual_rate)) / payments_per_year
    n = Decimal(str(years * payments_per_year))
    
    # 等額本息公式: P = r * PV / (1 - (1 + r)^(-n))
    numerator = r * p
    denominator = 1 - (1 + r) ** (-n)
    payment = numerator / denominator
    
    # 貨幣精度處理
    return payment.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)

# 測(cè)試
payment = loan_payment(200000, 0.045, 30)  # 1013.37

class Money:
    """精確貨幣處理類"""
    def __init__(self, amount, currency='USD'):
        self.amount = Decimal(str(amount)).quantize(Decimal('0.01'))
        self.currency = currency
    
    def __add__(self, other):
        if self.currency != other.currency:
            raise ValueError("Currency mismatch")
        return Money(self.amount + other.amount, self.currency)
    
    def __sub__(self, other):
        if self.currency != other.currency:
            raise ValueError("Currency mismatch")
        return Money(self.amount - other.amount, self.currency)
    
    def __mul__(self, multiplier):
        # 貨幣乘以標(biāo)量
        return Money(self.amount * Decimal(str(multiplier)), self.currency)
    
    def __truediv__(self, divisor):
        # 貨幣除以標(biāo)量
        return Money(self.amount / Decimal(str(divisor)), self.currency)
    
    def __str__(self):
        return f"{self.amount} {self.currency}"

# 使用示例
salary = Money(5000)
bonus = Money(1000)
total = salary + bonus  # 6000.00 USD
tax = total * 0.2  # 1200.00 USD
net = total - tax  # 4800.00 USD

class ScientificData:
    """科學(xué)實(shí)驗(yàn)數(shù)據(jù)處理"""
    def __init__(self, values, precision=4):
        self.values = [Decimal(str(v)) for v in values]
        self.precision = precision
    
    def mean(self):
        """精確計(jì)算平均值"""
        total = sum(self.values)
        return total / len(self.values)
    
    def variance(self):
        """精確計(jì)算方差"""
        mean_val = self.mean()
        squared_diffs = [(v - mean_val) ** 2 for v in self.values]
        return sum(squared_diffs) / len(self.values)
    
    def std_dev(self):
        """精確計(jì)算標(biāo)準(zhǔn)差"""
        return self.variance().sqrt()
    
    def report(self):
        """生成精確報(bào)告"""
        mean_val = self.mean().quantize(Decimal(f"1e-{self.precision}"))
        std_val = self.std_dev().quantize(Decimal(f"1e-{self.precision}"))
        return f"Mean: {mean_val}, Std Dev: {std_val}"

# 使用示例
data = [0.123456, 0.123457, 0.123458, 0.123459]
dataset = ScientificData(data, precision=6)
print(dataset.report())  # Mean: 0.123457, Std Dev: 0.000001

def precise_integral(f, a, b, n=1000):
    """精確數(shù)值積分"""
    a_dec = Decimal(str(a))
    b_dec = Decimal(str(b))
    dx = (b_dec - a_dec) / n
    
    total = Decimal('0')
    for i in range(n):
        x = a_dec + i * dx
        total += f(x) * dx
    
    return total

# 測(cè)試函數(shù)
def f(x):
    return x ** 2

# 計(jì)算∫x^2 dx從0到1
result = precise_integral(f, 0, 1)
print(result)  # 0.3333333333333333333333333333

class ToleranceStack:
    """公差疊加計(jì)算"""
    def __init__(self, nominal, tolerance):
        self.nominal = Decimal(str(nominal))
        self.tolerance = Decimal(str(tolerance))
    
    def __add__(self, other):
        nominal = self.nominal + other.nominal
        tolerance = self.tolerance + other.tolerance
        return ToleranceStack(nominal, tolerance)
    
    def __sub__(self, other):
        nominal = self.nominal - other.nominal
        tolerance = self.tolerance + other.tolerance
        return ToleranceStack(nominal, tolerance)
    
    def min_value(self):
        return self.nominal - self.tolerance
    
    def max_value(self):
        return self.nominal + self.tolerance
    
    def __str__(self):
        return f"{self.nominal} ± {self.tolerance}"

# 使用示例
part1 = ToleranceStack(10.0, 0.1)
part2 = ToleranceStack(5.0, 0.05)
assembly = part1 + part2
print(assembly)  # 15.0 ± 0.15
print(f"Min: {assembly.min_value()}, Max: {assembly.max_value()}")  # Min: 14.85, Max: 15.15

class SensorCalibrator:
    """高精度傳感器校準(zhǔn)系統(tǒng)"""
    def __init__(self, reference_values, measured_values):
        # 轉(zhuǎn)換為Decimal確保精度
        self.ref = [Decimal(str(v)) for v in reference_values]
        self.meas = [Decimal(str(v)) for v in measured_values]
        self.calibration_factor = self.calculate_factor()
    
    def calculate_factor(self):
        """計(jì)算校準(zhǔn)因子"""
        # 最小二乘法擬合
        n = len(self.ref)
        sum_xy = sum(r * m for r, m in zip(self.ref, self.meas))
        sum_x = sum(self.ref)
        sum_y = sum(self.meas)
        sum_x2 = sum(r ** 2 for r in self.ref)
        
        numerator = n * sum_xy - sum_x * sum_y
        denominator = n * sum_x2 - sum_x ** 2
        return numerator / denominator
    
    def calibrate(self, raw_value):
        """校準(zhǔn)讀數(shù)"""
        raw_dec = Decimal(str(raw_value))
        return float(raw_dec * self.calibration_factor)

# 使用示例
reference = [1.0, 2.0, 3.0, 4.0, 5.0]
measured = [1.01, 2.03, 3.02, 4.06, 5.04]
calibrator = SensorCalibrator(reference, measured)

raw_reading = 2.5
calibrated = calibrator.calibrate(raw_reading)
print(f"Raw: {raw_reading}, Calibrated: {calibrated:.4f}")  # Raw: 2.5, Calibrated: 2.5000

# 精度與性能測(cè)試
import timeit

def test_float():
    return 0.1 + 0.2

def test_decimal():
    return Decimal('0.1') + Decimal('0.2')

def test_fraction():
    return Fraction(1, 10) + Fraction(2, 10)

# 性能測(cè)試
float_time = timeit.timeit(test_float, number=1000000)
decimal_time = timeit.timeit(test_decimal, number=1000000)
fraction_time = timeit.timeit(test_fraction, number=1000000)

print(f"Float: {float_time:.6f}秒")
print(f"Decimal: {decimal_time:.6f}秒")
print(f"Fraction: {fraction_time:.6f}秒")

# 金融計(jì)算
from decimal import Decimal
price = Decimal('99.99')

# 科學(xué)分?jǐn)?shù)
from fractions import Fraction
ratio = Fraction(1, 3)

# 工程計(jì)算
class FixedPoint: ...

# 錯(cuò)誤做法
a = Decimal(0.1)  # 浮點(diǎn)數(shù)轉(zhuǎn)換引入誤差

# 正確做法
a = Decimal('0.1')  # 字符串初始化

# 全局精度設(shè)置
getcontext().prec = 28  # 28位有效數(shù)字

# 局部精度控制
with localcontext() as ctx:
    ctx.prec = 50
    # 高精度計(jì)算

# 金融計(jì)算使用ROUND_HALF_UP
getcontext().rounding = ROUND_HALF_UP

# 科學(xué)計(jì)算使用ROUND_HALF_EVEN
getcontext().rounding = ROUND_HALF_EVEN

# 批量處理減少對(duì)象創(chuàng)建
values = [Decimal(str(x)) for x in raw_data]
results = [x * factor for x in values]

# 避免不必要的精度
getcontext().prec = 6  # 合理精度

try:
    result = a / b
except DivisionByZero:
    handle_error()
except InvalidOperation:
    handle_invalid()

class TestPreciseCalculations(unittest.TestCase):
    def test_currency_addition(self):
        a = Money(10.50)
        b = Money(20.25)
        self.assertEqual(a + b, Money(30.75))
    
    def test_compound_interest(self):
        result = compound_interest(1000, 0.05, 5)
        self.assertEqual(result, Decimal('1276.28'))