大きな数の表記（3桁区切り・万進・英語）

<?php
declare(strict_types=1);

/**
 * 大きな数の表記（3桁区切り・万進・英語）。
 * v2: GMP（任意精度の整数）で計算する。(int) は 64ビットの上限で黙って頭打ちになり、
 * number_format も int / float しか受け取れないので、区切りは数字の文字列に対して自分で入れる。
 * @return array{plain:string, ja:string, en:string}
 */
function commafy(string $digits): string
{
    return preg_replace('/\B(?=(\d{3})+(?!\d))/', ',', $digits);
}

function enScale(GMP $a): string
{
    static $units = [18 => 'quintillion', 15 => 'quadrillion', 12 => 'trillion', 9 => 'billion', 6 => 'million', 3 => 'thousand'];
    if ($a < 1000) {
        return commafy(gmp_strval($a));
    }
    foreach ($units as $e => $word) {
        if ($a >= gmp_pow(10, $e)) {
            break;
        }
    }
    $d = gmp_pow(10, $e);
    [$q, $r] = gmp_div_qr($a * 1000000, $d);
    if ($r * 2 >= $d) {
        $q += 1; // 四捨五入（0.5 ちょうどは繰り上げ）
    }
    [$ip, $fp] = gmp_div_qr($q, 1000000);
    $frac = rtrim(str_pad(gmp_strval($fp), 6, '0', STR_PAD_LEFT), '0');
    return gmp_strval($ip) . ($frac !== '' ? '.' . $frac : '') . ' ' . $word;
}

function convertNumber(string $value): array
{
    $ja = ['', '万', '億', '兆', '京', '垓', '秭', '穣', '溝'];
    $n = gmp_init($value, 10);
    $sign = gmp_sign($n) < 0 ? '-' : '';
    $a = gmp_abs($n);
    $parts = [];
    for ($i = 0, $rest = $a; $rest > 0; $i++) {
        [$rest, $g] = gmp_div_qr($rest, 10000);
        if ($g > 0) {
            array_unshift($parts, gmp_strval($g) . $ja[$i]);
        }
    }
    return ['plain' => $sign . commafy(gmp_strval($a)), 'ja' => $sign . (implode('', $parts) ?: '0'), 'en' => $sign . enScale($a)];
}

<?php
declare(strict_types=1);

/**
 * 大きな数の表記（3桁区切り・万進・英語）。
 * v1: よくある書き方（(int) で読み、number_format で区切り、英語表記は割り算して round($x, 6)）。
 * @return array{plain:string, ja:string, en:string}
 */
function convertNumber(string $value): array
{
    $ja = ['', '万', '億', '兆', '京', '垓', '秭', '穣', '溝'];
    $enUnits = [18 => 'quintillion', 15 => 'quadrillion', 12 => 'trillion', 9 => 'billion', 6 => 'million', 3 => 'thousand'];
    $n = (int) $value;
    $sign = $n < 0 ? '-' : '';
    $a = abs($n);
    $parts = [];
    for ($i = 0, $rest = $a; $rest > 0; $i++) {
        $g = $rest % 10000;
        $rest = intdiv($rest, 10000);
        if ($g) {
            array_unshift($parts, $g . $ja[$i]);
        }
    }
    if ($a < 1000) {
        $en = number_format($a);
    } else {
        foreach ($enUnits as $e => $word) {
            if ($a >= 10 ** $e) {
                break;
            }
        }
        $x = round($a / 10 ** $e, 6);
        $en = rtrim(rtrim(number_format($x, 6, '.', ''), '0'), '.') . ' ' . $word;
    }
    return ['plain' => number_format($n), 'ja' => $sign . (implode('', $parts) ?: '0'), 'en' => $sign . $en];
}

"""大きな数の表記（3桁区切り・万進・英語）。

v2: int（桁数の上限がない）のまま計算し、英語表記の丸めも整数で行う（a / 10**e の小数は使わない）。
"""
JA = ["", "万", "億", "兆", "京", "垓", "秭", "穣", "溝"]
EN = [(18, "quintillion"), (15, "quadrillion"), (12, "trillion"), (9, "billion"), (6, "million"), (3, "thousand")]


def _en(a: int) -> str:
    if a < 1000:
        return f"{a:,}"
    e, word = next((e, w) for e, w in EN if a >= 10**e)
    q, r = divmod(a * 10**6, 10**e)  # 10^-6 単位の商と余り
    if r * 2 >= 10**e:               # 四捨五入（0.5 ちょうどは繰り上げ）
        q += 1
    ip, fp = divmod(q, 10**6)
    frac = f"{fp:06d}".rstrip("0")
    return f"{ip}" + (f".{frac}" if frac else "") + f" {word}"


def convert(value: str) -> dict:
    n = int(value)
    sign = "-" if n < 0 else ""
    a = abs(n)
    parts, i, rest = [], 0, a
    while rest > 0:
        rest, g = divmod(rest, 10000)
        if g:
            parts.insert(0, f"{g}{JA[i]}")
        i += 1
    return {"plain": f"{n:,}", "ja": sign + ("".join(parts) or "0"), "en": sign + _en(a)}

"""大きな数の表記（3桁区切り・万進・英語）。

v1: よくある書き方（int() で読み、英語表記は割り算して round(x, 6)）。
"""
JA = ["", "万", "億", "兆", "京", "垓", "秭", "穣", "溝"]
EN = [(18, "quintillion"), (15, "quadrillion"), (12, "trillion"), (9, "billion"), (6, "million"), (3, "thousand")]


def convert(value: str) -> dict:
    n = int(value)
    sign = "-" if n < 0 else ""
    a = abs(n)
    parts, i, rest = [], 0, a
    while rest > 0:
        rest, g = divmod(rest, 10000)
        if g:
            parts.insert(0, f"{g}{JA[i]}")
        i += 1
    ja = "".join(parts) or "0"
    if a < 1000:
        en = f"{a:,}"
    else:
        e, word = next((e, w) for e, w in EN if a >= 10**e)
        x = round(a / 10**e, 6)
        en = f"{x:f}".rstrip("0").rstrip(".") + " " + word
    return {"plain": f"{n:,}", "ja": sign + ja, "en": sign + en}

package main

import (
	"fmt"
	"math/big"
	"strings"
)

var jaUnits = []string{"", "万", "億", "兆", "京", "垓", "秭", "穣", "溝"}

var enUnits = []struct {
	e    int64
	word string
}{{18, "quintillion"}, {15, "quadrillion"}, {12, "trillion"}, {9, "billion"}, {6, "million"}, {3, "thousand"}}

func commafy(s string) string {
	var b strings.Builder
	for i, c := range s {
		if i > 0 && (len(s)-i)%3 == 0 {
			b.WriteByte(',')
		}
		b.WriteRune(c)
	}
	return b.String()
}

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

func enScale(a *big.Int) string {
	if a.Cmp(big.NewInt(1000)) < 0 {
		return commafy(a.String())
	}
	for _, u := range enUnits {
		d := pow10(u.e)
		if a.Cmp(d) < 0 {
			continue
		}
		q, r := new(big.Int).QuoRem(new(big.Int).Mul(a, pow10(6)), d, new(big.Int))
		if new(big.Int).Lsh(r, 1).Cmp(d) >= 0 { // 四捨五入（0.5 ちょうどは繰り上げ）
			q.Add(q, big.NewInt(1))
		}
		ip, fp := new(big.Int).QuoRem(q, pow10(6), new(big.Int))
		frac := strings.TrimRight(fmt.Sprintf("%06s", fp.String()), "0")
		if frac != "" {
			frac = "." + frac
		}
		return ip.String() + frac + " " + u.word
	}
	return commafy(a.String())
}

// Convert は大きな数を3つの表記にする。
// v2: math/big.Int で読む（strconv.ParseInt は 64ビットを超えるとエラー）。英語表記の丸めも整数で行う。
func Convert(value string) (map[string]string, error) {
	n, ok := new(big.Int).SetString(value, 10)
	if !ok {
		return nil, fmt.Errorf("invalid integer: %q", value)
	}
	sign := ""
	if n.Sign() < 0 {
		sign = "-"
	}
	a := new(big.Int).Abs(n)
	var parts []string
	rest, g, tenK := new(big.Int).Set(a), new(big.Int), big.NewInt(10000)
	for i := 0; rest.Sign() > 0; i++ {
		rest.QuoRem(rest, tenK, g)
		if g.Sign() != 0 {
			parts = append([]string{g.String() + jaUnits[i]}, parts...)
		}
	}
	ja := strings.Join(parts, "")
	if ja == "" {
		ja = "0"
	}
	return map[string]string{"plain": sign + commafy(a.String()), "ja": sign + ja, "en": sign + enScale(a)}, nil
}

package main

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

var jaUnits = []string{"", "万", "億", "兆", "京", "垓", "秭", "穣", "溝"}

var enUnits = []struct {
	e    int
	word string
}{{18, "quintillion"}, {15, "quadrillion"}, {12, "trillion"}, {9, "billion"}, {6, "million"}, {3, "thousand"}}

func commafy(s string) string {
	var b strings.Builder
	for i, c := range s {
		if i > 0 && (len(s)-i)%3 == 0 {
			b.WriteByte(',')
		}
		b.WriteRune(c)
	}
	return b.String()
}

// Convert は大きな数を3つの表記にする。
// v1: よくある書き方（strconv.ParseInt で int64 に読み、英語表記は float64 で割って FormatFloat(x, 'f', 6)）。
func Convert(value string) (map[string]string, error) {
	n, err := strconv.ParseInt(value, 10, 64)
	if err != nil {
		return nil, err
	}
	sign := ""
	a := n
	if n < 0 {
		sign, a = "-", -n
	}
	var parts []string
	for i, rest := 0, a; rest > 0; i++ {
		if g := rest % 10000; g != 0 {
			parts = append([]string{fmt.Sprintf("%d%s", g, jaUnits[i])}, parts...)
		}
		rest /= 10000
	}
	ja := strings.Join(parts, "")
	if ja == "" {
		ja = "0"
	}
	plainAbs := commafy(strconv.FormatInt(a, 10))
	en := plainAbs
	if a >= 1000 {
		for _, u := range enUnits {
			if float64(a) >= math.Pow10(u.e) {
				x := strconv.FormatFloat(float64(a)/math.Pow10(u.e), 'f', 6, 64)
				en = strings.TrimRight(strings.TrimRight(x, "0"), ".") + " " + u.word
				break
			}
		}
	}
	return map[string]string{"plain": sign + plainAbs, "ja": sign + ja, "en": sign + en}, nil
}

// 大きな数の表記（3桁区切り・万進・英語）。
// v2: BigInt で読む（Number() は 2^53 を超えると桁が変わる）。英語表記の丸めも BigInt の整数で行う。

const JA = ["", "万", "億", "兆", "京", "垓", "秭", "穣", "溝"];
const EN = [[18n, "quintillion"], [15n, "quadrillion"], [12n, "trillion"], [9n, "billion"], [6n, "million"], [3n, "thousand"]];
const commafy = (digits) => digits.replace(/\B(?=(\d{3})+(?!\d))/g, ",");

function en(a) {
  if (a < 1000n) return commafy(a.toString());
  const [e, word] = EN.find(([e]) => a >= 10n ** e);
  const d = 10n ** e;
  let q = (a * 10n ** 6n) / d; // 10^-6 単位（切り捨て）
  if (((a * 10n ** 6n) % d) * 2n >= d) q += 1n; // 四捨五入
  const ip = q / 1000000n;
  const frac = (q % 1000000n).toString().padStart(6, "0").replace(/0+$/, "");
  return `${ip}${frac ? "." + frac : ""} ${word}`;
}

export function convert({ value }) {
  const n = BigInt(value);
  const sign = n < 0n ? "-" : "";
  const a = n < 0n ? -n : n;
  const parts = [];
  let rest = a;
  for (let i = 0; rest > 0n; i++) {
    const g = rest % 10000n;
    rest /= 10000n;
    if (g) parts.unshift(`${g}${JA[i]}`);
  }
  return { plain: sign + commafy(a.toString()), ja: sign + (parts.join("") || "0"), en: sign + en(a) };
}

// 大きな数の表記（3桁区切り・万進・英語）。
// v1: よくある書き方（Number() で読み、toLocaleString で区切り、英語表記は割り算して toFixed(6)）。

const JA = ["", "万", "億", "兆", "京", "垓", "秭", "穣", "溝"];
const EN = [[18, "quintillion"], [15, "quadrillion"], [12, "trillion"], [9, "billion"], [6, "million"], [3, "thousand"]];

export function convert({ value }) {
  const n = Number(value);
  const sign = n < 0 ? "-" : "";
  const a = Math.abs(n);
  const parts = [];
  let rest = a;
  for (let i = 0; rest > 0; i++) {
    const g = rest % 10000;
    rest = Math.floor(rest / 10000);
    if (g) parts.unshift(`${g}${JA[i]}`);
  }
  let en;
  if (a < 1000) {
    en = a.toLocaleString("en-US");
  } else {
    const [e, word] = EN.find(([e]) => a >= 10 ** e);
    en = (a / 10 ** e).toFixed(6).replace(/\.?0+$/, "") + " " + word;
  }
  return { plain: n.toLocaleString("en-US"), ja: sign + (parts.join("") || "0"), en: sign + en };
}