Làm thế nào để sử dụng nan và inf trong C?

Tôi có một phương pháp số có thể trả về nan hoặc inf nếu có lỗi và để thử nghiệm có mục đích, tôi muốn tạm thời buộc nó trả về nan hoặc inf để đảm bảo tình huống được xử lý chính xác. Có cách nào đáng tin cậy, không phụ thuộc vào trình biên dịch để tạo giá trị nan và inf trong C không?

Sau khi googling khoảng 10 phút, tôi chỉ có thể tìm thấy các giải pháp phụ thuộc vào trình biên dịch.

Bạn có thể kiểm tra xem triển khai của mình có nó không:

#include <math.h>
#ifdef NAN
/* NAN is supported */
#endif
#ifdef INFINITY
/* INFINITY is supported */
#endif

Sự tồn tại của INFINITYđược đảm bảo bởi C99 (hoặc ít nhất là bản nháp mới nhất) và "mở rộng thành một biểu thức không đổi của kiểu float đại diện cho vô cùng dương hoặc không dấu, nếu có; khác với một hằng số dương của kiểu float tràn tại thời điểm dịch."

NAN có thể được xác định hoặc không, và "được xác định nếu và chỉ khi việc triển khai hỗ trợ các NaN yên tĩnh cho kiểu float. Nó mở rộng thành một biểu thức không đổi của kiểu float đại diện cho một NaN yên tĩnh."

Lưu ý rằng nếu bạn đang so sánh các giá trị dấu phẩy động và thực hiện:

a = NAN;

thậm chí sau đó,

a == NAN;

là sai. Một cách để kiểm tra NaN sẽ là:

#include <math.h>
if (isnan(a)) { ... }

Bạn cũng có thể làm: a != ađể kiểm tra xem acó phải là NaN không.

Ngoài ra còn có isfinite(), isinf(), isnormal(), và signbit()macro trong math.htrong C99.

C99 cũng có các nanchức năng:

#include <math.h>
double nan(const char *tagp);
float nanf(const char *tagp);
long double nanl(const char *tagp);

(Tham khảo: n1256).

Tài liệu INFINITY Tài liệu NAN

Không có cách nào độc lập với trình biên dịch để làm điều này, vì cả tiêu chuẩn C (hoặc C ++) đều không nói rằng các kiểu toán dấu phẩy động phải hỗ trợ NAN hoặc INF.

Chỉnh sửa: Tôi vừa kiểm tra từ ngữ của tiêu chuẩn C ++ và nó nói rằng các hàm này (thành viên của lớp mẫu số_limits):

quiet_NaN() 
signalling_NaN()

wiill trả về các đại diện NAN "nếu có". Nó không mở rộng về "nếu có" nghĩa là gì, nhưng có lẽ là một cái gì đó như "nếu đại diện FP của triển khai hỗ trợ họ". Tương tự, có một chức năng:

infinity() 

trả về một đại diện INF tích cực "nếu có".

Cả hai đều được định nghĩa trong <limits>tiêu đề - Tôi đoán rằng tiêu chuẩn C có một cái gì đó tương tự (có thể cũng là "nếu có") nhưng tôi không có bản sao của tiêu chuẩn C99 hiện tại.

Điều này hoạt động cho cả floatvà double:

double NAN = 0.0/0.0;
double POS_INF = 1.0 /0.0;
double NEG_INF = -1.0/0.0;

Chỉnh sửa: Như ai đó đã nói, tiêu chuẩn IEEE cũ nói rằng các giá trị như vậy sẽ gây ra bẫy. Nhưng các trình biên dịch mới hầu như luôn tắt bẫy và trả về các giá trị đã cho vì bẫy cản trở việc xử lý lỗi.

Một cách độc lập với trình biên dịch, nhưng không phải là cách độc lập với bộ xử lý để có được những điều này:

int inf = 0x7F800000;
return *(float*)&inf;

int nan = 0x7F800001;
return *(float*)&nan;

Điều này sẽ hoạt động trên bất kỳ bộ xử lý nào sử dụng định dạng dấu chấm động IEEE 754 (mà x86 thực hiện).

CẬP NHẬT: Đã kiểm tra và cập nhật.

double a_nan = strtod("NaN", NULL);
double a_inf = strtod("Inf", NULL);

<inf.h>

/* IEEE positive infinity.  */

#if __GNUC_PREREQ(3,3)
# define INFINITY   (__builtin_inff())
#else
# define INFINITY   HUGE_VALF
#endif

và

<bits/nan.h>
#ifndef _MATH_H
# error "Never use <bits/nan.h> directly; include <math.h> instead."
#endif


/* IEEE Not A Number.  */

#if __GNUC_PREREQ(3,3)

# define NAN    (__builtin_nanf (""))

#elif defined __GNUC__

# define NAN \
  (__extension__                                  \
   ((union { unsigned __l __attribute__ ((__mode__ (__SI__))); float __d; })  \
    { __l: 0x7fc00000UL }).__d)

#else

# include <endian.h>

# if __BYTE_ORDER == __BIG_ENDIAN
#  define __nan_bytes       { 0x7f, 0xc0, 0, 0 }
# endif
# if __BYTE_ORDER == __LITTLE_ENDIAN
#  define __nan_bytes       { 0, 0, 0xc0, 0x7f }
# endif

static union { unsigned char __c[4]; float __d; } __nan_union
    __attribute_used__ = { __nan_bytes };
# define NAN    (__nan_union.__d)

#endif  /* GCC.  */

Tôi cũng ngạc nhiên vì đây không phải là hằng số thời gian biên dịch. Nhưng tôi cho rằng bạn có thể tạo các giá trị này đủ dễ dàng bằng cách đơn giản thực hiện một lệnh trả về kết quả không hợp lệ như vậy. Chia cho 0, log cho 0, tan cho 90, đại loại là vậy.

Tôi thường sử dụng

#define INFINITY (1e999)

hoặc là

const double INFINITY = 1e999

hoạt động ít nhất trong ngữ cảnh IEEE 754 vì giá trị kép cao nhất có thể biểu diễn là gần đúng 1e308. 1e309cũng sẽ hoạt động tốt 1e99999, nhưng ba số chín là đủ và đáng nhớ. Vì đây là một ký tự kép (trong #definetrường hợp) hoặc một Infgiá trị thực , nó sẽ vẫn là vô hạn ngay cả khi bạn đang sử dụng phao 128 bit (“dài đôi”).

Đây là một cách đơn giản để xác định các hằng số đó và tôi khá chắc chắn rằng nó có thể di động:

const double inf = 1.0/0.0;
const double nan = 0.0/0.0;

Khi tôi chạy mã này:

printf("inf  = %f\n", inf);
printf("-inf = %f\n", -inf);
printf("nan  = %f\n", nan);
printf("-nan = %f\n", -nan);

Tôi có:

inf  = inf
-inf = -inf
nan  = -nan
-nan = nan