{row[:2]
for row in dat.supply.itertuples(index=False)}
}
def _demand_pairs(dat):
return {
"demand_pairs":
{row[:2]
for row in dat.demand.itertuples(index=False)}
}
input_schema.add_data_row_predicate(
"demand",
predicate_name="Check Demand Against Supply",
predicate=lambda row, supply_pairs:
(row["Commodity"], row["Node"]) not in supply_pairs,
predicate_kwargs_maker=_supply_pairs)
input_schema.add_data_row_predicate(
"supply",
predicate_name="Check Supply Against Demand",
predicate=lambda row, demand_pairs:
(row["Commodity"], row["Node"]) not in demand_pairs,
predicate_kwargs_maker=_demand_pairs)
# ---------------------------------------------------------------------------------
# ------------------------ define the output schema -------------------------------
solution_schema = PanDatFactory(flow=[["Commodity", "Source", "Destination"],
["Quantity"]],
parameters=[["Parameter"], ["Value"]])
# ---------------------------------------------------------------------------------
default_parameters = {"One Way Price": 2.25, "Amount Leftover Constraint": "Upper Bound"}
def _good_parameter_key_value(key, value):
if key == "One Way Price":
try:
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", "Parameter", number_allowed=False,
strings_allowed=default_parameters)
input_schema.add_data_row_predicate("parameters", predicate_name="Good Parameter Value",
predicate=lambda row : _good_parameter_key_value(row["Parameter"], row["Value"]))
# ---------------------------------------------------------------------------------
# ------------------------ define the output schema -------------------------------
solution_schema = PanDatFactory(
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 --------------------------------
def solve(dat):
"""
core solving routine
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"])
input_schema.add_parameter("Starter Weight",
default_value=1.2,
min=0,
max=float("inf"),
inclusive_min=False,
inclusive_max=False)
input_schema.add_parameter("Reserve Weight",
default_value=0.9,
min=0,
max=float("inf"),
from ticdat import PanDatFactory
input_schema = PanDatFactory(cities=[["Name"],["Demand"]],
distances=[["Source", "Destination"], ["Distance"]],
parameters=[["Parameter"], ["Value"]])
input_schema.add_parameter("Number of Centroids", default_value=4, inclusive_min=False, inclusive_max=False, min=0,
max=float("inf"), must_be_int=True)
input_schema.set_data_type("cities", "Demand", min=0, 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": {tuple(row[:2]): row[2] for row in dat.distances.itertuples(index=False)}}
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)
solution_schema = PanDatFactory(openings=[['City'],[]], assignments=[['City', 'Assigned To'],[]],
parameters=[["Parameter"], ["Value"]])
def solve(dat):
assert input_schema.good_pan_dat_object(dat), "bad dat check"
assert not input_schema.find_duplicates(dat), "duplicate row check"
assert not input_schema.find_foreign_key_failures(dat), "foreign key check"
assert not input_schema.find_data_type_failures(dat), "data type value check"
assert not input_schema.find_data_row_failures(dat), "data row check"
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 = PanDatFactory(parameters=[["Parameter"], ["Value"]],
buy_food=[["Food"], ["Quantity"]],
consume_nutrition=[["Category"], ["Quantity"]])
# ---------------------------------------------------------------------------------