6

値の相対的な分布を維持しながら、数値のコレクションをある範囲から別の範囲に変換する必要があります。

たとえば、ランダムに生成されたfloatを含むベクトルは、可能なunsigned char値（0..255）に収まるようにスケーリングできます。型変換を無視すると、これは、提供された入力が何であれ（たとえば、-1.0から1.0）、すべての数値が0.0から255.0（またはその前後）にスケーリングされることを意味します。

この変換を実行するためのテンプレートクラスを作成しました。これは、次を使用してコレクションに適用できますstd::transform。

template <class TYPE>
class scale_value {
    const TYPE fmin, tmin, ratio;
public:
    TYPE operator()(const TYPE& v) {
        TYPE vv(v);
        vv += (TYPE(0) - fmin); // offset according to input minimum
        vv *= ratio;            // apply the scaling factor
        vv -= (TYPE(0) - tmin); // offset according to output minimum
        return vv;
    }
    // constructor takes input min,max and output min,max
    scale_value(const TYPE& pfmin, const TYPE& pfmax, const TYPE& ptmin, const TYPE& ptmax)
        : fmin(pfmin), tmin(ptmin), ratio((ptmax-tmin)/(pfmax-fmin)) { }
    // some code removed for brevity
};

ただし、上記のコードは実数（、、 ...）に対してのみ正しく機能しfloatますdouble。整数はスケールアップ時に機能しますが、それでも全体の比率によってのみ機能します。

float scale_test_float[] = {0.0, 0.5, 1.0, 1.5, 2.0};
int scale_test_int[] = {0, 5, 10, 15, 20};

// create up-scalers
scale_value<float> scale_up_float(0.0, 2.0, 100.0, 200.0);
scale_value<int> scale_up_int(0, 20, 100, 200);

// create down-scalers
scale_value<float> scale_down_float(100.0, 200.0, 0.0, 2.0);
scale_value<int> scale_down_int(100, 200, 0, 20);

std::transform(scale_test_float, scale_test_float+5, scale_test_float, scale_up_float);
// scale_test_float -> 100.0, 125.0, 150.0, 175.0, 200.0
std::transform(scale_test_int, scale_test_int+5, scale_test_int, scale_up_int);
// scale_test_int -> 100, 125, 150, 175, 200

std::transform(scale_test_float, scale_test_float+5, scale_test_float, scale_down_float);
// scale_test_float -> 0.0, 0.5, 1.0, 1.5, 2.0
std::transform(scale_test_int, scale_test_int+5, scale_test_int, scale_down_int);
// scale_test_int -> 0, 0, 0, 0, 0 : fails due to ratio being rounded to 0

この問題に対する私の現在の解決策は、内部のすべてをscale_valueとして保存しdouble、必要に応じて型変換を使用することです。

TYPE operator()(const TYPE& v) {
    double vv(static_cast<double>(v));
    vv += (0.0 - fmin);                // offset according to input minimum
    vv *= ratio;                       // apply the scaling factor
    vv -= (0.0 - tmin);                // offset according to output minimum
    return static_cast<TYPE>(vv);
}

これは、値が丸められるのではなく切り捨てられるため、整数のエラーはありますが、ほとんどの場合に機能します。たとえば、からにスケーリングして{0,5,10,15,20}から戻るにスケーリング0..20すると、が得られます。20..35{0,4,9,14,20}

だから、私の質問は、これを行うためのより良い方法はありますか？sのコレクションをスケーリングする場合float、型変換はかなり冗長に見えますが、sをスケーリングする場合、int切り捨てが原因でエラーが発生します。

余談ですが、この目的のためにブーストで何か（少なくとも明らかなものは何もありません）を見つけられなかったことに驚きました。多分私はそれを逃しました-さまざまな数学ライブラリが私を混乱させます。

編集：特定のタイプに特化できることはわかっoperator()ていますが、これは多くのコード重複を意味し、テンプレートの便利な部分の1つを無効にします。たとえば、すべての非浮動小数点型（short、int、uint、...）に1回特化する方法がない限り。

4

3 に答える 3

3

まず、おそらく浮動小数点型であり、浮動小数点除算を使用して計算する必要があると思いますratio（おそらく別のメカニズムでも機能します）。それ以外の場合、たとえばからにスケーリングしようと[0, 19]する[0, 20]と、の積分比に1なり、スケーリングはまったく実行されません。

次に、浮動小数点型で問題なく動作すると仮定しましょう。ここで、すべての計算をとして実行しますdoubleが、出力タイプが整数の場合は、切り捨てるのではなく、最も近い出力整数に丸めたいと思います。したがって、is_integralいくつかの丸めを強制的に実行するために使用できます（現在、これをコンパイル/テストするためのアクセス権がないことに注意してください）。

TYPE operator()(const TYPE& v)
{
    double vv(static_cast<double>(v));
    vv -= fmin;                // offset according to input minimum
    vv *= ratio;               // apply the scaling factor
    vv += tmin;                // offset according to output minimum
    return static_cast<TYPE>(vv + (0.5 * is_integral<TYPE>::value));  // Round for integral types
}
于 2013-02-21T19:14:08.577 に答える
2

整数で機能する@JohnR.Strohmの提案に従って、私は次のことを思いつきました。これは、クラスの2つの特殊化を提供するだけで機能するようです（私の懸念は、すべてのタイプの特殊化を作成する必要があることでした）。 。ただし、非全体タイプごとに「特性」を記述する必要があります。

最初に「特性」スタイルのクラスを作成します（C ++ 11では、これはすでにstd :: is_floating_pointで提供されていると思いますが、今のところバニラC ++で立ち往生しています）：

template <class NUMBER>
struct number_is_float { static const bool val = false; };

template<>
struct number_is_float<float> { static const bool val = true; };

template<>
struct number_is_float<double> { static const bool val = true; };

template<>
struct number_is_float<long double> { static const bool val = true; };

この特性スタイルのクラスを使用して、クラスの基本的な「整数」実装を提供できますscale_value。

template <class TYPE, bool IS_FLOAT=number_is_float<TYPE>::val>
class scale_value
{
private:
    const double fmin, tmin, ratio;
public:
    TYPE operator()(const TYPE& v) {
        double vv(static_cast<double>(v));
        vv += (0.0 - fmin);
        vv *= ratio;
        vv += 0.5 * ((static_cast<double>(v) >= 0.0) ? 1.0 : -1.0);
        vv -= (0.0 - tmin);
        return static_cast<TYPE>(vv);
    }
    scale_value(const TYPE& pfmin, const TYPE& pfmax, const TYPE& ptmin, const TYPE& ptmax)
        : fmin(static_cast<double>(pfmin))
        , tmin(static_cast<double>(ptmin))
        , ratio((static_cast<double>(ptmax)-tmin)/(static_cast<double>(pfmax)-fmin))
    {
    }
};

TYPE...そして、パラメータが何らかのフロートであるという「特性」を持っている場合の部分的な特殊化：

template <class TYPE>
class scale_value<TYPE, true>
{
private:
    const TYPE fmin, tmin, ratio;
public:
    TYPE operator()(const TYPE& v) {
        TYPE vv(v);
        vv += (TYPE(0.0) - fmin);
        vv *= ratio;
        vv -= (TYPE(0.0) - tmin);
        return vv;
    }
    scale_value(const TYPE& pfmin, const TYPE& pfmax, const TYPE& ptmin, const TYPE& ptmax)
        : fmin(pfmin), tmin(ptmin), ratio((ptmax-tmin)/(pfmax-fmin)) {}
};

これらのクラスの主な違いは、整数の実装では、クラス内のデータがとして格納され、doubleJohnの回答に従って組み込みの丸めが行われることです。

固定小数点クラスを実装する必要があると判断した場合は、これを別の特性として追加する必要があると思います。

于 2013-02-21T16:25:53.813 に答える
1

丸めはユーザーの責任であり、コンピューター/コンパイラーの責任ではありません。

operator（）で、乗算に「丸めビット」を指定する必要があります。

私は次のようなものから始めてみます：

TYPE operator()(const TYPE& v) {
    double vv(static_cast<double>(v));
    vv += (0.0 - fmin);                // offset according to input minimum
    vv *= ratio;                       // apply the scaling factor
    vv += SIGN(static_cast<double>(v))*0.5;
    vv -= (0.0 - tmin);                // offset according to output minimum
    return static_cast<TYPE>(vv);
}

コンパイラがまだSIGN（x）関数を提供していない場合は、SIGN（x）関数を定義する必要があります。

double SIGN(const double x) {
    return (x >= 0) ? 1.0 : -1.0;
}
于 2013-02-21T14:00:34.617 に答える