C言語の無限大・NaN完全ガイド 判定・比較・例外処理まで解説

#include <stdio.h>
#include <math.h>

int main(void) {
    // math.h で定義されている無限大
    float  pos_inf_f = INFINITY;   // float型の正の無限大
    double pos_inf   = INFINITY;   // doubleへも代入可能

    // 負の無限大は符号をつけて生成
    double neg_inf   = -INFINITY;

    printf("pos_inf_f = %f\n", pos_inf_f);
    printf("pos_inf   = %f\n", pos_inf);
    printf("neg_inf   = %f\n", neg_inf);

    return 0;
}

#include <stdio.h>
#include <math.h>

int main(void) {
    double a = 1.0;
    double b = 0.0;

    // 非ゼロ / 0.0 は正または負の無限大 (実装依存の例外発生の可能性あり)
    double c = a / b;   // 1.0 / 0.0 → +inf (IEEE 754想定)

    double big = 1e308;
    double d = big * big; // オーバーフロー → +inf が典型的な挙動

    printf("a / b  = %f\n", c);
    printf("big*big= %f\n", d);

    return 0;
}

#include <stdio.h>
#include <math.h>

void check_value(double x) {
    if (isinf(x)) {
        if (x > 0) {
            printf("値は正の無限大です\n");
        } else {
            printf("値は負の無限大です\n");
        }
    } else {
        printf("値は無限大ではありません (x = %f)\n", x);
    }
}

int main(void) {
    double x1 = INFINITY;   // 正の無限大
    double x2 = -INFINITY;  // 負の無限大
    double x3 = 123.45;     // 通常の値

    check_value(x1);
    check_value(x2);
    check_value(x3);

    return 0;
}

#include <stdio.h>
#include <math.h>

void classify(double x) {
    if (isnan(x)) {
        printf("NaN です\n");
    } else if (isinf(x)) {
        printf("無限大です\n");
    } else if (isfinite(x)) {
        printf("有限値です (x = %f)\n", x);
    } else {
        printf("その他の値です\n");
    }
}

int main(void) {
    double a = 1.0 / 0.0;     // +inf (想定)
    double b = 0.0 / 0.0;     // NaN  (想定)
    double c = 123.456;       // 有限値

    classify(a);
    classify(b);
    classify(c);

    return 0;
}

#include <stdio.h>
#include <math.h>

int main(void) {
    float  nan_f = NAN;   // float型のNaN
    double nan_d = NAN;   // doubleにも代入できる

    printf("nan_f = %f\n", nan_f);
    printf("nan_d = %f\n", nan_d);

    return 0;
}

#include <stdio.h>
#include <math.h>

int main(void) {
    double x1 = 0.0 / 0.0;        // 0/0 → NaN (想定)
    double x2 = INFINITY - INFINITY; // ∞ - ∞ → NaN (想定)
    double x3 = sqrt(-1.0);       // 負数の平方根 → NaN (想定)

    printf("0.0 / 0.0        = %f\n", x1);
    printf("INFINITY - INFINITY = %f\n", x2);
    printf("sqrt(-1.0)       = %f\n", x3);

    return 0;
}

#include <stdio.h>
#include <math.h>

void check_nan(double x) {
    if (isnan(x)) {
        printf("値は NaN です\n");
    } else {
        printf("値は NaN ではありません (x = %f)\n", x);
    }
}

int main(void) {
    double a = 0.0 / 0.0;  // NaN (想定)
    double b = 1.0 / 0.0;  // +inf (想定)
    double c = 42.0;       // 有限値

    check_nan(a);
    check_nan(b);
    check_nan(c);

    return 0;
}

double x = 0.0 / 0.0; // NaN (想定)

// これは NaN 判定としては誤り
if (x == NAN) {
    // ここには決して到達しません
}

#include <stdio.h>

int main(void) {
    double x = 0.0 / 0.0;   // NaN (想定)

    if (x != x) {
        printf("xはNaNと判定されました (x != x)\n");
    } else {
        printf("xはNaNではありません\n");
    }

    return 0;
}

#include <stdio.h>
#include <math.h>

int main(void) {
    double p = INFINITY;
    double n = -INFINITY;
    double x = 1.0;

    printf("INFINITY == INFINITY : %d\n", p == INFINITY);
    printf("-INFINITY == -INFINITY : %d\n", n == -INFINITY);
    printf("INFINITY > 1.0 : %d\n", p > x);
    printf("-INFINITY < 1.0 : %d\n", n < x);

    return 0;
}

#include <stdio.h>
#include <math.h>

int main(void) {
    double x = NAN;
    double y = 1.0;

    printf("x == x : %d\n", x == x);
    printf("x != x : %d\n", x != x);
    printf("x < y  : %d\n", x < y);
    printf("x > y  : %d\n", x > y);
    printf("x <= y : %d\n", x <= y);
    printf("x >= y : %d\n", x >= y);

    return 0;
}

#include <stdio.h>
#include <math.h>
#include <errno.h>

int main(void) {
    errno = 0;                 // 事前にクリア
    double x = -1.0;
    double y = log(x);         // log(-1) は定義されない → NaN (想定)

    if (errno != 0) {
        perror("log error");
    }

    if (isnan(y)) {
        printf("結果は NaN です\n");
    }

    return 0;
}

#include <stdio.h>
#include <math.h>

double safe_div(double a, double b) {
    double result = a / b;

    if (isnan(result)) {
        printf("警告: a/b の結果が NaN になりました (a=%f, b=%f)\n", a, b);
    } else if (isinf(result)) {
        printf("警告: a/b の結果が無限大になりました (a=%f, b=%f)\n", a, b);
    }

    return result;
}

int main(void) {
    safe_div(1.0, 0.0);   // 無限大 (想定)
    safe_div(0.0, 0.0);   // NaN (想定)
    safe_div(1.0, 2.0);   // 正常

    return 0;
}

#include <stdio.h>
#include <math.h>

double sanitize(double x) {
    if (isnan(x)) {
        return 0.0;        // NaN → 0.0 に置き換え
    }
    if (x > 1e6) {         // 上限を設定
        return 1e6;
    }
    if (x < -1e6) {        // 下限を設定
        return -1e6;
    }
    return x;              // 問題なし
}

int main(void) {
    double values[] = { NAN, INFINITY, -INFINITY, 100.0 };
    size_t n = sizeof(values) / sizeof(values[0]);

    for (size_t i = 0; i < n; i++) {
        double s = sanitize(values[i]);
        printf("raw=%f, sanitized=%f\n", values[i], s);
    }

    return 0;
}

#include <stdio.h>
#include <math.h>

// 入力値を検証しながら平方根を計算する関数
// 戻り値: 正常な場合 0、異常な場合 非0
int safe_sqrt(double x, double *out_result) {
    if (x < 0.0) {
        // 負の数の平方根は定義されない
        fprintf(stderr, "エラー: 負の入力に対するsqrt(x)です (x=%f)\n", x);
        *out_result = NAN;
        return -1;
    }

    double r = sqrt(x);

    if (isnan(r) || isinf(r)) {
        fprintf(stderr, "エラー: sqrtの結果がNaNまたは無限大です (x=%f)\n", x);
        *out_result = NAN;
        return -2;
    }

    *out_result = r;
    return 0;
}

int main(void) {
    double inputs[] = { 4.0, -1.0, INFINITY };
    size_t n = sizeof(inputs) / sizeof(inputs[0]);

    for (size_t i = 0; i < n; i++) {
        double x = inputs[i];
        double r;
        int err = safe_sqrt(x, &r);

        if (err == 0) {
            printf("sqrt(%f) = %f\n", x, r);
        } else {
            printf("sqrt(%f) に失敗しました (err=%d)\n", x, err);
        }
    }

    return 0;
}

#include <stdio.h>
#include <math.h>

// 配列内にNaNまたは無限大が含まれているか調べる
int has_nan_or_inf(const double *arr, size_t n) {
    for (size_t i = 0; i < n; i++) {
        if (isnan(arr[i]) || isinf(arr[i])) {
            return 1;   // 見つかった
        }
    }
    return 0;           // 見つからなかった
}

int main(void) {
    double a[] = { 1.0, 2.0, 3.0 };
    double b[] = { 1.0, NAN, 3.0 };
    double c[] = { 1.0, INFINITY, 3.0 };

    printf("a: %d\n", has_nan_or_inf(a, 3));
    printf("b: %d\n", has_nan_or_inf(b, 3));
    printf("c: %d\n", has_nan_or_inf(c, 3));

    return 0;
}

#include <stdio.h>
#include <math.h>

void print_value_for_json(double x) {
    if (isnan(x)) {
        printf("\"NaN\"");
    } else if (isinf(x)) {
        if (x > 0) {
            printf("\"Infinity\"");
        } else {
            printf("\"-Infinity\"");
        }
    } else {
        printf("%f", x);
    }
}

int main(void) {
    double values[] = { 1.23, NAN, INFINITY, -INFINITY };
    size_t n = sizeof(values) / sizeof(values[0]);

    printf("[");
    for (size_t i = 0; i < n; i++) {
        if (i > 0) printf(", ");
        print_value_for_json(values[i]);
    }
    printf("]\n");

    return 0;
}