Tablica booleanów tworzy monstrualność

Question

Odziedziczyłem ten kod i nie mogę rozgryźć, co robi. Definicja wygląda dość proste:

result : BOOLEAN ; 
LOOKUP_TABLE : array 
    (BOOLEAN, BOOLEAN, BOOLEAN, BOOLEAN, BOOLEAN, BOOLEAN, BOOLEAN, BOOLEAN, 
    BOOLEAN, BOOLEAN, BOOLEAN, BOOLEAN, BOOLEAN, BOOLEAN, BOOLEAN, BOOLEAN) of 
    BOOLEAN := (others => (others => (others => (others => (others => (others => (others => (others => 
      (others => (others => (others => (others => (others => (others => (others => (others => 
       TRUE)))))))))))))))); 

W organizmie jest ona wykorzystywana w sposób następujący:

result := LOOKUP_TABLE(TRUE, FALSE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, 
         FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, TRUE); 

podczas zrzucania lookup_table w GDB tworzy linię o długości ponad 500 tysięcy znaków, pierwszy mały trochę wygląda następująco:

$1 = ((((((((((((((((true, true), (true, true)), ((true, true), (true, true))), (((true, true), (true, ... 

Początkowo moje pytanie miało być: w jaki sposób 16-logiczna tablica być zmniejszona do jednego bool „wynik” ?, ale po patrząc na to w GDB, muszę zapytać "Co to za rzecz???"

PS: Po zakończeniu rozmowy w organizmie, LOOKUP_TABLE wciąż 500000 znaków, gdzie każde pole logiczna jest prawdą ...

Answer 1

W Ada tablica nie jest koniecznie indeksowana przez int począwszy od 0. W tym przypadku masz tablicę wielowymiarową z boolami jako indeksami.

Podczas inicjowania tablicy należy określić cały zakres tablicy.

Jeden wymiarowa tablica będzie wyglądać następująco:

Lookup_Table : array(Boolean) of Boolean := (False..True => True);

Gdy mamy do czynienia z dużymi tablicami, to niewygodne określić wszystkie alternatywy, stąd kluczowe others. Oznacza to wszystkie alternatywy a nie jest określona, ​​to jest takie samo jak powyżej:

Lookup_Table : array(Boolean) of Boolean := (others => True);

Tablica wygląda teraz jak to (przy czym 1 oznacza wymiar, a C jest zawartością)

1 | C 
-----|----- 
False|True 
True |True 

w dwuwymiarowej tablicy, będzie to:

Lookup_Table : array(Boolean, Boolean) of Boolean := (others => (others => True));

1 | 2 | C 
-----|-----|----- 
False|False|True 
False|True |True 
True |False|True 
True |True |True 

W twoim przypadku ma 16 wymiarów.

można przeczytać więcej na temat Ada tablicy here

Answer 2

to nie jest 16-logiczna tablicą. Jest to macierz wymiarowa o wymiarach od false do true, więc ma 2 lub 65536 elementów.

Answer 3

Tego rodzaju rzeczy zazwyczaj reprezentują flagi wskazujące pewne uprawnienia. to znaczy.

IsAdmin CanEdit CanInsert CanDelete

Więc jeśli ktoś jest adminem i można edytować, ale nie ma ani usunąć wkładkę będzie: 1100. Może to duża tablica oznacza to samo.

Answer 4

Który został wybrany prawdopodobnie dlatego, że wartości są rzadkie. Myślę, że można by zastąpić jedną tablicą 64-bitowych boolów, czyli tablicą 8-bajtową (8192 unsigned chars). Ustaw początkowo na 0 i ustaw na 1 każdą użytą pozycję, bit lub klawisze.

Answer 5

Gdybym robił to i stół miał stosunkowo niewiele wartości odsetek bym prawdopodobnie korzystać z mapy z kluczem wieloczęściowe:

with Ada.Containers.Indefinite_Ordered_Maps; 

package Bool_16_Mapping is 

    Key_Arity : constant := 16; 

    type Key_Range is range 1 .. Key_Arity; 

    type Bool_16_Keys is array (Key_Range) of Boolean; 

    package Bool_16_Array_Management is 
    new Ada.Containers.Indefinite_Ordered_Maps 
     (Bool_16_Keys, Boolean); 

end Bool_16_Mapping; 

Wartości zainteresowania zostaną następnie wstawione do mapy. Podczas wykonywania należy użyć zwarcia Zawiera(), a następnie Element(), lub napisać trochę funkcji, aby to zrobić. Oto przykład:

with Ada.Text_IO; use Ada.Text_IO; 
with Bool_16_Mapping; 

procedure Bool_16_Map_Test is 

    Lookup_Table : Bool_16_Mapping.Bool_16_Array_Management.Map; 

    Working_Key : Bool_16_Mapping.Bool_16_Keys := (others => False); 

    function Get_Result (P1, P2, P3, P4, 
         P5, P6, P7, P8, 
         P9, P10, P11, P12, 
         P13, P14, P15, P16 : Boolean) return Boolean is 
     Key : Bool_16_Mapping.Bool_16_Keys := 
     (P1, P2, P3, P4, P5, P6, P7, P8, 
     P9, P10, P11, P12, P13, P14, P15, P16); 
     Result : Boolean := False; 
    begin 
     if Lookup_Table.Contains(Key) then 
     Result := Lookup_Table.Element(Key); 
     end if; 
     return Result; 
    end Get_Result; 

    Lookup_Result : Boolean; 

    use type Bool_16_Mapping.Key_Range; 

begin 
    -- Initialize the table with some values 
    for K in Bool_16_Mapping.Key_Range loop 
     Working_Key (K) := True; 
     Lookup_Table.Insert(Working_Key, K mod 2 = 0); 
    end loop; 

    Lookup_Result := Get_Result 
    (True, True, True, False, False, False, False, False, 
     False, False, False, False, False, False, False, False); 
    Put_Line("#1: " & Boolean'Image(Lookup_Result)); 

    Lookup_Result := Get_Result 
    (True, True, True, True, False, False, False, False, 
     False, False, False, False, False, False, False, False); 
    Put_Line("#2: " & Boolean'Image(Lookup_Result)); 

    Lookup_Result := Get_Result 
    (False, True, True, False, False, False, False, False, 
     False, False, False, False, False, False, False, False); 
    Put_Line("#3: " & Boolean'Image(Lookup_Result)); 

end Bool_16_Map_Test;