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

?

Edit: Jo, das ist wohl undurchdachter Käse

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

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

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.

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

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.

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?

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.