def bankers_round(value, ndigits=0):
    """實(shí)現(xiàn)銀行家舍入法"""
    # 處理整數(shù)
    if ndigits == 0:
        # 獲取小數(shù)部分
        fractional = value - math.floor(value)
        
        # 整數(shù)部分
        integer_part = math.floor(value)
        
        # 判斷中間值
        if fractional == 0.5:
            # 五成雙：偶數(shù)向下，奇數(shù)向上
            return integer_part if integer_part % 2 == 0 else integer_part + 1
        else:
            return round(value)
    else:
        # 處理小數(shù)位
        multiplier = 10 ** ndigits
        scaled = value * multiplier
        return bankers_round(scaled) / multiplier

# 測(cè)試
print(bankers_round(2.5))  # 2
print(bankers_round(3.5))  # 4
print(bankers_round(4.5))  # 4
print(bankers_round(2.535, 2))  # 2.54

def round_to_multiple(value, base, direction='nearest'):
    """向指定基數(shù)的倍數(shù)取整"""
    if direction == 'nearest':
        return base * round(value / base)
    elif direction == 'down':
        return base * math.floor(value / base)
    elif direction == 'up':
        return base * math.ceil(value / base)
    elif direction == 'toward_zero':
        return base * math.trunc(value / base)
    else:
        raise ValueError("Invalid direction")

# 測(cè)試
print(round_to_multiple(17, 5))  # 15 (nearest)
print(round_to_multiple(17, 5, 'up'))  # 20
print(round_to_multiple(17, 5, 'down'))  # 15
print(round_to_multiple(-17, 5, 'toward_zero'))  # -15

from fractions import Fraction

def round_to_fraction(value, denominator):
    """取整到最接近的分?jǐn)?shù)"""
    fraction = Fraction(value).limit_denominator(denominator)
    return float(fraction)

# 測(cè)試
print(round_to_fraction(3.14159, 100))  # 3.14 (157/50)
print(round_to_fraction(1.333, 4))  # 1.25 (5/4)

import numpy as np

# 創(chuàng)建數(shù)組
arr = np.array([1.23, 4.56, 7.89, 10.12])

# 四舍五入到整數(shù)
rounded = np.round(arr)  # [1., 5., 8., 10.]

# 向下取整
floored = np.floor(arr)  # [1., 4., 7., 10.]

# 向上取整
ceiled = np.ceil(arr)  # [2., 5., 8., 11.]

# 指定小數(shù)位
rounded_dec = np.round(arr, 1)  # [1.2, 4.6, 7.9, 10.1]

# 向5的倍數(shù)取整
rounded_5 = np.round(arr / 5) * 5  # [0., 5., 10., 10.]

from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

def currency_round(value, currency='USD'):
    """貨幣計(jì)算取整"""
    # 不同貨幣的小數(shù)位
    decimals = {
        'USD': 2,
        'JPY': 0,
        'BTC': 8,
        'KRW': 0
    }
    
    # 獲取小數(shù)位
    places = decimals.get(currency, 2)
    
    # 使用Decimal精確計(jì)算
    d = Decimal(str(value))
    return float(d.quantize(Decimal(f'1e-{places}'), rounding=ROUND_HALF_UP))

# 測(cè)試
print(currency_round(123.456, 'USD'))  # 123.46
print(currency_round(123.456, 'JPY'))  # 123.0
print(currency_round(0.12345678, 'BTC'))  # 0.12345678

def tax_calculation(income, tax_rate=0.2, brackets=None):
    """稅 務(wù)計(jì)算（考慮稅級(jí)）"""
    # 默認(rèn)稅級(jí)
    if brackets is None:
        brackets = [
            (10000, 0.1),
            (50000, 0.2),
            (100000, 0.3)
        ]
    
    tax = 0
    prev_bracket = 0
    
    for bracket, rate in brackets:
        if income <= prev_bracket:
            break
        
        # 計(jì)算當(dāng)前稅級(jí)應(yīng)納稅部分
        bracket_amount = min(income, bracket) - prev_bracket
        # 稅 務(wù)取整規(guī)則：向上取整到整數(shù)
        bracket_tax = math.ceil(bracket_amount * rate)
        tax += bracket_tax
        
        prev_bracket = bracket
    
    # 處理超過(guò)最高稅級(jí)部分
    if income > prev_bracket:
        excess = income - prev_bracket
        # 最高稅率
        max_rate = brackets[-1][1]
        tax += math.ceil(excess * max_rate)
    
    return tax

# 測(cè)試
income = 75000
tax = tax_calculation(income)
print(f"收入${income}的稅額: ${tax}")  # 收入$75000的稅額: $12500

def bin_data(data, bin_size, method='floor'):
    """數(shù)據(jù)分箱處理"""
    if method == 'floor':
        return [math.floor(x / bin_size) * bin_size for x in data]
    elif method == 'ceil':
        return [math.ceil(x / bin_size) * bin_size for x in data]
    elif method == 'round':
        return [round(x / bin_size) * bin_size for x in data]
    elif method == 'midpoint':
        return [math.floor(x / bin_size) * bin_size + bin_size / 2 for x in data]
    else:
        raise ValueError("Invalid binning method")

# 測(cè)試
data = [1.2, 3.7, 5.1, 7.8, 9.4]
binned = bin_data(data, 2, 'floor')  # [0.0, 2.0, 4.0, 6.0, 8.0]

import pandas as pd

def feature_rounding(df, config):
    """特征工程取整處理"""
    df_rounded = df.copy()
    
    for col, method in config.items():
        if method == 'int':
            df_rounded[col] = df[col].astype(int)
        elif method == 'floor':
            df_rounded[col] = np.floor(df[col])
        elif method == 'ceil':
            df_rounded[col] = np.ceil(df[col])
        elif method == 'round':
            df_rounded[col] = np.round(df[col])
        elif method == 'bankers':
            df_rounded[col] = df[col].apply(bankers_round)
        elif isinstance(method, int):
            df_rounded[col] = np.round(df[col], method)
        elif isinstance(method, tuple) and method[0] == 'multiple':
            base = method[1]
            df_rounded[col] = base * np.round(df[col] / base)
    
    return df_rounded

# 使用示例
data = {
    'price': [19.99, 29.50, 45.75, 99.99],
    'quantity': [1.5, 2.0, 1.75, 3.0],
    'rating': [4.2, 3.8, 4.5, 4.0]
}
df = pd.DataFrame(data)

config = {
    'price': 'int',         # 截?cái)嗳≌?
    'quantity': 'ceil',      # 向上取整
    'rating': 1             # 四舍五入到1位小數(shù)
}

rounded_df = feature_rounding(df, config)
"""
   price  quantity  rating
0     19       2.0     4.2
1     29       2.0     3.8
2     45       2.0     4.5
3     99       3.0     4.0
"""

class SensorDataProcessor:
    """傳感器數(shù)據(jù)處理系統(tǒng)"""
    def __init__(self, precision=0.01, rounding='round'):
        self.precision = precision
        self.rounding = rounding
        self.calibration_factor = 1.0
    
    def calibrate(self, reference_value, readings):
        """校準(zhǔn)傳感器"""
        avg_reading = sum(readings) / len(readings)
        self.calibration_factor = reference_value / avg_reading
    
    def process_reading(self, raw_value):
        """處理原始讀數(shù)"""
        # 應(yīng)用校準(zhǔn)
        calibrated = raw_value * self.calibration_factor
        
        # 根據(jù)配置取整
        if self.rounding == 'round':
            return round(calibrated / self.precision) * self.precision
        elif self.rounding == 'floor':
            return math.floor(calibrated / self.precision) * self.precision
        elif self.rounding == 'ceil':
            return math.ceil(calibrated / self.precision) * self.precision
        else:
            return calibrated
    
    def batch_process(self, raw_values):
        """批量處理讀數(shù)"""
        return [self.process_reading(v) for v in raw_values]

# 使用示例
sensor = SensorDataProcessor(precision=0.1, rounding='round')
sensor.calibrate(100.0, [98.5, 99.2, 101.3])  # 校準(zhǔn)因子≈1.005

readings = [99.0, 100.5, 102.3]
processed = sensor.batch_process(readings)  # [99.5, 101.0, 102.8]

def engineering_round(value, significant_digits=3):
    """工程取整（保留有效數(shù)字）"""
    if value == 0:
        return 0.0
    
    # 計(jì)算數(shù)量級(jí)
    magnitude = math.floor(math.log10(abs(value)))
    
    # 計(jì)算縮放因子
    scale = 10 ** (magnitude - significant_digits + 1)
    
    # 取整并縮放
    return round(value / scale) * scale

# 測(cè)試
print(engineering_round(123456, 3))  # 123000
print(engineering_round(0.00123456, 3))  # 0.00123
print(engineering_round(12.3456, 3))  # 12.3

import timeit
import math

# 測(cè)試數(shù)據(jù)
values = [x * 0.1 for x in range(1000000)]

# 測(cè)試函數(shù)
def test_round():
    return [round(x) for x in values]

def test_math_floor():
    return [math.floor(x) for x in values]

def test_int():
    return [int(x) for x in values]

def test_numpy_round():
    arr = np.array(values)
    return np.round(arr)

# 性能測(cè)試
methods = {
    "round": test_round,
    "math.floor": test_math_floor,
    "int": test_int,
    "numpy.round": test_numpy_round
}

results = {}
for name, func in methods.items():
    time = timeit.timeit(func, number=1)
    results[name] = time

print("100萬(wàn)次操作耗時(shí):")
for name, time in sorted(results.items(), key=lambda x: x[1]):
    print(f"{name}: {time:.4f}秒")

# 使用Decimal進(jìn)行精確金融計(jì)算
from decimal import Decimal, ROUND_HALF_EVEN
amount = Decimal('123.456').quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN)

# 使用Pandas/NumPy進(jìn)行向量化操作
df['rounded'] = np.round(df['values'], 2)

# 保留有效數(shù)字
def engineering_round(value, sig_digits=3):
    if value == 0: return 0
    scale = 10 ** (math.floor(math.log10(abs(value))) - sig_digits + 1)
    return round(value / scale) * scale

# 避免循環(huán)內(nèi)重復(fù)取整
# 錯(cuò)誤做法
for value in large_list:
    result = round(value, 2)

# 正確做法
rounded_list = [round(v, 2) for v in large_list]

# 處理NaN和Inf
def safe_round(value, digits=0):
    if math.isnan(value) or math.isinf(value):
        return value
    return round(value, digits)

class TestRounding(unittest.TestCase):
    def test_bankers_round(self):
        self.assertEqual(bankers_round(2.5), 2)
        self.assertEqual(bankers_round(3.5), 4)
    
    def test_currency_round(self):
        self.assertEqual(currency_round(123.456, 'USD'), 123.46)
        self.assertEqual(currency_round(123.456, 'JPY'), 123)

# 浮點(diǎn)數(shù)精度問(wèn)題
print(round(2.675, 2))  # 2.67 不是2.68