web-dev-qa-db-ja.com

C：フロートを間隔にラップする方法[-pi、pi）

効果的に実行できる素敵なCコードを探しています。

while (deltaPhase >= M_PI) deltaPhase -= M_TWOPI;
while (deltaPhase < -M_PI) deltaPhase += M_TWOPI;

私のオプションは何ですか？

cmathfloating-pointintervalsmodulo
38
P i

2013年4月19日編集：

Aka.Niceとarr_seaで指摘されている境界ケースを処理するように更新されたModulo関数：

static const double     _PI= 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348;
static const double _TWO_PI= 6.2831853071795864769252867665590057683943387987502116419498891846156328125724179972560696;

// Floating-point modulo
// The result (the remainder) has same sign as the divisor.
// Similar to matlab's mod(); Not similar to fmod() -   Mod(-3,4)= 1   fmod(-3,4)= -3
template<typename T>
T Mod(T x, T y)
{
    static_assert(!std::numeric_limits<T>::is_exact , "Mod: floating-point type expected");

    if (0. == y)
        return x;

    double m= x - y * floor(x/y);

    // handle boundary cases resulted from floating-point cut off:

    if (y > 0)              // modulo range: [0..y)
    {
        if (m>=y)           // Mod(-1e-16             , 360.    ): m= 360.
            return 0;

        if (m<0 )
        {
            if (y+m == y)
                return 0  ; // just in case...
            else
                return y+m; // Mod(106.81415022205296 , _TWO_PI ): m= -1.421e-14 
        }
    }
    else                    // modulo range: (y..0]
    {
        if (m<=y)           // Mod(1e-16              , -360.   ): m= -360.
            return 0;

        if (m>0 )
        {
            if (y+m == y)
                return 0  ; // just in case...
            else
                return y+m; // Mod(-106.81415022205296, -_TWO_PI): m= 1.421e-14 
        }
    }

    return m;
}

// wrap [rad] angle to [-PI..PI)
inline double WrapPosNegPI(double fAng)
{
    return Mod(fAng + _PI, _TWO_PI) - _PI;
}

// wrap [rad] angle to [0..TWO_PI)
inline double WrapTwoPI(double fAng)
{
    return Mod(fAng, _TWO_PI);
}

// wrap [deg] angle to [-180..180)
inline double WrapPosNeg180(double fAng)
{
    return Mod(fAng + 180., 360.) - 180.;
}

// wrap [deg] angle to [0..360)
inline double Wrap360(double fAng)
{
    return Mod(fAng ,360.);
}
25
Lior Kogan

ワンライナー一定時間ソリューション：

さて、_[min,max)_フォームの2番目の関数を数えると2行ですが、十分近いので、とにかくそれらをマージできます。

_/* change to `float/fmodf` or `long double/fmodl` or `int/%` as appropriate */

/* wrap x -> [0,max) */
double wrapMax(double x, double max)
{
    /* integer math: `(max + x % max) % max` */
    return fmod(max + fmod(x, max), max);
}
/* wrap x -> [min,max) */
double wrapMinMax(double x, double min, double max)
{
    return min + wrapMax(x - min, max - min);
}
_

その後、単純にdeltaPhase = wrapMinMax(deltaPhase, -M_PI, +M_PI)を使用できます。

ソリューションは一定時間です。つまり、かかる時間は、値が_[-PI,+PI)_からどれだけ離れているかに依存しません—良くも悪くも。

検証：

さて、あなたが私のWordをそのように理解することを期待していないので、境界条件を含むいくつかの例を示します。わかりやすくするために整数を使用していますが、fmod()とfloatを使用してもほとんど同じです。

  • Positive x：
    • wrapMax(3, 5) == 3：_(5 + 3 % 5) % 5 == (5 + 3) % 5 == 8 % 5 == 3_
    • wrapMax(6, 5) == 1：_(5 + 6 % 5) % 5 == (5 + 1) % 5 == 6 % 5 == 1_
  • 負のx：
    • 注：これらは、整数の剰余が左側の符号をコピーすると想定しています。そうでない場合、上記の（ "Positive"）ケースになります。
    • wrapMax(-3, 5) == 2：_(5 + (-3) % 5) % 5 == (5 - 3) % 5 == 2 % 5 == 2_
    • wrapMax(-6, 5) == 4：_(5 + (-6) % 5) % 5 == (5 - 1) % 5 == 4 % 5 == 4_
  • 境界：
    • wrapMax(0, 5) == 0：_(5 + 0 % 5) % 5 == (5 + 0) % 5 == 5 % 5 == 0_
    • wrapMax(5, 5) == 0：_(5 + 5 % 5) % 5 == (5 + 0) % 5== 5 % 5 == 0_
    • wrapMax(-5, 5) == 0：_(5 + (-5) % 5) % 5 == (5 + 0) % 5 == 5 % 5 == 0_
      • 注：おそらく_-0_ではなく_+0_浮動小数点数

wrapMinMax関数はほとんど同じように機能します。xを_[min,max)_にラップすることは、_x - min_を_[0,max-min)_にラップすることと同じで、その後（再）追加minを結果に追加します。

負の最大値で何が起こるかわかりませんが、自分で確認してください！

15
Tim Čas

入力角度が任意の高い値に到達する可能性があり、連続性が重要である場合は、

atan2(sin(x),cos(x))

これにより、sin（x）とcos（x）の連続性が、特に単精度（float）で、xの高い値のモジュロよりも良好に維持されます。

確かに、exact_value_of_pi-double_precision_approximation〜= 1.22e-16

一方、ほとんどのライブラリ/ハードウェアは、三角関数を評価するときに、モジュロを適用するためにPIの高精度の近似を使用します（ただし、x86ファミリはかなり貧弱な関数を使用することが知られています）。

結果は[-pi、pi]になる可能性があります。正確な境界を確認する必要があります。

個人的には、体系的に折り返すことにより、角度が数回転に達するのを防ぎ、ブーストのようなfmodソリューションに固執します。

9
aka.nice

math.hにはfmod関数もありますが、符号が原因で問題が発生するため、（whileですでに行っているように）結果を適切な範囲にするには、後続の操作が必要になります。 deltaPhaseの大きな値の場合、これはおそらく、数百回「M_TWOPI」を減算/追加するよりも高速です。

deltaPhase = fmod(deltaPhase, M_TWOPI);

編集：集中的に試したわけではありませんが、正の値と負の値を別々に処理することで、このようにfmodを使用できると思います。

    if (deltaPhase>0)
        deltaPhase = fmod(deltaPhase+M_PI, 2.0*M_PI)-M_PI;
    else
        deltaPhase = fmod(deltaPhase-M_PI, 2.0*M_PI)+M_PI;

計算時間は一定です（deltaPhaseの絶対値が増加するにつれて遅くなるwhileソリューションとは異なります）

9
jdehaan

私はこれを行います：

double wrap(double x) {
    return x-2*M_PI*floor(x/(2*M_PI)+0.5);  
}

重大な数値エラーが発生します。数値誤差の最良の解決策は、1/PIまたは1 /（2 * PI）でスケーリングされた位相を保存し、実行していることに応じて、固定小数点として保存することです。

8
Craig McGillivary

ラジアンで作業する代わりに、1 /（2π）でスケーリングされた角度を使用し、modf、floorなどを使用します。ラジアンに変換して、ライブラリ関数を使用します。

これには、1万半の回転が1万回転の半分と同じ回転という効果もあります。これは、近似値を合計するのではなく、浮動小数点値を正確に表現しているため、角度がラジアンの場合は保証されません。表現：

#include <iostream>
#include <cmath>

float wrap_rads ( float r )
{
    while ( r > M_PI ) {
        r -= 2 * M_PI;
    }

    while ( r <= -M_PI ) {
        r += 2 * M_PI;
    }

    return r;
}
float wrap_grads ( float r )
{
    float i;
    r = modff ( r, &i );

    if ( r > 0.5 ) r -= 1;
    if ( r <= -0.5 ) r += 1;

    return r;
}

int main ()
{
    for (int rotations = 1; rotations < 100000; rotations *= 10 ) {
    {
        float pi = ( float ) M_PI;
        float two_pi = 2 * pi;

        float a = pi;
        a += rotations * two_pi;

        std::cout << rotations << " and a half rotations in radians " << a << " => " << wrap_rads ( a ) / two_pi << '\n' ;
    }
    {
        float pi = ( float ) 0.5;
        float two_pi = 2 * pi;

        float a = pi;
        a += rotations * two_pi;

        std::cout << rotations << " and a half rotations in grads " << a << " => " << wrap_grads ( a ) / two_pi << '\n' ;
    }
    std::cout << '\n';
}}
6
Pete Kirkham

以下は、BoostでC++を使用できるこの質問を見つけた他の人のためのバージョンです。

#include <boost/math/constants/constants.hpp>
#include <boost/math/special_functions/sign.hpp>

template<typename T>
inline T normalizeRadiansPiToMinusPi(T rad)
{
  // copy the sign of the value in radians to the value of pi
  T signedPI = boost::math::copysign(boost::math::constants::pi<T>(),rad);
  // set the value of rad to the appropriate signed value between pi and -pi
  rad = fmod(rad+signedPI,(2*boost::math::constants::pi<T>())) - signedPI;

  return rad;
}

C++ 11バージョン、Boost依存関係なし：

#include <cmath>

// Bring the 'difference' between two angles into [-pi; pi].
template <typename T>
T normalizeRadiansPiToMinusPi(T rad) {
  // Copy the sign of the value in radians to the value of pi.
  T signed_pi = std::copysign(M_PI,rad);
  // Set the value of difference to the appropriate signed value between pi and -pi.
  rad = std::fmod(rad + signed_pi,(2 * M_PI)) - signed_pi;
  return rad;
}
5
Andrew Hundt

この質問は、2つの任意の数値間で浮動小数点値（またはdouble）をラップする方法を検索するときに発生しました。それは私のケースでは特に答えられなかったので、私はここで見ることができる自分の解決策を考え出しました。これは、指定された値を取り、lowerBoundとupperBoundの間でラップします。ここで、upperBoundは、lowerBoundと完全に一致するため、同等になります（つまり、360度== 0度なので、360は0にラップされます）。

うまくいけば、この回答が、より一般的な境界ソリューションを探しているこの質問に出くわした他の人に役立つでしょう。

double boundBetween(double val, double lowerBound, double upperBound){
   if(lowerBound > upperBound){std::swap(lowerBound, upperBound);}
   val-=lowerBound; //adjust to 0
   double rangeSize = upperBound - lowerBound;
   if(rangeSize == 0){return upperBound;} //avoid dividing by 0
   return val - (rangeSize * std::floor(val/rangeSize)) + lowerBound;
}

整数の関連する質問はここにあります： C++で整数をラップするためのクリーンで効率的なアルゴリズム

4
M2tM

任意の角度を[-π、π）に正規化するための2ライナーの非反復テスト済みソリューション：

double normalizeAngle(double angle)
{
    double a = fmod(angle + M_PI, 2 * M_PI);
    return a >= 0 ? (a - M_PI) : (a + M_PI);
}

同様に、[0、2π）の場合：

double normalizeAngle(double angle)
{
    double a = fmod(angle, 2 * M_PI);
    return a >= 0 ? a : (a + 2 * M_PI);
}
2
mojuba

Fmod（）が切り捨てられた除算を介して実装され、 dividend と同じ符号を持つ場合、一般的な問題をこうして解決することを利用できます。

（-PI、PI]の場合：

if (x > 0) x = x - 2PI * ceil(x/2PI)  #Shift to the negative regime
return fmod(x - PI, 2PI) + PI

[-PI、PI）の場合：

if (x < 0) x = x - 2PI * floor(x/2PI)  #Shift to the positive regime
return fmod(x + PI, 2PI) - PI

[これは疑似コードであることに注意してください。私のオリジナルはTclで書かれていて、それでみんなを拷問したくありませんでした。最初のケースが必要だったので、これを理解する必要がありました。]

2
Glenn

C99の場合：

float unwindRadians( float radians )
{
   const bool radiansNeedUnwinding = radians < -M_PI || M_PI <= radians;

   if ( radiansNeedUnwinding )
   {
      if ( signbit( radians ) )
      {
         radians = -fmodf( -radians + M_PI, 2.f * M_PI ) + M_PI;
      }
      else
      {
         radians = fmodf( radians + M_PI, 2.f * M_PI ) - M_PI;
      }
   }

   return radians;
}
0
otto

Glibcのlibm（newlibの実装を含む）にリンクしている場合は、__ ieee754_rem_pio2f（）および__ieee754_rem_pio2（）プライベート関数にアクセスできます。

extern __int32_t __ieee754_rem_pio2f (float,float*);

float wrapToPI(float xf){
const float p[4]={0,M_PI_2,M_PI,-M_PI_2};

    float yf[2];
    int q;
    int qmod4;

    q=__ieee754_rem_pio2f(xf,yf);

/* xf = q * M_PI_2 + yf[0] + yf[1]                 /
 * yf[1] << y[0], not sure if it could be ignored */

    qmod4= q % 4;

    if (qmod4==2) 
      /* (yf[0] > 0) defines interval (-pi,pi]*/
      return ( (yf[0] > 0) ?  -p[2] : p[2] ) + yf[0] + yf[1];
    else
      return p[qmod4] + yf[0] + yf[1];
}

編集：libm.aにリンクする必要があることに気づきましたが、libm.soで宣言されたシンボルが見つかりませんでした

0
xvan

deltaPhase -= floor(deltaPhase/M_TWOPI)*M_TWOPI;

0
lijie

私は（pythonで）使用しました：

def WrapAngle(Wrapped, UnWrapped ):
    TWOPI = math.pi * 2
    TWOPIINV = 1.0 / TWOPI
    return  UnWrapped + round((Wrapped - UnWrapped) * TWOPIINV) * TWOPI

同等のCコード：

#define TWOPI 6.28318531

double WrapAngle(const double dWrapped, const double dUnWrapped )
{   
    const double TWOPIINV = 1.0/ TWOPI;
    return  dUnWrapped + round((dWrapped - dUnWrapped) * TWOPIINV) * TWOPI;
}

これはラップされたドメイン+/- 2piにそれをもたらすことに注意してください+/- piドメインの場合、後でそれを次のように処理する必要があります：

if( angle > pi):
    angle -= 2*math.pi
0
Henrik

あなたが提案した方法が最善です。小さなたわみに対しては最速です。プログラムの角度が常に適切な範囲に偏向されている場合、範囲外の大きな値に遭遇することはまれです。したがって、複雑なモジュラー算術コードのコストを毎回支払うことは無駄に思えます。比較はモジュラー演算と比較して安価です（ http://embeddedgurus.com/stack-overflow/2011/02/efficient-c-tip-13-use-the-modulus-operator-with-caution/ =）。

0
Tom Larkworthy