Làm thế nào để biến bảng chân lý thành nhỏ nhất có thể nếu / khối khác

Làm thế nào tôi có thể lấy một bảng chân lý và biến nó thành một khối nếu được nén?

Chẳng hạn, giả sử tôi có bảng chân lý này trong đó A và B là điều kiện và x, y và z là các hành động có thể:

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

Điều này có thể chuyển thành bên dưới nếu khối:

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

Đây là một mẫu dễ dàng, nhưng tôi thường có một số điều kiện kết hợp theo nhiều cách khác nhau sẽ tạo ra các đầu ra khác nhau và thật khó để tìm ra cách gọn nhẹ và thanh lịch nhất để thể hiện logic của chúng trong một khối if.

Nếu bạn đang thiết kế từ bản đồ Karnaugh, thì mã cũng có thể trông giống như vậy:

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

actionMap[a][b]()

Trong C # .NET, bạn có thể sử dụng Lớp từ điển để nhận kết quả mà không cần bất kỳ ELSE nào như sau - Điều hay ho về điều này là:

1. Nó có thể đọc được
2. Các khóa mới sẽ là duy nhất (nếu không, bạn sẽ gặp lỗi)
3. Trình tự không quan trọng
4. Dễ dàng thêm hoặc xóa các mục

Nếu bạn không có lớp Từ điển tương đương, bạn có thể thực hiện tương tự trong chức năng tìm kiếm / tìm kiếm nhị phân.

//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();

Những gì bạn muốn là một thuật toán Rete . Điều này sẽ tự động kết hợp một bộ quy tắc và ưu tiên chúng thành một cây theo cách bạn mô tả.

Có một số hệ thống "công cụ quy tắc" thương mại thực hiện điều này ở quy mô rất lớn (hàng triệu quy tắc) trong đó tốc độ thực thi là rất cần thiết.

Đây là thư viện của bạn :) Và bạn không cần phải vượt qua toàn bộ bảng K, chỉ các trường mà bạn quan tâm :) Nó giả sử rằng toán tử AND của nó trong bảng chân lý. Nếu bạn muốn sử dụng nhiều toán tử hơn, bạn sẽ có thể viết lại nó. Bạn có thể có bất kỳ số lượng đối số. Viết pythonvà kiểm tra.

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()

Ánh xạ các đầu vào thành một giá trị duy nhất và sau đó bật nó:

#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

Một bảng tra cứu có chứa các con trỏ hàm có thể hoạt động tốt trong một số tình huống. Trong C, ví dụ, bạn có thể làm một cái gì đó như thế này:

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

Đây là một giải pháp tốt khi số lượng đầu vào tương đối nhỏ, vì số lượng mục trong bảng phải là 2 ^^ n trong đó n là số lượng đầu vào. 7 hoặc 8 đầu vào có thể quản lý được, 10 hoặc 12 bắt đầu trở nên xấu xí. Nếu bạn có nhiều đầu vào đó, trước tiên hãy cố gắng đơn giản hóa bằng các phương tiện khác (như bản đồ Karnaugh).

Nhìn vào phần mềm "Tuyệt đẹp Karnaugh" - nó có thể chấp nhận các bảng chân lý hoàn toàn chính xác như mẫu của bạn, chấp nhận định nghĩa công thức boolean phân tích, chấp nhận kịch bản lệnh Lua để xây dựng các bảng chân lý. Tiếp theo, phần mềm "Tuyệt đẹp Karnaugh" vẽ Bản đồ K cho đầu vào đã lấy, bạn có thể thu nhỏ thủ công hoặc sử dụng bộ giảm thiểu logic "Espresso" và tạo đầu ra cho C / C ++ và một số ngôn ngữ phần cứng. Tìm đến trang tính năng tóm tắt cho "Karnaugh tuyệt đẹp" - http://purefractalsolutions.com/show.php?a=xgk/gkm