def shuffle(self):
# and then shuffle
if self.variant == 'FULL_DECK':
self.cards = Deck.GetFullDeck()
else:
self.cards = Deck.GetShortDeck()
rshuffle(self.cards)
def siim_data_gen(filepaths,
batch_size,
dim=(1024, 1024),
shuffle=True,
mask_dir="",
augment_data=True):
"""An infinite generator that gives X, Y of shape (batch_size, *dims, 1) (float32), from the given valid
filepaths."""
from random import shuffle as rshuffle
down_sampling = 1024 // dim[0]
# Actually generate an infinite number of epochs
while True:
# We generate batches for one epoch
rshuffle(filepaths)
for i in range(0, len(filepaths) + batch_size, batch_size):
xs, ys = [], []
for filepath in filepaths[i:i + batch_size]:
X, Y = load_filep(filepath, down_sampling, mask_dir)
if augment_data:
X, Y = augment_sample(X[:, :, 0], Y[:, :, 0])
X = np.expand_dims(X, axis=2)
X = np.repeat(X, 3, axis=2)
Y = np.expand_dims(Y, axis=2)
xs.append(X)
ys.append(Y)
if len(xs) == 0:
break
yield np.array(xs), np.array(ys)
def shuffle(queryset):
if isinstance(queryset, list):
new_list = queryset[:]
rshuffle(new_list)
return new_list
return queryset.order_by('?')
def cards_shuffle(self):
l_cards = self.df_cards.values.tolist()
n_cards = self.df_cards.values
np.random.shuffle(n_cards)
rshuffle(self.cards)
self.sync_list_to_df()
def odds(hand, board, num_players):
my_hand = [Card.new(hand[0]), Card.new(hand[1])]
remove_cards = [Card.new(hand[0]), Card.new(hand[1])]
my_board = []
for i in range(len(board)):
import sys
print(board, file=sys.stderr)
try:
my_board.append(Card.new(board[i]))
remove_cards.append(Card.new(board[i]))
except KeyError as e:
print("BAD!!!", file=sys.stderr)
exit()
my_deck = Deck()
for i in range(len(remove_cards)):
my_deck.cards.remove(remove_cards[i])
my_players = [my_hand]
evaluator = Evaluator()
count = 0
for b in range(1000):
deck = Deck()
cards = my_deck.cards.copy()
rshuffle(cards)
deck.cards = cards
players = my_players.copy()
for j in range(num_players - 1):
players.append(deck.draw(2))
board = my_board.copy()
while len(board) < 5:
board.append(deck.draw(1))
if evaluator.hand_summary(board, players) == 0:
count += 1
return count / 1000
def shuffle(self):
# and then shuffle
self.cards = Deck.GetFullDeck()
rshuffle(self.cards)
self.dead_cards = []
def shuffle(self):
"""Shuffle the deck's cards."""
rshuffle(self.cards)
def shuffle(self):
"""洗牌"""
self.index = 0
rshuffle(self.cards)
def shuffle(self) -> None:
# and then shuffle
self.cards = Deck.GetFullDeck()
rshuffle(self.cards)
def shuffle(self):
if len(self.cards) < 52:
raise ValueError("Only full decks can be shuffled")
rshuffle(self.cards)
def shuffle(self):
rshuffle(self._deck)
def reshuffle(self):
rshuffle(self.cards)
def shuffle(self):
# and then shuffle
self.cards = self.GetPartialDeck(self.cardsToExclude)
rshuffle(self.cards)
def shuffle(self):
rshuffle(self.cards)
return
def reshuffle(self):
self.cards = Deck.GetFullDeck()
for card in self.dead_cards:
self.cards.remove(card)
rshuffle(self.cards)
def shuffle(self):
"""Shuffle deck"""
rshuffle(self._cards)
def shuffle(self):
if self.cheat:
return
# and then shuffle
self.cards = Deck.GetFullDeck()
rshuffle(self.cards)
def shuffle(self):
rshuffle(self.__stk)
def __setup_52_cards(self):
cards = Deck.GetFullDeck()
rshuffle(cards)
return cards
def shuffle(self):
self.cards = Deck.get_full_deck()
rshuffle(self.cards)
def shuffle(self):
rshuffle(self._deck)
