假设我有一个浮动X.我想找到小于X的最大数字，并且可以无损地存储在浮点数中。
IIRC IEEE标准说你可以通过将float的位转换为int表示，减去1，然后转换回float来实现。（编辑：对于非NaN或inf的正数，这是正确的。对于负数，您必须添加。有关详细信息，请参阅Rawling's answer。）
要在表示之间进行更改，我只知道C＃的（强制转换）运算符，它会截断。那不是我想要的。
有没有办法在C＃中执行此操作？
答案 0 :(得分：8)
以下是如何将float简单地转换为int，更改它，然后将其转回float：
float myFloat = 10.3f;
// Get the bytes making up the float
byte[] bytes = BitConverter.GetBytes(myFloat);
// Make an int out of them
int myInt = BitConverter.ToInt32(bytes, 0);
// Change it
myInt--;
// Get the bytes making up the int
bytes = BitConverter.GetBytes(myInt);
// Make a float out of them
myFloat = BitConverter.ToSingle(bytes, 0);
// gives 10.2999992 or so
BitConverter甚至内置了64位等效项：
double myDouble = 10.3;
long myLong = BitConverter.DoubleToInt64Bits(myDouble);
myLong--;
myDouble = BitConverter.Int64BitsToDouble(myLong); // gives 10.2999999...
但是，正如Peter Ruderman所指出的那样，基础int的简单递减并不能可靠地为您提供下一个最小的float。
特别是，对于负数，您需要递增整数，以使float 更负面。对于float零，下一个最小int实际上对应NaN，因此您需要一个特殊情况。
以下是我要拼凑的一些功能，这些功能应该能够应对这些情况;它也看起来像是在大数和正/负无穷大之间合理传播！我使用了不安全的转换来减少代码长度，但如果您愿意，可以坚持上面的字节转换：
static unsafe float Increment(float f)
{
int val = *(int*)&f;
if (f > 0)
val++;
else if (f < 0)
val--;
else if (f == 0)
return float.Epsilon;
return *(float*)&val;
}
static unsafe float Decrement(float f)
{
int val = *(int*)&f;
if (f > 0)
val--;
else if (f < 0)
val++;
else if (f == 0)
return -float.Epsilon; // thanks to Sebastian Negraszus
return *(float*)&val;
}
正如Jeppe指出的那样，你可能也想
if (float.IsNaN(f)) return f;启动每个函数，这样您就不会意外地增加或减少NaN并提供一些数字。float.PositiveInfinity或.NegativeInfinity的输入，因为从数学上讲，这些输入应该在增量/减量下保持不变。答案 1 :(得分：3)
有一个库例程，nexttowardf(x, -INFINITY);。
如果您想使用自己的代码进行操作，可以本机执行（在IEEE 754浮点运算中，无需访问浮点编码或组件），如下所示（在C中）。
提供了两个版本，一个在每种情况下使用一个次正规值（在某些处理器上可能很慢），另一个在输入很小的情况下使用次正规值（但它有一个分支）。虽然可以通过简单的测试添加支持，但不支持+ INFINITY作为输入。这是为double编写的，但float的更改很简单。
如果定义了CompileMain，它还包括一个测试程序。
#include <float.h>
#include <math.h>
/* Return the next floating-point value before the finite value q.
This was inspired by Algorithm 3.5 in Siegfried M. Rump, Takeshi Ogita, and
Shin'ichi Oishi, "Accurate Floating-Point Summation", _Technical Report
05.12_, Faculty for Information and Communication Sciences, Hamburg
University of Technology, November 13, 2005.
*/
double NextBefore(double q)
{
// SmallestPositive is the smallest positive floating-point number.
static const double SmallestPositive = DBL_EPSILON * DBL_MIN;
/* Scale is .625 ULP, so multiplying it by any significand in [1, 2)
yields something in [.625 ULP, 1.25 ULP].
*/
static const double Scale = 0.625 * DBL_EPSILON;
#if 0
/* This version has a branch but uses subnormal values only if q is so
small that q * Scale is subnormal.
*/
double increment = fabs(q)*Scale;
if (0. == increment)
return q - SmallestPositive;
return q - increment;
#else
/* This version uses a subnormal, SmallestPositive, in each case.
This might cause poor performance on some processors.
*/
return q - fmax(SmallestPositive, fabs(q)*Scale);
#endif
}
#if defined CompileMain
#include <stdio.h>
#include <stdlib.h>
#define NumberOf(a) (sizeof (a) / sizeof *(a))
int main(void)
{
int status = EXIT_SUCCESS;
static const struct { double in, out; } cases[] =
{
{ -INFINITY, -INFINITY },
{ -0x1.fffffffffffffp1023, -INFINITY },
{ -0x1.ffffffffffffep1023, -0x1.fffffffffffffp1023 },
{ -0x1.ffffffffffffdp1023, -0x1.ffffffffffffep1023 },
{ -0x1.ffffffffffffcp1023, -0x1.ffffffffffffdp1023 },
{ -0x1.0000000000003p1023, -0x1.0000000000004p1023 },
{ -0x1.0000000000002p1023, -0x1.0000000000003p1023 },
{ -0x1.0000000000001p1023, -0x1.0000000000002p1023 },
{ -0x1.0000000000000p1023, -0x1.0000000000001p1023 },
{ -0x1.fffffffffffffp1022, -0x1.0000000000000p1023 },
{ -0x1.fffffffffffffp1, -0x1.0000000000000p2 },
{ -0x1.ffffffffffffep1, -0x1.fffffffffffffp1 },
{ -0x1.ffffffffffffdp1, -0x1.ffffffffffffep1 },
{ -0x1.ffffffffffffcp1, -0x1.ffffffffffffdp1 },
{ -0x1.0000000000003p1, -0x1.0000000000004p1 },
{ -0x1.0000000000002p1, -0x1.0000000000003p1 },
{ -0x1.0000000000001p1, -0x1.0000000000002p1 },
{ -0x1.0000000000000p1, -0x1.0000000000001p1 },
{ -0x1.fffffffffffffp-1022, -0x1.0000000000000p-1021 },
{ -0x1.ffffffffffffep-1022, -0x1.fffffffffffffp-1022 },
{ -0x1.ffffffffffffdp-1022, -0x1.ffffffffffffep-1022 },
{ -0x1.ffffffffffffcp-1022, -0x1.ffffffffffffdp-1022 },
{ -0x1.0000000000003p-1022, -0x1.0000000000004p-1022 },
{ -0x1.0000000000002p-1022, -0x1.0000000000003p-1022 },
{ -0x1.0000000000001p-1022, -0x1.0000000000002p-1022 },
{ -0x1.0000000000000p-1022, -0x1.0000000000001p-1022 },
{ -0x0.fffffffffffffp-1022, -0x1.0000000000000p-1022 },
{ -0x0.ffffffffffffep-1022, -0x0.fffffffffffffp-1022 },
{ -0x0.ffffffffffffdp-1022, -0x0.ffffffffffffep-1022 },
{ -0x0.ffffffffffffcp-1022, -0x0.ffffffffffffdp-1022 },
{ -0x0.0000000000003p-1022, -0x0.0000000000004p-1022 },
{ -0x0.0000000000002p-1022, -0x0.0000000000003p-1022 },
{ -0x0.0000000000001p-1022, -0x0.0000000000002p-1022 },
{ -0x0.0000000000000p-1022, -0x0.0000000000001p-1022 },
{ +0x1.fffffffffffffp1023, +0x1.ffffffffffffep1023 },
{ +0x1.ffffffffffffep1023, +0x1.ffffffffffffdp1023 },
{ +0x1.ffffffffffffdp1023, +0x1.ffffffffffffcp1023 },
{ +0x1.0000000000004p1023, +0x1.0000000000003p1023 },
{ +0x1.0000000000003p1023, +0x1.0000000000002p1023 },
{ +0x1.0000000000002p1023, +0x1.0000000000001p1023 },
{ +0x1.0000000000001p1023, +0x1.0000000000000p1023 },
{ +0x1.0000000000000p1023, +0x1.fffffffffffffp1022 },
{ +0x1.0000000000000p2, +0x1.fffffffffffffp1 },
{ +0x1.fffffffffffffp1, +0x1.ffffffffffffep1 },
{ +0x1.ffffffffffffep1, +0x1.ffffffffffffdp1 },
{ +0x1.ffffffffffffdp1, +0x1.ffffffffffffcp1 },
{ +0x1.0000000000004p1, +0x1.0000000000003p1 },
{ +0x1.0000000000003p1, +0x1.0000000000002p1 },
{ +0x1.0000000000002p1, +0x1.0000000000001p1 },
{ +0x1.0000000000001p1, +0x1.0000000000000p1 },
{ +0x1.0000000000000p-1021, +0x1.fffffffffffffp-1022 },
{ +0x1.fffffffffffffp-1022, +0x1.ffffffffffffep-1022 },
{ +0x1.ffffffffffffep-1022, +0x1.ffffffffffffdp-1022 },
{ +0x1.ffffffffffffdp-1022, +0x1.ffffffffffffcp-1022 },
{ +0x1.0000000000004p-1022, +0x1.0000000000003p-1022 },
{ +0x1.0000000000003p-1022, +0x1.0000000000002p-1022 },
{ +0x1.0000000000002p-1022, +0x1.0000000000001p-1022 },
{ +0x1.0000000000001p-1022, +0x1.0000000000000p-1022 },
{ +0x1.0000000000000p-1022, +0x0.fffffffffffffp-1022 },
{ +0x0.fffffffffffffp-1022, +0x0.ffffffffffffep-1022 },
{ +0x0.ffffffffffffep-1022, +0x0.ffffffffffffdp-1022 },
{ +0x0.ffffffffffffdp-1022, +0x0.ffffffffffffcp-1022 },
{ +0x0.0000000000004p-1022, +0x0.0000000000003p-1022 },
{ +0x0.0000000000003p-1022, +0x0.0000000000002p-1022 },
{ +0x0.0000000000002p-1022, +0x0.0000000000001p-1022 },
{ +0x0.0000000000001p-1022, +0x0.0000000000000p-1022 },
};
for (int i = 0; i < NumberOf(cases); ++i)
{
double in = cases[i].in, expected = cases[i].out;
double observed = NextBefore(in);
printf("NextBefore(%a) = %a.\n", in, observed);
if (! (observed == expected))
{
printf("\tError, expected %a.\n", expected);
status = EXIT_FAILURE;
}
}
return status;
}
#endif // defined CompileMain