Преобразовать несвязанное значение в связанное значение с помощью алгоритма?

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

Я бы сделал что-то вроде этого:

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

Answer 3

Предположим, у вас есть min, похоже, что вы хотите

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

(Отредактировано, извините за более раннюю мин / макс путаницу!)