def test_add_projection(self):
db = "cinema.db"
projections = Projections(db)
#projections.add_projection(1, "3D", "2014-04-01", "19:10")
#projections.add_projection(1, "2D", "2014-04-01", "19:00")
#projections.add_projection(1, "4DX", "2014-04-02", "21:00")
#projections.add_projection(3, "2D", "2014-04-05", "20:00")
#projections.add_projection(2, "3D", "2014-04-02", "22:00")
#projections.add_projection(2, "2D", "2014-04-02", "19:30")
#TESTING SHOW PROJECTIONS
projections.show_movie_projection(2)
def make_a_reservation(cursor, connection):
seats = []
username = input("Enter username > ")
number_of_tickets = input("Enter the number of tickets > ")
Movies.get_all(cursor, connection)
movie_id = input("Choose a projection >")
Projections.get_all_for(cursor, movie_id)
projection_id = input("Enter the wanted projection")
for x in range(1, int(number_of_tickets)+1):
seats.append(Reservations.choose_seats(cursor, connection, projection_id))
Reservations.print_reservation(cursor, username, movie_id, projection_id, seats)
Reservations.confirm(cursor, connection, username, projection_id, seats)
def main():
connection = sqlite3.connect('cinema')
connection.row_factory = sqlite3.Row
cursor = connection.cursor()
cursor.execute('''CREATE TABLE IF NOT EXISTS cinema(id INTEGER PRIMARY KEY,
name TEXT)''')
Projections.load_reservations()
connection.commit()
Reservations.create_database(connection, cursor)
Projections.create_database(connection, cursor)
Movies.create_database(connection, cursor)
cinema = Cinema()
cinema.main_menu(cursor, connection)
def show_movie_projections(self, movie_id):
spots_unavailable = Reservations.show_used_seats_on_each_projection(
self.__conn)
avail_sp = {}
for x in spots_unavailable:
avail_sp[x['projection_id']] = self.capacity - x['num']
return {
"projetions":
Projections.show_movie_projections_by_movie_id(movie_id),
"available_spots": avail_sp}
def optimize(numRemainingPos, remainingPosList, remainingSal, excludedNames,
numLineups, salariesDir, projDir):
proj = Projections(salariesDir, projDir)
data = proj.data
clean_data = cleanProj(data)
removePlayers(clean_data, excludedNames)
clean_data.reset_index(drop=True, inplace=True)
posIndicies = getPosIndices(clean_data, remainingPosList)
# Get matrix of all combinations of Player Identities
indexCombinations = np.array(np.meshgrid(*posIndicies)).T.reshape(
-1, numRemainingPos)
rangeSeries = np.array(range(indexCombinations.shape[0]))
rangeMatrix = np.repeat(rangeSeries,
numRemainingPos).reshape(-1, numRemainingPos)
rangeMatrixMult = rangeMatrix * len(clean_data)
indexIncrements = (rangeMatrixMult + indexCombinations).reshape(-1)
playerIdentities = np.zeros(indexCombinations.shape[0] * len(clean_data))
np.add.at(playerIdentities, indexIncrements, 1)
playerIdentities = playerIdentities.reshape(-1, len(clean_data))
# Get matrix of projections
pointProjections = clean_data["Fpts"].to_numpy(copy=True)
pointProjMatrix = np.repeat(pointProjections.reshape(1, -1),
indexCombinations.shape[0],
axis=0)
salaries = clean_data["Salary"].to_numpy(copy=True)
salaryMatrix = np.repeat(salaries.reshape(1, -1),
indexCombinations.shape[0],
axis=0)
# Create masks for salary and duplicate (no more than 1 of each player) restraints
lineupSalMatrix = salaryMatrix * playerIdentities
lineupSalTotals = np.sum(lineupSalMatrix, axis=1)
salMask = np.where(lineupSalTotals <= remainingSal, 1, 0)
maxOccurrenceArray = np.amax(playerIdentities, axis=1)
dupeMask = np.where(maxOccurrenceArray > 1, 0, 1)
# Apply masks to projection totals
lineupProjMatrix = pointProjMatrix * playerIdentities
lineupProjTotals = np.sum(lineupProjMatrix, axis=1) * salMask * dupeMask
lineupOrder = np.argsort(lineupProjTotals)
playerNames = clean_data["Name"]
lineupNum = numLineups
for lineupInd in lineupOrder[-lineupNum:]:
print("Lineup " + str(lineupNum) + ":")
lineupPlayerIndices = np.argsort(
playerIdentities[lineupInd, :])[-numRemainingPos:]
for playerIndex in lineupPlayerIndices:
print(playerNames[playerIndex])
print(str(lineupProjTotals[lineupInd]) + " Fpts")
print("\n")
lineupNum -= 1
def choose_seats(cursor, connection, projection_id):
Projections.print_projection_seats(projection_id)
row_and_col = input("Enter the row and the collum separated with \" , \" >")
row_and_col = (row_and_col.split(","))
Reservations.reserv_seat(cursor, connection, projection_id, row_and_col[0], row_and_col[1])
return (row_and_col)
def choose_movie(cls, conn, movie_id):
res = Projections.show_projections(conn, movie_id=movie_id)
return res
def comp_sketch(matrix, objective, load_N=False, save_N=False, N_dir='../N_file/', **kwargs):
"""
Given matrix A, the function comp_sketch computes a sketch for A and performs further operations on PA.
It returns the total running time and the desired quantity.
parameter:
matrix: a RowMatrix object storing the matrix [A b]
objective: either 'x' or 'N'
'x': the function returns the solution to the problem min_x || PA[:,:-1]x - PA[:,-1] ||_2
'N': the function returns a square matrix N such that PA[:,:-1]*inv(N) is a matrix with orthonormal columns
load_N: load the precomputed N matrices if possible (it reduces the actual running time for sampling sketches)
save_N: save the computed N matrices for future use
sketch_type: either 'projection' or 'sampling'
projection_type: cw, gaussian, rademacher or srdht
c: projection size
s: sampling size (for sampling sketch only)
k: number of independent trials to run
"""
sketch_type = kwargs.get('sketch_type')
if not os.path.exists(N_dir):
os.makedirs(N_dir)
if objective == 'x':
if sketch_type == 'projection':
projection = Projections(**kwargs)
t = time.time()
x = projection.execute(matrix, 'x', save_N)
t = time.time() - t
if save_N:
logger.info('Saving N matrices from projections!')
N = [a[0] for a in x]
x = [a[1] for a in x]
# saving N
filename = N_dir + 'N_' + matrix.name + '_projection_' + kwargs.get('projection_type') + '_c' + str(int(kwargs.get('c'))) + '_k' + str(int(kwargs.get('k')))+ '.dat'
data = {'N': N, 'time': t}
pickle_write(filename,data)
elif sketch_type == 'sampling':
s = kwargs.get('s')
new_N_proj = 0
N_proj_filename = N_dir + 'N_' + matrix.name + '_projection_' + kwargs.get('projection_type') + '_c' + str(int(kwargs.get('c'))) + '_k' + str(int(kwargs.get('k'))) +'.dat'
if load_N and os.path.isfile(N_proj_filename):
logger.info('Found N matrices from projections, loading them!')
N_proj_filename = N_dir + 'N_' + matrix.name + '_projection_' + kwargs.get('projection_type') + '_c' + str(int(kwargs.get('c'))) + '_k' + str(int(kwargs.get('k'))) +'.dat'
result = pickle_load(N_proj_filename)
N_proj = result['N']
t_proj = result['time']
else: # otherwise, compute it
t = time.time()
projection = Projections(**kwargs)
N_proj = projection.execute(matrix, 'N')
t_proj = time.time() - t
new_N_proj = 1
sampling = Sampling(N=N_proj)
t = time.time()
x = sampling.execute(matrix, 'x', s, save_N )
t = time.time() - t + t_proj
if save_N and new_N_proj:
logger.info('Saving N matrices from projections!')
#filename = N_dir + 'N_' + matrix.name + '_projection_' + kwargs.get('projection_type') + '_c' + str(int(kwargs.get('c'))) + '_k' + str(int(kwargs.get('k'))) + '.dat'
data = {'N': N_proj, 'time': t_proj}
pickle_write(N_proj_filename,data)
if save_N:
logger.info('Saving N matrices from sampling!')
N = [a[0] for a in x]
x = [a[1] for a in x]
filename = N_dir + 'N_' + matrix.name + '_sampling_s' + str(int(kwargs.get('s'))) + '_' + kwargs.get('projection_type') + '_c' + str(int(kwargs.get('c'))) + '_k' + str(int(kwargs.get('k'))) + '.dat'
data = {'N': N, 'time': t}
pickle_write(filename,data)
else:
raise ValueError('Please enter a valid sketch type!')
return x, t
elif objective == 'N':
if sketch_type == 'projection':
N_proj_filename = N_dir + 'N_' + matrix.name + '_projection_' + kwargs.get('projection_type') + '_c' + str(int(kwargs.get('c'))) + '_k' + str(int(kwargs.get('k'))) + '.dat'
if load_N and os.path.isfile(N_proj_filename):
logger.info('Found N matrices from projections, loading them!')
result = pickle_load(N_proj_filename)
N = result['N']
t = result['time']
else:
t = time.time()
projection = Projections(**kwargs)
N = projection.execute(matrix, 'N')
t = time.time() - t
if save_N:
logger.info('Saving N matrices from projections!')
data = {'N': N, 'time': t}
pickle_write(N_proj_filename,data)
elif sketch_type == 'sampling':
s = kwargs.get('s')
new_N_proj = 0
new_N_samp = 0
N_samp_filename = N_dir + 'N_' + matrix.name + '_sampling_s' + str(int(kwargs.get('s'))) + '_' + kwargs.get('projection_type') + '_c' + str(int(kwargs.get('c'))) + '_k' + str(int(kwargs.get('k'))) + '.dat'
N_proj_filename = N_dir + 'N_' + matrix.name + '_projection_' + kwargs.get('projection_type') + '_c' + str(int(kwargs.get('c'))) + '_k' + str(int(kwargs.get('k'))) + '.dat'
if load_N and os.path.isfile(N_samp_filename):
logger.info('Found N matrices from sampling, loading them!')
result = pickle_load(N_samp_filename)
N = result['N']
t = result['time']
elif load_N and os.path.isfile(N_proj_filename):
logger.info('Found N matrices from projections, loading them!')
result = pickle_load(N_proj_filename)
N_proj = result['N']
t_proj = result['time']
sampling = Sampling(N=N_proj)
t = time.time()
N = sampling.execute(matrix, 'N', s)
t = time.time() - t + t_proj
new_N_samp = 1
else:
t = time.time()
projection = Projections(**kwargs)
N_proj = projection.execute(matrix, 'N')
t_proj = time.time() - t
new_N_proj = 1
t = time.time()
sampling = Sampling(N=N_proj)
N = sampling.execute(matrix, 'N', s)
t = time.time() - t + t_proj
new_N_samp = 1
if save_N and new_N_proj:
logger.info('Saving N matrices from projections!')
data = {'N': N_proj, 'time': t_proj}
pickle_write(N_proj_filename,data)
if save_N and new_N_samp:
logger.info('Saving N matrices from sampling!')
data = {'N': N, 'time': t}
pickle_write(N_samp_filename,data)
else:
raise ValueError('Please enter a valid sketch type!')
return N, t
else:
raise ValueError('Please enter a valid objective!')
def test_projection_Gaussian_x(self):
proj = Projections(projection_type='gaussian', sc=sc, c=1e2, k=3)
sol = proj.execute(self.matrix_Ab, 'x')
self.assertEqual(len(sol), 3)
self.assertEqual(len(sol[0]), self.matrix_Ab.n)
from movies import Movies
from projections import Projections
from reservation import Reservation
db = "cinema.db"
movies = Movies(db)
projections = Projections(db)
reservation = Reservation(db)
reservation.clear_reservation_on_stratup()
def start_mess():
start_message = "Hello, here is the cinema. You can \
use one of the the following commands:\
\n show_movies - print all movies ordered by rating\
\n show_movie_projections <movie_id> - \
print all projections of a given movie\
\n make_reservation\
\n cancel_reservation <name> - disintegrate given person's reservation\
\n exit\
\n help"
return start_message
def print_func(set_obj):
for row in set_obj:
print(row)
def print_hall(matrix):
def test_projection_Gaussian_x(self):
proj = Projections(projection_type='gaussian',sc=sc,c=1e2,k=3)
sol = proj.execute(self.matrix_Ab, 'x')
self.assertEqual(len(sol), 3)
self.assertEqual(len(sol[0]), self.matrix_Ab.n)
def test_projection_SRDHT_x(self):
proj = Projections(projection_type='srdht',sc=sc,c=1e2)
sol = proj.execute(self.matrix_Ab, 'x')
self.assertEqual(len(sol[0]), self.matrix_Ab.n)
class ProjectionSimulator(object):
"""
Simple class to simulate parallel-beam x-ray projections of a phantom.
Since the projections are usually obtained from a phantom, it's preferred
(for convenience) to match the number of bins to the pixel size of the
phantom. Otherwise, the phantom needs to be resized before being projected.
If the reconstruction is performed using a binary system matrix, that
matrix can be evaluated during the projection.
"""
def __init__(self, views, nrBins, phantom=None, start=0, stop=180):
self.__phantom = phantom
self.__nrBins = nrBins
self._views = views
self._start = start
self._stop = stop
self._angleInc = (stop-start)/float(views)
self.__projections = None
@property
def loadSize(self):
return self._views
@property
def phantom(self):
return self.__phantom
@property
def projections(self):
return self.__projections
@property
def views(self):
return self._views
def initProjections(self):
""" Initialize the projections object. """
self.__projections = Projections(self._views, self.__nrBins)
def projectAll(self, start=0, stop=180):
"""
Simulate a parallel-beam x-ray projection by summing up the phantom
data matrix column wise, yielding a sinogram line.
To this end, the number of bins (that the phantom is projected onto)
and the phantom pixel size should be equal. Otherwise, the phantom
needs to be reshaped.
"""
if self.readyForProjecting():
for a in range(0, self._views):
if a%25==0:
print "Projecting view " + str(a)
self.computeOne(a)
def computeOne(self, view):
"""
Helper function. Performs a single projection.
Required in ProjectionSimulatorHandler.process() to signal progress
after a single projection.
:param view | int
"""
rotPhantom = self.phantom.rotate(self._start - view*self._angleInc)
self.__projections.project(view, rotPhantom)
def ready(self):
"""
Convenience method for checking prerequisites for projecting.
:return isReady | bool
"""
if self.phantom is None or self.projections is None:
return False
if self.__nrBins != self.phantom.size:
pass #TODO resize phantom
return True
def initProjections(self):
""" Initialize the projections object. """
self.__projections = Projections(self._views, self.__nrBins)
def test_projection_Gaussian_N(self):
proj = Projections(projection_type='gaussian', sc=sc, c=1e2, k=3)
N = proj.execute(self.matrix_Ab, 'N')
self.assertEqual(len(N), 3)
self.assertEqual(N[0].shape, (self.matrix_Ab.n, self.matrix_Ab.n))
def test_projection_SRDHT_x(self):
proj = Projections(projection_type='srdht', sc=sc, c=1e2)
sol = proj.execute(self.matrix_Ab, 'x')
self.assertEqual(len(sol[0]), self.matrix_Ab.n)
def test_projection_Rademacher_x(self):
proj = Projections(projection_type='rademacher', sc=sc, c=1e2)
sol = proj.execute(self.matrix_Ab, 'x')
self.assertEqual(len(sol[0]), self.matrix_Ab.n)
def test_projection_Rademacher_x(self):
proj = Projections(projection_type='rademacher',sc=sc,c=1e2)
sol = proj.execute(self.matrix_Ab, 'x')
self.assertEqual(len(sol[0]), self.matrix_Ab.n)
__author__ = 'ap'
import mysql.connector
from shared.dfs_constants import DFSConstants
from projections import Projections
from models.defense_vs_position_manager import DefenseVsPositionManager
cnx = mysql.connector.connect(user='******', password='******', host='localhost', database='basketball_reference')
dvp_manager = DefenseVsPositionManager(cnx=cnx)
projections = Projections(cnx=cnx)
teams = []
cursor = cnx.cursor()
try:
cursor.execute("select distinct team from game_totals_basic where season = 2013")
for result in cursor:
teams.append(result[0])
for position in ["PG", "SG", "SF", "PF", "C"]:
ranks = []
for team in teams:
dvp = dvp_manager.calculate_defense_vs_position(DFSConstants.FANTASY_POINTS, position, team, 2013, DFSConstants.FAN_DUEL)
ranks.append((dvp, team))
# rank = projections.calculate_defense_vs_position_ranking(DFSConstants.FANTASY_POINTS, position, team, 2013, DFSConstants.FAN_DUEL)
# Sort the results in ascending order (lowest value at element 0).
ranks.sort()
def test_projection_Gaussian_N(self):
proj = Projections(projection_type='gaussian',sc=sc,c=1e2,k=3)
N = proj.execute(self.matrix_Ab, 'N')
self.assertEqual(len(N), 3)
self.assertEqual(N[0].shape, (self.matrix_Ab.n,self.matrix_Ab.n))
def test_get_date_time(self):
db = "cinema.db"
projections = Projections(db)
result = projections._get_movie_date_time(1)
self.assertEqual(result, ("2014-04-01", "19:10"))
