inclusive_min=True, inclusive_max=False)
input_schema.set_data_type("gas", "Min Octane Rating", min=0, max=float("inf"),
inclusive_min=True, inclusive_max=False)
input_schema.set_data_type("gas", "Max Lead Contents", min=0, max=float("inf"),
inclusive_min=True, inclusive_max=True)
input_schema.set_data_type("oil", "Supply", min=0, max=float("inf"),
inclusive_min=True, inclusive_max=True)
input_schema.set_data_type("oil", "Purchase Price", min=0, max=float("inf"),
inclusive_min=True, inclusive_max=False)
input_schema.set_data_type("oil", "Octane Rating", min=0, max=float("inf"),
inclusive_min=True, inclusive_max=False)
input_schema.set_data_type("oil", "Lead Contents", min=0, max=float("inf"),
inclusive_min=True, inclusive_max=False)
# We tolerate float("inf") as the Maximum Production but not the Production Cost
input_schema.add_data_row_predicate("parameters",
lambda row : not (row["Parameter"] == "Production Cost" and
row["Value"] == float("inf")))
input_schema.opl_prepend = "inp_" # avoid table name collisions
# ---------------------------------------------------------------------------------
# ------------------------ define the output schema -------------------------------
solution_schema = TicDatFactory(
parameters = [["Parameter"],["Value"]],
advertising = [["Gas"],["Dollars Spent"]],
blending = [["Oil","Gas"],["Quantity"]])
solution_schema.opl_prepend = "sln_" # avoid table name collisions
# ---------------------------------------------------------------------------------
input_schema.set_data_type("foods",
"Cost",
min=0,
max=float("inf"),
inclusive_min=True,
inclusive_max=False)
input_schema.set_data_type("nutrition_quantities",
"Quantity",
min=0,
max=float("inf"),
inclusive_min=True,
inclusive_max=False)
# We also want to insure that Max Nutrition doesn't fall below Min Nutrition
input_schema.add_data_row_predicate(
"categories",
predicate_name="Min Max Check",
predicate=lambda row: row["Max Nutrition"] >= row["Min Nutrition"])
# The default-default of zero makes sense everywhere except for Max Nutrition
input_schema.set_default_value("categories", "Max Nutrition", float("inf"))
# ---------------------------------------------------------------------------------
# ------------------------ define the output schema -------------------------------
# There are three solution tables, with 3 primary key fields and 3 data fields.
solution_schema = TicDatFactory(parameters=[["Parameter"], ["Value"]],
buy_food=[["Food"], ["Quantity"]],
consume_nutrition=[["Category"], ["Quantity"]])
for (tbl, fld), tip in solution_schema_tooltips.items():
solution_schema.set_tooltip(tbl, fld, tip)
# ---------------------------------------------------------------------------------
inclusive_min=True, inclusive_max=False)
# input_schema.add_foreign_key("player_ratings", "roster", ["Name", "Name"])
# input_schema.add_foreign_key("player_ratings", "positions", ["Position Group", "Position Group"])
input_schema.set_data_type("player_ratings", "Rating", min=0, max=float("inf"),
inclusive_min=True, inclusive_max=False)
# input_schema.add_foreign_key("position_constraints", "positions", ["Position Group", "Position Group"])
# input_schema.add_foreign_key("position_constraints", "innings", ["Inning Group", "Inning Group"])
# input_schema.add_foreign_key("position_constraints", "roster", ["Grade", "Grade"])
input_schema.set_data_type("position_constraints", "Min Players", min=0, max=float("inf"),
inclusive_min=True, inclusive_max=True)
input_schema.set_data_type("position_constraints", "Max Players", min=0, max=float("inf"),
inclusive_min=False, inclusive_max=True)
input_schema.add_data_row_predicate(
"position_constraints", predicate_name="Position Min Max Check",
predicate=lambda row : row["Max Players"] >= row["Min Players"])
solution_schema = TicDatFactory(
lineup = [["Inning", "Position"],["Name"]],
parameters = [["Key"],["Value"]])
def solve(dat):
assert input_schema.good_tic_dat_object(dat)
assert not input_schema.find_foreign_key_failures(dat)
assert not input_schema.find_data_type_failures(dat)
assert not input_schema.find_data_row_failures(dat)
dat = input_schema.copy_to_ampl(dat, field_renamings={
("roster", "Grade"):"grade",
("positions", "Position Importance"): "position_importance",
max=float("inf"),
inclusive_min=True,
inclusive_max=False)
input_schema.set_data_type("distances",
"Distance",
min=0,
max=float("inf"),
inclusive_min=True,
inclusive_max=False)
input_schema.add_foreign_key("distances", "cities", ['Source', 'Name'])
input_schema.add_foreign_key("distances", "cities", ['Destination', 'Name'])
# The distance matrix is bi-directionally safe. I.e. if the same source/dest and dest/source exist then the
# distances must match. If only one is present, it can fall back to the other in the code.
def _distance_matrix(dat):
return {
"distance_matrix":
{k: v["Distance"]
for k, v in dat.distances.items()}
}
input_schema.add_data_row_predicate(
"distances",
predicate_name="Check Bi-Directionally Safe",
predicate=lambda row, distance_matrix: (
(row["Destination"], row["Source"]) not in distance_matrix) or
(row["Distance"] == distance_matrix[row["Destination"], row["Source"]]),
predicate_kwargs_maker=_distance_matrix)
must_be_int=True)
input_schema.set_data_type(
"roster_requirements",
"Flex Status",
number_allowed=False,
strings_allowed=["Flex Eligible", "Flex Ineligible"])
input_schema.set_data_type("my_draft_positions",
"Draft Position",
min=0,
max=float("inf"),
inclusive_min=False,
inclusive_max=False,
must_be_int=True)
input_schema.add_data_row_predicate(
"roster_requirements",
predicate=lambda row: row["Max Num Starters"] >= row["Min Num Starters"])
input_schema.add_data_row_predicate(
"roster_requirements",
predicate=lambda row: row["Max Num Reserve"] >= row["Min Num Reserve"])
# ---------------------------------------------------------------------------------
# ------------------------ define the output schema -------------------------------
solution_schema = TicDatFactory(parameters=[["Parameter"], ["Value"]],
my_draft=[['Player Name'],
[
'Draft Position', 'Position',
'Planned Or Actual',
'Starter Or Reserve'
]])
return 0 < value < float("inf")
except:
return False
if key == "Amount Leftover Constraint":
return value in ["Equality", "Upper Bound"]
assert all(
_good_parameter_key_value(k, v) for k, v in default_parameters.items())
input_schema.set_data_type("parameters",
"Key",
number_allowed=False,
strings_allowed=default_parameters)
input_schema.add_data_row_predicate(
"parameters",
predicate_name="Good Parameter Value for Key",
predicate=lambda row: _good_parameter_key_value(row["Key"], row["Value"]))
# ---------------------------------------------------------------------------------
# ------------------------ define the output schema -------------------------------
solution_schema = TicDatFactory(
load_amount_details=[[
"Number One Way Trips", "Amount Leftover", "Load Amount"
], ["Number Of Visits"]],
load_amount_summary=[["Number One Way Trips", "Amount Leftover"],
["Number Of Visits"]])
# ---------------------------------------------------------------------------------
# ------------------------ create a solve function --------------------------------
input_schema.set_data_type("roster",
"Min Innings Played",
min=0,
max=9,
inclusive_min=True,
inclusive_max=True)
input_schema.set_data_type("roster",
"Max Innings Played",
min=0,
max=9,
inclusive_min=False,
inclusive_max=True)
input_schema.add_data_row_predicate(
"roster",
predicate_name="Roster Min Max Check",
predicate=lambda row: row["Max Innings Played"] >= row["Min Innings Played"
])
input_schema.add_foreign_key("roster", "innings", ["Arrival Inning", "Inning"])
input_schema.add_foreign_key("roster", "innings",
["Departure Inning", "Inning"])
input_schema.set_data_type("positions",
"Position Importance",
min=0,
max=float("inf"),
inclusive_min=True,
inclusive_max=False)
input_schema.set_data_type("positions",
"Consecutive Innings Only",
strings_allowed=['True', 'False'],
