예금 이자 계산 엔진 설계 — 일할 계산부터 우대금리까지

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);