def MoveRight(board):
#Moves blank tile right, if possible
#Convert to a square array
board = flat2square(board)
num_rows = len(board) #one side of the puzzle
num_cols = len(board)
[blank_row,
blank_col] = np.where(board == 0) #Find the location of the blank space
if (blank_col == num_cols -
1): #Blank spot is on the right edge; cannot be moved right
if verbose == True:
print(
"Blank space is at the right edge of the board and cannot be moved right."
)
return #board
else:
verbose("Moving 1 square to the right")
newBoard = np.copy(board)
newBoard[blank_row, blank_col] = board[blank_row, blank_col + 1]
newBoard[blank_row, blank_col + 1] = 0 #board[blank_row,blank_col]
newBoard = square2flat(newBoard)
return newBoard
def simplify(equation):
# si il n'y a pas de "=" c'est pas une equation si il y en a plus d'un c'est pas bon aussi
splitted = re.split("=", equation)
if len(splitted) == 1:
v.ft_missing_equal()
if len(splitted) > 2:
v.too_much_equal()
pattern = re.compile("[\^xX]\s*([+-])\s*(\d+(?:(\.\d+)?))\s*($|[\+\-\=])")
match = re.findall(pattern, equation)
if len(match) != 0:
v.no_sign()
pattern = re.compile("([\^xX])\s*(\d+?(\.(\d+)*?))\s*($|[\+\-\=])")
match = re.findall(pattern, equation)
if len(match) != 0:
v.no_float()
tmp1 = re.sub(r"([,])", r".", equation) # change "," to "."
tmp1 = re.sub(r"([^0-9.+\-*xX^=])", r"",
tmp1) # remove unwanted caracteres and spaces
tmp2 = ""
while tmp1 != tmp2:
tmp2 = tmp1
tmp1 = simplifier(tmp2)
v.verbose("[Verbose]Formated: " + tmp2)
return tmp2
def MoveDown(board):
#Moves blank tile down, if possible
#Convert to a square array
board = flat2square(board)
num_rows = len(board) #one side of the puzzle
num_cols = len(board)
[blank_row,
blank_col] = np.where(board == 0) #Find the location of the blank space
#print(num_rows)
if (blank_row == num_rows -
1): #Blank spot is on the bottom edge; cannot be moved down
verbose(
"Blank space is at the bottom edge of the board and cannot be moved down."
)
return #board
else:
verbose("Moving 1 square down")
newBoard = np.copy(board)
newBoard[blank_row, blank_col] = board[blank_row + 1, blank_col]
newBoard[blank_row + 1, blank_col] = 0
newBoard = square2flat(newBoard)
return newBoard
def BFS(board, attempt, attempt_num, parent, k):
myboard[0] = actions.MoveLeft(board)
myboard[1] = actions.MoveRight(board)
myboard[2] = actions.MoveUp(board)
myboard[3] = actions.MoveDown(board)
for i in range(0, 4):
print(myboard[i])
for i in range(0, 4):
if (square2flat(myboard[i]) in board_tracker
): # board configuration is already saved. Move on
verbose("Board configuration is already saved.")
return
else:
verbose("Adding board to list")
board_tracker[k] = square2flat(myboard[i])
k = k + 1
#print(attempt_num)
attempt[attempt_num] = attempt[parent].copy()
attempt[attempt_num].append(square2flat(myboard[i]))
parent = attempt_num
attempt_num += 1
# print(attempt[parent])
BFS(myboard[i], attempt, attempt_num + i, parent, k)
def delete(judo, input):
"""wrapper for judo class read function.
"""
verbose("{} command initiated".format(input.command), input.verbose)
verbose("judo file: {}".format(input.command_arg), input.verbose)
judo.delete(input.command_arg)
def getImage(self):
try:
image=self.images.get(True,0.1)
self.lastImage=image
return image
except Queue.Empty:
verbose('MJPG image queue is empty!')
return self.lastImage
def td_superoperator(N, E, J, gamma, gammabar, maxtime, dt):
import numpy as np
import scipy.linalg.lapack as lapack
import scipy.linalg as la
from superoperator import get_superoperator
from verbose import verbose
# Generate super density matrix time evolution operator
L = get_superoperator(N, E, J, gamma, gammabar)
# Diagonalize L
Lw = lapack.flapack.zgeev(np.asfortranarray(L, dtype='cfloat'))
w = Lw[0]
v = Lw[2]
#w,v = la.eig(L)
#w = -1j*w
# Make sure v is normalized
# norm = np.zeros((N**2,1))
# for n in range(N**2):
# for m in range(N**2):
# norm[n] = norm[n] + np.abs(v[m,n]*np.conj(v[m,n]))
# v[:,n] = v[:,n]/np.sqrt(norm[n])
# Find weights based on initial condition p(t=0) = |1>
alpha = np.sqrt(np.multiply(v[0, :], np.conj(v[0, :])))
alpha = np.zeros((N**2, 1))
alpha[:, 0] = np.divide(1, v[0, :])
alpha[:, 0] = np.divide(
alpha[:, 0], np.sum(np.multiply(alpha[0, :], np.conj(alpha[0, :]))))
# Check initial condition
Init = np.zeros((N**2, 1), dtype=complex)
for n in range(N**2):
Init[:, 0] = Init[:, 0] + alpha[n] * v[:, n]
# Write info if N<3
verbose(N, L, w, v, alpha, Init)
# Setup super density matrix
p = np.zeros((maxtime, N**2), dtype=complex)
pe = np.zeros((maxtime, N**2)) # Stores expectation value
# Calculate dynamics based on eigenvalues and vectors
for t in range(maxtime):
for m in range(N**2):
fact = alpha[m] * np.exp(w[m] * dt * t)
p[t, :] = p[t, :] + np.transpose(np.multiply(fact, v[:, m]))
for m in range(N**2):
pe[t, m] = np.sqrt(p[t, m].real**2 + p[t, m].imag**2)
# Take trace
pop = np.zeros((maxtime, N))
for n in range(N):
pop[:, n] = pe[:, n * N + n]
return (pop)
def degree_one(polynomes):
print("Polynomial degree: 1")
b = polynomes.get(1, 0)
c = polynomes.get(0, 0)
if c == 0:
v.verbose("[Verbose] bx = 0 => " + tools.ft_ftoa(b) +
"x = 0\n[Verbose] x can only be 0")
print("The solution is:")
print("0")
else:
v.verbose("[Verbose] bx + c = 0 => " + tools.ft_ftoa(b) + "x + " +
tools.ft_ftoa(c) + " = 0\n[Verbose] x = -c / b => x = -" +
tools.ft_ftoa(c) + " / " + tools.ft_ftoa(b))
print("The solution is:")
print(tools.ft_round(-c / b))
def __runClient(self,url):
self.url=url
try:
self.stream=urllib.urlopen(url)
except IOError:
self.startFlag.set()
return
self.imgbytes=''
self.startFlag.set()
while not self.stopFlag.is_set():
image=self.__readImage()
try:
self.images.put(image,True,0.1)
except Queue.Full:
verbose('MJPG image dropped - queue is full!')
def __init__(self):
# Set logging
verbose(self, self.__class__.__name__, loglevel=10, screen=True)
self.vout.debug("Logging enabled.")
self.pagedata = None
self.err = errors(self)
# Set browser session
self.br = requests.Session()
#Set session headers
headers = {}
headers['content-type'] = "application/json"
headers['User-agent'] = (
'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.1)' +
' Gecko/2008071615' + ' Fedora/3.0.1-1.fc9' + ' Firefox/3.0.1')
self.br.headers.update(headers)
def findAllPerms(board, k, attempt):
#4 ways to move
myboard[0] = actions.MoveLeft(board)
myboard[1] = actions.MoveRight(board)
myboard[2] = actions.MoveUp(board)
myboard[3] = actions.MoveDown(board)
for i in range(0, 4):
verbose("Flatboard is: " + flatboard_spaceless(myboard[i]))
if (flatboard_spaceless(myboard[i]) in board_tracker
): # board configuration is already saved. Move on
verbose("Board configuration is already saved.")
#return
elif (flatboard_spaceless(
myboard[i]) == flatboard_spaceless(goal)): #goal found
print("Goal found!")
print(flatboard_spaceless(myboard[i]))
board_tracker[k] = flatboard_spaceless(myboard[i])
k = k + 1
return
else:
verbose("Adding board to list")
board_tracker[k] = flatboard_spaceless(
myboard[i]) # board configuration is not saved yet. Save it
k = k + 1
findAllPerms(myboard[i], k)
def MoveLeft(board):
#Moves blank tile left, if possible
#board=CurrentNode
num_rows = len(board) #one side of the puzzle
num_cols = len(board)
[blank_row,
blank_col] = np.where(board == 0) #Find the location of the blank space
if (blank_col == 0): #Blank spot is on the left edge; cannot be moved left
verbose(
"Blank space is at the left edge of the board and cannot be moved left."
)
return board
else:
verbose("Moving 1 square to the left")
newBoard = np.copy(board)
newBoard[blank_row, blank_col] = board[blank_row, blank_col - 1]
newBoard[blank_row, blank_col - 1] = 0 #board[blank_row,blank_col]
return newBoard
def __init__(self): #{{{
# classtype=model.properties
# for classe in dict.keys(classtype):
# print classe
# self.__dict__[classe] = classtype[str(classe)]
self.mesh = mesh2d()
self.mask = mask()
self.geometry = geometry()
self.constants = constants()
self.smb = SMBforcing()
self.basalforcings = basalforcings()
self.materials = matice()
self.damage = damage()
self.friction = friction()
self.flowequation = flowequation()
self.timestepping = timestepping()
self.initialization = initialization()
self.rifts = rifts()
self.slr = slr()
self.debug = debug()
self.verbose = verbose()
self.settings = settings()
self.toolkits = toolkits()
self.cluster = generic()
self.balancethickness = balancethickness()
self.stressbalance = stressbalance()
self.groundingline = groundingline()
self.hydrology = hydrologyshreve()
self.masstransport = masstransport()
self.thermal = thermal()
self.steadystate = steadystate()
self.transient = transient()
self.levelset = levelset()
self.calving = calving()
self.gia = giaivins()
self.autodiff = autodiff()
self.inversion = inversion()
self.qmu = qmu()
self.amr = amr()
self.results = results()
self.outputdefinition = outputdefinition()
self.radaroverlay = radaroverlay()
self.miscellaneous = miscellaneous()
self.private = private()
def MoveUp(board):
#Moves blank tile up, if possible
#Convert to a square array
board = flat2square(board)
num_rows = len(board) #one side of the puzzle
num_cols = len(board)
[blank_row,
blank_col] = np.where(board == 0) #Find the location of the blank space
if (blank_row == 0): #Blank spot is on the top edge; cannot be moved up
verbose(
"Blank space is at the top edge of the board and cannot be moved up."
)
return #board
else:
verbose("Moving 1 square up")
newBoard = np.copy(board)
newBoard[blank_row, blank_col] = board[blank_row - 1, blank_col]
newBoard[blank_row - 1, blank_col] = 0
newBoard = square2flat(newBoard)
return newBoard
def k_anonymity_top_down(table_group: Group, k: int) -> List[Group]:
if table_group.size() <= k:
return [table_group]
verbose('--- Calculating k-anonymity top-down ---')
groups_to_anonymize = [table_group]
less_than_k_anonymized_groups = []
k_or_more_anonymized_groups = []
min_max_diff_g = table_group.get_min_max_diff()
while len(groups_to_anonymize) > 0:
group_to_anonymize = groups_to_anonymize.pop(0)
group_list = group_partition(group_to_anonymize, k, min_max_diff_g)
both_have_less = True
for group in group_list:
if group.size() >= k:
both_have_less = False
if not both_have_less:
for group in group_list:
if group.size() > k:
groups_to_anonymize.append(group)
elif group.size() == k:
k_or_more_anonymized_groups.append(group)
else:
less_than_k_anonymized_groups.append(group)
else:
k_or_more_anonymized_groups.append(group_to_anonymize)
verbose('--- Postprocessing k-anonymity top-down')
for ag in k_or_more_anonymized_groups:
verbose('k or more:' + str(ag.shape()) + '; company codes:' +
str(ag.ids))
for ag in less_than_k_anonymized_groups:
verbose('less than k:' + str(ag.shape()) + '; company codes:' +
str(ag.ids))
k_anonymity_top_down_postprocessing(less_than_k_anonymized_groups,
k_or_more_anonymized_groups,
min_max_diff_g, k)
return k_or_more_anonymized_groups
def degree_two(polynomes):
print("Polynomial degree: 2")
a = 0
b = 0
c = 0
if 2 in polynomes:
a = polynomes[2]
if 1 in polynomes:
b = polynomes[1]
if 0 in polynomes:
c = polynomes[0]
v.verbose('Discriminant formule: b^2 - 4ac')
v.verbose('Discriminant equation: ' + str(b) + '^2 - 4 * ' + str(a) +
' * ' + str(c))
discriminant = (b * b) - 4 * a * c
v.verbose('Discriminant : ' + str(discriminant))
if discriminant < 0:
print(
'Discriminant is strictly negatif, there is no real solution but two complex :'
)
v.verbose(
'Solution formules : x1 = (-b-i√∆)/(2a) et x2 = (-b+i√∆)/(2a)')
x1 = "(" + str(-b) + " − i" + str(
tools.sqrt(1, discriminant * -1, None, 0)) + ") / " + str(2 * a)
x2 = "(" + str(-b) + " + i" + str(
tools.sqrt(1, discriminant * -1, None, 0)) + ") / " + str(2 * a)
print(x1)
print(x2)
if discriminant == 0:
print('Discriminant is equal to zero, there is one solution :')
v.verbose('Solution formule : x = -b/(2a)')
v.verbose('Solution equation : x = -' + str(b) + '/ ( 2 * ' + str(a) +
' )')
x = (-b) / (2 * a)
print('The solution is :\n', tools.ft_round(x))
if discriminant > 0:
print('Discriminant is strictly positive, the two solutions are :')
v.verbose('Solution formules : x1 = (-b-√∆)/(2a) et x2 = (-b+√∆)/(2a)')
x1 = (-b - (tools.sqrt(1, discriminant, None, 0))) / (2 * a)
x2 = (-b + (tools.sqrt(1, discriminant, None, 0))) / (2 * a)
print(tools.ft_round(x1))
print(tools.ft_round(x2))
def create_p_anonymity_tree(group: Group, p: int, max_level: int,
pr_len: int) -> Dict[str, List[Node]]:
"""
The algorithm is implemented in a non-recursive way because keeping the entire tree structure is not needed
as we only use the leaf nodes.
The nodes_to_process is the list of nodes which have not already been processed.
As nodes are labeled as good or bad leaves, they are added to the good_leaves or bad_leaves lists, respectively.
The new_nodes_to_process flag indicates whether during the current cycle are new nodes are created by splits.
If there are new nodes, the nodes_to_process list is updated and those new nodes are processed.
A dictionary containing two keys is returned:
- the first key is "good leaves" and contains the list of good leaf nodes, and
- the second key is "bad leaves" and contains the list of bad leaf nodes.
"""
verbose(
'Starting "create tree" step (p: {}, max PR level: {}, PR length: {}) on the following rows:'
.format(p, max_level, pr_len))
for i, row in enumerate(group.group_table):
verbose("{}: {}".format(group.ids[i], row))
# Initialize nodes list with the starting node, corresponding to the group
nodes_to_process = [create_node_from_group(group, pr_len)]
new_nodes_to_process: List[Node] = []
good_leaves: List[Node] = []
bad_leaves: List[Node] = []
# Node splitting
while nodes_to_process:
debug("New nodes to process found")
new_nodes_to_process = []
for n in nodes_to_process:
n_id = n.id
n_size = n.size()
if n_size < p:
debug("Node {} labeled bad leaf (size: {})".format(
n_id, n_size))
bad_leaves.append(n)
elif n.level == max_level:
debug(
"Node {} labeled good leaf for reaching maximum PR level (size: {})"
.format(n_id, n_size))
good_leaves.append(n)
elif n_size < 2 * p:
debug("Node {} labeled good leaf for size (size: {})".format(
n_id, n_size))
good_leaves.append(n)
n.maximize_level(max_level)
else:
debug("Node {} big enough to be split (size: {})".format(
n_id, n_size))
child_nodes = n.split()
# Split not possible
if len(child_nodes) < 2 or max(child.size()
for child in child_nodes) < p:
debug(
"Node {} labeled good leaf: split produced only one node or no child node had size >= p"
.format(n_id))
good_leaves.append(n)
# Split possible
else:
debug("Split was successful")
TG_nodes: List[Node] = []
TB_nodes: List[Node] = []
total_TB_size = 0
debug("Checking tentative node sizes:")
for child in child_nodes:
if child.size() < p:
TB_nodes.append(child)
total_TB_size += child.size()
debug(
"Node {} is a tentative bad node (size: {}), total TB nodes size: {}"
.format(child.id, child.size(), total_TB_size))
else:
TG_nodes.append(child)
debug(
"Node {} is a tentative good node (size: {})".
format(child.id, child.size()))
new_nodes_to_process.extend(TG_nodes)
if total_TB_size >= p:
debug(
"Tentative bad nodes are big enough to be merged")
child_merge = merge_child_nodes(TB_nodes)
new_nodes_to_process.append(child_merge)
else:
debug(
"Tentative bad nodes are not big enough to be merged"
)
new_nodes_to_process.extend(TB_nodes)
nodes_to_process = new_nodes_to_process
verbose(
'The "create tree" step produced the following good leaves:\n{}\nand the following bad leaves:\n{}'
.format([n.id for n in good_leaves], [n.id for n in bad_leaves]))
return good_leaves, bad_leaves
def recycle_bad_leaves(good_leaves: List[Node], bad_leaves: List[Node],
p: int) -> List[Node]:
"""
"Recycle bad leaves" step of the KAPRA algorithm, which merges bad leaves creating good ones.
This function returns a list of all good leaf nodes.
"""
verbose('Starting "recycle bad leaves" phase')
# If there are no bad leaves, then this step is not needed
if not bad_leaves:
verbose('No bad leaves found: no "recycle bad leaves" step needed')
return good_leaves
# Preparation: bad leaves are sorted in different lists depending on their level
bad_leaves_by_level: Dict[int, List[Node]] = {}
debug("Sorting bad leaves by level:")
for bad_leaf in bad_leaves:
if bad_leaf.level in bad_leaves_by_level:
bad_leaves_by_level[bad_leaf.level].append(bad_leaf)
else:
bad_leaves_by_level[bad_leaf.level] = [bad_leaf]
for level in bad_leaves_by_level:
debug("Level {} bad leaves: {}".format(
level, [n.id for n in bad_leaves_by_level[level]]))
current_level = max(bad_leaves_by_level)
# Adding empty lists for levels with no leaves to prevent errors
for level in range(current_level):
if level not in bad_leaves_by_level:
bad_leaves_by_level[level] = []
debug("Maximum bad leaf level: {}".format(current_level))
bad_rows = sum(bad_leaf.size() for bad_leaf in bad_leaves)
while bad_rows >= p:
debug("{} bad rows to process".format(bad_rows))
debug("Processing bad leaves of level {}:".format(current_level))
for n in bad_leaves_by_level[current_level]:
debug('Leaf {}: size {}, pr "{}"'.format(n.id, n.size(), n.pr))
leaves_by_pr: Dict[str, Node] = {}
for bad_leaf in bad_leaves_by_level[current_level]:
if bad_leaf.pr not in leaves_by_pr:
debug('New PR "{}" found in bad leaf {}'.format(
bad_leaf.pr, bad_leaf.id))
leaves_by_pr[bad_leaf.pr] = bad_leaf
# If there are other bad leaves with the same PR, merge them
else:
merging_leaf = leaves_by_pr[bad_leaf.pr]
verbose('Merging leaf {} to leaf {} (PR: "{}")'.format(
bad_leaf.id, merging_leaf.id, merging_leaf.pr))
merging_leaf.extend_table_with_node(bad_leaf)
debug("The following leaves were produced:")
for leaf in leaves_by_pr.values():
debug("Leaf {}: size {}, ids {}".format(leaf.id, leaf.size(),
leaf.row_ids))
for leaf in leaves_by_pr.values():
# If the leaf is not smaller than p, then it is a good leaf
if leaf.size() >= p:
good_leaves.append(leaf)
bad_rows -= leaf.size()
debug("Leaf {} is a good leaf, {} bad rows remaining".format(
leaf.id, bad_rows))
# Otherwise its level is decreased and it will be checked in the next step for a possible merge
else:
debug(
"Leaf {} is a bad leaf: its SAX level is decreased".format(
leaf.id, bad_rows))
leaf.level -= 1
row = leaf.table[0]
leaf.pr = SAX(row, leaf.level, leaf.pr_len())
bad_leaves_by_level[leaf.level].append(leaf)
current_level -= 1
if bad_rows == 0:
verbose('No rows were suppressed in the "recycle bad leaves" phase')
else:
verbose(
str(bad_rows) +
' rows were suppressed in the "recycle bad leaves" phase: they could not be merged'
)
verbose(
'The "recycle bad leaves" phase produced the following good leaves:')
for n in good_leaves:
verbose('Node {}: size {}, level {}, PR "{}", ids {}'.format(
n.id, n.size(), n.level, n.pr, n.row_ids))
return good_leaves
#Calving md.calving.calvingrate = np.zeros((md.mesh.numberofvertices)) md.levelset.spclevelset = np.nan * np.ones((md.mesh.numberofvertices)) #Friction md.friction.coefficient = 20. * np.ones((md.mesh.numberofvertices)) md.friction.coefficient[np.where(md.mask.groundedice_levelset < 0.)[0]] = 0. md.friction.p = np.ones((md.mesh.numberofelements)) md.friction.q = np.ones((md.mesh.numberofelements)) #Numerical parameters md.stressbalance.viscosity_overshoot = 0.0 md.masstransport.stabilization = 1. md.thermal.stabilization = 1. md.verbose = verbose(0) md.settings.waitonlock = 30 md.stressbalance.restol = 0.05 md.steadystate.reltol = 0.05 md.stressbalance.reltol = 0.05 md.stressbalance.abstol = np.nan md.timestepping.time_step = 1. md.timestepping.final_time = 3. #GIA: md.gia.lithosphere_thickness = 100. * np.ones((md.mesh.numberofvertices)) # in km md.gia.mantle_viscosity = 1. * 10**21 * np.ones((md.mesh.numberofvertices)) # in Pa.s md.materials.lithosphere_shear_modulus = 6.7 * 10**10 # in Pa
def k_anonymity_bottom_up(table_group: Group, k: int) -> List[Group]:
list_of_groups = []
min_max_diff = table_group.get_min_max_diff()
# create a group for each tuple
for i in range(table_group.size()):
group_with_single_tuple = create_empty_group()
row, row_id, row_pr_val = table_group.get_all_attrs_at_index(i)
group_with_single_tuple.add_row_to_group(row, row_id, row_pr_val)
list_of_groups.append(group_with_single_tuple)
# do k-anonymity on groups
smallest_group_i = find_smallest_group_index(list_of_groups)
while list_of_groups[smallest_group_i].size() < k:
group_to_check = list_of_groups.pop(smallest_group_i)
index_of_merging_group = find_index_of_group_to_be_merged(
group_to_check, list_of_groups, min_max_diff)
list_of_groups[index_of_merging_group].merge_group(group_to_check)
smallest_group_i = find_smallest_group_index(list_of_groups)
# visualize_envelopes(list_of_groups)
list_of_groups_to_be_splitted = []
for i in reversed(range(len(list_of_groups))):
if list_of_groups[i].size() >= 2 * k:
list_of_groups_to_be_splitted.append(list_of_groups.pop(i))
verbose('Groups to split: {}'.format(list_of_groups_to_be_splitted))
while len(list_of_groups_to_be_splitted) > 0:
group_to_be_split = list_of_groups_to_be_splitted.pop()
# group_to_be_split.size == 14, k == 4
verbose('Current splitting group: {} {}'.format(
group_to_be_split.size(), group_to_be_split))
parts_into_split = int(group_to_be_split.size() / k)
verbose(
'Parts into group has to be split: {}'.format(parts_into_split))
dim_of_splitted_parts = int(group_to_be_split.size() /
parts_into_split)
verbose('Dimension of parts into the group has to be split: '.format(
dim_of_splitted_parts))
for p in range(parts_into_split):
index = group_to_be_split.size() - 1
splitted_group = create_empty_group()
for g in range(dim_of_splitted_parts):
row, row_id, row_pr_val = group_to_be_split.pop_row(index)
splitted_group.add_row_to_group(row, row_id, row_pr_val)
verbose('Splitting group: {}, at index: {}'.format(
splitted_group, index))
index -= 1
if p == parts_into_split - 1:
while group_to_be_split.size() > 0:
row, row_id, row_pr_val = group_to_be_split.pop_row(0)
splitted_group.add_row_to_group(row, row_id, row_pr_val)
list_of_groups.append(splitted_group)
else:
list_of_groups.append(splitted_group)
verbose('Updated list (after splitting): {} {}'.format(
len(list_of_groups), list_of_groups))
return list_of_groups
def degree_two(polynomes):
print("Polynomial degree: 2")
a = 0
b = 0
c = 0
if 2 in polynomes:
a = polynomes[2]
if 1 in polynomes:
b = polynomes[1]
if 0 in polynomes:
c = polynomes[0]
v.verbose('Discriminant formule: b^2 - 4ac')
v.verbose('Discriminant equation: ' + str(b) + '^2 - 4 * ' + str(a) +
' * ' + str(c))
discriminant = (b * b) - 4 * a * c
v.verbose('Discriminant : ' + str(discriminant))
if discriminant < 0:
print(
"The discriminant is strictly negative, the equation has no real solution, only 2 complex solutions:"
)
v.verbose(
'Solution formules : x1 = (-b-i√-∆)/(2a) et x2 = (-b+i√-∆)/(2a)')
print("(" + str(-b) + " − i" + str(tools.sqrt(-discriminant)) +
") / " + str(2 * a))
print("(" + str(-b) + " + i" + str(tools.sqrt(-discriminant)) +
") / " + str(2 * a))
sys.exit()
if discriminant == 0:
print('Discriminant is equal to zero, there is one solution :')
v.verbose('Solution formule : x = -b/(2a)')
v.verbose('Solution equation : x = -' + str(b) + '/ ( 2 * ' + str(a) +
' )')
x = (-b) / (2 * a)
print('The solution is :\n', x)
if discriminant > 0:
print('Discriminant is strictly positive, the two solutions are :')
v.verbose('Solution formules : x1 = (-b-√∆)/(2a) et x2 = (-b+√∆)/(2a)')
x1 = (-b - (tools.sqrt(discriminant))) / (2 * a)
x2 = (-b + (tools.sqrt(discriminant))) / (2 * a)
y1 = str(x1)
y2 = str(x2)
j = y1.find(".")
k = y2.find(".")
print(y1[:j + 5])
print(y2[:k + 5])
import verbose
verbose.setLevels(
99) # vlist can be a str: "2,readcmds,blah" or list [2,"readcmds","blah"]
verbose.openFile(
"test_verbose.log",
"w") # output to a file (open with truncate); default: sys.stderr output
verbose.verbose(
[2, "loop"],
"message") # output if verbose level >= 2 or one verbose string is "loop"
verbose.verbose(["info"], "message") # output if one verbose string is "info"
verbose.verbose([99], "message") # output if verbose level >= 99
verbose.verbose("99", "message") # output if verbose level >= 99
verbose.verbose(99, "message") # output if verbose level >= 99
verbose.isLevel(
"99,blah") # True if verbose level >= 99 or verbose str is "blah"
verbose.closeFile()
def create(judo, input):
"""wrapper for judo class read function.
"""
verbose("{} command initiated".format(input.command), input.verbose)
verbose("secret name: {}".format(input.command_arg), input.verbose)
if input.number:
verbose("number of shards: {}".format(input.number), input.verbose)
else:
print("Please specify the number of shards with --number or -n")
sys.exit(1)
if input.input:
verbose("secret to encrypt: {}".format(input.input), input.verbose)
else:
if not input.inputfile:
print("No secret provided. specify either --input or --inputfile")
sys.exit(1)
if input.inputfile:
verbose("file to encrypt: {}".format(input.inputfile), input.verbose)
if input.quorum:
verbose("quorum: {}".format(input.quorum), input.verbose)
else:
print("You must specify --quorum <value> or -m <value>")
sys.exit(1)
if input.expires:
verbose("expiration: {}".format(input.expires), input.verbose)
if input.ip:
verbose("allowed_ips: {}".format(input.ip), input.verbose)
judo.create(input.command_arg,
shards=input.number,
input=input.input,
min_shards=input.quorum,
input_file=input.inputfile,
expiration=input.expires,
allowed_ips=input.ip)
# Use a MacAyeal flow model
md = setflowequation(md, "SSA", "all")
# Save model
savevars("Pig/Models/PIG_Parameterization_py.dat", {"md": md})
elif step == 4:
md = loadmodel(path="Pig/Models/PIG_Parameterization_py.dat")
# Control general
md.inversion.iscontrol = 1
md.inversion.maxsteps = 20
md.inversion.maxiter = 40
md.inversion.dxmin = 0.1
md.inversion.gttol = 1.0e-4
md.verbose = verbose("control", True)
# Cost functions
md.inversion.cost_functions = [101, 103, 501]
md.inversion.cost_functions_coefficients = np.ones(
shape=(md.mesh.numberofvertices, 3))
md.inversion.cost_functions_coefficients[:, 0] = 1
md.inversion.cost_functions_coefficients[:, 1] = 1
md.inversion.cost_functions_coefficients[:, 2] = 8e-15
# Controls
md.inversion.control_parameters = ["FrictionCoefficient"]
md.inversion.min_parameters = 1 * np.ones(shape=(md.mesh.numberofvertices,
1))
md.inversion.max_parameters = 200 * np.ones(
shape=(md.mesh.numberofvertices, 1))
def postprocess(good_leaves: List[Node], bad_leaves: List[Node]) -> List[Node]:
"""
The postprocessing phase takes care of the bad leaves integrating them into the good leaves.
The modified good leaves are then returned.
"""
if not good_leaves:
print(
"WARNING: no good leaves found, not enough rows in the anonymizing group?"
)
elif not bad_leaves:
verbose("No bad leaves found: no postprocessing needed")
elif len(good_leaves) == 1:
verbose("Starting postprocessing phase")
good = good_leaves[0]
verbose(
"Only 1 good leaf (node {}): adding all bad leaf rows to the only good leaf"
.format(good.id))
for bad in bad_leaves:
debug("Processing bad leaf {}".format(bad.id))
debug("Similarity to good node: {})".format(
compute_pattern_similarity(bad.pr, good.pr, bad.level,
good.level)))
good.extend_table_with_node(bad)
else:
verbose("Starting postprocessing phase")
bad_leaves.sort(key=lambda node: node.size())
for bad in bad_leaves:
debug("Processing bad leaf {}".format(bad.id))
max_similarity = None
most_similar_good = None
for good in good_leaves:
similarity = compute_pattern_similarity(
bad.pr, good.pr, bad.level, good.level)
if max_similarity is None or similarity > max_similarity:
max_similarity = similarity
most_similar_good = good
debug(
"Updating most similar node to node {} (better similarity: {})"
.format(most_similar_good.id, max_similarity))
elif similarity == max_similarity and good.size(
) < most_similar_good.size():
most_similar_good = good
debug(
"Updating most similar node to node {} (smaller size: {})"
.format(most_similar_good.id,
most_similar_good.size()))
most_similar_good.extend_table_with_node(bad)
verbose("The postprocessing phase produced the following good leaves:")
for n in good_leaves:
verbose('Node {}: size {}, level {}, PR "{}", ids {}'.format(
n.id, n.size(), n.level, n.pr, n.row_ids))
return good_leaves
