露点・不快指数の計算

<?php
declare(strict_types=1);

/**
 * 露点・不快指数の計算。
 * v2: 不快指数は 10万倍した整数で正確に計算して四捨五入する（float だと 74.45 が 74.44999999999999 になり 74.4 に落ちる）。
 * 露点・絶対湿度は log / pow のまま（小数第1位では正確な値と一致することを60,100通りで確かめた）。湿度100%の露点は気温そのもの。
 */
/** $n は不快指数 × 100000（整数） */
function feelOf(int $n): string
{
    return match (true) {
        $n < 5500000 => '寒い',
        $n < 6000000 => '肌寒い',
        $n < 6500000 => '何も感じない',
        $n < 7000000 => '快適',
        $n < 7500000 => '暑くない',
        $n < 8000000 => 'やや暑い',
        $n < 8500000 => '暑くて汗が出る',
        default => '暑くてたまらない',
    };
}

/** 10万倍した整数 $n を小数第1位に四捨五入した文字列（0.5 は 0 から遠い方へ） */
function tenthsText(int $n): string
{
    $r = intdiv(abs($n) + 5000, 10000);
    return $r === 0 ? '0.0' : ($n < 0 ? '-' : '') . intdiv($r, 10) . '.' . $r % 10;
}

/** @param array{temp: string, humid: int} $in */
function calcDew(array $in): array
{
    $temp = $in['temp'];
    $humid = $in['humid'];
    if (!preg_match('/^-?\d+(\.\d)?$/', $temp)) {
        return ['error' => 'invalid_input'];
    }
    $t = (float) $temp;
    $t10 = (int) round($t * 10); // 小数第1位までなので、10倍すれば整数
    if ($t < -20 || $t > 40 || $humid < 1 || $humid > 100) {
        return ['error' => 'invalid_input'];
    }
    $es = 6.1078 * pow(10, (7.5 * $t) / (237.3 + $t));
    $gamma = log($humid / 100) + (17.27 * $t) / (237.7 + $t);
    $dew = $humid === 100 ? $t : (237.7 * $gamma) / (17.27 - $gamma);
    $di = 8100 * $t10 + $humid * (99 * $t10 - 14300) + 4630000; // 不快指数 × 100000（整数）
    $ah = (217 * $es * ($humid / 100)) / ($t + 273.15);
    return ['di' => tenthsText($di), 'feel' => feelOf($di), 'dew' => number_format($dew, 1),
        'abs_humidity' => number_format($ah, 1), 'risk' => $dew >= 18 ? '高い' : ($dew >= 12 ? '中' : '低い')];
}

<?php
declare(strict_types=1);

/**
 * 露点・不快指数の計算。
 * v1: (float) と log / pow で計算し、number_format($x, 1) で小数第1位にする素直な書き方。
 */
function feelOf(float $di): string
{
    return match (true) {
        $di < 55 => '寒い',
        $di < 60 => '肌寒い',
        $di < 65 => '何も感じない',
        $di < 70 => '快適',
        $di < 75 => '暑くない',
        $di < 80 => 'やや暑い',
        $di < 85 => '暑くて汗が出る',
        default => '暑くてたまらない',
    };
}

/** @param array{temp: string, humid: int} $in */
function calcDew(array $in): array
{
    $temp = $in['temp'];
    $humid = $in['humid'];
    if (!preg_match('/^-?\d+(\.\d)?$/', $temp)) {
        return ['error' => 'invalid_input'];
    }
    $t = (float) $temp;
    if ($t < -20 || $t > 40 || $humid < 1 || $humid > 100) {
        return ['error' => 'invalid_input'];
    }
    $es = 6.1078 * pow(10, (7.5 * $t) / (237.3 + $t));
    $gamma = log($humid / 100) + (17.27 * $t) / (237.7 + $t);
    $dew = (237.7 * $gamma) / (17.27 - $gamma);
    $di = 0.81 * $t + 0.01 * $humid * (0.99 * $t - 14.3) + 46.3;
    $ah = (217 * $es * ($humid / 100)) / ($t + 273.15);
    return ['di' => number_format($di, 1), 'feel' => feelOf($di), 'dew' => number_format($dew, 1),
        'abs_humidity' => number_format($ah, 1), 'risk' => $dew >= 18 ? '高い' : ($dew >= 12 ? '中' : '低い')];
}

"""露点・不快指数の計算。

v2: 不快指数は 10万倍した整数で正確に計算して四捨五入する（f"{x:.1f}" は2進数の値を偶数丸めするので 65.25 を 65.2 に、66.35（中身は 66.349…）を 66.3 にする）。
露点・絶対湿度は math.log / math.pow のまま（小数第1位では正確な値と一致することを60,100通りで確かめた）。
0 に丸まる値は "-0.0" ではなく "0.0" にする。湿度100%の露点は気温そのもの。
"""
import math
import re

FEEL = [(55, "寒い"), (60, "肌寒い"), (65, "何も感じない"), (70, "快適"), (75, "暑くない"), (80, "やや暑い"), (85, "暑くて汗が出る")]


def feel_of(n):
    """n は不快指数 × 100000（整数）"""
    for limit, label in FEEL:
        if n < limit * 100000:
            return label
    return "暑くてたまらない"


def tenths_text(n):
    """10万倍した整数 n を小数第1位に四捨五入した文字列（0.5 は 0 から遠い方へ）"""
    r = (abs(n) + 5000) // 10000
    return "0.0" if r == 0 else f"{'-' if n < 0 else ''}{r // 10}.{r % 10}"


def fixed1(x):
    s = f"{x:.1f}"
    return "0.0" if s == "-0.0" else s


def calc_dew(temp, humid):
    if not re.fullmatch(r"-?\d+(\.\d)?", temp):
        return {"error": "invalid_input"}
    t = float(temp)
    t10 = round(t * 10)  # 小数第1位までなので、10倍すれば整数
    if not (-20 <= t <= 40) or not (1 <= humid <= 100):
        return {"error": "invalid_input"}
    es = 6.1078 * math.pow(10, (7.5 * t) / (237.3 + t))
    gamma = math.log(humid / 100) + (17.27 * t) / (237.7 + t)
    dew = t if humid == 100 else (237.7 * gamma) / (17.27 - gamma)
    di = 8100 * t10 + humid * (99 * t10 - 14300) + 4630000  # 不快指数 × 100000（整数）
    ah = (217 * es * (humid / 100)) / (t + 273.15)
    return {"di": tenths_text(di), "feel": feel_of(di), "dew": fixed1(dew), "abs_humidity": fixed1(ah),
            "risk": "高い" if dew >= 18 else "中" if dew >= 12 else "低い"}

"""露点・不快指数の計算。

v1: float と math.log / math.pow で計算し、f"{x:.1f}" で小数第1位にする素直な書き方。
"""
import math
import re

FEEL = [(55, "寒い"), (60, "肌寒い"), (65, "何も感じない"), (70, "快適"), (75, "暑くない"), (80, "やや暑い"), (85, "暑くて汗が出る")]


def feel_of(di):
    for limit, label in FEEL:
        if di < limit:
            return label
    return "暑くてたまらない"


def calc_dew(temp, humid):
    if not re.fullmatch(r"-?\d+(\.\d)?", temp):
        return {"error": "invalid_input"}
    t = float(temp)
    if not (-20 <= t <= 40) or not (1 <= humid <= 100):
        return {"error": "invalid_input"}
    es = 6.1078 * math.pow(10, (7.5 * t) / (237.3 + t))
    gamma = math.log(humid / 100) + (17.27 * t) / (237.7 + t)
    dew = (237.7 * gamma) / (17.27 - gamma)
    di = 0.81 * t + 0.01 * humid * (0.99 * t - 14.3) + 46.3
    ah = (217 * es * (humid / 100)) / (t + 273.15)
    return {"di": f"{di:.1f}", "feel": feel_of(di), "dew": f"{dew:.1f}", "abs_humidity": f"{ah:.1f}",
            "risk": "高い" if dew >= 18 else "中" if dew >= 12 else "低い"}

package main

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

// v2: 不快指数は 10万倍した整数で正確に計算して四捨五入する（FormatFloat は2進数の値を偶数丸めするので 65.25 を 65.2 に、
// 66.35（中身は 66.349…）を 66.3 にする）。露点・絶対湿度は math.Log / math.Pow のまま（小数第1位では正確な値と一致することを
// 60,100通りで確かめた）。0 に丸まる値は "-0.0" ではなく "0.0" にする。湿度100%の露点は気温そのもの。

var tempPattern = regexp.MustCompile(`^-?\d+(\.\d)?$`)

// feelOf の n は不快指数 × 100000（整数）
func feelOf(n int) string {
	switch {
	case n < 5500000:
		return "寒い"
	case n < 6000000:
		return "肌寒い"
	case n < 6500000:
		return "何も感じない"
	case n < 7000000:
		return "快適"
	case n < 7500000:
		return "暑くない"
	case n < 8000000:
		return "やや暑い"
	case n < 8500000:
		return "暑くて汗が出る"
	}
	return "暑くてたまらない"
}

func f1(x float64) string {
	if s := strconv.FormatFloat(x, 'f', 1, 64); s != "-0.0" {
		return s
	}
	return "0.0"
}

// tenthsText は 10万倍した整数 n を小数第1位に四捨五入した文字列（0.5 は 0 から遠い方へ）
func tenthsText(n int) string {
	sign, a := "", n
	if n < 0 {
		sign, a = "-", -n
	}
	r := (a + 5000) / 10000
	if r == 0 {
		return "0.0"
	}
	return fmt.Sprintf("%s%d.%d", sign, r/10, r%10)
}

func CalcDew(temp string, humid int) map[string]any {
	if !tempPattern.MatchString(temp) {
		return map[string]any{"error": "invalid_input"}
	}
	t, _ := strconv.ParseFloat(temp, 64)
	if t < -20 || t > 40 || humid < 1 || humid > 100 {
		return map[string]any{"error": "invalid_input"}
	}
	h := float64(humid)
	t10 := int(math.Round(t * 10)) // 小数第1位までなので、10倍すれば整数
	es := 6.1078 * math.Pow(10, (7.5*t)/(237.3+t))
	gamma := math.Log(h/100) + (17.27*t)/(237.7+t)
	dew := (237.7 * gamma) / (17.27 - gamma)
	if humid == 100 {
		dew = t
	}
	di := 8100*t10 + humid*(99*t10-14300) + 4630000 // 不快指数 × 100000（整数）
	ah := (217 * es * (h / 100)) / (t + 273.15)
	risk := "低い"
	if dew >= 18 {
		risk = "高い"
	} else if dew >= 12 {
		risk = "中"
	}
	return map[string]any{"di": tenthsText(di), "feel": feelOf(di), "dew": f1(dew), "abs_humidity": f1(ah), "risk": risk}
}

package main

import (
	"math"
	"regexp"
	"strconv"
)

// v1: strconv.ParseFloat と math.Log / math.Pow で計算し、strconv.FormatFloat(x, 'f', 1, 64) で小数第1位にする素直な書き方。

var tempPattern = regexp.MustCompile(`^-?\d+(\.\d)?$`)

func feelOf(di float64) string {
	switch {
	case di < 55:
		return "寒い"
	case di < 60:
		return "肌寒い"
	case di < 65:
		return "何も感じない"
	case di < 70:
		return "快適"
	case di < 75:
		return "暑くない"
	case di < 80:
		return "やや暑い"
	case di < 85:
		return "暑くて汗が出る"
	}
	return "暑くてたまらない"
}

func f1(x float64) string { return strconv.FormatFloat(x, 'f', 1, 64) }

func CalcDew(temp string, humid int) map[string]any {
	if !tempPattern.MatchString(temp) {
		return map[string]any{"error": "invalid_input"}
	}
	t, _ := strconv.ParseFloat(temp, 64)
	if t < -20 || t > 40 || humid < 1 || humid > 100 {
		return map[string]any{"error": "invalid_input"}
	}
	h := float64(humid)
	es := 6.1078 * math.Pow(10, (7.5*t)/(237.3+t))
	gamma := math.Log(h/100) + (17.27*t)/(237.7+t)
	dew := (237.7 * gamma) / (17.27 - gamma)
	di := 0.81*t + 0.01*h*(0.99*t-14.3) + 46.3
	ah := (217 * es * (h / 100)) / (t + 273.15)
	risk := "低い"
	if dew >= 18 {
		risk = "高い"
	} else if dew >= 12 {
		risk = "中"
	}
	return map[string]any{"di": f1(di), "feel": feelOf(di), "dew": f1(dew), "abs_humidity": f1(ah), "risk": risk}
}

// 露点・不快指数の計算。
// v2: 不快指数は 10万倍した整数で正確に計算して四捨五入する（2進数の小数だと 66.35 が 66.349… になり 66.3 に落ちる）。
// 露点・絶対湿度は Math.log / Math.pow のまま（小数第1位では正確な値と一致することを60,100通りで確かめた）。
// toFixed は -0.04 を "-0.0" にするので、0 に丸まる値は "0.0" にする。湿度100%の露点は気温そのもの。

const LIMITS = [55, 60, 65, 70, 75, 80, 85];
const LABELS = ["寒い", "肌寒い", "何も感じない", "快適", "暑くない", "やや暑い", "暑くて汗が出る", "暑くてたまらない"];

/** 10万倍した整数 n を小数第1位に四捨五入した文字列（0.5 は 0 から遠い方へ） */
function tenthsText(n) {
  const r = Math.floor((Math.abs(n) + 5000) / 10000);
  return r === 0 ? "0.0" : `${n < 0 ? "-" : ""}${Math.floor(r / 10)}.${r % 10}`;
}

const fixed1 = (x) => { const s = x.toFixed(1); return s === "-0.0" ? "0.0" : s; };

export function calcDew({ temp, humid }) {
  if (!/^-?\d+(\.\d)?$/.test(temp)) return { error: "invalid_input" };
  const t = parseFloat(temp);
  const t10 = Math.round(t * 10); // 小数第1位までなので、10倍すれば整数
  if (!(t >= -20 && t <= 40) || !Number.isInteger(humid) || humid < 1 || humid > 100) return { error: "invalid_input" };
  const es = 6.1078 * Math.pow(10, (7.5 * t) / (237.3 + t));
  const gamma = Math.log(humid / 100) + (17.27 * t) / (237.7 + t);
  const dew = humid === 100 ? t : (237.7 * gamma) / (17.27 - gamma);
  const di = 8100 * t10 + humid * (99 * t10 - 14300) + 4630000; // 不快指数 × 100000（整数）
  const ah = (217 * es * (humid / 100)) / (t + 273.15);
  return {
    di: tenthsText(di), feel: LABELS[LIMITS.filter((l) => di >= l * 100000).length], dew: fixed1(dew), abs_humidity: fixed1(ah),
    risk: dew >= 18 ? "高い" : dew >= 12 ? "中" : "低い",
  };
}

// 露点・不快指数の計算。
// v1: parseFloat と Math.log / Math.pow で計算し、toFixed(1) で小数第1位にする素直な書き方。

function feelOf(di) {
  if (di < 55) return "寒い";
  if (di < 60) return "肌寒い";
  if (di < 65) return "何も感じない";
  if (di < 70) return "快適";
  if (di < 75) return "暑くない";
  if (di < 80) return "やや暑い";
  if (di < 85) return "暑くて汗が出る";
  return "暑くてたまらない";
}

export function calcDew({ temp, humid }) {
  if (!/^-?\d+(\.\d)?$/.test(temp)) return { error: "invalid_input" };
  const t = parseFloat(temp);
  if (!(t >= -20 && t <= 40) || !Number.isInteger(humid) || humid < 1 || humid > 100) return { error: "invalid_input" };
  const es = 6.1078 * Math.pow(10, (7.5 * t) / (237.3 + t));
  const gamma = Math.log(humid / 100) + (17.27 * t) / (237.7 + t);
  const dew = (237.7 * gamma) / (17.27 - gamma);
  const di = 0.81 * t + 0.01 * humid * (0.99 * t - 14.3) + 46.3;
  const ah = (217 * es * (humid / 100)) / (t + 273.15);
  return {
    di: di.toFixed(1), feel: feelOf(di), dew: dew.toFixed(1), abs_humidity: ah.toFixed(1),
    risk: dew >= 18 ? "高い" : dew >= 12 ? "中" : "低い",
  };
}

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

/**
 * 露点・不快指数の計算。
 * v2: 不快指数は 10万倍した整数で正確に計算して四捨五入する（double だと 74.45 が 74.44999999999999 になり 74.4 に落ちる）。
 * 露点・絶対湿度は Math.log / Math.pow のまま（小数第1位では正確な値と一致することを60,100通りで確かめた）。
 * String.format は -0.04 を "-0.0" にするので、0 に丸まる値は "0.0" にする。湿度100%の露点は気温そのもの。
 */
public final class Dew {
    private Dew() {}

    /** n は不快指数 × 100000（整数） */
    static String feelOf(long n) {
        if (n < 5_500_000) return "寒い";
        if (n < 6_000_000) return "肌寒い";
        if (n < 6_500_000) return "何も感じない";
        if (n < 7_000_000) return "快適";
        if (n < 7_500_000) return "暑くない";
        if (n < 8_000_000) return "やや暑い";
        if (n < 8_500_000) return "暑くて汗が出る";
        return "暑くてたまらない";
    }

    /** 10万倍した整数 n を小数第1位に四捨五入した文字列（0.5 は 0 から遠い方へ） */
    static String tenthsText(long n) {
        long r = (Math.abs(n) + 5000) / 10000;
        return r == 0 ? "0.0" : (n < 0 ? "-" : "") + r / 10 + "." + r % 10;
    }

    static String fixed1(double x) {
        String s = String.format(java.util.Locale.ROOT, "%.1f", x);
        return s.equals("-0.0") ? "0.0" : s;
    }

    public static Map<String, Object> calc(String temp, long humid) {
        Map<String, Object> out = new LinkedHashMap<>();
        if (!temp.matches("-?\\d+(\\.\\d)?")) { out.put("error", "invalid_input"); return out; }
        double t = Double.parseDouble(temp);
        long t10 = Math.round(t * 10); // 小数第1位までなので、10倍すれば整数
        if (t < -20 || t > 40 || humid < 1 || humid > 100) { out.put("error", "invalid_input"); return out; }
        double es = 6.1078 * Math.pow(10, (7.5 * t) / (237.3 + t));
        double gamma = Math.log(humid / 100.0) + (17.27 * t) / (237.7 + t);
        double dew = humid == 100 ? t : (237.7 * gamma) / (17.27 - gamma);
        long di = 8100 * t10 + humid * (99 * t10 - 14300) + 4_630_000; // 不快指数 × 100000（整数）
        double ah = (217 * es * (humid / 100.0)) / (t + 273.15);
        out.put("di", tenthsText(di));
        out.put("feel", feelOf(di));
        out.put("dew", fixed1(dew));
        out.put("abs_humidity", fixed1(ah));
        out.put("risk", dew >= 18 ? "高い" : dew >= 12 ? "中" : "低い");
        return out;
    }
}

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

/** 露点・不快指数の計算。v1: double と Math.log / Math.pow で計算し、String.format("%.1f") で小数第1位にする素直な書き方。 */
public final class Dew {
    private Dew() {}

    static String feelOf(double di) {
        if (di < 55) return "寒い";
        if (di < 60) return "肌寒い";
        if (di < 65) return "何も感じない";
        if (di < 70) return "快適";
        if (di < 75) return "暑くない";
        if (di < 80) return "やや暑い";
        if (di < 85) return "暑くて汗が出る";
        return "暑くてたまらない";
    }

    public static Map<String, Object> calc(String temp, long humid) {
        Map<String, Object> out = new LinkedHashMap<>();
        if (!temp.matches("-?\\d+(\\.\\d)?")) { out.put("error", "invalid_input"); return out; }
        double t = Double.parseDouble(temp);
        if (t < -20 || t > 40 || humid < 1 || humid > 100) { out.put("error", "invalid_input"); return out; }
        double es = 6.1078 * Math.pow(10, (7.5 * t) / (237.3 + t));
        double gamma = Math.log(humid / 100.0) + (17.27 * t) / (237.7 + t);
        double dew = (237.7 * gamma) / (17.27 - gamma);
        double di = 0.81 * t + 0.01 * humid * (0.99 * t - 14.3) + 46.3;
        double ah = (217 * es * (humid / 100.0)) / (t + 273.15);
        out.put("di", String.format("%.1f", di));
        out.put("feel", feelOf(di));
        out.put("dew", String.format("%.1f", dew));
        out.put("abs_humidity", String.format("%.1f", ah));
        out.put("risk", dew >= 18 ? "高い" : dew >= 12 ? "中" : "低い");
        return out;
    }
}

// 露点・不快指数の計算。
// v2: 不快指数は 10万倍した整数で正確に計算して四捨五入する（ToString("F1") は2進数の値を偶数丸めするので 65.25 を 65.2 に、
// 66.35（中身は 66.349…）を 66.3 にする）。露点・絶対湿度は Math.Log / Math.Pow のまま（小数第1位では正確な値と一致することを
// 60,100通りで確かめた）。0 に丸まる値は "-0.0" ではなく "0.0" にする。湿度100%の露点は気温そのもの。
using System.Globalization;
using System.Text.RegularExpressions;

public static class Dew
{
    // n は不快指数 × 100000（整数）
    static string FeelOf(long n) =>
        n < 5_500_000 ? "寒い" : n < 6_000_000 ? "肌寒い" : n < 6_500_000 ? "何も感じない" : n < 7_000_000 ? "快適" :
        n < 7_500_000 ? "暑くない" : n < 8_000_000 ? "やや暑い" : n < 8_500_000 ? "暑くて汗が出る" : "暑くてたまらない";

    // 10万倍した整数 n を小数第1位に四捨五入した文字列（0.5 は 0 から遠い方へ）
    static string TenthsText(long n)
    {
        long r = (Math.Abs(n) + 5000) / 10000;
        return r == 0 ? "0.0" : $"{(n < 0 ? "-" : "")}{r / 10}.{r % 10}";
    }

    static string F1(double x)
    {
        string s = x.ToString("F1", CultureInfo.InvariantCulture);
        return s == "-0.0" ? "0.0" : s;
    }

    public static Dictionary<string, object?> Calc(string temp, long humid)
    {
        if (!Regex.IsMatch(temp, @"^-?\d+(\.\d)?$")) return new() { ["error"] = "invalid_input" };
        double t = double.Parse(temp, CultureInfo.InvariantCulture);
        long t10 = (long)Math.Round(t * 10); // 小数第1位までなので、10倍すれば整数
        if (t < -20 || t > 40 || humid < 1 || humid > 100) return new() { ["error"] = "invalid_input" };
        double es = 6.1078 * Math.Pow(10, (7.5 * t) / (237.3 + t));
        double gamma = Math.Log(humid / 100.0) + (17.27 * t) / (237.7 + t);
        double dew = humid == 100 ? t : (237.7 * gamma) / (17.27 - gamma);
        long di = 8100 * t10 + humid * (99 * t10 - 14300) + 4_630_000; // 不快指数 × 100000（整数）
        double ah = (217 * es * (humid / 100.0)) / (t + 273.15);
        return new()
        {
            ["di"] = TenthsText(di), ["feel"] = FeelOf(di), ["dew"] = F1(dew), ["abs_humidity"] = F1(ah),
            ["risk"] = dew >= 18 ? "高い" : dew >= 12 ? "中" : "低い",
        };
    }
}

// 露点・不快指数の計算。
// v1: double と Math.Log / Math.Pow で計算し、ToString("F1") で小数第1位にする素直な書き方（金額ではないので double）。
using System.Globalization;
using System.Text.RegularExpressions;

public static class Dew
{
    static string FeelOf(double di) =>
        di < 55 ? "寒い" : di < 60 ? "肌寒い" : di < 65 ? "何も感じない" : di < 70 ? "快適" :
        di < 75 ? "暑くない" : di < 80 ? "やや暑い" : di < 85 ? "暑くて汗が出る" : "暑くてたまらない";

    static string F1(double x) => x.ToString("F1", CultureInfo.InvariantCulture);

    public static Dictionary<string, object?> Calc(string temp, long humid)
    {
        if (!Regex.IsMatch(temp, @"^-?\d+(\.\d)?$")) return new() { ["error"] = "invalid_input" };
        double t = double.Parse(temp, CultureInfo.InvariantCulture);
        if (t < -20 || t > 40 || humid < 1 || humid > 100) return new() { ["error"] = "invalid_input" };
        double es = 6.1078 * Math.Pow(10, (7.5 * t) / (237.3 + t));
        double gamma = Math.Log(humid / 100.0) + (17.27 * t) / (237.7 + t);
        double dew = (237.7 * gamma) / (17.27 - gamma);
        double di = 0.81 * t + 0.01 * humid * (0.99 * t - 14.3) + 46.3;
        double ah = (217 * es * (humid / 100.0)) / (t + 273.15);
        return new()
        {
            ["di"] = F1(di), ["feel"] = FeelOf(di), ["dew"] = F1(dew), ["abs_humidity"] = F1(ah),
            ["risk"] = dew >= 18 ? "高い" : dew >= 12 ? "中" : "低い",
        };
    }
}

//! 露点・不快指数の計算。
//! v2: 不快指数は 10万倍した整数で正確に計算して四捨五入する（format!("{:.1}") は2進数の値を偶数丸めするので 65.25 を 65.2 に、
//! 66.35（中身は 66.349…）を 66.3 にする）。露点・絶対湿度は ln / powf のまま（小数第1位では正確な値と一致することを
//! 60,100通りで確かめた）。0 に丸まる値は "-0.0" ではなく "0.0" にする。湿度100%の露点は気温そのもの。

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

/// n は不快指数 × 100000（整数）
fn feel_of(n: i64) -> &'static str {
    const LABELS: [&str; 8] = ["寒い", "肌寒い", "何も感じない", "快適", "暑くない", "やや暑い", "暑くて汗が出る", "暑くてたまらない"];
    LABELS[[55, 60, 65, 70, 75, 80, 85].iter().filter(|&&l| n >= l * 100_000).count()]
}

/// 10万倍した整数 n を小数第1位に四捨五入した文字列（0.5 は 0 から遠い方へ）
fn tenths_text(n: i64) -> String {
    let r = (n.abs() + 5000) / 10000;
    if r == 0 { "0.0".into() } else { format!("{}{}.{}", if n < 0 { "-" } else { "" }, r / 10, r % 10) }
}

fn fixed1(x: f64) -> String {
    let s = format!("{x:.1}");
    if s == "-0.0" { "0.0".into() } else { s }
}

fn valid_temp(t: &str) -> bool {
    let body = t.strip_prefix('-').unwrap_or(t);
    let (int, frac) = body.split_once('.').unwrap_or((body, "0"));
    !int.is_empty() && int.bytes().all(|b| b.is_ascii_digit()) && frac.len() == 1 && frac.bytes().all(|b| b.is_ascii_digit())
}

pub fn calc(temp: &str, humid: i64) -> Result<Value, String> {
    if !valid_temp(temp) {
        return Ok(obj(vec![("error", s("invalid_input"))]));
    }
    let t: f64 = temp.parse().map_err(|e| format!("{e}"))?;
    if !(-20.0..=40.0).contains(&t) || !(1..=100).contains(&humid) {
        return Ok(obj(vec![("error", s("invalid_input"))]));
    }
    let h = humid as f64;
    let t10 = (t * 10.0).round() as i64; // 小数第1位までなので、10倍すれば整数
    let es = 6.1078 * 10f64.powf((7.5 * t) / (237.3 + t));
    let gamma = (h / 100.0).ln() + (17.27 * t) / (237.7 + t);
    let dew = if humid == 100 { t } else { (237.7 * gamma) / (17.27 - gamma) };
    let di = 8100 * t10 + humid * (99 * t10 - 14300) + 4_630_000; // 不快指数 × 100000（整数）
    let ah = (217.0 * es * (h / 100.0)) / (t + 273.15);
    let risk = if dew >= 18.0 { "高い" } else if dew >= 12.0 { "中" } else { "低い" };
    Ok(obj(vec![
        ("di", s(tenths_text(di))), ("feel", s(feel_of(di))), ("dew", s(fixed1(dew))),
        ("abs_humidity", s(fixed1(ah))), ("risk", s(risk)),
    ]))
}

//! 露点・不快指数の計算。
//! v1: f64 と ln / powf で計算し、format!("{:.1}") で小数第1位にする素直な書き方。

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

fn feel_of(di: f64) -> &'static str {
    if di < 55.0 { "寒い" } else if di < 60.0 { "肌寒い" } else if di < 65.0 { "何も感じない" } else if di < 70.0 { "快適" }
    else if di < 75.0 { "暑くない" } else if di < 80.0 { "やや暑い" } else if di < 85.0 { "暑くて汗が出る" } else { "暑くてたまらない" }
}

fn valid_temp(t: &str) -> bool {
    let body = t.strip_prefix('-').unwrap_or(t);
    let (int, frac) = body.split_once('.').unwrap_or((body, "0"));
    !int.is_empty() && int.bytes().all(|b| b.is_ascii_digit()) && frac.len() == 1 && frac.bytes().all(|b| b.is_ascii_digit())
}

pub fn calc(temp: &str, humid: i64) -> Result<Value, String> {
    if !valid_temp(temp) {
        return Ok(obj(vec![("error", s("invalid_input"))]));
    }
    let t: f64 = temp.parse().map_err(|e| format!("{e}"))?;
    if !(-20.0..=40.0).contains(&t) || !(1..=100).contains(&humid) {
        return Ok(obj(vec![("error", s("invalid_input"))]));
    }
    let h = humid as f64;
    let es = 6.1078 * 10f64.powf((7.5 * t) / (237.3 + t));
    let gamma = (h / 100.0).ln() + (17.27 * t) / (237.7 + t);
    let dew = (237.7 * gamma) / (17.27 - gamma);
    let di = 0.81 * t + 0.01 * h * (0.99 * t - 14.3) + 46.3;
    let ah = (217.0 * es * (h / 100.0)) / (t + 273.15);
    let risk = if dew >= 18.0 { "高い" } else if dew >= 12.0 { "中" } else { "低い" };
    Ok(obj(vec![
        ("di", s(format!("{di:.1}"))), ("feel", s(feel_of(di))), ("dew", s(format!("{dew:.1}"))),
        ("abs_humidity", s(format!("{ah:.1}"))), ("risk", s(risk)),
    ]))
}

# 露点・不快指数の計算。
# v2: 不快指数は 10万倍した整数で正確に計算して四捨五入する（Float だと 74.45 が 74.44999999999999 になり 74.4 に落ちる）。
# 露点・絶対湿度は Math.log / ** のまま（小数第1位では正確な値と一致することを60,100通りで確かめた）。
# round(1) は -0.04 を -0.0 にするので、0 に丸まる値は "0.0" にする。湿度100%の露点は気温そのもの。

module Dew
  module_function

  FEEL = [[55, "寒い"], [60, "肌寒い"], [65, "何も感じない"], [70, "快適"], [75, "暑くない"], [80, "やや暑い"], [85, "暑くて汗が出る"]].freeze

  # n は不快指数 × 100000（整数）
  def feel_of(n)
    FEEL.each { |limit, label| return label if n < limit * 100_000 }
    "暑くてたまらない"
  end

  # 10万倍した整数 n を小数第1位に四捨五入した文字列（0.5 は 0 から遠い方へ）
  def tenths_text(n)
    r = (n.abs + 5000) / 10_000
    r.zero? ? "0.0" : "#{n.negative? ? '-' : ''}#{r / 10}.#{r % 10}"
  end

  def fixed1(x)
    s = x.round(1).to_s
    s == "-0.0" ? "0.0" : s
  end

  def calc(temp:, humid:)
    return { "error" => "invalid_input" } unless temp.match?(/\A-?\d+(\.\d)?\z/)

    t = temp.to_f
    t10 = (t * 10).round # 小数第1位までなので、10倍すれば整数
    return { "error" => "invalid_input" } unless t.between?(-20, 40) && humid.between?(1, 100)

    es = 6.1078 * (10**((7.5 * t) / (237.3 + t)))
    gamma = Math.log(humid / 100.0) + (17.27 * t) / (237.7 + t)
    dew = humid == 100 ? t : (237.7 * gamma) / (17.27 - gamma)
    di = 8100 * t10 + humid * (99 * t10 - 14_300) + 4_630_000 # 不快指数 × 100000（整数）
    ah = (217 * es * (humid / 100.0)) / (t + 273.15)
    { "di" => tenths_text(di), "feel" => feel_of(di), "dew" => fixed1(dew), "abs_humidity" => fixed1(ah),
      "risk" => dew >= 18 ? "高い" : (dew >= 12 ? "中" : "低い") }
  end
end

# 露点・不快指数の計算。
# v1: to_f の Float と Math.log / ** で計算し、round(1) で小数第1位にする素直な書き方。

module Dew
  module_function

  FEEL = [[55, "寒い"], [60, "肌寒い"], [65, "何も感じない"], [70, "快適"], [75, "暑くない"], [80, "やや暑い"], [85, "暑くて汗が出る"]].freeze

  def feel_of(di)
    FEEL.each { |limit, label| return label if di < limit }
    "暑くてたまらない"
  end

  def calc(temp:, humid:)
    return { "error" => "invalid_input" } unless temp.match?(/\A-?\d+(\.\d)?\z/)

    t = temp.to_f
    return { "error" => "invalid_input" } unless t.between?(-20, 40) && humid.between?(1, 100)

    es = 6.1078 * (10**((7.5 * t) / (237.3 + t)))
    gamma = Math.log(humid / 100.0) + (17.27 * t) / (237.7 + t)
    dew = (237.7 * gamma) / (17.27 - gamma)
    di = 0.81 * t + 0.01 * humid * (0.99 * t - 14.3) + 46.3
    ah = (217 * es * (humid / 100.0)) / (t + 273.15)
    { "di" => di.round(1).to_s, "feel" => feel_of(di), "dew" => dew.round(1).to_s, "abs_humidity" => ah.round(1).to_s,
      "risk" => dew >= 18 ? "高い" : (dew >= 12 ? "中" : "低い") }
  end
end

import java.util.Locale
import kotlin.math.abs
import kotlin.math.ln
import kotlin.math.pow
import kotlin.math.roundToLong

// 露点・不快指数の計算。
// v2: 不快指数は 10万倍した整数で正確に計算して四捨五入する（Double だと 74.45 が 74.44999999999999 になり 74.4 に落ちる）。
// 露点・絶対湿度は ln / pow のまま（小数第1位では正確な値と一致することを確かめた）。
// "%.1f".format は -0.04 を "-0.0" にするので、0 に丸まる値は "0.0" にする。湿度100%の露点は気温そのもの。

// n は不快指数 × 100000（整数）
fun feelOf(n: Long): String = when {
    n < 5_500_000 -> "寒い"
    n < 6_000_000 -> "肌寒い"
    n < 6_500_000 -> "何も感じない"
    n < 7_000_000 -> "快適"
    n < 7_500_000 -> "暑くない"
    n < 8_000_000 -> "やや暑い"
    n < 8_500_000 -> "暑くて汗が出る"
    else -> "暑くてたまらない"
}

// 10万倍した整数 n を小数第1位に四捨五入した文字列（0.5 は 0 から遠い方へ）
fun tenthsText(n: Long): String {
    val r = (abs(n) + 5000) / 10000
    return if (r == 0L) "0.0" else (if (n < 0) "-" else "") + "${r / 10}.${r % 10}"
}

fun fixed1(x: Double): String {
    val s = String.format(Locale.ROOT, "%.1f", x)
    return if (s == "-0.0") "0.0" else s
}

fun dewPoint(temp: String, humid: Long): Map<String, Any?> {
    if (!Regex("""-?\d+(\.\d)?""").matches(temp)) return linkedMapOf("error" to "invalid_input")
    val t = temp.toDouble()
    if (t < -20 || t > 40 || humid < 1 || humid > 100) return linkedMapOf("error" to "invalid_input")
    val t10 = (t * 10).roundToLong() // 小数第1位までなので、10倍すれば整数
    val es = 6.1078 * 10.0.pow((7.5 * t) / (237.3 + t))
    val gamma = ln(humid / 100.0) + (17.27 * t) / (237.7 + t)
    val dew = if (humid == 100L) t else (237.7 * gamma) / (17.27 - gamma)
    val di = 8100 * t10 + humid * (99 * t10 - 14300) + 4_630_000 // 不快指数 × 100000（整数）
    val ah = (217 * es * (humid / 100.0)) / (t + 273.15)
    return linkedMapOf(
        "di" to tenthsText(di),
        "feel" to feelOf(di),
        "dew" to fixed1(dew),
        "abs_humidity" to fixed1(ah),
        "risk" to if (dew >= 18) "高い" else if (dew >= 12) "中" else "低い",
    )
}

import kotlin.math.ln
import kotlin.math.pow

// 露点・不快指数の計算。v1: Double と ln / pow で計算し、"%.1f".format で小数第1位にする素直な書き方。

fun feelOf(di: Double): String = when {
    di < 55 -> "寒い"
    di < 60 -> "肌寒い"
    di < 65 -> "何も感じない"
    di < 70 -> "快適"
    di < 75 -> "暑くない"
    di < 80 -> "やや暑い"
    di < 85 -> "暑くて汗が出る"
    else -> "暑くてたまらない"
}

fun dewPoint(temp: String, humid: Long): Map<String, Any?> {
    if (!Regex("""-?\d+(\.\d)?""").matches(temp)) return linkedMapOf("error" to "invalid_input")
    val t = temp.toDouble()
    if (t < -20 || t > 40 || humid < 1 || humid > 100) return linkedMapOf("error" to "invalid_input")
    val es = 6.1078 * 10.0.pow((7.5 * t) / (237.3 + t))
    val gamma = ln(humid / 100.0) + (17.27 * t) / (237.7 + t)
    val dew = (237.7 * gamma) / (17.27 - gamma)
    val di = 0.81 * t + 0.01 * humid * (0.99 * t - 14.3) + 46.3
    val ah = (217 * es * (humid / 100.0)) / (t + 273.15)
    return linkedMapOf(
        "di" to "%.1f".format(di),
        "feel" to feelOf(di),
        "dew" to "%.1f".format(dew),
        "abs_humidity" to "%.1f".format(ah),
        "risk" to if (dew >= 18) "高い" else if (dew >= 12) "中" else "低い",
    )
}

// 露点・不快指数の計算。
// v2: 不快指数は 10万倍した整数で正確に計算して四捨五入する（String(format: "%.1f") は2進数の値を偶数丸めするので 65.25 を 65.2 に、
// 66.35（中身は 66.349…）を 66.3 にした）。露点・絶対湿度は log / pow のまま（小数第1位では正確な値と一致することを
// 全60,100通りで確かめた）。0 に丸まる値は "-0.0" ではなく "0.0" にする。湿度100%の露点は気温そのもの。
import Foundation

private let labels = ["寒い", "肌寒い", "何も感じない", "快適", "暑くない", "やや暑い", "暑くて汗が出る", "暑くてたまらない"]

/// n は不快指数 × 100000（整数）
private func feelOf(_ n: Int) -> String {
    labels[[55, 60, 65, 70, 75, 80, 85].filter { n >= $0 * 100_000 }.count]
}

/// 10万倍した整数 n を小数第1位に四捨五入した文字列（0.5 は 0 から遠い方へ）
private func tenthsText(_ n: Int) -> String {
    let r = (abs(n) + 5000) / 10000
    return r == 0 ? "0.0" : "\(n < 0 ? "-" : "")\(r / 10).\(r % 10)"
}

private func fixed1(_ x: Double) -> String {
    let s = String(format: "%.1f", x)
    return s == "-0.0" ? "0.0" : s
}

/// 小数第1位までの数か（"20"・"7.5"・"-10.0"）
private func validTemp(_ t: String) -> Bool {
    let body = t.hasPrefix("-") ? t.dropFirst() : Substring(t)
    let parts = body.split(separator: ".", maxSplits: 1, omittingEmptySubsequences: false)
    let int = parts[0], frac = parts.count > 1 ? parts[1] : "0"
    return !int.isEmpty && int.allSatisfy { $0.isASCII && $0.isNumber } && frac.count == 1
        && frac.allSatisfy { $0.isASCII && $0.isNumber }
}

func dewPoint(temp: String, humid: Int) throws -> [String: Any] {
    guard validTemp(temp), let t = Double(temp), (-20...40).contains(t), (1...100).contains(humid) else {
        return ["error": "invalid_input"]
    }
    let h = Double(humid)
    let t10 = Int((t * 10).rounded()) // 小数第1位までなので、10倍すれば整数
    let es = 6.1078 * pow(10, (7.5 * t) / (237.3 + t))
    let gamma = log(h / 100) + (17.27 * t) / (237.7 + t)
    let dew = humid == 100 ? t : (237.7 * gamma) / (17.27 - gamma)
    let di = 8100 * t10 + humid * (99 * t10 - 14300) + 4_630_000 // 不快指数 × 100000（整数）
    let ah = (217 * es * (h / 100)) / (t + 273.15)
    let risk = dew >= 18 ? "高い" : (dew >= 12 ? "中" : "低い")
    return ["di": tenthsText(di), "feel": feelOf(di), "dew": fixed1(dew), "abs_humidity": fixed1(ah), "risk": risk]
}

// ランナー規約（標準入力の JSON → 標準出力の JSON）の共通部分。どの spec でも同じ内容。
// ロジックは別ファイル。spec ごとの「入力を読んで呼ぶ」部分は main.swift に書く。
//
// Swift は Int のあふれ・配列の範囲外・強制アンラップの失敗でプロセスごと止まり（trap）、
// 言語の中では受け止められない。1件の失敗で全体を落とさないため、ケースは子プロセス
// （自分自身を --child で起動）で回し、子が止まったらそのケースを error にして残りを続ける。
import Foundation

struct Failure: Error, CustomStringConvertible {
    let description: String
    init(_ message: String) { description = message }
}

typealias Input = [String: Any]

extension Dictionary where Key == String, Value == Any {
    func str(_ key: String) throws -> String {
        guard let v = self[key] as? String else { throw Failure("\(key) がありません（文字列）") }
        return v
    }

    func int(_ key: String) throws -> Int {
        // JSONSerialization の数は NSNumber。as? Int は整数で表せるときだけ成功する（1.5 は nil）
        guard let v = self[key] as? Int else {
            throw Failure("\(key) がありません（整数）")
        }
        return v
    }
}

/// Swift の nil を JSON の null にする
func orNull(_ v: Any?) -> Any { v ?? NSNull() }

// コンパイラの版（#if swift(...) は言語モードの版で、swiftc の既定では Swift 5 になるので使わない）
private let runtimeName: String = {
    #if compiler(>=6.5)
    return "Swift 6.5+"
    #elseif compiler(>=6.4)
    return "Swift 6.4"
    #elseif compiler(>=6.3)
    return "Swift 6.3"
    #elseif compiler(>=6.2)
    return "Swift 6.2"
    #elseif compiler(>=6.1)
    return "Swift 6.1"
    #elseif compiler(>=6.0)
    return "Swift 6.0"
    #else
    return "Swift 5"
    #endif
}()

private func toJSON(_ v: Any) throws -> Data {
    try JSONSerialization.data(withJSONObject: v, options: [.withoutEscapingSlashes])
}

private func fail(_ message: String) -> Never {
    FileHandle.standardError.write(Data((message + "\n").utf8))
    exit(1)
}

/// 子プロセス: cases を順に回し、1件ごとに1行の JSON を書いてすぐ flush する
private func runChild(_ cases: [Input], _ calc: (Input) throws -> [String: Any]) {
    for c in cases {
        let id = c["id"] ?? NSNull()
        var r: [String: Any] = ["id": id]
        do {
            r["output"] = try calc(c["input"] as? Input ?? [:])
        } catch {
            r["error"] = "\(error)"
        }
        guard let line = try? toJSON(r) else { fail("結果を JSON にできません: \(id)") }
        FileHandle.standardOutput.write(line + Data("\n".utf8))
    }
}

private func signalName(_ s: Int32) -> String {
    switch s {
    case SIGTRAP, SIGILL: return "signal \(s)（trap。整数のあふれ・配列の範囲外・nil の強制アンラップなど）"
    case SIGABRT: return "signal \(s)（abort）"
    case SIGSEGV, SIGBUS: return "signal \(s)（不正なメモリ参照）"
    default: return "signal \(s)"
    }
}

/// 親プロセス:子に cases を渡し、子が途中で止まったら、止まったケースを error にして続きから回す
private func runParent(_ cases: [Input]) -> [Any] {
    let exe = URL(fileURLWithPath: CommandLine.arguments[0])
    var results: [Any] = []
    var rest = cases[...]
    while !rest.isEmpty {
        let p = Process()
        p.executableURL = exe
        p.arguments = ["--child"]
        let (inPipe, outPipe, errPipe) = (Pipe(), Pipe(), Pipe())
        p.standardInput = inPipe
        p.standardOutput = outPipe
        p.standardError = errPipe
        do { try p.run() } catch { fail("子プロセスを起動できません: \(error)") }

        var errData = Data()
        let group = DispatchGroup()
        group.enter()
        DispatchQueue.global().async {
            errData = errPipe.fileHandleForReading.readDataToEndOfFile()
            group.leave()
        }
        guard let payload = try? toJSON(["cases": Array(rest)]) else { fail("cases を JSON にできません") }
        inPipe.fileHandleForWriting.write(payload)
        try? inPipe.fileHandleForWriting.close()
        let outData = outPipe.fileHandleForReading.readDataToEndOfFile()
        group.wait()
        p.waitUntilExit()

        let lines = outData.split(separator: UInt8(ascii: "\n"))
        for line in lines {
            guard let r = try? JSONSerialization.jsonObject(with: Data(line)) else { fail("子の出力を読めません") }
            results.append(r)
        }
        rest = rest.dropFirst(lines.count)
        if p.terminationReason == .exit && p.terminationStatus == 0 {
            if !rest.isEmpty { fail("子プロセスが途中で終わりました") }
            break
        }
        // 子が止まった: 次のケースが原因
        guard let crashed = rest.first else { fail("子プロセスが異常終了しました") }
        let stderrText = String(decoding: errData, as: UTF8.self)
        // -O ではあふれの trap はメッセージを出さず signal で止まる
        let reason = stderrText.split(separator: "\n").first { $0.contains("Fatal error") }
            .map(String.init)
            ?? (p.terminationReason == .uncaughtSignal ? signalName(p.terminationStatus) : "exit \(p.terminationStatus)")
        results.append(["id": crashed["id"] ?? NSNull(), "error": "クラッシュ（プロセスが停止）: \(reason)"])
        rest = rest.dropFirst()
    }
    return results
}

/// 標準入力の JSON を読み、cases をすべて calc に通して、標準出力に JSON を書く
func runCases(_ calc: (Input) throws -> [String: Any]) {
    let src = FileHandle.standardInput.readDataToEndOfFile()
    guard let req = (try? JSONSerialization.jsonObject(with: src)) as? Input,
          let cases = req["cases"] as? [Input] else { fail("入力の JSON を読めません") }
    if CommandLine.arguments.dropFirst().first == "--child" {
        runChild(cases, calc)
        return
    }
    let out: [String: Any] = [
        "spec": req["spec"] ?? NSNull(),
        "lang": "swift",
        "runtime": runtimeName,
        "results": runParent(cases),
    ]
    guard let data = try? toJSON(out) else { fail("結果を JSON にできません") }
    FileHandle.standardOutput.write(data + Data("\n".utf8))
}

// 露点・不快指数の計算。
// v1: 素直に書いた版（Double と log / pow で計算し、String(format: "%.1f") で小数第1位にする）。
import Foundation

private func feelOf(_ di: Double) -> String {
    if di < 55 { return "寒い" }
    if di < 60 { return "肌寒い" }
    if di < 65 { return "何も感じない" }
    if di < 70 { return "快適" }
    if di < 75 { return "暑くない" }
    if di < 80 { return "やや暑い" }
    if di < 85 { return "暑くて汗が出る" }
    return "暑くてたまらない"
}

/// 小数第1位までの数か（"20"・"7.5"・"-10.0"）
private func validTemp(_ t: String) -> Bool {
    let body = t.hasPrefix("-") ? t.dropFirst() : Substring(t)
    let parts = body.split(separator: ".", maxSplits: 1, omittingEmptySubsequences: false)
    let int = parts[0], frac = parts.count > 1 ? parts[1] : "0"
    return !int.isEmpty && int.allSatisfy { $0.isASCII && $0.isNumber } && frac.count == 1
        && frac.allSatisfy { $0.isASCII && $0.isNumber }
}

func dewPoint(temp: String, humid: Int) throws -> [String: Any] {
    guard validTemp(temp), let t = Double(temp), (-20...40).contains(t), (1...100).contains(humid) else {
        return ["error": "invalid_input"]
    }
    let h = Double(humid)
    let es = 6.1078 * pow(10, (7.5 * t) / (237.3 + t))
    let gamma = log(h / 100) + (17.27 * t) / (237.7 + t)
    let dew = (237.7 * gamma) / (17.27 - gamma)
    let di = 0.81 * t + 0.01 * h * (0.99 * t - 14.3) + 46.3
    let ah = (217 * es * (h / 100)) / (t + 273.15)
    let risk = dew >= 18 ? "高い" : (dew >= 12 ? "中" : "低い")
    return ["di": String(format: "%.1f", di), "feel": feelOf(di), "dew": String(format: "%.1f", dew),
            "abs_humidity": String(format: "%.1f", ah), "risk": risk]
}

// ランナー規約（標準入力の JSON → 標準出力の JSON）の共通部分。どの spec でも同じ内容。
// ロジックは別ファイル。spec ごとの「入力を読んで呼ぶ」部分は main.swift に書く。
//
// Swift は Int のあふれ・配列の範囲外・強制アンラップの失敗でプロセスごと止まり（trap）、
// 言語の中では受け止められない。1件の失敗で全体を落とさないため、ケースは子プロセス
// （自分自身を --child で起動）で回し、子が止まったらそのケースを error にして残りを続ける。
import Foundation

struct Failure: Error, CustomStringConvertible {
    let description: String
    init(_ message: String) { description = message }
}

typealias Input = [String: Any]

extension Dictionary where Key == String, Value == Any {
    func str(_ key: String) throws -> String {
        guard let v = self[key] as? String else { throw Failure("\(key) がありません（文字列）") }
        return v
    }

    func int(_ key: String) throws -> Int {
        // JSONSerialization の数は NSNumber。as? Int は整数で表せるときだけ成功する（1.5 は nil）
        guard let v = self[key] as? Int else {
            throw Failure("\(key) がありません（整数）")
        }
        return v
    }
}

/// Swift の nil を JSON の null にする
func orNull(_ v: Any?) -> Any { v ?? NSNull() }

private let runtimeName: String = {
    #if swift(>=6.5)
    return "Swift 6.5+"
    #elseif swift(>=6.4)
    return "Swift 6.4"
    #elseif swift(>=6.3)
    return "Swift 6.3"
    #elseif swift(>=6.2)
    return "Swift 6.2"
    #elseif swift(>=6.1)
    return "Swift 6.1"
    #elseif swift(>=6.0)
    return "Swift 6.0"
    #else
    return "Swift 5"
    #endif
}()

private func toJSON(_ v: Any) throws -> Data {
    try JSONSerialization.data(withJSONObject: v, options: [.withoutEscapingSlashes])
}

private func fail(_ message: String) -> Never {
    FileHandle.standardError.write(Data((message + "\n").utf8))
    exit(1)
}

/// 子プロセス: cases を順に回し、1件ごとに1行の JSON を書いてすぐ flush する
private func runChild(_ cases: [Input], _ calc: (Input) throws -> [String: Any]) {
    for c in cases {
        let id = c["id"] ?? NSNull()
        var r: [String: Any] = ["id": id]
        do {
            r["output"] = try calc(c["input"] as? Input ?? [:])
        } catch {
            r["error"] = "\(error)"
        }
        guard let line = try? toJSON(r) else { fail("結果を JSON にできません: \(id)") }
        FileHandle.standardOutput.write(line + Data("\n".utf8))
    }
}

private func signalName(_ s: Int32) -> String {
    switch s {
    case SIGTRAP, SIGILL: return "signal \(s)（trap。整数のあふれ・配列の範囲外・nil の強制アンラップなど）"
    case SIGABRT: return "signal \(s)（abort）"
    case SIGSEGV, SIGBUS: return "signal \(s)（不正なメモリ参照）"
    default: return "signal \(s)"
    }
}

/// 親プロセス:子に cases を渡し、子が途中で止まったら、止まったケースを error にして続きから回す
private func runParent(_ cases: [Input]) -> [Any] {
    let exe = URL(fileURLWithPath: CommandLine.arguments[0])
    var results: [Any] = []
    var rest = cases[...]
    while !rest.isEmpty {
        let p = Process()
        p.executableURL = exe
        p.arguments = ["--child"]
        let (inPipe, outPipe, errPipe) = (Pipe(), Pipe(), Pipe())
        p.standardInput = inPipe
        p.standardOutput = outPipe
        p.standardError = errPipe
        do { try p.run() } catch { fail("子プロセスを起動できません: \(error)") }

        var errData = Data()
        let group = DispatchGroup()
        group.enter()
        DispatchQueue.global().async {
            errData = errPipe.fileHandleForReading.readDataToEndOfFile()
            group.leave()
        }
        guard let payload = try? toJSON(["cases": Array(rest)]) else { fail("cases を JSON にできません") }
        inPipe.fileHandleForWriting.write(payload)
        try? inPipe.fileHandleForWriting.close()
        let outData = outPipe.fileHandleForReading.readDataToEndOfFile()
        group.wait()
        p.waitUntilExit()

        let lines = outData.split(separator: UInt8(ascii: "\n"))
        for line in lines {
            guard let r = try? JSONSerialization.jsonObject(with: Data(line)) else { fail("子の出力を読めません") }
            results.append(r)
        }
        rest = rest.dropFirst(lines.count)
        if p.terminationReason == .exit && p.terminationStatus == 0 {
            if !rest.isEmpty { fail("子プロセスが途中で終わりました") }
            break
        }
        // 子が止まった: 次のケースが原因
        guard let crashed = rest.first else { fail("子プロセスが異常終了しました") }
        let stderrText = String(decoding: errData, as: UTF8.self)
        // -O ではあふれの trap はメッセージを出さず signal で止まる
        let reason = stderrText.split(separator: "\n").first { $0.contains("Fatal error") }
            .map(String.init)
            ?? (p.terminationReason == .uncaughtSignal ? signalName(p.terminationStatus) : "exit \(p.terminationStatus)")
        results.append(["id": crashed["id"] ?? NSNull(), "error": "クラッシュ（プロセスが停止）: \(reason)"])
        rest = rest.dropFirst()
    }
    return results
}

/// 標準入力の JSON を読み、cases をすべて calc に通して、標準出力に JSON を書く
func runCases(_ calc: (Input) throws -> [String: Any]) {
    let src = FileHandle.standardInput.readDataToEndOfFile()
    guard let req = (try? JSONSerialization.jsonObject(with: src)) as? Input,
          let cases = req["cases"] as? [Input] else { fail("入力の JSON を読めません") }
    if CommandLine.arguments.dropFirst().first == "--child" {
        runChild(cases, calc)
        return
    }
    let out: [String: Any] = [
        "spec": req["spec"] ?? NSNull(),
        "lang": "swift",
        "runtime": runtimeName,
        "results": runParent(cases),
    ]
    guard let data = try? toJSON(out) else { fail("結果を JSON にできません") }
    FileHandle.standardOutput.write(data + Data("\n".utf8))
}