Gehts auch einfacher (für Logiker) ?

Tomahawk

Ich habe folgende Konstruktion:

if (
(bb_rank_attack(square, blockers) & bb_set[white_king_square]) 
&&       
(bb_rank_attack(square, blockers) & (black_rook_bb | black_queen_bb))) return 1;

bb_rank_attack ist eine etwas zeitintensivere Function und muss in meiner Konstruktion 2x aufgerufen werden. Allerdings möchte ich den Ergebniswert von bb_rank_attack nicht in einer temporären Variable zwischenspeichern.

Lässt sich der logische Ausdruck irgendwie anders zusammensetzen?

Vielen Dank schonmal

Bashar

if (bb_rank_attack(square, blockers) 
    & bb_set[white_king_square] 
    & (black_rook_bb | black_queen_bb)) return 1;

?

Edit: Jo, das ist wohl undurchdachter Käse

dekcarki

Ich hätte jetzt

if (
(bb_rank_attack(square, blockers) & 
       ( bb_set[white_king_square] | black_rook_bb | black_queen_bb ) )
            return 1;

gesagt, weil in bb_set[white_king_square] kann ja was gesetzt sein, was in (black_rook_bb | black_queen_bb) nicht gesetzt ist.

bsp:

bb_rank_attack(square, blockers) = 110 = A
bb_set[white_king_square] = 100 = B
(black_rook_bb | black_queen_bb) = 010 = C

A&B = 100
A&C = 010
=> A&B&C = 000 -> falsch

B|C = 110
A&(B|C) = 110 -> wahr

Tomahawk

Nein, das geht nicht.

Beispiel aus dem Schach:

bb_rank_attack sei:

`

xx-xxxx-

`

bb_set[white_king_square] sei:

`

------x-

`

(black_rook_bb | black_queen_bb) sei:

`

x-------

`

Also wäre Deine Formulierung nicht wahr, obwohl sie wahr ist (siehe oben).

knivil

Lässt sich der logische Ausdruck irgendwie anders zusammensetzen?

Es ist kein logischer Ausdruck, da du Bitoperationen hast.

Allerdings möchte ich den Ergebniswert von bb_rank_attack nicht in einer temporären Variable zwischenspeichern.

Warum auch immer. Die 4 Byte auf dem Stack tun schon weh. Aber im Allgemeinen muss man Ergebnisse zwischenspeichern, wenn man sie wiederverwenden will ohne Neuberechnung.

Tomahawk

dekcarki schrieb:

Ich hätte jetzt
if (
(bb_rank_attack(square, blockers) & 
       ( bb_set[white_king_square] | black_rook_bb | black_queen_bb ) )
            return 1;
gesagt, weil in bb_set[white_king_square] kann ja was gesetzt sein, was in (black_rook_bb | black_queen_bb) nicht gesetzt ist.

bsp:

bb_rank_attack(square, blockers) = 110 = A
bb_set[white_king_square] = 100 = B
(black_rook_bb | black_queen_bb) = 010 = C

A&B = 100
A&C = 010
=> A&B&C = 000 -> falsch

B|C = 110
A&(B|C) = 110 -> wahr

Ist auch nicht dasselbe!

bsp:

bb_rank_attack(square, blockers) = 110 = A
bb_set[white_king_square] = 100 = B
(black_rook_bb | black_queen_bb) = 000 = C

A&B = 100
A&C = 000
=> A&B&C = 000 -> falsch

B|C = 100
A&(B|C) = 100 -> wahr

dekcarki

So, Edit die 3.

A = bb_rank_attack(square, blockers)
B = bb_set[white_king_square]
C = (black_rook_bb | black_queen_bb)

if( ( A^(B|C) ) & (B|C) == 0 ) return 1;

A = 1100
B = 1000
C = 0100

(B|C) = 1100
A^(B|C) = 0000
(A^(B|C))&(B|C) = 0000 passt.

A = 1100
B = 1000
C = 0010

(B|C) = 1010
A^(B|C) = 0110
(A^(B|C))&(B|C) = 0010 <-- ist ungleich 0, also passt das auch.

hustbaer

Tomahawk schrieb:

bb_rank_attack ist eine etwas zeitintensivere Function und muss in meiner Konstruktion 2x aufgerufen werden. Allerdings möchte ich den Ergebniswert von bb_rank_attack nicht in einer temporären Variable zwischenspeichern.

Wieso nicht?

Bashar

dekcarki schrieb:

if( ( A^(B|C) ) & (B|C) == 0 ) return 1;

Das ist doch jetzt bloß noch Rumprobieren.

Gegenbeispiel:
A = 0001010
B = 1101100
C = 0110110

B|C = 1111110
A^(B|C) = 1110100
A^(B|C) & (B|C) = 1110100 != 0

Aber:
A & B = 0001000
A & C = 0000010
Also: (A&B) && (A&C) == true

Mein Tipp: Es geht nicht, man braucht insgesamt zwei Vergleiche auf 0.