請求書の消費税と端数処理

<?php
declare(strict_types=1);

use BcMath\Number;

/**
 * 請求書の消費税と端数処理。
 * v2: 十進（BcMath\Number）で計算し、端数処理は絶対値基準の RoundingMode で明示する。
 */
const DIV_SCALE = 20;

function roundingMode(string $mode): RoundingMode
{
    return match ($mode) {
        'floor' => RoundingMode::TowardsZero,      // 切り捨て（負でも 0 方向）
        'round' => RoundingMode::HalfAwayFromZero, // 四捨五入（偶数丸めではない）
        'ceil'  => RoundingMode::AwayFromZero,     // 切り上げ（負なら -∞ 方向）
        default => throw new InvalidArgumentException("unknown rounding: {$mode}"),
    };
}

function toYen(Number $value, string $mode): int
{
    return (int) $value->round(0, roundingMode($mode))->value;
}

/** @return array{exclusive:int, tax:int, inclusive:int} */
function calcInvoiceTax(string $basis, int $amount, string $rate, string $rounding): array
{
    $a = new Number($amount);
    $r = new Number($rate);
    if ($basis === 'exclusive') {
        $tax = toYen($a * $r, $rounding);
        return ['exclusive' => $amount, 'tax' => $tax, 'inclusive' => $amount + $tax];
    }
    $exclusive = toYen($a->div(1 + $r, DIV_SCALE), $rounding);
    return ['exclusive' => $exclusive, 'tax' => $amount - $exclusive, 'inclusive' => $amount];
}

<?php
declare(strict_types=1);

/**
 * 請求書の消費税と端数処理。
 * v1: 素直に書いた版（float と組み込みの floor / round / ceil）。
 */
function applyRounding(float $value, string $mode): int
{
    return (int) match ($mode) {
        'round' => round($value),
        'ceil'  => ceil($value),
        default => floor($value),
    };
}

/** @return array{exclusive:int, tax:int, inclusive:int} */
function calcInvoiceTax(string $basis, int $amount, string $rate, string $rounding): array
{
    $r = (float) $rate;
    if ($basis === 'exclusive') {
        $tax = applyRounding($amount * $r, $rounding);
        return ['exclusive' => $amount, 'tax' => $tax, 'inclusive' => $amount + $tax];
    }
    $exclusive = applyRounding($amount / (1 + $r), $rounding);
    return ['exclusive' => $exclusive, 'tax' => $amount - $exclusive, 'inclusive' => $amount];
}

"""請求書の消費税と端数処理。

v2: decimal で計算し、端数処理は絶対値基準の丸めモードで明示する。
"""
from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal, localcontext

# decimal の ROUND_DOWN / ROUND_UP / ROUND_HALF_UP は絶対値基準（負でも 0 方向／0 から遠い方へ）
ROUNDING = {
    "floor": ROUND_DOWN,     # 切り捨て
    "round": ROUND_HALF_UP,  # 四捨五入（偶数丸めではない）
    "ceil": ROUND_UP,        # 切り上げ
}


def to_yen(value: Decimal, mode: str) -> int:
    return int(value.quantize(Decimal(1), rounding=ROUNDING[mode]))


def calc_invoice_tax(basis: str, amount: int, rate: str, rounding: str) -> dict:
    r = Decimal(rate)
    with localcontext(prec=50):
        if basis == "exclusive":
            tax = to_yen(amount * r, rounding)
            return {"exclusive": amount, "tax": tax, "inclusive": amount + tax}
        exclusive = to_yen(amount / (1 + r), rounding)
        return {"exclusive": exclusive, "tax": amount - exclusive, "inclusive": amount}

"""請求書の消費税と端数処理。

v1: 素直に書いた版（float と組み込みの math.floor / round / math.ceil）。
"""
import math


def apply_rounding(value: float, mode: str) -> int:
    if mode == "round":
        return round(value)
    if mode == "ceil":
        return math.ceil(value)
    return math.floor(value)


def calc_invoice_tax(basis: str, amount: int, rate: str, rounding: str) -> dict:
    r = float(rate)
    if basis == "exclusive":
        tax = apply_rounding(amount * r, rounding)
        return {"exclusive": amount, "tax": tax, "inclusive": amount + tax}
    exclusive = apply_rounding(amount / (1 + r), rounding)
    return {"exclusive": exclusive, "tax": amount - exclusive, "inclusive": amount}

package main

import (
	"fmt"
	"math/big"
)

// Output は請求書の税抜・消費税・税込（円）。
type Output struct {
	Exclusive int64 `json:"exclusive"`
	Tax       int64 `json:"tax"`
	Inclusive int64 `json:"inclusive"`
}

// v2: math/big.Rat で正確に計算し、端数処理は絶対値基準で自前で行う。
// Go の math/big には「0方向・0から遠い方へ・四捨五入」を名指しする丸めが無いため、
// 商と余り（QuoRem は 0 方向に切り捨てる）から決める。
func toYen(v *big.Rat, mode string) (int64, error) {
	q, r := new(big.Int).QuoRem(v.Num(), v.Denom(), new(big.Int)) // Denom は常に正
	if r.Sign() != 0 {
		away := false
		switch mode {
		case "floor": // 切り捨て（0 方向）
		case "ceil": // 切り上げ（0 から遠い方へ）
			away = true
		case "round": // 四捨五入（|余り|×2 ≥ 分母 なら 0 から遠い方へ）
			away = new(big.Int).Lsh(new(big.Int).Abs(r), 1).Cmp(v.Denom()) >= 0
		default:
			return 0, fmt.Errorf("unknown rounding: %s", mode)
		}
		if away {
			q.Add(q, big.NewInt(int64(r.Sign())))
		}
	}
	if !q.IsInt64() {
		return 0, fmt.Errorf("out of int64 range: %s", q)
	}
	return q.Int64(), nil
}

// CalcInvoiceTax は端数処理をして税額を求める。
func CalcInvoiceTax(basis string, amount int64, rate string, rounding string) (Output, error) {
	r, ok := new(big.Rat).SetString(rate)
	if !ok {
		return Output{}, fmt.Errorf("invalid rate: %q", rate)
	}
	a := new(big.Rat).SetInt64(amount)
	if basis == "exclusive" {
		tax, err := toYen(new(big.Rat).Mul(a, r), rounding)
		if err != nil {
			return Output{}, err
		}
		return Output{amount, tax, amount + tax}, nil
	}
	onePlusRate := new(big.Rat).Add(big.NewRat(1, 1), r)
	exclusive, err := toYen(new(big.Rat).Quo(a, onePlusRate), rounding)
	if err != nil {
		return Output{}, err
	}
	return Output{exclusive, amount - exclusive, amount}, nil
}

package main

import (
	"math"
	"strconv"
)

// Output は請求書の税抜・消費税・税込（円）。
type Output struct {
	Exclusive int64 `json:"exclusive"`
	Tax       int64 `json:"tax"`
	Inclusive int64 `json:"inclusive"`
}

// v1: 素直に書いた版（float64 と math.Floor / math.Round / math.Ceil）。
func applyRounding(v float64, mode string) int64 {
	switch mode {
	case "round":
		return int64(math.Round(v))
	case "ceil":
		return int64(math.Ceil(v))
	default:
		return int64(math.Floor(v))
	}
}

// CalcInvoiceTax は端数処理をして税額を求める。
func CalcInvoiceTax(basis string, amount int64, rate string, rounding string) (Output, error) {
	r, err := strconv.ParseFloat(rate, 64)
	if err != nil {
		return Output{}, err
	}
	if basis == "exclusive" {
		tax := applyRounding(float64(amount)*r, rounding)
		return Output{amount, tax, amount + tax}, nil
	}
	exclusive := applyRounding(float64(amount)/(1+r), rounding)
	return Output{exclusive, amount - exclusive, amount}, nil
}

// 請求書の消費税と端数処理。
// v2: BigInt の分数で正確に計算し、端数処理は絶対値基準で自前で行う。
// JS には十進型が無く、Math.floor / Math.round / Math.ceil は負の側で意味が変わるため使わない。

/** "0.10" → { n: 10n, d: 100n } */
function parseDecimal(s) {
  const m = /^(-?)(\d+)(?:\.(\d+))?$/.exec(s);
  if (!m) throw new RangeError(`invalid decimal: ${s}`);
  const frac = m[3] ?? "";
  const n = BigInt(m[2] + frac);
  return { n: m[1] ? -n : n, d: 10n ** BigInt(frac.length) };
}

/** n/d（d > 0）を 1円単位に。BigInt の / と % は 0 方向に切り捨てる */
function toYen(n, d, mode) {
  const q = n / d;
  const r = n % d;
  if (r === 0n) return q;
  const sign = n < 0n ? -1n : 1n;
  const absR = r < 0n ? -r : r;
  if (mode === "floor") return q;                           // 切り捨て（0 方向）
  if (mode === "ceil") return q + sign;                     // 切り上げ（0 から遠い方へ）
  if (mode === "round") return 2n * absR >= d ? q + sign : q; // 四捨五入（偶数丸めではない）
  throw new RangeError(`unknown rounding: ${mode}`);
}

/** amount は BigInt で受け取り、BigInt で返す（2^53 を超える金額のため） */
export function calcInvoiceTax({ basis, amount, rate, rounding }) {
  const r = parseDecimal(rate);
  if (basis === "exclusive") {
    const tax = toYen(amount * r.n, r.d, rounding);
    return { exclusive: amount, tax, inclusive: amount + tax };
  }
  // amount ÷ (1 + n/d) = amount × d ÷ (d + n)
  const exclusive = toYen(amount * r.d, r.d + r.n, rounding);
  return { exclusive, tax: amount - exclusive, inclusive: amount };
}

// 請求書の消費税と端数処理。
// v1: 素直に書いた版（Number と Math.floor / Math.round / Math.ceil）。

function applyRounding(value, mode) {
  if (mode === "round") return Math.round(value);
  if (mode === "ceil") return Math.ceil(value);
  return Math.floor(value);
}

export function calcInvoiceTax({ basis, amount, rate, rounding }) {
  const r = Number(rate);
  if (basis === "exclusive") {
    const tax = applyRounding(amount * r, rounding);
    return { exclusive: amount, tax, inclusive: amount + tax };
  }
  const exclusive = applyRounding(amount / (1 + r), rounding);
  return { exclusive, tax: amount - exclusive, inclusive: amount };
}