Question

我需要将一个数字集合从一个范围转换为另一个范围，同时保持值的相对分布。

例如，可以缩放包含随机生成的浮点数的向量以适合可能的无符号字符值（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，...）。缩放 up 时整数有效，但即使这样，只有整体比率：

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}。

所以，我的问题是，有更好的方法吗？在缩放float s的集合的情况下，类型转换似乎相当多余，而在缩放int时，由于截断而引入了错误。

顺便说一句，我很惊讶在boost中没有为此目的发现某些事情（至少没有明显的事）。也许我错过了 - 各种数学库让我感到困惑。

编辑：我意识到我可以针对特定类型专门设置operator()，但是这意味着很多代码重复，这会使模板的一个有用部分失效。除非有一个方法，例如，对所有非浮点类型（short，int，uint，...）专门化一次。

Answer 1

首先，我认为您的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
}

Answer 2

根据@John R. Strohm的建议，这对整数有用，我提出了以下内容，似乎只需要提供类的两个特化（我的担心是必须编写一个专门化的各种类型）。但是，它确实需要为每个非整体类型写一个“特征”。

首先我创建一个“traits”式的类（请注意，在C ++ 11中我认为这已经在std :: is_floating_point中提供了，但是现在我已经被使用了vanilla 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; };

使用这个traits-style类，我们可以提供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)) {}
};

这些类之间的主要区别在于，对于整数实现，类中的数据存储为double，并且根据John的答案存在内置舍入。

如果我决定需要实现定点类，那么我想我需要将其添加为另一个特征。

Answer 3

舍入是你的责任，而不是计算机/编译器。

在您的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）函数，则必须定义它。

double SIGN(const double x) {
    return (x >= 0) ? 1.0 : -1.0;
}

更改任意数值类型的值的范围比例

3 个答案: