def get_error_paths(self, initial_state_set,
final_state_set, pi_ref,
ci_ref, pi_cons, ci_cons,
max_paths):
'''
@type pi_cons: constraints.IntervalCons
@type ci_cons: constraints.IntervalCons
'''
MAX_ERROR_PATHS = max_paths
ci_dim = self.num_dims.ci
pi_dim = self.num_dims.pi
# init_set = set()
path_list = []
ci_seq_list = []
pi_seq_list = []
error_paths = self.compute_error_paths(initial_state_set, final_state_set, MAX_ERROR_PATHS)
#bounded_error_paths = U.bounded_iter(error_paths, MAX_ERROR_PATHS)
bounded_error_paths = error_paths
def get_ci_seq(path):
return self.get_seq_of_ci_pi(path)[0]
def get_pi_seq(path):
return self.get_seq_of_ci_pi(path)[1]
def get_empty(_):
return []
get_ci = get_ci_seq if ci_dim != 0 else get_empty
get_pi = get_pi_seq if pi_dim != 0 else get_empty
# if ci_dim == 0:
# for path in bounded_error_paths:
# ci_seq = []
# ci_seq_list.append(ci_seq)
# init_set.add(path[0])
# return (list(init_set), ci_seq_list)
# else:
max_len = -np.inf
min_len = np.inf
unique_paths = set()
for path in bounded_error_paths:
# ci_seq = self.get_seq_of_ci(path)
pi_seq_cells = get_pi(path)
pi_ref.update_from_path(path, pi_seq_cells)
# convert pi_cells to ival constraints
#pi_seq = map(self.plant_abs.get_ival_cons_pi_cell, get_pi(path))
pi_seq = [CM.get_ival_cons_cell(pi_cell, pi_ref.eps) for pi_cell in pi_seq_cells]
if ci_ref is not None:
ci_seq_cells = get_ci(path)
ci_ref.update_from_path(path, ci_seq_cells)
ci_seq = [CM.get_ival_cons_cell(ci_cell, ci_ref.eps) for ci_cell in ci_seq_cells]
else:
ci_seq = get_ci(path)
#print(pi_seq)
#FIXME: Why are uniqe paths found only for the case when dim(ci) != 0?
plant_states_along_path = tuple(state.plant_state for state in path)
if plant_states_along_path not in unique_paths:
unique_paths.add(plant_states_along_path)
if ci_dim != 0:
assert(len(ci_seq) == len(path) - 1)
else:
assert(len(ci_seq) == 0)
if pi_dim != 0:
assert(len(pi_seq) == len(path) - 1)
else:
assert(len(pi_seq) == 0)
# max_len = max(len(ci_seq), max_len)
# min_len = min(len(ci_seq), min_len)
max_len = max(len(path), max_len)
min_len = min(len(path), min_len)
ci_seq_list.append(ci_seq)
pi_seq_list.append(pi_seq)
path_list.append(path)
assert(max_len <= self.N + 1)
# normalize list lens by appending 0
# if max_len != min_len or max_len < self.N:
# # TODO: many a times we find paths, s.t. len(path) > self.N
# # How should those paths be handled?
# # - Should they be ignored, shortened, or what?
# # - or should nothing be done about them?
# for (idx, ci_seq) in enumerate(ci_seq_list):
# # instead of zeros, use random!
# num_of_missing_ci_tail = max(max_len, self.N) - len(ci_seq)
# ci_seq_list[idx] = ci_seq \
# + list(np.random.random((num_of_missing_ci_tail, ci_dim)))
# for (idx, pi_seq) in enumerate(pi_seq_list):
# num_of_missing_pi_tail = max(max_len, self.N) - len(pi_seq)
# pi_seq_list[idx] = pi_seq \
# + list(np.random.random((num_of_missing_pi_tail, pi_dim)))
for (idx, (ci_seq, pi_seq)) in enumerate(zip(ci_seq_list, pi_seq_list)):
missing_ci_len = self.N - len(ci_seq)
missing_pi_len = self.N - len(pi_seq)
# row, column
r, c_ci = missing_ci_len, ci_dim
#FIXME: default random values
if ci_ref is not None:
ci_seq_list[idx] = ci_seq + [ci_cons] * missing_ci_len
else:
ci_seq_list[idx] = ci_seq + list(np.random.uniform(ci_cons.l, ci_cons.h, (r, c_ci)))
#pi_seq_list[idx] = pi_seq + list(np.random.uniform(pi_cons.l, pi_cons.h, (r, c_pi)))
pi_seq_list[idx] = pi_seq + [pi_cons] * missing_pi_len
if __debug__:
print('path states, min_len:{}, max_len:{}'.format(min_len, max_len))
# ##!!##logger.debug('init_list:{}\n'.format(init_list))
# ##!!##logger.debug('ci_seq_list:{}\n'.format(ci_seq_list))
# print('len(init_list)', len(init_list))
# print('len(ci_seq_list)', len(ci_seq_list))
# for ci_seq in ci_seq_list:
# print(ci_seq)
# for pi_seq in pi_seq_list:
# print(pi_seq)
return (path_list, ci_seq_list, pi_seq_list)
