Question

我有一个设备驱动程序，它使用以下算法将从传感器接收的值（无绑定范围）转换为不同的值（绑定范围）。

传感器的值通常在0-200范围内，但可以超过它，最大值约为4000（这种情况只有在极端方式使用传感器时才会发生）。我基本上需要一个可以执行以下操作但没有巨型if的函数，因此它更灵活。

需要接受值，步骤（在本例中为20.0f）和最大输出（在本例中为10）。

/* disregard the floating point numbers, I can cast them to int */
if (value <= 20.0f)
    return 0;
else if (value <= 40.0f)
    return 1;
else if (value <= 60.0f)
    return 2;
else if (value <= 80.0f)
    return 3;
else if (value <= 100.0f)
    return 4;
else if (value <= 120.0f)
    return 5;
else if (value <= 140.0f)
    return 6;
else if (value <= 160.0f)
    return 7;
else if (value <= 180.0f)
    return 8;
else if (value <= 190.0f)
    return 9;
else if (value >= 200.0f)
    return 10;

return 0;

Answer 1

int step(double value, int step, int maximum) { 
    return min(int(value / step), maximum);
}

编辑：正如@DSM所说，这有一个fencepost错误，应该是这样的：

int step(double value, int step, int maximum) { 
    return min(int((value-1) / step), maximum);
}

Answer 2

假设您有min，看起来像是

min(0, (int)((min(220, value) - 20) / 20))

（编辑，抱歉早期的最小/最大混乱！）

Answer 3

我会做这样的事情：

struct temp_thresholds {                                                                                                                                                                   
        float upper_bound;                                                                                                                                                                 
        int   ret_val;                                                                                                                                                                     
} thresholds = {                                                                                                                                                                           
        {  20.0f,     0},                                                                                                                                                                  
        {  40.0f,     1},                                                                                                                                                                  
        {  80.0f,     2},                                                                                                                                                                  
        // ..                                                                                                                                                                              
        { 190.0f,     9},                                                                                                                                                                  
        { 200.0f,     0}, // strange, and doesn't quite match your code                                                                                                                   
        { MAX_FLOAT, 10}, // find a constant like this                                                                                                                                     
};                                                                                                                                                                                         

int foo(float value)                                                                                                                                                                      
{                                                                                                                                                                                          
        // if the table were big enough, you could do binary search                                                                                                                        
        for (int i = 0; i < sizeof thresholds / sizeof thresholds[0]; ++i)                                                                                                                 
                if (value <= thresholds[i].upper_bound)                                                                                                                                    
                        return thresholds[i].ret_value;                                                                                                                                    
        assert(0);                                                                                                                                                                         
        return 0;                                                                                                                                                                          
}

使用算法将未绑定的值转换为绑定值？

3 个答案: