利率の変換（年利・月利・日利）

<?php
declare(strict_types=1);

/**
 * 利率の変換（年利・月利・日利）。
 * v2: 利率の文字列を float に読まず、小数点を外した数字の列（分子）と 10^桁数（分母）の正確な分数として10進のまま読む。
 * 上限の比較も分子と「上限 × 10^桁数」の整数で比べる。
 * …5 ちょうどになりうる値（単利の3つと、入力と同じ単位の複利）は「分子 ÷ 分母」の整数の筆算で、
 * 桁 e を整数の比較で決め、0.5 ちょうどは大きい方へ四捨五入する。
 * 入力と違う単位の複利（累乗・累乗根）は float で計算する。累乗根は無理数になり、整数の累乗も小数が10桁以上続くので、
 * 有効数字5桁の …5 ちょうどにはならない。rate が 0 なら複利も "0"。
 * v1 の float では c005 の 12.003 ÷ 12 = 1.00025 が 1.0002499999999999 になって simple_month が 1.0002 に落ち、
 * c016 の月利 0.123455% を12乗してから12乗根で戻すと 0.123455 より少し小さくなって compound_month が 0.12345 に落ちた。
 * c006 の 0.33 × 365 ÷ 12 = 10.0375（float では 10.03749999…）は、number_format が「1000 倍してから丸める」ため
 * 掛け算の誤差で 10037.5 ちょうどになり、偶然 10.038 で通っていた（Go・JavaScript の v1 は 10.037 に落ちた）。
 * 長い入力では分子・分母が int の上限（約 9.2 × 10^18）を超えうるので、整数は数字の列のまま筆算する
 * （bcmath・gmp は入っていない環境があるので使わない）。
 */
const DECIMAL = '/^[0-9]+(\.[0-9]+)?$/D'; // D: $ を末尾の改行の前で一致させない
const N = ['year' => 1, 'month' => 12, 'day' => 365];
const LIMIT = ['year' => '1000', 'month' => '100', 'day' => '1'];

/** 先頭の 0 を外す（0 は "0"） */
function digitsNorm(string $a): string
{
    $a = ltrim($a, '0');
    return $a === '' ? '0' : $a;
}

/** 0 以上の整数（数字の列）の大小。-1・0・1 */
function digitsCmp(string $a, string $b): int
{
    return strlen($a) <=> strlen($b) ?: strcmp($a, $b) <=> 0;
}

function digitsAdd(string $a, string $b): string
{
    $n = max(strlen($a), strlen($b));
    $a = str_pad($a, $n, '0', STR_PAD_LEFT);
    $b = str_pad($b, $n, '0', STR_PAD_LEFT);
    $out = '';
    $carry = 0;
    for ($i = $n - 1; $i >= 0; $i--) {
        $s = (int) $a[$i] + (int) $b[$i] + $carry;
        $out = ($s % 10) . $out;
        $carry = intdiv($s, 10);
    }
    return digitsNorm(($carry ? '1' : '') . $out);
}

/** $a - $b（$a >= $b のとき） */
function digitsSub(string $a, string $b): string
{
    $b = str_pad($b, strlen($a), '0', STR_PAD_LEFT);
    $out = '';
    $borrow = 0;
    for ($i = strlen($a) - 1; $i >= 0; $i--) {
        $d = (int) $a[$i] - (int) $b[$i] - $borrow;
        $borrow = $d < 0 ? 1 : 0;
        $out = ($d + 10 * $borrow) . $out;
    }
    return digitsNorm($out);
}

/** 数字の列 × 小さい int（365 まで） */
function digitsMulSmall(string $a, int $m): string
{
    $out = '';
    $carry = 0;
    for ($i = strlen($a) - 1; $i >= 0; $i--) {
        $s = (int) $a[$i] * $m + $carry;
        $out = ($s % 10) . $out;
        $carry = intdiv($s, 10);
    }
    return digitsNorm(($carry ? (string) $carry : '') . $out);
}

/** 筆算の割り算。[商, 余り] */
function digitsDivMod(string $a, string $b): array
{
    $q = '';
    $r = '0';
    for ($i = 0, $n = strlen($a); $i < $n; $i++) {
        $r = digitsNorm($r . $a[$i]);
        $d = 0;
        while (digitsCmp($r, $b) >= 0) {
            $r = digitsSub($r, $b);
            $d++;
        }
        $q .= $d;
    }
    return [digitsNorm($q), $r];
}

/** n ÷ 10^d を書き、小数の最後の0と小数点を取る */
function show(string $n, int $d): string
{
    $s = str_pad($n, $d + 1, '0', STR_PAD_LEFT);
    return rtrim(rtrim(substr($s, 0, -$d) . '.' . substr($s, -$d), '0'), '.');
}

/** 小数の桁数 d（有効数字5桁・2以上8以下）。10^e <= 値 < 10^(e+1) の e を決めて 5 − e − 1 */
function places(int $e): int
{
    return min(max(5 - $e - 1, 2), 8);
}

/**
 * 正確な値 $num ÷ ($den × 10^$scale)（0 以上）を四捨五入（0.5 ちょうどは大きい方へ）して書く。
 * $den は 1・12・365。
 */
function fmtExact(string $num, int $den, int $scale): string
{
    if ($num === '0') {
        return '0';
    }
    // e は -4 以下なら d = 8、2 以上なら d = 2 なので、-3〜2 の境目だけ比べればよい。
    // 値 >= 10^k ⇔ num × 10^3 >= den × 10^(scale + k + 3)
    $e = -4;
    for ($k = -3; $k <= 2; $k++) {
        if (digitsCmp($num . '000', $den . str_repeat('0', $scale + $k + 3)) >= 0) {
            $e = $k;
        }
    }
    $d = places($e);
    // 値 × 10^d = (num × 10^d) ÷ (den × 10^scale)。余りの2倍が割る数以上なら切り上げ
    $q = (string) $den . str_repeat('0', $scale);
    [$n, $r] = digitsDivMod($num . str_repeat('0', $d), $q);
    if (digitsCmp(digitsAdd($r, $r), $q) >= 0) {
        $n = digitsAdd($n, '1');
    }
    return show($n, $d);
}

/** float の $p（…5 ちょうどにならない値）を書く */
function fmtFloat(float $p): string
{
    if ($p <= 0) {
        return '0';
    }
    $d = places((int) floor(log10($p)));
    return show(sprintf('%.0f', round($p * 10 ** $d)), $d);
}

/** @param array{rate: string, unit: string} $in */
function convertRate(array $in): array
{
    $rate = $in['rate'] ?? null;
    $unit = $in['unit'] ?? null;
    if (!is_string($unit) || !isset(N[$unit]) || !is_string($rate) || !preg_match(DECIMAL, $rate)) {
        return ['error' => 'invalid_input'];
    }
    [$int, $frac] = explode('.', $rate . '.');
    $num = digitsNorm($int . $frac);  // 利率（%）= num ÷ 10^scale
    $scale = strlen($frac);
    if (digitsCmp($num, LIMIT[$unit] . str_repeat('0', $scale)) > 0) {
        return ['error' => 'out_of_range'];
    }
    $n = N[$unit];
    $simple = digitsMulSmall($num, $n);  // 単利の年利（%）= simple ÷ 10^scale
    $out = [
        'simple_year' => fmtExact($simple, 1, $scale),
        'simple_month' => fmtExact($simple, 12, $scale),
        'simple_day' => fmtExact($simple, 365, $scale),
    ];
    if ($num === '0') {
        return $out + ['compound_year' => '0', 'compound_month' => '0', 'compound_day' => '0'];
    }
    $g = (1 + (float) $rate / 100) ** $n;  // 複利で1年に何倍になるか
    $same = fmtExact($num, 1, $scale);
    $out['compound_year'] = $unit === 'year' ? $same : fmtFloat(($g - 1) * 100);
    $out['compound_month'] = $unit === 'month' ? $same : fmtFloat(($g ** (1 / 12) - 1) * 100);
    $out['compound_day'] = $unit === 'day' ? $same : fmtFloat(($g ** (1 / 365) - 1) * 100);
    return $out;
}

<?php
declare(strict_types=1);

/**
 * 利率の変換（年利・月利・日利）。
 * v1: 利率を is_numeric で確かめて float に読み、単利は割り算、複利は ** で累乗・累乗根を計算して、
 * 桁数を log10 の floor で決め、number_format で書いてから最後の0を取る素直な書き方。
 */
const N = ['year' => 1, 'month' => 12, 'day' => 365];
const LIMIT = ['year' => 1000, 'month' => 100, 'day' => 1];

function fmt(float $p): string
{
    if ($p == 0) {
        return '0';
    }
    $d = 5 - (int) floor(log10(abs($p))) - 1;
    $d = min(max($d, 2), 8);
    $s = number_format($p, $d, '.', '');
    return rtrim(rtrim($s, '0'), '.');
}

/** @param array{rate: string, unit: string} $in */
function convertRate(array $in): array
{
    $rate = $in['rate'] ?? null;
    $unit = $in['unit'] ?? null;
    if (!is_string($unit) || !isset(N[$unit]) || !is_numeric($rate)) {
        return ['error' => 'invalid_input'];
    }
    $raw = (float) $rate;
    if ($raw < 0) {
        return ['error' => 'invalid_input'];
    }
    if ($raw > LIMIT[$unit]) {
        return ['error' => 'out_of_range'];
    }
    $n = N[$unit];
    $r = $raw / 100;
    $aSimple = $r * $n;
    $aCompound = (1 + $r) ** $n - 1;
    return [
        'simple_year' => fmt($aSimple * 100),
        'simple_month' => fmt($aSimple / 12 * 100),
        'simple_day' => fmt($aSimple / 365 * 100),
        'compound_year' => fmt($aCompound * 100),
        'compound_month' => fmt(((1 + $aCompound) ** (1 / 12) - 1) * 100),
        'compound_day' => fmt(((1 + $aCompound) ** (1 / 365) - 1) * 100),
    ];
}

"""利率の変換（年利・月利・日利）。

v2: 利率の文字列を fractions.Fraction（正確な分数）で10進のまま読む。
…5 ちょうどになりうる値（単利の3つと、入力と同じ単位の複利）は分数のまま正確に四捨五入する。
入力と違う単位の複利（累乗・累乗根）は float で計算する。累乗根は無理数になり、整数の累乗も小数が10桁以上続くので、
有効数字5桁の …5 ちょうどにはならない。
v1 の float では 12.003 ÷ 12 = 1.00025 が 1.0002499999999999 になって 1.0002 に落ち、
月利 0.123455% を12乗してから12乗根で戻すと 0.123455 より少し小さくなって 0.12345 に落ちた。
"""
import math
import re
from fractions import Fraction

DECIMAL = re.compile(r"[0-9]+(\.[0-9]+)?")
N = {"year": 1, "month": 12, "day": 365}
LIMIT = {"year": 1000, "month": 100, "day": 1}


def read_decimal(s):
    """10進の数の文字列を正確な分数に。読めなければ None（float() と違い "1e3"・"nan"・"-1" も読まない）"""
    if not isinstance(s, str) or not DECIMAL.fullmatch(s):
        return None
    return Fraction(s)


def digits(e):
    """10^e <= 値 < 10^(e+1) のときの小数の桁数（有効数字5桁・2以上8以下）"""
    return min(max(5 - e - 1, 2), 8)


def show(n, d):
    """n / 10^d を書き、小数の最後の0と小数点を取る"""
    s = str(n).rjust(d + 1, "0")
    return (s[:-d] + "." + s[-d:]).rstrip("0").rstrip(".")


def fmt_exact(x):
    """正確な分数 x（0 以上）を四捨五入（0.5 ちょうどは大きい方へ）して書く"""
    if x == 0:
        return "0"
    e = 0
    while x >= 10 ** (e + 1):
        e += 1
    while x < Fraction(10) ** e:
        e -= 1
    d = digits(e)
    return show(math.floor(x * 10 ** d + Fraction(1, 2)), d)


def fmt_float(p):
    """float の p を書く。…5 ちょうどにならない値だけに使う"""
    if p <= 0:  # とても小さい利率では、累乗根の計算が 0 になる（c017）
        return "0"
    d = digits(math.floor(math.log10(p)))
    return show(round(p * 10 ** d), d)


def convert(rate, unit):
    r = read_decimal(rate)
    if unit not in N or r is None:
        return {"error": "invalid_input"}
    if r > LIMIT[unit]:
        return {"error": "out_of_range"}
    n = N[unit]
    a_simple = r * n
    out = {
        "simple_year": fmt_exact(a_simple),
        "simple_month": fmt_exact(a_simple / 12),
        "simple_day": fmt_exact(a_simple / 365),
    }
    if r == 0:
        return {**out, "compound_year": "0", "compound_month": "0", "compound_day": "0"}
    g = (1 + float(r) / 100) ** n  # 複利で1年に何倍になるか
    out["compound_year"] = fmt_exact(r) if unit == "year" else fmt_float((g - 1) * 100)
    out["compound_month"] = fmt_exact(r) if unit == "month" else fmt_float((g ** (1 / 12) - 1) * 100)
    out["compound_day"] = fmt_exact(r) if unit == "day" else fmt_float((g ** (1 / 365) - 1) * 100)
    return out

"""利率の変換（年利・月利・日利）。

v1: 利率を float に読み、単利は割り算、複利は ** で累乗・累乗根を計算して、
桁数を math.log10 で決め、f"{:.{d}f}" で書いてから最後の0を取る素直な書き方。
"""
import math

N = {"year": 1, "month": 12, "day": 365}
LIMIT = {"year": 1000, "month": 100, "day": 1}


def fmt(p):
    if p == 0:
        return "0"
    d = 5 - math.floor(math.log10(abs(p))) - 1
    d = min(max(d, 2), 8)
    s = f"{p:.{d}f}"
    return s.rstrip("0").rstrip(".") if "." in s else s


def convert(rate, unit):
    if unit not in N:
        return {"error": "invalid_input"}
    try:
        raw = float(rate)
    except ValueError:
        return {"error": "invalid_input"}
    if raw < 0:
        return {"error": "invalid_input"}
    if raw > LIMIT[unit]:
        return {"error": "out_of_range"}
    n = N[unit]
    r = raw / 100
    a_simple = r * n
    a_compound = (1 + r) ** n - 1
    return {
        "simple_year": fmt(a_simple * 100),
        "simple_month": fmt(a_simple / 12 * 100),
        "simple_day": fmt(a_simple / 365 * 100),
        "compound_year": fmt(a_compound * 100),
        "compound_month": fmt(((1 + a_compound) ** (1 / 12) - 1) * 100),
        "compound_day": fmt(((1 + a_compound) ** (1 / 365) - 1) * 100),
    }

package main

import (
	"math"
	"math/big"
	"regexp"
	"strconv"
	"strings"
)

// 利率の変換（年利・月利・日利）。
// v2: 利率の文字列を float64 に読まず、小数点を外した数字の列（分子・big.Int）と 10^桁数（分母）の正確な分数として10進のまま読む。
// 上限の比較も分子と「上限 × 10^桁数」の整数で比べる。
// …5 ちょうどになりうる値（単利の3つと、入力と同じ単位の複利）は big.Int の割り算で、
// 桁 e を整数の比較で決め、0.5 ちょうどは大きい方へ四捨五入する。
// 入力と違う単位の複利（累乗・累乗根）は float64 で計算する。累乗根は無理数になり、整数の累乗も小数が10桁以上続くので、
// 有効数字5桁の …5 ちょうどにはならない。rate が 0 なら複利も "0"。
// v1 の float64 では c005 の 12.003 ÷ 12 = 1.00025 が 1.0002499999999999 になって simple_month が 1.0002 に落ち、
// c006 の 0.33 × 365 ÷ 12 = 10.0375 が 10.037499999999999 になって 10.037 に落ち、
// c016 の月利 0.123455% を12乗してから12乗根で戻すと 0.123455 より少し小さくなって compound_month が 0.12345 に落ちた。
// strconv.FormatFloat は2進数の値を正確に10進に直してから丸めるので、2進数で …5 より少し小さければ必ず小さい方になる。

// strconv.ParseFloat は "1e3"・"Inf"・"-1"・"0x1p3" も読むので、先に形を確かめる。
var decimal = regexp.MustCompile(`^[0-9]+(\.[0-9]+)?$`)

var nOf = map[string]int64{"year": 1, "month": 12, "day": 365}
var limit = map[string]int64{"year": 1000, "month": 100, "day": 1}

func pow10(k int) *big.Int { return new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(k)), nil) }

// places は 10^e <= 値 < 10^(e+1) のときの小数の桁数（有効数字5桁・2以上8以下）。
func places(e int) int { return min(max(5-e-1, 2), 8) }

// show は n ÷ 10^d を書き、小数の最後の0と小数点を取る。
func show(n string, d int) string {
	if len(n) < d+1 {
		n = strings.Repeat("0", d+1-len(n)) + n
	}
	s := n[:len(n)-d] + "." + n[len(n)-d:]
	return strings.TrimRight(strings.TrimRight(s, "0"), ".")
}

// fmtExact は正確な値 num ÷ (den × 10^scale)（0 以上）を四捨五入（0.5 ちょうどは大きい方へ）して書く。
func fmtExact(num *big.Int, den int64, scale int) string {
	if num.Sign() == 0 {
		return "0"
	}
	// e は -4 以下なら d = 8、2 以上なら d = 2 なので、-3〜2 の境目だけ比べればよい。
	// 値 >= 10^k ⇔ num × 10^3 >= den × 10^(scale + k + 3)
	lhs := new(big.Int).Mul(num, pow10(3))
	e := -4
	for k := -3; k <= 2; k++ {
		rhs := new(big.Int).Mul(big.NewInt(den), pow10(scale+k+3))
		if lhs.Cmp(rhs) >= 0 {
			e = k
		}
	}
	d := places(e)
	q := new(big.Int).Mul(big.NewInt(den), pow10(scale))
	n, r := new(big.Int).QuoRem(new(big.Int).Mul(num, pow10(d)), q, new(big.Int)) // 0 以上なので QuoRem は切り捨て
	if r.Lsh(r, 1).Cmp(q) >= 0 {
		n.Add(n, big.NewInt(1))
	}
	return show(n.String(), d)
}

// fmtFloat は float64 の p（…5 ちょうどにならない値）を書く。
func fmtFloat(p float64) string {
	if p <= 0 {
		return "0"
	}
	d := places(int(math.Floor(math.Log10(p))))
	return show(strconv.FormatFloat(math.Round(p*math.Pow(10, float64(d))), 'f', 0, 64), d)
}

func Convert(rate, unit string) map[string]any {
	n, ok := nOf[unit]
	if !ok || !decimal.MatchString(rate) {
		return map[string]any{"error": "invalid_input"}
	}
	intPart, frac, _ := strings.Cut(rate, ".")
	num, _ := new(big.Int).SetString(intPart+frac, 10) // 利率（%）= num ÷ 10^scale
	scale := len(frac)
	if num.Cmp(new(big.Int).Mul(big.NewInt(limit[unit]), pow10(scale))) > 0 {
		return map[string]any{"error": "out_of_range"}
	}
	simple := new(big.Int).Mul(num, big.NewInt(n)) // 単利の年利（%）= simple ÷ 10^scale
	out := map[string]any{
		"simple_year":  fmtExact(simple, 1, scale),
		"simple_month": fmtExact(simple, 12, scale),
		"simple_day":   fmtExact(simple, 365, scale),
	}
	if num.Sign() == 0 {
		out["compound_year"], out["compound_month"], out["compound_day"] = "0", "0", "0"
		return out
	}
	r, _ := strconv.ParseFloat(rate, 64)
	g := math.Pow(1+r/100, float64(n)) // 複利で1年に何倍になるか
	same := fmtExact(num, 1, scale)
	pick := func(u string, p float64) string {
		if unit == u {
			return same
		}
		return fmtFloat(p)
	}
	out["compound_year"] = pick("year", (g-1)*100)
	out["compound_month"] = pick("month", (math.Pow(g, 1.0/12)-1)*100)
	out["compound_day"] = pick("day", (math.Pow(g, 1.0/365)-1)*100)
	return out
}

package main

import (
	"math"
	"strconv"
	"strings"
)

// v1: 利率を strconv.ParseFloat で float64 に読み、単利は割り算、複利は math.Pow で累乗・累乗根を計算して、
// 桁数を math.Log10 の Floor で決め、strconv.FormatFloat で書いてから最後の0を取る素直な書き方。

var nOf = map[string]float64{"year": 1, "month": 12, "day": 365}
var limit = map[string]float64{"year": 1000, "month": 100, "day": 1}

func format(p float64) string {
	if p == 0 {
		return "0"
	}
	d := 5 - int(math.Floor(math.Log10(math.Abs(p)))) - 1
	d = min(max(d, 2), 8)
	s := strconv.FormatFloat(p, 'f', d, 64)
	return strings.TrimRight(strings.TrimRight(s, "0"), ".")
}

func Convert(rate, unit string) map[string]any {
	n, ok := nOf[unit]
	if !ok {
		return map[string]any{"error": "invalid_input"}
	}
	raw, err := strconv.ParseFloat(rate, 64)
	if err != nil || raw < 0 {
		return map[string]any{"error": "invalid_input"}
	}
	if raw > limit[unit] {
		return map[string]any{"error": "out_of_range"}
	}
	r := raw / 100
	aSimple := r * n
	aCompound := math.Pow(1+r, n) - 1
	return map[string]any{
		"simple_year":    format(aSimple * 100),
		"simple_month":   format(aSimple / 12 * 100),
		"simple_day":     format(aSimple / 365 * 100),
		"compound_year":  format(aCompound * 100),
		"compound_month": format((math.Pow(1+aCompound, 1.0/12) - 1) * 100),
		"compound_day":   format((math.Pow(1+aCompound, 1.0/365) - 1) * 100),
	}
}

// 利率の変換（年利・月利・日利）。
// v2: 利率の文字列を Number に読まず、小数点を外した数字の列（分子・BigInt）と 10^桁数（分母）の正確な分数として10進のまま読む。
// 上限の比較も分子と「上限 × 10^桁数」の BigInt で比べる。
// …5 ちょうどになりうる値（単利の3つと、入力と同じ単位の複利）は BigInt の割り算で、
// 桁 e を整数の比較で決め、0.5 ちょうどは大きい方へ四捨五入する。
// 入力と違う単位の複利（累乗・累乗根）は Number で計算する。累乗根は無理数になり、整数の累乗も小数が10桁以上続くので、
// 有効数字5桁の …5 ちょうどにはならない。rate が 0 なら複利も "0"。
// v1（元ツールと同じ形）の Number では c005 の 12.003 ÷ 12 = 1.00025 が 1.0002499999999999 になって simple_month が 1.0002 に落ち、
// c006 の 0.33 × 365 ÷ 12 = 10.0375 が 10.037499999999999 になって 10.037 に落ち、
// c016 の月利 0.123455% を12乗してから12乗根で戻すと 0.123455 より少し小さくなって compound_month が 0.12345 に落ちた。
// toFixed は2進数の値を正確に10進に直してから丸めるので、2進数で …5 より少し小さければ必ず小さい方になる。

// Number() は "1e3"・" 12 "・"0x10"・"Infinity" も読むので、先に形を確かめる。
const DECIMAL = /^[0-9]+(\.[0-9]+)?$/;
const N = { year: 1n, month: 12n, day: 365n };
const LIMIT = { year: 1000n, month: 100n, day: 1n };

/** 10^e <= 値 < 10^(e+1) のときの小数の桁数（有効数字5桁・2以上8以下） */
const places = (e) => Math.min(Math.max(5 - e - 1, 2), 8);

/** n ÷ 10^d を書き、小数の最後の0と小数点を取る */
function show(n, d) {
  const s = String(n).padStart(d + 1, "0");
  return `${s.slice(0, -d)}.${s.slice(-d)}`.replace(/\.?0+$/, "");
}

/** 正確な値 num ÷ (den × 10^scale)（0 以上）を四捨五入（0.5 ちょうどは大きい方へ）して書く */
function fmtExact(num, den, scale) {
  if (num === 0n) return "0";
  // e は -4 以下なら d = 8、2 以上なら d = 2 なので、-3〜2 の境目だけ比べればよい。
  // 値 >= 10^k ⇔ num × 10^3 >= den × 10^(scale + k + 3)
  let e = -4;
  for (let k = -3; k <= 2; k++) {
    if (num * 1000n >= den * 10n ** BigInt(scale + k + 3)) e = k;
  }
  const d = places(e);
  const q = den * 10n ** BigInt(scale);
  // 値 × 10^d + 0.5 の切り捨て = (2 × num × 10^d + q) ÷ (2 × q)。BigInt の割り算は正の数なら切り捨て
  return show((2n * num * 10n ** BigInt(d) + q) / (2n * q), d);
}

/** Number の p（…5 ちょうどにならない値）を書く */
function fmtFloat(p) {
  if (!(p > 0)) return "0";
  const d = places(Math.floor(Math.log10(p)));
  return show(Math.round(p * 10 ** d), d);
}

export function convert({ rate, unit }) {
  if (!Object.hasOwn(N, unit) || typeof rate !== "string" || !DECIMAL.test(rate)) return { error: "invalid_input" };
  const [int, frac = ""] = rate.split(".");
  const num = BigInt(int + frac); // 利率（%）= num ÷ 10^scale
  const scale = frac.length;
  if (num > LIMIT[unit] * 10n ** BigInt(scale)) return { error: "out_of_range" };
  const n = N[unit];
  const simple = num * n; // 単利の年利（%）= simple ÷ 10^scale
  const out = {
    simple_year: fmtExact(simple, 1n, scale),
    simple_month: fmtExact(simple, 12n, scale),
    simple_day: fmtExact(simple, 365n, scale),
  };
  if (num === 0n) return { ...out, compound_year: "0", compound_month: "0", compound_day: "0" };
  const g = (1 + Number(rate) / 100) ** Number(n); // 複利で1年に何倍になるか
  const same = fmtExact(num, 1n, scale);
  out.compound_year = unit === "year" ? same : fmtFloat((g - 1) * 100);
  out.compound_month = unit === "month" ? same : fmtFloat((g ** (1 / 12) - 1) * 100);
  out.compound_day = unit === "day" ? same : fmtFloat((g ** (1 / 365) - 1) * 100);
  return out;
}

// 利率の変換（年利・月利・日利）。
// v1: 利率を Number() で読み、単利は割り算、複利は ** で累乗・累乗根を計算して、
// 桁数を Math.log10 の floor で決め、toFixed で書いてから最後の0を取る素直な書き方（元ツールと同じ形）。

const N = { year: 1, month: 12, day: 365 };
const LIMIT = { year: 1000, month: 100, day: 1 };

function fmt(p) {
  if (p === 0) return "0";
  let d = 5 - Math.floor(Math.log10(Math.abs(p))) - 1;
  d = Math.min(Math.max(d, 2), 8);
  return p.toFixed(d).replace(/\.?0+$/, "");
}

export function convert({ rate, unit }) {
  if (!Object.hasOwn(N, unit)) return { error: "invalid_input" };
  const raw = Number(rate);
  if (rate === "" || Number.isNaN(raw) || raw < 0) return { error: "invalid_input" };
  if (raw > LIMIT[unit]) return { error: "out_of_range" };
  const n = N[unit];
  const r = raw / 100;
  const aSimple = r * n;
  const aCompound = (1 + r) ** n - 1;
  return {
    simple_year: fmt(aSimple * 100),
    simple_month: fmt((aSimple / 12) * 100),
    simple_day: fmt((aSimple / 365) * 100),
    compound_year: fmt(aCompound * 100),
    compound_month: fmt(((1 + aCompound) ** (1 / 12) - 1) * 100),
    compound_day: fmt(((1 + aCompound) ** (1 / 365) - 1) * 100),
  };
}

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * 利率の変換（年利・月利・日利）。
 * v2: 利率の文字列を BigDecimal（10進のまま）で読み、上限（年1000・月100・日1）とも compareTo で正確に比べる。
 * …5 ちょうどになりうる値（単利の3つと、入力と同じ単位の複利）は「分子 ÷ 分母」の整数（BigInteger）のまま扱い、
 * 桁 e（10^e ≤ 値 < 10^(e+1)）も整数の比較で決めて、floor((2 × 分子 × 10^d + 分母) ÷ (2 × 分母)) で
 * 四捨五入する（0.5 ちょうどは大きい方へ）。÷12・÷365 は割り切れないので、BigDecimal の divide に MathContext を
 * 渡すと途中で一度丸まって二重の丸めになりうる。分数のままなら丸めは最後の1回だけ。
 * 入力と違う単位の複利（累乗・累乗根）は double で計算する。累乗根は無理数になり、整数の累乗も小数が10桁以上続くので、
 * 有効数字5桁の …5 ちょうどにはならない。利率が 0 なら複利も "0"。
 * v1（double・String.format）は16件中14件。c005 の単利の月利 12.003 ÷ 12 = 1.00025 が double では
 * 1.0002499999999999 になって "1.0002"（正しくは "1.0003"）、c016 の月利 0.123455% を12乗してから12乗根で戻すと
 * 0.123455 より少し小さくなって compound_month が "0.12345"（正しくは "0.12346"）と出た。
 * c006（0.33 × 365 ÷ 12 = 10.0375）は double では 10.03749999… だが、String.format は double の最短の10進表記
 * "10.0375" を HALF_UP で丸めるので、たまたま "10.038" と正しく出ていた（C# の ToString("F3") は "10.037"）。
 * Double.parseDouble は "1e2"・"NaN"・前後の空白も読むので、入力は 10進の数の形かを先に確かめる。
 */
public final class Rate {
    private Rate() {}

    private static final Pattern DECIMAL = Pattern.compile("[0-9]+(\\.[0-9]+)?");

    static int n(String unit) {
        switch (unit) {
            case "year": return 1;
            case "month": return 12;
            case "day": return 365;
            default: return 0;
        }
    }

    static BigDecimal limit(String unit) {
        switch (unit) {
            case "year": return BigDecimal.valueOf(1000);
            case "month": return BigDecimal.valueOf(100);
            default: return BigDecimal.ONE;
        }
    }

    /** 10進の数の文字列を BigDecimal に。形が違えば null */
    static BigDecimal dec(String s) {
        return s != null && DECIMAL.matcher(s).matches() ? new BigDecimal(s) : null;
    }

    /** 10^e ≤ 値 < 10^(e+1) のときの小数の桁数（有効数字5桁・2以上8以下） */
    static int digits(int e) {
        return Math.min(Math.max(5 - e - 1, 2), 8);
    }

    /** num ÷ den（どちらも 0 より大きい）と 10^e を比べる */
    static int cmpPow10(BigInteger num, BigInteger den, int e) {
        return e >= 0 ? num.compareTo(den.multiply(BigInteger.TEN.pow(e)))
                      : num.multiply(BigInteger.TEN.pow(-e)).compareTo(den);
    }

    /** q ÷ 10^d を書き、小数の最後の0と小数点を取る */
    static String show(BigInteger q, int d) {
        StringBuilder s = new StringBuilder(q.toString());
        while (s.length() < d + 1) s.insert(0, '0');
        s.insert(s.length() - d, '.');
        int end = s.length();
        while (s.charAt(end - 1) == '0') end--;
        if (s.charAt(end - 1) == '.') end--;
        return s.substring(0, end);
    }

    /** 正確な値 num ÷ den（0 以上）を四捨五入（0.5 ちょうどは大きい方へ）して書く */
    static String fmtExact(BigInteger num, BigInteger den) {
        if (num.signum() == 0) return "0";
        int e = 0;
        while (cmpPow10(num, den, e + 1) >= 0) e++;
        while (cmpPow10(num, den, e) < 0) e--;
        int d = digits(e);
        BigInteger two = BigInteger.TWO;
        BigInteger q = num.multiply(BigInteger.TEN.pow(d)).multiply(two).add(den).divide(den.multiply(two));
        return show(q, d);
    }

    /** double の p を書く。…5 ちょうどにならない値だけに使う */
    static String fmtFloat(double p) {
        if (p <= 0) return "0"; // 1 + r ÷ 100 が double で 1 になるほど小さい利率
        int d = digits((int) Math.floor(Math.log10(p)));
        return show(BigInteger.valueOf(Math.round(p * Math.pow(10, d))), d);
    }

    public static Map<String, Object> convert(String rate, String unit) {
        Map<String, Object> out = new LinkedHashMap<>();
        BigDecimal r = dec(rate);
        int n = unit == null ? 0 : n(unit);
        if (n == 0 || r == null) {
            out.put("error", "invalid_input");
            return out;
        }
        if (r.compareTo(limit(unit)) > 0) {
            out.put("error", "out_of_range");
            return out;
        }
        // r = unscaled ÷ 10^scale（scale ≥ 0。正規表現で指数を読まないので）
        BigInteger u = r.unscaledValue();
        BigInteger p = BigInteger.TEN.pow(r.scale());
        BigInteger aSimple = u.multiply(BigInteger.valueOf(n)); // 単利の年利（%）= aSimple ÷ p
        out.put("simple_year", fmtExact(aSimple, p));
        out.put("simple_month", fmtExact(aSimple, p.multiply(BigInteger.valueOf(12))));
        out.put("simple_day", fmtExact(aSimple, p.multiply(BigInteger.valueOf(365))));
        if (r.signum() == 0) {
            out.put("compound_year", "0");
            out.put("compound_month", "0");
            out.put("compound_day", "0");
            return out;
        }
        String same = fmtExact(u, p);
        double g = Math.pow(1 + r.doubleValue() / 100, n); // 複利で1年に何倍になるか
        out.put("compound_year", unit.equals("year") ? same : fmtFloat((g - 1) * 100));
        out.put("compound_month", unit.equals("month") ? same : fmtFloat((Math.pow(g, 1.0 / 12) - 1) * 100));
        out.put("compound_day", unit.equals("day") ? same : fmtFloat((Math.pow(g, 1.0 / 365) - 1) * 100));
        return out;
    }
}

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 利率の変換（年利・月利・日利）。
 * v1: 利率を double に読み、単利は割り算、複利は Math.pow で累乗・累乗根を計算して、
 * 桁数を Math.log10 の floor で決め、String.format("%." + d + "f") で書いてから最後の0を取る素直な書き方。
 */
public final class Rate {
    private Rate() {}

    static int n(String unit) {
        switch (unit) {
            case "year": return 1;
            case "month": return 12;
            case "day": return 365;
            default: return 0;
        }
    }

    static double limit(String unit) {
        switch (unit) {
            case "year": return 1000;
            case "month": return 100;
            default: return 1;
        }
    }

    static String fmt(double p) {
        if (p == 0) return "0";
        int d = 5 - (int) Math.floor(Math.log10(Math.abs(p))) - 1;
        d = Math.min(Math.max(d, 2), 8);
        String s = String.format("%." + d + "f", p);
        if (s.contains(".")) s = s.replaceAll("0+$", "").replaceAll("\\.$", "");
        return s;
    }

    public static Map<String, Object> convert(String rate, String unit) {
        Map<String, Object> out = new LinkedHashMap<>();
        int n = n(unit);
        if (n == 0) {
            out.put("error", "invalid_input");
            return out;
        }
        double raw;
        try {
            raw = Double.parseDouble(rate);
        } catch (NumberFormatException | NullPointerException e) {
            out.put("error", "invalid_input");
            return out;
        }
        if (raw < 0) {
            out.put("error", "invalid_input");
            return out;
        }
        if (raw > limit(unit)) {
            out.put("error", "out_of_range");
            return out;
        }
        double r = raw / 100;
        double aSimple = r * n;
        double aCompound = Math.pow(1 + r, n) - 1;
        out.put("simple_year", fmt(aSimple * 100));
        out.put("simple_month", fmt(aSimple / 12 * 100));
        out.put("simple_day", fmt(aSimple / 365 * 100));
        out.put("compound_year", fmt(aCompound * 100));
        out.put("compound_month", fmt((Math.pow(1 + aCompound, 1.0 / 12) - 1) * 100));
        out.put("compound_day", fmt((Math.pow(1 + aCompound, 1.0 / 365) - 1) * 100));
        return out;
    }
}

// 利率の変換（年利・月利・日利）。
// v2: 利率の文字列を、小数点を外した整数 u と小数の桁数 k に分けて BigInteger で読む（利率 = u ÷ 10^k、10進のまま正確）。
// decimal は28桁ほどまでしか持てず、それより長い入力は黙って丸めるので使わない。上限（年1000・月100・日1）も
// u と 上限 × 10^k の整数で比べる。
// …5 ちょうどになりうる値（単利の3つと、入力と同じ単位の複利）は「分子 ÷ 分母」の整数のまま扱い、
// 桁 e（10^e ≤ 値 < 10^(e+1)）も整数の比較で決めて、floor((2 × 分子 × 10^d + 分母) ÷ (2 × 分母)) で
// 四捨五入する（0.5 ちょうどは大きい方へ）。÷12・÷365 は割り切れないので、途中で小数に直すと一度丸まって二重の丸めになりうる。
// 入力と違う単位の複利（累乗・累乗根）は double で計算する。累乗根は無理数になり、整数の累乗も小数が10桁以上続くので、
// 有効数字5桁の …5 ちょうどにはならない。利率が 0 なら複利も "0"。
// v1（double・ToString("F" + d)）は16件中13件。c005 の単利の月利 12.003 ÷ 12 = 1.00025 が double では
// 1.0002499999999999 になって "1.0002"（正しくは "1.0003"）、c006 の 0.33 × 365 ÷ 12 = 10.0375 が
// 10.03749999… になって "10.037"（正しくは "10.038"）、c016 の月利 0.123455% を12乗してから12乗根で戻すと
// 0.123455 より少し小さくなって compound_month が "0.12345"（正しくは "0.12346"）と出た。
// .NET の ToString("F") は double の正確な2進数の値で丸めるので、最短の10進表記で丸める Java・Kotlin の
// String.format では通った c006 も落ちた。
// double.TryParse は "1e2"・"NaN"・空白も読み、カルチャで小数点の記号も変わるので、形を先に確かめて InvariantCulture で読む。
using System.Globalization;
using System.Numerics;
using System.Text.RegularExpressions;

public static class Rate
{
    static readonly Regex DecimalForm = new(@"^[0-9]+(\.[0-9]+)?\z");
    static readonly Dictionary<string, int> N = new() { ["year"] = 1, ["month"] = 12, ["day"] = 365 };
    static readonly Dictionary<string, int> Limit = new() { ["year"] = 1000, ["month"] = 100, ["day"] = 1 };

    /// 10^e ≤ 値 < 10^(e+1) のときの小数の桁数（有効数字5桁・2以上8以下）
    static int Digits(int e) => Math.Clamp(5 - e - 1, 2, 8);

    /// num ÷ den（どちらも 0 より大きい）と 10^e を比べる
    static int CmpPow10(BigInteger num, BigInteger den, int e) =>
        e >= 0 ? num.CompareTo(den * BigInteger.Pow(10, e)) : (num * BigInteger.Pow(10, -e)).CompareTo(den);

    /// q ÷ 10^d を書き、小数の最後の0と小数点を取る
    static string Show(BigInteger q, int d)
    {
        string s = q.ToString(CultureInfo.InvariantCulture).PadLeft(d + 1, '0');
        return (s[..^d] + "." + s[^d..]).TrimEnd('0').TrimEnd('.');
    }

    /// 正確な値 num ÷ den（0 以上）を四捨五入（0.5 ちょうどは大きい方へ）して書く
    static string FmtExact(BigInteger num, BigInteger den)
    {
        if (num.IsZero) return "0";
        int e = 0;
        while (CmpPow10(num, den, e + 1) >= 0) e++;
        while (CmpPow10(num, den, e) < 0) e--;
        int d = Digits(e);
        return Show((num * BigInteger.Pow(10, d) * 2 + den) / (den * 2), d);
    }

    /// double の p を書く。…5 ちょうどにならない値だけに使う
    static string FmtFloat(double p)
    {
        if (p <= 0) return "0"; // 1 + r ÷ 100 が double で 1 になるほど小さい利率
        int d = Digits((int)Math.Floor(Math.Log10(p)));
        return Show(new BigInteger(Math.Round(p * Math.Pow(10, d), MidpointRounding.AwayFromZero)), d);
    }

    public static Dictionary<string, object?> Convert(string rate, string unit)
    {
        if (!N.TryGetValue(unit, out int n) || !DecimalForm.IsMatch(rate))
            return new() { ["error"] = "invalid_input" };
        int dot = rate.IndexOf('.');
        int k = dot < 0 ? 0 : rate.Length - dot - 1;
        var u = BigInteger.Parse(dot < 0 ? rate : rate.Remove(dot, 1), CultureInfo.InvariantCulture);
        var p = BigInteger.Pow(10, k); // 利率 = u ÷ p
        if (u > Limit[unit] * p)
            return new() { ["error"] = "out_of_range" };
        var aSimple = u * n; // 単利の年利（%）= aSimple ÷ p
        var out_ = new Dictionary<string, object?>
        {
            ["simple_year"] = FmtExact(aSimple, p),
            ["simple_month"] = FmtExact(aSimple, p * 12),
            ["simple_day"] = FmtExact(aSimple, p * 365),
        };
        if (u.IsZero)
        {
            out_["compound_year"] = out_["compound_month"] = out_["compound_day"] = "0";
            return out_;
        }
        string same = FmtExact(u, p);
        double g = Math.Pow(1 + double.Parse(rate, CultureInfo.InvariantCulture) / 100, n); // 複利で1年に何倍になるか
        out_["compound_year"] = unit == "year" ? same : FmtFloat((g - 1) * 100);
        out_["compound_month"] = unit == "month" ? same : FmtFloat((Math.Pow(g, 1.0 / 12) - 1) * 100);
        out_["compound_day"] = unit == "day" ? same : FmtFloat((Math.Pow(g, 1.0 / 365) - 1) * 100);
        return out_;
    }
}

// 利率の変換（年利・月利・日利）。
// v1: 利率を double に読み、単利は割り算、複利は Math.Pow で累乗・累乗根を計算して、
// 桁数を Math.Log10 の Floor で決め、ToString("F" + d) で書いてから最後の0を取る素直な書き方。

public static class Rate
{
    static readonly Dictionary<string, int> N = new() { ["year"] = 1, ["month"] = 12, ["day"] = 365 };
    static readonly Dictionary<string, double> Limit = new() { ["year"] = 1000, ["month"] = 100, ["day"] = 1 };

    static string Fmt(double p)
    {
        if (p == 0) return "0";
        int d = 5 - (int)Math.Floor(Math.Log10(Math.Abs(p))) - 1;
        d = Math.Clamp(d, 2, 8);
        string s = p.ToString("F" + d);
        return s.Contains('.') ? s.TrimEnd('0').TrimEnd('.') : s;
    }

    public static Dictionary<string, object?> Convert(string rate, string unit)
    {
        if (!N.TryGetValue(unit, out int n) || !double.TryParse(rate, out double raw) || raw < 0)
            return new() { ["error"] = "invalid_input" };
        if (raw > Limit[unit])
            return new() { ["error"] = "out_of_range" };
        double r = raw / 100;
        double aSimple = r * n;
        double aCompound = Math.Pow(1 + r, n) - 1;
        return new()
        {
            ["simple_year"] = Fmt(aSimple * 100),
            ["simple_month"] = Fmt(aSimple / 12 * 100),
            ["simple_day"] = Fmt(aSimple / 365 * 100),
            ["compound_year"] = Fmt(aCompound * 100),
            ["compound_month"] = Fmt((Math.Pow(1 + aCompound, 1.0 / 12) - 1) * 100),
            ["compound_day"] = Fmt((Math.Pow(1 + aCompound, 1.0 / 365) - 1) * 100),
        };
    }
}

//! 利率の変換（年利・月利・日利）。
//! v2: 利率を f64 で読まない。文字列が 10進の数の形（[0-9]+(\.[0-9]+)?）かを確かめ、数字の並びのまま扱う
//! （parse::<f64>() は "1e3"・"inf"・"NaN" も読む）。上限（年1000・月100・日1）は整数部と小数部の数字で正確に比べる。
//! …5 ちょうどになりうる値（単利の3つと、入力と同じ単位の複利）は、値 = 利率 x × n ÷ k（n, k は 1・12・365）を
//! 整数の計算で正確に四捨五入する（0.5 ちょうどは大きい方へ）:
//!   小数 d 桁に四捨五入した整数 = floor((floor(2n × x × 10^d) + k) ÷ 2k)  （k が整数なので内側の floor を先に取ってよい）
//!   桁 e（10^e ≤ 値 < 10^(e+1)）も「floor(n × x × 10^8) ≥ k × 10^(e+8)」で決める（e は -3〜2 だけ見ればよい。その外は d が 8 か 2）。
//! floor(c × x × 10^d)（c ≤ 730・d ≤ 8）は、x の整数部と小数 d 桁までを u128 の整数 A にし、それより下の桁 g = 0.ddd… は
//! 右の桁から「c × 数字 + 繰り上がり」を10で割って繰り上がりだけを求めて floor(c × g) を出し、c × A に足す。
//! u128 に入れるのは整数部（上限の確認のあと4桁まで）と小数8桁までなので、入力の小数が何桁あってもあふれず、
//! 末尾の0を落としたり桁を切り捨てたりする必要もない（切り捨てると、1/3・1/73 を含む割り切れない境目のすぐ上の入力が
//! 下に落ちて丸めが変わる）。
//! 入力と違う単位の複利（累乗・累乗根）は f64 で計算する（累乗根は無理数、整数の累乗も小数が10桁以上続き …5 ちょうどにならない）。
//! 利率が 0 なら複利も "0"。f64 で計算した複利が 0 以下になったら（c017 の 0.0000000000000000001% など、1 + r が 1 になる）"0" と書く。
//! v1 は f64 で 12.003 ÷ 12 = 1.00025 が 1.0002499999999999 になって c005 の simple_month が "1.0002"、
//! 0.33 × 365 ÷ 12 = 10.0375 が 10.037499999999… になって c006 の simple_month が "10.037"、
//! 月利 0.123455% を12乗してから12乗根で戻すと少し小さくなって c016 の compound_month が "0.12345" と出ていた（17件中14件）。

use crate::json::{obj, s, Value};

/// 検査済みの 10進の数。int は先頭の0を除いた整数部の数字（4桁以下）、frac は小数部の数字
struct Dec<'a> {
    int: u128,
    frac: &'a [u8],
}

enum Read<'a> {
    Ok(Dec<'a>),
    Invalid,
    OutOfRange,
}

fn read(text: &str, limit: u128) -> Read<'_> {
    let (int_part, frac_part) = match text.split_once('.') { Some((i, f)) => (i, Some(f)), None => (text, None) };
    let digits = |p: &str| !p.is_empty() && p.bytes().all(|b| b.is_ascii_digit());
    if !digits(int_part) || frac_part.is_some_and(|f| !digits(f)) {
        return Read::Invalid;
    }
    let frac = frac_part.unwrap_or("").as_bytes();
    let int_digits = int_part.trim_start_matches('0');
    if int_digits.len() > 4 {
        return Read::OutOfRange; // 10000 以上（上限は 1000 まで）
    }
    let int = int_digits.bytes().fold(0u128, |a, b| a * 10 + (b - b'0') as u128);
    if int > limit || (int == limit && frac.iter().any(|&b| b != b'0')) {
        return Read::OutOfRange;
    }
    Read::Ok(Dec { int, frac })
}

impl Dec<'_> {
    /// floor(c × x × 10^d)。c は小さい整数（730 まで）、d は 0〜10
    fn floor_scaled(&self, c: u128, d: usize) -> u128 {
        let mut a = self.int;
        for i in 0..d {
            a = a * 10 + self.frac.get(i).map_or(0, |&b| (b - b'0') as u128);
        }
        let mut carry = 0u128; // 右の桁から c × 0.ddd… の繰り上がりだけを求める
        for &b in self.frac.iter().skip(d).rev() {
            carry = (c * (b - b'0') as u128 + carry) / 10;
        }
        c * a + carry
    }

    fn is_zero(&self) -> bool {
        self.int == 0 && self.frac.iter().all(|&b| b == b'0')
    }

    /// x × n ÷ k を有効数字5桁で四捨五入（0.5 ちょうどは大きい方へ）して書く
    fn fmt_exact(&self, n: u128, k: u128) -> String {
        if self.is_zero() {
            return "0".into();
        }
        let scaled = self.floor_scaled(n, 8); // floor(n × x × 10^8)
        let e = (-3..=2).rev().find(|&e: &i32| scaled >= k * 10u128.pow((e + 8) as u32)).unwrap_or(-4);
        let d = digits(e);
        show((self.floor_scaled(2 * n, d) + k) / (2 * k), d)
    }
}

/// 10^e ≤ 値 < 10^(e+1) のときの小数の桁数（有効数字5桁・2以上8以下）
fn digits(e: i32) -> usize {
    (5 - e - 1).clamp(2, 8) as usize
}

/// m ÷ 10^d を書き、小数の最後の0と小数点を取る
fn show(m: u128, d: usize) -> String {
    let t = format!("{:0>w$}", m, w = d + 1);
    let (i, f) = t.split_at(t.len() - d);
    let f = f.trim_end_matches('0');
    if f.is_empty() { i.to_string() } else { format!("{i}.{f}") }
}

/// f64 の p を書く。…5 ちょうどにならない値だけに使う
fn fmt_float(p: f64) -> String {
    if p <= 0.0 {
        return "0".into(); // 利率がとても小さく、1 + r が 1 になったとき（正しく丸めても 0）
    }
    let d = digits(p.log10().floor() as i32);
    show((p * 10f64.powi(d as i32)).round() as u128, d)
}

pub fn convert(rate: &str, unit: &str) -> Result<Value, String> {
    let (n, limit) = match unit {
        "year" => (1u128, 1000),
        "month" => (12, 100),
        "day" => (365, 1),
        _ => return Ok(obj(vec![("error", s("invalid_input"))])),
    };
    let x = match read(rate, limit) {
        Read::Ok(x) => x,
        Read::Invalid => return Ok(obj(vec![("error", s("invalid_input"))])),
        Read::OutOfRange => return Ok(obj(vec![("error", s("out_of_range"))])),
    };
    let simple = [("simple_year", 1), ("simple_month", 12), ("simple_day", 365)];
    let mut out: Vec<(&str, Value)> = simple.iter().map(|&(name, k)| (name, s(x.fmt_exact(n, k)))).collect();
    let compound = [("compound_year", 1u128, 1.0), ("compound_month", 12, 12.0), ("compound_day", 365, 365.0)];
    if x.is_zero() {
        out.extend(compound.iter().map(|&(name, _, _)| (name, s("0"))));
        return Ok(obj(out));
    }
    let r: f64 = rate.parse().map_err(|_| "f64 に読めません".to_string())?; // 形は確かめ済み
    let g = (1.0 + r / 100.0).powf(n as f64); // 複利で1年に何倍になるか
    for (name, m, mf) in compound {
        let v = if m == n { x.fmt_exact(1, 1) } else { fmt_float((g.powf(1.0 / mf) - 1.0) * 100.0) };
        out.push((name, s(v)));
    }
    Ok(obj(out))
}

//! 利率の変換（年利・月利・日利）。
//! v1: 利率を f64 に読み（parse::<f64>()）、単利は割り算、複利は powf で累乗・累乗根を計算して、
//! 桁数を log10().floor() で決め、format!("{:.d$}") で書いてから最後の0を取る素直な書き方。

use crate::json::{obj, s, Value};

fn fmt(p: f64) -> String {
    if p == 0.0 {
        return "0".into();
    }
    let d = (5 - p.abs().log10().floor() as i32 - 1).clamp(2, 8) as usize;
    let t = format!("{:.d$}", p);
    if t.contains('.') { t.trim_end_matches('0').trim_end_matches('.').to_string() } else { t }
}

pub fn convert(rate: &str, unit: &str) -> Result<Value, String> {
    let (n, limit) = match unit {
        "year" => (1.0, 1000.0),
        "month" => (12.0, 100.0),
        "day" => (365.0, 1.0),
        _ => return Ok(obj(vec![("error", s("invalid_input"))])),
    };
    let Ok(raw) = rate.parse::<f64>() else {
        return Ok(obj(vec![("error", s("invalid_input"))]));
    };
    if raw < 0.0 {
        return Ok(obj(vec![("error", s("invalid_input"))]));
    }
    if raw > limit {
        return Ok(obj(vec![("error", s("out_of_range"))]));
    }
    let r = raw / 100.0;
    let a_simple = r * n;
    let a_compound = (1.0 + r).powf(n) - 1.0;
    Ok(obj(vec![
        ("simple_year", s(fmt(a_simple * 100.0))),
        ("simple_month", s(fmt(a_simple / 12.0 * 100.0))),
        ("simple_day", s(fmt(a_simple / 365.0 * 100.0))),
        ("compound_year", s(fmt(a_compound * 100.0))),
        ("compound_month", s(fmt(((1.0 + a_compound).powf(1.0 / 12.0) - 1.0) * 100.0))),
        ("compound_day", s(fmt(((1.0 + a_compound).powf(1.0 / 365.0) - 1.0) * 100.0))),
    ]))
}

# 利率の変換（年利・月利・日利）。
# v2: 利率の文字列が 10進の数の形（[0-9]+(\.[0-9]+)?）かを確かめてから Rational（正確な分数）で読む
# （Float()・Rational() は "1e3"・"0x10"・"1_000"・"1/2" も読むので、先に形を確かめる）。上限の比較も分数のまま。
# …5 ちょうどになりうる値（単利の3つと、入力と同じ単位の複利）は分数のまま、floor(x × 10^d + 1/2) で
# 正確に四捨五入する（0.5 ちょうどは大きい方へ）。桁 e も分数と 10 のべきの比較で決める。
# 入力と違う単位の複利（累乗・累乗根）は Float で計算する（累乗根は無理数、整数の累乗も小数が10桁以上続き …5 ちょうどにならない）。
# 利率が 0 なら複利も "0"。Float で計算した複利が 0 以下になったら（c017 の 0.0000000000000000001% など、
# 1 + r が 1 になる）"0" と書く。
# v1 の Float では 12.003 ÷ 12 = 1.00025 が 1.0002499999999999 になって c005 の simple_month が "1.0002"、
# 月利 0.123455% を12乗してから12乗根で戻すと少し小さくなって c016 の compound_month が "0.12345" と出ていた（17件中15件）。
# c006（0.33 × 365 ÷ 12 = 10.0375）は v1 でも通った。Float の値は 10.037499999999999644… だが、Ruby の format("%.3f") は
# これを "10.038" と書く（C の printf・Rust・Swift は "10.037"）。format("%.2f", 2.675) も "2.68"。
# Ruby の format は2進数の正確な値で丸めないことがあり、たまたま正しい答えになっただけ。

module Rate
  module_function

  DECIMAL = /\A[0-9]+(\.[0-9]+)?\z/
  N = { "year" => 1, "month" => 12, "day" => 365 }.freeze
  LIMIT = { "year" => 1000, "month" => 100, "day" => 1 }.freeze

  def read_decimal(s)
    s.is_a?(String) && DECIMAL.match?(s) ? Rational(s) : nil
  end

  # 10^e <= 値 < 10^(e+1) のときの小数の桁数（有効数字5桁・2以上8以下）
  def digits(e)
    (5 - e - 1).clamp(2, 8)
  end

  # n / 10^d を書き、小数の最後の0と小数点を取る
  def show(n, d)
    s = n.to_s.rjust(d + 1, "0")
    "#{s[0...-d]}.#{s[-d..]}".sub(/0+\z/, "").sub(/\.\z/, "")
  end

  # 正確な分数 x（0 以上）を四捨五入（0.5 ちょうどは大きい方へ）して書く
  def fmt_exact(x)
    return "0" if x.zero?

    e = 0
    e += 1 while x >= Rational(10)**(e + 1)
    e -= 1 while x < Rational(10)**e
    d = digits(e)
    show((x * 10**d + Rational(1, 2)).floor, d)
  end

  # Float の p を書く。…5 ちょうどにならない値だけに使う
  def fmt_float(p)
    return "0" if p <= 0 # 利率がとても小さく、1 + r が 1 になったとき（正しく丸めても 0）

    d = digits(Math.log10(p).floor)
    show((p * 10**d).round, d)
  end

  def convert(rate:, unit:)
    r = read_decimal(rate)
    return { "error" => "invalid_input" } if r.nil? || !N.key?(unit)
    return { "error" => "out_of_range" } if r > LIMIT[unit]

    n = N[unit]
    a_simple = r * n
    out = {
      "simple_year" => fmt_exact(a_simple),
      "simple_month" => fmt_exact(a_simple / 12),
      "simple_day" => fmt_exact(a_simple / 365)
    }
    return out.merge("compound_year" => "0", "compound_month" => "0", "compound_day" => "0") if r.zero?

    g = (1 + r.to_f / 100)**n # 複利で1年に何倍になるか
    out["compound_year"] = unit == "year" ? fmt_exact(r) : fmt_float((g - 1) * 100)
    out["compound_month"] = unit == "month" ? fmt_exact(r) : fmt_float((g**(1.0 / 12) - 1) * 100)
    out["compound_day"] = unit == "day" ? fmt_exact(r) : fmt_float((g**(1.0 / 365) - 1) * 100)
    out
  end
end

# 利率の変換（年利・月利・日利）。
# v1: 利率を Float に読み（Float()）、単利は割り算、複利は ** で累乗・累乗根を計算して、
# 桁数を Math.log10 の floor で決め、format("%.*f") で書いてから最後の0を取る素直な書き方。

module Rate
  module_function

  N = { "year" => 1, "month" => 12, "day" => 365 }.freeze
  LIMIT = { "year" => 1000, "month" => 100, "day" => 1 }.freeze

  def fmt(p)
    return "0" if p.zero?

    d = (5 - Math.log10(p.abs).floor - 1).clamp(2, 8)
    s = format("%.*f", d, p)
    s.include?(".") ? s.sub(/0+\z/, "").sub(/\.\z/, "") : s
  end

  def convert(rate:, unit:)
    return { "error" => "invalid_input" } unless N.key?(unit)

    raw = Float(rate, exception: false)
    return { "error" => "invalid_input" } if raw.nil? || raw.negative?
    return { "error" => "out_of_range" } if raw > LIMIT[unit]

    n = N[unit]
    r = raw / 100
    a_simple = r * n
    a_compound = (1 + r)**n - 1
    {
      "simple_year" => fmt(a_simple * 100),
      "simple_month" => fmt(a_simple / 12 * 100),
      "simple_day" => fmt(a_simple / 365 * 100),
      "compound_year" => fmt(a_compound * 100),
      "compound_month" => fmt(((1 + a_compound)**(1.0 / 12) - 1) * 100),
      "compound_day" => fmt(((1 + a_compound)**(1.0 / 365) - 1) * 100)
    }
  end
end

import java.math.BigDecimal
import java.math.BigInteger
import kotlin.math.floor
import kotlin.math.log10
import kotlin.math.pow
import kotlin.math.roundToLong

// 利率の変換（年利・月利・日利）。
// v2: 利率の文字列を BigDecimal（10進のまま）で読み、上限（年1000・月100・日1）とも正確に比べる。
// …5 ちょうどになりうる値（単利の3つと、入力と同じ単位の複利）は「分子 ÷ 分母」の整数（BigInteger）のまま扱い、
// 桁 e（10^e ≤ 値 < 10^(e+1)）も整数の比較で決めて、floor((2 × 分子 × 10^d + 分母) ÷ (2 × 分母)) で
// 四捨五入する（0.5 ちょうどは大きい方へ）。÷12・÷365 は割り切れないので、BigDecimal の divide に MathContext を
// 渡すと途中で一度丸まって二重の丸めになりうる。分数のままなら丸めは最後の1回だけ。
// 入力と違う単位の複利（累乗・累乗根）は Double で計算する。累乗根は無理数になり、整数の累乗も小数が10桁以上続くので、
// 有効数字5桁の …5 ちょうどにはならない。利率が 0 なら複利も "0"。
// v1（Double・"%.${d}f".format）は16件中14件。c005 の単利の月利 12.003 ÷ 12 = 1.00025 が Double では
// 1.0002499999999999 になって "1.0002"（正しくは "1.0003"）、c016 の月利 0.123455% を12乗してから12乗根で戻すと
// 0.123455 より少し小さくなって compound_month が "0.12345"（正しくは "0.12346"）と出た。
// c006（0.33 × 365 ÷ 12 = 10.0375）は Double では 10.03749999… だが、format は Java の String.format と同じく
// Double の最短の10進表記 "10.0375" を HALF_UP で丸めるので、たまたま "10.038" と正しく出ていた。
// toDoubleOrNull は "1e2"・"NaN" も読むので、入力は 10進の数の形かを先に確かめる。

private val DECIMAL = Regex("[0-9]+(\\.[0-9]+)?")
private val N = mapOf("year" to 1, "month" to 12, "day" to 365)
private val LIMIT = mapOf("year" to BigDecimal(1000), "month" to BigDecimal(100), "day" to BigDecimal.ONE)

/** 10進の数の文字列を BigDecimal に。形が違えば null */
private fun dec(s: String): BigDecimal? = if (DECIMAL.matches(s)) BigDecimal(s) else null

/** 10^e ≤ 値 < 10^(e+1) のときの小数の桁数（有効数字5桁・2以上8以下） */
private fun digits(e: Int): Int = (5 - e - 1).coerceIn(2, 8)

/** num ÷ den（どちらも 0 より大きい）と 10^e を比べる */
private fun cmpPow10(num: BigInteger, den: BigInteger, e: Int): Int =
    if (e >= 0) num.compareTo(den * BigInteger.TEN.pow(e)) else (num * BigInteger.TEN.pow(-e)).compareTo(den)

/** q ÷ 10^d を書き、小数の最後の0と小数点を取る */
private fun show(q: BigInteger, d: Int): String {
    val s = q.toString().padStart(d + 1, '0')
    return (s.dropLast(d) + "." + s.takeLast(d)).trimEnd('0').trimEnd('.')
}

/** 正確な値 num ÷ den（0 以上）を四捨五入（0.5 ちょうどは大きい方へ）して書く */
private fun fmtExact(num: BigInteger, den: BigInteger): String {
    if (num.signum() == 0) return "0"
    var e = 0
    while (cmpPow10(num, den, e + 1) >= 0) e++
    while (cmpPow10(num, den, e) < 0) e--
    val d = digits(e)
    val two = BigInteger.TWO
    return show((num * BigInteger.TEN.pow(d) * two + den) / (den * two), d)
}

/** Double の p を書く。…5 ちょうどにならない値だけに使う */
private fun fmtFloat(p: Double): String {
    if (p <= 0) return "0" // 1 + r ÷ 100 が Double で 1 になるほど小さい利率
    val d = digits(floor(log10(p)).toInt())
    return show(BigInteger.valueOf((p * 10.0.pow(d)).roundToLong()), d)
}

fun convertRate(rate: String, unit: String): Map<String, Any?> {
    val r = dec(rate)
    val n = N[unit]
    if (n == null || r == null) return linkedMapOf("error" to "invalid_input")
    if (r > LIMIT.getValue(unit)) return linkedMapOf("error" to "out_of_range")
    // r = u ÷ p（scale ≥ 0。正規表現で指数を読まないので）
    val u = r.unscaledValue()
    val p = BigInteger.TEN.pow(r.scale())
    val aSimple = u * BigInteger.valueOf(n.toLong()) // 単利の年利（%）= aSimple ÷ p
    val out = linkedMapOf<String, Any?>(
        "simple_year" to fmtExact(aSimple, p),
        "simple_month" to fmtExact(aSimple, p * BigInteger.valueOf(12)),
        "simple_day" to fmtExact(aSimple, p * BigInteger.valueOf(365)),
    )
    if (r.signum() == 0) {
        out["compound_year"] = "0"
        out["compound_month"] = "0"
        out["compound_day"] = "0"
        return out
    }
    val same = fmtExact(u, p)
    val g = (1 + r.toDouble() / 100).pow(n) // 複利で1年に何倍になるか
    out["compound_year"] = if (unit == "year") same else fmtFloat((g - 1) * 100)
    out["compound_month"] = if (unit == "month") same else fmtFloat((g.pow(1.0 / 12) - 1) * 100)
    out["compound_day"] = if (unit == "day") same else fmtFloat((g.pow(1.0 / 365) - 1) * 100)
    return out
}

import kotlin.math.abs
import kotlin.math.floor
import kotlin.math.log10
import kotlin.math.pow

// 利率の変換（年利・月利・日利）。
// v1: 利率を Double に読み、単利は割り算、複利は pow で累乗・累乗根を計算して、
// 桁数を log10 の floor で決め、"%.${d}f".format(x) で書いてから最後の0を取る素直な書き方。

private val N = mapOf("year" to 1, "month" to 12, "day" to 365)
private val LIMIT = mapOf("year" to 1000.0, "month" to 100.0, "day" to 1.0)

private fun fmt(p: Double): String {
    if (p == 0.0) return "0"
    val d = (5 - floor(log10(abs(p))).toInt() - 1).coerceIn(2, 8)
    val s = "%.${d}f".format(p)
    return if ('.' in s) s.trimEnd('0').trimEnd('.') else s
}

fun convertRate(rate: String, unit: String): Map<String, Any?> {
    val n = N[unit] ?: return linkedMapOf("error" to "invalid_input")
    val raw = rate.toDoubleOrNull()
    if (raw == null || raw < 0) return linkedMapOf("error" to "invalid_input")
    if (raw > LIMIT.getValue(unit)) return linkedMapOf("error" to "out_of_range")
    val r = raw / 100
    val aSimple = r * n
    val aCompound = (1 + r).pow(n) - 1
    return linkedMapOf(
        "simple_year" to fmt(aSimple * 100),
        "simple_month" to fmt(aSimple / 12 * 100),
        "simple_day" to fmt(aSimple / 365 * 100),
        "compound_year" to fmt(aCompound * 100),
        "compound_month" to fmt(((1 + aCompound).pow(1.0 / 12) - 1) * 100),
        "compound_day" to fmt(((1 + aCompound).pow(1.0 / 365) - 1) * 100),
    )
}