データ通信量（ギガ）の目安

<?php
declare(strict_types=1);

use BcMath\Number;

/**
 * データ通信量（ギガ）の目安。
 * v2: 十進（BcMath\Number）で計算し、四捨五入は RoundingMode::HalfAwayFromZero で明示する。
 * float だと 0.08 × 3.5 × 25 が 7.000000000000001 になり、7GB プランの境目を越えてしまう。
 * 割り算（3 ÷ 0.07 など）は割り切れないことがあるので、四捨五入に影響しない桁数（30桁）まで出す。
 */
function fmtData(Number $gb): string
{
    $r = fn (Number $x, int $p): string => $x->round($p, RoundingMode::HalfAwayFromZero)->value;
    if ($gb >= 10) {
        return $r($gb, 0) . ' GB';
    }
    if ($gb >= 1) {
        return oneDecimal($gb) . ' GB';
    }
    $mb = $gb * 1024;
    return $mb >= 100 ? $r($mb, 0) . ' MB' : oneDecimal($mb) . ' MB';
}

/** 小数第1位に四捨五入し、必ず小数1桁で表す（"7.0"） */
function oneDecimal(Number $x): string
{
    $t = (int) ($x * 10)->round(0, RoundingMode::HalfAwayFromZero)->value;
    return intdiv($t, 10) . '.' . $t % 10;
}

function fmtHours(Number $h): string
{
    if ($h >= 100) {
        return $h->round(0, RoundingMode::HalfAwayFromZero)->value . ' 時間';
    }
    $whole = (int) $h->floor()->value;
    $mins = (int) (($h - $whole) * 60)->round(0, RoundingMode::HalfAwayFromZero)->value;
    if ($mins === 60) {
        $whole++;
        $mins = 0;
    }
    if ($whole === 0) {
        return "$mins 分";
    }
    return $mins === 0 ? "$whole 時間" : "$whole 時間 $mins 分";
}

/** @return array<string, string> */
function calcUsage(string $perHour, string $hours, string $days): array
{
    $p = new Number($perHour);
    $perDay = $p * new Number($hours);
    $monthly = $perDay * new Number($days);
    $plan = '大容量・無制限プランが目安';
    foreach ([3, 5, 7, 10, 20, 30, 50, 100] as $t) {
        if ($monthly <= $t) {
            $plan = "{$t}GB プランが目安";
            break;
        }
    }
    return ['monthly' => fmtData($monthly), 'per_day' => fmtData($perDay),
        'hours_3gb' => fmtHours((new Number(3))->div($p, 30)), 'hours_20gb' => fmtHours((new Number(20))->div($p, 30)), 'plan' => $plan];
}

<?php
declare(strict_types=1);

/**
 * データ通信量（ギガ）の目安。
 * v1: よくある書き方（float で計算し、round と number_format で表示）。
 */
function fmtData(float $gb): string
{
    if ($gb >= 10) {
        return number_format($gb, 0, '.', '') . ' GB';
    }
    if ($gb >= 1) {
        return number_format($gb, 1, '.', '') . ' GB';
    }
    $mb = $gb * 1024;
    return $mb >= 100 ? (int) round($mb) . ' MB' : number_format($mb, 1, '.', '') . ' MB';
}

function fmtHours(float $h): string
{
    if ($h >= 100) {
        return (int) round($h) . ' 時間';
    }
    $whole = (int) floor($h);
    $mins = (int) round(($h - $whole) * 60);
    if ($mins === 60) {
        $whole++;
        $mins = 0;
    }
    if ($whole === 0) {
        return "$mins 分";
    }
    return $mins === 0 ? "$whole 時間" : "$whole 時間 $mins 分";
}

/** @return array<string, string> */
function calcUsage(string $perHour, string $hours, string $days): array
{
    $p = (float) $perHour;
    $h = (float) $hours;
    $monthly = $p * $h * (float) $days;
    $plan = '大容量・無制限プランが目安';
    foreach ([3, 5, 7, 10, 20, 30, 50, 100] as $t) {
        if ($monthly <= $t) {
            $plan = "{$t}GB プランが目安";
            break;
        }
    }
    return ['monthly' => fmtData($monthly), 'per_day' => fmtData($p * $h), 'hours_3gb' => fmtHours(3 / $p), 'hours_20gb' => fmtHours(20 / $p), 'plan' => $plan];
}

"""データ通信量（ギガ）の目安。

v2: fractions.Fraction で正確に計算し、四捨五入（0.5 ちょうどは繰り上げ）も整数で行う。
float だと 0.08 × 3.5 × 25 が 7.000000000000001 になり、7GB プランの境目を越えてしまう。
"""
import math
from fractions import Fraction as F

TIERS = [3, 5, 7, 10, 20, 30, 50, 100]


def _hu(x: F) -> int:
    return math.floor(x + F(1, 2))


def _one(x: F) -> str:
    t = _hu(x * 10)
    return f"{t // 10}.{t % 10}"


def fmt_data(gb: F) -> str:
    if gb >= 10:
        return f"{_hu(gb)} GB"
    if gb >= 1:
        return f"{_one(gb)} GB"
    mb = gb * 1024
    return f"{_hu(mb)} MB" if mb >= 100 else f"{_one(mb)} MB"


def fmt_hours(h: F) -> str:
    if h >= 100:
        return f"{_hu(h)} 時間"
    whole = math.floor(h)
    mins = _hu((h - whole) * 60)
    if mins == 60:
        whole, mins = whole + 1, 0
    if whole == 0:
        return f"{mins} 分"
    return f"{whole} 時間" if mins == 0 else f"{whole} 時間 {mins} 分"


def calc_usage(per_hour: str, hours: str, days: str) -> dict:
    p, h, d = F(per_hour), F(hours), F(days)
    monthly = p * h * d
    plan = next((f"{t}GB プランが目安" for t in TIERS if monthly <= t), "大容量・無制限プランが目安")
    return {"monthly": fmt_data(monthly), "per_day": fmt_data(p * h), "hours_3gb": fmt_hours(3 / p),
            "hours_20gb": fmt_hours(20 / p), "plan": plan}

"""データ通信量（ギガ）の目安。

v1: よくある書き方（float で計算し、round と f-string で表示）。
"""
import math

TIERS = [3, 5, 7, 10, 20, 30, 50, 100]


def fmt_data(gb: float) -> str:
    if gb >= 10:
        return f"{round(gb)} GB"
    if gb >= 1:
        return f"{gb:.1f} GB"
    mb = gb * 1024
    return f"{round(mb)} MB" if mb >= 100 else f"{mb:.1f} MB"


def fmt_hours(h: float) -> str:
    if h >= 100:
        return f"{round(h)} 時間"
    whole = math.floor(h)
    mins = round((h - whole) * 60)
    if mins == 60:
        whole, mins = whole + 1, 0
    if whole == 0:
        return f"{mins} 分"
    if mins == 0:
        return f"{whole} 時間"
    return f"{whole} 時間 {mins} 分"


def calc_usage(per_hour: str, hours: str, days: str) -> dict:
    p, h, d = float(per_hour), float(hours), float(days)
    monthly = p * h * d
    plan = next((f"{t}GB プランが目安" for t in TIERS if monthly <= t), "大容量・無制限プランが目安")
    return {"monthly": fmt_data(monthly), "per_day": fmt_data(p * h), "hours_3gb": fmt_hours(3 / p),
            "hours_20gb": fmt_hours(20 / p), "plan": plan}

package main

import (
	"fmt"
	"math/big"
)

var tiers = []int64{3, 5, 7, 10, 20, 30, 50, 100}

// v2: math/big.Rat で正確に計算し、四捨五入（0.5 ちょうどは繰り上げ）も自前で行う。
// float64 だと 0.08 × 3.5 × 25 が 7.000000000000001 になり 7GB プランの境目を越え、
// FormatFloat は 12.5 を偶数丸めで 12 にする。

func ge(x *big.Rat, k int64) bool { return x.Cmp(big.NewRat(k, 1)) >= 0 }

// hu は 0 以上の x を整数に四捨五入する。
func hu(x *big.Rat) int64 {
	v := new(big.Rat).Add(x, big.NewRat(1, 2))
	return new(big.Int).Quo(v.Num(), v.Denom()).Int64()
}

func mul(x *big.Rat, k int64) *big.Rat { return new(big.Rat).Mul(x, big.NewRat(k, 1)) }

func one(x *big.Rat) string { t := hu(mul(x, 10)); return fmt.Sprintf("%d.%d", t/10, t%10) }

func fmtData(gb *big.Rat) string {
	if ge(gb, 10) {
		return fmt.Sprintf("%d GB", hu(gb))
	}
	if ge(gb, 1) {
		return one(gb) + " GB"
	}
	mb := mul(gb, 1024)
	if ge(mb, 100) {
		return fmt.Sprintf("%d MB", hu(mb))
	}
	return one(mb) + " MB"
}

func fmtHours(h *big.Rat) string {
	if ge(h, 100) {
		return fmt.Sprintf("%d 時間", hu(h))
	}
	whole := new(big.Int).Quo(h.Num(), h.Denom()).Int64()
	mins := hu(mul(new(big.Rat).Sub(h, big.NewRat(whole, 1)), 60))
	if mins == 60 {
		whole, mins = whole+1, 0
	}
	switch {
	case whole == 0:
		return fmt.Sprintf("%d 分", mins)
	case mins == 0:
		return fmt.Sprintf("%d 時間", whole)
	}
	return fmt.Sprintf("%d 時間 %d 分", whole, mins)
}

func rat(s string) (*big.Rat, error) {
	r, ok := new(big.Rat).SetString(s)
	if !ok {
		return nil, fmt.Errorf("invalid decimal: %q", s)
	}
	return r, nil
}

// CalcUsage は月の通信量の目安を求める。
func CalcUsage(perHour, hours, days string) (map[string]string, error) {
	p, err := rat(perHour)
	if err != nil {
		return nil, err
	}
	h, err := rat(hours)
	if err != nil {
		return nil, err
	}
	d, err := rat(days)
	if err != nil {
		return nil, err
	}
	perDay := new(big.Rat).Mul(p, h)
	monthly := new(big.Rat).Mul(perDay, d)
	plan := "大容量・無制限プランが目安"
	for _, t := range tiers {
		if monthly.Cmp(big.NewRat(t, 1)) <= 0 {
			plan = fmt.Sprintf("%dGB プランが目安", t)
			break
		}
	}
	return map[string]string{"monthly": fmtData(monthly), "per_day": fmtData(perDay),
		"hours_3gb": fmtHours(new(big.Rat).Quo(big.NewRat(3, 1), p)), "hours_20gb": fmtHours(new(big.Rat).Quo(big.NewRat(20, 1), p)), "plan": plan}, nil
}

package main

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

var tiers = []float64{3, 5, 7, 10, 20, 30, 50, 100}

// v1: よくある書き方（float64 で計算し、math.Round と strconv.FormatFloat で表示）。
func fmtData(gb float64) string {
	if gb >= 10 {
		return strconv.FormatFloat(gb, 'f', 0, 64) + " GB"
	}
	if gb >= 1 {
		return strconv.FormatFloat(gb, 'f', 1, 64) + " GB"
	}
	mb := gb * 1024
	if mb >= 100 {
		return fmt.Sprintf("%d MB", int64(math.Round(mb)))
	}
	return strconv.FormatFloat(mb, 'f', 1, 64) + " MB"
}

func fmtHours(h float64) string {
	if h >= 100 {
		return fmt.Sprintf("%d 時間", int64(math.Round(h)))
	}
	whole := int64(math.Floor(h))
	mins := int64(math.Round((h - float64(whole)) * 60))
	if mins == 60 {
		whole, mins = whole+1, 0
	}
	switch {
	case whole == 0:
		return fmt.Sprintf("%d 分", mins)
	case mins == 0:
		return fmt.Sprintf("%d 時間", whole)
	}
	return fmt.Sprintf("%d 時間 %d 分", whole, mins)
}

func num(s string) float64 { v, _ := strconv.ParseFloat(s, 64); return v }

// CalcUsage は月の通信量の目安を求める。
func CalcUsage(perHour, hours, days string) (map[string]string, error) {
	p, h, d := num(perHour), num(hours), num(days)
	monthly := p * h * d
	plan := "大容量・無制限プランが目安"
	for _, t := range tiers {
		if monthly <= t {
			plan = fmt.Sprintf("%dGB プランが目安", int(t))
			break
		}
	}
	return map[string]string{"monthly": fmtData(monthly), "per_day": fmtData(p * h), "hours_3gb": fmtHours(3 / p), "hours_20gb": fmtHours(20 / p), "plan": plan}, nil
}

// データ通信量（ギガ）の目安。
// v2: BigInt の分数で正確に計算し、四捨五入（0.5 ちょうどは繰り上げ）も整数で行う。
// Number だと 0.08 × 3.5 × 25 が 7.000000000000001 になり、7GB プランの境目を越えてしまう。

const TIERS = [3n, 5n, 7n, 10n, 20n, 30n, 50n, 100n];

/** "3.5" → [35n, 10n]（分子・分母） */
function dec(s) {
  const m = /^(\d+)(?:\.(\d+))?$/.exec(s);
  if (!m) throw new RangeError(`invalid decimal: ${s}`);
  const frac = m[2] ?? "";
  return [BigInt(m[1] + frac), 10n ** BigInt(frac.length)];
}
const ge = ([n, d], k) => n >= k * d;                 // n/d >= k
const hu = ([n, d], mul = 1n) => (2n * n * mul + d) / (2n * d); // n/d × mul を四捨五入
const one = (x) => { const t = hu(x, 10n); return `${t / 10n}.${t % 10n}`; };

function fmtData(x) {
  if (ge(x, 10n)) return `${hu(x)} GB`;
  if (ge(x, 1n)) return `${one(x)} GB`;
  const mb = [x[0] * 1024n, x[1]];
  return ge(mb, 100n) ? `${hu(mb)} MB` : `${one(mb)} MB`;
}

function fmtHours([n, d]) {
  if (n >= 100n * d) return `${hu([n, d])} 時間`;
  let whole = n / d;
  let mins = hu([n - whole * d, d], 60n);
  if (mins === 60n) { whole += 1n; mins = 0n; }
  if (whole === 0n) return `${mins} 分`;
  return mins === 0n ? `${whole} 時間` : `${whole} 時間 ${mins} 分`;
}

export function calcUsage({ per_hour, hours, days }) {
  const p = dec(per_hour), h = dec(hours), d = dec(days);
  const perDay = [p[0] * h[0], p[1] * h[1]];
  const monthly = [perDay[0] * d[0], perDay[1] * d[1]];
  const t = TIERS.find((k) => monthly[0] <= k * monthly[1]);
  return {
    monthly: fmtData(monthly), per_day: fmtData(perDay),
    hours_3gb: fmtHours([3n * p[1], p[0]]), hours_20gb: fmtHours([20n * p[1], p[0]]),
    plan: t ? `${t}GB プランが目安` : "大容量・無制限プランが目安",
  };
}

// データ通信量（ギガ）の目安。
// v1: よくある書き方（Number で計算し、toFixed と Math.round で表示。元のツールと同じ）。

const TIERS = [3, 5, 7, 10, 20, 30, 50, 100];

function fmtData(gb) {
  if (gb >= 10) return gb.toFixed(0) + " GB";
  if (gb >= 1) return gb.toFixed(1) + " GB";
  const mb = gb * 1024;
  return mb >= 100 ? Math.round(mb) + " MB" : mb.toFixed(1) + " MB";
}

function fmtHours(h) {
  if (h >= 100) return Math.round(h) + " 時間";
  let whole = Math.floor(h);
  let mins = Math.round((h - whole) * 60);
  if (mins === 60) { whole += 1; mins = 0; }
  if (whole === 0) return mins + " 分";
  if (mins === 0) return whole + " 時間";
  return whole + " 時間 " + mins + " 分";
}

export function calcUsage({ per_hour, hours, days }) {
  const p = Number(per_hour), h = Number(hours), d = Number(days);
  const monthly = p * h * d;
  const t = TIERS.find((x) => monthly <= x);
  return { monthly: fmtData(monthly), per_day: fmtData(p * h), hours_3gb: fmtHours(3 / p), hours_20gb: fmtHours(20 / p),
    plan: t ? `${t}GB プランが目安` : "大容量・無制限プランが目安" };
}