Spezieller Code oder allgemeiner Code?

Tomahawk

Euer sarkastischer Humor zu später Stunde impliziert, dass euch nicht solch massive Grundlagenprobleme wie mir vorliegen

Ist denn so ein Aufbau mit relativ vielen Zugriffen auf 2-dimensionale Arrays merklich ineffizienter (hinsichtlich der Laufzeiteffizienz), als eine "feste Verdrahtung"?

Oder kann ich diesen Aspekt vernachlässigen (tue ich gerne, wenn es unter 10% Speedverlust bleiben kann)?

drakon

Machs allgemein und profile dein Programm am Ende. Wenn du merkst, dass es an der Stelle einen Engpass gibt, dann ändere es, ansonsten lass es.

Tomahawk schrieb:

Ist denn so ein Aufbau mit relativ vielen Zugriffen auf 2-dimensionale Arrays merklich ineffizienter (hinsichtlich der Laufzeiteffizienz), als eine "feste Verdrahtung"?

Ein Zugriff auf ein Array spürst du zeitlich nicht, es muss nur ein Offset errechnet werden und du bist bei deinen Daten.
Aber ganz versteh ich dein Problem nicht, du hast in beiden Beispielen noch dein CASE, da ist es doch wurscht ob die Struktur ein farbenindiziertes Array hat, oder die Werte direkt mit black_rook oder sonstwas angesprochen werden.

Ich kann dem nur Zustimmen. Grundsätzlich gilt es so zu programmieren, dass man den Code einfach warten kann. Und ein Code der redundant ist, ist ein Monster!

Wenn dein Programm läuft, dann gibt es Möglichkeiten die Programmteile, wo wirklich Zeit verloren geht zu finden und zu verbessern.

Tomahawk

demotron schrieb:

Tomahawk schrieb:

Ist denn so ein Aufbau mit relativ vielen Zugriffen auf 2-dimensionale Arrays merklich ineffizienter (hinsichtlich der Laufzeiteffizienz), als eine "feste Verdrahtung"?

Ein Zugriff auf ein Array spürst du zeitlich nicht, es muss nur ein Offset errechnet werden und du bist bei deinen Daten.
Aber ganz versteh ich dein Problem nicht, du hast in beiden Beispielen noch dein CASE, da ist es doch wurscht ob die Struktur ein farbenindiziertes Array hat, oder die Werte direkt mit black_rook oder sonstwas angesprochen werden.

Sorry, das habe ich erst nach dem Posten gemerkt. So war es gemeint:

case PIECE_ROOK:                                     // so natürlich
      board.bitboard[color]&=bitboard_clear[to]; 
      board.rook_bitboard[color]&=bitboard_clear[to]; 
      board.rooks[color]--; 
      board.pieces[color]--; 
      board.key_pieces^=random_rook[color][to]; 
      board.key_material^=random_rook_material[color][board.rooks[color]]; 
      board.moves[to]++; 
      break;

Tomahawk

// für spiegelungen kommt noch etwas bitgefummel für die symetrie hinzu.

// anstatt...

if (board[square] == E1) { }

// könnte ich zwei versionen schreiben:

if (board[square^(56*color)] == E1) { }  // color=0|1

if (board[square] == (E1^(56*color))) { }  // color=0|1

macht das einen Unterschied für den Compiler hinsichtlich Effizienz?

// das waren alle probleme mit der symterie des schachbrettes

Tomahawk

Sorry, ich bin müde und unkonzentriert, ich meinte natürlich:

// spezieller code der redundanten fassung sieht etwa so aus:

if (square == CONST_E1) { } 

// für den code allgemeinen fassung könnte ich zwei versionen schreiben: 

if ((square^(56*color)) == CONST_E1) { }  // color=0|1 

if (square == (CONST_E1^(56*color))) { }  // color=0|1 

macht das einen Unterschied für den Compiler hinsichtlich Effizienz? !

unskilled

zu müde um das "edit"-feld zu sehen? nach 37 posts sollte man das ja doch mal mitbekommen haben?! ^^

was willst du denn jetzt noch hören?
jeder programmierer wird dir immer sagen, dass doppelter code doof ist... wie volkard das schon vorgemacht hat...

bb

5cript

CONST_E1^(56*color)

Value ^ 56
ist das nicht etwas hoch ???
bei 2
-->
72057594037927936

ich bin zu müde noch nachdenken zu wollen, was bringt das denn jetzt ?

ich bin zu müde noch nachdenken zu wollen, was bringt das denn jetzt ?

Hinweis: Dein Fehler liegt in der Interpretation des ^-Operators

Tomahawk

Tim06TR schrieb:

CONST_E1^(56*color)

Value ^ 56
ist das nicht etwas hoch ???
bei 2
-->
72057594037927936

ich bin zu müde noch nachdenken zu wollen, was bringt das denn jetzt ?

square^56 ist eine vertikale Spielelung eines Feldes auf dem Schachbrett (A1->A8 usw.)