def split_domain(domain, pos):
""" Splits a domain into two subdomains. """
from domain import Domain
section1 = Domain(name=domain.name + "[:{0}]".format(pos),
sequence=domain.sequence[:pos])
section2 = Domain(name=domain.name + "[{0}:]".format(pos + 1),
sequence=domain.sequence[pos:])
domain.subdomains = [section1, section2]
def domains(self):
if not self._domains:
self._domains = [
Domain(triple, self.label) for triple in self.triples
]
elif len(self._domains) < len(self.triples):
# the `geometry` method has computed the first domain already
self._domains.extend(
Domain(triple, self.label) for triple in self.triples[1:])
return self._domains
def main():
"""
Main function
"""
domain1: Domain = Domain(43690, 'D1', NUM_MAC_ADDRESSES)
domain2: Domain = Domain(48059, 'D2', NUM_MAC_ADDRESSES)
domain3: Domain = Domain(52428, 'D3', NUM_MAC_ADDRESSES)
for domain in [domain1, domain2, domain3]:
print(domain)
def find_subdomains(self, domain_name: str) -> []:
d1 = Domain('iit.' + domain_name)
d1.add_ip_address('1.1.1.1')
d2 = Domain('math.' + domain_name)
d2.add_ip_address('2.2.2.2')
d3 = Domain('phy.' + domain_name)
d3.add_ip_address('3.3.3.3')
return [d1, d2, d3]
def find_subdomains(self, domain_name: str) -> []:
d1 = Domain('iit.' + domain_name)
d1.add_ip_address('1.1.1.1')
d2 = Domain('math.' + domain_name)
d2.add_ip_address('4.4.4.4')
d3 = Domain('phy.' + domain_name)
d3.add_ip_address('5.5.5.5')
d4 = Domain('lang.' + domain_name)
d4.add_ip_address('5.5.5.5')
return [d1, d2, d3, d4]
def test_contructor_num_mac(self):
"""
Test if contructed with the right number of mac addresses
"""
for num_mac_addresses in range(3):
domain = Domain(1, 'test', num_mac_addresses)
self.assertEqual(len(domain.mac_addresses), num_mac_addresses)
def get_domains(self, search=""):
"""Get a list of your :class:`domains <tracker_client.domain.Domain>`.
Note that the optional search term is supplied as part of the GraphQL query variables and
affects the API response received, rather than filtering results client-side.
:param str search: Search term to filter results with. For example, supplying
the string "abc" would return only Domains containing "abc" in their domain_name.
:return: A list of your domains.
:rtype: list[Domain]
:raises ValueError: if your domains can't be retrieved.
"""
params = {"after": "", "search": search}
has_next = True
domain_list = []
# The maximum number of domains that can be requested at once is 100
# This loop gets 100 domains, checks if there are more, and if there are
# it gets another 100 starting after the last domain it got
while has_next:
result = self.execute_query(queries.GET_ALL_DOMAINS, params)
if "error" in result:
print("Server error: ", result)
raise ValueError("Unable to get your domains.")
for edge in result["findMyDomains"]["edges"]:
domain_list.append(Domain(self, **edge["node"]))
has_next = result["findMyDomains"]["pageInfo"]["hasNextPage"]
params["after"] = result["findMyDomains"]["pageInfo"]["endCursor"]
return domain_list
def __init__(self, *args, **kargs):
"""
Initializes a new Strand object. The following keyword arguments are
accepted: name, domains OR sequence.
If direct sequence constraints are specified, a new domain is defined
with these constraints, and is assigned as the domain list for this
Strand.
"""
# Assign id
self.id = Strand.id_counter
Strand.id_counter += 1
# Assign DNA object type
self._object_type = 'strand'
# Assign name
if 'name' in kargs: self.name = kargs['name']
else: self.name = 'strand_{0}'.format(self.id)
# If sequence constraints were specified, create a dummy domain with
# these constraints. Otherwise, assign the given list of domains.
if 'domains' in kargs and 'sequence' not in kargs:
self._domains = kargs['domains']
elif 'sequence' in kargs and 'domains' not in kargs:
d = Domain(name=self.name + "_domain", sequence=kargs['sequence'])
self._domains = [d]
else:
raise ValueError("Must specify strand constraints or domain list.")
# Assign length
self._length = sum([d.length for d in self._domains])
def load_the_domain(self, domain_params):
if domain_params.get('use_available_domain', None):
domain = Domain(domain_params['domain_shape'],
domain_params['domain_type'],
domain_params["domain_number"])
domain.generate_domain_name()
stat = domain.load_domain(self.output_folder, domain_params)
new_agent_loc = domain_params['new_agent_loc']
if stat:
print("Using available domain ...")
return domain
else:
print("Domain is not available")
print("Creating a new random domain ... ")
domain = create_random_domain(domain_params['domain_shape'],
domain_params['domain_type'],
domain_params['num_wall'],
domain_params['num_storage'],
domain_params['num_gold'],
domain_params["domain_number"])
# self.save_domain()
# self.domain.plot_domain(True, self.output_folder)
# self.new_agent_loc = self.domain_params['new_agent_loc']
return domain
def test_public_score():
# df_2018 = pd.read_csv('./data/2018data_final/2018.csv')
# df_public = pd.read_csv('./data/ground_truth.csv')
# df_public = pd.read_csv('./data/2020data_final/2020.csv')
# df_public = pd.read_csv('./data/2014data_final/2014.csv')
# df_public = pd.read_csv('./data/2018data_final/2018.csv')
df_public = pd.read_csv('./data/2017data_final/2017.csv')
# for attr in ['taxi_id', 'trip_day_of_week', 'trip_hour_of_day']:
for attr in ['trip_day_of_week', 'trip_hour_of_day']:
# df_2018 = df_2018.drop(columns=attr)
df_public = df_public.drop(columns=attr)
# data_2018 = df_2018.to_numpy()
data_public = df_public.to_numpy(dtype=int)
for attr in range(data_public.shape[1]):
print(attr, np.unique(data_public[:, attr]))
# print(df_2018.columns)
# print(df_public.columns)
domain_dict = json.load(open('./preprocess/domain.json', 'r'))
domain_dict = {
i: domain_dict[df_public.columns[i]]
for i in range(len(df_public.columns))
}
domain = Domain(domain_dict, list(range(len(domain_dict))))
print(domain)
df_public = df_public.assign(epsilon=10.0)
df_public.to_csv('./submission_2017.csv', index=False)
def task_2():
print("Zadatak [2]:\n")
domains = (Domain((0, 11)), Domain((-5, 6)))
func = Fuzzy.fuzzy_lambda(domains[1].index(-4), domains[1].index(0),
domains[1].index(4))
sets = (MutableFuzzySet(domains[0]), CalculatedFuzzySet(domains[1], func))
titles = ("S₁", "S₂ (lambda<-4, 0, 4>(D₂))")
for i, value in enumerate((1., 0.8, 0.6, 0.4, 0.2)):
sets[0].set(i, value)
for t, s in zip(titles, sets):
print("{}:\n{}\n".format(t, s))
print("\n")
def NIST3_read_data(data_path, domain_path):
print('reading data')
df = pd.read_csv(data_path)
df.drop(columns=['trip_day_of_week', 'trip_hour_of_day'], inplace=True)
by_shift = pd.pivot_table(
df.assign(n=1),
values="n",
index="taxi_id",
columns="shift",
aggfunc="count",
fill_value=0,
)
by_pickup = pd.pivot_table(
df.assign(n=1),
values="n",
index="taxi_id",
columns="pickup_community_area",
aggfunc="count",
fill_value=0,
)
taxi_df = by_shift.join(by_pickup, rsuffix="p")
# print(taxi_df.columns)
# print(taxi_df.index)
headings = list(df.columns)
domain_dict = json.load(open(domain_path))
domain_dict = {i: domain_dict[df.columns[i]] for i in range(len(headings))}
domain = Domain(domain_dict, list(range(len(domain_dict))))
# print(df.iloc[0:30].to_numpy()[:, [0, 1, 2, 3, 4, -1]])
return df, domain, headings, taxi_df
def plot_miles(df):
columns = list(df.columns)
data = df.to_numpy()
data = data[:, -1].reshape((-1, 1))
# data[data==0] = 1
data[data > 400] = 400
# data = (np.log10(data) * 10).astype(int)
temp = int(max(data))
print('max mile', temp)
temp_dict = {0: temp + 1}
domain = Domain(temp_dict, [
0,
])
hist = tools.get_marginal(data, domain, (0, ))
hist[hist == 0] = 1
hist = np.log10(hist)
ptools.plot_list(hist,
'./evaluate/trip_miles.pdf',
size=(20.0, 2.5),
zero_line=True)
def test_not_consistent_if_assignment_violates_constraint(self):
# Arrange
variables = [
Variable('1', Domain([1, 2, 3])),
Variable('2', Domain([1, 2]))
]
constraints = [EqualConstraint(variables[0], 2)]
csp = ConstraintSatisfactionProblem(variables, constraints)
assignment = Assignment()
assignment.set(variables[0].name, 3)
# Act
consistent = csp.consistent(assignment)
# Assert
self.assertFalse(consistent)
def build_trajectory(size, from_action_space=False, action_space=None):
"""
Build a trajctory of four-tuples using ranfom action
"""
T= []
d = Domain()
x = d.initial_state()
while len(T) < size:
if not from_action_space: # continuous action in (-1,1)
u = d.random_action()
else: # choose an action from a custom discrete action space
u = np.random.choice(action_space, size=1)
new_x, r = d.f(u)
# add the four-tuple to the trajectory
T.append([x, u, r, new_x, d.is_final_state()])
if d.is_final_state():
x = d.initial_state()
else:
x = new_x
# shuffle the trajectory
np.random.shuffle(T)
return T
def main(num_lights):
if num_lights > 10:
print(f"Warning: there are {num_lights*2**num_lights} possible "
f"actions to switch on {num_lights} ligths. This will take a "
f"while...")
actions = [Switch(num, "ON") for num in range(1, num_lights + 1)]
actions += [Switch(num, "OFF") for num in range(1, num_lights + 1)]
lights = Domain(actions)
print("\nExample on how to switch {} lights on:\n".format(num_lights))
status = {
"LIGHT_{}".format(num): "OFF"
for num in range(1, num_lights + 1)
}
goal = {"LIGHT_{}".format(num): "ON" for num in range(1, num_lights + 1)}
lights.solve(status, goal)
if num_lights <= 10:
print("\nOnce all lights are on, plot domain graph and solution")
labels = {node: node_to_label(node) for node in lights.nodes}
if num_lights <= 5:
lights.plot(labels=labels, font_size=9)
else:
lights.plot_bokeh(labels=labels, node_size=10)
print("\nBye")
def test_solver_success_many_variables_many_constraints(self):
# Arrange
variables = []
domain = set([1, 2, 3, 4, 5])
for i in range(5):
variable = Variable(str(i), Domain(list(domain)))
variables.append(variable)
constraints = [
EqualConstraint(variables[2], 3),
AllDiffConstraint(variables)
]
csp = ConstraintSatisfactionProblem(variables, constraints)
solver = Solver()
# Act
result = solver.solve(csp)
# Assert
self.assertTrue(result.success)
assignment = result.assignment
self.assertIsNotNone(assignment)
self.assertEqual(3, assignment.get(variables[2].name))
encountered_values = set()
for variable in variables:
value = assignment.get(variable.name)
self.assertTrue(value in domain)
self.assertFalse(value in encountered_values)
encountered_values.add(value)
def __init__(self, parent=None):
super().__init__(parent)
self.setAttribute(Qt.WA_QuitOnClose)
self.setAttribute(Qt.WA_DeleteOnClose)
# create instance variables
self._ui = uic.loadUi('mainwindow.ui', self)
# create models
self._domain = Domain(parent=self)
self._vcoCharWidget = VCOCharWidget(parent=self)
self._ui.tabWidgetMain.addTab(self._vcoCharWidget,
'VCO characteristics')
self._measureModel = MeasureModel(parent=self, domain=self._domain)
self._markerModel = MarkerModel(parent=self)
self._plotWidget = PhasePlotWidget(parent=self, domain=self._domain)
self._ui.layoutPlot = QVBoxLayout()
self._ui.layoutPlot.addWidget(self._ui.widgetStats)
self._ui.layoutPlot.addWidget(self._plotWidget)
self._ui.tabPlot.setLayout(self._ui.layoutPlot)
# UI hack
self._show_freq = False
self._show_amp = False
self._show_curr = False
self._init()
def _domainListCheck(self):
newList = self._getMessagesForDomainListing('add')
adds, removes = splitDictLists(newList, self._domainListMessages,
RH_Message().keys())
# Removals
ids = [r['rhid'] for r in removes]
indices = []
if (0 < len(ids)):
for i, d in enumerate(self._domains):
if (d.getID in ids):
d.cleanUp()
indices.append(i)
self._domains = [
d for i, d in enumerate(self._domains) if i not in indices
]
# Additions
for a in adds:
self._domains.append(
Domain(
redhawk.attach(
a['rhname']), # Return redhawk domain instance
'', # No parent ID
self.outbox)) # Using the global outbox
self._domainListMessages = newList
self.domainTask = gevent.spawn_later(self._domainTaskWaitSec,
self._domainListCheck)
def test_consistent_for_partial_assignment(self):
# Arrange
variables = [
Variable('1', Domain([1, 2, 3])),
Variable('2', Domain([1, 2]))
]
constraints = [EqualConstraint(variables[0], 2)]
csp = ConstraintSatisfactionProblem(variables, constraints)
assignment = Assignment()
assignment.set(variables[0].name, 2)
# Act
consistent = csp.consistent(assignment)
# Assert
self.assertTrue(consistent)
def get_parent_domain(self, domain_tag):
domain = Domain(self.auth, domain_tag)
domain.cache_list("apps/{0}/domains".format(os.environ['NEST_APP_ID']),
None, 'tag')
if not domain.load():
print "the domain does not exist"
return None
return domain
def test():
for length in range(3, 50):
logging.info("Started length %d" % length)
for i in range(1):
logging.info("Run #%d" % i)
domain = Domain(length)
_, execution_time = solve(domain)
save_perfomance(length, execution_time)
def index(self, **dom):
'''
Returns indexes given domain
'''
dd = self.domain
dd.update(dom)
return Domain(**dd)(self.grid, self.time)
def test_select_unassigned_variable_returns_valid_variable(self):
# Arrange
variables = [
Variable('1', Domain([1, 2, 3])),
Variable('2', Domain([1, 2]))
]
constraints = [EqualConstraint(variables[0], 2)]
csp = ConstraintSatisfactionProblem(variables, constraints)
assignment = Assignment()
assignment.set(variables[0].name, 2)
# Act
variable = csp.select_unassigned_variable(assignment)
# Assert
self.assertIsNotNone(variable)
self.assertEqual(variables[1].name, variable.name)
def get_taxi_trip_data(data_df, domain):
trip_data = data_df.to_numpy()
trip_dom_dict = {}
for i in range(1, len(domain.dict)):
trip_dom_dict[i - 1] = domain.dict[i]
trip_domain = Domain(trip_dom_dict, list(range(len(trip_dom_dict))))
return trip_data[:, 1:], trip_domain, trip_data[:, 0]
def test_violated_if_at_least_one_variable_not_different(self):
# Arrange
assignment = Assignment()
variables = []
for i in range(8):
variable = Variable(str(i), Domain(list(range(1, 10))))
variables.append(variable)
assignment.set(variable.name, i + 1)
non_unique_variable = Variable('8', Domain(list(range(1, 10))))
variables.append(non_unique_variable)
assignment.set(non_unique_variable.name, 1)
constraint = AllDiffConstraint(variables)
# Act
result = constraint.is_violated(assignment)
# Assert
self.assertTrue(result)
def p_domain(p):
'''domain : LPAREN DEFINE_KEY domain_def require_def types_def constants_def predicates_def action_def_lst RPAREN
| LPAREN DEFINE_KEY domain_def require_def types_def predicates_def action_def_lst RPAREN
| LPAREN DEFINE_KEY domain_def require_def constants_def predicates_def action_def_lst RPAREN
| LPAREN DEFINE_KEY domain_def require_def predicates_def action_def_lst RPAREN'''
if len(p) == 10: # both types and constants are given
p[0] = Domain(p[3], p[4], p[5][1], p[6][1], p[7],
p[8]) # both :types and :constants
elif len(p) == 9:
if p[5][0] == "types":
p[0] = Domain(p[3], p[4], p[5][1], {}, p[6],
p[7]) # :types but no constants
elif p[5][0] == "constants":
p[0] = Domain(p[3], p[4], {}, p[5][1], p[6],
p[7]) # no :types, but :constants
elif len(p) == 8:
p[0] = Domain(p[3], p[4], {}, {}, p[5],
p[6]) # no :constants or :types
def compute_child_label_and_domain(
self, child_position, node_label, node_domain,
mid_point): # Compute subdivision and labels of four children
if child_position == 0: # "ne":
return 4 * node_label + 1, Domain(mid_point,
node_domain.get_max_point())
elif child_position == 1: # "nw":
min = Point(node_domain.get_min_point().get_x(), mid_point.get_y())
max = Point(mid_point.get_x(), node_domain.get_max_point().get_y())
return 4 * node_label + 2, Domain(min, max)
elif child_position == 2: # "sw":
return 4 * node_label + 3, Domain(node_domain.get_min_point(),
mid_point)
elif child_position == 3: # "se":
min = Point(mid_point.get_x(), node_domain.get_min_point().get_y())
max = Point(node_domain.get_max_point().get_x(), mid_point.get_y())
return 4 * node_label + 4, Domain(min, max)
else:
return None, None # #
def __getitem__(self, key):
kwargs = {}
if 'comment' in self._domains[key]:
kwargs['comment'] = self._domains[key]['comment']
else:
kwargs['comment'] = None
return Domain(self.conn, self._domains[key]['name'],
self._domains[key]['id'],
self._domains[key]['accountId'], **kwargs)
def __init__(self, model_type, trajectory, N, nb_games):
# parameters of the models
self.trees_n_estimators = 50
self.model_type = model_type
self.trajectory = trajectory
self.nb_games = nb_games
self.domain = Domain()
self.model = self.Q_iter(N)
