def test_parameters(self):
schema = test_schema + "_parameters"
tdf = TicDatFactory(parameters=[["Key"], ["Value"]])
tdf.add_parameter("Something", 100)
tdf.add_parameter("Different",
'boo',
strings_allowed='*',
number_allowed=False)
dat = tdf.TicDat(
parameters=[["Something", float("inf")], ["Different", "inf"]])
tdf.pgsql.write_schema(self.engine, schema)
tdf.pgsql.write_data(dat, self.engine, schema)
dat_ = tdf.pgsql.create_tic_dat(self.engine, schema)
self.assertTrue(tdf._same_data(dat, dat_))
from ticdat import TicDatFactory
input_schema = TicDatFactory(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.add_parameter("High Service Distance",
default_value=0,
inclusive_min=True,
inclusive_max=True,
min=0,
max=float("inf"),
must_be_int=False)
input_schema.add_parameter("Maximum Average Service Distance",
default_value=float("inf"),
inclusive_min=True,
inclusive_max=True,
min=0,
max=float("inf"),
must_be_int=False)
input_schema.add_parameter("Minimum Percent High Service Demand",
default_value=0,
inclusive_min=True,
inclusive_max=True,
This module describes the constraints placed on data flowing into the diet engine
"""
from ticdat import TicDatFactory
# define table and column names the engine can expect as inputs
input_schema = TicDatFactory(categories=[["Name"],
["Min Nutrition", "Max Nutrition"]],
foods=[["Name"], ["Cost"]],
nutrition_quantities=[["Food", "Category"],
["Quantity"]],
parameters=[['Name'], ['Value']])
# add the following parameter to the parameters table
input_schema.add_parameter("How To Make Solution",
"Use Gurobi",
number_allowed=False,
strings_allowed=["Use Gurobi", "Use Cache"])
# Define the foreign key relationships
input_schema.add_foreign_key("nutrition_quantities", "foods", ["Food", "Name"])
input_schema.add_foreign_key("nutrition_quantities", "categories",
["Category", "Name"])
# Define the data types
input_schema.set_data_type("categories",
"Min Nutrition",
min=0,
max=float("inf"),
inclusive_min=True,
inclusive_max=False)
input_schema.set_data_type("categories",
from ticdat import TicDatFactory
input_schema = TicDatFactory(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'])
solution_schema = TicDatFactory(openings=[['City'], []],
assignments=[['City', 'Assigned To'], []],
parameters=[["Parameter"], ["Value"]])
input_schema.add_foreign_key("distance", "sites", ['Destination', 'Name'])
# center_status is a flag field which can take one of two string values.
input_schema.set_data_type(
"sites",
"Center Status",
number_allowed=False,
strings_allowed=["Can Be Center", "Pure Demand Point"])
# The default type of non infinite, non negative works for distance and demand
input_schema.set_data_type("sites", "Demand")
input_schema.set_data_type("distance", "Distance")
input_schema.add_parameter("Number of Centroids",
default_value=1,
inclusive_min=False,
inclusive_max=False,
min=0,
max=float("inf"),
must_be_int=True)
input_schema.add_parameter("MIP Gap",
default_value=0.001,
inclusive_min=False,
inclusive_max=False,
min=0,
max=float("inf"),
must_be_int=False)
input_schema.add_parameter("Formulation",
"Strong",
number_allowed=False,
strings_allowed=["Weak", "Strong"])
# ---------------------------------------------------------------------------------
def testDateTime(self):
schema = test_schema + "_datetime"
tdf = TicDatFactory(table_with_stuffs=[["field one"], ["field two"]],
parameters=[["a"], ["b"]])
tdf.add_parameter("p1", "Dec 15 1970", datetime=True)
tdf.add_parameter("p2", None, datetime=True, nullable=True)
tdf.set_data_type("table_with_stuffs", "field one", datetime=True)
tdf.set_data_type("table_with_stuffs",
"field two",
datetime=True,
nullable=True)
dat = tdf.TicDat(table_with_stuffs=[[
dateutil.parser.parse("July 11 1972"), None
], [datetime.datetime.now(),
dateutil.parser.parse("Sept 11 2011")]],
parameters=[["p1", "7/11/1911"], ["p2", None]])
self.assertFalse(
tdf.find_data_type_failures(dat)
or tdf.find_data_row_failures(dat))
tdf.pgsql.write_schema(self.engine, schema)
tdf.pgsql.write_data(dat, self.engine, schema)
dat_1 = tdf.pgsql.create_tic_dat(self.engine, schema)
self.assertFalse(
tdf._same_data(dat, dat_1, nans_are_same_for_data_rows=True))
self.assertTrue(
all(
len(getattr(dat, t)) == len(getattr(dat_1, t))
for t in tdf.all_tables))
self.assertFalse(
tdf.find_data_type_failures(dat_1)
or tdf.find_data_row_failures(dat_1))
self.assertTrue(
isinstance(dat_1.parameters["p1"]["b"], datetime.datetime))
self.assertTrue(
all(
isinstance(_, datetime.datetime)
for _ in dat_1.table_with_stuffs))
self.assertTrue(
len([_ for _ in dat_1.table_with_stuffs if pd.isnull(_)]) == 0)
self.assertTrue(
all(
isinstance(_, datetime.datetime) or pd.isnull(_)
for v in dat_1.table_with_stuffs.values() for _ in v.values()))
self.assertTrue(
len([
_ for v in dat_1.table_with_stuffs.values()
for _ in v.values() if pd.isnull(_)
]) == 1)
pdf = PanDatFactory.create_from_full_schema(
tdf.schema(include_ancillary_info=True))
pan_dat = pdf.pgsql.create_pan_dat(self.engine, schema)
dat_2 = pdf.copy_to_tic_dat(pan_dat)
# pandas can be a real PIA sometimes, hacking around some weird downcasting
for k in list(dat_2.table_with_stuffs):
dat_2.table_with_stuffs[pd.Timestamp(
k)] = dat_2.table_with_stuffs.pop(k)
self.assertTrue(
tdf._same_data(dat_1, dat_2, nans_are_same_for_data_rows=True))
pdf.pgsql.write_data(pan_dat, self.engine, schema)
dat_3 = pdf.copy_to_tic_dat(
pdf.pgsql.create_pan_dat(self.engine, schema))
for k in list(dat_3.table_with_stuffs):
dat_3.table_with_stuffs[pd.Timestamp(
k)] = dat_3.table_with_stuffs.pop(k)
self.assertTrue(
tdf._same_data(dat_1, dat_3, nans_are_same_for_data_rows=True))
input_schema = TicDatFactory (
parameters=[["Parameter"], ["Value"]],
load_amounts=[["Amount"],[]],
number_of_one_way_trips=[["Number"],[]],
amount_leftover=[["Amount"], []])
input_schema.set_data_type("load_amounts", "Amount", min=0, max=float("inf"),
inclusive_min=False, inclusive_max=False)
input_schema.set_data_type("number_of_one_way_trips", "Number", min=0, max=float("inf"),
inclusive_min=False, inclusive_max=False, must_be_int=True)
input_schema.set_data_type("amount_leftover", "Amount", min=0, max=float("inf"),
inclusive_min=True, inclusive_max=False)
input_schema.add_parameter("One Way Price", default_value=2.25, min=0, max=float("inf"), inclusive_min=True,
inclusive_max=False)
input_schema.add_parameter("Amount Leftover Constraint", default_value="Upper Bound", number_allowed=False,
strings_allowed=["Equality", "Upper Bound", "Upper Bound With Leftover Multiple Rule"])
# ---------------------------------------------------------------------------------
# ------------------------ 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 --------------------------------
def solve(dat):
input_schema.add_foreign_key("distance", "sites", ['Destination', 'Name'])
# center_status is a flag field which can take one of two string values.
input_schema.set_data_type(
"sites",
"Center Status",
number_allowed=False,
strings_allowed=["Can Be Center", "Pure Demand Point"])
# The default type of non infinite, non negative works for distance and demand
input_schema.set_data_type("sites", "Demand")
input_schema.set_data_type("distance", "Distance")
input_schema.add_parameter("Number of Centroids",
default_value=1,
inclusive_min=False,
inclusive_max=False,
min=0,
max=float("inf"),
must_be_int=True)
input_schema.add_parameter("MIP Gap",
default_value=0.001,
inclusive_min=False,
inclusive_max=False,
min=0,
max=float("inf"),
must_be_int=False)
# not using a the "strong v weak" parameter, testing will always use the weak formulation
input_schema.add_parameter("Core Model Type",
"cplex",
number_allowed=False,
strings_allowed=["gurobi", "cplex"])
