有符号字符 ATAN2 和 ATAN 近似值答案

【问题标题】：Signed Char ATAN2 and ATAN approximations有符号字符 ATAN2 和 ATAN 近似值
【发布时间】：2014-11-29 19:38:56
【问题描述】：

基本上，我一直在尝试制作两个近似函数。在这两种情况下，我都输入了“x”和“y”组件（以处理那些讨厌的 n/0 和 0/0 条件），并且需要得到一个 Signed Char 输出。在 ATAN2 的情况下，它应该提供 +/-PI 的范围，在 ATAN 的情况下，范围应该是 +/- PI/2。

我昨天整个时间都在试图绕过它。在 excel 中玩耍后，根据近似值找到了一个整体良好的算法：

    X * (PI/4 + 0.273 * (1 - |X|)) * 128/PI // Scale factor at end to switch to char format

我想出了以下代码：

signed char nabsSC(signed char x)
{
    if(x > 0)
        return -x;
    return x;
}

signed char signSC(signed char input, signed char ifZero = 0, signed char scaleFactor = 1)
{
    if(input > 0)
    {return scaleFactor;}

    else if(input < 0)
    {return -scaleFactor;}

    else
    {return ifZero;}
}

signed char divisionSC(signed char numerator, signed char denominator)
{
    if(denominator == 0)                // Error Condition
    {return 0;}
    else
    {return numerator/denominator;}
}

//#######################################################################################

signed char atan2SC(signed char y, signed char x)
{
    // @todo make clearer : the code was deduced through trial and error in excel with brute force... not the best reasoning in the world but hey ho
    if((x == y) && (x == 0))                            // Error Condition
    {return 0;}

                                    // Prepare for algorithm Choice
    const signed char X = abs(x);
    signed char Y = abs(y);
    if(Y > 2)
    {Y = (Y << 1) + 4;}

    const signed char alpha1 = 43;
    const signed char alpha2 = 11;
                                    // Make Choice
    if(X <= Y)                          // x/y Path
    {
        const signed char beta = 64;
        const signed char a = divisionSC(x,y);          // x/y
        const signed char A = nabsSC(a);                // -|x/y|

        const signed char temp = a * (alpha1 + alpha2 * A);     // (x/y) * (32 + ((0.273 * 128) / PI) * (1 - |x/y|)))
                                                        // Small angle approximation of ARCTAN(X)
        if(y < 0)                   // Determine Quadrant
        {return -(temp + beta);}
        else
        {return -(temp - beta);}
    }
    else                                // y/x Path
    {
        const signed char a = divisionSC(y,x);          // y/x
        const signed char A = nabsSC(a);                // -|y/x|

        const signed char temp = a * (alpha1 + alpha2 * A);     // (y/x) * (32 + ((0.273 * 128) / PI) * (1 - |y/x|)))
                                                        // Small angle approximation of ARCTAN(X)

        if(x < 0)                   // Determine Quadrant
        {
            Y = signSC(y, -127, 127);                       // Sign(y)*127, if undefined: use -127
            return temp + Y;
        }
        else
        {return temp;}
    }
}

令我非常失望的是，实现的错误高达 180 度，而且几乎无处不在。（我在转换为有符号字符格式后将其与库中的 ATAN2F 进行了比较。）

我从这个网站得到了一般要点：http://geekshavefeelings.com/posts/fixed-point-atan2

谁能告诉我哪里出错了？以及我应该如何在没有这些疯狂的情况下接近 ATAN 变体（应该更精确，因为它看起来超过一半的范围）。

我目前在 Windows 上使用 QT creator 4.8.1。这段特定代码的最终平台最终将是一个没有 FPU 的微控制器，ATAN 功能将是使用的主要功能之一。因此，具有合理误差的效率（ATAN2 为 +/-2 度，ATAN 为 +/-1 度。这些是目前的猜测，所以我可能会增加范围，但是，90 度绝对是不可接受的！）是目标游戏。

提前感谢您的任何帮助！

编辑：澄清一下，ATAN2 和 ATAN 的输出是有符号的 char 值，但是这两种类型的范围是不同的范围。

ATAN2 的范围应为 -128 (-PI) 到 127 (+PI - PI/128)。

ATAN 的范围为 -128 (-PI/2) 到 127 (+PI/2 - PI/256)。

因此，两者的输出值可以被认为是两种不同的数据类型。

如有任何混淆，请见谅。

EDIT2：将隐式 int 数字显式转换为带符号的 char 常量。

【问题讨论】：

请注意，一个 8 位字节（如果您的微控制器上的 CHAR_BIT = 8）没有超过 256 个可能的值，而一个圆有 360 度。也许你可以写一些你想要的角度测量单位。
代码在signed char 上使用了大量操作，显然代码不应使用浮点数。但在C 中，temp = a * (43 + 11 * A); 调用int 操作，而不仅仅是signed char 操作。 1) int 操作是否可以接受？ 2) 你的微控制器的int 大小是多少。 3）你考虑过CORDIC吗？
一些参考信息BAMs.
您有 256 个可能的值映射到 256 个值。为什么不直接“离线”计算它，并在代码中使用查找表（这只会“花费”你 256 字节的内存）？
@chux 感谢您对隐式 int 声明的提醒。我希望现在已经明确定义了它们。在这种情况下，不能接受 int 操作。我查看了 CORDIC，但它在不使用多次迭代的情况下的性能可靠性困扰了我。感谢 BAM 的链接，我已经掌握了一般要点，但没有给它命名。

标签： c++ c atan2

【解决方案1】：

下面是大纲。以下是附加信息。

结果角度（二进制角度测量）准确地在数学上将单位圆分成 8 个楔形。假设 -128 到 127 char，对于 atan2SC()，每个八分圆的结果是 33 个整数：0 到 32 + 偏移量。（0 到 32，而不是 0 到 31，因为四舍五入。）对于 atan2SC()，结果是 0 到 64。因此，只需专注于计算 1 个主八分圆的结果，x,y 输入和 0 到 64 结果。 atan2SC() 和 atan2SC() 都可以使用这个辅助函数 at2()。对于atan2SC()，要找到中间角a，请使用a = at2(x,y)/2。对于atanSC()，请使用a = at2(-128, y)。
用a = divisionSC(x,y) 和a * (43 + 11 * A) 查找整数商会在除法中丢失太多信息。需要通过使用x,y 的方程找到atan2 近似值，可能形式为at2 = (a*y*y + b*y)/(c*x*x + d*x)。
最好使用负绝对值，如 nabsSC()。整数的负范围满足或超过正范围。例如-128 到 -1 与 1 到 127。调用 at2() 时使用负数和 0。

[编辑]

下面是带有简化八分圆选择算法的代码。它经过精心构造，以确保对 x,y 的任何否定都将导致 SCHAR_MIN,SCHAR_MAX 范围 - 假设 2 的补码。所有八分圆都调用iat2()，在这里可以进行改进以提高精度。注意：iat2() 除以 x==0 被阻止，因为此时 x 不为 0。取决于舍入模式，如果此帮助函数与atanSC() 共享，将决定其详细信息。建议 2 分段线性表是宽整数数学不可用，否则线性 (ay+b)/(cx+d)。我可能会更多地玩这个。
精度与性能的权重对于 OP 的代码来说是至关重要的，但传递得不够好，我无法得出最佳答案。所以我在下面发布了一个测试驱动程序，用于评估iat2() OP 提出的任何细节的精确度。
存在 3 个陷阱。 1）当答案是+180度时，OP似乎想要-128 BAM。但是atan2(-1, 0.0) 提出了+pi。这种符号反转可能是一个问题。注意：atan2(-1, -0.0) --> -pi。 Ref。 2) 当答案略小于 +180 度时，取决于iat2() 的详细信息，整数 BAM 结果为 +128，趋向于回绕到 -128。 atan2() 结果刚好小于 +pi 或 +128 BAM。这个边缘条件需要在OP 的最终代码中审查。 3) (x=0,y=0) 情况需要特殊处理。八分圆选择代码找到它。
signed char atanSC(signed char x) 的代码，如果需要快速，可以使用几个 if()s 和一个 64 字节的查找表。（假设一个 8 位有符号字符）。在iat2() 中可以使用同一张表。

#include <stdio.h>
#include <stdlib.h>

// -x > -y >= 0, so divide by 0 not possible
static signed char iat2(signed char y, signed char x) {
  // printf("x=%4d y=%4d\n", x, y); fflush(stdout);
  return ((y*32+(x/2))/x)*2;  // 3.39 mxdiff
  // return ((y*64+(x/2))/x);    // 3.65 mxdiff
  // return (y*64)/x;            // 3.88 mxdiff
}

signed char iatan2sc(signed char y, signed char x) {
  // determine octant
  if (y >= 0) { // oct 0,1,2,3
    if (x >= 0) { // oct 0,1
      if (x > y) {
        return iat2(-y, -x)/2 + 0*32;
      } else {
        if (y == 0) return 0; // (x=0,y=0)
        return -iat2(-x, -y)/2 + 2*32;
      }
    } else { // oct 2,3
      // if (-x <= y) {
      if (x >= -y) {
        return iat2(x, -y)/2 + 2*32;
      } else {
        return -iat2(-y, x)/2 + 4*32;
      }
    }
  } else { // oct 4,5,6,7
    if (x < 0) { // oct 4,5
      // if (-x > -y) {
      if (x < y) {
        return iat2(y, x)/2 + -4*32;
      } else {
        return -iat2(x, y)/2 + -2*32;
      }
    } else { // oct 6,7
      // if (x <= -y) {
      if (-x >= y) {
        return iat2(-x, y)/2 + -2*32;
      } else {
        return -iat2(y, -x)/2 + -0*32;
      }
    }
  }
}

#include <math.h>

static void test_iatan2sc(signed char y, signed char x) {
  static int mn=INT_MAX;
  static int mx=INT_MIN;
  static double mxdiff = 0;

  signed char i = iatan2sc(y,x);
  static const double Pi = 3.1415926535897932384626433832795;
  double a = atan2(y ? y : -0.0, x) * 256/(2*Pi);

  if (i < mn) {
    mn = i;
    printf ("x=%4d,y=%4d  --> %4d   %f, mn %d mx %d mxdiff %f\n", 
        x,y,i,a,mn,mx,mxdiff);
  }
  if (i > mx) {
    mx = i;
    printf ("x=%4d,y=%4d  --> %4d   %f, mn %d mx %d mxdiff %f\n", 
        x,y,i,a,mn,mx,mxdiff);
  }

  double diff = fabs(i - a);
  if (diff > 128) diff = fabs(diff - 256);

  if (diff > mxdiff) {
    mxdiff = diff;
    printf ("x=%4d,y=%4d  --> %4d   %f, mn %d mx %d mxdiff %f\n", 
        x,y,i,a,mn,mx,mxdiff);
  }
}


int main(void) {
  int x,y;
  int n = 127;
  for (y = -n-1; y <= n; y++) {
    for (x = -n-1; x <= n; x++) {
      test_iatan2sc(y,x);
    }
  }
  puts("Done");
  return 0;
}

顺便说一句：一个有趣的问题。

【讨论】：

感谢您的回答，我没有考虑过仅处理该范围的第三个函数，明天下班后尝试对其进行编码。我同意我在那里丢失了很多信息，但是我认为在将内容限制为签名字符时我会丢失很多信息，只是没有这么多=p。另一方面，我需要减少执行的操作总数，因为这些特定功能将在整个项目中广泛使用（技术上只是减少功能的时间，但这与执行的操作的数量和类型有关） .