Question

我正在尝试计算各种输入的IEEE-754 32位浮点平方根但是对于一个特定的输入，基于Newton-Raphson方法的下面的算法将不会收敛，我想知道我能做些什么解决问题？对于我正在设计的平台，我有一个32位浮点加法器/减法器，乘法器和分频器。

对于输入0x7F7FFFFF（3.4028234663852886E38）。，该算法将无法收敛到18446743523953729536.000000的正确答案。此算法的答案为18446743523953737728.000000。

在使用硬件实现之前，我正在使用MATLAB来实现我的代码。我只能使用单精度浮点值（所以没有多少）。

clc; clear; close all;

% Input
R = typecast(uint32(hex2dec(num2str(dec2hex(((hex2dec('7F7FFFFF'))))))),'single')

% Initial estimate
OneOverRoot2 = single(1/sqrt(2));
Root2 = single(sqrt(2));

% Get low and high bits of input R
hexdata_high = bitand(bitshift(hex2dec(num2hex(single(R))),-16),hex2dec('ffff'));
hexdata_low = bitand(hex2dec(num2hex(single(R))),hex2dec('ffff'));

% Change exponent of input to -1 to get Mantissa
temp = bitand(hexdata_high,hex2dec('807F'));
Expo = bitshift(bitand(hexdata_high,hex2dec('7F80')),-7);
hexdata_high = bitor(temp,hex2dec('3F00'));
b = typecast(uint32(hex2dec(num2str(dec2hex(((bitshift(hexdata_high,16)+ hexdata_low)))))),'single');

% If exponent is odd ...
if (bitand(Expo,1))
    % Pretend the mantissa [0.5 ... 1.0) is multiplied by 2 as Expo is odd,
    %   so it now has the value [1.0 ... 2.0)
    % Estimate the sqrt(mantissa) as [1.0 ... sqrt(2))
    % IOW: linearly map (0.5 ... 1.0) to (1.0 ... sqrt(2))
    Mantissa = (Root2 - 1.0)/(1.0 - 0.5)*(b - 0.5) + 1.0;
else
    % The mantissa is in range [0.5 ... 1.0)
    % Estimate the sqrt(mantissa) as [1/sqrt(2) ... 1.0)
    % IOW: linearly map (0.5 ... 1.0) to (1/sqrt(2) ... 1.0)
    Mantissa = (1.0 - OneOverRoot2)/(1.0 - 0.5)*(b - 0.5) + OneOverRoot2;
end

newS = Mantissa*2^(bitshift(Expo-127,-1));
S=newS

% S = (S + R/S)/2 method
for j = 1:6 
    fprintf('S  %u %f %f\n', j, S, (S-sqrt(R)));
    S = single((single(S) + single(single(R)/single(S))))/2;
    S = single(S);
end

goodaccuracy =  (abs((single(S)-single(sqrt(single(R)))))) < 2^-23
difference = (abs((single(S)-single(sqrt(single(R))))))

% Get hexadecimal output
hexdata_high = (bitand(bitshift(hex2dec(num2hex(single(S))),-16),hex2dec('ffff')));
hexdata_low = (bitand(hex2dec(num2hex(single(S))),hex2dec('ffff')));
fprintf('FLOAT: T  Input: %e\t\tCorrect: %e\t\tMy answer: %e\n', R, sqrt(R), S);
fprintf('output hex = 0x%04X%04X\n',hexdata_high,hexdata_low);
out = hex2dec(num2hex(single(S)));

Answer 1

我对此感到震惊。这就是我想出的：

float mysqrtf(float f) {
  if (f < 0) return 0.0f/0.0f;
  if (f == 1.0f / 0.0f) return f;
  if (f != f) return f;

  // half-ass an initial guess of 1.0.
  int expo;
  float foo = frexpf(f, &expo);
  float s = 1.0;
  if (expo & 1) foo *= 2, expo--;

  // this is the only case for which what's below fails.
  if (foo == 0x0.ffffffp+0) return ldexpf(0x0.ffffffp+0, expo/2);

  // do four newton iterations.
  for (int i = 0; i < 4; i++) {
   float diff = s*s-foo;
    diff /= s;
    s -= diff/2;
  }

  // do one last newton iteration, computing s*s-foo exactly.
  float scal = s >= 1 ? 4096 : 2048;
  float shi = (s + scal) - scal; // high 12 bits of significand
  float slo = s - shi; // rest of significand
  float diff = shi * shi - foo; // subtraction exact by sterbenz's theorem
  diff += 2 * shi * slo; // opposite signs; exact by sterbenz's theorem
  diff += slo * slo;
  diff /= s; // diff == fma(s, s, -foo) / s.
  s -= diff/2;

  return ldexpf(s, expo/2);
}

要分析的第一件事是浮点运算中的公式(s*s-foo)/s。如果s足够接近sqrt(foo)，Sterbenz定理告诉我们分子在正确答案的ulp（foo）内 - 所有这个错误都是来自计算的近似误差{{ 1}}。然后我们除以s*s;这给了我们最坏的另一半近似误差。因此，即使没有融合的乘法加法，s也应该在1.5 ulp以内。我们把它除以两个。

请注意，只要您使用足够的牛顿迭代进行跟踪，初始猜测本身并不重要。

通过abs（s-foo / s）测量近似值s对sqrt（foo）的误差。我初始猜测1的误差最多为1.精确算术中的牛顿迭代将误差平方并将其除以4.浮点运算中的牛顿迭代---我做了四次的方式---正方形错误，将其除以4，然后再踢出0.75 ulp的错误。你这样做了四次，你发现你最多有diff的相对误差，大约是0.77 ulp。这意味着四次牛顿迭代产生了忠实的圆形结果。

我做第五步牛顿步骤以获得正确的圆角平方根。它起作用的原因有点复杂。

0x0.000000C4018384持有shi的“上半部分”，而s持有“下半部分”。每个有效数字中的最后12位将为零。这尤其意味着slo和shi * shi以及shi * slo可以完全代表slo * slo。

float在s*s的两个ulps范围内。 foo在shi*shi的2047 ulps范围内。因此s*s在2049 ulps之内;特别是，它完全可以表示并且小于2 ^-10。

您可以检查是否可以添加shi * shi - foo并获得一个精确可表示的结果，该结果在2 ^-22为零之内，然后添加2 * shi * slo并获得可准确表示的结果--- slo*slo完全计算。

除以s*s-foo时，由于我们的误差已经很小，因此你会在这里发出额外的半个误差，最多为2 ^-48。

现在我们做一个牛顿步骤。我们已经将当前误差正确地计算到2 ^-46之内。将其中的一半加到s给我们平方根到3 * 2 ^-48。

为了保证正确的舍入，我们需要证明在1/2和2之间没有s s，而不是我特殊的那个，其平方根在3 *之内2 <连续> -48 两个连续float之间的中点。您可以进行一些误差分析，得到丢番图方程，找到丢番图方程的所有解，找出它们对应的输入，并找出算法对它们的作用。（如果你这样做，有一个“物理”解决方案和一堆“非物理”解决方案。唯一真正的解决方案是我特别容易解决的问题。）然而，可能有一种更清洁的方式。

如何修复这个浮点平方根算法

1 个答案: