Come trasformare la tabella di verità nel blocco if / else più piccolo possibile

Come posso prendere una tabella della verità e trasformarla in un blocco if compattato?

Ad esempio, supponiamo di avere questa tabella di verità in cui A e B sono condizioni e x, ye z sono azioni possibili:

A B | x y z
-------------
0 0 | 0 0 1
0 1 | 0 0 1
1 0 | 0 1 0
1 1 | 1 0 0

Questo potrebbe trasformarsi in sotto se blocco:

if(A)
{
    if(B)
    {
        do(x)
    }
    else
    {
        do(y)
    }
}
else
{
    do(z)
}

Questo è un semplice esempio, ma spesso ho diverse condizioni che combinate in modi diversi dovrebbero produrre output diversi e diventa difficile capire il modo più compatto ed elegante di rappresentare la loro logica in un blocco if.

Se stai progettando da una mappa di Karnaugh, anche il codice potrebbe apparire così:

//                   a      b
def actionMap = [ false: [false: { z() },
                          true:  { z() }],
                  true:  [false: { x() },
                          true:  { y() }]]

actionMap[a][b]()

In C # .NET, puoi utilizzare una classe di dizionario per ottenere il risultato senza IF ELSE come segue: La cosa bella di questo è:

1. È leggibile
2. Le nuove chiavi saranno univoche (altrimenti, otterrai un errore)
3. La sequenza non ha importanza
4. Facile da aggiungere o rimuovere voci

Se non disponi di un equivalente della classe del dizionario, puoi fare lo stesso in una funzione di ricerca / ricerca binaria.

//A B | x y z
//-------------
//0 0 | 0 0 1
//0 1 | 0 0 1
//1 0 | 0 1 0
//1 1 | 1 0 0
// Create a Dictionary object and populate it
Dictionary<string, string> _decisionTable = new Dictionary<string, string>() { 
    { "0,0", "0,0,1" }, 
    { "0,1", "0,0,1" }, 
    { "1,0", "0,1,0" }, 
    { "1,1", "1,0,0"} 
};

//usage example: Find the values of X,Y,Z for A=1,B=0
Console.WriteLine(_decisionTable["1,0"]);
Console.Read();

Quello che vuoi è un algoritmo di Rete . Questo combina automaticamente un insieme di regole e le priorità in un albero come descritto.

Esistono numerosi sistemi commerciali di "motore delle regole" che lo fanno su larga scala (milioni di regole) in cui la velocità di esecuzione è essenziale.

Ecco la tua libreria :) E non è necessario passare la tabella K completa, solo i campi che ti interessano :) Si presume che il suo operatore AND nella tabella di verità. Se vuoi usare più operatori, dovresti essere in grado di riscriverlo. Puoi avere qualsiasi numero di argomenti. Scritto pythone testato.

def x():
    print "xxxx"

def y():
    print "yyyyy"

def z(): #this is default function
    print "zzzzz"

def A():
    return 3 == 1

def B():
    return 2 == 2


def insert(statements,function):
    rows.append({ "statements":statements, "function":function })

def execute():
    for row in rows:
        print "==============="
        flag = 1

        for index, val in enumerate(row["statements"]):
            #for first pass of lopp, index is 0, for second its 1....
            #if any function returns result different than one in our row, 
            # we wont execute funtion of that row (mark row as not executable)
            if funcs[index]() != val:
                flag = 0

        if flag == 1:
            #we execute function 
            row["function"]()
        else: z() #we call default function


funcs = [A,B]  #so we can access functions by index key
rows = []

insert( (0,0), y)
insert( (0,1), y)
insert( (1,0), x)
insert( (1,1), x)
insert( (0,1), x)

execute()

Mappare gli input in un singolo valore e quindi accenderlo:

#define X(a, b) (!!(a) * 2 + !!(b))
switch(X(A, B)) {
case X(0, 0):
    ...
    break;
case X(0, 1):
    ...
    break;
case X(1, 0):
    ...
    break;
case X(1, 1):
    ...
    break;
}
#undef X

Una tabella di ricerca contenente i puntatori a funzioni può funzionare bene in alcune situazioni. In C, ad esempio, puoi fare qualcosa del genere:

typedef void(*VoidFunc)(void);

void do(int a, int b)
{
    static VoidFunc myFunctions[4] = {z, z, y, x}; // the lookup table

    VoidFunc theFunction = myFunctions[ a * 2 + b ];
    theFunction();
}

Questa è una buona soluzione quando il numero di input è relativamente piccolo, poiché il numero di voci nella tabella deve essere 2 ^^ n dove n è il numero di input. 7 o 8 ingressi potrebbero essere gestibili, 10 o 12 iniziano a diventare brutti. Se hai così tanti input, prova prima a semplificare con altri mezzi (come le mappe di Karnaugh).

Guarda il software "Gorgeous Karnaugh": può accettare tabelle di verità abbastanza esatte come il tuo campione, accettare definizioni di formule booleane analitiche, accettare script Lua per costruire tabelle di verità. Successivamente, il software "Gorgeous Karnaugh" disegna le K-Maps per l'input preso, che puoi minimizzare manualmente o usando il minimizer logico "Espresso", e produce output per C / C ++ e alcuni linguaggi hardware. Guarda la pagina delle caratteristiche di riepilogo per "Gorgeous Karnaugh" - http://purefractalsolutions.com/show.php?a=xgk/gkm