def add_constraint(self,c): # check for inference infered_list = [] for c_ in self.constraint_list: if set(c_.var_list).issubset(c.var_list): new_var_l = list(set(c.var_list) - set(c_.var_list)) new_val = c.value - c_.value new_c = constraint(new_var_l,new_val) infered_list.append(new_c) elif set(c.var_list).issubset(c_.var_list): new_var_l = list(set(c_.var_list) - set(c.var_list)) new_val = c_.value - c.value new_c = constraint(new_var_l, new_val) infered_list.append(new_c) self.constraint_list.append(c) self.constraint_list = self.constraint_list + infered_list
def createConstraint(indices, u, v, r): for i in indices: g.constraints.append(constraint(g.nodes[i], u, v, r, 'y')) g.constraintX.append(g.constraints[len(g.constraints) - 1].node.u) g.constraintY.append(g.constraints[len(g.constraints) - 1].node.v) g.constraintColor.append(g.constraints[len(g.constraints) - 1].color)
def build_new_constraint(self,i,j,val): neighs = self.get_neighb(i,j) new_neighs = [] for l,m in neighs: if self.known_board[l,m] == 1: val = val - self.current_state[l,m] else: new_neighs.append((l,m)) for l,m in new_neighs: self.isVariable[l,m] = 1 return constraint(var_list=new_neighs,val=val)
def decoder(individual): global genotype phenotype = {} for item in genotype: gene = individual[item[-1]:item[-1] + item[2]] integer = 0 for i in range(item[2]): integer += gene[i] * 2**(item[2] - i - 1) if item[1] == "discrete": excess = 2**item[2] - len(item[-2]) if integer + 1 <= 2 * excess: index = integer // 2 else: index = integer - excess phenotype[item[0]] = item[-2][index] else: phenotype[item[0]] = item[3] + float(integer) / float( 2**item[2] - 1) * (item[4] - item[3]) if flag_constraint: from constraint import constraint phenotype = constraint(phenotype) return phenotype
def ParseLine(line,size): #the variables of the sudoku variables = [] constraints = [] count = 0 for unit in line: if unit == '.': #Create a variable with a full domain. variables.append(variable.Variable(range(1, size+1))) elif( RepresentsInt( unit ) ): #Create a variable with a full domain variables.append(variable.Variable(range(1, size+1))) #create a constraint constraint_list = [1 , 2, 3, 4, 5, 6, 7, 8, 9] constraint_list.remove (int(unit) ) for x in constraint_list: new_constraint = constraint.constraint( variables[ len(variables) - 1 ] ) new_constraint.unary_constraint = x constraints.append (new_constraint) count = count + 1 sudoku_constraints = general_sudoku_constraints( variables ) return [variables, constraints]
def ParseLine(line,size): #The variables of the sudoku variables = [] #The constraints of the sudoku constraints = [] count = 0 for unit in line: if unit == '.': #Create a variable with a full domain. variables.append(variable.Variable(range(1, size+1))) elif( RepresentsInt( unit ) ): #Create a variable with a full domain variables.append(variable.Variable(range(1, size+1))) #Create all the unary constraints for this given number constraint_list = range(1, size+1) constraint_list.remove (int(unit)) for x in constraint_list: new_constraint = constraint.constraint( len(variables) - 1 ) new_constraint.unary_constraint = x constraints.append (new_constraint) count = count + 1 return (variables, constraints)
def interface(self): button = str(self.__getattribute__("button")) # check for left click if button == "MouseButton.LEFT": # Initialize file dialogue interface root = tk.Tk() root.withdraw() filepath = filedialog.askopenfilename() if filepath == "": return try: # convert file contents to a dataframe dfs = pd.read_html(filepath) # Clear existing structure g.nodes = [] g.nodeX, g.nodeY, g.nodeColor = [], [], [] g.elements = [] loops = len(g.elementsPlot) for i in range(0, loops): g.elementsPlot.pop(0).remove() g.constraints = [] g.constraintX, g.constraintY, g.constraintColor = [], [], [] g.forces = [] loops = len(g.forcesPlot) for i in range(0, loops): g.forcesPlot.pop(0).remove() g.moments = [] loops = len(g.momentsPlot) for i in range(0, loops): g.momentsPlot.pop(0).remove() # Loop through the dataframe and create the structure table = 0 for i in dfs: if table == 0: for j in i.values: g.nodes.append(node(j[1], j[2], 'b')) g.nodeX.append(g.nodes[len(g.nodes)-1].u) g.nodeY.append(g.nodes[len(g.nodes)-1].v) g.nodeColor.append(g.nodes[len(g.nodes)-1].color) elif table == 1: for j in i.values: g.elements.append(element(g.nodes[int(j[1])], g.nodes[int(j[2])], j[3], j[4], j[5], 'k')) elif table == 2: for j in i.values: g.constraints.append(constraint(g.nodes[int(j[1])], bool(j[2]), bool(j[3]), bool(j[4]), 'y')) g.constraintX.append(g.constraints[len(g.constraints)-1].node.u) g.constraintY.append(g.constraints[len(g.constraints)-1].node.v) g.constraintColor.append(g.constraints[len(g.constraints)-1].color) elif table == 3: for j in i.values: g.forces.append(force(g.nodes[int(j[1])], j[2], j[3], 'darkred')) elif table == 4: for j in i.values: g.moments.append(moment(g.nodes[int(j[1])], j[2], 'darkred')) table += 1 except ValueError: # If the file chosen is not .html or has invalid contents tk.messagebox.showerror(title="File Error", message="Invalid Structure File") # Clear the dataframe dfs = 0
def general_sudoku_constraints( variables ): size = int (math.sqrt(len(variables) )) constraints = [] #constraint for every number in every column the number cannot be equal for a in range (0, size): row = variables[ size * a : size * a + size] for i in row: for j in row: if(i != j): new_constraint = constraint.constraint( i ) new_constraint.variable2 = j constraints.append( new_constraint ) #constraints for every for i in range(0,size): #makes 9 rows column = [] for j in range( 0, size ): #makes a row column.append( variables[ size * j + i] ) for k in column: for z in column: if( k != z ): new_constraint = constraint.constraint( k ) new_constraint.variable2 = z constraints.append( new_constraint ) #constraints for every box #first column of boxes boxsize = int (math.sqrt( size) ) for i in range( 0, boxsize ): #makes 9 boxes (a box has the same number of variables as the size of the sudoku) box = [] for j in range(0, boxsize ) : for k in range(0, boxsize ): box.append( variables [ k + j* size + (i * boxsize * size) ] ) for k in box: for z in box: if( k != z ): new_constraint = constraint.constraint( k ) new_constraint.variable2 = z constraints.append( new_constraint ) #second column of boxes for i in range( 0, boxsize ): #makes 9 boxes (a box has the same number of variables as the size of the sudoku) box = [] for j in range(0, boxsize ) : for k in range(0, boxsize ): box.append( variables [ k + j* size + (i * boxsize * size) + 3 ] ) for k in box: for z in box: if( k != z ): new_constraint = constraint.constraint( k ) new_constraint.variable2 = z constraints.append( new_constraint ) #third column of boxes for i in range( 0, boxsize ): #makes 9 boxes (a box has the same number of variables as the size of the sudoku) box = [] for j in range(0, boxsize ) : for k in range(0, boxsize ): box.append( variables [ k + j* size + (i * boxsize * size) + 6 ] ) for k in box: for z in box: if( k != z ): new_constraint = constraint.constraint( k ) new_constraint.variable2 = z constraints.append( new_constraint ) return constraints
I_Ei = np.c_[I[:-1], I[1:]] x_Eid = x_Id[I_Ei] J_Emde = np.einsum('mei,Eid->Emed', dN_mei, x_Eid) J_det_Em = np.linalg.det(J_Emde) J_inv_Emed = np.linalg.inv(J_Emde) # Quadratic forms dN_Eimd = np.einsum('mei,Eide->Eimd', dN_mei, J_inv_Emed) BB_ECidDjf = np.einsum('m, CD, C, C, Eimd,Ejmf,Em->ECidDjf', w_m, DELTA_cd, A_c, E_c, dN_Eimd, dN_Eimd, J_det_Em) NN_ECidDjf = np.einsum('m, CD,mi,mj,,,Em->ECiDj', w_m, SWITCH_cd, N_mi, N_mi, p, G, J_det_Em) BB_Eij = BB_ECidDjf.reshape(-1, n_e_dof, n_e_dof) NN_Eij = NN_ECidDjf.reshape(-1, n_e_dof, n_e_dof) K_Eij = BB_Eij + NN_Eij # Multilayer expansion C = np.arange(n_c) * n_n_tot I_C = I[np.newaxis, :] + C[:, np.newaxis] I_ECi = np.vstack([[I_C[:, :-1], I_C[:, 1:]]]).T.reshape(-1, n_e_dof) # apply constraints and solve F_ext = np.zeros((n_dof_tot, ), np.float_) K_Eij, F_ext = constraint(n_dof_tot / 2 - 1, 0., K_Eij, I_ECi, F_ext) K_Eij, F_ext = constraint(n_dof_tot - 1, 0.01, K_Eij, I_ECi, F_ext) d_I = cg(K_Eij, F_ext, I_ECi) print 'd_I', d_I # post processing import matplotlib.pyplot as plt plt.plot(x_Id[:, 0], d_I.reshape(2, -1).T) plt.xlabel('x') plt.ylabel('displacement') plt.show()
def __init__(self, L, ham_vec, t, U, max_iter): self.L = L self.max_iter = max_iter self.t_ = t self.U_ = U self.time_start = time.time() g1_vec = np.zeros(2 * self.L, dtype=np.float32) z1_vec = np.zeros(2 * self.L, dtype=np.float32) g2_ph_vec = np.zeros(4 * L * L * L, dtype=np.float32) z2_ph_vec = np.zeros(4 * L * L * L, dtype=np.float32) g2_pair1_vec = np.zeros(L * L * L, dtype=np.float32) z2_pair1_vec = np.zeros(L * L * L, dtype=np.float32) g2_pair2_vec = np.zeros(L * L * L, dtype=np.float32) z2_pair2_vec = np.zeros(L * L * L, dtype=np.float32) self.primal_var = primal(L, g1_vec, g2_ph_vec, g2_pair1_vec, g2_pair2_vec) self.dual_var = dual(L, z1_vec, z2_ph_vec, z2_pair1_vec, z2_pair2_vec) self.const_var = constraint(L) self.const_var.generate_constraint_matrix() #self.const_var.generate_constraint_matrix_test() self.duality_gap = np.zeros(5 * L) self.dim_var = len(g1_vec) + len(g2_ph_vec) + len(g2_pair1_vec) + len( g2_pair2_vec) self.dim_const = self.const_var.dim_const self.w = np.zeros((self.dim_var, self.dim_var), dtype=np.float32) self.inv_wT = np.zeros((self.dim_var, self.dim_var), dtype=np.float32) self.vec_rx = np.zeros(self.dim_var, dtype=np.float32) self.vec_ry = np.zeros(self.dim_const, dtype=np.float32) self.vec_rz = np.zeros(self.dim_var, dtype=np.float32) self.vec_rd = np.zeros(self.dim_var, dtype=np.float32) self.wt_lambda_inv_I = np.zeros(self.dim_var, dtype=np.float32) self.var_y = np.zeros(self.dim_const, dtype=np.float32) self.del_x = np.zeros(self.dim_var, dtype=np.float32) self.del_z = np.zeros(self.dim_var, dtype=np.float32) self.del_y = np.zeros(self.const_var.dim_const, dtype=np.float32) self.vec_ham = ham_vec self.debug = False if (self.debug): self.eig_val_x = np.zeros(2 * self.L + self.L * self.L * 2 + self.L * self.L + self.L * self.L, dtype=np.complex64) self.eig_val_z = np.zeros(2 * self.L + self.L * self.L * 2 + self.L * self.L + self.L * self.L, dtype=np.complex64) self.if_combined_direction = True # if calculate combined direction self.convg_criteria = 0.001 self.prev_error = 1000.0 self.truncation = 0.001