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

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指出，这有一个栅栏柱错误的，应该是这样的：

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