Зачем оценивать

<?php

declare(strict_types=1);

/**
 * Binary size helper: converts bytes to human-readable form and back.
 * Uses power-of-2 (IEC) units: KiB, MiB, GiB, TiB, PiB.
 */
final class BinarySize
{
    private const UNITS = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB'];

    /**
     * Format bytes into the largest unit where value >= 1.
     * Example: format(1536) => "1.5 KiB"
     */
    public static function format(int|float $bytes, int $precision = 2): string
    {
        if ($bytes < 1) {
            return '0 B';
        }

        $exp = (int) floor(log($bytes, 1024));
        $exp = min($exp, count(self::UNITS) - 1);
        $value = $bytes / (1024 ** $exp);

        return sprintf("%.{$precision}f %s", $value, self::UNITS[$exp]);
    }

    /**
     * Parse "2.5 GiB" back into bytes.
     */
    public static function parse(string $input): int
    {
        if (!preg_match('/^\s*(\d+(?:\.\d+)?)\s*([KMGTPE]?i?B)\s*$/i', $input, $m)) {
            throw new \InvalidArgumentException("Invalid size format: {$input}");
        }

        $value = (float) $m[1];
        $unit = strtoupper($m[2]);
        $idx = array_search($unit, array_map('strtoupper', self::UNITS), true);

        if ($idx === false) {
            throw new \InvalidArgumentException("Unknown unit: {$unit}");
        }

        return (int) round($value * (1024 ** $idx));
    }

    /**
     * Raw power of 2: pow2(30) => 1073741824.
     */
    public static function pow2(int $exp): int
    {
        return 1 << $exp;
    }
}

// Usage:
// BinarySize::format(5 * 1024 ** 3) => "5.00 GiB"
// BinarySize::parse("500 MiB") => 524288000

package sizing

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

var units = []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"}

// Format converts bytes into the largest unit where value >= 1.
// Example: Format(1536) => "1.50 KiB".
func Format(bytes float64, precision int) string {
	if bytes < 1 {
		return "0 B"
	}

	exp := int(math.Floor(math.Log(bytes) / math.Log(1024)))
	if exp >= len(units) {
		exp = len(units) - 1
	}

	value := bytes / math.Pow(1024, float64(exp))
	return fmt.Sprintf("%.*f %s", precision, value, units[exp])
}

var sizeRe = regexp.MustCompile(`^\s*(\d+(?:\.\d+)?)\s*([KMGTPE]?i?B)\s*$`)

// Parse converts "2.5 GiB" into bytes.
func Parse(input string) (int64, error) {
	m := sizeRe.FindStringSubmatch(input)
	if m == nil {
		return 0, fmt.Errorf("invalid size format: %q", input)
	}

	value, err := strconv.ParseFloat(m[1], 64)
	if err != nil {
		return 0, err
	}

	unit := strings.ToUpper(m[2])
	for i, u := range units {
		if strings.ToUpper(u) == unit {
			return int64(math.Round(value * math.Pow(1024, float64(i)))), nil
		}
	}
	return 0, fmt.Errorf("unknown unit: %s", unit)
}

// Pow2 returns 2^exp as int64 (safe up to 62).
func Pow2(exp int) int64 {
	return int64(1) << exp
}

using System;
using System.Globalization;
using System.Linq;
using System.Text.RegularExpressions;

// Binary size helper: converts bytes to human-readable form and back.
// Uses power-of-2 (IEC) units: KiB, MiB, GiB, TiB, PiB.
public static partial class BinarySize
{
    private static readonly string[] Units = ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"];

    // Format bytes into the largest unit where value >= 1.
    // Example: Format(1536) => "1.50 KiB"
    public static string Format(double bytes, int precision = 2)
    {
        if (bytes < 1)
        {
            return "0 B";
        }

        var exp = Math.Min((int)Math.Floor(Math.Log(bytes, 1024)), Units.Length - 1);
        var value = bytes / Math.Pow(1024, exp);

        return string.Create(
            CultureInfo.InvariantCulture,
            $"{Math.Round(value, precision).ToString("F" + precision, CultureInfo.InvariantCulture)} {Units[exp]}");
    }

    // Parse "2.5 GiB" back into bytes.
    public static long Parse(string input)
    {
        var match = SizePattern().Match(input);
        if (!match.Success)
        {
            throw new FormatException($"Invalid size format: {input}");
        }

        var value = double.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
        var unit = match.Groups[2].Value;
        var idx = Array.FindIndex(Units, u => string.Equals(u, unit, StringComparison.OrdinalIgnoreCase));

        if (idx < 0)
        {
            throw new FormatException($"Unknown unit: {unit}");
        }

        return (long)Math.Round(value * Math.Pow(1024, idx));
    }

    // Raw power of two: Pow2(30) => 1073741824. Safe up to 62.
    public static long Pow2(int exp) => 1L << exp;

    [GeneratedRegex(@"^\s*(\d+(?:\.\d+)?)\s*([KMGTPE]?i?B)\s*$", RegexOptions.IgnoreCase)]
    private static partial Regex SizePattern();
}

// Usage:
// BinarySize.Format(5L * 1024 * 1024 * 1024); // "5.00 GiB"
// BinarySize.Parse("500 MiB");                // 524288000

from __future__ import annotations

import math
import re

# Power-of-2 (IEC) units
UNITS = ("B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB")
SIZE_RE = re.compile(r"^\s*(\d+(?:\.\d+)?)\s*([KMGTPE]?i?B)\s*$", re.IGNORECASE)

def format_size(num_bytes: float, precision: int = 2) -> str:
    """Format bytes into the largest unit where the value is >= 1.

    Example: format_size(1536) -> "1.50 KiB"
    """
    if num_bytes < 1:
        return "0 B"

    exp = min(int(math.log(num_bytes, 1024)), len(UNITS) - 1)
    value = num_bytes / (1024 ** exp)
    return f"{value:.{precision}f} {UNITS[exp]}"

def parse_size(text: str) -> int:
    """Parse "2.5 GiB" back into bytes."""
    match = SIZE_RE.match(text)
    if match is None:
        raise ValueError(f"Invalid size format: {text}")

    value = float(match.group(1))
    unit = match.group(2).upper()

    for idx, candidate in enumerate(UNITS):
        if candidate.upper() == unit:
            return round(value * (1024 ** idx))

    raise ValueError(f"Unknown unit: {unit}")

def pow2(exp: int) -> int:
    """Raw power of two: pow2(30) -> 1073741824. Python ints are unbounded."""
    return 1 << exp

# Usage:
# format_size(5 * 1024 ** 3)  # "5.00 GiB"
# parse_size("500 MiB")       # 524288000