/** * Calculate table index * * @return {int} table index (range: 0 .. MAX_IDX) * * | 0-5 | 6-7 | 8-10 * | wk (0..63) | wp file (0..3) | wp rank (0..5) */ inline int index(int wk, int wp) { int result = wk + (FILE(wp) << 6) + ((RANK(wp) - 1) << 8); assert(result >= 0 && result < MAX_IDX); assert(FILE(wp) <= 3); assert(RANK(wp) <= 6); return result; }
GString *board_format_line(board *b, char handsep, char suitsep) { GString *out = g_string_new(NULL); int h; for (h = 1; h < 5; h++) { int c; for (c = 51; c >= 39; c--) if (b->dealt_cards[c] == h) g_string_append_printf(out, "%c", rank_char(RANK(c))); g_string_append_printf(out, "%c", suitsep); for (c = 38; c >= 26; c--) if (b->dealt_cards[c] == h) g_string_append_printf(out, "%c", rank_char(RANK(c))); g_string_append_printf(out, "%c", suitsep); for (c = 25; c >= 13; c--) if (b->dealt_cards[c] == h) g_string_append_printf(out, "%c", rank_char(RANK(c))); g_string_append_printf(out, "%c", suitsep); for (c = 12; c >= 0; c--) if (b->dealt_cards[c] == h) g_string_append_printf(out, "%c", rank_char(RANK(c))); if (h < 4) g_string_append_printf(out, "%c", handsep); } return out; }
void GolfSolver::translate_layout() { /* Read the workspace. */ int total = 0; for ( int w = 0; w < 7; ++w ) { int i = translate_pile(deal->stack[w], W[w], 52); Wp[w] = &W[w][i - 1]; Wlen[w] = i; total += i; } int i = translate_pile( deal->waste, W[7], 52 ); Wp[7] = &W[7][i-1]; Wlen[7] = i; total += i; i = translate_pile( deal->talon, W[8], 52 ); Wp[8] = &W[8][i-1]; Wlen[8] = i; total += i; for ( int i = 0; i < 9; i++ ) { for ( int l = 0; l < Wlen[i]; l++ ) { card_t card = W[i][l]; if ( DOWN( card ) ) card = RANK( card ) + PS_SPADE + ( 1 << 7 ); else card = RANK( card ) + PS_SPADE; W[i][l] = card; } } }
void YukonSolver::undo_move(MOVE *m) { #if PRINT if ( m->totype == O_Type ) fprintf( stderr, "\nundo move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index ); else fprintf( stderr, "\nundo move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index ); print_layout(); #endif int from, to; card_t card; from = m->from; to = m->to; /* Add to 'from' pile. */ if ( m->turn_index > 0 ) { card_t card2 = *Wp[from]; if ( !DOWN( card2 ) ) card2 = ( SUIT( card2 ) << 4 ) + RANK( card2 ) + ( 1 << 7 ); *Wp[from] = card2; } if (m->totype == O_Type) { card = O[to] + Osuit[to]; O[to]--; Wp[from]++; *Wp[from] = card; Wlen[from]++; } else { for ( int l = m->card_index; l >= 0; l-- ) { card = W[to][Wlen[to]-l-1]; Wp[from]++; *Wp[from] = card; Wlen[from]++; *Wp[to]--; } Wlen[to] -= m->card_index + 1; hashpile(to); } if ( m->turn_index == 0 ) { card_t card = *Wp[from]; if ( DOWN( card ) ) card = ( SUIT( card ) << 4 ) + RANK( card ); else card += ( 1 << 7 ); *Wp[from] = card; } hashpile(from); #if PRINT print_layout(); #endif }
void YukonSolver::make_move(MOVE *m) { #if PRINT if ( m->totype == O_Type ) fprintf( stderr, "\nmake move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index ); else fprintf( stderr, "\nmake move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index ); print_layout(); #else //print_layout(); #endif int from, to; card_t card = NONE; from = m->from; to = m->to; for ( int l = m->card_index; l >= 0; l-- ) { card = W[from][Wlen[from]-l-1]; Wp[from]--; if ( m->totype != O_Type ) { Wp[to]++; *Wp[to] = card; Wlen[to]++; } } Wlen[from] -= m->card_index + 1; if ( m->turn_index == 0 ) { if ( DOWN( card ) ) card = ( SUIT( card ) << 4 ) + RANK( card ); else card += ( 1 << 7 ); W[to][Wlen[to]-m->card_index-1] = card; } else if ( m->turn_index != -1 ) { card_t card2 = *Wp[from]; if ( DOWN( card2 ) ) card2 = ( SUIT( card2 ) << 4 ) + RANK( card2 ); *Wp[from] = card2; } hashpile(from); /* Add to pile. */ if (m->totype == O_Type) { O[to]++; Q_ASSERT( m->card_index == 0 ); } else { hashpile(to); } #if PRINT print_layout(); #endif }
static inline int square_distance(int s1, int s2) { int r = abs(RANK(s1) - RANK(s2)); int c = abs(COLUMN(s1) - COLUMN(s2)); if (r > c) return r; else return c; };
int GypsySolver::good_automove(int o, int r) { int i; if (r <= 2) { return true; } /* Check the Out piles of opposite color. */ int red_piles[] = { 0, 1, 4, 5 }; int black_piles[] = { 2, 3, 6, 7 }; for (i = 0; i < 4; ++i) { int pile = 0; if ( COLOR( o ) == PS_BLACK ) pile = red_piles[i] + outs; else pile = black_piles[i] + outs; if ( !Wlen[pile] || RANK( *Wp[pile] ) < r - 1) { /* Not all the N-1's of opposite color are out yet. We can still make an automove if either both N-2's are out or the other same color N-3 is out (Raymond's rule). Note the re-use of the loop variable i. We return here and never make it back to the outer loop. */ for (i = 0; i < 4; ++i ) { if ( COLOR( o ) == PS_BLACK ) pile = red_piles[i] + outs; else pile = black_piles[i] + outs; if ( !Wlen[pile] || RANK( *Wp[pile] ) < r - 2) return false; } for (i = 0; i < 4; ++i ) { if ( COLOR( o ) == PS_BLACK ) pile = black_piles[i] + outs; else pile = red_piles[i] + outs; if ( !Wlen[pile] || RANK( *Wp[pile] ) < r - 3) return false; } return true; } } return true; }
// '[' RANK ']' // '[' '*' ']' BOOL CLRTypeName::TypeNameParser::ARRAY() { IfFalseReturn(TokenIs(TypeNameARRAY)); NextToken(); if (TokenIs(TypeNameAstrix)) { m_pTypeName->SetArray(1); NextToken(); } else { DWORD dwRank = 1; IfFalseReturn(RANK(&dwRank)); if (dwRank == 1) { m_pTypeName->SetSzArray(); } else { m_pTypeName->SetArray(dwRank); } } IfFalseReturn(TokenIs(TypeNameCloseSqBracket)); NextToken(); return TRUE; }
HandRank EvaluateHand(int hand[5]) { int rankcount[13]= {0}; for (int i=0; i< 5; i++) rankcount[RANK(hand[i])]++; if (is_royal(hand)) return eRoyal; if (is_straight_flush(hand, rankcount)) return eStraightFlush; if (is_four(rankcount)) return eFour; if (is_full(rankcount)) return eFull; if (is_flush(hand)) return eFlush; if (is_straight(rankcount)) return eStraight; if (is_three(rankcount)) return eThree; if (is_TwoPair(rankcount)) return eTwoPair; if (is_Pair(rankcount)) return ePair; return eBust; }
void PrettyPrint(Heap * h) { Heap * h1; if(h == NULL_HEAP) { printf(" nil "); return; } printf("("); h1 = h; do { PrintItem(ITEM(h1)); printf("[%u] ", RANK(h1)); PrettyPrint(CHILD(h1)); h1 = FORWARD(h1); } while(h1 != h); printf(")"); }
int GypsySolver::getOuts() { int k = 0; for (int o = 0; o < 8; ++o) if ( Wlen[outs + o] ) k += RANK( *Wp[outs + o] ); return k; }
inline bool higher( const card_t &c1, const card_t &c2) { // Sanity check. if (c1 == c2) return false; // Must be same suit. if ( SUIT( c1 ) != SUIT( c2 ) ) return false; // Aces form a special case. if (RANK( c2 ) == PS_ACE) return true; if (RANK( c1 ) == PS_ACE) return false; return (RANK( c1 ) < RANK( c2 )); }
void SimonSolver::undo_move(MOVE *m) { #if PRINT //qDebug() << "\n\nundo_move\n"; if ( m->totype == O_Type ) fprintf( stderr, "move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index ); else fprintf( stderr, "move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index ); print_layout(); #endif int from, to; card_t card; from = m->from; to = m->to; if (m->totype == O_Type) { for ( int j = PS_KING; j >= PS_ACE; --j ) { Wp[from]++; *Wp[from] = O[to] + j; Wlen[from]++; } O[to] = -1; hashpile( from ); #if PRINT print_layout(); #endif return; } /* Add to 'from' pile. */ if ( m->turn_index > 0 ) { card_t card2 = *Wp[from]; if ( !DOWN( card2 ) ) card2 = ( SUIT( card2 ) << 4 ) + RANK( card2 ) + ( 1 << 7 ); *Wp[from] = card2; } for ( int l = m->card_index; l >= 0; --l ) { card = W[to][Wlen[to]-l-1]; Wp[from]++; *Wp[from] = card; Wlen[from]++; Wp[to]--; } Wlen[to] -= m->card_index + 1; hashpile(to); hashpile(from); #if PRINT print_layout(); #endif }
int SanityCheck2(Heap * h) { int sum; Heap * h1; Heap * h2; if(h == NULL_HEAP) { return(TRUE); } h1 = h; do { if(CHILD(h1) != NULL_HEAP) { sum = 0; h2 = CHILD(h1); do { sum += RANK(h2) + 1; h2 = FORWARD(h2); } while(h2 != CHILD(h1)); if(sum != RANK(h1)) { return(FALSE); } if(!SanityCheck2(CHILD(h1))) { return(FALSE); } } h1 = FORWARD(h1); } while(h1 != h); return(TRUE); }
/* Wrapper over uvwrite_c to deal with numpy arrays, conversion of baseline * codes, and accepts preamble as a tuple. */ PyObject * UVObject_write(UVObject *self, PyObject *args) { PyArrayObject *data=NULL, *flags=NULL, *uvw=NULL; int i, j; double preamble[PREAMBLE_SIZE], t; // Parse arguments and typecheck if (!PyArg_ParseTuple(args, "(O!d(ii))O!O!", &PyArray_Type, &uvw, &t, &i, &j, &PyArray_Type, &data, &PyArray_Type, &flags)) return NULL; if (RANK(uvw) != 1 || DIM(uvw,0) != 3) { PyErr_Format(PyExc_ValueError, "uvw must have shape (3,) %d", RANK(uvw)); return NULL; } else if (RANK(data)!=1 || RANK(flags)!=1 || DIM(data,0)!=DIM(flags,0)) { PyErr_Format(PyExc_ValueError, "data and flags must be 1 dimensional and have the same shape"); return NULL; } CHK_ARRAY_TYPE(uvw, NPY_DOUBLE); CHK_ARRAY_TYPE(data, NPY_CFLOAT); // Check for both int,long, b/c label of 32b number is platform dependent if (TYPE(flags) != NPY_INT && \ (sizeof(int) == sizeof(long) && TYPE(flags) != NPY_LONG)) { PyErr_Format(PyExc_ValueError, "type(flags) != NPY_LONG or NPY_INT"); return NULL; } // Fill up the preamble preamble[0] = IND1(uvw,0,double); preamble[1] = IND1(uvw,1,double); preamble[2] = IND1(uvw,2,double); preamble[3] = t; preamble[4] = MKBL(i,j); // Here is the MIRIAD call try { uvwrite_c(self->tno, preamble, (float *)data->data, (int *)flags->data, DIM(data,0)); } catch (MiriadError &e) { PyErr_Format(PyExc_RuntimeError, e.get_message()); return NULL; } Py_INCREF(Py_None); return Py_None; }
bool GypsySolver::isWon() { // maybe won? for (int o = 0; o < 8; ++o) { if ( ( Wlen[outs + o] == 0 ) || ( RANK( *Wp[outs + o] ) != PS_KING ) ) return false; } return true; }
std::string SqToStr( int sq ) { char file = FILE(sq); char rank = RANK(sq); char buf[3]; buf[0] = file; buf[1] = rank; buf[2] = '\0'; std::string s = buf; return s; }
string refresh(int *cl, int b, int e) { string output = ""; int i, ls, ns; if (b < 0 || e < 0) return output; if (cl[b] < 0 || cl[e] > 51) return output; output = sprintf("%18s%s:", "", suit_str[ls = ns = SUIT(cl[b])]); for (i = b; i <= e; i++) { ns = SUIT(cl[i]); if (ls == ns) output += rank_str[RANK(cl[i])] + " "; else { output = sprintf("%s\n%18s%s:", output, "", suit_str[ls = ns]); output += rank_str[RANK(cl[i])] + " "; } } return output + "\n"; }
void SimonSolver::make_move(MOVE *m) { #if PRINT //qDebug() << "\n\nmake_move\n"; if ( m->totype == O_Type ) fprintf( stderr, "move %d from %d out (at %d) Prio: %d\n\n", m->card_index, m->from, m->turn_index, m->pri ); else fprintf( stderr, "move %d from %d to %d (%d) Prio: %d\n\n", m->card_index, m->from, m->to, m->turn_index, m->pri ); print_layout(); #else //print_layout(); #endif int from, to; card_t card = NONE; from = m->from; to = m->to; if (m->totype == O_Type) { O[to] = SUIT( *Wp[from] ); Wlen[from] -= 13; Wp[from] -= 13; hashpile( from ); if ( Wlen[from] && DOWN( *Wp[from] ) ) { *Wp[from] = ( SUIT( *Wp[from] ) << 4 ) + RANK( *Wp[from] ); } #if PRINT print_layout(); #endif return; } for ( int l = m->card_index; l >= 0; --l ) { card = W[from][Wlen[from]-l-1]; Wp[from]--; if ( m->totype != O_Type ) { Wp[to]++; *Wp[to] = card; Wlen[to]++; } } Wlen[from] -= m->card_index + 1; hashpile(from); hashpile(to); #if PRINT print_layout(); #endif }
static char *lin_card_string(board *b) { static char out[39+16+4+1]; int i = 0, h; for (h = 4; h != 3; h = (h == 4 ? 1 : h + 1)) { int c; out[i++] = 'S'; for (c = 39; c < 52; c++) if (b->dealt_cards[c] == h) out[i++] = rank_char(RANK(c)); out[i++] = 'H'; for (c = 26; c < 39; c++) if (b->dealt_cards[c] == h) out[i++] = rank_char(RANK(c)); out[i++] = 'D'; for (c = 13; c < 26; c++) if (b->dealt_cards[c] == h) out[i++] = rank_char(RANK(c)); out[i++] = 'C'; for (c = 0; c < 13; c++) if (b->dealt_cards[c] == h) out[i++] = rank_char(RANK(c)); out[i++] = ','; } return out; }
// *empty* // ',' RANK BOOL CLRTypeName::TypeNameParser::RANK(DWORD* pdwRank) { if (!TokenIs(TypeNameRANK)) { return TRUE; } NextToken(); *pdwRank = *pdwRank + 1; IfFalseReturn(RANK(pdwRank)); return TRUE; }
void IdiotSolver::make_move(MOVE *m) { #if PRINT if ( m->totype == O_Type ) fprintf( stderr, "\nmake move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index ); else fprintf( stderr, "\nmake move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index ); print_layout(); #else //print_layout(); #endif int from, to; card_t card = NONE; from = m->from; to = m->to; if ( from == 4 ) { Q_ASSERT( Wlen[from] >= 4 ); for ( int i = 0; i < 4; ++i ) { Wp[i]++; card = *Wp[from]; *Wp[i] = ( SUIT( card ) << 4 ) + RANK( card ); Wp[from]--; Wlen[from]--; Wlen[i]++; hashpile( i ); } hashpile( from ); } else { card = *Wp[from]; Wp[from]--; Wlen[from]--; *Wp[to]++; *Wp[to] = card; Wlen[to]++; hashpile( to ); hashpile(from); } #if PRINT print_layout(); #endif }
void GolfSolver::make_move(MOVE *m) { #if PRINT if ( m->totype == O_Type ) fprintf( stderr, "\nmake move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index ); else fprintf( stderr, "\nmake move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index ); print_layout(); #else //print_layout(); #endif int from = m->from; int to = m->to; Q_ASSERT( to == 7 ); Q_ASSERT( from != 7 ); // move to pile if ( from == 8 && to == 7 ) { card_t card = *Wp[8]; Wp[8]--; Wlen[8]--; card = ( SUIT( card ) << 4 ) + RANK( card ); Wp[7]++; *Wp[7] = card; Wlen[7]++; hashpile( 7 ); hashpile( 8 ); #if PRINT print_layout(); #endif return; } card_t card = *Wp[from]; Wp[from]--; Wlen[from]--; Wp[to]++; *Wp[to] = card; Wlen[to]++; hashpile(from); hashpile(to); #if PRINT print_layout(); #endif }
char GetRankChar(unsigned char c) { /* * */ const char randChars[] = " 23456789TJQKA"; if(ISCARDBACK(c)) return '?'; if(ISUNKNOWN(c)) return '_'; return randChars[RANK(c)]; }
int SanityCheck3(Heap * h, int rank) { int sum; Heap * h1; Heap * h2; if((h == NULL_HEAP) && (rank == 0)) { return(TRUE); } sum = 0; h1 = h; do { sum += RANK(h1) + 1; if(!SanityCheck3(CHILD(h1), RANK(h1))) { return(FALSE); } h1 = FORWARD(h1); } while(h1 != h); if(sum == rank) { return(TRUE); } else { return(FALSE); } }
// CAdds data to a at indices specified in ind. Assumes arrays are safe. static int caddloop(PyArrayObject *a, PyArrayObject *ind, PyArrayObject *data) { char *index = NULL; int v; for (int i=0; i < DIM(ind,0); i++) { index = a->data; for (int j=0; j < RANK(a); j++) { v = IND2(ind,i,j,long); if (v < 0) v += DIM(a,j); if (v < 0 || v >= DIM(a,j)) return -1; index += v * a->strides[j]; } CADD(index,PNT1(data,i),T); } return 0; }
void IdiotSolver::undo_move(MOVE *m) { #if PRINT if ( m->totype == O_Type ) fprintf( stderr, "\nundo move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index ); else fprintf( stderr, "\nundo move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index ); print_layout(); #endif int from, to; card_t card; from = m->from; to = m->to; if ( from == 4 ) { for ( int i = 3; i >= 0; --i ) { card = *Wp[i]; Wp[i]--; Wlen[i]--; Wp[from]++; *Wp[from] = ( SUIT( card ) << 4 ) + RANK( card ) + ( 1 << 7 ); Wlen[from]++; hashpile( i ); } hashpile( from ); } else { card = *Wp[to]; Wp[to]--; Wlen[to]--; *Wp[from]++; *Wp[from] = card; Wlen[from]++; hashpile( to ); hashpile(from); } #if PRINT print_layout(); #endif }
char* StringPosition(Position pos) { char ret[2+1]; // Unsigned so we don't need to check < 0. if(pos > 63) { return strdup("#invalid position"); } if(sprintf(ret, "%c%d", 'a'+FILE(pos), RANK(pos)+1) != 2) { panic("Couldn't string position"); } ret[2] = '\0'; return strdup(ret); }
void ClockSolver::undo_move(MOVE *m) { #if PRINT2 if ( m->totype == O_Type ) fprintf( stderr, "\nundo move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index ); else fprintf( stderr, "\nundo move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index ); print_layout(); #endif int from, to; card_t card; from = m->from; to = m->to; if (m->totype == O_Type) { card = W[8][to]; if ( RANK( card ) == PS_ACE ) W[8][to] = W[8][to] - PS_ACE + PS_KING; else W[8][to]--; Wp[from]++; *Wp[from] = card; Wlen[from]++; hashpile( 8 ); hashpile( from ); } else { card = *Wp[to]; Wp[from]++; *Wp[from] = card; Wlen[from]++; Wp[to]--; Wlen[to]--; hashpile(to); hashpile( from ); } #if PRINT2 print_layout(); #endif }
void ClockSolver::make_move(MOVE *m) { #if PRINT if ( m->totype == O_Type ) fprintf( stderr, "\nmake move %d from %d out %d (at %d)\n\n", m->card_index, m->from, m->to, m->turn_index ); else fprintf( stderr, "\nmake move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index ); print_layout(); #else //print_layout(); #endif int from, to; from = m->from; to = m->to; card_t card = *Wp[from]; Wlen[from]--; Wp[from]--; hashpile(from); /* Add to pile. */ if (m->totype == O_Type) { if ( RANK( W[8][to] ) == PS_KING ) W[8][to] = W[8][to] - PS_KING + PS_ACE; else W[8][to]++; Q_ASSERT( m->card_index == 0 ); hashpile( 8 ); } else { Wp[to]++; *Wp[to] = card; Wlen[to]++; hashpile( to ); } #if PRINT print_layout(); #endif }