数を見やすく — 3桁区切りと小数第2位の四捨五入

<?php
// 受け取った数を、小数第2位までに四捨五入して、3桁ごとにカンマを入れて出す
// (float) では大きい数の下の桁が失われるので、文字列のまま整数部と小数部に分けて計算する
$s = $argv[1];
$negative = str_starts_with($s, '-');
$parts = explode('.', ltrim($s, '-'));
$frac = str_pad($parts[1] ?? '', 3, '0');

// 「1234567.891」なら "123456789"（0.01 が何個か）。PHP の整数に入らない桁数でも扱えるよう、文字列のまま持つ
$digits = $parts[0] . substr($frac, 0, 2);
if ($frac[2] >= '5') {
    // 小数第3位が 5 以上なら、0 から遠いほうへ繰り上げる。筆算と同じく、下の桁から 9 を 0 にして繰り上げる
    $i = strlen($digits) - 1;
    while ($i >= 0 && $digits[$i] === '9') {
        $digits[$i] = '0';
        $i--;
    }
    if ($i < 0) {
        $digits = '1' . $digits;
    } else {
        $digits[$i] = (string) ((int) $digits[$i] + 1);
    }
}

$digits = str_pad(ltrim($digits, '0'), 3, '0', STR_PAD_LEFT); // 先頭の 0 を取り、0.0x のときは 0 を補う
$intStr = preg_replace('/(\d)(?=(\d{3})+\z)/', '$1,', substr($digits, 0, -2)); // 右から3桁ごとにカンマ
$sign = $negative && trim($digits, '0') !== '' ? '-' : ''; // 0.00 にマイナスは付けない
echo $sign . $intStr . '.' . substr($digits, -2) . "\n";

# 受け取った数を、小数第2位までに四捨五入して、3桁ごとにカンマを入れて出す
import sys
from decimal import ROUND_HALF_UP, Decimal

# float は 1.005 を少し小さい数として持つので、10進数のまま計算する Decimal に、文字列から直す
d = Decimal(sys.argv[1])
# ROUND_HALF_UP は「ちょうど半分は 0 から遠いほうへ」（日本の四捨五入）
d = d.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
if d.is_zero():
    d = abs(d)  # -0.001 は -0.00 になるので、マイナスを取る
print(f"{d:,.2f}")

// 受け取った数を、小数第2位までに四捨五入して、3桁ごとにカンマを入れて出す
// float64 は 1.005 を少し小さい数として持つので、文字列のまま整数部と小数部に分けて計算する
package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {
	s := os.Args[1]
	negative := strings.HasPrefix(s, "-")
	intPart, fracPart, _ := strings.Cut(strings.TrimPrefix(s, "-"), ".")
	frac := fracPart + "000"

	// 「1234567.891」なら "123456789"（0.01 が何個か）。int64 に入らない桁数でも扱えるよう、文字列のまま持つ
	digits := []byte(intPart + frac[:2])
	if frac[2] >= '5' {
		// 小数第3位が 5 以上なら、0 から遠いほうへ繰り上げる。筆算と同じく、下の桁から 9 を 0 にして繰り上げる
		i := len(digits) - 1
		for i >= 0 && digits[i] == '9' {
			digits[i] = '0'
			i--
		}
		if i < 0 {
			digits = append([]byte{'1'}, digits...)
		} else {
			digits[i]++
		}
	}

	d := strings.TrimLeft(string(digits), "0")
	for len(d) < 3 { // 0.0x のときは、先頭に 0 を補う
		d = "0" + d
	}
	intDigits := d[:len(d)-2]

	// 右から3桁ごとにカンマを入れる
	var b strings.Builder
	for i, c := range intDigits {
		if i > 0 && (len(intDigits)-i)%3 == 0 {
			b.WriteString(",")
		}
		b.WriteRune(c)
	}

	sign := ""
	if negative && strings.Trim(d, "0") != "" { // 0.00 にマイナスは付けない
		sign = "-"
	}
	fmt.Printf("%s%s.%s\n", sign, b.String(), d[len(d)-2:])
}

// 受け取った数を、小数第2位までに四捨五入して、3桁ごとにカンマを入れて出す
// 普通の数（Number）は 1.005 を少し小さい数として持つので、文字列のまま整数部と小数部に分けて計算する
const s = process.argv[2];
const negative = s.startsWith("-");
const [intPart, fracPart = ""] = s.replace("-", "").split(".");
const frac = fracPart.padEnd(3, "0");

// 「1234567.891」なら 123456789（0.01 が何個か）。大きい数でも1の位まで正しく持てる BigInt を使う
let cents = BigInt(intPart + frac.slice(0, 2));
if (frac[2] >= "5") {
  cents += 1n; // 小数第3位が 5 以上なら、0 から遠いほうへ繰り上げる
}

const digits = cents.toString().padStart(3, "0");
const intStr = digits.slice(0, -2).replace(/\B(?=(\d{3})+$)/g, ","); // 右から3桁ごとにカンマ
const sign = negative && cents !== 0n ? "-" : ""; // 0.00 にマイナスは付けない
console.log(`${sign}${intStr}.${digits.slice(-2)}`);

// 受け取った数を小数第2位までに四捨五入して、3桁ごとにカンマを入れて出す
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Locale;

public class FormatNumber {
    public static void main(String[] args) {
        // double は 1.005 をぴったり持てないので、10進数のまま持つ BigDecimal で四捨五入する（HALF_UP は 0 から遠いほうへ）
        BigDecimal x = new BigDecimal(args[0]).setScale(2, RoundingMode.HALF_UP);
        // カンマと小数点の記号が国の設定で変わらないように、Locale.ROOT を指定する
        System.out.println(String.format(Locale.ROOT, "%,.2f", x));
    }
}

// 受け取った数を小数第2位までに四捨五入して、3桁ごとにカンマを入れて出す
using System.Globalization;

// double は 1.005 をぴったり持てないので、10進数のまま持つ decimal を使う
decimal x = decimal.Parse(args[0], CultureInfo.InvariantCulture);
// Math.Round は何も指定しないと「偶数のほうへ」丸めるので、AwayFromZero（0 から遠いほうへ）を指定する
x = Math.Round(x, 2, MidpointRounding.AwayFromZero);
// カンマと小数点の記号が国の設定で変わらないように、InvariantCulture を指定する
Console.WriteLine(x.ToString("N2", CultureInfo.InvariantCulture));

// 受け取った数を小数第2位までに四捨五入して、3桁ごとにカンマを入れて出す

// 数字の列に1を足す（"199" → "200"、"99" → "100"）
fn add_one(digits: &str) -> String {
    let mut out: Vec<char> = digits.chars().collect();
    let mut i = out.len();
    loop {
        if i == 0 {
            out.insert(0, '1');
            break;
        }
        i -= 1;
        if out[i] == '9' {
            out[i] = '0';
        } else {
            out[i] = char::from_digit(out[i].to_digit(10).unwrap() + 1, 10).unwrap();
            break;
        }
    }
    out.into_iter().collect()
}

fn main() {
    let args: Vec<String> = std::env::args().collect();
    // f64 は 1.005 をぴったり持てないので、文字列のまま10進数の桁を見て四捨五入する
    let (negative, s) = match args[1].strip_prefix('-') {
        Some(rest) => (true, rest.to_string()),
        None => (false, args[1].clone()),
    };
    let (int_part, frac_part) = s.split_once('.').unwrap_or((&s, ""));
    let frac = format!("{:0<3}", frac_part); // 小数を3桁以上にそろえる（"5" → "500"）
    // 整数部と小数2桁をつないだ数字の列（1.005 なら "100"）。小数第3位が5以上なら1を足す（0 から遠いほうへ）
    let mut digits = format!("{}{}", int_part, &frac[..2]);
    if frac.as_bytes()[2] >= b'5' {
        digits = add_one(&digits);
    }
    let (int_digits, frac2) = digits.split_at(digits.len() - 2);
    let int_digits = int_digits.trim_start_matches('0');
    let int_digits = if int_digits.is_empty() { "0" } else { int_digits };
    // 整数部に3桁ごとのカンマを入れる
    let mut with_commas = String::new();
    for (i, c) in int_digits.chars().enumerate() {
        if i > 0 && (int_digits.len() - i) % 3 == 0 {
            with_commas.push(',');
        }
        with_commas.push(c);
    }
    // 四捨五入して 0 になったときは「-0.00」にしない
    let sign = if negative && (int_digits != "0" || frac2 != "00") { "-" } else { "" };
    println!("{}{}.{}", sign, with_commas, frac2);
}

# 受け取った数を、小数第2位までに四捨五入して、3桁ごとにカンマを入れて出す
# to_f（小数）は 1.005 を少し小さい数として持つので、文字列のまま整数部と小数部に分けて計算する
s = ARGV[0]
negative = s.start_with?("-")
int_part, frac_part = s.delete_prefix("-").split(".")
frac = (frac_part || "").ljust(3, "0")

# 「1234567.891」なら 123456789（0.01 が何個か）。Ruby の整数には上限が無い
cents = Integer(int_part + frac[0, 2], 10)
cents += 1 if frac[2] >= "5" # 小数第3位が 5 以上なら、0 から遠いほうへ繰り上げる

digits = cents.to_s.rjust(3, "0")
int_str = digits[0..-3].gsub(/(\d)(?=(\d{3})+\z)/, '\1,') # 右から3桁ごとにカンマ
sign = negative && cents != 0 ? "-" : "" # 0.00 にマイナスは付けない
puts "#{sign}#{int_str}.#{digits[-2..]}"

// 受け取った数を小数第2位までに四捨五入して、3桁ごとにカンマを入れて出す
import java.math.BigDecimal
import java.math.RoundingMode
import java.util.Locale

fun main(args: Array<String>) {
    // Double は 1.005 をぴったり持てないので、10進数のまま持つ BigDecimal で四捨五入する（HALF_UP は 0 から遠いほうへ）
    val x = BigDecimal(args[0]).setScale(2, RoundingMode.HALF_UP)
    // カンマと小数点の記号が国の設定で変わらないように、Locale.ROOT を指定する
    println("%,.2f".format(Locale.ROOT, x))
}

// 受け取った数を小数第2位までに四捨五入して、3桁ごとにカンマを入れて出す

// 数字の列に1を足す（"199" → "200"、"99" → "100"）
func addOne(_ digits: String) -> String {
    var out = Array(digits)
    var i = out.count
    while true {
        if i == 0 {
            out.insert("1", at: 0)
            break
        }
        i -= 1
        if out[i] == "9" {
            out[i] = "0"
        } else {
            out[i] = Character(String(out[i].wholeNumberValue! + 1))
            break
        }
    }
    return String(out)
}

// Double は 1.005 をぴったり持てないので、文字列のまま10進数の桁を見て四捨五入する
var s = CommandLine.arguments[1]
let negative = s.hasPrefix("-")
if negative {
    s.removeFirst()
}
let parts = s.split(separator: ".", omittingEmptySubsequences: false)
let intPart = String(parts[0])
var frac = parts.count > 1 ? String(parts[1]) : ""
while frac.count < 3 {
    frac += "0"  // 小数を3桁以上にそろえる（"5" → "500"）
}
// 整数部と小数2桁をつないだ数字の列（1.005 なら "100"）。小数第3位が5以上なら1を足す（0 から遠いほうへ）
var digits = intPart + frac.prefix(2)
if Array(frac)[2] >= "5" {
    digits = addOne(digits)
}
var intDigits = String(digits.dropLast(2).drop(while: { $0 == "0" }))
if intDigits.isEmpty {
    intDigits = "0"
}
let frac2 = String(digits.suffix(2))
// 整数部に3桁ごとのカンマを入れる
var withCommas = ""
for (i, c) in intDigits.enumerated() {
    if i > 0 && (intDigits.count - i) % 3 == 0 {
        withCommas += ","
    }
    withCommas.append(c)
}
// 四捨五入して 0 になったときは「-0.00」にしない
let sign = negative && (intDigits != "0" || frac2 != "00") ? "-" : ""
print("\(sign)\(withCommas).\(frac2)")