預金利息計算エンジンの設計 — 日割り計算から優遇金利まで

ACT/365 (実日数/365):  1,000,000 x 0.03 x 73/365 = 6,000.00ウォン
ACT/360 (実日数/360):  1,000,000 x 0.03 x 73/360 = 6,083.33ウォン
30/360  (月30日換算)  :  日数を30日単位に換算して計算

[単利 Simple Interest]
  利息 = 元本 x 年利率 x (経過日数 / 365)
  I = P x r x (d / 365)

[複利 Compound Interest - 年m回複利、n年]
  元利金 = 元本 x (1 + r/m)^(m x n)
  S = P x (1 + r/m)^(m*n)

[月複利の定期預金の例 - 年3.0%、12か月、月複利]
  S = P x (1 + 0.03/12)^12
    = P x 1.030416...  (実効利回り約3.0416%)

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class InterestCalculator {

    private static final BigDecimal DAYS_IN_YEAR = new BigDecimal("365");
    private static final int CALC_SCALE = 10;   // 中間計算の精度
    private static final int KRW_SCALE = 0;     // ウォンは小数点なし

    /** 単利: 元本 x 年利率 x 経過日数/365、ウォン未満切捨て */
    public BigDecimal simpleInterest(BigDecimal principal,
                                     BigDecimal annualRate,   // 0.03 = 年3%
                                     LocalDate from,          // 預入日(含む)
                                     LocalDate to) {          // 支払日(除く)
        long days = ChronoUnit.DAYS.between(from, to);
        if (days < 0) {
            throw new IllegalArgumentException("支払日が預入日より前です");
        }
        return principal
                .multiply(annualRate)
                .multiply(new BigDecimal(days))
                .divide(DAYS_IN_YEAR, CALC_SCALE, RoundingMode.HALF_UP)
                .setScale(KRW_SCALE, RoundingMode.DOWN);  // ウォン未満切捨て
    }

    /** 月複利: 毎月利息を元本へ組み入れて積み上げる */
    public BigDecimal monthlyCompound(BigDecimal principal,
                                      BigDecimal annualRate,
                                      int months) {
        BigDecimal monthlyRate = annualRate.divide(
                new BigDecimal("12"), CALC_SCALE, RoundingMode.HALF_UP);
        BigDecimal balance = principal;
        for (int i = 0; i < months; i++) {
            BigDecimal interest = balance.multiply(monthlyRate)
                    .setScale(KRW_SCALE, RoundingMode.DOWN); // 回次ごとに切捨て
            balance = balance.add(interest);
        }
        return balance;
    }
}

from decimal import Decimal, ROUND_DOWN, ROUND_HALF_UP, getcontext
from datetime import date

getcontext().prec = 28  # 十分なグローバル精度

DAYS_IN_YEAR = Decimal("365")

def simple_interest(principal: Decimal, annual_rate: Decimal,
                    start: date, end: date) -> Decimal:
    """単利利息。預入日含む、支払日除く。ウォン未満切捨て。"""
    days = (end - start).days
    if days < 0:
        raise ValueError("支払日が預入日より前です")
    raw = principal * annual_rate * Decimal(days) / DAYS_IN_YEAR
    return raw.quantize(Decimal("1"), rounding=ROUND_DOWN)

def installment_maturity_interest(monthly_amount: Decimal,
                                  annual_rate: Decimal,
                                  months: int) -> Decimal:
    """定額積立の満期利息(単利): 回次ごとの預入月数に比例。"""
    total = Decimal("0")
    for k in range(1, months + 1):
        remaining_months = months - k + 1
        portion = (monthly_amount * annual_rate
                   * Decimal(remaining_months) / Decimal("12"))
        total += portion
    return total.quantize(Decimal("1"), rounding=ROUND_DOWN)

>>> 0.1 + 0.2
0.30000000000000004
>>> Decimal("0.1") + Decimal("0.2")
Decimal('0.3')

[満期支払]
  利息 = 元本 x 約定金利 x 預入日数/365

[中途解約]
  利息 = 元本 x 中途解約金利(預入期間の区分別) x 実預入日数/365
  - 中途解約金利は通常「基準金利 x 比率」または区分別の固定金利テーブル
  - 優遇金利は通常、中途解約時には適用除外

[一部引出(一部解約)]
  - 引出分: 引出時点まで中途解約算式で精算
  - 残存分: 元の約定条件を維持
  - 引出回数制限、最低維持残高など商品条件の検証が必要

[定額積立の満期利息(単利、約定払込日基準)]
  k回次払込金の利息 = 月掛金 x 年利率 x (満期までの残月数)/12
  総利息 = 月掛金 x 年利率 x (n + (n-1) + ... + 1)/12
        = 月掛金 x 年利率 x n(n+1)/(2 x 12)

  例: 月10万ウォン、年3%、12か月
  総利息 = 100,000 x 0.03 x 12x13/(2x12) = 100,000 x 0.03 x 6.5 = 19,500ウォン

CREATE TABLE preferential_rate_rule (
    product_code     VARCHAR(10)  NOT NULL,
    rule_id          VARCHAR(8)   NOT NULL,
    rule_name        VARCHAR(100) NOT NULL,   -- 例: 給与振込優遇
    condition_type   VARCHAR(20)  NOT NULL,   -- SALARY_TRANSFER, CARD_SPEND ...
    condition_param  VARCHAR(200),            -- JSONパラメータ(閾値など)
    bonus_rate       NUMERIC(7,4) NOT NULL,   -- 優遇幅(年利 %p)
    eval_timing      CHAR(1)      NOT NULL,   -- O:新規時 M:満期時 D:毎日
    valid_from       DATE         NOT NULL,
    valid_to         DATE         NOT NULL,
    CONSTRAINT pk_prr PRIMARY KEY (product_code, rule_id, valid_from)
);

public interface PreferentialCondition {
    /** 条件充足の可否を評価する。評価時点のコンテキストを受け取る。 */
    boolean evaluate(EvaluationContext ctx);
}

public class SalaryTransferCondition implements PreferentialCondition {
    private final int requiredMonths;  // 直近N か月連続の給与振込

    public SalaryTransferCondition(int requiredMonths) {
        this.requiredMonths = requiredMonths;
    }

    @Override
    public boolean evaluate(EvaluationContext ctx) {
        return ctx.salaryTransferMonths() >= requiredMonths;
    }
}

public class PreferentialRateEngine {

    public BigDecimal totalBonusRate(String productCode,
                                     EvaluationContext ctx,
                                     LocalDate evalDate) {
        List ruleRows = ruleRepository.findActive(productCode, evalDate);
        BigDecimal sum = BigDecimal.ZERO;
        for (Object row : ruleRows) {
            RuleRow rule = (RuleRow) row;
            PreferentialCondition cond = conditionFactory.create(rule);
            if (cond.evaluate(ctx)) {
                sum = sum.add(rule.bonusRate());
                auditLogger.record(ctx.accountNo(), rule.ruleId(), evalDate);
            }
        }
        return sum.min(maxBonusRate(productCode));  // 上限の適用
    }
}

税引前利息 = 利息計算エンジンの算出額
所得税     = 税引前利息 x 所得税率   (端数処理規則を適用)
地方所得税 = 所得税 x 地方所得税率   (端数処理規則を適用)
税引後利息 = 税引前利息 - 所得税 - 地方所得税

CREATE TABLE product_rate_history (
    product_code   VARCHAR(10)  NOT NULL,
    rate_type      CHAR(2)      NOT NULL,   -- 01:基準 02:中途解約 03:満期後
    effective_from DATE         NOT NULL,   -- 適用開始日(含む)
    effective_to   DATE         NOT NULL,   -- 適用終了日(除く)、9999-12-31許容
    annual_rate    NUMERIC(7,4) NOT NULL,
    approved_by    VARCHAR(20)  NOT NULL,   -- 決裁情報
    created_at     TIMESTAMP    NOT NULL,
    CONSTRAINT pk_pr PRIMARY KEY (product_code, rate_type, effective_from)
);

総利息 = SUM( 元本(または日別残高) x 区間金利 x 区間日数/365 )
        for 各金利区間 in [預入日, 支払日)

例: 100万ウォン、4/1預入、7/1支払
    4/1 - 5/15 (44日): 年3.0%  ->  1,000,000 x 0.030 x 44/365 = 3,616ウォン
    5/16 - 7/1 (47日): 年3.5%  ->  1,000,000 x 0.035 x 47/365 = 4,506ウォン
    合計(ウォン未満切捨て方針により区間別/総額別に処理)        = 8,122ウォン

 [利息決算バッチの流れ]
   1. 対象抽出: 決算対象の商品/口座 (状態、課税タイプを含む)
   2. 日積数集計: 決算期間の日別残高の合計 (ジャーナルから再構成可能であること)
   3. 税引前利息計算: 日積数 x 日歩(年利率/365)、区間金利を反映
   4. 税金計算: 課税タイプ別の源泉徴収額を算出
   5. 支払処理: 税引後利息の入金取引を生成 (利息取引タイプ)
   6. 仕訳記録: 支払利息 / 未払利息 / 預り金(税金) の整理
   7. 検証: 総額照合 (口座別合計 = 仕訳総額)、前年/前期比の異常値チェック
   8. レポート: 決算明細、源泉徴収の集計を出力

from hypothesis import given, strategies as st
from decimal import Decimal
from datetime import date, timedelta

amounts = st.integers(min_value=1, max_value=10_000_000_000)
days    = st.integers(min_value=0, max_value=3650)
rates   = st.decimals(min_value="0.0001", max_value="0.20", places=4)

@given(p=amounts, d=days, r=rates)
def test_interest_is_monotonic_in_days(p, d, r):
    """預入日数が増えれば利息は減らない。"""
    start = date(2026, 1, 1)
    i1 = simple_interest(Decimal(p), r, start, start + timedelta(days=d))
    i2 = simple_interest(Decimal(p), r, start, start + timedelta(days=d + 1))
    assert i2 >= i1

@given(p=amounts, d=days, r=rates)
def test_interest_never_negative(p, d, r):
    start = date(2026, 1, 1)
    i = simple_interest(Decimal(p), r, start, start + timedelta(days=d))
    assert i >= 0

@given(p1=amounts, p2=amounts, d=days, r=rates)
def test_splitting_principal_loses_at_most_rounding(p1, p2, d, r):
    """元本を分割して計算した合計は、一括計算と切捨て誤差以内で一致する。"""
    start = date(2026, 1, 1)
    end = start + timedelta(days=d)
    whole = simple_interest(Decimal(p1 + p2), r, start, end)
    split = (simple_interest(Decimal(p1), r, start, end)
             + simple_interest(Decimal(p2), r, start, end))
    assert 0 <= whole - split <= 1  # 切捨て1ウォン以内

// 絶対禁止
double interest = 1000000 * 0.03 * 73 / 365.0;  // 二進誤差が内在

// 基本動作
BigDecimal interest = new BigDecimal("1000000")
        .multiply(new BigDecimal("0.03"))
        .multiply(new BigDecimal("73"))
        .divide(new BigDecimal("365"), 10, RoundingMode.HALF_UP)
        .setScale(0, RoundingMode.DOWN);