使用算法將未綁定值轉換爲綁定值？

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