patrón general para implementar tablas de verdad

Question

¿Existe un buen patrón general para implementar tablas de verdad?

Estoy volviendo a trabajar con algún código heredado (C++) y me acabo de dar cuenta de que la función con la que estoy trabajando equivale a una tabla de verdad con 3 entradas binarias y 8 salidas posibles. Aquí hay un ejemplo de dos de las ocho pruebas y salidas correspondientes:

// - + + 
if ((prevdst5 < 0.0) && (dst5 > 0.0) && (nextdst5 > 0.0)){ 
    thawpct = (dst5/(dst5 - prevdst5)); 
} 

// - - + 
if ((prevdst5 < 0.0) && (dst5 < 0.0) && (nextdst5 > 0.0)){ 
    thawpct = (nextdst5/(nextdst5 - dst5)); 
} 

// other cases... 

return thawpct; 

Básicamente me gustaría saber si hay un más limpio, más fácil de mantener/extensible * manera de configurar esto.

• ¿Qué ocurre si se agrega otra entrada? Entonces, la cantidad de sentencias if necesarias sería 16, lo cual, en mi opinión, sería demasiado complicado de manejar con el patrón actual.
• ¿Qué pasa si varios de los combos de entrada se asignan a la misma salida?

* La base de código es un modelo de ecosistema utilizado en la academia, por lo que el mantenimiento y la extensión equivalen a cosas similares según la perspectiva del codificador.

Answer 1

Una matriz es una tabla.

Una secuencia de valores de verdad booleanos es un número binario.

Las matrices están indexadas por número.

Sooooo .....

Se podría definir una función para cada cálculo:

// - + + == 0 1 1 == 3 
inline double f3(double prev, double curr, double next) 
{ 
    return curr/(curr - prev); 
} 

// - - + == 0 0 1 == 1 
inline double f1(double prev, double curr, double next) 
{ 
    return next/(next - curr); 
} 

// ... 

Entonces declarar una matriz de punteros de función:

typedef double (*func_type)(double, double, double); 
func_type funcs[8] = { 
    f1, f2, // ... 
}; 

Entonces índice en la matriz utilizando las condiciones booleanas como dígitos binarios:

func_type f = funcs[ (int(prevdst5 < 0.0)<<2) | (int(dst5 < 0.0)<<1) | int(nextdst5 > 0.0) ]; 
thawpct = f(prevdst5, dst5, nextdst5); 

• ¿Qué ocurre si se agrega otra entrada? (A continuación, el número de pruebas sería 16, que en mi opinión sería difícil de manejar con el patrón actual)

se duplica el tamaño de la matriz y añadir f8, f9 etc., si son diferentes cálculos necesitaba, pero sólo se agrega la nueva prueba una vez, en el índice de matriz:

func_type f = funcs[ (cond<<3) | (int(prevdst5 < 0.0)<<2) | (int(dst5 < 0.0)<<1) | int(nextdst5 > 0.0) ]; 

• ¿Qué pasa si varios de los combos de entrada debe asignar a la misma salida?

tienda el mismo puntero de función en varios elementos de la matriz:

func_type funcs[8] = { 
    f1, f2, f3, f1, f1, // ... 
}; 

Answer 2

se podía mantener un mapeo de 3 (o n) los valores de la función adecuada que necesita ser realizado.A continuación, repita la función en este mapa según el estado true/false de las condiciones y ejecútelo.

De esta manera se tendría un mapa 3 dimensional (con un tamaño de 2 en todas las Dimensiones)

Answer 3

int condition = (prev >= 0 ? (1<<0) : 0) + 
       (cur >= 0 ? (1<<1) : 0) + 
       (next >= 0 ? (1<<2) : 0); 

switch (condition) { 
    case 0: // - - - 
    case 1: // + - - 
    case 2: // - + - 
    case 3: // + + - 
    case 4: // - - + 
    case 5: // + - + 
    case 6: // - + + 
    case 7: // + + + 
}