1:\\n grid2[distances > max_distance, :] = np.nan\\n else:\\n grid2[distances > max_distance] = np.nan\\n grid = grid2\\n distances = dict(list(zip(tids, distances)))\\n\\n else:\\n distances = None\\n\\n if distances:\\n return results, distances\\n else:\\n return results\",\n \"def _index(tensor_3d, tensor_2d):\\n x, y, z = tensor_3d.size()\\n t = tensor_3d.reshape(x * y, z)\\n tt = tensor_2d.reshape(x * y)\\n v = t[torch.arange(x * y), tt]\\n v = v.reshape(x, y)\\n return v\",\n \"def build_augmented_matrix(self):\\r\\n for row in range(self.SIZE):\\r\\n self.matrix[row].append(self.result[row])\",\n \"def get_unet():\\n inputs = Input((img_rows, img_cols, 1))\\n conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(inputs)\\n conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv1)\\n pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)\\n\\n conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(pool1)\\n conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv2)\\n pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)\\n\\n conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(pool2)\\n conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv3)\\n pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)\\n\\n conv4 = Conv2D(256, (3, 3), activation='relu', padding='same')(pool3)\\n conv4 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv4)\\n pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)\\n\\n conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(pool4)\\n conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(conv5)\\n\\n up6 = concatenate([Conv2DTranspose(256, (2, 2), strides=(2, 2),\\n padding='same')(conv5), conv4], axis=3)\\n conv6 = Conv2D(256, (3, 3), activation='relu', padding='same')(up6)\\n conv6 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv6)\\n\\n up7 = concatenate([Conv2DTranspose(128, (2, 2), strides=(2, 2),\\n padding='same')(conv6), conv3], axis=3)\\n conv7 = Conv2D(128, (3, 3), activation='relu', padding='same')(up7)\\n conv7 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv7)\\n\\n up8 = concatenate([Conv2DTranspose(64, (2, 2), strides=(2, 2),\\n padding='same')(conv7), conv2], axis=3)\\n conv8 = Conv2D(64, (3, 3), activation='relu', padding='same')(up8)\\n conv8 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv8)\\n\\n up9 = concatenate([Conv2DTranspose(32, (2, 2), strides=(2, 2),\\n padding='same')(conv8), conv1], axis=3)\\n conv9 = Conv2D(32, (3, 3), activation='relu', padding='same')(up9)\\n conv9 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv9)\\n\\n conv10 = Conv2D(1, (1, 1), activation='sigmoid')(conv9)\\n\\n model = Model(inputs=[inputs], outputs=[conv10])\\n\\n model.compile(optimizer=Adam(lr=1e-4), loss=dice_coef_loss,\\n metrics=[dice_coef])\\n\\n return model\",\n \"def _expand_shape_to_4d(weight_tensor: libpymo.TensorParams):\\n dims = len(weight_tensor.shape)\\n\\n if dims > 5:\\n raise RuntimeError\\n\\n if dims == 4:\\n yield weight_tensor\\n\\n else:\\n orig_shape = weight_tensor.shape\\n if dims < 4:\\n # If we have less dimensions, we add 1s to make 4 dimensions\\n _4d_shape = np.append(orig_shape, [1 for _ in range(4-dims)]).astype(int)\\n else:\\n # If we have more dimensions, we concatenate all the dimensions beyond 3 into one dimension\\n _4d_shape = np.array(orig_shape[:3] + [math.prod(orig_shape[3:])])\\n\\n try:\\n weight_tensor.shape = _4d_shape\\n yield weight_tensor\\n finally:\\n weight_tensor.shape = orig_shape\",\n \"def _compute_nodes(npts, ndim, ilbds):\\n if npts ** ndim * ndim >= 1e9:\\n raise ValueError(\\\"Tensor-mesh too large for memory.\\\")\\n nodes = _compute_nodes_1d(npts, ilbds[0])\\n productmesh = np.repeat(nodes, npts ** (ndim - 1))\\n for i in range(1, ndim):\\n nodes = _compute_nodes_1d(npts, ilbds[i])\\n column = np.repeat(np.tile(nodes, int(npts ** i)), int(npts ** (ndim - 1 - i)))\\n productmesh = np.vstack((productmesh.T, column)).T\\n if ndim == 1:\\n return productmesh.reshape((npts, 1))\\n else:\\n return productmesh\",\n \"def tile_and_bind3d(s, tensor, z, y, x, z_factor=2, y_factor=None, x_factor=None):\\n y_factor = y_factor or z_factor\\n x_factor = x_factor or y_factor\\n zo, zi = s[tensor].split(z, z_factor)\\n yo, yi = s[tensor].split(y, y_factor)\\n xo, xi = s[tensor].split(x, x_factor)\\n s[tensor].bind(zo, te.thread_axis(\\\"blockIdx.z\\\"))\\n s[tensor].bind(zi, te.thread_axis(\\\"threadIdx.z\\\"))\\n s[tensor].bind(yo, te.thread_axis(\\\"blockIdx.y\\\"))\\n s[tensor].bind(yi, te.thread_axis(\\\"threadIdx.y\\\"))\\n s[tensor].bind(xo, te.thread_axis(\\\"blockIdx.x\\\"))\\n s[tensor].bind(xi, te.thread_axis(\\\"threadIdx.x\\\"))\\n s[tensor].reorder(zo, yo, xo, zi, yi, xi)\\n return zo, yo, xo, zi, yi, xi\",\n \"def setViews(self,batchSize):\\n assert batchSize <= self.maxBatch, \\\"Batch size exceeds max batch\\\"\\n self.hActs = [H.get_col_slice(0,batchSize) for H in self.hActs_M]\\n self.hActsFor = self.hActsFor_M.get_col_slice(0,batchSize)\\n self.hActsBack = self.hActsBack_M.get_col_slice(0,batchSize)\\n self.probs = self.probs_M.get_col_slice(0,batchSize)\\n self.rowVec = self.rowVec_M.get_col_slice(0,batchSize)\\n if self.train:\\n self.deltasC = self.deltasC_M.get_col_slice(0,batchSize)\\n self.deltasOut = self.deltasOut_M.get_col_slice(0,batchSize)\\n self.deltasIn = self.deltasIn_M.get_col_slice(0,batchSize)\\n self.tmpGrad = self.tmpGrad_M.get_col_slice(0,batchSize)\\n if self.temporalLayer > 0:\\n self.tmpGradFor = self.tmpGrad # reuse tmpGrad mem\\n self.tmpGradBack = self.tmpGradBack_M.get_col_slice(0,batchSize)\\n self.deltasFor = self.deltasFor_M.get_col_slice(0,batchSize)\\n self.deltasBack = self.deltasBack_M.get_col_slice(0,batchSize)\",\n \"def unstructured_grid(self, X, Y, Z):\\r\\n uX = []\\r\\n uY = []\\r\\n uZ = []\\r\\n l = self.size[0] * self.size[1]\\r\\n self.Grid = vtk.vtkUnstructuredGrid()\\r\\n for k in range(self.size[2]):\\r\\n n = 0\\r\\n for j in range(self.size[1]):\\r\\n for i in range(self.size[0]):\\r\\n # SW-B\\r\\n swb = 8 * k * l + 4 * l + 2 * self.size[0] * (j + 1) + 2 * n\\r\\n uX.append(X[swb])\\r\\n uY.append(Y[swb])\\r\\n uZ.append(Z[swb])\\r\\n # SE-B\\r\\n seb = 8 * k * l + 4 * l + 2 * self.size[0] * (j + 1) + 2 * n + 1\\r\\n uX.append(X[seb])\\r\\n uY.append(Y[seb])\\r\\n uZ.append(Z[seb])\\r\\n # NE-B\\r\\n neb = 8 * k * l + 4 * l + 2 * self.size[0] * j + 2 * n + 1\\r\\n uX.append(X[neb])\\r\\n uY.append(Y[neb])\\r\\n uZ.append(Z[neb])\\r\\n # NW-B\\r\\n nwb = 8 * k * l + 4 * l + 2 * self.size[0] * j + 2 * n\\r\\n uX.append(X[nwb])\\r\\n uY.append(Y[nwb])\\r\\n uZ.append(Z[nwb])\\r\\n # SW-T\\r\\n swt = 8 * k * l + 2 * self.size[0] * (j + 1) + 2 * n\\r\\n uX.append(X[swt])\\r\\n uY.append(Y[swt])\\r\\n uZ.append(Z[swt])\\r\\n # SE-T\\r\\n sett = 8 * k * l + 2 * self.size[0] * (j + 1) + 2 * n + 1\\r\\n uX.append(X[sett])\\r\\n uY.append(Y[sett])\\r\\n uZ.append(Z[sett])\\r\\n # NE-T\\r\\n net = 8 * k * l + 2 * self.size[0] * j + 2 * n + 1\\r\\n uX.append(X[net])\\r\\n uY.append(Y[net])\\r\\n uZ.append(Z[net])\\r\\n # NW-T\\r\\n nwt = 8 * k * l + 2 * self.size[0] * j + 2 * n\\r\\n uX.append(X[nwt])\\r\\n uY.append(Y[nwt])\\r\\n uZ.append(Z[nwt])\\r\\n\\r\\n n += 1\\r\\n\\r\\n # Set points\\r\\n points = vtk.vtkPoints()\\r\\n points.SetNumberOfPoints(2 * self.size[0] * 2 * self.size[1] * 2 * self.size[2])\\r\\n for i in range(len(uX)):\\r\\n points.SetPoint(i, [uX[i], uY[i], uZ[i]])\\r\\n self.Grid.SetPoints(points)\\r\\n\\r\\n # Set cells\\r\\n cells = vtk.vtkCellArray()\\r\\n cell = vtk.vtkHexahedron()\\r\\n for i in range(len(uX)):\\r\\n if i > 0 and i % 8 == 0:\\r\\n cells.InsertNextCell(cell)\\r\\n cell.GetPointIds().SetId(i % 8, i)\\r\\n cells.InsertNextCell(cell)\\r\\n\\r\\n self.Grid.SetCells(cell.GetCellType(), cells)\",\n \"def mtr_tr_dense_local(sz):\\n hparams = mtr_tr_dense(sz)\\n hparams.decoder_layers = [\\\"local_self_att\\\", \\\"enc_att\\\", \\\"drd\\\"] * 6\\n hparams.local_attention_radius = 32\\n return hparams\",\n \"def compress(self, tensor):\",\n \"def nested_tensor_from_tensor_list(tensor_list):\\n max_size = _max_by_axis([list(img.shape) for img in tensor_list])\\n batch_shape = [len(tensor_list)] + max_size # len is the num of images in this batch\\n b, c, h, w = batch_shape\\n dtype = tensor_list[0].dtype\\n data_tensor = paddle.zeros(batch_shape, dtype=dtype)\\n mask = paddle.ones((b, h, w), dtype='int32')\\n # zip has broadcast for tensor and mask\\n #print('===== inside nested_tensor_from_tensor_list')\\n # zip cannot used in paddle, which will create a new tensor. in pytorch it works well\\n #for img, pad_img, m in zip(tensor_list, tensor, mask):\\n # pad_img[: img.shape[0], : img.shape[1], : img.shape[2]] = img\\n # m[: img.shape[0], :img.shape[1]] = 0\\n for idx in range(b):\\n s0 = tensor_list[idx].shape[0]\\n s1 = tensor_list[idx].shape[1]\\n s2 = tensor_list[idx].shape[2]\\n # direct set value raise error in current env, we use numpy to bypass\\n #data_tensor[idx, : s0, : s1, : s2] = tensor_list[idx].cpu().numpy()\\n data_tensor[idx, : s0, : s1, : s2] = tensor_list[idx]\\n mask[idx, : s1, : s2] = 0\\n return NestedTensor(data_tensor, mask)\",\n \"def gru_encoder(cell, embedding, init_state, batch_input, batch_mask):\\n #batch_size = batch_input.get_shape()[0]\\n #state = tf.zeros([batch_size, options['state_size']], tf.float32) # initialize the state\\n outputs = []\\n #split_inputs = tf.split(1, batch_input.get_shape()[0], batch_input)\\n \\n with tf.device(\\\"/cpu:0\\\"):\\n embedded_list = tf.nn.embedding_lookup(embedding, batch_input)\\n #embedded_list = batch_mask * tf.transpose(embedded_list, [2, 0, 1]) # Add mask to change embedding into zeros\\n #embedded_list = tf.transpose(embedded_list, [2, 1, 0])\\n embedded_list = tf.transpose(embedded_list, [1, 0, 2])\\n embedded_list = tf.unpack(embedded_list) # list of embedding\\n \\n # min_sequence_length = tf.reduce_min(seq_len)\\n #max_sequence_length = tf.reduce_max(seq_len)\\n\\n state = init_state\\n for time, (embedded, i_mask) in enumerate(zip(embedded_list, tf.unpack(tf.transpose(batch_mask)))):\\n #embedded = tf.nn.embedding_lookup(embedding, tf.reshape(inputs, [-1])) # deprecated\\n #embedded = embedded * tf.reshape(tf.convert_to_tensor(batch_mask[:, time], tf.float32), [batch_size, 1]) # deprecated\\n #copy_cond = (time >= seq_len)\\n #new_output, new_state = cell(embedded, state)\\n output, state = cell(embedded, state)#tf.select(copy_cond, zero_output, new_output), tf.select(copy_cond, state, new_state)\\n output = tf.expand_dims(i_mask, 1) * output\\n outputs.append(output)\\n #outputs = batch_mask * tf.transpose(tf.pack(outputs), [2, 0, 1])\\n #outputs = tf.unpack(tf.transpose(outputs, [2, 1, 0]))\\n return outputs, state\",\n \"def create_cells_from_dims(num_verts_x: int, num_verts_y: int):\\n num_cells_x = num_verts_x - 1\\n num_cells_y = num_verts_y - 1\\n num_cells = num_cells_x*num_cells_y\\n cell_array = np.zeros((num_cells, 4), dtype=int)\\n cell_num = 0\\n\\n # I am sure this could be done in a more efficient way.\\n for y_cell in range(num_cells_y):\\n for x_cell in range(num_cells_x):\\n cell_array[cell_num, 0] = x_cell + num_verts_x*y_cell\\n cell_array[cell_num, 1] = cell_array[cell_num, 0] + 1\\n cell_array[cell_num, 2] = cell_array[cell_num, 0] + num_verts_x + 1\\n cell_array[cell_num, 3] = cell_array[cell_num, 0] + num_verts_x\\n cell_num += 1\\n\\n return cell_array\",\n \"def tensor():\\n tensor = np.loadtxt('tensor.dat')\\n #tensor = np.reshape(tensor,len(tensor)/4)\\n tensor_new = np.zeros((len(tensor),2,2))\\n tensor_new[:,0,0] = tensor[:,0]\\n tensor_new[:,0,1] = tensor[:,1]\\n tensor_new[:,1,0] = tensor[:,1]\\n tensor_new[:,1,1] = tensor[:,2]\\n # eigen-value decomposition\\n S = np.zeros((len(tensor_new),2,2))\\n for i in xrange(len(S)):\\n R,D = np.linalg.eig(tensor_new[i])\\n D_log = np.log(D)\\n S[i] = np.dot(R.T,np.dot(D_log,R))\\n S = np.reshape(S,(len(S),4))\\n return S\",\n \"def _generate_boxes(self):\\n boxes_all = []\\n for level in range(self.min_level, self.max_level + 1):\\n boxes_l = []\\n for scale in range(self.num_scales):\\n for aspect_ratio in self.aspect_ratios:\\n stride = 2 ** level\\n intermidate_scale = 2 ** (scale / float(self.num_scales))\\n base_anchor_size = self.anchor_size * stride * intermidate_scale\\n aspect_x = aspect_ratio ** 0.5\\n aspect_y = aspect_ratio ** -0.5\\n half_anchor_size_x = base_anchor_size * aspect_x / 2.0\\n half_anchor_size_y = base_anchor_size * aspect_y / 2.0\\n x = tf.range(stride / 2, self.image_size[1], stride)\\n y = tf.range(stride / 2, self.image_size[0], stride)\\n xv, yv = tf.meshgrid(x, y)\\n xv = tf.cast(tf.reshape(xv, [-1]), dtype=tf.float32)\\n yv = tf.cast(tf.reshape(yv, [-1]), dtype=tf.float32)\\n # Tensor shape Nx4.\\n boxes = tf.stack([yv - half_anchor_size_y, xv - half_anchor_size_x,\\n yv + half_anchor_size_y, xv + half_anchor_size_x],\\n axis=1)\\n boxes_l.append(boxes)\\n # Concat anchors on the same level to tensor shape NxAx4.\\n boxes_l = tf.stack(boxes_l, axis=1)\\n boxes_l = tf.reshape(boxes_l, [-1, 4])\\n boxes_all.append(boxes_l)\\n return tf.concat(boxes_all, axis=0)\",\n \"def batch_gather_3d(values, indices):\\n return tf.gather(tf.reshape(values, [-1, tf.shape(values)[2]]),\\n tf.range(0, tf.shape(values)[0]) * tf.shape(values)[1] +\\n indices)\",\n \"def init_four_d_array(dimens, val):\\n w, x, y, z = dimens\\n return [[[[val for l in range(z)]\\n for k in range(y)]\\n for j in range(x)]\\n for i in range(w)]\",\n \"def generator(real_init): #-1, 5, 3\\n with tf.variable_scope('rnn_gen', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\\n x_init = real_init[:,:,0] #-1, 8\\n y_init = real_init[:,:,1] #-1, 8\\n z_init = real_init[:,:,2] #-1, 8\\n \\n with tf.variable_scope('x_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\\n x_w1 = tf.get_variable('x_w1', [6, 3])\\n x_b1 = tf.get_variable('x_b1', [3])\\n x_w2 = tf.get_variable('x_w2', [9, 3])\\n x_b2 = tf.get_variable('x_b2', [3])\\n x_w3 = tf.get_variable('x_w3', [3, 1])\\n x_b3 = tf.get_variable('x_b3', [1])\\n x_w4 = tf.get_variable('x_w4', [3, 1])\\n x_b4 = tf.get_variable('x_b4', [1])\\n \\n x_full = x_init#-1, 8\\n for i in range(104):\\n x_layer1 = tf.nn.elu(tf.matmul(x_init, x_w1) + x_b1)#-1, 4\\n x_layer2 = tf.concat([x_init, x_layer1], 1)#-1, 12\\n x_layer3 = tf.nn.elu(tf.matmul(x_layer2, x_w2) + x_b2)#-1, 4\\n \\n x_mean = tf.sigmoid(tf.matmul(x_layer3, x_w3) + x_b3)#-1, 1\\n x_gamma = tf.sigmoid(tf.matmul(x_layer3, x_w4) + x_b4)#-1, 1\\n x_delta = x_mean + x_gamma * tf.random_normal(tf.shape(x_gamma), dtype = tf.float32)#-1, 1\\n x_delta_denorm = (x_delta * 2 - 1) / 80\\n x_output = tf.expand_dims(x_full[:,-1], 1) + x_delta_denorm\\n x_full = tf.concat([x_full, x_output], axis = 1)#-1, 10 + 1\\n x_init = x_full[:,-6:]\\n \\n with tf.variable_scope('y_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\\n y_w1 = tf.get_variable('y_w1', [6, 3])\\n y_b1 = tf.get_variable('y_b1', [3])\\n y_w2 = tf.get_variable('y_w2', [9, 3])\\n y_b2 = tf.get_variable('y_b2', [3])\\n y_w3 = tf.get_variable('y_w3', [3, 1])\\n y_b3 = tf.get_variable('y_b3', [1])\\n y_w4 = tf.get_variable('y_w4', [3, 1])\\n y_b4 = tf.get_variable('y_b4', [1])\\n \\n y_full = y_init#-1, 8\\n for i in range(104):\\n y_layer1 = tf.nn.elu(tf.matmul(y_init, y_w1) + y_b1)\\n y_layer2 = tf.concat([y_init, y_layer1], 1)#-1, 12\\n y_layer3 = tf.nn.elu(tf.matmul(y_layer2, y_w2) + y_b2)#-1, 4\\n \\n y_mean = tf.sigmoid(tf.matmul(y_layer3, y_w3) + y_b3) #-1, 1\\n y_gamma = tf.sigmoid(tf.matmul(y_layer3, y_w4) + y_b4) #-1, 1\\n y_delta = y_mean + y_gamma * tf.random_normal(tf.shape(y_gamma), dtype = tf.float32)#-1, 1\\n y_delta_denorm = (y_delta * 5 - 2.7) / 1700\\n y_output = tf.expand_dims(y_full[:,-1], 1) + y_delta_denorm\\n y_full = tf.concat([y_full, y_output], axis = 1)#-1, 10 + 1, 1\\n y_init = y_full[:,-6:]\\n \\n with tf.variable_scope('z_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\\n z_w1 = tf.get_variable('z_w1', [6, 3])\\n z_b1 = tf.get_variable('z_b1', [3])\\n z_w2 = tf.get_variable('z_w2', [9, 3])\\n z_b2 = tf.get_variable('z_b2', [3])\\n z_w3 = tf.get_variable('z_w3', [3, 1])\\n z_b3 = tf.get_variable('z_b3', [1])\\n z_w4 = tf.get_variable('z_w4', [3, 1])\\n z_b4 = tf.get_variable('z_b4', [1])\\n \\n z_full = z_init#-1, 8\\n for i in range(104):\\n z_layer1 = tf.nn.elu(tf.matmul(z_init, z_w1) + z_b1)\\n z_layer2 = tf.concat([z_init, z_layer1], 1)#-1, 12\\n z_layer3 = tf.nn.elu(tf.matmul(z_layer2, z_w2) + z_b2)#-1, 4\\n \\n z_mean = tf.sigmoid(tf.matmul(z_layer3, z_w3) + z_b3) #-1, 1\\n z_gamma = tf.sigmoid(tf.matmul(z_layer3, z_w4) + z_b4) #-1, 1\\n z_delta = z_mean + z_gamma * tf.random_normal(tf.shape(z_gamma), dtype = tf.float32)#-1, 1\\n z_delta_denorm = (z_delta * 3 - 2.2) / 300\\n z_output = tf.expand_dims(z_full[:,-1], 1) + z_delta_denorm\\n z_full = tf.concat([z_full, z_output], axis = 1)#-1, 10 + 1, 1\\n z_init = z_full[:,-6:]\\n \\n rand_layer1 = tf.concat([tf.expand_dims(x_full, 2), tf.expand_dims(y_full, 2), tf.expand_dims(z_full, 2)], axis = 2)#-1, 200, 3\\n rand_layer1_reshape = tf.reshape(rand_layer1, shape = (-1, 110, 3, 1))\\n output_filt = tf.ones(shape = (11, 1, 1, 1)) / 11\\n \\n rand_layer2 = tf.nn.conv2d(rand_layer1_reshape, output_filt, strides = [1,1,1,1], padding = 'VALID')\\n \\n return tf.reshape(rand_layer2, shape = (-1, 100, 3)) #-1, 110, 3\",\n \"def iso_tensor(a, b):\\n\\n # Velocity to Lame parameters\\n mu = b*b\\n lam = a*a - 2.*mu\\n\\n # Components of Voigt matrix\\n Cii = 2.*mu + lam\\n Cij = lam\\n Cjj = mu\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = Cii; C[0,1] = Cij; C[0,2] = Cij; C[0,3] = 0.; C[0,4] = 0.; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = Cii; C[1,2] = Cij; C[1,3] = 0.; C[1,4] = 0.; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = Cii; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = Cjj; C[3,4] = 0.; C[3,5] = 0.\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = Cjj; C[4,5] = 0.\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = Cjj\\n\\n return C\",\n \"def _generate_embeddings(self, config): \\n tr_parts = []\\n te_parts = []\\n all_columns = []\\n for comp in self.components:\\n tr_tmp, te_tmp, cols = comp.generate(config)\\n if cols != None:\\n print(tr_tmp.shape,te_tmp.shape)\\n tr_parts.append(tr_tmp)\\n te_parts.append(te_tmp)\\n all_columns += cols\\n X_train = np.concatenate(tr_parts, axis=1)\\n X_test = np.concatenate(te_parts, axis=1)\\n print(\\\"Concatenated size:\\\", X_train.shape, X_test.shape)\\n self.feature_columns = all_columns\\n return X_train, X_test\",\n \"def GraphFn(self, inp):\\n tensor = inp * 2.0\\n tensor = array_ops.reshape(tensor, self.tensor_shapes[1])\\n tensor = tensor + 3.0\\n tensor = array_ops.reshape(tensor, self.tensor_shapes[2])\\n tensor = tensor * 4.0\\n tensor = array_ops.reshape(tensor, self.tensor_shapes[3])\\n tensor += tensor + 5.0\\n return array_ops.identity(tensor, name='output_0')\",\n \"def vae_decoder(self):\\n return stax.serial(\\n stax.Dense(self.hidden_dims[1], W_init=stax.randn()),\\n stax.Relu,\\n stax.Dense(self.hidden_dims[0], W_init=stax.randn()),\\n stax.Relu,\\n stax.Dense(self.out_dim, W_init=stax.randn()) \\n )\",\n \"def dti6to33(dt6):\\n dt33 = numpy.zeros(dt6.shape[:-1] + (3, 3), dtype=dt6.dtype)\\n dt33[..., 0, 0] = dt6[..., 5] # dxx\\n dt33[..., 0, 1] = dt33[..., 1, 0] = dt6[..., 4] / 2 # dxy\\n dt33[..., 0, 2] = dt33[..., 2, 0] = dt6[..., 3] / 2 # dxz\\n dt33[..., 1, 1] = dt6[..., 2] # dyy\\n dt33[..., 1, 2] = dt33[..., 2, 1] = dt6[..., 1] / 2 # dyz\\n dt33[..., 2, 2] = dt6[..., 0] # dzz\\n\\n return dt33\",\n \"def create_teacher(self):\\n\\n #words = [\\\"one\\\", \\\"two\\\", \\\"three\\\", \\\"four\\\", \\\"five\\\", \\\"six\\\", \\\"seven\\\", \\\"eight\\\", \\\"nine\\\"]\\n\\n #print(\\\"self.length: \\\", self.length)\\n for i, image in enumerate(self.images):\\n if False:#i % 2 == 0:\\n img = list(chunks(image, 10))\\n plt.imshow(img, interpolation=\\\"nearest\\\", origin=\\\"upper\\\")\\n plt.colorbar()\\n plt.title(self.labels[i])\\n plt.show()\\n label = np.argmax(self.labels[i]) + 1\\n label_vector = self.labels[i]\\n timesteps = label + 1\\n\\n for chain in list(self.traces[i]):\\n count_tensor = list()\\n input_tensor = list()\\n target_tensor = list()\\n \\n #count_tensor.append([0] * z_size)\\n #input_tensor.append(image)\\n #target_tensor.append([None, None])\\n\\n #count_padding = [0 for x in range(z_size)]\\n \\n for count, link in enumerate(chain):\\n count_vector = [0 if x is not count else 1 for x in range(z_size)]\\n count_tensor.append(count_vector)\\n x, y = link\\n image[y*200+x] = 255\\n input_tensor.append(image)\\n target_tensor.append(list(link))\\n\\n # Fill in the rest of the list with the same (current one doe\\n #for cont in range(count + 1, z_size):\\n for cont in range(count + 1, z_size + 1):\\n #count_tensor.append(count_padding)\\n count_tensor.append(count_vector)\\n input_tensor.append(image)\\n target_tensor.append(list(link))\\n\\n \\n\\n self.explode_lbls.append(label)\\n self.explode_labels.append(label_vector)\\n self.explode_counts.append(count_tensor)\\n self.explode_images.append(input_tensor)\\n self.explode_traces.append(target_tensor)\\n #print(target_tensor)\\n\\n \\n \\n self.explode_length = len(self.explode_images)\",\n \"def _apply_array_spin1234(self, h1e: 'Nparray', h2e: 'Nparray',\\n h3e: 'Nparray', h4e: 'Nparray') -> 'Nparray':\\n norb = self.norb()\\n tno = 2 * norb\\n assert h4e.shape == (tno, tno, tno, tno, tno, tno, tno, tno)\\n lena = self.lena()\\n lenb = self.lenb()\\n\\n nh1e = numpy.copy(h1e)\\n nh2e = numpy.copy(h2e)\\n nh3e = numpy.copy(h3e)\\n\\n if fqe.settings.use_accelerated_code:\\n _make_nh123(norb, h4e, nh1e, nh2e, nh3e)\\n else:\\n for i in range(norb * 2):\\n for j in range(norb * 2):\\n for k in range(norb * 2):\\n nh1e[:, :] -= h4e[:, j, i, k, j, i, k, :]\\n for l in range(norb * 2):\\n nh2e[i, j, :, :] += (h4e[j, l, i, k, l, k, :, :] +\\n h4e[i, j, l, k, l, k, :, :] +\\n h4e[i, l, k, j, l, k, :, :] +\\n h4e[j, i, k, l, l, k, :, :] +\\n h4e[i, k, j, l, k, :, l, :] +\\n h4e[j, i, k, l, k, :, l, :] +\\n h4e[i, j, k, l, :, k, l, :])\\n nh3e[i, j, k, :, :, :] += (\\n h4e[k, i, j, l, l, :, :, :] +\\n h4e[j, i, l, k, l, :, :, :] +\\n h4e[i, l, j, k, l, :, :, :] +\\n h4e[i, k, j, l, :, l, :, :] +\\n h4e[i, j, l, k, :, l, :, :] +\\n h4e[i, j, k, l, :, :, l, :])\\n\\n (dveca, dvecb) = self.calculate_dvec_spin()\\n evecaa = numpy.zeros((norb, norb, norb, norb, lena, lenb),\\n dtype=self._dtype)\\n evecab = numpy.zeros((norb, norb, norb, norb, lena, lenb),\\n dtype=self._dtype)\\n evecba = numpy.zeros((norb, norb, norb, norb, lena, lenb),\\n dtype=self._dtype)\\n evecbb = numpy.zeros((norb, norb, norb, norb, lena, lenb),\\n dtype=self._dtype)\\n for i in range(norb):\\n for j in range(norb):\\n tmp = self._calculate_dvec_spin_with_coeff(dveca[i, j, :, :])\\n evecaa[:, :, i, j, :, :] = tmp[0][:, :, :, :]\\n evecba[:, :, i, j, :, :] = tmp[1][:, :, :, :]\\n\\n tmp = self._calculate_dvec_spin_with_coeff(dvecb[i, j, :, :])\\n evecab[:, :, i, j, :, :] = tmp[0][:, :, :, :]\\n evecbb[:, :, i, j, :, :] = tmp[1][:, :, :, :]\\n\\n out = self._apply_array_spin123(nh1e, nh2e, nh3e, (dveca, dvecb),\\n (evecaa, evecab, evecba, evecbb))\\n\\n def ncon(A, B):\\n \\\"\\\"\\\"Tensor contraction and transposition corresponding with\\n einsum 'ikmojlnp,mnopxy->ijklxy'\\n \\\"\\\"\\\"\\n return numpy.transpose(numpy.tensordot(A,\\n B,\\n axes=((2, 6, 3, 7), (0, 1, 2,\\n 3))),\\n axes=(0, 2, 1, 3, 4, 5))\\n\\n n = norb # shorter\\n nevecaa = ncon(h4e[:n, :n, :n, :n, :n, :n, :n, :n], evecaa) \\\\\\n + 2.0 * ncon(h4e[:n, :n, :n, n:, :n, :n, :n, n:], evecab) \\\\\\n + ncon(h4e[:n, :n, n:, n:, :n, :n, n:, n:], evecbb)\\n\\n nevecab = ncon(h4e[:n, n:, :n, :n, :n, n:, :n, :n], evecaa) \\\\\\n + 2.0 * ncon(h4e[:n, n:, :n, n:, :n, n:, :n, n:], evecab) \\\\\\n + ncon(h4e[:n, n:, n:, n:, :n, n:, n:, n:], evecbb)\\n\\n nevecbb = ncon(h4e[n:, n:, :n, :n, n:, n:, :n, :n], evecaa) \\\\\\n + 2.0 * ncon(h4e[n:, n:, :n, n:, n:, n:, :n, n:], evecab) \\\\\\n + ncon(h4e[n:, n:, n:, n:, n:, n:, n:, n:], evecbb)\\n\\n dveca2 = numpy.zeros(dveca.shape, dtype=self._dtype)\\n dvecb2 = numpy.zeros(dvecb.shape, dtype=self._dtype)\\n for i in range(norb):\\n for j in range(norb):\\n dveca[:, :, :, :] = nevecaa[i, j, :, :, :, :]\\n dvecb[:, :, :, :] = nevecab[i, j, :, :, :, :]\\n cvec = self._calculate_coeff_spin_with_dvec((dveca, dvecb))\\n dveca2[i, j, :, :] += cvec[:, :]\\n\\n dveca[:, :, :, :] = nevecab[:, :, i, j, :, :]\\n dvecb[:, :, :, :] = nevecbb[i, j, :, :, :, :]\\n cvec = self._calculate_coeff_spin_with_dvec((dveca, dvecb))\\n dvecb2[i, j, :, :] += cvec[:, :]\\n\\n out += self._calculate_coeff_spin_with_dvec((dveca2, dvecb2))\\n return out\",\n \"def T(self) -> BaseMatrix:\",\n \"def T(self) -> BaseMatrix:\",\n \"def expand_many(x, axes):\\n for ax in axes:\\n x = torch.unsqueeze(x, ax)\\n return x\",\n \"def transform(tensor):\\n L, W, D = tensor.shape\\n return tensor.transpose(1, 0, 2).reshape(W, L*D).mean(axis=0)\",\n \"def extforce (u, v):\\r\\n\\r\\n for i in range (height):\\r\\n for j in range (width):\\r\\n u[i,j], v[i,j] = np.stack((u[i,j], v[i,j])) + dt * extacc\\r\\n\\r\\n return u, v\",\n \"def dti33to6(dt33):\\n dt6 = numpy.zeros(dt33.shape[:-2] + (6, ), dtype=dt33.dtype)\\n dt6[..., 5] = dt33[..., 0, 0]\\n dt6[..., 4] = dt33[..., 0, 1] + dt33[..., 1, 0]\\n dt6[..., 3] = dt33[..., 0, 2] + dt33[..., 2, 0]\\n dt6[..., 2] = dt33[..., 1, 1]\\n dt6[..., 1] = dt33[..., 1, 2] + dt33[..., 2, 1]\\n dt6[..., 0] = dt33[..., 2, 2]\\n\\n return dt6\",\n \"def amoebanetd(num_classes: int = 10,\\n num_layers: int = 4,\\n num_filters: int = 512,\\n ) -> nn.Sequential:\\n channel = num_filters // 4\\n\\n def make_layer(channel: int,\\n num_layers: int,\\n genotype: Genotype,\\n ) -> Tuple[nn.Sequential, int]:\\n n = num_layers\\n channel_prev_prev, channel_prev, channel_curr = channel, channel, channel\\n cells = []\\n\\n reduction_prev = False\\n reduction = True\\n channel_curr *= 2\\n cell, multiplier = make_cell(genotype, channel_prev_prev,\\n channel_prev, channel_curr, reduction, reduction_prev)\\n channel_prev_prev, channel_prev = channel_prev, multiplier * channel_curr\\n cells.append(cell)\\n\\n reduction_prev = True\\n reduction = True\\n channel_curr *= 2\\n cell, multiplier = make_cell(genotype, channel_prev_prev,\\n channel_prev, channel_curr, reduction, reduction_prev)\\n channel_prev_prev, channel_prev = channel_prev, multiplier * channel_curr\\n cells.append(cell)\\n\\n reduction = False\\n reduction_prev = True\\n for _ in range(n):\\n cell, multiplier = make_cell(genotype, channel_prev_prev,\\n channel_prev, channel_curr, reduction, reduction_prev)\\n channel_prev_prev, channel_prev = channel_prev, multiplier * channel_curr\\n cells.append(cell)\\n reduction_prev = False\\n\\n reduction_prev = False\\n reduction = True\\n channel_curr *= 2\\n cell, multiplier = make_cell(genotype, channel_prev_prev,\\n channel_prev, channel_curr, reduction, reduction_prev)\\n channel_prev_prev, channel_prev = channel_prev, multiplier * channel_curr\\n cells.append(cell)\\n\\n reduction = False\\n reduction_prev = True\\n for _ in range(n):\\n cell, multiplier = make_cell(genotype, channel_prev_prev,\\n channel_prev, channel_curr, reduction, reduction_prev)\\n channel_prev_prev, channel_prev = channel_prev, multiplier * channel_curr\\n cells.append(cell)\\n reduction_prev = False\\n\\n reduction_prev = False\\n reduction = True\\n channel_curr *= 2\\n cell, multiplier = make_cell(genotype, channel_prev_prev,\\n channel_prev, channel_curr, reduction, reduction_prev)\\n channel_prev_prev, channel_prev = channel_prev, multiplier * channel_curr\\n cells.append(cell)\\n\\n reduction = False\\n reduction_prev = True\\n for _ in range(n):\\n cell, multiplier = make_cell(genotype, channel_prev_prev,\\n channel_prev, channel_curr, reduction, reduction_prev)\\n channel_prev_prev, channel_prev = channel_prev, multiplier * channel_curr\\n cells.append(cell)\\n reduction_prev = False\\n\\n return nn.Sequential(*cells), channel_prev\\n\\n cells, channel_prev = make_layer(channel, num_layers, amoebanetd_genotype)\\n\\n model = nn.Sequential(OrderedDict([\\n ('stem', make_stem(channel)),\\n ('cells', cells),\\n ('fin', Classifier(channel_prev, num_classes))\\n ]))\\n\\n return flatten_sequential(model)\",\n \"def _setup(self) -> None:\\n #TODO: type\\n self.activation = self.params['activation']\\n\\n self.batchsize: int = self.params['batchsize']\\n\\n self.input_shape: Tuple[int,int,int] = self.params['input_shape']\\n\\n self.d: int = self.input_shape[1]\\n assert(not self.d == 0)\\n\\n self.n: int = int(sqrt(self.input_shape[2]))\\n assert(not self.n == 0)\\n\\n self.dtype: type = self.params['dtype']\\n\\n # initialize weights\\n self.W: List[tf.Tensor] = []\\n \\n for i in range(3):\\n #TODO: type\\n w_init = self.params['initializer_w']\\n if self.params['initializer_w' + str(i)] is not None:\\n w_init = self.params['initializer_w' + str(i)]\\n\\n w_stddev: float = self.params['stddev_w']\\n if self.params['stddev_w' + str(i)] is not None:\\n w_stddev = self.params['stddev_w' + str(i)]\\n\\n self.W.append(tf.get_variable(\\\"weights_\\\" + str(i),\\n shape = (self.d, (self.d if i < 2 else 2 * self.d)),\\n dtype = self.dtype,\\n initializer = w_init(stddev=w_stddev)))\\n\\n #TODO: type\\n b_init = self.params['initializer_b']\\n b_stddev = self.params['stddev_b']\\n self.B: tf.Tensor = tf.get_variable(\\\"biases\\\", shape = (1, self.d, 1),\\n dtype = self.dtype,\\n initializer = b_init(stddev=b_stddev))\\n\\n # create/load expand matrix\\n with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\\n self.expand: tf.Tensor = tf.get_variable(\\n \\\"expand\\\" + str(self.n),\\n shape = (self.n, self.n * self.n),\\n dtype = self.dtype,\\n initializer = tf.constant_initializer(make_expand(self.n)))\\n\\n # create/load tile matrix\\n tile: np.ndarray = np.array([([1] + [0]*(self.n-1))*self.n])\\n for i in range(1, self.n):\\n tile = np.append(tile, [([0]*i + [1] + [0]*(self.n-1-i))*self.n], 0)\\n\\n self.tile: tf.Tensor = tf.constant(tile, self.dtype)\",\n \"def _unmerge_beam_dim(tensor: Any, batch_size: int, beam_size: int) ->Any:\\n if not isinstance(tensor, torch.Tensor):\\n return tensor\\n shape = list(tensor.size())\\n new_shape = [batch_size] + [beam_size] + shape[1:]\\n return tensor.view(tuple(new_shape))\",\n \"def _make_coord_array(t,d):\\n Nt,Nd = t.shape[0],d.shape[0]\\n X = np.zeros([Nt,Nd,3],dtype=np.float64)\\n for j in range(Nt):\\n for k in range(Nd):\\n X[j,k,0] = t[j]\\n X[j,k,1:3] = d[k,:]\\n X = np.reshape(X,(Nt*Nd,3))\\n return X\",\n \"def __data_generation(self, list_IDs_temp):\\n # Initialization\\n\\n X = np.zeros((self.batch_size, *self.data.shape[1:]))\\n y_2d = np.zeros((self.batch_size, *self.labels.shape[1:]))\\n\\n for i, ID in enumerate(list_IDs_temp):\\n X[i] = self.data[ID].copy()\\n y_2d[i] = self.labels[ID]\\n\\n if self.augment_rotation \\\\\\n or self.augment_shear or self.augment_zoom:\\n\\n affine = {}\\n affine['zoom'] = 1\\n affine['rotation'] = 0\\n affine['shear'] = 0\\n\\n # Because we use views down below, \\n # don't change the targets in memory.\\n # But also, don't deep copy y_2d unless necessary (that's\\n # why it's here and not above)\\n y_2d = y_2d.copy()\\n\\n if self.augment_rotation:\\n affine['rotation'] = self.rotation_val*\\\\\\n (np.random.rand()*2-1)\\n if self.augment_zoom:\\n affine['zoom'] = self.zoom_val*\\\\\\n (np.random.rand()*2-1) + 1\\n if self.augment_shear:\\n affine['shear'] = self.shear_val*\\\\\\n (np.random.rand()*2-1)\\n\\n for idx in range(X.shape[0]):\\n X[idx] = \\\\\\n tf.keras.preprocessing.image.apply_affine_transform(\\n X[idx],\\n theta=affine['rotation'],\\n shear=affine['shear'],\\n zx=affine['zoom'],\\n zy=affine['zoom'],\\n fill_mode='nearest')\\n y_2d[idx] = \\\\\\n tf.keras.preprocessing.image.apply_affine_transform(\\n y_2d[idx],\\n theta=affine['rotation'],\\n shear=affine['shear'],\\n zx=affine['zoom'],\\n zy=affine['zoom'],\\n fill_mode='nearest')\\n\\n if self.augment_shift:\\n X, y_2d = self.random_shift(X, y_2d.copy(),\\n X.shape[1],\\n X.shape[2],\\n self.shift_val)\\n\\n if self.augment_brightness:\\n X = tf.image.random_brightness(X, self.bright_val)\\n\\n if self.augment_hue:\\n if self.chan_num == 3:\\n X = tf.image.random_hue(X, self.hue_val)\\n else:\\n warnings.warn(\\\"Hue augmention set to True for mono. Ignoring.\\\")\\n\\n if self.augment_brightness or self.augment_hue:\\n X = X.numpy()\\n\\n return X, y_2d\",\n \"def edge_velocity(self):\\n #reflext x values at x edges\\n self.u[1,:,0] = -self.u[1,:,1]\\n self.u[1,:,-1] = -self.u[1,:,-2]\\n #mirror x values at y edges \\n self.u[1,0,:] = self.u[1,1,:]\\n self.u[1,-1,:] = self.u[1,-2,:]\\n #mirror y values at x edges\\n self.u[0,:,0] = self.u[0,:,1]\\n self.u[0,:,-1] = self.u[0,:,-2]\\n #mirror y values at y edges \\n self.u[0,0,:] = -self.u[0,1,:]\\n self.u[0,-1,:] = -self.u[0,-2,:]\",\n \"def generator(z, width=3, depth=3, activation=tf.nn.elu, out_dim=1,\\n reuse=False):\\n with tf.variable_scope('generator', reuse=reuse) as gen_vars:\\n x = layers.dense(z, width, activation=activation)\\n\\n for idx in range(depth - 1):\\n x = layers.dense(x, width, activation=activation)\\n\\n out = layers.dense(x, out_dim, activation=None)\\n return out\",\n \"def forward_pass_unet(images, phase_train):\\n\\n K = 4\\n images = tf.expand_dims(images, -1)\\n\\n # Network blocks\\n conv1 = sdn.convolution('Conv1', images, 3, K, 1, phase_train=phase_train)\\n down = sdn.convolution('Down128', conv1, 2, K*2, 2, phase_train=phase_train)\\n\\n conv2 = sdn.convolution('Conv2', down, 3, K*2, 1, phase_train=phase_train)\\n conv2 = sdn.residual_layer('Conv2b', conv2, 3, K*2, 1, phase_train=phase_train)\\n down = sdn.convolution('Down64', conv2, 2, K*4, 2, phase_train=phase_train)\\n\\n conv3 = sdn.residual_layer('Conv3', down, 3, K*4, 1, phase_train=phase_train)\\n conv3 = sdn.residual_layer('Conv3b', conv3, 3, K*4, 1, phase_train=phase_train)\\n down = sdn.convolution('Down32', conv3, 2, K*8, 2, phase_train=phase_train) # Now 32x32\\n\\n conv4 = sdn.residual_layer('Conv4', down, 3, K*8, 1, phase_train=phase_train)\\n conv4 = sdn.residual_layer('Conv4b', conv4, 3, K*8, 1, phase_train=phase_train)\\n down = sdn.convolution('Down16', conv4, 2, K*16, 2, phase_train=phase_train)\\n\\n conv5 = sdn.inception_layer('Conv5', down, K*16, 1, phase_train=phase_train)\\n conv5 = sdn.inception_layer('Conv5b', conv5, K*16, 1, phase_train=phase_train)\\n down = sdn.convolution('Down8', conv5, 2, K*32, 2, phase_train=phase_train)\\n\\n conv6 = sdn.inception_layer('Conv6', down, K*32, phase_train=phase_train)\\n conv6 = sdn.inception_layer('Conv6b', conv6, K*32, phase_train=phase_train)\\n down = sdn.convolution('Down4', conv6, 2, K*64, 2, phase_train=phase_train)\\n\\n # Bottom of the decoder: 4x4\\n conv7 = sdn.inception_layer('Bottom1', down, K*64, phase_train=phase_train)\\n conv7 = sdn.residual_layer('Bottom2', conv7, 3, K*64, 1, dropout=FLAGS.dropout_factor, phase_train=phase_train)\\n conv7 = sdn.inception_layer('Bottom2', conv7, K*64, phase_train=phase_train)\\n\\n # Upsample 1\\n dconv = sdn.deconvolution('Dconv1', conv7, 2, K*32, S=2, phase_train=phase_train, concat=False, concat_var=conv6, out_shape=[FLAGS.batch_size, 8, 8, K*32])\\n dconv = sdn.inception_layer('Dconv1b', dconv, K*32, phase_train=phase_train)\\n\\n dconv = sdn.deconvolution('Dconv2', dconv, 2, K*16, S=2, phase_train=phase_train, concat=False, concat_var=conv5, out_shape=[FLAGS.batch_size, 16, 16, K*16])\\n dconv = sdn.inception_layer('Dconv2b', dconv, K*16, phase_train=phase_train)\\n\\n dconv = sdn.deconvolution('Dconv3', dconv, 2, K*8, S=2, phase_train=phase_train, concat=False, concat_var=conv4, out_shape=[FLAGS.batch_size, 32, 32, K*8])\\n dconv = sdn.inception_layer('Dconv3b', dconv, K*8, phase_train=phase_train)\\n\\n dconv = sdn.deconvolution('Dconv4', dconv, 2, K*4, S=2, phase_train=phase_train, concat=False, concat_var=conv3, out_shape=[FLAGS.batch_size, 64, 64, K*4])\\n dconv = sdn.residual_layer('Dconv4b', dconv, 3, K*4, S=1, phase_train=phase_train)\\n\\n dconv = sdn.deconvolution('Dconv5', dconv, 2, K*2, S=2, phase_train=phase_train, concat=False, concat_var=conv2, out_shape=[FLAGS.batch_size, 128, 128, K*2])\\n dconv = sdn.residual_layer('Dconv5b', dconv, 3, K*2, S=1, phase_train=phase_train)\\n\\n dconv = sdn.deconvolution('Dconv6', dconv, 2, K, S=2, phase_train=phase_train, concat=False, concat_var=conv1, out_shape=[FLAGS.batch_size, 256, 256, K])\\n dconv = sdn.convolution('Dconv6b', dconv, 3, K, S=1, phase_train=phase_train, dropout=FLAGS.dropout_factor)\\n\\n # Output is a 1x1 box with 3 labels\\n Logits = sdn.convolution('Logits', dconv, 1, FLAGS.num_classes, S=1, phase_train=phase_train, BN=False, relu=False, bias=False)\\n\\n return Logits, sdn.calc_L2_Loss(FLAGS.l2_gamma)\",\n \"def _prepare_input(\\n self, data: Union[Dict[str, torch.Tensor], torch.Tensor, np.ndarray]\\n ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:\\n\\n # convert ot dict\\n if isinstance(data, torch.Tensor):\\n p4 = data\\n data = dict()\\n data[\\\"p4\\\"] = p4\\n elif isinstance(data, np.ndarray):\\n p4 = torch.from_numpy(data)\\n data = dict()\\n data[\\\"p4\\\"] = p4\\n\\n node_ps = data[\\\"p4\\\"].to(device=self.device, dtype=self.dtype) * self.scale\\n if self.jet_features:\\n jet_p = torch.sum(node_ps, dim=-2).unsqueeze(-2)\\n node_ps = torch.cat((node_ps, jet_p), dim=-2)\\n\\n scalars = normsq4(node_ps).abs().sqrt().unsqueeze(-1)\\n if self.jet_features:\\n jet_mass = (\\n normsq4(torch.sum(node_ps, dim=-2))\\n .unsqueeze(-1)\\n .unsqueeze(-1)\\n .repeat(1, self.num_input_particles, 1)\\n )\\n scalars = torch.cat((scalars, jet_mass), dim=-1)\\n\\n # Calculate node masks and edge masks\\n if \\\"labels\\\" in data:\\n node_mask = data[\\\"labels\\\"].to(device=self.device)\\n node_mask = node_mask.to(torch.uint8)\\n elif \\\"masks\\\" in data:\\n node_mask = data[\\\"masks\\\"].to(device=self.device)\\n node_mask = node_mask.to(torch.uint8)\\n elif \\\"mask\\\" in data:\\n node_mask = data[\\\"mask\\\"].to(device=self.device)\\n node_mask = node_mask.to(torch.uint8)\\n else:\\n node_mask = data[\\\"p4\\\"][..., 0] != 0\\n node_mask = node_mask.to(device=self.device, dtype=torch.uint8)\\n if self.jet_features:\\n jet_mask = torch.ones_like(node_mask[..., 0:1])\\n jet_mask = jet_mask.to(device=self.device, dtype=torch.uint8)\\n node_mask = torch.cat((node_mask, jet_mask), dim=-1)\\n edge_mask = node_mask.unsqueeze(1) * node_mask.unsqueeze(2)\\n\\n if \\\"scalars\\\" in data.keys():\\n # (0,0) representation\\n scalars = torch.cat(\\n [scalars, data[\\\"scalars\\\"].to(device=self.device, dtype=self.dtype)],\\n dim=-1,\\n )\\n\\n return scalars, node_ps, node_mask, edge_mask\",\n \"def convert_state(self, x, v):\\n \\n\\n #print(self.offset[0] * self.tiling_displacement[len(self.tiling_displacement)-1][0] / self.tile_width[0])\\n\\n #state = 0\\n n_features = self.total_tiles[0] * self.total_tiles[1] * self.n_tilings\\n state = np.zeros(n_features, dtype=int)\\n print(np.shape(state))\\n\\n for i in range(self.n_tilings):\\n # Finds the index of the tile in both dimensions\\n x_tile = (x - self.offset[0] * self.tiling_displacement[i][0] - self.x_range[0] + self.extra_tiles[0] * self.tile_width[0]) // self.tile_width[0]\\n v_tile = (v - self.offset[1] * self.tiling_displacement[i][1] - self.v_range[0] + self.extra_tiles[1] * self.tile_width[1]) // self.tile_width[1]\\n \\n #x_tile = (x - self.offset[0] * self.tiling_displacement[i][0] - self.x_range[0] + self.extra_tiles[0] * self.tile_width[0]) // self.tile_width[0]\\n #v_tile = (v - self.offset[1] * self.tiling_displacement[i][1] - self.v_range[0] + self.extra_tiles[1] * self.tile_width[1]) // self.tile_width[1]\\n\\n index = int(i * (self.total_tiles[0]*self.total_tiles[1]) + x_tile * self.total_tiles[0] + v_tile)\\n print(\\\"INDEX\\\" , index)\\n state[index] = 1\\n\\n\\n\\n\\n \\\"\\\"\\\"\\n # adds the correct bit (corresponding to the state of the tiling) to the state integer\\n state += 2 ** (i * self.n_tiles**2 + x_tile * self.n_tiles + v_tile)\\n \\\"\\\"\\\"\\n print (\\\"Tiling %s: (%s,%s)\\\" % (i, x_tile, v_tile))\\n\\n return state\",\n \"def forward(self, im1,im2,im3,im4,im5,im6):\\n #edge_index_1 = data[\\\"edge_index_1\\\"]\\n #edge_index_2 = data[\\\"edge_index_2\\\"]\\n #features_1 = data[\\\"features_1\\\"]\\n #features_2 = data[\\\"features_2\\\"]\\n #print(data.shape)\\n im1 = im1.unsqueeze(0)\\n im2 = im2.unsqueeze(0)\\n im3 = im3.unsqueeze(0)\\n im4 = im4.unsqueeze(0)\\n im5 = im5.unsqueeze(0)\\n im6 = im6.unsqueeze(0)\\n f_g_1_1 = self.backbone(im1)\\n f_g_1_2 = self.backbone(im2)\\n f_g_1_3 = self.backbone(im3)\\n f_g_2_1 = self.backbone(im4)\\n f_g_2_2 = self.backbone(im5)\\n f_g_2_3 = self.backbone(im6)\\n edge_index_1 = torch.tensor([[0,0,0,1,1,1,2,2,2],[0,1,2,0,1,2,0,1,2]],dtype=torch.long).cuda()\\n #edge_index_1 = edge_index_1.t().contiguous()\\n edge_index_2 = edge_index_1\\n #print('zz11!', f_g_1_1.shape, f_g_2_3.shape, edge_index_1.shape)\\n features_1 = torch.cat([f_g_1_1,f_g_1_2,f_g_1_3],dim=0)\\n features_2 = torch.cat([f_g_2_1,f_g_2_2,f_g_2_3],dim=0)\\n features_1 = features_1.view(3,-1)\\n features_2 = features_1.view(3,-1)\\n #features_1 = features_1.permute(2,3,1,0)\\n #features_2 = features_2.permute(2,3,1,0)\\n #print(features_1.shape, features_2.shape)\\n #time.sleep(50)\\n abstract_features_1 = self.convolutional_pass(edge_index_1, features_1)\\n abstract_features_2 = self.convolutional_pass(edge_index_2, features_2)\\n #print('alalala')\\n #time.sleep(5)\\n if self.args.histogram == True:\\n hist = self.calculate_histogram(abstract_features_1,\\n torch.t(abstract_features_2))\\n\\n pooled_features_1 = self.attention(abstract_features_1)\\n pooled_features_2 = self.attention(abstract_features_2)\\n scores = self.tensor_network(pooled_features_1, pooled_features_2)\\n scores = torch.t(scores)\\n\\n if self.args.histogram == True:\\n scores = torch.cat((scores, hist), dim=1).view(1, -1)\\n\\n scores = torch.nn.functional.relu(self.fully_connected_first(scores))\\n score = torch.sigmoid(self.scoring_layer(scores))\\n return score\",\n \"def transform_batch(images,\\n max_rot_deg,\\n max_shear_deg,\\n max_zoom_diff_pct,\\n max_shift_pct,\\n experimental_tpu_efficiency=True):\\n\\n def clipped_random():\\n rand = tf.random.normal([1], dtype=tf.float32)\\n rand = tf.clip_by_value(rand, -2., 2.) / 2.\\n return rand\\n\\n batch_size = images.shape[0]\\n tf.debugging.assert_equal(\\n images.shape[1],\\n images.shape[2],\\n \\\"Images should be square\\\")\\n DIM = images.shape[1]\\n channels = images.shape[3]\\n XDIM = DIM % 2\\n\\n rot = max_rot_deg * clipped_random()\\n shr = max_shear_deg * clipped_random() \\n h_zoom = 1.0 + clipped_random()*max_zoom_diff_pct\\n w_zoom = 1.0 + clipped_random()*max_zoom_diff_pct\\n h_shift = clipped_random()*(DIM*max_shift_pct)\\n w_shift = clipped_random()*(DIM*max_shift_pct)\\n\\n # GET TRANSFORMATION MATRIX\\n m = get_mat(rot,shr,h_zoom,w_zoom,h_shift,w_shift) \\n\\n # LIST DESTINATION PIXEL INDICES\\n x = tf.repeat(tf.range(DIM//2,-DIM//2,-1), DIM) # 10000,\\n y = tf.tile(tf.range(-DIM//2,DIM//2),[DIM])\\n z = tf.ones([DIM*DIM],tf.int32)\\n idx = tf.stack( [x,y,z] ) # [3, 10000]\\n\\n # ROTATE DESTINATION PIXELS ONTO ORIGIN PIXELS\\n idx2 = tf.matmul(m,tf.cast(idx,tf.float32))\\n idx2 = tf.cast(idx2,tf.int32)\\n idx2 = tf.clip_by_value(idx2,-DIM//2+XDIM+1,DIM//2)\\n\\n # FIND ORIGIN PIXEL VALUES \\n idx3 = tf.stack( [DIM//2-idx2[0,], DIM//2-1+idx2[1,]] )\\n idx3 = tf.transpose(idx3)\\n batched_idx3 = tf.tile(idx3[tf.newaxis], [batch_size, 1, 1])\\n\\n if experimental_tpu_efficiency:\\n # This reduces excessive padding in the original tf.gather_nd op\\n idx4 = idx3[:, 0] * DIM + idx3[:, 1]\\n images = tf.reshape(images, [batch_size, DIM * DIM, channels])\\n d = tf.gather(images, idx4, axis=1)\\n return tf.reshape(d, [batch_size,DIM,DIM,channels])\\n else:\\n d = tf.gather_nd(images, batched_idx3, batch_dims=1)\\n return tf.reshape(d,[batch_size,DIM,DIM,channels])\",\n \"def mesh_grid(self,width,height):\\n # get\\n \\n x_linspace=tf.linspace(-self.cx_,1-self.cx_,width)\\n y_linspace=tf.linspace(-self.cy_,1-self.cy_,height)\\n \\n# x_cord,y_cord=tf.meshgrid(x_linspace,y_linspace)\\n y_cord,x_cord=tf.meshgrid(y_linspace,x_linspace)\\n \\n \\n x_cord=tf.reshape(x_cord,[-1])\\n y_cord=tf.reshape(y_cord,[-1])\\n \\n f_=tf.ones_like(x_cord)\\n \\n x_=tf.div(x_cord,self.cf)\\n y_=tf.div(y_cord,self.cf)\\n \\n grid=tf.concat([x_,y_,f_],0)\\n return grid\",\n \"def cell_edges(self):\",\n \"def forward(self, input_tensor):\\n last = input_tensor\\n for module in self.projection:\\n projection = module(last)\\n last = torch.cat((last, projection), -1)\\n projection = last\\n\\n intermediate = self.seed(projection)\\n intermediate = intermediate.view((-1, 512, 3, 3))\\n\\n projection_2d = projection.view((-1, self.projection_dim, 1, 1))\\n projection_2d = self.projection_upscaler(projection_2d)\\n\\n for i, (conv, upscaling) in enumerate(zip(self.conv, self.upscaling)):\\n if i + 1 != len(self.upscaling):\\n if i > 0:\\n intermediate = torch.cat((intermediate, projection_2d), 1)\\n intermediate = torch.nn.functional.pixel_shuffle(intermediate, 2)\\n intermediate = conv(intermediate)\\n projection_2d = upscaling(projection_2d)\\n\\n r_space = self.colourspace_r(projection)\\n r_space = r_space.view((-1, 16, 1, 1))\\n r_space = self.colourspace_upscaler(r_space)\\n r_space = intermediate * r_space\\n r_space = torch.sum(r_space, dim=1, keepdim=True)\\n\\n g_space = self.colourspace_g(projection)\\n g_space = g_space.view((-1, 16, 1, 1))\\n g_space = self.colourspace_upscaler(g_space)\\n g_space = intermediate * g_space\\n g_space = torch.sum(g_space, dim=1, keepdim=True)\\n\\n b_space = self.colourspace_b(projection)\\n b_space = b_space.view((-1, 16, 1, 1))\\n b_space = self.colourspace_upscaler(b_space)\\n b_space = intermediate * b_space\\n b_space = torch.sum(b_space, dim=1, keepdim=True)\\n\\n output = torch.cat((r_space, g_space, b_space), dim=1)\\n\\n return output\",\n \"def e_step(votes_ij, activations_j, mean_j, stdv_j, var_j, spatial_routing_matrix):\\n \\n with tf.variable_scope(\\\"e_step\\\") as scope:\\n \\n # AG 26/06/2018: changed stdv_j to var_j\\n o_p_unit0 = - tf.reduce_sum(\\n tf.square(votes_ij - mean_j, name=\\\"num\\\") / (2 * var_j), \\n axis=-1, \\n keepdims=True, \\n name=\\\"o_p_unit0\\\")\\n \\n o_p_unit2 = - 0.5 * tf.reduce_sum(\\n tf.log(2*np.pi * var_j), \\n axis=-1, \\n keepdims=True, \\n name=\\\"o_p_unit2\\\"\\n )\\n\\n # (24, 6, 6, 288, 32, 1)\\n o_p = o_p_unit0 + o_p_unit2\\n zz = tf.log(activations_j + FLAGS.epsilon) + o_p\\n \\n # AG 13/11/2018: New implementation of normalising across parents\\n #----- Start -----#\\n zz_shape = zz.get_shape().as_list()\\n batch_size = zz_shape[0]\\n parent_space = zz_shape[1]\\n kh_kw_i = zz_shape[3]\\n parent_caps = zz_shape[4]\\n kk = int(np.sum(spatial_routing_matrix[:,0]))\\n child_caps = int(kh_kw_i / kk)\\n \\n zz = tf.reshape(zz, [batch_size, parent_space, parent_space, kk, \\n child_caps, parent_caps])\\n \\n \\\"\\\"\\\"\\n # In un-log space\\n with tf.variable_scope(\\\"to_sparse_unlog\\\") as scope:\\n zz_unlog = tf.exp(zz)\\n #zz_sparse_unlog = utl.to_sparse(zz_unlog, spatial_routing_matrix, \\n # sparse_filler=1e-15)\\n zz_sparse_unlog = utl.to_sparse(\\n zz_unlog, \\n spatial_routing_matrix, \\n sparse_filler=0.0)\\n # maybe this value should be even lower 1e-15\\n zz_sparse_log = tf.log(zz_sparse_unlog + 1e-15) \\n zz_sparse = zz_sparse_log\\n \\\"\\\"\\\"\\n\\n \\n # In log space\\n with tf.variable_scope(\\\"to_sparse_log\\\") as scope:\\n # Fill the sparse matrix with the smallest value in zz (at least -100)\\n sparse_filler = tf.minimum(tf.reduce_min(zz), -100)\\n# sparse_filler = -100\\n zz_sparse = utl.to_sparse(\\n zz, \\n spatial_routing_matrix, \\n sparse_filler=sparse_filler)\\n \\n \\n with tf.variable_scope(\\\"softmax_across_parents\\\") as scope:\\n rr_sparse = utl.softmax_across_parents(zz_sparse, spatial_routing_matrix)\\n \\n with tf.variable_scope(\\\"to_dense\\\") as scope:\\n rr_dense = utl.to_dense(rr_sparse, spatial_routing_matrix)\\n \\n rr = tf.reshape(\\n rr_dense, \\n [batch_size, parent_space, parent_space, kh_kw_i, parent_caps, 1])\\n #----- End -----#\\n\\n # AG 02/11/2018\\n # In response to a question on OpenReview, Hinton et al. wrote the \\n # following:\\n # \\\"The gradient flows through EM algorithm. We do not use stop gradient. A \\n # routing of 3 is like a 3 layer network where the weights of layers are \\n # shared.\\\"\\n # https://openreview.net/forum?id=HJWLfGWRb¬eId=S1eo2P1I3Q\\n \\n return rr\",\n \"def arr(img_arr, img_wid, img_hei):\\n X = torch.Tensor(img_arr).view(-1, 1, img_wid, img_hei)\\n X = X/255.0\\n return X\",\n \"def generative_model(self):\\n activation = tf.nn.relu\\n if self.linear:\\n activation = None\\n\\n # p(x | z, s)\\n if self.batch is not None:\\n h = tf.concat([self.z, self.batch], 1)\\n else:\\n h = self.z\\n \\n #h = dense(h, self.n_hidden,\\n # activation=tf.nn.relu, bn=True, keep_prob=self.dropout_rate, phase=self.training_phase)\\n h = dense(h, self.n_hidden,\\n activation=activation, bn=True, keep_prob=None, phase=self.training_phase)\\n \\n for layer in range(2, self.n_layers + 1):\\n if self.batch is not None:\\n h = tf.concat([h, self.batch], 1)\\n h = dense(h, self.n_hidden, activation=activation, \\\\\\n bn=True, keep_prob=self.dropout_rate, phase=self.training_phase)\\n\\n if self.batch is not None:\\n h = tf.concat([h, self.batch], 1) \\n \\n #mean gamma\\n self.px_scale = dense(h, self.n_input, activation=tf.nn.softmax, \\\\\\n bn=False, keep_prob=None, phase=self.training_phase)\\n \\n #dispersion\\n if self.dispersion == \\\"gene-cell\\\":\\n self.px_r = dense(h, self.n_input, activation=None, \\\\\\n bn=False, keep_prob=None, phase=self.training_phase)\\n elif self.dispersion == \\\"gene\\\":\\n self.px_r = tf.Variable(tf.random_normal([self.n_input]), name=\\\"r\\\")\\n else:\\n if self.dispersion is False:\\n self.px_r = tf.ones([self.n_input])\\n else:\\n if self.batch_ind is None:\\n raise ValueError(\\\"batch dispersion with no batch info\\\")\\n else:\\n self.px_r = tf.Variable(tf.random_normal([self.num_batches, self.n_input]), name=\\\"r\\\")\\n\\n \\n #mean poisson\\n self.px_rate = self.px_scale \\n if self.scalings:\\n self.px_rate = self.px_scale * tf.exp(self.library)\\n\\n #dropout\\n if self.zi:\\n self.px_dropout = dense(h, self.n_input, activation=None, \\\\\\n bn=False, keep_prob=None, phase=self.training_phase)\",\n \"def one_hot(indices, depth):\\n # print(indices)\\n encoded_indices = torch.zeros(indices.size() + torch.Size([depth])).cuda()\\n index = indices.view(indices.size()+torch.Size([1]))\\n encoded_indices = encoded_indices.scatter_(1,index,1)\\n \\n return encoded_indices\",\n \"def squeeze_batch_dim(nest: types.NestedTensor) -> types.NestedTensor:\\n return tree.map_structure(lambda x: tf.squeeze(x, axis=0), nest)\",\n \"def affine_grid_generator(height,width,theta):\\n num_batch = tf.shape(theta)[0]\\n \\n x = tf.linspace(-1.,1.,width)\\n y = tf.linspace(-1.,1.,height)\\n x_t,y_t = tf.meshgrid(x,y)\\n\\n #flatten\\n x_t_flat = tf.reshape(x_t,[-1])\\n y_t_flat = tf.reshape(y_t,[-1])\\n\\n #reshape to [x_t,y_t,1] \\n ones = tf.ones_like(x_t_flat)\\n sampling_grid = tf.stack([x_t_flat,y_t_flat,ones])\\n\\n # repeat grid num_batch times\\n sampling_grid = tf.expand_dims(sampling_grid,axis=0)\\n sampling_grid = tf.tile(sampling_grid,[num_batch,1,1])\\n\\n # cast to float32 \\n theta = tf.cast(theta,'float32')\\n sampling_grid = tf.cast(sampling_grid,'float32')\\n\\n # transform the sampling grid\\n batch_grids = tf.matmul(theta,sampling_grid)\\n\\n # reshape to (num_batch,H,W,2)\\n batch_grids = tf.reshape(batch_grids,[num_batch,2,height,width])\\n\\n return batch_grids\",\n \"def test_flatten3D():\\n with tf.Session().as_default():\\n tensor2d = tf.constant([[1, 2, 3]], dtype=tf.float32)\\n with pytest.raises(AssertionError):\\n output = flatten3D(tensor2d)\\n\\n tensor3d = tf.constant([[[1, 2, 3]]], dtype=tf.float32)\\n assert tensor3d == flatten3D(tensor3d)\\n\\n init_shape = (3, 17, 23, 3, 5)\\n expected_shape = (3, 17, 23*3*5)\\n\\n tensor5d = tf.constant(np.arange(0, np.prod(init_shape)).reshape(init_shape), tf.int32)\\n assert tensor5d.eval().shape == init_shape\\n output = flatten3D(tensor5d)\\n assert output.eval().shape == expected_shape\",\n \"def tiled_images(self, name, tensor, data_format='channels_last', **kwargs):\\r\\n with tf.name_scope('viz_featuremaps'):\\r\\n if data_format == 'channels_first':\\r\\n # N x C x H x W\\r\\n tensor = tf.transpose(tensor, perm=(0, 2, 3, 1))\\r\\n # N x H x W x C\\r\\n tensor = tf.transpose(tensor, perm=(1, 2, 3, 0))\\r\\n # H x W x C x N\\r\\n self._4d_tensor(name, tensor, **kwargs)\",\n \"def f() -> None:\\n x = torch.rand(7, 3).to(self.device)\\n kernel = ScaleKernel(MaternKernel())\\n allocator = GreedyVarianceReduction()\\n allocator.allocate_inducing_points(x, kernel, 4, x.shape[:-2])\",\n \"def __init__(self, in_dimension, layer_1d, layer_2d, layer_3d, categorical_dimension, latent_dimension):\\n super(VAEEncoderGumbel, self).__init__()\\n self.latent_dimension = latent_dimension\\n self.categorical_dimension = categorical_dimension\\n\\n # Reduce dimension up to second last layer of Encoder\\n self.encode_nn = nn.Sequential(\\n nn.Linear(in_dimension, layer_1d),\\n nn.ReLU(),\\n nn.Linear(layer_1d, layer_2d),\\n nn.ReLU(),\\n nn.Linear(layer_2d, layer_3d),\\n nn.ReLU(),\\n nn.Linear(layer_3d, latent_dimension*categorical_dimension),\\n nn.ReLU()\\n )\",\n \"def add_batch_dim(nest: types.NestedArray) -> types.NestedTensor:\\n return tree.map_structure(lambda x: tf.expand_dims(x, axis=0), nest)\",\n \"def _build_batch_transformer(self, input_tensor):\\n\\n self._dual.set_op('bt_input', input_tensor)\\n\\n # get hyper params\\n sample_repeat = self._hparams.bt_sample_repeat\\n blank_repeat = self._hparams.bt_blank_repeat\\n presentation_repeat = self._hparams.bt_presentation_repeat\\n is_degrade = self._hparams.bt_degrade\\n degrade_repeat = self._hparams.bt_degrade_repeat\\n degrade_type = self._hparams.bt_degrade_type\\n degrade_value = self._hparams.bt_degrade_value\\n degrade_factor = self._hparams.bt_degrade_factor\\n\\n # note: x_batch = input batch, y_batch = transformed batch\\n\\n with tf.variable_scope('batch_transformer'):\\n\\n # convert input to shape [batch, samples]\\n input_shape = input_tensor.get_shape().as_list()\\n input_area = np.prod(input_shape[1:])\\n batch_input_shape = (-1, input_area)\\n\\n input_vector = tf.reshape(input_tensor, batch_input_shape, name='input_vector')\\n logging.debug(input_vector)\\n\\n x_batch_length = input_shape[0]\\n y_batch_length = presentation_repeat * x_batch_length * (sample_repeat + blank_repeat) + \\\\\\n (1 + degrade_repeat if is_degrade else 0)\\n\\n self._blank_indices = []\\n for p in range(presentation_repeat):\\n start_pres = p * x_batch_length * (sample_repeat + blank_repeat)\\n for s in range(x_batch_length):\\n blank_start = start_pres + s*(sample_repeat+blank_repeat) + sample_repeat\\n self._blank_indices.append([blank_start, blank_start + blank_repeat-1])\\n\\n # start with all blanks, in this case zero tensors\\n y_batch = tf.get_variable(initializer=tf.zeros(shape=[y_batch_length, input_area]),\\n trainable=False,\\n name='blanks')\\n\\n # use scatter updates to fill with repeats, can not do 1-to-many, so need to do it\\n # `pres_repeat * sample_repeat` times\\n presentation_length = x_batch_length * (sample_repeat + blank_repeat)\\n for p in range(presentation_repeat):\\n\\n input_vector = tf.random_shuffle(input_vector)\\n\\n for i in range(sample_repeat):\\n x2y = [] # the idx itself is the x_idx, val = y_idx\\n for x_idx in range(x_batch_length):\\n y_idx = (p * presentation_length) + x_idx * (sample_repeat + blank_repeat) + i\\n x2y.append(y_idx)\\n xy_scatter_map = tf.constant(value=x2y, name='x_y_scatter_' + str(i))\\n y_batch = tf.scatter_update(y_batch, xy_scatter_map, input_vector, name=\\\"sample_repeat\\\")\\n\\n # append degraded and non-degraded samples\\n if is_degrade:\\n # randomly choose one of the input vectors\\n input_shuffled = tf.random_shuffle(input_vector)\\n target = input_shuffled[0]\\n\\n if degrade_type == 'horizontal':\\n degraded = image_utils.degrade_image(input_shuffled, label=None, degrade_type='horizontal',\\n degrade_value=degrade_value)[0]\\n elif degrade_type == 'vertical':\\n raise NotImplementedError('vertical degradation not implemented')\\n elif degrade_type == 'random':\\n\\n # This next commented out line, caused major malfunction (result was passed to degrade in place of the whole batch - but i have no idea why)\\n # degraded_samples = tf.reshape(target, batch_input_shape) # for efficiency, only degrade one image\\n\\n min_value_0 = True\\n if min_value_0 is not True:\\n degraded = image_utils.degrade_image(image=input_shuffled, label=None, degrade_type='random',\\n degrade_value=degrade_value,\\n degrade_factor=degrade_factor)[0]\\n else:\\n # degrade the high bits (not the bits that are already zero)\\n eps = 0.01\\n degrade_mask = tf.greater(target, 1.0 - eps)\\n degrade_mask = tf.to_float(degrade_mask)\\n degrade_mask = tf_print(degrade_mask, \\\"degrade_mask\\\", mute=True)\\n\\n degraded = tf_utils.degrade_by_mask(input_tensor=input_shuffled,\\n num_active=self._active_bits,\\n degrade_mask=degrade_mask,\\n degrade_factor=degrade_factor,\\n degrade_value=degrade_value)[0]\\n\\n else:\\n raise NotImplementedError('Unknown degradation type.')\\n\\n degraded_repeated = tf.ones([degrade_repeat, input_area])\\n degraded_repeated = degraded_repeated * degraded\\n\\n target = tf.reshape(target, [1, input_area])\\n degraded_and_target = tf.concat([degraded_repeated, target], 0)\\n\\n index_map = []\\n for i in range(degrade_repeat+1):\\n index_map.insert(0, y_batch_length - 1 - i)\\n\\n y_batch = tf.scatter_update(y_batch, tf.constant(index_map), degraded_and_target, name=\\\"degradetarget\\\")\\n y_batch = tf.stop_gradient(y_batch)\\n\\n self._dual.set_op('bt_output', y_batch)\\n return y_batch\",\n \"def generator(z):\\n with tf.variable_scope(\\\"generator\\\"):\\n img = tf.layers.dense(z,4*4*512,activation=tf.nn.relu,use_bias=True)\\n img = tf.layers.batch_normalization(img,axis=1,training=True)\\n img = tf.reshape(img,[-1,4,4,512])\\n print(img.shape)\\n img = tf.layers.conv2d_transpose(img,256,kernel_size=5,strides=2,activation=tf.nn.relu,padding='same')\\n print(img.shape)\\n img = tf.layers.batch_normalization(img,3,training=True)\\n img = tf.layers.conv2d_transpose(img,128,kernel_size=5,strides=2,activation=tf.nn.relu,padding='same')\\n print(img.shape)\\n img = tf.layers.batch_normalization(img,3,training=True)\\n img = tf.layers.conv2d_transpose(img,3,kernel_size=5,strides=2,activation=tf.nn.tanh,padding='same')\\n print(img.shape)\\n return img\",\n \"def get_equation_matrix(obj_dict, node_dict):\\n\\n v_src_count = len(obj_dict['V'])\\n v_src_map = {}\\n for ind in range(len(obj_dict['V'])):\\n v_src_map[obj_dict['V'][ind].name] = ind \\n \\n node_count = len(node_dict.keys())-1 # excluded GND\\n \\n A = np.zeros((node_count, node_count), dtype='complex') # top left quad\\n B = np.zeros((node_count, v_src_count), dtype='complex') # top right quad\\n aux = np.zeros((v_src_count, node_count), dtype='complex') # bottom left quad\\n zero_quad = np.zeros((v_src_count,v_src_count), dtype='complex') # bottom right quad\\n const_vec_nodes = np.zeros((node_count), dtype='complex')\\n const_vec_aux = np.zeros((v_src_count), dtype='complex')\\n\\n for k in obj_dict.keys():\\n lst = obj_dict[k]\\n for obj in lst:\\n n1 = node_dict[obj.n1]-1\\n n2 = node_dict[obj.n2]-1\\n value = obj.value\\n\\n if obj.el_type in 'RLC':\\n if obj.imp == None: # dc\\n if obj.el_type == 'L':\\n value = EPS\\n elif obj.el_type == 'C':\\n value = INF\\n else:\\n value = obj.imp + EPS\\n\\n if n1 != -1 and n2 != -1:\\n A[n1,n1] += 1/value\\n A[n1,n2] += -1/value\\n A[n2,n1] += -1/value\\n A[n2,n2] += 1/value\\n\\n elif n1 == -1:\\n A[n2,n2] += 1/value\\n\\n elif n2 == -1:\\n A[n1,n1] += 1/value\\n\\n elif obj.el_type == 'V':\\n nv = v_src_map[obj.name]\\n if n1 != -1 and n2 != -1:\\n B[n1,nv] += 1\\n B[n2,nv] += -1\\n aux[nv,n1] += 1\\n aux[nv,n2] += -1\\n \\n elif n1 == -1:\\n B[n2,nv] += -1\\n aux[nv,n2] += -1\\n \\n elif n2 == -1:\\n B[n1,nv] += 1\\n aux[nv,n1] += 1\\n\\n const_vec_aux[nv] += value\\n\\n elif obj.el_type == 'I':\\n if n1 != -1 and n2 != -1:\\n const_vec_nodes[n1] += obj.value\\n const_vec_nodes[n2] += -obj.value\\n elif n1 == -1:\\n const_vec_nodes[n2] += -obj.value\\n elif n2 == -1:\\n const_vec_nodes[n1] += obj.value\\n\\n elif obj.el_type in 'EGHF':\\n print(\\\"ERR: Controlled sources not supported yet\\\")\\n return None\\n\\n top_half = np.concatenate((A, B), axis=1) \\n bot_half = np.concatenate((aux, zero_quad), axis=1)\\n coeff_mat = np.concatenate((top_half, bot_half), axis=0)\\n const_vec = np.concatenate((const_vec_nodes, const_vec_aux), axis=0)\\n\\n return [coeff_mat, const_vec]\",\n \"def prepare_emb(self):\\n with tf.variable_scope(\\\"PrepEmb\\\", reuse=tf.AUTO_REUSE):\\n self.src_ten = tf.cast(tf.convert_to_tensor(self.src_ten), tf.float32)\\n self.tgt_ten = tf.cast(tf.convert_to_tensor(self.tgt_ten), tf.float32)\\n # Mapping\\n self.src_ten = tf.matmul(self.src_ten, self.W)\\n # Normalization\\n self.src_ten = tf.nn.l2_normalize(self.src_ten, axis=1)\\n self.tgt_ten = tf.nn.l2_normalize(self.tgt_ten, axis=1)\",\n \"def transform_seg_gt(gt):\\n gt_tensor = np.zeros((1, 1, gt.shape[0], gt.shape[1]))\\n gt_tensor[0, 0, :, :] = gt[:, :]\\n\\n return gt_tensor\",\n \"def vae_decoder(self):\\n return stax.serial(\\n stax.Dense(self.hidden_dims[1], W_init=stax.randn()),\\n stax.Relu,\\n stax.Dense(self.hidden_dims[0], W_init=stax.randn()),\\n stax.Relu,\\n stax.Dense(self.out_dim, W_init=stax.randn()),\\n stax.exp\\n )\",\n \"def apply_dof_transformation_hexahedron(\\n entity_transformations, entity_dofs, data, cell_info\\n):\\n apply_dof_transformation(3, 12, 6, entity_transformations, entity_dofs,\\n data, cell_info, List([\\\"quadrilateral\\\"] * 6))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.645886","0.56280047","0.55941963","0.55898535","0.55519897","0.55153","0.54828554","0.5457415","0.5443727","0.5424891","0.5404391","0.53744656","0.53711516","0.53519404","0.5349043","0.53421223","0.53419113","0.53325886","0.53046644","0.5291646","0.5277062","0.52700454","0.5250719","0.5247169","0.52125","0.52117336","0.520233","0.52021706","0.51987505","0.5197735","0.5191076","0.51789767","0.5172257","0.51715606","0.5170034","0.5156259","0.51499003","0.51089644","0.5108047","0.51035994","0.50997037","0.50734633","0.5072029","0.50715446","0.5070792","0.5058071","0.50569236","0.5055637","0.50505656","0.50415695","0.50398797","0.5031205","0.50229037","0.50228584","0.5022462","0.50198466","0.50151265","0.5013682","0.5010134","0.50076765","0.5004739","0.50029045","0.49988914","0.49988914","0.49983722","0.49912256","0.49859086","0.49772546","0.49735856","0.49668342","0.4966348","0.49652138","0.49644652","0.49627823","0.49616638","0.49610445","0.49470118","0.4945412","0.49425635","0.4935394","0.4931293","0.4928665","0.49244773","0.49243787","0.49240765","0.49222142","0.4921653","0.49176097","0.49141076","0.4912479","0.49112153","0.49078125","0.4905216","0.4903675","0.49016672","0.4895384","0.48953587","0.48897055","0.488882","0.48867553","0.48776117"],"string":"[\n \"0.645886\",\n \"0.56280047\",\n \"0.55941963\",\n \"0.55898535\",\n \"0.55519897\",\n \"0.55153\",\n \"0.54828554\",\n \"0.5457415\",\n \"0.5443727\",\n \"0.5424891\",\n \"0.5404391\",\n \"0.53744656\",\n \"0.53711516\",\n \"0.53519404\",\n \"0.5349043\",\n \"0.53421223\",\n \"0.53419113\",\n \"0.53325886\",\n \"0.53046644\",\n \"0.5291646\",\n \"0.5277062\",\n \"0.52700454\",\n \"0.5250719\",\n \"0.5247169\",\n \"0.52125\",\n \"0.52117336\",\n \"0.520233\",\n \"0.52021706\",\n \"0.51987505\",\n \"0.5197735\",\n \"0.5191076\",\n \"0.51789767\",\n \"0.5172257\",\n \"0.51715606\",\n \"0.5170034\",\n \"0.5156259\",\n \"0.51499003\",\n \"0.51089644\",\n \"0.5108047\",\n \"0.51035994\",\n \"0.50997037\",\n \"0.50734633\",\n \"0.5072029\",\n \"0.50715446\",\n \"0.5070792\",\n \"0.5058071\",\n \"0.50569236\",\n \"0.5055637\",\n \"0.50505656\",\n \"0.50415695\",\n \"0.50398797\",\n \"0.5031205\",\n \"0.50229037\",\n \"0.50228584\",\n \"0.5022462\",\n \"0.50198466\",\n \"0.50151265\",\n \"0.5013682\",\n \"0.5010134\",\n \"0.50076765\",\n \"0.5004739\",\n \"0.50029045\",\n \"0.49988914\",\n \"0.49988914\",\n \"0.49983722\",\n \"0.49912256\",\n \"0.49859086\",\n \"0.49772546\",\n \"0.49735856\",\n \"0.49668342\",\n \"0.4966348\",\n \"0.49652138\",\n \"0.49644652\",\n \"0.49627823\",\n \"0.49616638\",\n \"0.49610445\",\n \"0.49470118\",\n \"0.4945412\",\n \"0.49425635\",\n \"0.4935394\",\n \"0.4931293\",\n \"0.4928665\",\n \"0.49244773\",\n \"0.49243787\",\n \"0.49240765\",\n \"0.49222142\",\n \"0.4921653\",\n \"0.49176097\",\n \"0.49141076\",\n \"0.4912479\",\n \"0.49112153\",\n \"0.49078125\",\n \"0.4905216\",\n \"0.4903675\",\n \"0.49016672\",\n \"0.4895384\",\n \"0.48953587\",\n \"0.48897055\",\n \"0.488882\",\n \"0.48867553\",\n \"0.48776117\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94479,"cells":{"query":{"kind":"string","value":"Populates 6x6 elastic tensor for cubic crystals"},"document":{"kind":"string","value":"def cubeCij(c11, c13, c44):\n C = np.zeros(shape=(6, 6))\n C[0, 0] = C[1, 1] = C[2, 2] = c11\n C[0, 1] = C[0, 2] = C[1, 0] = C[1, 2] = C[2, 0] = C[2, 1] = c13\n C[3, 3] = C[4, 4] = C[5, 5] = c44\n S = np.linalg.inv(C)\n return {\"C\": C, \"S\": S}"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_sc(self):\n sc = []\n a = np.array([1, 0, 0], dtype=np.float32)\n b = np.array([0, 1, 0], dtype=np.float32)\n c = np.array([0, 0, 1], dtype=np.float32)\n # order z -> y -> x\n for i, j, k in itertools.product(*itertools.repeat(range(-(self.nsc//2),self.nsc//2+1), 3)):\n sc.append(i*a + j*b + k*c)\n sc = np.stack(sc, axis=0)\n #print(sc.shape)\n\n with tf.variable_scope(\"supercell\"):\n sc = tf.constant(sc, dtype=tf.float32)\n return sc","def cubic_evolve(self,nt=1):\n #loop through time steps\n for l in range(nt):\n # temporary array\n y_temp = np.zeros(self.y.shape[0])\n # loop through array\n for i in range(self.y.shape[0]):\n # idx left to departure point\n x_dep = self.x[i]-self.u[i]*self.dt\n j = int(np.floor(x_dep/self.dx))\n # alpha\n a = (self.x[i]-self.u[i]*self.dt - j*self.dx)/self.dx\n # calculate next time step\n f = lambda x: x % self.y.shape[0] if x >= self.y.shape[0] else x\n y_temp[i] = - a * (1-a)*(2-a)/6 * self.y[f(j-1)]\n y_temp[i] += (1-a**2)*(2-a)/2 * self.y[f(j)]\n y_temp[i] += a*(1+a)*(2-a)/2 * self.y[f(j+1)]\n y_temp[i] -= a*(1-a**2)/6 * self.y[f(j+2)]\n self.y = np.copy(y_temp)\n return self.y","def Cijkl(C):\n c = np.zeros(shape=(3, 3, 3, 3))\n CC = np.zeros(shape=(9, 9))\n CC[0:6, 0:6] = C[0:6, 0:6]\n CC[6:9, 6:9] = C[3:6, 3:6]\n CC[0:6, 6:9] = C[0:6, 3:6]\n CC[6:9, 0:6] = C[3:6, 0:6]\n\n c[0, 0, 0, 0] = CC[0, 0]\n c[0, 0, 1, 1] = CC[0, 1]\n c[0, 0, 2, 2] = CC[0, 2]\n c[0, 0, 1, 2] = CC[0, 3]\n c[0, 0, 2, 0] = CC[0, 4]\n c[0, 0, 0, 1] = CC[0, 5]\n c[0, 0, 2, 1] = CC[0, 6]\n c[0, 0, 0, 2] = CC[0, 7]\n c[0, 0, 1, 0] = CC[0, 8]\n\n c[1, 1, 0, 0] = CC[1, 0]\n c[1, 1, 1, 1] = CC[1, 1]\n c[1, 1, 2, 2] = CC[1, 2]\n c[1, 1, 1, 2] = CC[1, 3]\n c[1, 1, 2, 0] = CC[1, 4]\n c[1, 1, 0, 1] = CC[1, 5]\n c[1, 1, 2, 1] = CC[1, 6]\n c[1, 1, 0, 2] = CC[1, 7]\n c[1, 1, 1, 0] = CC[1, 8]\n\n c[2, 2, 0, 0] = CC[2, 0]\n c[2, 2, 1, 1] = CC[2, 1]\n c[2, 2, 2, 2] = CC[2, 2]\n c[2, 2, 1, 2] = CC[2, 3]\n c[2, 2, 2, 0] = CC[2, 4]\n c[2, 2, 0, 1] = CC[2, 5]\n c[2, 2, 2, 1] = CC[2, 6]\n c[2, 2, 0, 2] = CC[2, 7]\n c[2, 2, 1, 0] = CC[2, 8]\n\n c[1, 2, 0, 0] = CC[3, 0]\n c[1, 2, 1, 1] = CC[3, 1]\n c[1, 2, 2, 2] = CC[3, 2]\n c[1, 2, 1, 2] = CC[3, 3]\n c[1, 2, 2, 0] = CC[3, 4]\n c[1, 2, 0, 1] = CC[3, 5]\n c[1, 2, 2, 1] = CC[3, 6]\n c[1, 2, 0, 2] = CC[3, 7]\n c[1, 2, 1, 0] = CC[3, 8]\n\n c[2, 0, 0, 0] = CC[4, 0]\n c[2, 0, 1, 1] = CC[4, 1]\n c[2, 0, 2, 2] = CC[4, 2]\n c[2, 0, 1, 2] = CC[4, 3]\n c[2, 0, 2, 0] = CC[4, 4]\n c[2, 0, 0, 1] = CC[4, 5]\n c[2, 0, 2, 1] = CC[4, 6]\n c[2, 0, 0, 2] = CC[4, 7]\n c[2, 0, 1, 0] = CC[4, 8]\n\n c[0, 1, 0, 0] = CC[5, 0]\n c[0, 1, 1, 1] = CC[5, 1]\n c[0, 1, 2, 2] = CC[5, 2]\n c[0, 1, 1, 2] = CC[5, 3]\n c[0, 1, 2, 0] = CC[5, 4]\n c[0, 1, 0, 1] = CC[5, 5]\n c[0, 1, 2, 1] = CC[5, 6]\n c[0, 1, 0, 2] = CC[5, 7]\n c[0, 1, 1, 0] = CC[5, 8]\n\n c[2, 1, 0, 0] = CC[6, 0]\n c[2, 1, 1, 1] = CC[6, 1]\n c[2, 1, 2, 2] = CC[6, 2]\n c[2, 1, 1, 2] = CC[6, 3]\n c[2, 1, 2, 0] = CC[6, 4]\n c[2, 1, 0, 1] = CC[6, 5]\n c[2, 1, 2, 1] = CC[6, 6]\n c[2, 1, 0, 2] = CC[6, 7]\n c[2, 1, 1, 0] = CC[6, 8]\n\n c[0, 2, 0, 0] = CC[7, 0]\n c[0, 2, 1, 1] = CC[7, 1]\n c[0, 2, 2, 2] = CC[7, 2]\n c[0, 2, 1, 2] = CC[7, 3]\n c[0, 2, 2, 0] = CC[7, 4]\n c[0, 2, 0, 1] = CC[7, 5]\n c[0, 2, 2, 1] = CC[7, 6]\n c[0, 2, 0, 2] = CC[7, 7]\n c[0, 2, 1, 0] = CC[7, 8]\n\n c[1, 0, 0, 0] = CC[8, 0]\n c[1, 0, 1, 1] = CC[8, 1]\n c[1, 0, 2, 2] = CC[8, 2]\n c[1, 0, 1, 2] = CC[8, 3]\n c[1, 0, 2, 0] = CC[8, 4]\n c[1, 0, 0, 1] = CC[8, 5]\n c[1, 0, 2, 1] = CC[8, 6]\n c[1, 0, 0, 2] = CC[8, 7]\n c[1, 0, 1, 0] = CC[8, 8]\n return c","def construct_basis_tensors(self):\n\t\n\tu = np.array([self.cth*self.cphi, self.cth*self.sphi, -self.sth])\n\tv = np.array([self.sphi, -self.cphi, 0.0])\n\n\tep = np.outer(u,u) - np.outer(v,v)\n\tec = np.outer(u,v) + np.outer(v,u)\n\t\n\tself.ep = self.c2psi*ep - self.s2psi*ec\n\tself.ec = self.s2psi*ep + self.c2psi*ec\n\t\t\n\treturn","def _C(self):\n\n # Find the local x and y coordinates at each node\n xi = 0\n yi = 0\n xj = self.width()\n yj = 0\n xm = xj\n ym = self.height()\n xn = 0\n yn = ym\n\n # Calculate the [C] coefficient matrix\n C = array([[1, xi, yi, xi**2, xi*yi, yi**2, xi**3, xi**2*yi, xi*yi**2, yi**3, xi**3*yi, xi*yi**3],\n [0, 0, 1, 0, xi, 2*yi, 0, xi**2, 2*xi*yi, 3*yi**2, xi**3, 3*xi*yi**2],\n [0, -1, 0, -2*xi, -yi, 0, -3*xi**2, -2*xi*yi, -yi**2, 0, -3*xi**2*yi, -yi**3],\n \n [1, xj, yj, xj**2, xj*yj, yj**2, xj**3, xj**2*yj, xj*yj**2, yj**3, xj**3*yj, xj*yj**3],\n [0, 0, 1, 0, xj, 2*yj, 0, xj**2, 2*xj*yj, 3*yj**2, xj**3, 3*xj*yj**2],\n [0, -1, 0, -2*xj, -yj, 0, -3*xj**2, -2*xj*yj, -yj**2, 0, -3*xj**2*yj, -yj**3],\n\n [1, xm, ym, xm**2, xm*ym, ym**2, xm**3, xm**2*ym, xm*ym**2, ym**3, xm**3*ym, xm*ym**3],\n [0, 0, 1, 0, xm, 2*ym, 0, xm**2, 2*xm*ym, 3*ym**2, xm**3, 3*xm*ym**2],\n [0, -1, 0, -2*xm, -ym, 0, -3*xm**2, -2*xm*ym, -ym**2, 0, -3*xm**2*ym, -ym**3],\n\n [1, xn, yn, xn**2, xn*yn, yn**2, xn**3, xn**2*yn, xn*yn**2, yn**3, xn**3*yn, xn*yn**3],\n [0, 0, 1, 0, xn, 2*yn, 0, xn**2, 2*xn*yn, 3*yn**2, xn**3, 3*xn*yn**2],\n [0, -1, 0, -2*xn, -yn, 0, -3*xn**2, -2*xn*yn, -yn**2, 0, -3*xn**2*yn, -yn**3]])\n \n # Return the coefficient matrix\n return C","def construct_linear_system(self):\n N=self.grid.Ncells()\n Nbc = len(self.dirichlet_bcs)\n self.Ncalc=Ncalc = N - Nbc\n\n # map cells to forced values\n dirichlet = dict( [ (c,v) for c,v,xy in self.dirichlet_bcs])\n\n self.is_calc_c = is_calc_c = np.ones(N,np.bool8)\n for c,v,xy in self.dirichlet_bcs:\n is_calc_c[c] = False\n\n # is_calc_c[self.c_mask] = False\n\n # c_map is indexed by real cell indices, and returns the matrix index\n c_map = self.c_map = np.zeros(N,np.int32)\n self.c_map[is_calc_c] = np.arange(Ncalc)\n\n dzc=self.dzc\n dzf=self.dzf\n area_c=self.area_c\n\n meth='coo' # 'dok'\n if meth == 'dok':\n A=sparse.dok_matrix((Ncalc,Ncalc),np.float64)\n else:\n # construct the matrix from a sequence of indices and values\n ij=[]\n values=[] # successive value for the same i.j will be summed\n \n b = np.zeros(Ncalc,np.float64)\n flux_per_gradient_j = -self.K_j * self.l_j * dzf / self.d_j * self.dt\n\n self.grid.edge_to_cells() # makes sure that edges['cells'] exists.\n \n for j in range(self.grid.Nedges()):\n e = self.grid.edges[j]\n ic1,ic2 = e['cells']\n \n if ic1<0 or ic2<0 or e['deleted']:\n continue # boundary edge, or deleted edge\n \n flux_per_gradient=flux_per_gradient_j[j]\n \n # this is the desired operation:\n # Cdiff[ic1] -= flux_per_gradient / (An[ic1]*dzc) * (C[ic2] - C[ic1])\n # Cdiff[ic2] += flux_per_gradient / (An[ic2]*dzc) * (C[ic2] - C[ic1])\n # Where Cdiff is row, C is col\n\n if is_calc_c[ic1] and is_calc_c[ic2]:\n mic2 = c_map[ic2]\n mic1 = c_map[ic1]\n v1=flux_per_gradient / (area_c[ic1]*dzc[ic1])\n v2=flux_per_gradient / (area_c[ic2]*dzc[ic2])\n \n if meth == 'dok':\n A[mic1,mic2] -= v1\n A[mic1,mic1] += v1\n A[mic2,mic2] += v2\n A[mic2,mic1] -= v2\n else:\n ij.append( (mic1,mic2) ) ; values.append(-v1)\n ij.append( (mic1,mic1) ) ; values.append(v1)\n ij.append( (mic2,mic2) ) ; values.append(v1)\n ij.append( (mic2,mic1) ) ; values.append(-v1)\n \n elif not ( is_calc_c[ic1] or is_calc_c[ic2] ):\n # both are dirichlet, so nothing to do\n pass\n elif not is_calc_c[ic2]:\n mic1 = c_map[ic1]\n v=flux_per_gradient / (self.area_c[ic1]*dzc[ic1])\n if meth == 'dok':\n A[mic1,mic1] += v\n else:\n ij.append( (mic1,mic1) )\n values.append(v)\n\n # roughly\n # A[1,1]*x[1] + A[1,2]*x[2] + ... = b[1]\n # but we already know x[2],\n # A[1,1]*x[1] + ... = b[1] - A[1,2]*x[2]\n # so flip the sign, multiply by known dirichlet value, and\n # add to the RHS\n b[mic1] += flux_per_gradient / (area_c[ic1]*dzc[ic1]) * dirichlet[ic2]\n else: # not is_calc_c[c1]\n mic2 = c_map[ic2]\n # A[mic2,mic2] += flux_per_gradient / (area_c[ic2]*dzc[ic2])\n # A[mic2,mic1] -= flux_per_gradient / (area_c[ic2]*dzc[ic2])\n\n # A[mic2,mic2]*x[2] + A[mic2,mic1]*x[1] = b[2]\n # ...\n # A[mic2,mic2]*x[2] - flux_per_gradient / (area_c[ic2]*dzc[ic2])*x[1] = b[2]\n # ...\n # A[mic2,mic2]*x[2] = b[2] + flux_per_gradient / (area_c[ic2]*dzc[ic2])*x[1]\n v=flux_per_gradient / (area_c[ic2]*dzc[ic2])\n if meth == 'dok':\n A[mic2,mic2] += v\n else:\n ij.append( (mic2,mic2) )\n values.append(v)\n b[mic2] += flux_per_gradient / (area_c[ic2]*dzc[ic2]) * dirichlet[ic1]\n\n # Used to test 'is not 0:' but modern python complains\n if isinstance(self.alpha,np.ndarray): \n for c in range(N):\n if self.is_calc_c[c]:\n mic=self.c_map[c]\n v=self.alpha[c]*self.dt\n if meth == 'dok':\n A[mic,mic] -= v\n else:\n ij.append( (mic,mic) )\n values.append(-v)\n\n # Flux boundary conditions:\n for ic,value,xy in self.neumann_bcs:\n mic=c_map[ic]\n # make mass/time into concentration/step\n # arrived at minus sign by trial and error.\n # 2023-08-04: there was a bug here that used ic2 instead of ic.\n b[mic] -= value/(area_c[ic]*dzc[ic]) * self.dt\n\n if meth == 'dok':\n self.A = sparse.coo_matrix(A)\n else:\n ijs=np.array(ij,dtype=np.int32)\n data=np.array(values,dtype=np.float64)\n A=sparse.coo_matrix( (data, (ijs[:,0],ijs[:,1]) ), shape=(Ncalc,Ncalc) )\n self.A=A\n \n # report scale to get a sense of whether dt is too large\n Ascale = A.diagonal().min()\n log.debug(\"Ascale is %s\"%Ascale)\n\n self.b = b","def cell_cnc_tracker(Out, U, V, W, t, cell0, cellG, cellD, SHP, cryoconite_locations):\n\n Cells = np.random.rand(len(t),SHP[0],SHP[1],SHP[2]) * cell0\n CellD = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellD\n CellG = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellG\n \n \n for i in np.arange(0,SHP[0],1):\n CellG[i,:,:] = np.where(cryoconite_locations==True, CellG[i,:,:]*1000, CellG[i,:,:])\n \n for t in np.arange(0,len(Out.Qz[:,0,0,0]),1):\n \n for layer in np.arange(0,len(Out.Qz[0,:,0,0]),1):\n\n # normalise lateral flow so that -ve= flow out of cells towards edges\n # and positive flow is towards centre line. In Qx -ve = leftwards flow\n # and +ve = rightwards flow. This leads to a rightwards drift in cell\n # fluxes if not normalised in this way.\n U[t,layer,:,0:int(U.shape[2]/2)] = 0-U[t,layer,:,0:int(U.shape[2]/2)]\n\n # nabla is the inverted delta operator used to denote the divergence \n # of a vector field, here applied to hydrological flow in m3/d \n # calculated as dx/dt + dy/dt + dz/dt\n\n nabla = (U[t,layer,:,:] + V[t,layer,:,:] + W[t,layer,:,:])\n \n # divergence gives net in/outflow in m3/t\n # cells/m3 = cells/mL *1000\n\n delC = Out.Q[t,layer,:,:] * (1+CellG[layer,:,:] - CellD[layer,:,:])\n\n Cells[t,layer,:,:] = Cells[t,layer,:,:] + (delC * 1000) \n\n Cells[Cells<0] = 0\n \n CellColumnTot = Cells.sum(axis=1)\n \n\n return Cells, CellColumnTot","def antigorite():\n\n rho = 2620.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 208.4; C[0,1] = 66.2; C[0,2] = 15.9; C[0,3] = 0.; C[0,4] = 2.4; C[0,5] = 0.\n C[1,0] = C[0,1]; C[1,1] = 201.6; C[1,2] = 5.; C[1,3] = 0.; C[1,4] = -4.4; C[1,5] = 0.\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 96.7; C[2,3] = 0.; C[2,4] = 2.5; C[2,5] = 0.\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 17.4; C[3,4] = 0.; C[3,5] = -13.1\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 18.3; C[4,5] = 0.\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 65.\n\n return C, rho","def get_cells(self):\r\n return \\\r\n (self.nx-1 if self.nx>1 else 1)* \\\r\n (self.ny-1 if self.ny>1 else 1)* \\\r\n (self.nz-1 if self.nz>1 else 1)","def forward(self, x):\n # l1\n #print(\"INIT SIZE\", torch.cuda.max_memory_allocated())\n #print(\"L1\")\n #print(\"input\", x.shape)\n e1 = self.ec_init(x)\n #print(\"init\", e1.shape)\n syn1 = self.ec11(e1) # init right - l1\n #print(\"syn1\", syn1.shape)\n #print(\"L2\")\n e2 = self.bilinear(syn1, 32, 32, size=self.sizes[2]) # l1-2\n #print(\"e2\", e2.shape)\n # l2\n syn2 = self.ec22(e2) # right l2 (concat later)\n #print(\"syn2\", syn2.shape)\n del e1, e2\n e3 = self.bilinear(syn2, 32, 32, size=self.sizes[3]) # l2-3\n #print(\"L3\")\n #print(\"e3\", e3.shape)\n # l3\n syn3 = self.ec33(e3) # right l3 (concat later)\n #print(\"syn3\", syn3.shape)\n del e3 # delete\n #print(\"L4\")\n e41 = self.bilinear(syn3, 32, 64, size=self.sizes[4]) # l3-l4\n #print(\"e41\", e41.shape)\n\n # l4\n e42 = self.ec441(e41) # right 1 l4\n #print(\"e42\", e42.shape) \n syn4 = self.ec442(e42) # right 2 l4 (concat later)\n #print(\"syn4\", syn4.shape)\n del e41, e42\n #print(\"L5\")\n e51 = self.bilinear(syn4, 64, 128, size=self.sizes[5]) # l4-l5\n #print(\"e51\", e51.shape)\n # l5\n e52 = self.ec551(e51) # right 1\n #print(\"e52\", e52.shape)\n syn5 = self.ec552(e52) # right 2\n #print(\"syn5\", syn5.shape)\n del e51, e52\n #print(\"L6\")\n e61 = self.bilinear(syn5, 128, 128, size=self.sizes[6]) # l5-l6\n #print(\"e61\", e61.shape)\n \n # l6\n e62 = self.ec661(e61) # right 1\n #print(\"e62\", e62.shape)\n syn6 = self.ec662(e62) # right 2\n #print(\"syn6\", syn6.shape)\n del e61, e62\n #print(\"L7\")\n e71 = self.bilinear(syn6, 128, 256, size=self.sizes[7]) #l6-7\n #print(\"e71\", e71.shape)\n \n # l7\n e72 = self.ec771(e71) # right 1 (green)\n #print(\"e72\", e72.shape)\n syn7 = self.ec772(e72) # right 2 (turq)\n #print(\"syn7\", syn7.shape)\n del e71, e72\n\n #print(\"L8\")\n\n #e_bottom_left = self.bilinear(syn7, 256, 4092, size=self.sizes[8]) # l7-l8\n e_bottom_left = self.bilinear(syn7, 256, 256, size=self.sizes[8]) # l7-l8\n #print(\"e_b_l\", e_bottom_left.shape)\n\n # l8 - the very bottom most encoded\n e_bottom_left = e_bottom_left.view(e_bottom_left.size(0), -1)\n batch_size = e_bottom_left.size()[0]\n e_bottom_right = self.ec88(e_bottom_left)\n # TODO - change the view so that 1st arg is batch size again\n e_bottom_right = e_bottom_right.view(batch_size, e_bottom_right.size(1), 1,1,1)\n #print(\"e_b_r\", e_bottom_right.shape)\n\n #print(\"SIZE BEFORE DEL\", torch.cuda.max_memory_allocated())\n if torch.cuda.is_available():\n torch.cuda.empty_cache()\n #print(\"SIZE AFTER DEL\", torch.cuda.max_memory_allocated())\n\n ## DECODE ##\n #print(\"TO CONCAT:\")\n #print(\"Shape1\", self.bilinear(e_bottom_right, 4096, 256, size=self.sizes2[7]).shape)\n #print(\"Shape1\", self.bilinear(e_bottom_right, 256, 256, size=self.sizes2[7]).shape)\n #print(\"syn7 \", syn7.shape)\n # QUESTION - check this is a simple cat - says \"copy and stack\"\n #d71 = torch.cat((self.bilinear(e_bottom_right, 4096, 256, size=self.sizes2[7]), syn7), dim=1) # concat on level 7\n d71 = torch.cat((self.bilinear(e_bottom_right, 256, 256, size=self.sizes2[7]), syn7), dim=1) # concat on level 7\n #print(\"d71 (post cat)\", d71.shape)\n del e_bottom_left, e_bottom_right\n d72 = self.dc77(d71) # move right on level 7 (decode)\n #print(\"d72 (decoded)\", d72.shape)\n del d71, syn7\n\n # TODO - finish\n d61 = torch.cat((self.bilinear(d72, 256, 128, size=self.sizes2[6]), syn6), dim=1)\n del d72, syn6\n d62 = self.dc66(d61)\n\n d51 = torch.cat((self.bilinear(d62, 128, 128, size=self.sizes2[5]), syn5), dim=1)\n del d61, d62, syn5\n d52 = self.dc55(d51)\n\n d41 = torch.cat((self.bilinear(d52, 128, 64, size=self.sizes2[4]), syn4), dim=1)\n del d51, d52, syn4\n d42 = self.dc44(d41)\n\n d31 = torch.cat((self.bilinear(d42, 64, 32, size=self.sizes2[3]), syn3), dim=1)\n del d41, d42, syn3\n d32 = self.dc33(d31)\n\n d21 = torch.cat((self.bilinear(d32, 32, 32, size=self.sizes2[2]), syn2), dim=1)\n del d31, d32, syn2\n d22 = self.dc22(d21)\n\n d11 = torch.cat((self.bilinear(d22, 32, 32, size=self.sizes2[1]), syn1), dim=1)\n del d21, d22, syn1\n d12 = self.dc11(d11)\n return d12\n \"\"\"\n del d11\n # QUESTION\n # is this right or is there only 1 rightward step at top layer\n d0 = self.dc10(d12)\n return d0\n \"\"\"","def C(t):\n out = [0.]*D #: For each t we return a list of D coordinates\n for d in range(D): #: Iterate over 0-indexed dimension indices\n out[d] = S(t,d)\n return out","def manipulate_heat_data(self): \n self.exh.T_array = ( 0.5 * (self.exh.T_inlet_array +\n self.exh.T_outlet_array) + 273.15)\n self.exh.delta_T_array = ( self.exh.T_inlet_array -\n self.exh.T_outlet_array )\n \n self.cool.delta_T_array = ( self.cool.T_inlet_array -\n self.cool.T_outlet_array )\n self.cool.C = self.cool.mdot * self.cool.c_p","def _build_c_phi_matrices_noiseless(self, t: tf.Tensor) -> tf.Tensor:\n c_phi_matrices = self.kernel.compute_c_phi(t, t)\\\n + tf.expand_dims(tf.eye(self.n_points_int, dtype=tf.float64), 0)\\\n * self.jitter\n return c_phi_matrices","def ket(i, dims):\n if not isinstance(i, list):\n i=[i]\n #Single qubit\n if len(i)==1:\n val = np.zeros((dims,1))\n val[i] = 1\n return val.reshape(dims,1)\n #multiple qubits. we need to tensor them together\n val = np.ones((1,1)) #initialize variable, so we have something to tensor with, the first time\n for x in i:\n val = np.tensordot(val,ket([x],dims), axes=0).transpose(0,2,1,3)\n val = val.reshape(val.shape[0]*val.shape[1],val.shape[2]*val.shape[3])\n return val.reshape(val.shape[0],1)","def bra(i, dims):\n if not isinstance(i, list):\n i=[i]\n #Single qubit\n if len(i)==1:\n val = np.zeros((dims,1))\n val[i] = 1\n return val.reshape(1,dims)\n #multiple qubits. we need to tensor them together\n val = np.ones((1,1)) #initialize variable, so we have something to tensor with, the first time\n for x in i:\n val = np.tensordot(val,ket([x],dims), axes=0).transpose(0,2,1,3)\n val = val.reshape(val.shape[0]*val.shape[1],val.shape[2]*val.shape[3])\n return val.reshape(1,val.shape[0])","def grid_unit_cell(self):\n from cctbx import uctbx\n a = self.unit_cell_parameters[0] / self.unit_cell_grid[0]\n b = self.unit_cell_parameters[1] / self.unit_cell_grid[1]\n c = self.unit_cell_parameters[2] / self.unit_cell_grid[2]\n alpha,beta,gamma = self.unit_cell_parameters[3:6]\n return uctbx.unit_cell((a,b,c,alpha,beta,gamma))","def heatbasic(u0,T,K):\n import numpy as np\n N = len(u0)-1\n\n dx = 1.0/N;\n dt = 0.1/K;\n x = np.linspace(0,1,N+1)\n\n u = np.copy(u0)\n\n u_history = [u]\n\n A = np.zeros( (N+1,N+1) )\n for i in range(1,N):\n A[i,i-1] = 1;\n A[i,i] = -2;\n A[i,i+1] = 1\n A = A * dt/(dx*dx)\n A = A + np.eye(N+1)\n A[0,0] = 0.0;\n A[N,N] = 0.0;\n\n for k in range(K):\n u = np.dot(A,u)\n u_history.append(u)\n\n return u_history","def __updateMatC(self):\n\t\tif self.regScheme == 2:\n\t\t\tfor id1 in range(self.nTemplates):\n\t\t\t\tself.C[id1,id1] = 1.0 / self.w0[id1]**2","def c(self, z, y, r, t):\n \n u = np.zeros( self.m ) \n \n return u","def stress_tensor(self):\n s = \"::: forming the Cauchy stress tensor :::\"\n print_text(s, self.color)\n epi = self.strain_rate_tensor(self.U3)\n I = Identity(3)\n\n sigma = 2*self.eta*epi - self.p*I\n return sigma","def C3D(self, temperature: float = None) -> ArrayLike:\n t = temperature\n n1 = self.nu(t) / (1 - self.nu(t))\n n2 = (1 - 2 * self.nu(t)) / (2 * (1 - self.nu(t)))\n\n C = np.array([[ 1, n1, n1, 0, 0, 0],\n [n1, 1, n1, 0, 0, 0],\n [n1, n1, 1, 0, 0, 0],\n [ 0, 0, 0, n2, 0, 0],\n [ 0, 0, 0, 0, n2, 0],\n [ 0, 0, 0, 0, 0, n2]], dtype=float)\n C *= self.E(t) * (1 - self.nu(t)) / ((1 + self.nu(t)) * (1 - 2 * self.nu(t)))\n\n return C","def c_():\r\n c = np.array([[0, 0], [0, 100], [100, 100], [100, 80], [20, 80],\r\n [20, 20], [100, 20], [100, 0], [0, 0]])\r\n return c","def equation(self):\n mat = np.empty((self.nunknowns, self.model.neq))\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\n for icp in range(self.ncp):\n istart = icp * self.nlayers\n ieq = 0\n for e in self.model.elementlist:\n if e.nunknowns > 0:\n qx, qy = e.disvecinflayers(self.xc[icp], self.yc[icp], self.layers)\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\n qx * self.cosnorm[icp] + qy * self.sinnorm[icp] - self.resfac[:, np.newaxis] * \\\n (e.potinflayers(self.xcin[icp], self.ycin[icp], self.layers, aq=self.aq) / self.aq.Tcol[\n self.layers] - \\\n e.potinflayers(self.xcout[icp], self.ycout[icp], self.layers, aq=self.aq) / self.aq.Tcol[\n self.layers])\n ieq += e.nunknowns\n else:\n qx, qy = e.disveclayers(self.xc[icp], self.yc[icp], self.layers)\n rhs[istart:istart + self.nlayers] -= qx * self.cosnorm[icp] + qy * self.sinnorm[icp] + self.resfac * \\\n (e.potentiallayers(self.xcin[icp], self.ycin[icp], self.layers,\n aq=self.aq) / self.aq.T[self.layers] -\n e.potentiallayers(self.xcout[icp], self.ycout[icp],\n self.layers, aq=self.aq) / self.aq.T[\n self.layers])\n return mat, rhs","def fixed_cost(self):\n return np.einsum('i->', self.c[self.f])","def set_cells(self, val=None):\t\r\n self._cells = \\\r\n (self.nx-1 if self.nx>1 else 1)* \\\r\n (self.ny-1 if self.ny>1 else 1)* \\\r\n (self.nz-1 if self.nz>1 else 1)","def clinopyroxene_92():\n\n rho = 3327.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 257.3; C[0,1] = 85.9; C[0,2] = 76.2; C[0,3] = 0.; C[0,4] = 7.1; C[0,5] = 0.\n C[1,0] = C[0,1]; C[1,1] = 216.2; C[1,2] = 71.8; C[1,3] = 0.; C[1,4] = 13.3; C[1,5] = 0.\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 260.2; C[2,3] = 0.; C[2,4] = 33.7; C[2,5] = 0.\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 80.2; C[3,4] = 0.; C[3,5] = 10.2\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 70.6; C[4,5] = 0.\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 85.8\n\n return C, rho","def quartz():\n\n rho = 2649.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 86.9; C[0,1] = 7.6; C[0,2] = 12.; C[0,3] = 17.8; C[0,4] = 0.; C[0,5] = 0.\n C[1,0] = C[0,1]; C[1,1] = 86.9; C[1,2] = 12.; C[1,3] = -17.8; C[1,4] = 0.; C[1,5] = 0.\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 106.4; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 59.5; C[3,4] = 0.; C[3,5] = 0.\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 59.5; C[4,5] = -17.8\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 39.6\n\n return C, rho","def iso_tensor(a, b):\n\n # Velocity to Lame parameters\n mu = b*b\n lam = a*a - 2.*mu\n\n # Components of Voigt matrix\n Cii = 2.*mu + lam\n Cij = lam\n Cjj = mu\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = Cii; C[0,1] = Cij; C[0,2] = Cij; C[0,3] = 0.; C[0,4] = 0.; C[0,5] = 0.\n C[1,0] = C[0,1]; C[1,1] = Cii; C[1,2] = Cij; C[1,3] = 0.; C[1,4] = 0.; C[1,5] = 0.\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = Cii; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = Cjj; C[3,4] = 0.; C[3,5] = 0.\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = Cjj; C[4,5] = 0.\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = Cjj\n\n return C","def initialize_system(self):\n self.mfd.set_mesh(self.mesh)\n [[div_data, div_row, div_col], \n [div_t_data, div_t_row, div_t_col]] = self.mfd.build_div()\n [self.m_x_coo_data, \n m_x_coo_row, \n m_x_coo_col] = self.mfd.build_m(save_update_info=True)\n\n self.m_x_coo_length = len(self.m_x_coo_data)\n \n # The data for the bottom right should be zeros. \n [c_data, c_row, c_col] = self.mfd.build_bottom_right()\n \n [coupling_data, coupling_row, coupling_col] = self.mfd.build_coupling_terms()\n\n self.div = sparse.coo_matrix((np.array(div_data), \n (np.add(np.array(div_row), \n -self.mesh.get_number_of_faces()), \n np.array(div_col))))\n self.div = self.div.tocsr()\n\n lhs_data = self.m_x_coo_data\n lhs_row = m_x_coo_row\n lhs_col = m_x_coo_col\n \n lhs_data += div_data\n lhs_row += div_row\n lhs_col += div_col\n\n lhs_data += div_t_data\n lhs_row += div_t_row\n lhs_col += div_t_col \n \n self.c_start = len(lhs_data)\n \n lhs_data += c_data\n lhs_row += c_row\n lhs_col += c_col \n\n self.c_end = len(c_data)\n\n lhs_data += coupling_data\n lhs_row += coupling_row\n lhs_col += coupling_col\n\n # Convert m_x_coo_data to numpy array. \n self.m_x_coo_data = np.array(self.m_x_coo_data)\n\n self.lhs_coo = sparse.coo_matrix((np.array(lhs_data), \n (np.array(lhs_row), \n np.array(lhs_col))))\n\n # RHS construction is for Neumann and Dirichlet \n # boundaries specified by the mesh. \n self.rhs_mfd = self.mfd.build_rhs()","def Green_func(self):\n if self.bc == True:\n size = self.grid_size\n else:\n size = 2*self.grid_size\n self.Green = np.zeros([size, size])\n for x in range(len(self.Green[0])):\n for y in range(len(self.Green[1])):\n radius = np.sqrt(x**2 + y**2) \n if radius < self.soften: \n radius = self.soften\n self.Green[x, y]=1/(4 * np.pi * radius)\n if self.grid_size%2 == 0: \n self.Green[: size//2, size//2 : ] = np.flip(self.Green[: size//2, : size//2], axis = 1) # an intermittent step - the original grid has only been flipped once (2 x the original size)\n self.Green[ size//2 : , :] = np.flip(self.Green[: size//2, :], axis = 0)\n else: \n print(\"Exiting - Grid size is currently odd. Pleaset set to an even value.\")","def six_hundred_cell(self):\n verts = []\n q12 = QQ(1)/2\n base = [q12,q12,q12,q12]\n for i in range(2):\n for j in range(2):\n for k in range(2):\n for l in range(2):\n verts.append([x for x in base])\n base[3] = base[3]*(-1)\n base[2] = base[2]*(-1)\n base[1] = base[1]*(-1)\n base[0] = base[0]*(-1)\n for x in permutations([0,0,0,1]):\n verts.append(x)\n for x in permutations([0,0,0,-1]):\n verts.append(x)\n g = QQ(1618033)/1000000 # Golden ratio approximation\n verts = verts + [i([q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n return Polyhedron(vertices = verts)","def contract_tenors(self):\n\n\tself.r_outer_r[:,:,0,1,:] = self.r_outer_r[:,:,0,1,:]/(1. - self.k_dot_r[0,1,:])\n\tself.r_outer_r[:,:,0,2,:] = self.r_outer_r[:,:,0,2,:]/(1. - self.k_dot_r[0,2,:])\n\t\n\tself.r_outer_r[:,:,1,0,:] = self.r_outer_r[:,:,1,0,:]/(1. - self.k_dot_r[1,0,:])\n\tself.r_outer_r[:,:,1,2,:] = self.r_outer_r[:,:,1,2,:]/(1. - self.k_dot_r[1,2,:])\n\t\n\tself.r_outer_r[:,:,2,0,:] = self.r_outer_r[:,:,2,0,:]/(1. - self.k_dot_r[2,0,:])\n\tself.r_outer_r[:,:,2,1,:] = self.r_outer_r[:,:,2,1,:]/(1. - self.k_dot_r[2,1,:])\n\n\tself.delta_l = np.zeros((3,3,self.N),dtype=np.complex_)\n \n\tself.delta_l[0,1,:] = get_l(self,0,1)\n\tself.delta_l[1,0,:] = get_l(self,1,0)\n\t\n\tself.delta_l[0,2,:] = get_l(self,0,2)\n\tself.delta_l[2,0,:] = get_l(self,2,0)\n\t\n\tself.delta_l[1,2,:] = get_l(self,1,2)\n\tself.delta_l[2,1,:] = get_l(self,2,1)\n \n\treturn","def eclogite_massive():\n\n rho = 3490.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 238.85; C[0,1] = 82.01; C[0,2] = 81.44; C[0,3] = 0.3; C[0,4] = -0.02; C[0,5] = 0.5\n C[1,0] = C[0,1]; C[1,1] = 242.12; C[1,2] = 81.11; C[1,3] = -0.66; C[1,4] = 0.33; C[1,5] = 0.12\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 235.57; C[2,3] = -0.28; C[2,4] = 0.22; C[2,5] = 0.31\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 78.72; C[3,4] = 0.27; C[3,5] = 0.\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 78.37; C[4,5] = 0.25\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 77.91\n\n return C, rho","def clinopyroxene_98():\n\n rho = 3190.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 237.8; C[0,1] = 83.5; C[0,2] = 80.; C[0,3] = 0.; C[0,4] = 9.; C[0,5] = 0.\n C[1,0] = C[0,1]; C[1,1] = 183.6; C[1,2] = 59.9; C[1,3] = 0.; C[1,4] = 9.5; C[1,5] = 0.\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 229.5; C[2,3] = 0.; C[2,4] = 48.1; C[2,5] = 0.\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 76.5; C[3,4] = 0.; C[3,5] = 8.4\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 73.; C[4,5] = 0.\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 81.6\n\n return C, rho","def make_cijkl_E_nu(E=200, nu=0.3):\n lambd = E * nu / (1 + nu) / (1 - 2 * nu)\n mu = E / 2 / (1 + nu)\n cij = np.zeros((6, 6))\n cij[(0, 1, 2), (0, 1, 2)] = lambd + 2 * mu\n cij[(0, 0, 1, 1, 2, 2), (1, 2, 0, 2, 0, 1)] = lambd\n cij[(3, 4, 5), (3, 4, 5)] = mu\n # check symmetry\n assert np.allclose(cij, cij.T)\n # convert to order 4 tensor\n coord_mapping = {\n (1, 1): 1,\n (2, 2): 2,\n (3, 3): 3,\n (2, 3): 4,\n (1, 3): 5,\n (1, 2): 6,\n (2, 1): 6,\n (3, 1): 5,\n (3, 2): 4,\n }\n\n cijkl = np.zeros((3, 3, 3, 3))\n for i in range(3):\n for j in range(3):\n for k in range(3):\n for l in range(3):\n u = coord_mapping[(i + 1, j + 1)]\n v = coord_mapping[(k + 1, l + 1)]\n cijkl[i, j, k, l] = cij[u - 1, v - 1]\n return cijkl, cij","def LEIsotropic3D(self):\n const = self.ymod / ((1+self.Nu) * (1-(2*self.Nu)))\n a = const * self.Nu\n b = const * (1-self.Nu)\n c = (a-b)/2\n Cmat = np.array(\n [\n [b, a, a, 0, 0, 0],\n [a, b, a, 0, 0, 0],\n [a, a, b, 0, 0, 0],\n [0, 0, 0, c, 0, 0],\n [0, 0, 0, 0, c, 0],\n [0, 0, 0, 0, 0, c]\n ], dtype=float)\n stress_el = Cmat @ self.eps\n return stress_el, Cmat","def _build_c_phi_matrices(self, t: tf.Tensor) -> tf.Tensor:\n c_phi_matrices = self.kernel.compute_c_phi(t, t)\\\n + tf.expand_dims(tf.eye(self.n_points_int, dtype=tf.float64), 0)\\\n * self.likelihood_variances\n return c_phi_matrices","def prepare_evaluation(self):\n # this is called after the optimizer has discretized the graph\n cells = [self.edges[2, 3].op, self.edges[4, 5].op, self.edges[6, 7].op]\n\n self._expand()\n\n channels = [64, 128, 256]\n factor = 4\n\n for cell, c in zip(cells, channels):\n for _, _, data in cell.edges.data():\n data.op.update_nodes(\n lambda node, in_edges, out_edges: _set_comb_op_channels(\n node, in_edges, out_edges, c=c\n ),\n single_instances=False,\n )\n\n self.edges[1, 2].set(\"op\", ops.Stem(channels[0]))\n self.edges[2, 3].set(\"op\", cells[0].copy())\n self.edges[3, 4].set(\n \"op\",\n ops.SepConv(channels[0], channels[0], kernel_size=3, stride=1, padding=1),\n )\n self.edges[4, 5].set(\"op\", cells[0].copy())\n self.edges[5, 6].set(\n \"op\",\n ops.SepConv(channels[0], channels[1], kernel_size=3, stride=2, padding=1),\n )\n self.edges[6, 7].set(\"op\", cells[1].copy())\n self.edges[7, 8].set(\n \"op\",\n ops.SepConv(channels[1], channels[1], kernel_size=3, stride=1, padding=1),\n )\n self.edges[8, 9].set(\"op\", cells[1].copy())\n self.edges[9, 10].set(\n \"op\",\n ops.SepConv(channels[1], channels[2], kernel_size=3, stride=2, padding=1),\n )\n self.edges[10, 11].set(\"op\", cells[2].copy())\n self.edges[11, 12].set(\n \"op\",\n ops.SepConv(channels[2], channels[2], kernel_size=3, stride=1, padding=1),\n )\n self.edges[12, 13].set(\"op\", cells[2].copy())\n self.edges[13, 14].set(\n \"op\",\n ops.Sequential(\n ops.SepConv(\n channels[-1], channels[-1], kernel_size=3, stride=1, padding=1\n ),\n nn.AdaptiveAvgPool2d(1),\n nn.Flatten(),\n nn.Linear(channels[-1], 10),\n ),\n )\n\n self.update_edges(\n update_func=lambda edge: _increase_channels(edge, factor),\n scope=self.OPTIMIZER_SCOPE,\n private_edge_data=True,\n )","def temp_update(self):\n a_w = self.k / self.dx\n a_e = self.k / self.dx\n a_n = self.k / self.dy\n a_s = self.k / self.dy\n a_p = a_w + a_e + a_n + a_s + self.rho * self.cp * self.dx / self.dt\n for i, j in ti.ndrange((1, self.nx - 1), (1, self.ny - 1)):\n self.T[i,\n j] = (a_w * self.T[i - 1, j] + a_e * self.T[i + 1, j] +\n a_s * self.T[i, j - 1] + a_n * self.T[i, j + 1]) / a_p","def equation(self):\n mat = np.empty((self.nunknowns, self.model.neq))\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\n for icp in range(self.ncp):\n istart = icp * self.nlayers\n ieq = 0\n for e in self.model.elementlist:\n if e.nunknowns > 0:\n headin = self.intpot(e.potinflayers, self.xcin[icp], self.ycin[icp],\n self.xcin[icp + 1], self.ycin[icp + 1], self.layers,\n aq=self.aqin) / self.aqin.Tcol[self.layers]\n headout = self.intpot(e.potinflayers, self.xcout[icp], self.ycout[icp],\n self.xcout[icp + 1], self.ycout[icp + 1], self.layers,\n aq=self.aqout) / self.aqout.Tcol[self.layers]\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = headin - headout\n ieq += e.nunknowns\n else:\n headin = self.intpot(e.potentiallayers, self.xcin[icp], self.ycin[icp],\n self.xcin[icp + 1], self.ycin[icp + 1], self.layers,\n aq=self.aqin) / self.aqin.T[self.layers]\n headout = self.intpot(e.potentiallayers, self.xcout[icp], self.ycout[icp],\n self.xcout[icp + 1], self.ycout[icp + 1], self.layers,\n aq=self.aqout) / self.aqout.T[self.layers]\n rhs[istart:istart + self.nlayers] -= headin - headout\n return mat, rhs","def constructCell():\n\t\tself.weightGenerate()","def __init__(self, u1=(1,0,0), u2=(0,1,0), u3=(0,0,1)):\n u1 = vec3(u1)\n u2 = vec3(u2)\n u3 = vec3(u3)\n\n if triple_scalar_product(u1, u2, u3) != 1:\n print >> sys.stderr, \"!! Invalid lattice vectors: u1 = %s, u2 = %s, u3 = %s\" % (u1,u2,u3)\n self.e1 = vec3(1,0,0)\n self.e2 = vec3(0,1,0)\n self.e3 = vec3(0,0,1)\n else:\n s1 = square(u1)\n s2 = square(u2)\n d12 = dot(u1, u2)\n d23 = dot(u2, u3)\n d13 = dot(u1, u3)\n alpha = -d12/s1\n gamma = -(alpha*d13 + d23)/(alpha*d12 + s2)\n beta = -(d13 + gamma*d12)/s1\n self.e1 = u1\n self.e2 = u2 + alpha*u1\n self.e3 = u3 + beta*u1 + gamma*u2\n\n if verbose:\n print(\"e1 = %s\" % self.e1)\n print(\"e2 = %s\" % self.e2)\n print(\"e3 = %s\" % self.e3)\n\n self.L1 = length(self.e1)\n self.L2 = length(self.e2)\n self.L3 = length(self.e3)\n self.n1 = self.e1/self.L1\n self.n2 = self.e2/self.L2\n self.n3 = self.e3/self.L3\n self.cells = []\n\n v0 = vec3(0,0,0)\n self.v = [v0,\n v0 + self.e3,\n v0 + self.e2,\n v0 + self.e2 + self.e3,\n v0 + self.e1,\n v0 + self.e1 + self.e3,\n v0 + self.e1 + self.e2,\n v0 + self.e1 + self.e2 + self.e3]\n\n # Compute bounding box of cuboid\n xs = [vk.x for vk in self.v]\n ys = [vk.y for vk in self.v]\n zs = [vk.z for vk in self.v]\n vmin = vec3(min(xs), min(ys), min(zs))\n vmax = vec3(max(xs), max(ys), max(zs))\n\n # Extend to nearest integer coordinates\n ixmin = int(floor(vmin.x))\n ixmax = int(ceil(vmax.x))\n iymin = int(floor(vmin.y))\n iymax = int(ceil(vmax.y))\n izmin = int(floor(vmin.z))\n izmax = int(ceil(vmax.z))\n if verbose:\n print(\"ixmin, ixmax = %d, %d\" % (ixmin,ixmax))\n print(\"iymin, iymax = %d, %d\" % (iymin,iymax))\n print(\"izmin, izmax = %d, %d\" % (izmin,izmax))\n\n # Determine which cells (and which faces within those cells) are non-trivial\n for ix in range(ixmin, ixmax):\n for iy in range(iymin, iymax):\n for iz in range(izmin, izmax):\n shift = vec3(-ix, -iy, -iz)\n faces = [Plane(self.v[0] + shift, +self.n1),\n Plane(self.v[4] + shift, -self.n1),\n Plane(self.v[0] + shift, +self.n2),\n Plane(self.v[2] + shift, -self.n2),\n Plane(self.v[0] + shift, +self.n3),\n Plane(self.v[1] + shift, -self.n3)]\n\n c = Cell(ix, iy, iz)\n skipcell = False\n for f in faces:\n r = UnitCubeTest(f)\n if r == +1:\n # Unit cube is completely above this plane; this cell is empty\n continue\n elif r == 0:\n # Unit cube intersects this plane; keep track of it\n c.faces.append(f)\n elif r == -1:\n skipcell = True\n break\n\n if skipcell or len(c.faces) == 0:\n if verbose:\n print(\"Skipping cell at (%d,%d,%d)\" % (ix,iy,iz))\n continue\n else:\n self.cells.append(c)\n if verbose:\n print(\"Adding cell at (%d,%d,%d)\" % (ix,iy,iz))\n\n # For the identity remapping, use exactly one cell\n if len(self.cells) == 0:\n self.cells.append(Cell())\n\n # Print the full list of cells\n if verbose:\n print(\"%d non-empty cells\" % len(self.cells))\n for c in self.cells:\n print(\"Cell at (%d,%d,%d) has %d non-trivial planes\" % (c.ix,\n c.iy, c.iz, len(c.faces)))","def generate_cells(self,n_c):\n self.n_c = n_c\n self.cells = [Cell() for i in range(n_c)]\n return self.cells","def construct_A(self, N, r, t0, tf):\n a = np.zeros((2*r,N))\n \n for i in range(N): \n for j in range(r): \n if i >= j : \n a[j,i] = self.prod(xrange(i-(j-1), i+1))*t0**(i-j)\n a[r+j,i] = self.prod(xrange(i-(j-1), i+1))*tf**(i-j)\n return a","def makeGrid(self):\n self.h = self.step_x\n self.k = self.step_t\n self.t, self.x = np.meshgrid(np.arange(self.min_t, self.max_t, self.step_t), np.arange(self.min_x, self.max_x\n , self.step_x))","def buildReconstructionTerm(self):\r\n\r\n # shape is (batch size,)\r\n self.reconst = T.mean(self.log_pygx, axis=1)","def _allEquilibriumFunc(self,cps,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks,k1M,k3M):\n # We move from an array to a list of 2d-array for the competition over each template:\n\n cp=cps[0]\n cpt = [np.reshape(cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)],(m.shape[0],m.shape[1])) for l,m in enumerate(masks)]\n new_cpt = [np.zeros(l.shape)+1 for l in cpt]\n new_cp = 1\n\n olderX = [np.zeros(m.shape[1]) for m in masks]\n for layeridx,layer in enumerate(masks):\n layerEq = np.zeros(layer.shape[1])\n if(layeridx==0):\n for inpIdx in range(layer.shape[1]):\n #compute of Kactivs,Kinhibs;\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #compute of \"weights\": sum of kactivs and kinhibs\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\n x_eq = X0[inpIdx]/(1+E0*w_inpIdx/cp)\n # update for fixed point:\n new_cp += w_inpIdx*x_eq\n # saving values\n layerEq[inpIdx] = x_eq\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\n olderX[layeridx] = layerEq\n else:\n for inpIdx in range(layer.shape[1]):\n\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\n #Terms for the previous layers\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\n #computing of new equilibrium\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\n layerEq[inpIdx] = x_eq\n\n #compute of Kactivs,Kinhibs, for the current layer:\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\n new_cp += firstComplex + Inhib2/(E0*cp)*x_eq\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\n olderX[layeridx] = layerEq\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\n for outputsIdx in range(masks[-1].shape[0]):\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\n\n Inhib = np.sum(Cinhibs*olderX[-1]/kdT[-1][outputsIdx])\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]*cp+Inhib/cp))\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\n new_cp += Inhib2/(E0*cp)*x_eq\n\n #we know that the root should be larger than 1 so we artificially add a root barrier at 1.\n diff_cps = np.zeros(cps.shape)\n if new_cp>=1:\n diff_cps[0] = cp - new_cp\n else:\n diff_cps[0] = 10**3\n for l,m in enumerate(masks):\n layer_new_cpt = np.reshape(new_cpt[l],(m.shape[0]*m.shape[1]))\n layer_old_cpt = cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)]\n diff_cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)] = layer_old_cpt - np.where(layer_new_cpt<1,layer_old_cpt + 10**3, layer_new_cpt)\n return diff_cps","def equation(self):\n mat = np.empty((self.nunknowns, self.model.neq))\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\n for icp in range(self.ncp):\n istart = icp * self.nlayers\n ieq = 0\n for e in self.model.elementlist:\n if e.nunknowns > 0:\n qx, qy = e.disvecinflayers(self.xcout[icp], self.ycout[icp], self.layers)\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\n qx * self.cosnorm[icp] + qy * self.sinnorm[icp]\n ieq += e.nunknowns\n else:\n qx, qy = e.disveclayers(self.xcout[icp], self.ycout[icp], self.layers)\n rhs[istart:istart + self.nlayers] -= qx * self.cosnorm[icp] + qy * self.sinnorm[icp]\n return mat, rhs","def jadeite():\n\n rho = 3330.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 274.; C[0,1] = 94.; C[0,2] = 71.; C[0,3] = 0.; C[0,4] = 4.; C[0,5] = 0.\n C[1,0] = C[0,1]; C[1,1] = 253.; C[1,2] = 82.; C[1,3] = 0.; C[1,4] = 14.; C[1,5] = 0.\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 282.; C[2,3] = 0.; C[2,4] = 28.; C[2,5] = 0.\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 88.; C[3,4] = 0.; C[3,5] = 13.\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 65.; C[4,5] = 0.\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 94.\n\n return C, rho","def equation(self):\n mat = np.empty((self.nunknowns, self.model.neq))\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\n for icp in range(self.ncp):\n istart = icp * self.nlayers\n ieq = 0\n for e in self.model.elementlist:\n if e.nunknowns > 0:\n qx, qy = e.disvecinflayers(self.xc[icp], self.yc[icp], self.layers)\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\n qx * self.cosnorm[icp] + qy * self.sinnorm[icp]\n ieq += e.nunknowns\n else:\n qx, qy = e.disveclayers(self.xc[icp], self.yc[icp], self.layers)\n rhs[istart:istart + self.nlayers] -= qx * self.cosnorm[icp] + qy * self.sinnorm[icp]\n return mat, rhs","def _build(self):\n ary = np.zeros( (3,3,3), float )\n ary[0,0,0] = ary[1,1,1] = ary[0,1,2] = ary[1,0,2] = 1.\n ary[0,2,0] = ary[0,2,2] = ary[2,0,0] = ary[2,0,2] = 0.5\n ary[1,2,1] = ary[1,2,2] = ary[2,1,1] = ary[2,1,2] = 0.5\n ary[2,2,0] = ary[2,2,1] = 0.25\n ary[2,2,2] = 0.5\n return ary","def _train(self):\n return np.zeros(1, 10)","def serpentinite_37():\n\n rho = 3000.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 205.52; C[0,1] = 66.36; C[0,2] = 62.29; C[0,3] = -0.1; C[0,4] = -1.48; C[0,5] = 3.86\n C[1,0] = C[0,1]; C[1,1] = 195.79; C[1,2] = 62.53; C[1,3] = -0.37; C[1,4] = 0.2; C[1,5] = 1.54\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 193.30; C[2,3] = -1.78; C[2,4] = -0.24; C[2,5] = 0.83\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 66.17; C[3,4] = 1.47; C[3,5] = -0.57\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 64.70; C[4,5] = -0.84\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 67.83\n\n return C, rho","def equation(self):\n mat = np.empty((self.nunknowns, self.model.neq))\n # rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\n rhs = self.hc.copy()\n for icp in range(self.ncp):\n istart = icp * self.nlayers\n # rhs[istart:istart+self.nlayers] = self.pc[]\n ieq = 0\n for e in self.model.elementlist:\n if e.nunknowns > 0:\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\n e.potinflayers(self.xc[icp], self.yc[icp], self.layers) / self.aq.Tcol[self.layers]\n if e == self:\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] -= self.resfac[icp]\n ieq += e.nunknowns\n else:\n rhs[istart:istart + self.nlayers] -= \\\n e.potentiallayers(self.xc[icp], self.yc[icp], self.layers) / self.aq.T[\n self.layers] # Pretty cool that this works, really\n return mat, rhs","def term_1(\n omega1, # vorticity-1\n omega2, # vorticity-2\n omega3, # vorticity-3\n enst, # enstrophy\n nu_sgs, # turbulent viscosity\n h = True): # spatial step size\n #---------------------------------------------------------------------#\n # Setting default values #\n #---------------------------------------------------------------------#\n if h is True:\n h = 2.0*np.pi/64.0\n #---------------------------------------------------------------------#\n # Preallocating space #\n #---------------------------------------------------------------------#\n term = np.zeros((64,64,64))\n #---------------------------------------------------------------------#\n # Enstrophy term #\n #---------------------------------------------------------------------#\n term += np.gradient(\\\n np.gradient(enst, h, edge_order=2)[2], h, edge_order=2)[2]\n term += np.gradient(\\\n np.gradient(enst, h, edge_order=2)[1], h, edge_order=2)[1]\n term += np.gradient(\\\n np.gradient(enst, h, edge_order=2)[0], h, edge_order=2)[0]\n #---------------------------------------------------------------------#\n # Dissipation #\n #---------------------------------------------------------------------#\n omega1_grad = np.gradient(omega1, h, edge_order=2)\n omega2_grad = np.gradient(omega2, h, edge_order=2)\n omega3_grad = np.gradient(omega3, h, edge_order=2)\n term -= np.square(omega1_grad[2])\n term -= np.square(omega1_grad[1])\n term -= np.square(omega1_grad[0])\n term -= np.square(omega2_grad[2])\n term -= np.square(omega2_grad[1])\n term -= np.square(omega2_grad[0])\n term -= np.square(omega3_grad[2])\n term -= np.square(omega3_grad[1])\n term -= np.square(omega3_grad[0])\n #---------------------------------------------------------------------#\n # Applying the subgrid stress #\n #---------------------------------------------------------------------#\n term *= nu_sgs\n\n return term","def construct_detector_tensor(self):\n\t\n\tself.x = self.Orbit.get_orbit(self.t) # get the S/C for all relevant times\n\t\n\tcalc_xi(self) # Calculate the wave variables\n\t\n\tself.rij = self.Orbit.get_seps(self.t, self.x) # calculate separation vectors between spacecraft\n\t\n\t# calculate the outer product between unit separation vectors\n\tself.r_outer_r = 0.5*self.Orbit.get_rOr(self.rij)\n\t \n\tcalc_k_dot_r(self)\n\n\treturn","def generator(real_init): #-1, 5, 3\n with tf.variable_scope('rnn_gen', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\n x_init = real_init[:,:,0] #-1, 8\n y_init = real_init[:,:,1] #-1, 8\n z_init = real_init[:,:,2] #-1, 8\n \n with tf.variable_scope('x_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\n x_w1 = tf.get_variable('x_w1', [6, 3])\n x_b1 = tf.get_variable('x_b1', [3])\n x_w2 = tf.get_variable('x_w2', [9, 3])\n x_b2 = tf.get_variable('x_b2', [3])\n x_w3 = tf.get_variable('x_w3', [3, 1])\n x_b3 = tf.get_variable('x_b3', [1])\n x_w4 = tf.get_variable('x_w4', [3, 1])\n x_b4 = tf.get_variable('x_b4', [1])\n \n x_full = x_init#-1, 8\n for i in range(104):\n x_layer1 = tf.nn.elu(tf.matmul(x_init, x_w1) + x_b1)#-1, 4\n x_layer2 = tf.concat([x_init, x_layer1], 1)#-1, 12\n x_layer3 = tf.nn.elu(tf.matmul(x_layer2, x_w2) + x_b2)#-1, 4\n \n x_mean = tf.sigmoid(tf.matmul(x_layer3, x_w3) + x_b3)#-1, 1\n x_gamma = tf.sigmoid(tf.matmul(x_layer3, x_w4) + x_b4)#-1, 1\n x_delta = x_mean + x_gamma * tf.random_normal(tf.shape(x_gamma), dtype = tf.float32)#-1, 1\n x_delta_denorm = (x_delta * 2 - 1) / 80\n x_output = tf.expand_dims(x_full[:,-1], 1) + x_delta_denorm\n x_full = tf.concat([x_full, x_output], axis = 1)#-1, 10 + 1\n x_init = x_full[:,-6:]\n \n with tf.variable_scope('y_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\n y_w1 = tf.get_variable('y_w1', [6, 3])\n y_b1 = tf.get_variable('y_b1', [3])\n y_w2 = tf.get_variable('y_w2', [9, 3])\n y_b2 = tf.get_variable('y_b2', [3])\n y_w3 = tf.get_variable('y_w3', [3, 1])\n y_b3 = tf.get_variable('y_b3', [1])\n y_w4 = tf.get_variable('y_w4', [3, 1])\n y_b4 = tf.get_variable('y_b4', [1])\n \n y_full = y_init#-1, 8\n for i in range(104):\n y_layer1 = tf.nn.elu(tf.matmul(y_init, y_w1) + y_b1)\n y_layer2 = tf.concat([y_init, y_layer1], 1)#-1, 12\n y_layer3 = tf.nn.elu(tf.matmul(y_layer2, y_w2) + y_b2)#-1, 4\n \n y_mean = tf.sigmoid(tf.matmul(y_layer3, y_w3) + y_b3) #-1, 1\n y_gamma = tf.sigmoid(tf.matmul(y_layer3, y_w4) + y_b4) #-1, 1\n y_delta = y_mean + y_gamma * tf.random_normal(tf.shape(y_gamma), dtype = tf.float32)#-1, 1\n y_delta_denorm = (y_delta * 5 - 2.7) / 1700\n y_output = tf.expand_dims(y_full[:,-1], 1) + y_delta_denorm\n y_full = tf.concat([y_full, y_output], axis = 1)#-1, 10 + 1, 1\n y_init = y_full[:,-6:]\n \n with tf.variable_scope('z_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\n z_w1 = tf.get_variable('z_w1', [6, 3])\n z_b1 = tf.get_variable('z_b1', [3])\n z_w2 = tf.get_variable('z_w2', [9, 3])\n z_b2 = tf.get_variable('z_b2', [3])\n z_w3 = tf.get_variable('z_w3', [3, 1])\n z_b3 = tf.get_variable('z_b3', [1])\n z_w4 = tf.get_variable('z_w4', [3, 1])\n z_b4 = tf.get_variable('z_b4', [1])\n \n z_full = z_init#-1, 8\n for i in range(104):\n z_layer1 = tf.nn.elu(tf.matmul(z_init, z_w1) + z_b1)\n z_layer2 = tf.concat([z_init, z_layer1], 1)#-1, 12\n z_layer3 = tf.nn.elu(tf.matmul(z_layer2, z_w2) + z_b2)#-1, 4\n \n z_mean = tf.sigmoid(tf.matmul(z_layer3, z_w3) + z_b3) #-1, 1\n z_gamma = tf.sigmoid(tf.matmul(z_layer3, z_w4) + z_b4) #-1, 1\n z_delta = z_mean + z_gamma * tf.random_normal(tf.shape(z_gamma), dtype = tf.float32)#-1, 1\n z_delta_denorm = (z_delta * 3 - 2.2) / 300\n z_output = tf.expand_dims(z_full[:,-1], 1) + z_delta_denorm\n z_full = tf.concat([z_full, z_output], axis = 1)#-1, 10 + 1, 1\n z_init = z_full[:,-6:]\n \n rand_layer1 = tf.concat([tf.expand_dims(x_full, 2), tf.expand_dims(y_full, 2), tf.expand_dims(z_full, 2)], axis = 2)#-1, 200, 3\n rand_layer1_reshape = tf.reshape(rand_layer1, shape = (-1, 110, 3, 1))\n output_filt = tf.ones(shape = (11, 1, 1, 1)) / 11\n \n rand_layer2 = tf.nn.conv2d(rand_layer1_reshape, output_filt, strides = [1,1,1,1], padding = 'VALID')\n \n return tf.reshape(rand_layer2, shape = (-1, 100, 3)) #-1, 110, 3","def __init__(self, nDense1, nDense2, nDense3):\n super(CAE, self).__init__()\n self.dense1 = nn.Linear(nDense1, nDense2)\n self.tanh = nn.Tanh()\n self.dense2 = nn.Linear(nDense2, nDense3)","def eclogite_foliated():\n\n rho = 3300.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 203.45; C[0,1] = 67.76; C[0,2] = 64.47; C[0,3] = 0.08; C[0,4] = 1.9; C[0,5] = -0.4\n C[1,0] = C[0,1]; C[1,1] = 220.58; C[1,2] = 63.65; C[1,3] = 0.46; C[1,4] = 0.59; C[1,5] = 0.06\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 189.75; C[2,3] = 0.13; C[2,4] = 0.95; C[2,5] = -0.2\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 66.32; C[3,4] = -0.27; C[3,5] = 0.73\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 65.77; C[4,5] = -0.02\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 70.75\n\n return C, rho","def initialize_cells(self):\n for loc in np.ndindex(*self.shape): # TODO: see if nested for loop is faster than this\n c = Cell(loc, self)\n self.cells.append(c)","def lstmcell_grad_c(input, hx, cx, w_ih, w_hh, b_ih, b_hh, dc, target=\"cce\"):\n # things from fwd\n whl = [w_ih, w_hh]\n W = Concat(whl, 1) # [4*hidden_size, input_size+hidden_size]\n b = b_ih + b_hh\n\n batch, input_size = get_shape(input)\n _, hidden_size = get_shape(hx)\n xh = akg.topi.concatenate((hx, input), 1)\n t = akg.topi.nn.dense(xh, W, b)\n temp_i = akg.tvm.compute((batch, hidden_size), lambda i, j: t(i, j), name=\"temp_i\")\n i = sigmoid(temp_i)\n temp_f = akg.tvm.compute((batch, hidden_size), lambda i, j: t(i, j + hidden_size), name=\"temp_f\")\n f = sigmoid(temp_f)\n temp_c_ = akg.tvm.compute((batch, hidden_size), lambda i, j: t(i, j + 2 * hidden_size), name=\"temp_c\")\n c_ = Tanh(temp_c_)\n\n # starts bwd\n # head * dh/do shape [n,]\n dtemp_o = akg.tvm.compute((batch, hidden_size), lambda *i: 0)\n dWo = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j: 0, name=\"dWo\")\n\n df = dc * cx\n dtemp_f = f * (1 - f) * df\n kk2 = akg.tvm.reduce_axis((0, batch))\n dWf = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j:\n akg.tvm.sum(xh[kk2, j] * dtemp_f(kk2, i), axis=kk2), name=\"dWf\")\n\n di = c_ * dc\n dtemp_i = i * (1 - i) * di\n kk3 = akg.tvm.reduce_axis((0, batch))\n dWi = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j:\n akg.tvm.sum(xh[kk3, j] * dtemp_i(kk3, i), axis=kk3), name=\"dWi\")\n\n dc_ = i * dc\n dtemp_c_ = (1 - c_ * c_) * dc_\n kk4 = akg.tvm.reduce_axis((0, batch))\n dWc = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j:\n akg.tvm.sum(xh[kk4, j] * dtemp_c_(kk4, i), axis=kk4), name=\"dWc\")\n\n dW = akg.topi.concatenate((dWi, dWf, dWc, dWo))\n\n db = akg.topi.concatenate((dtemp_i, dtemp_f, dtemp_c_, dtemp_o), 1)\n\n kk5 = akg.tvm.reduce_axis((0, 4 * hidden_size))\n dxh = akg.tvm.compute((batch, hidden_size + input_size), lambda i, j:\n akg.tvm.sum(W[kk5, j] * db[i, kk5], axis=kk5), name=\"dxh\")\n dhx = akg.tvm.compute((batch, hidden_size), lambda i, j: dxh[i, j], name=\"dhx\")\n dx = akg.tvm.compute((batch, input_size), lambda i, j: dxh[i, j + hidden_size], name=\"dx\")\n\n dcx = f * dc\n\n dw_ih = akg.tvm.compute(w_ih.shape, lambda i, j: dW[i, j])\n #dw_hh = akg.tvm.compute(w_hh.shape, lambda i, j: dW[i, j + input_size])\n\n bhr = akg.tvm.reduce_axis((0, batch))\n\n db_ih = akg.tvm.compute((4 * hidden_size,), lambda i: akg.tvm.sum(db[i, bhr], axis=bhr), name=\"dbih\")\n\n bir = akg.tvm.reduce_axis((0, batch))\n\n db_hh = akg.tvm.compute((4 * hidden_size,), lambda i: akg.tvm.sum(db[i, bir], axis=bir), name=\"dbhh\")\n\n return dw_ih, w_hh, db_ih, db_hh, dcx, dhx, dx","def equation(self):\n mat = np.empty((self.nunknowns, self.model.neq))\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\n for icp in range(self.ncp):\n istart = icp * self.nlayers\n ieq = 0\n for e in self.model.elementlist:\n if e.nunknowns > 0:\n qxin, qyin = e.disvecinflayers(self.xcin[icp], self.ycin[icp], self.layers, aq=self.aqin)\n qxout, qyout = e.disvecinflayers(self.xcout[icp], self.ycout[icp], self.layers, aq=self.aqout)\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\n (qxin - qxout) * self.cosnorm[icp] + (qyin - qyout) * self.sinnorm[icp]\n ieq += e.nunknowns\n else:\n qxin, qyin = e.disveclayers(self.xcin[icp], self.ycin[icp], self.layers, aq=self.aqin)\n qxout, qyout = e.disveclayers(self.xcout[icp], self.ycout[icp], self.layers, aq=self.aqout)\n rhs[istart:istart + self.nlayers] -= (qxin - qxout) * self.cosnorm[icp] + (qyin - qyout) * \\\n self.sinnorm[icp]\n return mat, rhs","def hot_plate(n,c=None):\n A,b=finite_difference(n)\n if c is None:\n u=linalg.spsolve(A.tocsr(),b)\n \n else:\n u=linalg.spsolve(A.tocsr(),c)\n \n \n x=np.linspace(1,n,n)\n y=np.linspace(1,n,n)\n X,Y=np.meshgrid(x,y)\n Z=u.reshape((n,n))\n \n \n \n \n # Plot the heat map of f over the 2-D domain.\n plt.pcolormesh(X, Y, Z, cmap=\"seismic\")\n plt.colorbar()\n plt.xlim(1,n)\n plt.ylim(1,n)\n plt.show()","def _mn_cor_ ( self , size = -1 , root = False ) :\n #\n cov = self.cov ( size , root )\n #\n from math import sqrt\n #\n if isinstance ( cov , ROOT.TMatrix ) :\n\n size = cov.GetNrows()\n root = True\n \n else : size = cov.kRows\n\n ## use ROOT matrices \n if root : cor = ROOT.TMatrix ( size , size )\n else : cor = cov.__class__ () \n\n for i in range(0, size ) :\n \n d_i = cov ( i , i )\n cor [ i , i ] = 1 if 0 < d_i else 0\n \n for j in range ( i + 1 , size ) :\n \n d_j = cov ( j , j )\n \n if 0 != cov ( i , j ) and 0 < d_i and 0 < d_j :\n \n if root and _rv < 6 : cor [ i ] [ j ] = cov ( i , j ) / sqrt ( d_i * d_j )\n else : cor [ i , j ] = cov ( i , j ) / sqrt ( d_i * d_j )\n \n else :\n \n if root and _rv < 6 : cor [ i ] [ j ] = 0 \n else : cor [ i , j ] = 0\n\n return cor","def generate_julia(self, iterations, c):\n if self.grid is None:\n raise RuntimeError(\"Grid hasn't been setup - call set_grid first.\")\n # Define the tensorflow variables\n c_val = tf.constant(np.full(shape=self.grid.shape, fill_value=c, dtype=self.grid.dtype))\n z = tf.Variable(self.grid)\n n = tf.Variable(tf.zeros_like(c_val, tf.float32))\n # Start the tensorflow session\n with tf.Session():\n tf.global_variables_initializer().run()\n # Define the main julia algorithm - either take the square plus x, or keep z\n\n z_out = tf.where(tf.abs(z) < self.threshold, z ** 2 + c_val, z)\n not_diverged = tf.abs(z_out) < self.threshold\n step = tf.group(z.assign(z_out), n.assign_add(tf.cast(not_diverged, tf.float32)))\n\n for i in range(iterations):\n step.run()\n self.end_step = n.eval()\n self.end_z = z_out.eval()","def latin_hypercube(n_pts, dim):\n X = np.zeros((n_pts, dim))\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\n for i in range(dim): # Shuffle the center locataions for each dimension.\n X[:, i] = centers[np.random.permutation(n_pts)]\n\n # Add some perturbations within each box\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\n X += pert\n return X","def init(self):\n for i, j in ti.ndrange(self.nx, self.ny):\n self.T[i, j] = self.inside_taichi(\n self.Vector2(i / self.nx, j / self.ny))","def __call__(self):\n\n if self.indices is []:\n return\n\n\n #-----------------------------------------\n # Here is where the important formula is applied\n #----------------------------------------\n if self.indices is None:\n height = self.stage_c - self.elev_c\n self.friction_c[:] = self.friction(height)\n else:\n ind = self.indices\n height = self.stage_c[ind] - self.elev_c[ind]\n self.friction_c[ind] = self.friction(height)","def equation(self):\n mat = np.empty((self.nunknowns, self.model.neq))\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\n for icp in range(self.ncp):\n istart = icp * self.nlayers\n ieq = 0\n for e in self.model.elementlist:\n if e.nunknowns > 0:\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\n e.potinflayers(self.xcin[icp], self.ycin[icp], self.layers, aq=self.aqin) / self.aqin.Tcol - \\\n e.potinflayers(self.xcout[icp], self.ycout[icp], self.layers, aq=self.aqout) / self.aqout.Tcol\n ieq += e.nunknowns\n else:\n rhs[istart:istart + self.nlayers] -= \\\n e.potentiallayers(self.xcin[icp], self.ycin[icp], self.layers, aq=self.aqin) / self.aqin.T - \\\n e.potentiallayers(self.xcout[icp], self.ycout[icp], self.layers, aq=self.aqout) / self.aqout.T\n return mat, rhs","def add_computed_gas_concentrations(self):\n # Extract the z-coordinate and T, S, P profile\n zs = self.interp_ds.coords[self.ztsp[0]].values\n Ts = self.interp_ds[self.ztsp[1]].values\n Ss = self.interp_ds[self.ztsp[2]].values\n Ps = self.interp_ds[self.ztsp[3]].values\n \n # Create an air object\n air_names = ['nitrogen', 'oxygen', 'argon', 'carbon_dioxide']\n yk = np.array([0.78084, 0.20946, 0.009340, 0.00036])\n from tamoc import dbm\n air = dbm.FluidMixture(air_names)\n m = air.masses(yk)\n \n # Compute the concentrations adjusted for depth\n Cs = np.zeros((len(zs), len(air_names)))\n for i in range(len(zs)):\n Cs[i,:] = air.solubility(m, Ts[i], 101325., Ss[i])[0,:] * \\\n seawater.density(Ts[i], Ss[i], Ps[i]) / \\\n seawater.density(Ts[i], Ss[i], 101325.)\n \n # Make sure none of these gases are already in the measured profile\n for name in air_names:\n if name in self.interp_ds:\n air_names[air_names.index(name)] = 'computed_' + name\n \n # Add these data to the Profile object\n data = np.hstack((np.atleast_2d(zs).transpose(), Cs))\n names = [self.ztsp[0]] + air_names \n units = [self.ztsp_units[0]] + 4*['kg/m^3']\n self.append(data, names, units)\n \n # Rebuild the interpolator\n self._build_interpolator()","def equation(self):\n mat = np.empty((self.nunknowns, self.model.neq))\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\n for icp in range(self.ncp):\n istart = icp * self.nlayers\n rhs[istart:istart + self.nlayers] = self.pc\n ieq = 0\n for e in self.model.elementlist:\n if e.nunknowns > 0:\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\n e.potinflayers(self.xc[icp], self.yc[icp], self.layers)\n ieq += e.nunknowns\n else:\n rhs[istart:istart + self.nlayers] -= \\\n e.potentiallayers(self.xc[icp], self.yc[icp],\n self.layers) # Pretty cool that this works, really\n return mat, rhs","def circuit():\n np.random.seed(1967)\n for gates in gates_per_layers:\n for gate in gates:\n qml.apply(gate)\n return qml.expval(qml.PauliZ(0))","def calculate_strain(self):\n\t\n\tself.Hpij = np.zeros((3,3,self.N),dtype=np.complex_)\n\tself.Hcij = np.zeros((3,3,self.N),dtype=np.complex_)\n\t\n\tcalc_Hcp_ij(self)\t\n\n\tconstruct_basis_tensors(self)\n\n\tcalc_Hij(self)\n\t\n\tcontract_tenors(self)\n\n\treturn","def initial_setup(N,L,dim):\r\n r = np.zeros((3,N))\r\n #n = int(np.rint((N/3)**(1/dim)))\r\n #nz = int(n+n)\r\n x1 = np.linspace(0+L/n/2,L-L/n/2,n)\r\n d0 = 1.0e-10 #intial distance between hydrogen and oxygen\r\n x2 = x1 + d0\r\n x3 = x1 - d0/np.sqrt(2)\r\n z = np.zeros(3*n)\r\n xy = np.zeros(3*n)\r\n for ii in range(n):\r\n z[ii*3+1] = x1[ii]\r\n z[ii*3+2] = x2[ii]\r\n z[ii*3] = x3[ii]\r\n xy[ii*3] = x1[ii]\r\n xy[ii*3+1] = x1[ii]\r\n xy[ii*3+2] = x1[ii]\r\n rx, ry,rz = np.meshgrid(x1,x1,z)\r\n r[0,:] = np.reshape(rx,N)\r\n r[1,:] = np.reshape(ry,N)\r\n r[2,:] = np.reshape(rz,N)\r\n r[0,0::3] += d0/np.sqrt(2) #add additional offset to one Oxygen\r\n return r","def _build_tensor(args):\n cells,iptr,indx,data,tid,nproc,selected,log1p = args\n\n for i in range(0+tid,len(cells),nproc):\n index = selected[i]\n sidx = iptr[index]\n # find the number of gene entries for\n # this cell\n if index < len(iptr) - 1:\n # find length to next cell\n nentries = iptr[index + 1] - sidx \n else:\n # find length to the end\n nentries = len(data) - sidx\n\n for j in range(0,nentries):\n if log1p:\n cells[i][indx[sidx+j]] = np.log(1+(data[sidx+j]))\n else:\n cells[i][indx[sidx+j]] = (data[sidx+j])\n #cells[i][indx[sidx+j]] = float(data[sidx+j])","def updateC(A, U, B):\n \n m_dim = A.shape[1] \n q_dim = B.shape[0]\n \n C_tensor = np.zeros((m_dim, m_dim, q_dim), dtype=np.complex)\n \n for k in range(q_dim):\n A_k = A[:, :, k]\n b_k = B[k]\n \n x_hat = U @ b_k\n y_hat = A_k.conj().T @ x_hat\n \n phase_y = np.exp(1j*np.angle(y_hat))\n #phase_y = np.sign(y_hat)\n C_k = np.diag(phase_y)\n C_tensor[:, :, k] = C_k\n \n \n return C_tensor","def _generate_cells(self) -> None:\n for i in range(15):\n for j in range(15):\n c = Cell(x=i, y=j)\n c.answer = self.puzzle.solution[j*self.width+i]\n self.cells[(j, i)] = c # row, col","def quadraticize(self, x, u, k):\n num_players = len(u)\n\n # Congert to torch.Tensor format.\n x_torch = torch.from_numpy(x).requires_grad_(True)\n u_torch = [torch.from_numpy(ui).requires_grad_(True) for ui in u]\n\n # Evaluate cost here.\n cost_torch = self.__call__(x_torch, u_torch, k)\n cost = cost_torch.item()\n\n # Compute gradients (and store numpy versions).\n grad_x_torch = torch.autograd.grad(\n cost_torch, x_torch, create_graph=True, allow_unused=True)[0]\n grad_u_torch = [\n torch.autograd.grad(\n cost_torch, ui_torch, create_graph=True, allow_unused=True)[0]\n for ui_torch in u_torch]\n\n # Compute Hessians (and store numpy versions), and be careful to\n # catch Nones (which indicate cost not depending on a particular\n # variable).\n hess_x = np.zeros((len(x), len(x)))\n grad_x = np.zeros((len(x), 1))\n if grad_x_torch is not None:\n grad_x = grad_x_torch.detach().numpy().copy()\n for ii in range(len(x)):\n hess_row = torch.autograd.grad(\n grad_x_torch[ii, 0], x_torch, retain_graph=True)[0]\n hess_x[ii, :] = hess_row.detach().numpy().copy().T\n\n hess_u = []\n for ii in range(num_players):\n hess_ui = np.zeros((len(u[ii]), len(u[ii])))\n grad_ui_torch = grad_u_torch[ii]\n if grad_ui_torch is not None:\n grad_ui = grad_ui_torch.detach().numpy().copy()\n for dim in range(len(u[ii])):\n hess_row = torch.autograd.grad(\n grad_ui_torch[dim, 0], u_torch[ii], retain_graph=True)[0]\n hess_ui[dim, :] = hess_row.detach().numpy().copy().T\n\n hess_u.append(hess_ui)\n\n return cost, grad_x, hess_x, hess_u","def garnet():\n\n rho = 3660.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 306.2; C[0,1] = 112.5; C[0,2] = 112.5; C[0,3] = 0.; C[0,4] = 0.; C[0,5] = 0.\n C[1,0] = C[0,1]; C[1,1] = 306.2; C[1,2] = 112.5; C[1,3] = 0.; C[1,4] = 0.; C[1,5] = 0.\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 306.2; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 92.7; C[3,4] = 0.; C[3,5] = 0.\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 92.7; C[4,5] = 0.\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 92.7\n\n return C, rho","def contract(tensor):\n temp = np.einsum('ikma, jlan', tensor, tensor)\n M = np.zeros((tensor.shape[0]**2, tensor.shape[1]**2, tensor.shape[2], tensor.shape[3]))\n for i,j,k,l,m,n in it.product(*[range(x) for x in temp.shape]):\n M[i + tensor.shape[0]*j, k + tensor.shape[1]*l, m, n] = temp[i,j,k,l,m,n]\n return M","def lherzolite():\n\n rho = 3270.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 187.4; C[0,1] = 63.71; C[0,2] = 63.87; C[0,3] = 0.78; C[0,4] = 2.02; C[0,5] = -3.2\n C[1,0] = C[0,1]; C[1,1] = 211.25; C[1,2] = 64.5; C[1,3] = -3.07; C[1,4] = 0.87; C[1,5] = -5.78\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 190.; C[2,3] = 0.38; C[2,4] = 2.38; C[2,5] = -0.12\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 67.9; C[3,4] = -2.12; C[3,5] = 1.6\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 63.12; C[4,5] = -0.55\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 66.83\n\n return C, rho","def image_cube(self, i=0, channels=None, cell=1.0, imagesize=4096, pol='i'):\n\n # select integration and reduce pol axis\n if ((pol == 'i') | (pol == 'I')):\n if len(trackdata) == 2:\n print 'Making Stokes I image as mean of two pols...'\n else:\n print 'Making Stokes I image as mean over all pols. Hope that\\'s ok...'\n tr=self.data.mean(axis=3)[0]\n elif isinstance(pol, types.IntType):\n print 'Making image of pol %d' % (pol)\n tr=self.data[0,:,:,pol]\n \n # res and size in aipy units (lambda)\n # size is pixel scale (cell size)\n size=1/n.radians(cell/60.0)\n # full field\n res=size/imagesize\n fov = n.degrees(1./res)*3600. # field of view in arcseconds\n\n if channels is None:\n channels=range(self.nchan)\n\n # form channel dependent uvw\n u_ch = n.outer(self.u[i], self.freq/self.freq_orig[0])\n v_ch = n.outer(self.v[i], self.freq/self.freq_orig[0])\n w_ch = n.outer(self.w[i], self.freq/self.freq_orig[0])\n\n # make image\n image=n.zeros((len(channels),size/res,size/res))\n for c,ic in zip(channels,xrange(len(channels))):\n print 'Creating image for channel %d...' % c\n ai = aipy.img.Img(size=size, res=res)\n uvw_new, tr_new = ai.append_hermitian( (u_ch[:,c], v_ch[:,c], w_ch[:,c]), tr[:,c])\n ai.put(uvw_new, tr_new)\n image[ic] = ai.image(center = (size/res/2, size/res/2))\n\n self.ai=ai\n self.image_center=(size/res/2, size/res/2)\n return image","def calcAllIntensities(self, xc, yc):\n\n tp = 0.0\n ix = 0\n iy = 0\n h = 0\n ints = np.zeros([5, 5])\n ints_inner = np.zeros([5, 5])\n # ints = [[0.0] * 5] * 5\n # ints_inner = [[0.0] * 5] * 5\n x = 0.0\n y = 0.0\n xc1 = 0.0\n yc1 = 0.0\n xc1 = xc\n yc1 = yc\n \n for h in np.arange(1,5,1):\n for k in np.arange(1,5,1):\n ints[h][k] = 0.0\n ints_inner[h][k] = 0.0\n\n for k in np.arange(0, 2, 1):\n for h in np.arange(0, 2, 1):\n for ix in np.arange(0, self.stepp + 1, 1):\n for iy in np.arange(0, self.stepp + 1, 1):\n #print(k, h, ix, iy)\n if self.qc_format == 0 :\n x = -(1 + self.G) + h * (1 + 2 * self.G) + (ix * (1.0 / self.stepp))\n y = -(1 + self.G) + k * (1 + 2 * self.G) + (iy * (1.0 / self.stepp))\n if self.spot_radius == 0 or math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)) == 0 :\n tp = 0.0\n else :\n tp = (math.sin((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))) / ((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))\n tp = math.pow(tp,2)\n #print(tp)\n elif self.qc_format == 1 :\n x = -1 + h + (ix * (1 / self.stepp))\n y = -1 + k + (iy * (1 / self.stepp))\n ints[h + 1][k + 1] += math.pow(math.exp((math.pow((x - xc1),2) + math.pow((y - yc1),2) ) / math.pow(self.spot_radius,2)), -1)\n if (self.spot_radius * self.spot_radius) == 0 or ((x - xc1) * (y - yc1) * np.pi * np.pi) == 0 :\n tp = 0.0\n else :\n tp = (math.sin((x - xc1) * np.pi / self.spot_radius) * math.sin((y - yc1) * np.pi / self.spot_radius)) / (((x - xc1) * (y - yc1) * np.pi * np.pi) / (self.spot_radius * self.spot_radius))\n\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.radius_inner,2):\n ints_inner[h + 1][k + 1] += tp\n else :\n if self.qc_format == 1 :\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.cell_qc, 2):\n ints[h + 1][k + 1] += tp\n if (math.pow(x,2) + math.pow(y,2)) <= 1 :\n #print(math.pow(x,2) + math.pow(y,2))\n ints[h + 1][k + 1] += tp\n # print(ints[h + 1][k + 1])\t\t\t\t\t\t\n tp = 0.0\n\n # print(ints)\n\n Aq = 0.0\n Bq = 0.0\n Cq = 0.0\n Dq = 0.0\n Ac_inner = 0.0\n Bc_inner = 0.0\n Cc_inner = 0.0\n Dc_inner = 0.0\n Ac = 0.0\n Bc = 0.0\n Cc = 0.0\n Dc = 0.0\n Ac = ints[1][2]\n Bc = ints[2][2]\n Cc = ints[2][1]\n Dc = ints[1][1]\n\n Ac_inner = ints_inner[1][2]\n Bc_inner = ints_inner[2][2]\n Cc_inner = ints_inner[2][1]\n Dc_inner = ints_inner[1][1]\n Ac *= self.QE\n Bc *= self.QE\n Cc *= self.QE\n Dc *= self.QE\n\n Ac_inner *= self.QE_inner\n Bc_inner *= self.QE_inner\n Cc_inner *= self.QE_inner\n Dc_inner *= self.QE_inner\n Ac += Ac_inner\n Bc += Bc_inner\n Cc += Cc_inner\n Dc += Dc_inner\n\n Aq = Ac\n Bq = Bc\n Cq = Cc\n Dq = Dc\n\n #tp/TP = cotribution percentage of the spot with respect to max (spot center)\n if self.smooth == 0 :\n if (Config.hplk_c0_e * self.TP) == 0 :\n cnst = 0\n else :\n cnst = ((Parameters.TPS / (self.n_ml * self.n_ml)) * self.lamb) / (Config.hplk_c0_e * self.TP) #Número de fótons efeticos\n if Config.flag_spice == 1 :\n Ac *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP) #W\n Bc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\n Cc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\n Dc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\n Ac *= 1 / (math.pow(self.cell_qc * 1e-6,2)) #W/(m^2)\n Bc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\n Cc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\n Dc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\n #Ac *= 1 / (self.lamb * 1e6); #Adequação da irradiância para a unidade W/m2micm conforme necessário no SPICE\n #Bc *= 1 / (self.lamb * 1e6);\n #Cc *= 1 / (self.lamb * 1e6);\n #Dc *= 1 / (self.lamb * 1e6);\n \n ############################## DOUBLE CHECK ##############################\n # self.grava_arquivos = 1\n # self.flag_V_QC = 0\n # grava_le_arquivos(0) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n # self.flag_V_QC = 1\n # self.grava_arquivos = 0\n ############################## DOUBLE CHECK ##############################\n Aq *= cnst * 1e9\n Bq *= cnst * 1e9\n Cq *= cnst * 1e9\n Dq *= cnst * 1e9\n else :\n Aq *= cnst * 1e9\n Bq *= cnst * 1e9\n Cq *= cnst * 1e9\n Dq *= cnst * 1e9\n\n # 'returns' all the intensities\n self.A_intensity = Aq\n self.B_intensity = Bq\n self.C_intensity = Cq\n self.D_intensity = Dq","def __init__(self, dim): #, length_scale, length_scale_bounds=()):\n# assert isinstance(column, (list, tuple, int)), \"must be int or list of ints\"\n# self.column = [column] if isinstance(column, int) else column\n# assert all(isinstance(i, int) for i in self.column), \"must be integers\"\n self.dim = dim\n \n kernels = [Projection([c]) for c in range(dim)]\n\n # combine the kernels into a single product kernel\n self.kernel = reduce(lambda k0, k1 : k0 * k1, kernels)","def init_compute(params):\n\n # unzip dictionary and assign parameters\n N, M, K, T = params.values()\n\n p0 = np.fft.fftfreq(N, 1.0 / N)\n x0 = np.arange(0, 2 * np.pi, 2 * np.pi / N)\n\n p_time_evolution = np.zeros((N, T), dtype=\"complex_\")\n x_time_evolution = np.zeros((N, T), dtype=\"complex_\")\n p_time_evolution[:, 0] = p0\n x_time_evolution[:, 0] = x0\n\n # Initialise b,c tensor to hold b,c matrices iteravtively\n b_tensor = np.zeros((N, N, T), dtype=\"complex_\")\n c_tensor = np.zeros((N, N, T), dtype=\"complex_\")\n c_trace = np.zeros(T, dtype=\"complex_\")\n for i in range(T - 1): # Evolve\n b = coeff_b(N, N) * p_time_evolution[:, i]\n c = b @ b.T.conj()\n print(c.trace())\n c_trace[i] = c.trace()\n p_time_evolution[:, i + 1] = evolve(\n p_time_evolution[:, i],\n \"momentum\",\n x_time_evolution[:, i],\n p_time_evolution[:, i],\n params,\n )\n x_time_evolution[:, i + 1] = evolve(\n x_time_evolution[:, i],\n \"position\",\n x_time_evolution[:, i],\n p_time_evolution[:, i],\n params,\n )\n b_tensor[:, :, i], c_tensor[:, :, i] = b, c\n return b_tensor, c_tensor","def exact(self, roots):\n self.tensornet = Circuit(self.nspins + self.nmagnons)\n for n in range(self.nmagnons):\n self.tensornet.add(gates.X(n))\n for i, m in enumerate(range(self.nmagnons, 0, -1)):\n for n in range(self.nspins):\n self.tensornet.add(gates.Unitary(self._r_matrix_xxz(roots[i]), n + m - 1, n + m))\n return self.tensornet","def _excitonic_coft_old(self,SS,AG,n):\n \n # FIXME: works only for 2 level molecules\n \n c0 = AG.monomers[0].get_egcf((0,1))\n Nt = len(c0)\n \n # SystemBathInteraction\n sbi = AG.get_SystemBathInteraction()\n # CorrelationFunctionMatrix\n cfm = sbi.CC\n \n # get number of monomeric basis states\n Na = 0\n for monomer in AG.monomers:\n Na += monomer.nel-1\n \n ct = numpy.zeros((Nt),dtype=numpy.complex128)\n #Na = AG.nmono\n for kk in range(Na):\n \n #nkk = AG.monomers[kk].egcf_mapping[0]\n \n for ll in range(Na):\n \n #nll = AG.monomers[ll].egcf_mapping[0]\n \n ct += ((SS[kk+1,n+1]**2)*(SS[ll+1,n+1]**2)*cfm.get_coft(kk,ll))\n #*AG.egcf_matrix.get_coft(nkk,nll))\n \n return ct","def surface(self):\n # return sum(np.outer(basis_function, control_point) for basis_function, control_point in zip(self.basis_1, self.basis)).T\n # return sum(np.outer(basis_function_1, self.control_net[ii, jj]) for ((ii, basis_function_1), (jj, basis_function_2)) in zip(enumerate(self.basis_1), enumerate(self.basis_2))).T\n # return sum(np.outer(basis_function_1, self.control_net[ii, jj]) + np.outer(basis_function_2, self.control_net[ii, jj]) for ((ii, basis_function_1), (jj, basis_function_2)) in zip(enumerate(self.basis_1), enumerate(self.basis_2))).T\n\n # x = np.zeros_like(self.xi_1_mesh)\n # y = np.zeros_like(self.xi_1_mesh)\n # z = np.zeros_like(self.xi_1_mesh)\n xyz = np.zeros((*self.xi_1_mesh.shape, 3))\n for (i, basis_function_i), (j, basis_function_j) in itertools.product(enumerate(self.basis_1), enumerate(self.basis_2)):\n print(i, basis_function_i)\n print(j, basis_function_j)\n print(self.control_net[i, j])\n # b1, b2 = np.meshgrid(basis_function_i, basis_function_j, indexing = 'ij')\n control_x, control_y, control_z = self.control_net[i, j]\n # print(b1.shape, b2.shape, np.array(self.control_net[i, j]).shape)\n # print((b1 * b2).shape)\n # z += np.outer(b1 * b2, self.control_net[i, j])\n # print(np.shape(z))\n print(np.outer(basis_function_i, basis_function_j))\n # x += np.outer(basis_function_i, basis_function_j) * control_x\n # y += np.outer(basis_function_i, basis_function_j) * control_y\n # z += np.outer(basis_function_i, basis_function_j) * control_z\n print(np.outer(basis_function_i, basis_function_j).shape)\n print(np.outer(np.outer(basis_function_i, basis_function_j), self.control_net[i, j]).shape)\n print(np.outer(np.outer(basis_function_i, basis_function_j), np.array(self.control_net[i, j])).shape)\n r = np.einsum('i,j,k->ijk', basis_function_i, basis_function_j, np.array(self.control_net[i, j]))\n print(r.shape)\n xyz += r\n\n # print(x, y, z)\n\n # return x, y, z\n return xyz","def cell_setup(self):\n p = self.project\n c = p.NewCell(0, area=1000, with_surfacewater=True)\n vgm = cmf.VanGenuchtenMualem()\n vgm.fit_w0()\n for d in self.depth:\n vgm.Ksat = 10 * 2 ** -d\n c.add_layer(d, vgm)\n c.install_connection(cmf.Richards)\n c.install_connection(cmf.GreenAmptInfiltration)\n return CmfConnector(c, 5)","def _simulate_all_cells(self):\n for ID in tqdm(self.condition_dict, desc='Simulating cells'):\n for n in range(len(self.condition_dict[ID])):\n cond_dict = self.condition_dict[ID][n]\n g, tc, rsh_mult, rs_mult, Io_mult, Il_mult, nnsvth_mult = cond_dict['E'], cond_dict['Tc'], cond_dict[\n 'Rsh_mult'], cond_dict['Rs_mult'], cond_dict['Io_mult'], cond_dict['Il_mult'], cond_dict['nnsvth_mult']\n # calculate the 5 parameters for each set of cell conditions\n\n # Eventually, replace this with derived 5-parameters\n iph, io, rs, rsh, nnsvth = pvlib.pvsystem.calcparams_cec(effective_irradiance=g, temp_cell=tc,\n alpha_sc=self.cell_parameters['alpha_sc'],\n a_ref=self.cell_parameters['a_ref'],\n I_L_ref=self.cell_parameters['I_L_ref'],\n I_o_ref=self.cell_parameters['I_o_ref'],\n R_sh_ref=self.cell_parameters['R_sh_ref'],\n R_s=self.cell_parameters['R_s'],\n Adjust=self.cell_parameters['Adjust'])\n rs, rsh, io, iph, nnsvth = rs * rs_mult, rsh * \\\n rsh_mult, io * Io_mult, iph * Il_mult, nnsvth * nnsvth_mult\n\n # calculate cell IV curves by condition, rather than by cell index\n voc_est = pvlib.singlediode.estimate_voc(iph, io, nnsvth)\n v = voltage_pts(self.num_points_in_IV, voc_est,\n self.module_parameters['breakdown_voltage'])\n i = pvlib.singlediode.bishop88_i_from_v(v, iph, io, rs, rsh, nnsvth,\n breakdown_factor=self.module_parameters['breakdown_factor'],\n breakdown_voltage=self.module_parameters[\n 'breakdown_voltage'],\n breakdown_exp=self.module_parameters['breakdown_exp'])\n\n # @dev: Uncomment if debugging pvlib bishop88 simulation results\n # plt.plot(v,i)\n # plt.xlim(-5,v[-1])\n # plt.ylim(0,iph+1)\n # plt.title(f\"{ID}: {n} :: {rs},\"\n # f\"{rsh}, {io}, {iph}, {nnsvth}\")\n # plt.show()\n\n self.condition_dict[ID][n]['V'] = v\n self.condition_dict[ID][n]['I'] = i\n self.condition_dict[ID][n]['E'] = g\n self.condition_dict[ID][n]['Tc'] = tc\n return","def equation(self):\n mat = np.empty((self.nunknowns, self.model.neq))\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\n for icp in range(self.ncp):\n istart = icp * self.nlayers\n ieq = 0\n for e in self.model.elementlist:\n if e.nunknowns > 0:\n fluxin = self.intflux(e.disvecinflayers, self.xcin[icp], self.ycin[icp],\n self.xcin[icp + 1], self.ycin[icp + 1], self.layers, aq=self.aqin)\n fluxout = self.intflux(e.disvecinflayers, self.xcout[icp], self.ycout[icp],\n self.xcout[icp + 1], self.ycout[icp + 1], self.layers, aq=self.aqout)\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = fluxin - fluxout\n ieq += e.nunknowns\n else:\n fluxin = self.intflux(e.disveclayers, self.xcin[icp], self.ycin[icp],\n self.xcin[icp + 1], self.ycin[icp + 1], self.layers, aq=self.aqin)\n fluxout = self.intflux(e.disveclayers, self.xcout[icp], self.ycout[icp],\n self.xcout[icp + 1], self.ycout[icp + 1], self.layers, aq=self.aqout)\n rhs[istart:istart + self.nlayers] -= fluxin - fluxout\n return mat, rhs","def compute_centrifugal(self):\r\n # update the coordinates\r\n self.get_coords()\r\n\r\n # compute the centrifugal force\r\n self.centrifugal.assign(project(\r\n -1*self.rho*cross(self.omega, cross(self.omega, self.r)), self.V))","def T(self):\n # TODO - your code here\n transpose = []\n for col in range(self.w):\n new_row = []\n for row in range(self.h):\n new_row.append(self.g[row][col])\n transpose.append(new_row)\n return Matrix(transpose)\n # TODO - your code here","def solid(t, coord, ii, n_pixels, random_values):\n\n\n return (100,100,100)","def Controlled2(U):\n '''Generalized controlled unitary tensor construction\n Parameters:\n -----------\n U: input tensor which is assumed to be a square Matrix\n\n Returns:\n --------\n Controlled unitary\n\n '''\n shp = U.shape\n new_ten = scipy.linalg.block_diag(np.eye(*shp), U)\n return new_ten.reshape(2, shp[0], 2, shp[1], 2, shp[2])","def g_tensor(self,gpara,gperp,zeta_a):\n gx = gperp\n gy = gperp\n gz = gpara\n\n self.gx = gx\n self.gy = gy\n self.gz = gz\n self.g_grid = np.array([[gx*gx, gx*gy, gx*gz],[gy*gx, gy*gy, gy*gz],[gz*gx, gz*gy, gz*gz]])\n # rotate the crystal coordinates so that I'm now in the coordinate system \n # given by the zeeman tensor's principal axes\n self.a = Ry(zeta_a) @ self.a\n self.b = Ry(zeta_a) @ self.b\n self.c = Ry(zeta_a) @ self.c","def mesh_uniform(N_e, d, Omega):","def hexapodZernikeMultiLinearModel_hexapodcoordinate():\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\n Vfile = '/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_validate.cp'\n b=p.load(open(Tfile))\n vb=p.load(open(Vfile))\n nobs = len(b)\n x = b[:,0]\n y = b[:,1]\n z = b[:,2]\n theta = b[:,3]\n phi = b[:,4]\n fwhm = b[:,5]\n e1 = b[:,6]\n e2 = b[:,7]\n thetax = theta*np.cos(np.deg2rad(phi))\n thetay = theta*np.sin(np.deg2rad(phi))\n xh = x*1000 # convert to hexapod coordinate\n yh = -y*1000\n zh = -z*1000\n xtilth = - thetay\n ytilth = - thetax\n dataX = b[:,8:68]\n coeff_xh = sm.WLS(xh,dataX).fit().params\n coeff_yh = sm.WLS(yh,dataX).fit().params\n coeff_zh = sm.WLS(zh,dataX).fit().params\n coeff_xtilth = sm.WLS(xtilth,dataX).fit().params\n coeff_ytilth = sm.WLS(ytilth,dataX).fit().params\n coeff = np.array([coeff_xh,coeff_yh,coeff_zh,coeff_xtilth,coeff_ytilth])\n vx = vb[:,0]\n vy = vb[:,1]\n vz = vb[:,2]\n vtheta = vb[:,3]\n vphi = vb[:,4]\n vfwhm = vb[:,5]\n ve1 = vb[:,6]\n ve2 = vb[:,7]\n vthetax = vtheta*np.cos(np.deg2rad(vphi))\n vthetay = vtheta*np.sin(np.deg2rad(vphi))\n vxh = vx*1000 # convert to hexapod coordinate\n vyh = -vy*1000\n vzh = -vz*1000\n vxtilth = - vthetay\n vytilth = - vthetax\n vdataX = vb[:,8:68]\n fit = np.dot(vdataX,coeff.T)\n bp.bin_scatter(vxh,fit[:,0],nbins=20,fmt='bo',scatter=True)\n bp.bin_scatter(vyh,fit[:,1],nbins=20,fmt='bo',scatter=True)\n bp.bin_scatter(vzh,fit[:,2],nbins=20,fmt='bo',scatter=True)\n bp.bin_scatter(vxtilth,fit[:,3],nbins=20,fmt='bo',scatter=True)\n bp.bin_scatter(vytilth,fit[:,4],nbins=20,fmt='bo',scatter=True)","def update_concentrations_batch(self): \n #--- Update the cell concentrations ---\n # dX_i/dt = mu_i*(1-rmp/100)*X_i*(1 - sum(i,(1-rmp/100)X(i))/carrying_capacity) or \n # (X_i(t+dt) - X_i(t))/dt = mu*(1-rmp/100)*X_i(t)*(1 - sum(i,(1-rmp/100)*X_i(t))/carrying_capacity)\n # where rmp is the random mortality percentage\n # If concentration is negative set it to zero\n members_gDW_per_ml_total = sum([(1 - self.random_mortality_percentage/100)*member.organism.gDW_per_ml[self._t] for member in self.community_members])\n self._logisticG_factor_gDW_per_ml = 1 - members_gDW_per_ml_total/self.carrying_capacity['gDW_per_ml']\n if len([member for member in self.community_members if member.organism.cells_per_ml != None]) == len(self.community_members):\n members_cells_per_ml_total = sum([(1 - self.random_mortality_percentage/100)*member.organism.cells_per_ml[self._t] for member in self.community_members])\n self._logisticG_factor_cells_per_ml = 1 - members_cells_per_ml_total/self.carrying_capacity['cells_per_ml']\n\n for member in self.community_members:\n # We always need gDW_per_ml to update compound concentrations but\n # providing cells_per_ml is optional\n member.organism.gDW_per_ml[self._t + self._dt] = max(member.organism.mu[self._t]*(1-self.random_mortality_percentage/100)*member.organism.gDW_per_ml[self._t]*self._logisticG_factor_gDW_per_ml*self._dt + member.organism.gDW_per_ml[self._t],0)\n\n if member.organism.cells_per_ml is not None:\n member.organism.cells_per_ml[self._t + self._dt] = max(member.organism.mu[self._t]*(1 - self.random_mortality_percentage/100)*member.organism.cells_per_ml[self._t]*self._logisticG_factor_cells_per_ml*self._dt + member.organism.cells_per_ml[self._t],0)\n\n # Total death rate (** newly added for DMMM_mortality **)\n if member.organism.mu[self._t] < 0:\n # In thise case random_mortality_rate has already been incorporated into mu\n # (see DMMM.py)\n member.organism.total_death_rate[self._t] = member.organism.mu[self._t] \n else:\n member.organism.total_death_rate[self._t] = member.organism.random_mortality_rate\n\n\n #--- Update shared compound concentrations ---\n # dC/dt = f where, f = sum(k,v_export_k*X_k) - sum(k,v_uptake_k*X_k) + dead_pool_rate\n # (C(t+dt) - c(t))/dt = sum(k,v_export_k*X_k) - sum(k,v_uptake_k*X_k) + dead_pool \n # where, dead_pool_rate = sum(k,-self.cell_pool_factor*cell_pool_concentration_k*total_death_rate_k*X_k)\n # Here, cell_pool_concentration is the concentration of the compound pool \n # per gDW or per cells, which should have already been assigned to each \n # shared compound. The minus sign is because total_death_rate is negative\n # while dead_pool_rate must be non-negative. Here, self.cell_pool_factor is\n # the factor that should be multiplied by concentration of that compound \n # (this is because sometimes we want to explore how the growth is affected if \n # the cell pool is higher than the ones reported experimentally)\n total_cmps_conc = sum([cmp.concentration[self._t] for cmp in self.shared_compounds])\n self._logisticG_factor_cmps = 1 - total_cmps_conc/self.carrying_capacity['compounds_mM']\n self._f = dict([(cmp,None) for cmp in self.shared_compounds])\n\n if not hasattr(self,'cell_pool_factor'):\n self.cell_pool_factor = 1\n\n for shared_cmp in self.shared_compounds:\n dead_pool_rate = -sum([self.cell_pool_factor*shared_cmp.cell_pool_concentration[member.organism.id]*member.organism.total_death_rate[self._t]*1000*member.organism.gDW_per_ml[self._t] for member in self.community_members])\n if dead_pool_rate < 0:\n raise userError('dead_pool_rate is negative')\n\n f = sum([r.flux[self._t]*1000*r.model.organism.gDW_per_ml[self._t] for r in shared_cmp.reactions]) + dead_pool_rate\n self._f[shared_cmp] = f\n\n conc = f*self._logisticG_factor_cmps*self._dt + shared_cmp.concentration[self._t]\n\n if conc >= 0 or (conc < 0 and abs(conc) <= 1e-9):\n conc = max(conc,0)\n\n shared_cmp.concentration[self._t + self._dt] = conc","def olivine():\n\n rho = 3355.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 320.5; C[0,1] = 68.15; C[0,2] = 71.6; C[0,3] = 0.; C[0,4] = 0.; C[0,5] = 0.\n C[1,0] = C[0,1]; C[1,1] = 196.5; C[1,2] = 76.8; C[1,3] = 0.; C[1,4] = 0.; C[1,5] = 0.\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 233.5; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 64.; C[3,4] = 0.; C[3,5] = 0.\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 77.; C[4,5] = 0.\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 78.7\n\n return C, rho","def calc_C(h, x0, nu_C, W):\n M = len(nu_C)\n C = np.zeros((W, M), dtype=float)\n N = len(h)\n B = np.zeros((2 * N + 2, W))\n x = x0 * np.arange(0, N + 1, dtype=float) / N\n h_ext = np.concatenate(([1.0], h))\n rhs = np.r_[np.ones(N + 1, dtype=float), np.zeros(N + 1, dtype=float)]\n rhs[0] = rhs[0] / np.sqrt(2.0)\n rhs[N] = rhs[N] / np.sqrt(2.0)\n for m, nu_val in enumerate(nu_C):\n for r in range(W):\n k = r - (W / 2) + 1\n B[:N + 1, r] = h_ext * np.cos(2 * np.pi * (k - nu_val) * x)\n B[N + 1:, r] = h_ext * np.sin(2 * np.pi * (k - nu_val) * x)\n B[0, :] = B[0, :] / np.sqrt(2.0)\n B[N, :] = B[N, :] / np.sqrt(2.0)\n B[N + 1, :] = B[N + 1, :] / np.sqrt(2.0)\n B[2 * N + 1, :] = B[2 * N + 1, :] / np.sqrt(2.0)\n q, r = np.linalg.qr(B)\n C[:, m] = solve_triangular(r, np.dot(q.transpose(), rhs))\n # C[:,m] = np.linalg.lstsq(B, rhs)[0]\n return C"],"string":"[\n \"def get_sc(self):\\n sc = []\\n a = np.array([1, 0, 0], dtype=np.float32)\\n b = np.array([0, 1, 0], dtype=np.float32)\\n c = np.array([0, 0, 1], dtype=np.float32)\\n # order z -> y -> x\\n for i, j, k in itertools.product(*itertools.repeat(range(-(self.nsc//2),self.nsc//2+1), 3)):\\n sc.append(i*a + j*b + k*c)\\n sc = np.stack(sc, axis=0)\\n #print(sc.shape)\\n\\n with tf.variable_scope(\\\"supercell\\\"):\\n sc = tf.constant(sc, dtype=tf.float32)\\n return sc\",\n \"def cubic_evolve(self,nt=1):\\n #loop through time steps\\n for l in range(nt):\\n # temporary array\\n y_temp = np.zeros(self.y.shape[0])\\n # loop through array\\n for i in range(self.y.shape[0]):\\n # idx left to departure point\\n x_dep = self.x[i]-self.u[i]*self.dt\\n j = int(np.floor(x_dep/self.dx))\\n # alpha\\n a = (self.x[i]-self.u[i]*self.dt - j*self.dx)/self.dx\\n # calculate next time step\\n f = lambda x: x % self.y.shape[0] if x >= self.y.shape[0] else x\\n y_temp[i] = - a * (1-a)*(2-a)/6 * self.y[f(j-1)]\\n y_temp[i] += (1-a**2)*(2-a)/2 * self.y[f(j)]\\n y_temp[i] += a*(1+a)*(2-a)/2 * self.y[f(j+1)]\\n y_temp[i] -= a*(1-a**2)/6 * self.y[f(j+2)]\\n self.y = np.copy(y_temp)\\n return self.y\",\n \"def Cijkl(C):\\n c = np.zeros(shape=(3, 3, 3, 3))\\n CC = np.zeros(shape=(9, 9))\\n CC[0:6, 0:6] = C[0:6, 0:6]\\n CC[6:9, 6:9] = C[3:6, 3:6]\\n CC[0:6, 6:9] = C[0:6, 3:6]\\n CC[6:9, 0:6] = C[3:6, 0:6]\\n\\n c[0, 0, 0, 0] = CC[0, 0]\\n c[0, 0, 1, 1] = CC[0, 1]\\n c[0, 0, 2, 2] = CC[0, 2]\\n c[0, 0, 1, 2] = CC[0, 3]\\n c[0, 0, 2, 0] = CC[0, 4]\\n c[0, 0, 0, 1] = CC[0, 5]\\n c[0, 0, 2, 1] = CC[0, 6]\\n c[0, 0, 0, 2] = CC[0, 7]\\n c[0, 0, 1, 0] = CC[0, 8]\\n\\n c[1, 1, 0, 0] = CC[1, 0]\\n c[1, 1, 1, 1] = CC[1, 1]\\n c[1, 1, 2, 2] = CC[1, 2]\\n c[1, 1, 1, 2] = CC[1, 3]\\n c[1, 1, 2, 0] = CC[1, 4]\\n c[1, 1, 0, 1] = CC[1, 5]\\n c[1, 1, 2, 1] = CC[1, 6]\\n c[1, 1, 0, 2] = CC[1, 7]\\n c[1, 1, 1, 0] = CC[1, 8]\\n\\n c[2, 2, 0, 0] = CC[2, 0]\\n c[2, 2, 1, 1] = CC[2, 1]\\n c[2, 2, 2, 2] = CC[2, 2]\\n c[2, 2, 1, 2] = CC[2, 3]\\n c[2, 2, 2, 0] = CC[2, 4]\\n c[2, 2, 0, 1] = CC[2, 5]\\n c[2, 2, 2, 1] = CC[2, 6]\\n c[2, 2, 0, 2] = CC[2, 7]\\n c[2, 2, 1, 0] = CC[2, 8]\\n\\n c[1, 2, 0, 0] = CC[3, 0]\\n c[1, 2, 1, 1] = CC[3, 1]\\n c[1, 2, 2, 2] = CC[3, 2]\\n c[1, 2, 1, 2] = CC[3, 3]\\n c[1, 2, 2, 0] = CC[3, 4]\\n c[1, 2, 0, 1] = CC[3, 5]\\n c[1, 2, 2, 1] = CC[3, 6]\\n c[1, 2, 0, 2] = CC[3, 7]\\n c[1, 2, 1, 0] = CC[3, 8]\\n\\n c[2, 0, 0, 0] = CC[4, 0]\\n c[2, 0, 1, 1] = CC[4, 1]\\n c[2, 0, 2, 2] = CC[4, 2]\\n c[2, 0, 1, 2] = CC[4, 3]\\n c[2, 0, 2, 0] = CC[4, 4]\\n c[2, 0, 0, 1] = CC[4, 5]\\n c[2, 0, 2, 1] = CC[4, 6]\\n c[2, 0, 0, 2] = CC[4, 7]\\n c[2, 0, 1, 0] = CC[4, 8]\\n\\n c[0, 1, 0, 0] = CC[5, 0]\\n c[0, 1, 1, 1] = CC[5, 1]\\n c[0, 1, 2, 2] = CC[5, 2]\\n c[0, 1, 1, 2] = CC[5, 3]\\n c[0, 1, 2, 0] = CC[5, 4]\\n c[0, 1, 0, 1] = CC[5, 5]\\n c[0, 1, 2, 1] = CC[5, 6]\\n c[0, 1, 0, 2] = CC[5, 7]\\n c[0, 1, 1, 0] = CC[5, 8]\\n\\n c[2, 1, 0, 0] = CC[6, 0]\\n c[2, 1, 1, 1] = CC[6, 1]\\n c[2, 1, 2, 2] = CC[6, 2]\\n c[2, 1, 1, 2] = CC[6, 3]\\n c[2, 1, 2, 0] = CC[6, 4]\\n c[2, 1, 0, 1] = CC[6, 5]\\n c[2, 1, 2, 1] = CC[6, 6]\\n c[2, 1, 0, 2] = CC[6, 7]\\n c[2, 1, 1, 0] = CC[6, 8]\\n\\n c[0, 2, 0, 0] = CC[7, 0]\\n c[0, 2, 1, 1] = CC[7, 1]\\n c[0, 2, 2, 2] = CC[7, 2]\\n c[0, 2, 1, 2] = CC[7, 3]\\n c[0, 2, 2, 0] = CC[7, 4]\\n c[0, 2, 0, 1] = CC[7, 5]\\n c[0, 2, 2, 1] = CC[7, 6]\\n c[0, 2, 0, 2] = CC[7, 7]\\n c[0, 2, 1, 0] = CC[7, 8]\\n\\n c[1, 0, 0, 0] = CC[8, 0]\\n c[1, 0, 1, 1] = CC[8, 1]\\n c[1, 0, 2, 2] = CC[8, 2]\\n c[1, 0, 1, 2] = CC[8, 3]\\n c[1, 0, 2, 0] = CC[8, 4]\\n c[1, 0, 0, 1] = CC[8, 5]\\n c[1, 0, 2, 1] = CC[8, 6]\\n c[1, 0, 0, 2] = CC[8, 7]\\n c[1, 0, 1, 0] = CC[8, 8]\\n return c\",\n \"def construct_basis_tensors(self):\\n\\t\\n\\tu = np.array([self.cth*self.cphi, self.cth*self.sphi, -self.sth])\\n\\tv = np.array([self.sphi, -self.cphi, 0.0])\\n\\n\\tep = np.outer(u,u) - np.outer(v,v)\\n\\tec = np.outer(u,v) + np.outer(v,u)\\n\\t\\n\\tself.ep = self.c2psi*ep - self.s2psi*ec\\n\\tself.ec = self.s2psi*ep + self.c2psi*ec\\n\\t\\t\\n\\treturn\",\n \"def _C(self):\\n\\n # Find the local x and y coordinates at each node\\n xi = 0\\n yi = 0\\n xj = self.width()\\n yj = 0\\n xm = xj\\n ym = self.height()\\n xn = 0\\n yn = ym\\n\\n # Calculate the [C] coefficient matrix\\n C = array([[1, xi, yi, xi**2, xi*yi, yi**2, xi**3, xi**2*yi, xi*yi**2, yi**3, xi**3*yi, xi*yi**3],\\n [0, 0, 1, 0, xi, 2*yi, 0, xi**2, 2*xi*yi, 3*yi**2, xi**3, 3*xi*yi**2],\\n [0, -1, 0, -2*xi, -yi, 0, -3*xi**2, -2*xi*yi, -yi**2, 0, -3*xi**2*yi, -yi**3],\\n \\n [1, xj, yj, xj**2, xj*yj, yj**2, xj**3, xj**2*yj, xj*yj**2, yj**3, xj**3*yj, xj*yj**3],\\n [0, 0, 1, 0, xj, 2*yj, 0, xj**2, 2*xj*yj, 3*yj**2, xj**3, 3*xj*yj**2],\\n [0, -1, 0, -2*xj, -yj, 0, -3*xj**2, -2*xj*yj, -yj**2, 0, -3*xj**2*yj, -yj**3],\\n\\n [1, xm, ym, xm**2, xm*ym, ym**2, xm**3, xm**2*ym, xm*ym**2, ym**3, xm**3*ym, xm*ym**3],\\n [0, 0, 1, 0, xm, 2*ym, 0, xm**2, 2*xm*ym, 3*ym**2, xm**3, 3*xm*ym**2],\\n [0, -1, 0, -2*xm, -ym, 0, -3*xm**2, -2*xm*ym, -ym**2, 0, -3*xm**2*ym, -ym**3],\\n\\n [1, xn, yn, xn**2, xn*yn, yn**2, xn**3, xn**2*yn, xn*yn**2, yn**3, xn**3*yn, xn*yn**3],\\n [0, 0, 1, 0, xn, 2*yn, 0, xn**2, 2*xn*yn, 3*yn**2, xn**3, 3*xn*yn**2],\\n [0, -1, 0, -2*xn, -yn, 0, -3*xn**2, -2*xn*yn, -yn**2, 0, -3*xn**2*yn, -yn**3]])\\n \\n # Return the coefficient matrix\\n return C\",\n \"def construct_linear_system(self):\\n N=self.grid.Ncells()\\n Nbc = len(self.dirichlet_bcs)\\n self.Ncalc=Ncalc = N - Nbc\\n\\n # map cells to forced values\\n dirichlet = dict( [ (c,v) for c,v,xy in self.dirichlet_bcs])\\n\\n self.is_calc_c = is_calc_c = np.ones(N,np.bool8)\\n for c,v,xy in self.dirichlet_bcs:\\n is_calc_c[c] = False\\n\\n # is_calc_c[self.c_mask] = False\\n\\n # c_map is indexed by real cell indices, and returns the matrix index\\n c_map = self.c_map = np.zeros(N,np.int32)\\n self.c_map[is_calc_c] = np.arange(Ncalc)\\n\\n dzc=self.dzc\\n dzf=self.dzf\\n area_c=self.area_c\\n\\n meth='coo' # 'dok'\\n if meth == 'dok':\\n A=sparse.dok_matrix((Ncalc,Ncalc),np.float64)\\n else:\\n # construct the matrix from a sequence of indices and values\\n ij=[]\\n values=[] # successive value for the same i.j will be summed\\n \\n b = np.zeros(Ncalc,np.float64)\\n flux_per_gradient_j = -self.K_j * self.l_j * dzf / self.d_j * self.dt\\n\\n self.grid.edge_to_cells() # makes sure that edges['cells'] exists.\\n \\n for j in range(self.grid.Nedges()):\\n e = self.grid.edges[j]\\n ic1,ic2 = e['cells']\\n \\n if ic1<0 or ic2<0 or e['deleted']:\\n continue # boundary edge, or deleted edge\\n \\n flux_per_gradient=flux_per_gradient_j[j]\\n \\n # this is the desired operation:\\n # Cdiff[ic1] -= flux_per_gradient / (An[ic1]*dzc) * (C[ic2] - C[ic1])\\n # Cdiff[ic2] += flux_per_gradient / (An[ic2]*dzc) * (C[ic2] - C[ic1])\\n # Where Cdiff is row, C is col\\n\\n if is_calc_c[ic1] and is_calc_c[ic2]:\\n mic2 = c_map[ic2]\\n mic1 = c_map[ic1]\\n v1=flux_per_gradient / (area_c[ic1]*dzc[ic1])\\n v2=flux_per_gradient / (area_c[ic2]*dzc[ic2])\\n \\n if meth == 'dok':\\n A[mic1,mic2] -= v1\\n A[mic1,mic1] += v1\\n A[mic2,mic2] += v2\\n A[mic2,mic1] -= v2\\n else:\\n ij.append( (mic1,mic2) ) ; values.append(-v1)\\n ij.append( (mic1,mic1) ) ; values.append(v1)\\n ij.append( (mic2,mic2) ) ; values.append(v1)\\n ij.append( (mic2,mic1) ) ; values.append(-v1)\\n \\n elif not ( is_calc_c[ic1] or is_calc_c[ic2] ):\\n # both are dirichlet, so nothing to do\\n pass\\n elif not is_calc_c[ic2]:\\n mic1 = c_map[ic1]\\n v=flux_per_gradient / (self.area_c[ic1]*dzc[ic1])\\n if meth == 'dok':\\n A[mic1,mic1] += v\\n else:\\n ij.append( (mic1,mic1) )\\n values.append(v)\\n\\n # roughly\\n # A[1,1]*x[1] + A[1,2]*x[2] + ... = b[1]\\n # but we already know x[2],\\n # A[1,1]*x[1] + ... = b[1] - A[1,2]*x[2]\\n # so flip the sign, multiply by known dirichlet value, and\\n # add to the RHS\\n b[mic1] += flux_per_gradient / (area_c[ic1]*dzc[ic1]) * dirichlet[ic2]\\n else: # not is_calc_c[c1]\\n mic2 = c_map[ic2]\\n # A[mic2,mic2] += flux_per_gradient / (area_c[ic2]*dzc[ic2])\\n # A[mic2,mic1] -= flux_per_gradient / (area_c[ic2]*dzc[ic2])\\n\\n # A[mic2,mic2]*x[2] + A[mic2,mic1]*x[1] = b[2]\\n # ...\\n # A[mic2,mic2]*x[2] - flux_per_gradient / (area_c[ic2]*dzc[ic2])*x[1] = b[2]\\n # ...\\n # A[mic2,mic2]*x[2] = b[2] + flux_per_gradient / (area_c[ic2]*dzc[ic2])*x[1]\\n v=flux_per_gradient / (area_c[ic2]*dzc[ic2])\\n if meth == 'dok':\\n A[mic2,mic2] += v\\n else:\\n ij.append( (mic2,mic2) )\\n values.append(v)\\n b[mic2] += flux_per_gradient / (area_c[ic2]*dzc[ic2]) * dirichlet[ic1]\\n\\n # Used to test 'is not 0:' but modern python complains\\n if isinstance(self.alpha,np.ndarray): \\n for c in range(N):\\n if self.is_calc_c[c]:\\n mic=self.c_map[c]\\n v=self.alpha[c]*self.dt\\n if meth == 'dok':\\n A[mic,mic] -= v\\n else:\\n ij.append( (mic,mic) )\\n values.append(-v)\\n\\n # Flux boundary conditions:\\n for ic,value,xy in self.neumann_bcs:\\n mic=c_map[ic]\\n # make mass/time into concentration/step\\n # arrived at minus sign by trial and error.\\n # 2023-08-04: there was a bug here that used ic2 instead of ic.\\n b[mic] -= value/(area_c[ic]*dzc[ic]) * self.dt\\n\\n if meth == 'dok':\\n self.A = sparse.coo_matrix(A)\\n else:\\n ijs=np.array(ij,dtype=np.int32)\\n data=np.array(values,dtype=np.float64)\\n A=sparse.coo_matrix( (data, (ijs[:,0],ijs[:,1]) ), shape=(Ncalc,Ncalc) )\\n self.A=A\\n \\n # report scale to get a sense of whether dt is too large\\n Ascale = A.diagonal().min()\\n log.debug(\\\"Ascale is %s\\\"%Ascale)\\n\\n self.b = b\",\n \"def cell_cnc_tracker(Out, U, V, W, t, cell0, cellG, cellD, SHP, cryoconite_locations):\\n\\n Cells = np.random.rand(len(t),SHP[0],SHP[1],SHP[2]) * cell0\\n CellD = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellD\\n CellG = np.zeros(shape=(SHP[0],SHP[1],SHP[2])) + cellG\\n \\n \\n for i in np.arange(0,SHP[0],1):\\n CellG[i,:,:] = np.where(cryoconite_locations==True, CellG[i,:,:]*1000, CellG[i,:,:])\\n \\n for t in np.arange(0,len(Out.Qz[:,0,0,0]),1):\\n \\n for layer in np.arange(0,len(Out.Qz[0,:,0,0]),1):\\n\\n # normalise lateral flow so that -ve= flow out of cells towards edges\\n # and positive flow is towards centre line. In Qx -ve = leftwards flow\\n # and +ve = rightwards flow. This leads to a rightwards drift in cell\\n # fluxes if not normalised in this way.\\n U[t,layer,:,0:int(U.shape[2]/2)] = 0-U[t,layer,:,0:int(U.shape[2]/2)]\\n\\n # nabla is the inverted delta operator used to denote the divergence \\n # of a vector field, here applied to hydrological flow in m3/d \\n # calculated as dx/dt + dy/dt + dz/dt\\n\\n nabla = (U[t,layer,:,:] + V[t,layer,:,:] + W[t,layer,:,:])\\n \\n # divergence gives net in/outflow in m3/t\\n # cells/m3 = cells/mL *1000\\n\\n delC = Out.Q[t,layer,:,:] * (1+CellG[layer,:,:] - CellD[layer,:,:])\\n\\n Cells[t,layer,:,:] = Cells[t,layer,:,:] + (delC * 1000) \\n\\n Cells[Cells<0] = 0\\n \\n CellColumnTot = Cells.sum(axis=1)\\n \\n\\n return Cells, CellColumnTot\",\n \"def antigorite():\\n\\n rho = 2620.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 208.4; C[0,1] = 66.2; C[0,2] = 15.9; C[0,3] = 0.; C[0,4] = 2.4; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = 201.6; C[1,2] = 5.; C[1,3] = 0.; C[1,4] = -4.4; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 96.7; C[2,3] = 0.; C[2,4] = 2.5; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 17.4; C[3,4] = 0.; C[3,5] = -13.1\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 18.3; C[4,5] = 0.\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 65.\\n\\n return C, rho\",\n \"def get_cells(self):\\r\\n return \\\\\\r\\n (self.nx-1 if self.nx>1 else 1)* \\\\\\r\\n (self.ny-1 if self.ny>1 else 1)* \\\\\\r\\n (self.nz-1 if self.nz>1 else 1)\",\n \"def forward(self, x):\\n # l1\\n #print(\\\"INIT SIZE\\\", torch.cuda.max_memory_allocated())\\n #print(\\\"L1\\\")\\n #print(\\\"input\\\", x.shape)\\n e1 = self.ec_init(x)\\n #print(\\\"init\\\", e1.shape)\\n syn1 = self.ec11(e1) # init right - l1\\n #print(\\\"syn1\\\", syn1.shape)\\n #print(\\\"L2\\\")\\n e2 = self.bilinear(syn1, 32, 32, size=self.sizes[2]) # l1-2\\n #print(\\\"e2\\\", e2.shape)\\n # l2\\n syn2 = self.ec22(e2) # right l2 (concat later)\\n #print(\\\"syn2\\\", syn2.shape)\\n del e1, e2\\n e3 = self.bilinear(syn2, 32, 32, size=self.sizes[3]) # l2-3\\n #print(\\\"L3\\\")\\n #print(\\\"e3\\\", e3.shape)\\n # l3\\n syn3 = self.ec33(e3) # right l3 (concat later)\\n #print(\\\"syn3\\\", syn3.shape)\\n del e3 # delete\\n #print(\\\"L4\\\")\\n e41 = self.bilinear(syn3, 32, 64, size=self.sizes[4]) # l3-l4\\n #print(\\\"e41\\\", e41.shape)\\n\\n # l4\\n e42 = self.ec441(e41) # right 1 l4\\n #print(\\\"e42\\\", e42.shape) \\n syn4 = self.ec442(e42) # right 2 l4 (concat later)\\n #print(\\\"syn4\\\", syn4.shape)\\n del e41, e42\\n #print(\\\"L5\\\")\\n e51 = self.bilinear(syn4, 64, 128, size=self.sizes[5]) # l4-l5\\n #print(\\\"e51\\\", e51.shape)\\n # l5\\n e52 = self.ec551(e51) # right 1\\n #print(\\\"e52\\\", e52.shape)\\n syn5 = self.ec552(e52) # right 2\\n #print(\\\"syn5\\\", syn5.shape)\\n del e51, e52\\n #print(\\\"L6\\\")\\n e61 = self.bilinear(syn5, 128, 128, size=self.sizes[6]) # l5-l6\\n #print(\\\"e61\\\", e61.shape)\\n \\n # l6\\n e62 = self.ec661(e61) # right 1\\n #print(\\\"e62\\\", e62.shape)\\n syn6 = self.ec662(e62) # right 2\\n #print(\\\"syn6\\\", syn6.shape)\\n del e61, e62\\n #print(\\\"L7\\\")\\n e71 = self.bilinear(syn6, 128, 256, size=self.sizes[7]) #l6-7\\n #print(\\\"e71\\\", e71.shape)\\n \\n # l7\\n e72 = self.ec771(e71) # right 1 (green)\\n #print(\\\"e72\\\", e72.shape)\\n syn7 = self.ec772(e72) # right 2 (turq)\\n #print(\\\"syn7\\\", syn7.shape)\\n del e71, e72\\n\\n #print(\\\"L8\\\")\\n\\n #e_bottom_left = self.bilinear(syn7, 256, 4092, size=self.sizes[8]) # l7-l8\\n e_bottom_left = self.bilinear(syn7, 256, 256, size=self.sizes[8]) # l7-l8\\n #print(\\\"e_b_l\\\", e_bottom_left.shape)\\n\\n # l8 - the very bottom most encoded\\n e_bottom_left = e_bottom_left.view(e_bottom_left.size(0), -1)\\n batch_size = e_bottom_left.size()[0]\\n e_bottom_right = self.ec88(e_bottom_left)\\n # TODO - change the view so that 1st arg is batch size again\\n e_bottom_right = e_bottom_right.view(batch_size, e_bottom_right.size(1), 1,1,1)\\n #print(\\\"e_b_r\\\", e_bottom_right.shape)\\n\\n #print(\\\"SIZE BEFORE DEL\\\", torch.cuda.max_memory_allocated())\\n if torch.cuda.is_available():\\n torch.cuda.empty_cache()\\n #print(\\\"SIZE AFTER DEL\\\", torch.cuda.max_memory_allocated())\\n\\n ## DECODE ##\\n #print(\\\"TO CONCAT:\\\")\\n #print(\\\"Shape1\\\", self.bilinear(e_bottom_right, 4096, 256, size=self.sizes2[7]).shape)\\n #print(\\\"Shape1\\\", self.bilinear(e_bottom_right, 256, 256, size=self.sizes2[7]).shape)\\n #print(\\\"syn7 \\\", syn7.shape)\\n # QUESTION - check this is a simple cat - says \\\"copy and stack\\\"\\n #d71 = torch.cat((self.bilinear(e_bottom_right, 4096, 256, size=self.sizes2[7]), syn7), dim=1) # concat on level 7\\n d71 = torch.cat((self.bilinear(e_bottom_right, 256, 256, size=self.sizes2[7]), syn7), dim=1) # concat on level 7\\n #print(\\\"d71 (post cat)\\\", d71.shape)\\n del e_bottom_left, e_bottom_right\\n d72 = self.dc77(d71) # move right on level 7 (decode)\\n #print(\\\"d72 (decoded)\\\", d72.shape)\\n del d71, syn7\\n\\n # TODO - finish\\n d61 = torch.cat((self.bilinear(d72, 256, 128, size=self.sizes2[6]), syn6), dim=1)\\n del d72, syn6\\n d62 = self.dc66(d61)\\n\\n d51 = torch.cat((self.bilinear(d62, 128, 128, size=self.sizes2[5]), syn5), dim=1)\\n del d61, d62, syn5\\n d52 = self.dc55(d51)\\n\\n d41 = torch.cat((self.bilinear(d52, 128, 64, size=self.sizes2[4]), syn4), dim=1)\\n del d51, d52, syn4\\n d42 = self.dc44(d41)\\n\\n d31 = torch.cat((self.bilinear(d42, 64, 32, size=self.sizes2[3]), syn3), dim=1)\\n del d41, d42, syn3\\n d32 = self.dc33(d31)\\n\\n d21 = torch.cat((self.bilinear(d32, 32, 32, size=self.sizes2[2]), syn2), dim=1)\\n del d31, d32, syn2\\n d22 = self.dc22(d21)\\n\\n d11 = torch.cat((self.bilinear(d22, 32, 32, size=self.sizes2[1]), syn1), dim=1)\\n del d21, d22, syn1\\n d12 = self.dc11(d11)\\n return d12\\n \\\"\\\"\\\"\\n del d11\\n # QUESTION\\n # is this right or is there only 1 rightward step at top layer\\n d0 = self.dc10(d12)\\n return d0\\n \\\"\\\"\\\"\",\n \"def C(t):\\n out = [0.]*D #: For each t we return a list of D coordinates\\n for d in range(D): #: Iterate over 0-indexed dimension indices\\n out[d] = S(t,d)\\n return out\",\n \"def manipulate_heat_data(self): \\n self.exh.T_array = ( 0.5 * (self.exh.T_inlet_array +\\n self.exh.T_outlet_array) + 273.15)\\n self.exh.delta_T_array = ( self.exh.T_inlet_array -\\n self.exh.T_outlet_array )\\n \\n self.cool.delta_T_array = ( self.cool.T_inlet_array -\\n self.cool.T_outlet_array )\\n self.cool.C = self.cool.mdot * self.cool.c_p\",\n \"def _build_c_phi_matrices_noiseless(self, t: tf.Tensor) -> tf.Tensor:\\n c_phi_matrices = self.kernel.compute_c_phi(t, t)\\\\\\n + tf.expand_dims(tf.eye(self.n_points_int, dtype=tf.float64), 0)\\\\\\n * self.jitter\\n return c_phi_matrices\",\n \"def ket(i, dims):\\n if not isinstance(i, list):\\n i=[i]\\n #Single qubit\\n if len(i)==1:\\n val = np.zeros((dims,1))\\n val[i] = 1\\n return val.reshape(dims,1)\\n #multiple qubits. we need to tensor them together\\n val = np.ones((1,1)) #initialize variable, so we have something to tensor with, the first time\\n for x in i:\\n val = np.tensordot(val,ket([x],dims), axes=0).transpose(0,2,1,3)\\n val = val.reshape(val.shape[0]*val.shape[1],val.shape[2]*val.shape[3])\\n return val.reshape(val.shape[0],1)\",\n \"def bra(i, dims):\\n if not isinstance(i, list):\\n i=[i]\\n #Single qubit\\n if len(i)==1:\\n val = np.zeros((dims,1))\\n val[i] = 1\\n return val.reshape(1,dims)\\n #multiple qubits. we need to tensor them together\\n val = np.ones((1,1)) #initialize variable, so we have something to tensor with, the first time\\n for x in i:\\n val = np.tensordot(val,ket([x],dims), axes=0).transpose(0,2,1,3)\\n val = val.reshape(val.shape[0]*val.shape[1],val.shape[2]*val.shape[3])\\n return val.reshape(1,val.shape[0])\",\n \"def grid_unit_cell(self):\\n from cctbx import uctbx\\n a = self.unit_cell_parameters[0] / self.unit_cell_grid[0]\\n b = self.unit_cell_parameters[1] / self.unit_cell_grid[1]\\n c = self.unit_cell_parameters[2] / self.unit_cell_grid[2]\\n alpha,beta,gamma = self.unit_cell_parameters[3:6]\\n return uctbx.unit_cell((a,b,c,alpha,beta,gamma))\",\n \"def heatbasic(u0,T,K):\\n import numpy as np\\n N = len(u0)-1\\n\\n dx = 1.0/N;\\n dt = 0.1/K;\\n x = np.linspace(0,1,N+1)\\n\\n u = np.copy(u0)\\n\\n u_history = [u]\\n\\n A = np.zeros( (N+1,N+1) )\\n for i in range(1,N):\\n A[i,i-1] = 1;\\n A[i,i] = -2;\\n A[i,i+1] = 1\\n A = A * dt/(dx*dx)\\n A = A + np.eye(N+1)\\n A[0,0] = 0.0;\\n A[N,N] = 0.0;\\n\\n for k in range(K):\\n u = np.dot(A,u)\\n u_history.append(u)\\n\\n return u_history\",\n \"def __updateMatC(self):\\n\\t\\tif self.regScheme == 2:\\n\\t\\t\\tfor id1 in range(self.nTemplates):\\n\\t\\t\\t\\tself.C[id1,id1] = 1.0 / self.w0[id1]**2\",\n \"def c(self, z, y, r, t):\\n \\n u = np.zeros( self.m ) \\n \\n return u\",\n \"def stress_tensor(self):\\n s = \\\"::: forming the Cauchy stress tensor :::\\\"\\n print_text(s, self.color)\\n epi = self.strain_rate_tensor(self.U3)\\n I = Identity(3)\\n\\n sigma = 2*self.eta*epi - self.p*I\\n return sigma\",\n \"def C3D(self, temperature: float = None) -> ArrayLike:\\n t = temperature\\n n1 = self.nu(t) / (1 - self.nu(t))\\n n2 = (1 - 2 * self.nu(t)) / (2 * (1 - self.nu(t)))\\n\\n C = np.array([[ 1, n1, n1, 0, 0, 0],\\n [n1, 1, n1, 0, 0, 0],\\n [n1, n1, 1, 0, 0, 0],\\n [ 0, 0, 0, n2, 0, 0],\\n [ 0, 0, 0, 0, n2, 0],\\n [ 0, 0, 0, 0, 0, n2]], dtype=float)\\n C *= self.E(t) * (1 - self.nu(t)) / ((1 + self.nu(t)) * (1 - 2 * self.nu(t)))\\n\\n return C\",\n \"def c_():\\r\\n c = np.array([[0, 0], [0, 100], [100, 100], [100, 80], [20, 80],\\r\\n [20, 20], [100, 20], [100, 0], [0, 0]])\\r\\n return c\",\n \"def equation(self):\\n mat = np.empty((self.nunknowns, self.model.neq))\\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\\n for icp in range(self.ncp):\\n istart = icp * self.nlayers\\n ieq = 0\\n for e in self.model.elementlist:\\n if e.nunknowns > 0:\\n qx, qy = e.disvecinflayers(self.xc[icp], self.yc[icp], self.layers)\\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\\\\n qx * self.cosnorm[icp] + qy * self.sinnorm[icp] - self.resfac[:, np.newaxis] * \\\\\\n (e.potinflayers(self.xcin[icp], self.ycin[icp], self.layers, aq=self.aq) / self.aq.Tcol[\\n self.layers] - \\\\\\n e.potinflayers(self.xcout[icp], self.ycout[icp], self.layers, aq=self.aq) / self.aq.Tcol[\\n self.layers])\\n ieq += e.nunknowns\\n else:\\n qx, qy = e.disveclayers(self.xc[icp], self.yc[icp], self.layers)\\n rhs[istart:istart + self.nlayers] -= qx * self.cosnorm[icp] + qy * self.sinnorm[icp] + self.resfac * \\\\\\n (e.potentiallayers(self.xcin[icp], self.ycin[icp], self.layers,\\n aq=self.aq) / self.aq.T[self.layers] -\\n e.potentiallayers(self.xcout[icp], self.ycout[icp],\\n self.layers, aq=self.aq) / self.aq.T[\\n self.layers])\\n return mat, rhs\",\n \"def fixed_cost(self):\\n return np.einsum('i->', self.c[self.f])\",\n \"def set_cells(self, val=None):\\t\\r\\n self._cells = \\\\\\r\\n (self.nx-1 if self.nx>1 else 1)* \\\\\\r\\n (self.ny-1 if self.ny>1 else 1)* \\\\\\r\\n (self.nz-1 if self.nz>1 else 1)\",\n \"def clinopyroxene_92():\\n\\n rho = 3327.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 257.3; C[0,1] = 85.9; C[0,2] = 76.2; C[0,3] = 0.; C[0,4] = 7.1; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = 216.2; C[1,2] = 71.8; C[1,3] = 0.; C[1,4] = 13.3; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 260.2; C[2,3] = 0.; C[2,4] = 33.7; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 80.2; C[3,4] = 0.; C[3,5] = 10.2\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 70.6; C[4,5] = 0.\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 85.8\\n\\n return C, rho\",\n \"def quartz():\\n\\n rho = 2649.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 86.9; C[0,1] = 7.6; C[0,2] = 12.; C[0,3] = 17.8; C[0,4] = 0.; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = 86.9; C[1,2] = 12.; C[1,3] = -17.8; C[1,4] = 0.; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 106.4; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 59.5; C[3,4] = 0.; C[3,5] = 0.\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 59.5; C[4,5] = -17.8\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 39.6\\n\\n return C, rho\",\n \"def iso_tensor(a, b):\\n\\n # Velocity to Lame parameters\\n mu = b*b\\n lam = a*a - 2.*mu\\n\\n # Components of Voigt matrix\\n Cii = 2.*mu + lam\\n Cij = lam\\n Cjj = mu\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = Cii; C[0,1] = Cij; C[0,2] = Cij; C[0,3] = 0.; C[0,4] = 0.; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = Cii; C[1,2] = Cij; C[1,3] = 0.; C[1,4] = 0.; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = Cii; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = Cjj; C[3,4] = 0.; C[3,5] = 0.\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = Cjj; C[4,5] = 0.\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = Cjj\\n\\n return C\",\n \"def initialize_system(self):\\n self.mfd.set_mesh(self.mesh)\\n [[div_data, div_row, div_col], \\n [div_t_data, div_t_row, div_t_col]] = self.mfd.build_div()\\n [self.m_x_coo_data, \\n m_x_coo_row, \\n m_x_coo_col] = self.mfd.build_m(save_update_info=True)\\n\\n self.m_x_coo_length = len(self.m_x_coo_data)\\n \\n # The data for the bottom right should be zeros. \\n [c_data, c_row, c_col] = self.mfd.build_bottom_right()\\n \\n [coupling_data, coupling_row, coupling_col] = self.mfd.build_coupling_terms()\\n\\n self.div = sparse.coo_matrix((np.array(div_data), \\n (np.add(np.array(div_row), \\n -self.mesh.get_number_of_faces()), \\n np.array(div_col))))\\n self.div = self.div.tocsr()\\n\\n lhs_data = self.m_x_coo_data\\n lhs_row = m_x_coo_row\\n lhs_col = m_x_coo_col\\n \\n lhs_data += div_data\\n lhs_row += div_row\\n lhs_col += div_col\\n\\n lhs_data += div_t_data\\n lhs_row += div_t_row\\n lhs_col += div_t_col \\n \\n self.c_start = len(lhs_data)\\n \\n lhs_data += c_data\\n lhs_row += c_row\\n lhs_col += c_col \\n\\n self.c_end = len(c_data)\\n\\n lhs_data += coupling_data\\n lhs_row += coupling_row\\n lhs_col += coupling_col\\n\\n # Convert m_x_coo_data to numpy array. \\n self.m_x_coo_data = np.array(self.m_x_coo_data)\\n\\n self.lhs_coo = sparse.coo_matrix((np.array(lhs_data), \\n (np.array(lhs_row), \\n np.array(lhs_col))))\\n\\n # RHS construction is for Neumann and Dirichlet \\n # boundaries specified by the mesh. \\n self.rhs_mfd = self.mfd.build_rhs()\",\n \"def Green_func(self):\\n if self.bc == True:\\n size = self.grid_size\\n else:\\n size = 2*self.grid_size\\n self.Green = np.zeros([size, size])\\n for x in range(len(self.Green[0])):\\n for y in range(len(self.Green[1])):\\n radius = np.sqrt(x**2 + y**2) \\n if radius < self.soften: \\n radius = self.soften\\n self.Green[x, y]=1/(4 * np.pi * radius)\\n if self.grid_size%2 == 0: \\n self.Green[: size//2, size//2 : ] = np.flip(self.Green[: size//2, : size//2], axis = 1) # an intermittent step - the original grid has only been flipped once (2 x the original size)\\n self.Green[ size//2 : , :] = np.flip(self.Green[: size//2, :], axis = 0)\\n else: \\n print(\\\"Exiting - Grid size is currently odd. Pleaset set to an even value.\\\")\",\n \"def six_hundred_cell(self):\\n verts = []\\n q12 = QQ(1)/2\\n base = [q12,q12,q12,q12]\\n for i in range(2):\\n for j in range(2):\\n for k in range(2):\\n for l in range(2):\\n verts.append([x for x in base])\\n base[3] = base[3]*(-1)\\n base[2] = base[2]*(-1)\\n base[1] = base[1]*(-1)\\n base[0] = base[0]*(-1)\\n for x in permutations([0,0,0,1]):\\n verts.append(x)\\n for x in permutations([0,0,0,-1]):\\n verts.append(x)\\n g = QQ(1618033)/1000000 # Golden ratio approximation\\n verts = verts + [i([q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n return Polyhedron(vertices = verts)\",\n \"def contract_tenors(self):\\n\\n\\tself.r_outer_r[:,:,0,1,:] = self.r_outer_r[:,:,0,1,:]/(1. - self.k_dot_r[0,1,:])\\n\\tself.r_outer_r[:,:,0,2,:] = self.r_outer_r[:,:,0,2,:]/(1. - self.k_dot_r[0,2,:])\\n\\t\\n\\tself.r_outer_r[:,:,1,0,:] = self.r_outer_r[:,:,1,0,:]/(1. - self.k_dot_r[1,0,:])\\n\\tself.r_outer_r[:,:,1,2,:] = self.r_outer_r[:,:,1,2,:]/(1. - self.k_dot_r[1,2,:])\\n\\t\\n\\tself.r_outer_r[:,:,2,0,:] = self.r_outer_r[:,:,2,0,:]/(1. - self.k_dot_r[2,0,:])\\n\\tself.r_outer_r[:,:,2,1,:] = self.r_outer_r[:,:,2,1,:]/(1. - self.k_dot_r[2,1,:])\\n\\n\\tself.delta_l = np.zeros((3,3,self.N),dtype=np.complex_)\\n \\n\\tself.delta_l[0,1,:] = get_l(self,0,1)\\n\\tself.delta_l[1,0,:] = get_l(self,1,0)\\n\\t\\n\\tself.delta_l[0,2,:] = get_l(self,0,2)\\n\\tself.delta_l[2,0,:] = get_l(self,2,0)\\n\\t\\n\\tself.delta_l[1,2,:] = get_l(self,1,2)\\n\\tself.delta_l[2,1,:] = get_l(self,2,1)\\n \\n\\treturn\",\n \"def eclogite_massive():\\n\\n rho = 3490.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 238.85; C[0,1] = 82.01; C[0,2] = 81.44; C[0,3] = 0.3; C[0,4] = -0.02; C[0,5] = 0.5\\n C[1,0] = C[0,1]; C[1,1] = 242.12; C[1,2] = 81.11; C[1,3] = -0.66; C[1,4] = 0.33; C[1,5] = 0.12\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 235.57; C[2,3] = -0.28; C[2,4] = 0.22; C[2,5] = 0.31\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 78.72; C[3,4] = 0.27; C[3,5] = 0.\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 78.37; C[4,5] = 0.25\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 77.91\\n\\n return C, rho\",\n \"def clinopyroxene_98():\\n\\n rho = 3190.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 237.8; C[0,1] = 83.5; C[0,2] = 80.; C[0,3] = 0.; C[0,4] = 9.; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = 183.6; C[1,2] = 59.9; C[1,3] = 0.; C[1,4] = 9.5; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 229.5; C[2,3] = 0.; C[2,4] = 48.1; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 76.5; C[3,4] = 0.; C[3,5] = 8.4\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 73.; C[4,5] = 0.\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 81.6\\n\\n return C, rho\",\n \"def make_cijkl_E_nu(E=200, nu=0.3):\\n lambd = E * nu / (1 + nu) / (1 - 2 * nu)\\n mu = E / 2 / (1 + nu)\\n cij = np.zeros((6, 6))\\n cij[(0, 1, 2), (0, 1, 2)] = lambd + 2 * mu\\n cij[(0, 0, 1, 1, 2, 2), (1, 2, 0, 2, 0, 1)] = lambd\\n cij[(3, 4, 5), (3, 4, 5)] = mu\\n # check symmetry\\n assert np.allclose(cij, cij.T)\\n # convert to order 4 tensor\\n coord_mapping = {\\n (1, 1): 1,\\n (2, 2): 2,\\n (3, 3): 3,\\n (2, 3): 4,\\n (1, 3): 5,\\n (1, 2): 6,\\n (2, 1): 6,\\n (3, 1): 5,\\n (3, 2): 4,\\n }\\n\\n cijkl = np.zeros((3, 3, 3, 3))\\n for i in range(3):\\n for j in range(3):\\n for k in range(3):\\n for l in range(3):\\n u = coord_mapping[(i + 1, j + 1)]\\n v = coord_mapping[(k + 1, l + 1)]\\n cijkl[i, j, k, l] = cij[u - 1, v - 1]\\n return cijkl, cij\",\n \"def LEIsotropic3D(self):\\n const = self.ymod / ((1+self.Nu) * (1-(2*self.Nu)))\\n a = const * self.Nu\\n b = const * (1-self.Nu)\\n c = (a-b)/2\\n Cmat = np.array(\\n [\\n [b, a, a, 0, 0, 0],\\n [a, b, a, 0, 0, 0],\\n [a, a, b, 0, 0, 0],\\n [0, 0, 0, c, 0, 0],\\n [0, 0, 0, 0, c, 0],\\n [0, 0, 0, 0, 0, c]\\n ], dtype=float)\\n stress_el = Cmat @ self.eps\\n return stress_el, Cmat\",\n \"def _build_c_phi_matrices(self, t: tf.Tensor) -> tf.Tensor:\\n c_phi_matrices = self.kernel.compute_c_phi(t, t)\\\\\\n + tf.expand_dims(tf.eye(self.n_points_int, dtype=tf.float64), 0)\\\\\\n * self.likelihood_variances\\n return c_phi_matrices\",\n \"def prepare_evaluation(self):\\n # this is called after the optimizer has discretized the graph\\n cells = [self.edges[2, 3].op, self.edges[4, 5].op, self.edges[6, 7].op]\\n\\n self._expand()\\n\\n channels = [64, 128, 256]\\n factor = 4\\n\\n for cell, c in zip(cells, channels):\\n for _, _, data in cell.edges.data():\\n data.op.update_nodes(\\n lambda node, in_edges, out_edges: _set_comb_op_channels(\\n node, in_edges, out_edges, c=c\\n ),\\n single_instances=False,\\n )\\n\\n self.edges[1, 2].set(\\\"op\\\", ops.Stem(channels[0]))\\n self.edges[2, 3].set(\\\"op\\\", cells[0].copy())\\n self.edges[3, 4].set(\\n \\\"op\\\",\\n ops.SepConv(channels[0], channels[0], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[4, 5].set(\\\"op\\\", cells[0].copy())\\n self.edges[5, 6].set(\\n \\\"op\\\",\\n ops.SepConv(channels[0], channels[1], kernel_size=3, stride=2, padding=1),\\n )\\n self.edges[6, 7].set(\\\"op\\\", cells[1].copy())\\n self.edges[7, 8].set(\\n \\\"op\\\",\\n ops.SepConv(channels[1], channels[1], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[8, 9].set(\\\"op\\\", cells[1].copy())\\n self.edges[9, 10].set(\\n \\\"op\\\",\\n ops.SepConv(channels[1], channels[2], kernel_size=3, stride=2, padding=1),\\n )\\n self.edges[10, 11].set(\\\"op\\\", cells[2].copy())\\n self.edges[11, 12].set(\\n \\\"op\\\",\\n ops.SepConv(channels[2], channels[2], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[12, 13].set(\\\"op\\\", cells[2].copy())\\n self.edges[13, 14].set(\\n \\\"op\\\",\\n ops.Sequential(\\n ops.SepConv(\\n channels[-1], channels[-1], kernel_size=3, stride=1, padding=1\\n ),\\n nn.AdaptiveAvgPool2d(1),\\n nn.Flatten(),\\n nn.Linear(channels[-1], 10),\\n ),\\n )\\n\\n self.update_edges(\\n update_func=lambda edge: _increase_channels(edge, factor),\\n scope=self.OPTIMIZER_SCOPE,\\n private_edge_data=True,\\n )\",\n \"def temp_update(self):\\n a_w = self.k / self.dx\\n a_e = self.k / self.dx\\n a_n = self.k / self.dy\\n a_s = self.k / self.dy\\n a_p = a_w + a_e + a_n + a_s + self.rho * self.cp * self.dx / self.dt\\n for i, j in ti.ndrange((1, self.nx - 1), (1, self.ny - 1)):\\n self.T[i,\\n j] = (a_w * self.T[i - 1, j] + a_e * self.T[i + 1, j] +\\n a_s * self.T[i, j - 1] + a_n * self.T[i, j + 1]) / a_p\",\n \"def equation(self):\\n mat = np.empty((self.nunknowns, self.model.neq))\\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\\n for icp in range(self.ncp):\\n istart = icp * self.nlayers\\n ieq = 0\\n for e in self.model.elementlist:\\n if e.nunknowns > 0:\\n headin = self.intpot(e.potinflayers, self.xcin[icp], self.ycin[icp],\\n self.xcin[icp + 1], self.ycin[icp + 1], self.layers,\\n aq=self.aqin) / self.aqin.Tcol[self.layers]\\n headout = self.intpot(e.potinflayers, self.xcout[icp], self.ycout[icp],\\n self.xcout[icp + 1], self.ycout[icp + 1], self.layers,\\n aq=self.aqout) / self.aqout.Tcol[self.layers]\\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = headin - headout\\n ieq += e.nunknowns\\n else:\\n headin = self.intpot(e.potentiallayers, self.xcin[icp], self.ycin[icp],\\n self.xcin[icp + 1], self.ycin[icp + 1], self.layers,\\n aq=self.aqin) / self.aqin.T[self.layers]\\n headout = self.intpot(e.potentiallayers, self.xcout[icp], self.ycout[icp],\\n self.xcout[icp + 1], self.ycout[icp + 1], self.layers,\\n aq=self.aqout) / self.aqout.T[self.layers]\\n rhs[istart:istart + self.nlayers] -= headin - headout\\n return mat, rhs\",\n \"def constructCell():\\n\\t\\tself.weightGenerate()\",\n \"def __init__(self, u1=(1,0,0), u2=(0,1,0), u3=(0,0,1)):\\n u1 = vec3(u1)\\n u2 = vec3(u2)\\n u3 = vec3(u3)\\n\\n if triple_scalar_product(u1, u2, u3) != 1:\\n print >> sys.stderr, \\\"!! Invalid lattice vectors: u1 = %s, u2 = %s, u3 = %s\\\" % (u1,u2,u3)\\n self.e1 = vec3(1,0,0)\\n self.e2 = vec3(0,1,0)\\n self.e3 = vec3(0,0,1)\\n else:\\n s1 = square(u1)\\n s2 = square(u2)\\n d12 = dot(u1, u2)\\n d23 = dot(u2, u3)\\n d13 = dot(u1, u3)\\n alpha = -d12/s1\\n gamma = -(alpha*d13 + d23)/(alpha*d12 + s2)\\n beta = -(d13 + gamma*d12)/s1\\n self.e1 = u1\\n self.e2 = u2 + alpha*u1\\n self.e3 = u3 + beta*u1 + gamma*u2\\n\\n if verbose:\\n print(\\\"e1 = %s\\\" % self.e1)\\n print(\\\"e2 = %s\\\" % self.e2)\\n print(\\\"e3 = %s\\\" % self.e3)\\n\\n self.L1 = length(self.e1)\\n self.L2 = length(self.e2)\\n self.L3 = length(self.e3)\\n self.n1 = self.e1/self.L1\\n self.n2 = self.e2/self.L2\\n self.n3 = self.e3/self.L3\\n self.cells = []\\n\\n v0 = vec3(0,0,0)\\n self.v = [v0,\\n v0 + self.e3,\\n v0 + self.e2,\\n v0 + self.e2 + self.e3,\\n v0 + self.e1,\\n v0 + self.e1 + self.e3,\\n v0 + self.e1 + self.e2,\\n v0 + self.e1 + self.e2 + self.e3]\\n\\n # Compute bounding box of cuboid\\n xs = [vk.x for vk in self.v]\\n ys = [vk.y for vk in self.v]\\n zs = [vk.z for vk in self.v]\\n vmin = vec3(min(xs), min(ys), min(zs))\\n vmax = vec3(max(xs), max(ys), max(zs))\\n\\n # Extend to nearest integer coordinates\\n ixmin = int(floor(vmin.x))\\n ixmax = int(ceil(vmax.x))\\n iymin = int(floor(vmin.y))\\n iymax = int(ceil(vmax.y))\\n izmin = int(floor(vmin.z))\\n izmax = int(ceil(vmax.z))\\n if verbose:\\n print(\\\"ixmin, ixmax = %d, %d\\\" % (ixmin,ixmax))\\n print(\\\"iymin, iymax = %d, %d\\\" % (iymin,iymax))\\n print(\\\"izmin, izmax = %d, %d\\\" % (izmin,izmax))\\n\\n # Determine which cells (and which faces within those cells) are non-trivial\\n for ix in range(ixmin, ixmax):\\n for iy in range(iymin, iymax):\\n for iz in range(izmin, izmax):\\n shift = vec3(-ix, -iy, -iz)\\n faces = [Plane(self.v[0] + shift, +self.n1),\\n Plane(self.v[4] + shift, -self.n1),\\n Plane(self.v[0] + shift, +self.n2),\\n Plane(self.v[2] + shift, -self.n2),\\n Plane(self.v[0] + shift, +self.n3),\\n Plane(self.v[1] + shift, -self.n3)]\\n\\n c = Cell(ix, iy, iz)\\n skipcell = False\\n for f in faces:\\n r = UnitCubeTest(f)\\n if r == +1:\\n # Unit cube is completely above this plane; this cell is empty\\n continue\\n elif r == 0:\\n # Unit cube intersects this plane; keep track of it\\n c.faces.append(f)\\n elif r == -1:\\n skipcell = True\\n break\\n\\n if skipcell or len(c.faces) == 0:\\n if verbose:\\n print(\\\"Skipping cell at (%d,%d,%d)\\\" % (ix,iy,iz))\\n continue\\n else:\\n self.cells.append(c)\\n if verbose:\\n print(\\\"Adding cell at (%d,%d,%d)\\\" % (ix,iy,iz))\\n\\n # For the identity remapping, use exactly one cell\\n if len(self.cells) == 0:\\n self.cells.append(Cell())\\n\\n # Print the full list of cells\\n if verbose:\\n print(\\\"%d non-empty cells\\\" % len(self.cells))\\n for c in self.cells:\\n print(\\\"Cell at (%d,%d,%d) has %d non-trivial planes\\\" % (c.ix,\\n c.iy, c.iz, len(c.faces)))\",\n \"def generate_cells(self,n_c):\\n self.n_c = n_c\\n self.cells = [Cell() for i in range(n_c)]\\n return self.cells\",\n \"def construct_A(self, N, r, t0, tf):\\n a = np.zeros((2*r,N))\\n \\n for i in range(N): \\n for j in range(r): \\n if i >= j : \\n a[j,i] = self.prod(xrange(i-(j-1), i+1))*t0**(i-j)\\n a[r+j,i] = self.prod(xrange(i-(j-1), i+1))*tf**(i-j)\\n return a\",\n \"def makeGrid(self):\\n self.h = self.step_x\\n self.k = self.step_t\\n self.t, self.x = np.meshgrid(np.arange(self.min_t, self.max_t, self.step_t), np.arange(self.min_x, self.max_x\\n , self.step_x))\",\n \"def buildReconstructionTerm(self):\\r\\n\\r\\n # shape is (batch size,)\\r\\n self.reconst = T.mean(self.log_pygx, axis=1)\",\n \"def _allEquilibriumFunc(self,cps,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks,k1M,k3M):\\n # We move from an array to a list of 2d-array for the competition over each template:\\n\\n cp=cps[0]\\n cpt = [np.reshape(cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)],(m.shape[0],m.shape[1])) for l,m in enumerate(masks)]\\n new_cpt = [np.zeros(l.shape)+1 for l in cpt]\\n new_cp = 1\\n\\n olderX = [np.zeros(m.shape[1]) for m in masks]\\n for layeridx,layer in enumerate(masks):\\n layerEq = np.zeros(layer.shape[1])\\n if(layeridx==0):\\n for inpIdx in range(layer.shape[1]):\\n #compute of Kactivs,Kinhibs;\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #compute of \\\"weights\\\": sum of kactivs and kinhibs\\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\\n x_eq = X0[inpIdx]/(1+E0*w_inpIdx/cp)\\n # update for fixed point:\\n new_cp += w_inpIdx*x_eq\\n # saving values\\n layerEq[inpIdx] = x_eq\\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\\n olderX[layeridx] = layerEq\\n else:\\n for inpIdx in range(layer.shape[1]):\\n\\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\\n #Terms for the previous layers\\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\\n #computing of new equilibrium\\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\\n layerEq[inpIdx] = x_eq\\n\\n #compute of Kactivs,Kinhibs, for the current layer:\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\\n new_cp += firstComplex + Inhib2/(E0*cp)*x_eq\\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\\n olderX[layeridx] = layerEq\\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\\n for outputsIdx in range(masks[-1].shape[0]):\\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\\n\\n Inhib = np.sum(Cinhibs*olderX[-1]/kdT[-1][outputsIdx])\\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]*cp+Inhib/cp))\\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\\n new_cp += Inhib2/(E0*cp)*x_eq\\n\\n #we know that the root should be larger than 1 so we artificially add a root barrier at 1.\\n diff_cps = np.zeros(cps.shape)\\n if new_cp>=1:\\n diff_cps[0] = cp - new_cp\\n else:\\n diff_cps[0] = 10**3\\n for l,m in enumerate(masks):\\n layer_new_cpt = np.reshape(new_cpt[l],(m.shape[0]*m.shape[1]))\\n layer_old_cpt = cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)]\\n diff_cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)] = layer_old_cpt - np.where(layer_new_cpt<1,layer_old_cpt + 10**3, layer_new_cpt)\\n return diff_cps\",\n \"def equation(self):\\n mat = np.empty((self.nunknowns, self.model.neq))\\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\\n for icp in range(self.ncp):\\n istart = icp * self.nlayers\\n ieq = 0\\n for e in self.model.elementlist:\\n if e.nunknowns > 0:\\n qx, qy = e.disvecinflayers(self.xcout[icp], self.ycout[icp], self.layers)\\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\\\\n qx * self.cosnorm[icp] + qy * self.sinnorm[icp]\\n ieq += e.nunknowns\\n else:\\n qx, qy = e.disveclayers(self.xcout[icp], self.ycout[icp], self.layers)\\n rhs[istart:istart + self.nlayers] -= qx * self.cosnorm[icp] + qy * self.sinnorm[icp]\\n return mat, rhs\",\n \"def jadeite():\\n\\n rho = 3330.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 274.; C[0,1] = 94.; C[0,2] = 71.; C[0,3] = 0.; C[0,4] = 4.; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = 253.; C[1,2] = 82.; C[1,3] = 0.; C[1,4] = 14.; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 282.; C[2,3] = 0.; C[2,4] = 28.; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 88.; C[3,4] = 0.; C[3,5] = 13.\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 65.; C[4,5] = 0.\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 94.\\n\\n return C, rho\",\n \"def equation(self):\\n mat = np.empty((self.nunknowns, self.model.neq))\\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\\n for icp in range(self.ncp):\\n istart = icp * self.nlayers\\n ieq = 0\\n for e in self.model.elementlist:\\n if e.nunknowns > 0:\\n qx, qy = e.disvecinflayers(self.xc[icp], self.yc[icp], self.layers)\\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\\\\n qx * self.cosnorm[icp] + qy * self.sinnorm[icp]\\n ieq += e.nunknowns\\n else:\\n qx, qy = e.disveclayers(self.xc[icp], self.yc[icp], self.layers)\\n rhs[istart:istart + self.nlayers] -= qx * self.cosnorm[icp] + qy * self.sinnorm[icp]\\n return mat, rhs\",\n \"def _build(self):\\n ary = np.zeros( (3,3,3), float )\\n ary[0,0,0] = ary[1,1,1] = ary[0,1,2] = ary[1,0,2] = 1.\\n ary[0,2,0] = ary[0,2,2] = ary[2,0,0] = ary[2,0,2] = 0.5\\n ary[1,2,1] = ary[1,2,2] = ary[2,1,1] = ary[2,1,2] = 0.5\\n ary[2,2,0] = ary[2,2,1] = 0.25\\n ary[2,2,2] = 0.5\\n return ary\",\n \"def _train(self):\\n return np.zeros(1, 10)\",\n \"def serpentinite_37():\\n\\n rho = 3000.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 205.52; C[0,1] = 66.36; C[0,2] = 62.29; C[0,3] = -0.1; C[0,4] = -1.48; C[0,5] = 3.86\\n C[1,0] = C[0,1]; C[1,1] = 195.79; C[1,2] = 62.53; C[1,3] = -0.37; C[1,4] = 0.2; C[1,5] = 1.54\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 193.30; C[2,3] = -1.78; C[2,4] = -0.24; C[2,5] = 0.83\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 66.17; C[3,4] = 1.47; C[3,5] = -0.57\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 64.70; C[4,5] = -0.84\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 67.83\\n\\n return C, rho\",\n \"def equation(self):\\n mat = np.empty((self.nunknowns, self.model.neq))\\n # rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\\n rhs = self.hc.copy()\\n for icp in range(self.ncp):\\n istart = icp * self.nlayers\\n # rhs[istart:istart+self.nlayers] = self.pc[]\\n ieq = 0\\n for e in self.model.elementlist:\\n if e.nunknowns > 0:\\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\\\\n e.potinflayers(self.xc[icp], self.yc[icp], self.layers) / self.aq.Tcol[self.layers]\\n if e == self:\\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] -= self.resfac[icp]\\n ieq += e.nunknowns\\n else:\\n rhs[istart:istart + self.nlayers] -= \\\\\\n e.potentiallayers(self.xc[icp], self.yc[icp], self.layers) / self.aq.T[\\n self.layers] # Pretty cool that this works, really\\n return mat, rhs\",\n \"def term_1(\\n omega1, # vorticity-1\\n omega2, # vorticity-2\\n omega3, # vorticity-3\\n enst, # enstrophy\\n nu_sgs, # turbulent viscosity\\n h = True): # spatial step size\\n #---------------------------------------------------------------------#\\n # Setting default values #\\n #---------------------------------------------------------------------#\\n if h is True:\\n h = 2.0*np.pi/64.0\\n #---------------------------------------------------------------------#\\n # Preallocating space #\\n #---------------------------------------------------------------------#\\n term = np.zeros((64,64,64))\\n #---------------------------------------------------------------------#\\n # Enstrophy term #\\n #---------------------------------------------------------------------#\\n term += np.gradient(\\\\\\n np.gradient(enst, h, edge_order=2)[2], h, edge_order=2)[2]\\n term += np.gradient(\\\\\\n np.gradient(enst, h, edge_order=2)[1], h, edge_order=2)[1]\\n term += np.gradient(\\\\\\n np.gradient(enst, h, edge_order=2)[0], h, edge_order=2)[0]\\n #---------------------------------------------------------------------#\\n # Dissipation #\\n #---------------------------------------------------------------------#\\n omega1_grad = np.gradient(omega1, h, edge_order=2)\\n omega2_grad = np.gradient(omega2, h, edge_order=2)\\n omega3_grad = np.gradient(omega3, h, edge_order=2)\\n term -= np.square(omega1_grad[2])\\n term -= np.square(omega1_grad[1])\\n term -= np.square(omega1_grad[0])\\n term -= np.square(omega2_grad[2])\\n term -= np.square(omega2_grad[1])\\n term -= np.square(omega2_grad[0])\\n term -= np.square(omega3_grad[2])\\n term -= np.square(omega3_grad[1])\\n term -= np.square(omega3_grad[0])\\n #---------------------------------------------------------------------#\\n # Applying the subgrid stress #\\n #---------------------------------------------------------------------#\\n term *= nu_sgs\\n\\n return term\",\n \"def construct_detector_tensor(self):\\n\\t\\n\\tself.x = self.Orbit.get_orbit(self.t) # get the S/C for all relevant times\\n\\t\\n\\tcalc_xi(self) # Calculate the wave variables\\n\\t\\n\\tself.rij = self.Orbit.get_seps(self.t, self.x) # calculate separation vectors between spacecraft\\n\\t\\n\\t# calculate the outer product between unit separation vectors\\n\\tself.r_outer_r = 0.5*self.Orbit.get_rOr(self.rij)\\n\\t \\n\\tcalc_k_dot_r(self)\\n\\n\\treturn\",\n \"def generator(real_init): #-1, 5, 3\\n with tf.variable_scope('rnn_gen', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\\n x_init = real_init[:,:,0] #-1, 8\\n y_init = real_init[:,:,1] #-1, 8\\n z_init = real_init[:,:,2] #-1, 8\\n \\n with tf.variable_scope('x_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\\n x_w1 = tf.get_variable('x_w1', [6, 3])\\n x_b1 = tf.get_variable('x_b1', [3])\\n x_w2 = tf.get_variable('x_w2', [9, 3])\\n x_b2 = tf.get_variable('x_b2', [3])\\n x_w3 = tf.get_variable('x_w3', [3, 1])\\n x_b3 = tf.get_variable('x_b3', [1])\\n x_w4 = tf.get_variable('x_w4', [3, 1])\\n x_b4 = tf.get_variable('x_b4', [1])\\n \\n x_full = x_init#-1, 8\\n for i in range(104):\\n x_layer1 = tf.nn.elu(tf.matmul(x_init, x_w1) + x_b1)#-1, 4\\n x_layer2 = tf.concat([x_init, x_layer1], 1)#-1, 12\\n x_layer3 = tf.nn.elu(tf.matmul(x_layer2, x_w2) + x_b2)#-1, 4\\n \\n x_mean = tf.sigmoid(tf.matmul(x_layer3, x_w3) + x_b3)#-1, 1\\n x_gamma = tf.sigmoid(tf.matmul(x_layer3, x_w4) + x_b4)#-1, 1\\n x_delta = x_mean + x_gamma * tf.random_normal(tf.shape(x_gamma), dtype = tf.float32)#-1, 1\\n x_delta_denorm = (x_delta * 2 - 1) / 80\\n x_output = tf.expand_dims(x_full[:,-1], 1) + x_delta_denorm\\n x_full = tf.concat([x_full, x_output], axis = 1)#-1, 10 + 1\\n x_init = x_full[:,-6:]\\n \\n with tf.variable_scope('y_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\\n y_w1 = tf.get_variable('y_w1', [6, 3])\\n y_b1 = tf.get_variable('y_b1', [3])\\n y_w2 = tf.get_variable('y_w2', [9, 3])\\n y_b2 = tf.get_variable('y_b2', [3])\\n y_w3 = tf.get_variable('y_w3', [3, 1])\\n y_b3 = tf.get_variable('y_b3', [1])\\n y_w4 = tf.get_variable('y_w4', [3, 1])\\n y_b4 = tf.get_variable('y_b4', [1])\\n \\n y_full = y_init#-1, 8\\n for i in range(104):\\n y_layer1 = tf.nn.elu(tf.matmul(y_init, y_w1) + y_b1)\\n y_layer2 = tf.concat([y_init, y_layer1], 1)#-1, 12\\n y_layer3 = tf.nn.elu(tf.matmul(y_layer2, y_w2) + y_b2)#-1, 4\\n \\n y_mean = tf.sigmoid(tf.matmul(y_layer3, y_w3) + y_b3) #-1, 1\\n y_gamma = tf.sigmoid(tf.matmul(y_layer3, y_w4) + y_b4) #-1, 1\\n y_delta = y_mean + y_gamma * tf.random_normal(tf.shape(y_gamma), dtype = tf.float32)#-1, 1\\n y_delta_denorm = (y_delta * 5 - 2.7) / 1700\\n y_output = tf.expand_dims(y_full[:,-1], 1) + y_delta_denorm\\n y_full = tf.concat([y_full, y_output], axis = 1)#-1, 10 + 1, 1\\n y_init = y_full[:,-6:]\\n \\n with tf.variable_scope('z_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\\n z_w1 = tf.get_variable('z_w1', [6, 3])\\n z_b1 = tf.get_variable('z_b1', [3])\\n z_w2 = tf.get_variable('z_w2', [9, 3])\\n z_b2 = tf.get_variable('z_b2', [3])\\n z_w3 = tf.get_variable('z_w3', [3, 1])\\n z_b3 = tf.get_variable('z_b3', [1])\\n z_w4 = tf.get_variable('z_w4', [3, 1])\\n z_b4 = tf.get_variable('z_b4', [1])\\n \\n z_full = z_init#-1, 8\\n for i in range(104):\\n z_layer1 = tf.nn.elu(tf.matmul(z_init, z_w1) + z_b1)\\n z_layer2 = tf.concat([z_init, z_layer1], 1)#-1, 12\\n z_layer3 = tf.nn.elu(tf.matmul(z_layer2, z_w2) + z_b2)#-1, 4\\n \\n z_mean = tf.sigmoid(tf.matmul(z_layer3, z_w3) + z_b3) #-1, 1\\n z_gamma = tf.sigmoid(tf.matmul(z_layer3, z_w4) + z_b4) #-1, 1\\n z_delta = z_mean + z_gamma * tf.random_normal(tf.shape(z_gamma), dtype = tf.float32)#-1, 1\\n z_delta_denorm = (z_delta * 3 - 2.2) / 300\\n z_output = tf.expand_dims(z_full[:,-1], 1) + z_delta_denorm\\n z_full = tf.concat([z_full, z_output], axis = 1)#-1, 10 + 1, 1\\n z_init = z_full[:,-6:]\\n \\n rand_layer1 = tf.concat([tf.expand_dims(x_full, 2), tf.expand_dims(y_full, 2), tf.expand_dims(z_full, 2)], axis = 2)#-1, 200, 3\\n rand_layer1_reshape = tf.reshape(rand_layer1, shape = (-1, 110, 3, 1))\\n output_filt = tf.ones(shape = (11, 1, 1, 1)) / 11\\n \\n rand_layer2 = tf.nn.conv2d(rand_layer1_reshape, output_filt, strides = [1,1,1,1], padding = 'VALID')\\n \\n return tf.reshape(rand_layer2, shape = (-1, 100, 3)) #-1, 110, 3\",\n \"def __init__(self, nDense1, nDense2, nDense3):\\n super(CAE, self).__init__()\\n self.dense1 = nn.Linear(nDense1, nDense2)\\n self.tanh = nn.Tanh()\\n self.dense2 = nn.Linear(nDense2, nDense3)\",\n \"def eclogite_foliated():\\n\\n rho = 3300.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 203.45; C[0,1] = 67.76; C[0,2] = 64.47; C[0,3] = 0.08; C[0,4] = 1.9; C[0,5] = -0.4\\n C[1,0] = C[0,1]; C[1,1] = 220.58; C[1,2] = 63.65; C[1,3] = 0.46; C[1,4] = 0.59; C[1,5] = 0.06\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 189.75; C[2,3] = 0.13; C[2,4] = 0.95; C[2,5] = -0.2\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 66.32; C[3,4] = -0.27; C[3,5] = 0.73\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 65.77; C[4,5] = -0.02\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 70.75\\n\\n return C, rho\",\n \"def initialize_cells(self):\\n for loc in np.ndindex(*self.shape): # TODO: see if nested for loop is faster than this\\n c = Cell(loc, self)\\n self.cells.append(c)\",\n \"def lstmcell_grad_c(input, hx, cx, w_ih, w_hh, b_ih, b_hh, dc, target=\\\"cce\\\"):\\n # things from fwd\\n whl = [w_ih, w_hh]\\n W = Concat(whl, 1) # [4*hidden_size, input_size+hidden_size]\\n b = b_ih + b_hh\\n\\n batch, input_size = get_shape(input)\\n _, hidden_size = get_shape(hx)\\n xh = akg.topi.concatenate((hx, input), 1)\\n t = akg.topi.nn.dense(xh, W, b)\\n temp_i = akg.tvm.compute((batch, hidden_size), lambda i, j: t(i, j), name=\\\"temp_i\\\")\\n i = sigmoid(temp_i)\\n temp_f = akg.tvm.compute((batch, hidden_size), lambda i, j: t(i, j + hidden_size), name=\\\"temp_f\\\")\\n f = sigmoid(temp_f)\\n temp_c_ = akg.tvm.compute((batch, hidden_size), lambda i, j: t(i, j + 2 * hidden_size), name=\\\"temp_c\\\")\\n c_ = Tanh(temp_c_)\\n\\n # starts bwd\\n # head * dh/do shape [n,]\\n dtemp_o = akg.tvm.compute((batch, hidden_size), lambda *i: 0)\\n dWo = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j: 0, name=\\\"dWo\\\")\\n\\n df = dc * cx\\n dtemp_f = f * (1 - f) * df\\n kk2 = akg.tvm.reduce_axis((0, batch))\\n dWf = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j:\\n akg.tvm.sum(xh[kk2, j] * dtemp_f(kk2, i), axis=kk2), name=\\\"dWf\\\")\\n\\n di = c_ * dc\\n dtemp_i = i * (1 - i) * di\\n kk3 = akg.tvm.reduce_axis((0, batch))\\n dWi = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j:\\n akg.tvm.sum(xh[kk3, j] * dtemp_i(kk3, i), axis=kk3), name=\\\"dWi\\\")\\n\\n dc_ = i * dc\\n dtemp_c_ = (1 - c_ * c_) * dc_\\n kk4 = akg.tvm.reduce_axis((0, batch))\\n dWc = akg.tvm.compute((hidden_size, hidden_size + input_size), lambda i, j:\\n akg.tvm.sum(xh[kk4, j] * dtemp_c_(kk4, i), axis=kk4), name=\\\"dWc\\\")\\n\\n dW = akg.topi.concatenate((dWi, dWf, dWc, dWo))\\n\\n db = akg.topi.concatenate((dtemp_i, dtemp_f, dtemp_c_, dtemp_o), 1)\\n\\n kk5 = akg.tvm.reduce_axis((0, 4 * hidden_size))\\n dxh = akg.tvm.compute((batch, hidden_size + input_size), lambda i, j:\\n akg.tvm.sum(W[kk5, j] * db[i, kk5], axis=kk5), name=\\\"dxh\\\")\\n dhx = akg.tvm.compute((batch, hidden_size), lambda i, j: dxh[i, j], name=\\\"dhx\\\")\\n dx = akg.tvm.compute((batch, input_size), lambda i, j: dxh[i, j + hidden_size], name=\\\"dx\\\")\\n\\n dcx = f * dc\\n\\n dw_ih = akg.tvm.compute(w_ih.shape, lambda i, j: dW[i, j])\\n #dw_hh = akg.tvm.compute(w_hh.shape, lambda i, j: dW[i, j + input_size])\\n\\n bhr = akg.tvm.reduce_axis((0, batch))\\n\\n db_ih = akg.tvm.compute((4 * hidden_size,), lambda i: akg.tvm.sum(db[i, bhr], axis=bhr), name=\\\"dbih\\\")\\n\\n bir = akg.tvm.reduce_axis((0, batch))\\n\\n db_hh = akg.tvm.compute((4 * hidden_size,), lambda i: akg.tvm.sum(db[i, bir], axis=bir), name=\\\"dbhh\\\")\\n\\n return dw_ih, w_hh, db_ih, db_hh, dcx, dhx, dx\",\n \"def equation(self):\\n mat = np.empty((self.nunknowns, self.model.neq))\\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\\n for icp in range(self.ncp):\\n istart = icp * self.nlayers\\n ieq = 0\\n for e in self.model.elementlist:\\n if e.nunknowns > 0:\\n qxin, qyin = e.disvecinflayers(self.xcin[icp], self.ycin[icp], self.layers, aq=self.aqin)\\n qxout, qyout = e.disvecinflayers(self.xcout[icp], self.ycout[icp], self.layers, aq=self.aqout)\\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\\\\n (qxin - qxout) * self.cosnorm[icp] + (qyin - qyout) * self.sinnorm[icp]\\n ieq += e.nunknowns\\n else:\\n qxin, qyin = e.disveclayers(self.xcin[icp], self.ycin[icp], self.layers, aq=self.aqin)\\n qxout, qyout = e.disveclayers(self.xcout[icp], self.ycout[icp], self.layers, aq=self.aqout)\\n rhs[istart:istart + self.nlayers] -= (qxin - qxout) * self.cosnorm[icp] + (qyin - qyout) * \\\\\\n self.sinnorm[icp]\\n return mat, rhs\",\n \"def hot_plate(n,c=None):\\n A,b=finite_difference(n)\\n if c is None:\\n u=linalg.spsolve(A.tocsr(),b)\\n \\n else:\\n u=linalg.spsolve(A.tocsr(),c)\\n \\n \\n x=np.linspace(1,n,n)\\n y=np.linspace(1,n,n)\\n X,Y=np.meshgrid(x,y)\\n Z=u.reshape((n,n))\\n \\n \\n \\n \\n # Plot the heat map of f over the 2-D domain.\\n plt.pcolormesh(X, Y, Z, cmap=\\\"seismic\\\")\\n plt.colorbar()\\n plt.xlim(1,n)\\n plt.ylim(1,n)\\n plt.show()\",\n \"def _mn_cor_ ( self , size = -1 , root = False ) :\\n #\\n cov = self.cov ( size , root )\\n #\\n from math import sqrt\\n #\\n if isinstance ( cov , ROOT.TMatrix ) :\\n\\n size = cov.GetNrows()\\n root = True\\n \\n else : size = cov.kRows\\n\\n ## use ROOT matrices \\n if root : cor = ROOT.TMatrix ( size , size )\\n else : cor = cov.__class__ () \\n\\n for i in range(0, size ) :\\n \\n d_i = cov ( i , i )\\n cor [ i , i ] = 1 if 0 < d_i else 0\\n \\n for j in range ( i + 1 , size ) :\\n \\n d_j = cov ( j , j )\\n \\n if 0 != cov ( i , j ) and 0 < d_i and 0 < d_j :\\n \\n if root and _rv < 6 : cor [ i ] [ j ] = cov ( i , j ) / sqrt ( d_i * d_j )\\n else : cor [ i , j ] = cov ( i , j ) / sqrt ( d_i * d_j )\\n \\n else :\\n \\n if root and _rv < 6 : cor [ i ] [ j ] = 0 \\n else : cor [ i , j ] = 0\\n\\n return cor\",\n \"def generate_julia(self, iterations, c):\\n if self.grid is None:\\n raise RuntimeError(\\\"Grid hasn't been setup - call set_grid first.\\\")\\n # Define the tensorflow variables\\n c_val = tf.constant(np.full(shape=self.grid.shape, fill_value=c, dtype=self.grid.dtype))\\n z = tf.Variable(self.grid)\\n n = tf.Variable(tf.zeros_like(c_val, tf.float32))\\n # Start the tensorflow session\\n with tf.Session():\\n tf.global_variables_initializer().run()\\n # Define the main julia algorithm - either take the square plus x, or keep z\\n\\n z_out = tf.where(tf.abs(z) < self.threshold, z ** 2 + c_val, z)\\n not_diverged = tf.abs(z_out) < self.threshold\\n step = tf.group(z.assign(z_out), n.assign_add(tf.cast(not_diverged, tf.float32)))\\n\\n for i in range(iterations):\\n step.run()\\n self.end_step = n.eval()\\n self.end_z = z_out.eval()\",\n \"def latin_hypercube(n_pts, dim):\\n X = np.zeros((n_pts, dim))\\n centers = (1.0 + 2.0 * np.arange(0.0, n_pts)) / float(2 * n_pts)\\n for i in range(dim): # Shuffle the center locataions for each dimension.\\n X[:, i] = centers[np.random.permutation(n_pts)]\\n\\n # Add some perturbations within each box\\n pert = np.random.uniform(-1.0, 1.0, (n_pts, dim)) / float(2 * n_pts)\\n X += pert\\n return X\",\n \"def init(self):\\n for i, j in ti.ndrange(self.nx, self.ny):\\n self.T[i, j] = self.inside_taichi(\\n self.Vector2(i / self.nx, j / self.ny))\",\n \"def __call__(self):\\n\\n if self.indices is []:\\n return\\n\\n\\n #-----------------------------------------\\n # Here is where the important formula is applied\\n #----------------------------------------\\n if self.indices is None:\\n height = self.stage_c - self.elev_c\\n self.friction_c[:] = self.friction(height)\\n else:\\n ind = self.indices\\n height = self.stage_c[ind] - self.elev_c[ind]\\n self.friction_c[ind] = self.friction(height)\",\n \"def equation(self):\\n mat = np.empty((self.nunknowns, self.model.neq))\\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\\n for icp in range(self.ncp):\\n istart = icp * self.nlayers\\n ieq = 0\\n for e in self.model.elementlist:\\n if e.nunknowns > 0:\\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\\\\n e.potinflayers(self.xcin[icp], self.ycin[icp], self.layers, aq=self.aqin) / self.aqin.Tcol - \\\\\\n e.potinflayers(self.xcout[icp], self.ycout[icp], self.layers, aq=self.aqout) / self.aqout.Tcol\\n ieq += e.nunknowns\\n else:\\n rhs[istart:istart + self.nlayers] -= \\\\\\n e.potentiallayers(self.xcin[icp], self.ycin[icp], self.layers, aq=self.aqin) / self.aqin.T - \\\\\\n e.potentiallayers(self.xcout[icp], self.ycout[icp], self.layers, aq=self.aqout) / self.aqout.T\\n return mat, rhs\",\n \"def add_computed_gas_concentrations(self):\\n # Extract the z-coordinate and T, S, P profile\\n zs = self.interp_ds.coords[self.ztsp[0]].values\\n Ts = self.interp_ds[self.ztsp[1]].values\\n Ss = self.interp_ds[self.ztsp[2]].values\\n Ps = self.interp_ds[self.ztsp[3]].values\\n \\n # Create an air object\\n air_names = ['nitrogen', 'oxygen', 'argon', 'carbon_dioxide']\\n yk = np.array([0.78084, 0.20946, 0.009340, 0.00036])\\n from tamoc import dbm\\n air = dbm.FluidMixture(air_names)\\n m = air.masses(yk)\\n \\n # Compute the concentrations adjusted for depth\\n Cs = np.zeros((len(zs), len(air_names)))\\n for i in range(len(zs)):\\n Cs[i,:] = air.solubility(m, Ts[i], 101325., Ss[i])[0,:] * \\\\\\n seawater.density(Ts[i], Ss[i], Ps[i]) / \\\\\\n seawater.density(Ts[i], Ss[i], 101325.)\\n \\n # Make sure none of these gases are already in the measured profile\\n for name in air_names:\\n if name in self.interp_ds:\\n air_names[air_names.index(name)] = 'computed_' + name\\n \\n # Add these data to the Profile object\\n data = np.hstack((np.atleast_2d(zs).transpose(), Cs))\\n names = [self.ztsp[0]] + air_names \\n units = [self.ztsp_units[0]] + 4*['kg/m^3']\\n self.append(data, names, units)\\n \\n # Rebuild the interpolator\\n self._build_interpolator()\",\n \"def equation(self):\\n mat = np.empty((self.nunknowns, self.model.neq))\\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\\n for icp in range(self.ncp):\\n istart = icp * self.nlayers\\n rhs[istart:istart + self.nlayers] = self.pc\\n ieq = 0\\n for e in self.model.elementlist:\\n if e.nunknowns > 0:\\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = \\\\\\n e.potinflayers(self.xc[icp], self.yc[icp], self.layers)\\n ieq += e.nunknowns\\n else:\\n rhs[istart:istart + self.nlayers] -= \\\\\\n e.potentiallayers(self.xc[icp], self.yc[icp],\\n self.layers) # Pretty cool that this works, really\\n return mat, rhs\",\n \"def circuit():\\n np.random.seed(1967)\\n for gates in gates_per_layers:\\n for gate in gates:\\n qml.apply(gate)\\n return qml.expval(qml.PauliZ(0))\",\n \"def calculate_strain(self):\\n\\t\\n\\tself.Hpij = np.zeros((3,3,self.N),dtype=np.complex_)\\n\\tself.Hcij = np.zeros((3,3,self.N),dtype=np.complex_)\\n\\t\\n\\tcalc_Hcp_ij(self)\\t\\n\\n\\tconstruct_basis_tensors(self)\\n\\n\\tcalc_Hij(self)\\n\\t\\n\\tcontract_tenors(self)\\n\\n\\treturn\",\n \"def initial_setup(N,L,dim):\\r\\n r = np.zeros((3,N))\\r\\n #n = int(np.rint((N/3)**(1/dim)))\\r\\n #nz = int(n+n)\\r\\n x1 = np.linspace(0+L/n/2,L-L/n/2,n)\\r\\n d0 = 1.0e-10 #intial distance between hydrogen and oxygen\\r\\n x2 = x1 + d0\\r\\n x3 = x1 - d0/np.sqrt(2)\\r\\n z = np.zeros(3*n)\\r\\n xy = np.zeros(3*n)\\r\\n for ii in range(n):\\r\\n z[ii*3+1] = x1[ii]\\r\\n z[ii*3+2] = x2[ii]\\r\\n z[ii*3] = x3[ii]\\r\\n xy[ii*3] = x1[ii]\\r\\n xy[ii*3+1] = x1[ii]\\r\\n xy[ii*3+2] = x1[ii]\\r\\n rx, ry,rz = np.meshgrid(x1,x1,z)\\r\\n r[0,:] = np.reshape(rx,N)\\r\\n r[1,:] = np.reshape(ry,N)\\r\\n r[2,:] = np.reshape(rz,N)\\r\\n r[0,0::3] += d0/np.sqrt(2) #add additional offset to one Oxygen\\r\\n return r\",\n \"def _build_tensor(args):\\n cells,iptr,indx,data,tid,nproc,selected,log1p = args\\n\\n for i in range(0+tid,len(cells),nproc):\\n index = selected[i]\\n sidx = iptr[index]\\n # find the number of gene entries for\\n # this cell\\n if index < len(iptr) - 1:\\n # find length to next cell\\n nentries = iptr[index + 1] - sidx \\n else:\\n # find length to the end\\n nentries = len(data) - sidx\\n\\n for j in range(0,nentries):\\n if log1p:\\n cells[i][indx[sidx+j]] = np.log(1+(data[sidx+j]))\\n else:\\n cells[i][indx[sidx+j]] = (data[sidx+j])\\n #cells[i][indx[sidx+j]] = float(data[sidx+j])\",\n \"def updateC(A, U, B):\\n \\n m_dim = A.shape[1] \\n q_dim = B.shape[0]\\n \\n C_tensor = np.zeros((m_dim, m_dim, q_dim), dtype=np.complex)\\n \\n for k in range(q_dim):\\n A_k = A[:, :, k]\\n b_k = B[k]\\n \\n x_hat = U @ b_k\\n y_hat = A_k.conj().T @ x_hat\\n \\n phase_y = np.exp(1j*np.angle(y_hat))\\n #phase_y = np.sign(y_hat)\\n C_k = np.diag(phase_y)\\n C_tensor[:, :, k] = C_k\\n \\n \\n return C_tensor\",\n \"def _generate_cells(self) -> None:\\n for i in range(15):\\n for j in range(15):\\n c = Cell(x=i, y=j)\\n c.answer = self.puzzle.solution[j*self.width+i]\\n self.cells[(j, i)] = c # row, col\",\n \"def quadraticize(self, x, u, k):\\n num_players = len(u)\\n\\n # Congert to torch.Tensor format.\\n x_torch = torch.from_numpy(x).requires_grad_(True)\\n u_torch = [torch.from_numpy(ui).requires_grad_(True) for ui in u]\\n\\n # Evaluate cost here.\\n cost_torch = self.__call__(x_torch, u_torch, k)\\n cost = cost_torch.item()\\n\\n # Compute gradients (and store numpy versions).\\n grad_x_torch = torch.autograd.grad(\\n cost_torch, x_torch, create_graph=True, allow_unused=True)[0]\\n grad_u_torch = [\\n torch.autograd.grad(\\n cost_torch, ui_torch, create_graph=True, allow_unused=True)[0]\\n for ui_torch in u_torch]\\n\\n # Compute Hessians (and store numpy versions), and be careful to\\n # catch Nones (which indicate cost not depending on a particular\\n # variable).\\n hess_x = np.zeros((len(x), len(x)))\\n grad_x = np.zeros((len(x), 1))\\n if grad_x_torch is not None:\\n grad_x = grad_x_torch.detach().numpy().copy()\\n for ii in range(len(x)):\\n hess_row = torch.autograd.grad(\\n grad_x_torch[ii, 0], x_torch, retain_graph=True)[0]\\n hess_x[ii, :] = hess_row.detach().numpy().copy().T\\n\\n hess_u = []\\n for ii in range(num_players):\\n hess_ui = np.zeros((len(u[ii]), len(u[ii])))\\n grad_ui_torch = grad_u_torch[ii]\\n if grad_ui_torch is not None:\\n grad_ui = grad_ui_torch.detach().numpy().copy()\\n for dim in range(len(u[ii])):\\n hess_row = torch.autograd.grad(\\n grad_ui_torch[dim, 0], u_torch[ii], retain_graph=True)[0]\\n hess_ui[dim, :] = hess_row.detach().numpy().copy().T\\n\\n hess_u.append(hess_ui)\\n\\n return cost, grad_x, hess_x, hess_u\",\n \"def garnet():\\n\\n rho = 3660.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 306.2; C[0,1] = 112.5; C[0,2] = 112.5; C[0,3] = 0.; C[0,4] = 0.; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = 306.2; C[1,2] = 112.5; C[1,3] = 0.; C[1,4] = 0.; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 306.2; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 92.7; C[3,4] = 0.; C[3,5] = 0.\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 92.7; C[4,5] = 0.\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 92.7\\n\\n return C, rho\",\n \"def contract(tensor):\\n temp = np.einsum('ikma, jlan', tensor, tensor)\\n M = np.zeros((tensor.shape[0]**2, tensor.shape[1]**2, tensor.shape[2], tensor.shape[3]))\\n for i,j,k,l,m,n in it.product(*[range(x) for x in temp.shape]):\\n M[i + tensor.shape[0]*j, k + tensor.shape[1]*l, m, n] = temp[i,j,k,l,m,n]\\n return M\",\n \"def lherzolite():\\n\\n rho = 3270.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 187.4; C[0,1] = 63.71; C[0,2] = 63.87; C[0,3] = 0.78; C[0,4] = 2.02; C[0,5] = -3.2\\n C[1,0] = C[0,1]; C[1,1] = 211.25; C[1,2] = 64.5; C[1,3] = -3.07; C[1,4] = 0.87; C[1,5] = -5.78\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 190.; C[2,3] = 0.38; C[2,4] = 2.38; C[2,5] = -0.12\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 67.9; C[3,4] = -2.12; C[3,5] = 1.6\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 63.12; C[4,5] = -0.55\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 66.83\\n\\n return C, rho\",\n \"def image_cube(self, i=0, channels=None, cell=1.0, imagesize=4096, pol='i'):\\n\\n # select integration and reduce pol axis\\n if ((pol == 'i') | (pol == 'I')):\\n if len(trackdata) == 2:\\n print 'Making Stokes I image as mean of two pols...'\\n else:\\n print 'Making Stokes I image as mean over all pols. Hope that\\\\'s ok...'\\n tr=self.data.mean(axis=3)[0]\\n elif isinstance(pol, types.IntType):\\n print 'Making image of pol %d' % (pol)\\n tr=self.data[0,:,:,pol]\\n \\n # res and size in aipy units (lambda)\\n # size is pixel scale (cell size)\\n size=1/n.radians(cell/60.0)\\n # full field\\n res=size/imagesize\\n fov = n.degrees(1./res)*3600. # field of view in arcseconds\\n\\n if channels is None:\\n channels=range(self.nchan)\\n\\n # form channel dependent uvw\\n u_ch = n.outer(self.u[i], self.freq/self.freq_orig[0])\\n v_ch = n.outer(self.v[i], self.freq/self.freq_orig[0])\\n w_ch = n.outer(self.w[i], self.freq/self.freq_orig[0])\\n\\n # make image\\n image=n.zeros((len(channels),size/res,size/res))\\n for c,ic in zip(channels,xrange(len(channels))):\\n print 'Creating image for channel %d...' % c\\n ai = aipy.img.Img(size=size, res=res)\\n uvw_new, tr_new = ai.append_hermitian( (u_ch[:,c], v_ch[:,c], w_ch[:,c]), tr[:,c])\\n ai.put(uvw_new, tr_new)\\n image[ic] = ai.image(center = (size/res/2, size/res/2))\\n\\n self.ai=ai\\n self.image_center=(size/res/2, size/res/2)\\n return image\",\n \"def calcAllIntensities(self, xc, yc):\\n\\n tp = 0.0\\n ix = 0\\n iy = 0\\n h = 0\\n ints = np.zeros([5, 5])\\n ints_inner = np.zeros([5, 5])\\n # ints = [[0.0] * 5] * 5\\n # ints_inner = [[0.0] * 5] * 5\\n x = 0.0\\n y = 0.0\\n xc1 = 0.0\\n yc1 = 0.0\\n xc1 = xc\\n yc1 = yc\\n \\n for h in np.arange(1,5,1):\\n for k in np.arange(1,5,1):\\n ints[h][k] = 0.0\\n ints_inner[h][k] = 0.0\\n\\n for k in np.arange(0, 2, 1):\\n for h in np.arange(0, 2, 1):\\n for ix in np.arange(0, self.stepp + 1, 1):\\n for iy in np.arange(0, self.stepp + 1, 1):\\n #print(k, h, ix, iy)\\n if self.qc_format == 0 :\\n x = -(1 + self.G) + h * (1 + 2 * self.G) + (ix * (1.0 / self.stepp))\\n y = -(1 + self.G) + k * (1 + 2 * self.G) + (iy * (1.0 / self.stepp))\\n if self.spot_radius == 0 or math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)) == 0 :\\n tp = 0.0\\n else :\\n tp = (math.sin((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))) / ((1 / self.spot_radius) * math.sqrt(math.pow((x - xc1),2) + math.pow((y - yc1),2)))\\n tp = math.pow(tp,2)\\n #print(tp)\\n elif self.qc_format == 1 :\\n x = -1 + h + (ix * (1 / self.stepp))\\n y = -1 + k + (iy * (1 / self.stepp))\\n ints[h + 1][k + 1] += math.pow(math.exp((math.pow((x - xc1),2) + math.pow((y - yc1),2) ) / math.pow(self.spot_radius,2)), -1)\\n if (self.spot_radius * self.spot_radius) == 0 or ((x - xc1) * (y - yc1) * np.pi * np.pi) == 0 :\\n tp = 0.0\\n else :\\n tp = (math.sin((x - xc1) * np.pi / self.spot_radius) * math.sin((y - yc1) * np.pi / self.spot_radius)) / (((x - xc1) * (y - yc1) * np.pi * np.pi) / (self.spot_radius * self.spot_radius))\\n\\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.radius_inner,2):\\n ints_inner[h + 1][k + 1] += tp\\n else :\\n if self.qc_format == 1 :\\n if (math.pow(x,2) + math.pow(y,2)) <= math.pow(self.cell_qc, 2):\\n ints[h + 1][k + 1] += tp\\n if (math.pow(x,2) + math.pow(y,2)) <= 1 :\\n #print(math.pow(x,2) + math.pow(y,2))\\n ints[h + 1][k + 1] += tp\\n # print(ints[h + 1][k + 1])\\t\\t\\t\\t\\t\\t\\n tp = 0.0\\n\\n # print(ints)\\n\\n Aq = 0.0\\n Bq = 0.0\\n Cq = 0.0\\n Dq = 0.0\\n Ac_inner = 0.0\\n Bc_inner = 0.0\\n Cc_inner = 0.0\\n Dc_inner = 0.0\\n Ac = 0.0\\n Bc = 0.0\\n Cc = 0.0\\n Dc = 0.0\\n Ac = ints[1][2]\\n Bc = ints[2][2]\\n Cc = ints[2][1]\\n Dc = ints[1][1]\\n\\n Ac_inner = ints_inner[1][2]\\n Bc_inner = ints_inner[2][2]\\n Cc_inner = ints_inner[2][1]\\n Dc_inner = ints_inner[1][1]\\n Ac *= self.QE\\n Bc *= self.QE\\n Cc *= self.QE\\n Dc *= self.QE\\n\\n Ac_inner *= self.QE_inner\\n Bc_inner *= self.QE_inner\\n Cc_inner *= self.QE_inner\\n Dc_inner *= self.QE_inner\\n Ac += Ac_inner\\n Bc += Bc_inner\\n Cc += Cc_inner\\n Dc += Dc_inner\\n\\n Aq = Ac\\n Bq = Bc\\n Cq = Cc\\n Dq = Dc\\n\\n #tp/TP = cotribution percentage of the spot with respect to max (spot center)\\n if self.smooth == 0 :\\n if (Config.hplk_c0_e * self.TP) == 0 :\\n cnst = 0\\n else :\\n cnst = ((Parameters.TPS / (self.n_ml * self.n_ml)) * self.lamb) / (Config.hplk_c0_e * self.TP) #Número de fótons efeticos\\n if Config.flag_spice == 1 :\\n Ac *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP) #W\\n Bc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\\n Cc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\\n Dc *= Parameters.TPS / (self.n_ml * self.n_ml * self.TP)\\n Ac *= 1 / (math.pow(self.cell_qc * 1e-6,2)) #W/(m^2)\\n Bc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\\n Cc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\\n Dc *= 1 / (math.pow(self.cell_qc * 1e-6,2))\\n #Ac *= 1 / (self.lamb * 1e6); #Adequação da irradiância para a unidade W/m2micm conforme necessário no SPICE\\n #Bc *= 1 / (self.lamb * 1e6);\\n #Cc *= 1 / (self.lamb * 1e6);\\n #Dc *= 1 / (self.lamb * 1e6);\\n \\n ############################## DOUBLE CHECK ##############################\\n # self.grava_arquivos = 1\\n # self.flag_V_QC = 0\\n # grava_le_arquivos(0) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\\n # self.flag_V_QC = 1\\n # self.grava_arquivos = 0\\n ############################## DOUBLE CHECK ##############################\\n Aq *= cnst * 1e9\\n Bq *= cnst * 1e9\\n Cq *= cnst * 1e9\\n Dq *= cnst * 1e9\\n else :\\n Aq *= cnst * 1e9\\n Bq *= cnst * 1e9\\n Cq *= cnst * 1e9\\n Dq *= cnst * 1e9\\n\\n # 'returns' all the intensities\\n self.A_intensity = Aq\\n self.B_intensity = Bq\\n self.C_intensity = Cq\\n self.D_intensity = Dq\",\n \"def __init__(self, dim): #, length_scale, length_scale_bounds=()):\\n# assert isinstance(column, (list, tuple, int)), \\\"must be int or list of ints\\\"\\n# self.column = [column] if isinstance(column, int) else column\\n# assert all(isinstance(i, int) for i in self.column), \\\"must be integers\\\"\\n self.dim = dim\\n \\n kernels = [Projection([c]) for c in range(dim)]\\n\\n # combine the kernels into a single product kernel\\n self.kernel = reduce(lambda k0, k1 : k0 * k1, kernels)\",\n \"def init_compute(params):\\n\\n # unzip dictionary and assign parameters\\n N, M, K, T = params.values()\\n\\n p0 = np.fft.fftfreq(N, 1.0 / N)\\n x0 = np.arange(0, 2 * np.pi, 2 * np.pi / N)\\n\\n p_time_evolution = np.zeros((N, T), dtype=\\\"complex_\\\")\\n x_time_evolution = np.zeros((N, T), dtype=\\\"complex_\\\")\\n p_time_evolution[:, 0] = p0\\n x_time_evolution[:, 0] = x0\\n\\n # Initialise b,c tensor to hold b,c matrices iteravtively\\n b_tensor = np.zeros((N, N, T), dtype=\\\"complex_\\\")\\n c_tensor = np.zeros((N, N, T), dtype=\\\"complex_\\\")\\n c_trace = np.zeros(T, dtype=\\\"complex_\\\")\\n for i in range(T - 1): # Evolve\\n b = coeff_b(N, N) * p_time_evolution[:, i]\\n c = b @ b.T.conj()\\n print(c.trace())\\n c_trace[i] = c.trace()\\n p_time_evolution[:, i + 1] = evolve(\\n p_time_evolution[:, i],\\n \\\"momentum\\\",\\n x_time_evolution[:, i],\\n p_time_evolution[:, i],\\n params,\\n )\\n x_time_evolution[:, i + 1] = evolve(\\n x_time_evolution[:, i],\\n \\\"position\\\",\\n x_time_evolution[:, i],\\n p_time_evolution[:, i],\\n params,\\n )\\n b_tensor[:, :, i], c_tensor[:, :, i] = b, c\\n return b_tensor, c_tensor\",\n \"def exact(self, roots):\\n self.tensornet = Circuit(self.nspins + self.nmagnons)\\n for n in range(self.nmagnons):\\n self.tensornet.add(gates.X(n))\\n for i, m in enumerate(range(self.nmagnons, 0, -1)):\\n for n in range(self.nspins):\\n self.tensornet.add(gates.Unitary(self._r_matrix_xxz(roots[i]), n + m - 1, n + m))\\n return self.tensornet\",\n \"def _excitonic_coft_old(self,SS,AG,n):\\n \\n # FIXME: works only for 2 level molecules\\n \\n c0 = AG.monomers[0].get_egcf((0,1))\\n Nt = len(c0)\\n \\n # SystemBathInteraction\\n sbi = AG.get_SystemBathInteraction()\\n # CorrelationFunctionMatrix\\n cfm = sbi.CC\\n \\n # get number of monomeric basis states\\n Na = 0\\n for monomer in AG.monomers:\\n Na += monomer.nel-1\\n \\n ct = numpy.zeros((Nt),dtype=numpy.complex128)\\n #Na = AG.nmono\\n for kk in range(Na):\\n \\n #nkk = AG.monomers[kk].egcf_mapping[0]\\n \\n for ll in range(Na):\\n \\n #nll = AG.monomers[ll].egcf_mapping[0]\\n \\n ct += ((SS[kk+1,n+1]**2)*(SS[ll+1,n+1]**2)*cfm.get_coft(kk,ll))\\n #*AG.egcf_matrix.get_coft(nkk,nll))\\n \\n return ct\",\n \"def surface(self):\\n # return sum(np.outer(basis_function, control_point) for basis_function, control_point in zip(self.basis_1, self.basis)).T\\n # return sum(np.outer(basis_function_1, self.control_net[ii, jj]) for ((ii, basis_function_1), (jj, basis_function_2)) in zip(enumerate(self.basis_1), enumerate(self.basis_2))).T\\n # return sum(np.outer(basis_function_1, self.control_net[ii, jj]) + np.outer(basis_function_2, self.control_net[ii, jj]) for ((ii, basis_function_1), (jj, basis_function_2)) in zip(enumerate(self.basis_1), enumerate(self.basis_2))).T\\n\\n # x = np.zeros_like(self.xi_1_mesh)\\n # y = np.zeros_like(self.xi_1_mesh)\\n # z = np.zeros_like(self.xi_1_mesh)\\n xyz = np.zeros((*self.xi_1_mesh.shape, 3))\\n for (i, basis_function_i), (j, basis_function_j) in itertools.product(enumerate(self.basis_1), enumerate(self.basis_2)):\\n print(i, basis_function_i)\\n print(j, basis_function_j)\\n print(self.control_net[i, j])\\n # b1, b2 = np.meshgrid(basis_function_i, basis_function_j, indexing = 'ij')\\n control_x, control_y, control_z = self.control_net[i, j]\\n # print(b1.shape, b2.shape, np.array(self.control_net[i, j]).shape)\\n # print((b1 * b2).shape)\\n # z += np.outer(b1 * b2, self.control_net[i, j])\\n # print(np.shape(z))\\n print(np.outer(basis_function_i, basis_function_j))\\n # x += np.outer(basis_function_i, basis_function_j) * control_x\\n # y += np.outer(basis_function_i, basis_function_j) * control_y\\n # z += np.outer(basis_function_i, basis_function_j) * control_z\\n print(np.outer(basis_function_i, basis_function_j).shape)\\n print(np.outer(np.outer(basis_function_i, basis_function_j), self.control_net[i, j]).shape)\\n print(np.outer(np.outer(basis_function_i, basis_function_j), np.array(self.control_net[i, j])).shape)\\n r = np.einsum('i,j,k->ijk', basis_function_i, basis_function_j, np.array(self.control_net[i, j]))\\n print(r.shape)\\n xyz += r\\n\\n # print(x, y, z)\\n\\n # return x, y, z\\n return xyz\",\n \"def cell_setup(self):\\n p = self.project\\n c = p.NewCell(0, area=1000, with_surfacewater=True)\\n vgm = cmf.VanGenuchtenMualem()\\n vgm.fit_w0()\\n for d in self.depth:\\n vgm.Ksat = 10 * 2 ** -d\\n c.add_layer(d, vgm)\\n c.install_connection(cmf.Richards)\\n c.install_connection(cmf.GreenAmptInfiltration)\\n return CmfConnector(c, 5)\",\n \"def _simulate_all_cells(self):\\n for ID in tqdm(self.condition_dict, desc='Simulating cells'):\\n for n in range(len(self.condition_dict[ID])):\\n cond_dict = self.condition_dict[ID][n]\\n g, tc, rsh_mult, rs_mult, Io_mult, Il_mult, nnsvth_mult = cond_dict['E'], cond_dict['Tc'], cond_dict[\\n 'Rsh_mult'], cond_dict['Rs_mult'], cond_dict['Io_mult'], cond_dict['Il_mult'], cond_dict['nnsvth_mult']\\n # calculate the 5 parameters for each set of cell conditions\\n\\n # Eventually, replace this with derived 5-parameters\\n iph, io, rs, rsh, nnsvth = pvlib.pvsystem.calcparams_cec(effective_irradiance=g, temp_cell=tc,\\n alpha_sc=self.cell_parameters['alpha_sc'],\\n a_ref=self.cell_parameters['a_ref'],\\n I_L_ref=self.cell_parameters['I_L_ref'],\\n I_o_ref=self.cell_parameters['I_o_ref'],\\n R_sh_ref=self.cell_parameters['R_sh_ref'],\\n R_s=self.cell_parameters['R_s'],\\n Adjust=self.cell_parameters['Adjust'])\\n rs, rsh, io, iph, nnsvth = rs * rs_mult, rsh * \\\\\\n rsh_mult, io * Io_mult, iph * Il_mult, nnsvth * nnsvth_mult\\n\\n # calculate cell IV curves by condition, rather than by cell index\\n voc_est = pvlib.singlediode.estimate_voc(iph, io, nnsvth)\\n v = voltage_pts(self.num_points_in_IV, voc_est,\\n self.module_parameters['breakdown_voltage'])\\n i = pvlib.singlediode.bishop88_i_from_v(v, iph, io, rs, rsh, nnsvth,\\n breakdown_factor=self.module_parameters['breakdown_factor'],\\n breakdown_voltage=self.module_parameters[\\n 'breakdown_voltage'],\\n breakdown_exp=self.module_parameters['breakdown_exp'])\\n\\n # @dev: Uncomment if debugging pvlib bishop88 simulation results\\n # plt.plot(v,i)\\n # plt.xlim(-5,v[-1])\\n # plt.ylim(0,iph+1)\\n # plt.title(f\\\"{ID}: {n} :: {rs},\\\"\\n # f\\\"{rsh}, {io}, {iph}, {nnsvth}\\\")\\n # plt.show()\\n\\n self.condition_dict[ID][n]['V'] = v\\n self.condition_dict[ID][n]['I'] = i\\n self.condition_dict[ID][n]['E'] = g\\n self.condition_dict[ID][n]['Tc'] = tc\\n return\",\n \"def equation(self):\\n mat = np.empty((self.nunknowns, self.model.neq))\\n rhs = np.zeros(self.nunknowns) # Needs to be initialized to zero\\n for icp in range(self.ncp):\\n istart = icp * self.nlayers\\n ieq = 0\\n for e in self.model.elementlist:\\n if e.nunknowns > 0:\\n fluxin = self.intflux(e.disvecinflayers, self.xcin[icp], self.ycin[icp],\\n self.xcin[icp + 1], self.ycin[icp + 1], self.layers, aq=self.aqin)\\n fluxout = self.intflux(e.disvecinflayers, self.xcout[icp], self.ycout[icp],\\n self.xcout[icp + 1], self.ycout[icp + 1], self.layers, aq=self.aqout)\\n mat[istart:istart + self.nlayers, ieq:ieq + e.nunknowns] = fluxin - fluxout\\n ieq += e.nunknowns\\n else:\\n fluxin = self.intflux(e.disveclayers, self.xcin[icp], self.ycin[icp],\\n self.xcin[icp + 1], self.ycin[icp + 1], self.layers, aq=self.aqin)\\n fluxout = self.intflux(e.disveclayers, self.xcout[icp], self.ycout[icp],\\n self.xcout[icp + 1], self.ycout[icp + 1], self.layers, aq=self.aqout)\\n rhs[istart:istart + self.nlayers] -= fluxin - fluxout\\n return mat, rhs\",\n \"def compute_centrifugal(self):\\r\\n # update the coordinates\\r\\n self.get_coords()\\r\\n\\r\\n # compute the centrifugal force\\r\\n self.centrifugal.assign(project(\\r\\n -1*self.rho*cross(self.omega, cross(self.omega, self.r)), self.V))\",\n \"def T(self):\\n # TODO - your code here\\n transpose = []\\n for col in range(self.w):\\n new_row = []\\n for row in range(self.h):\\n new_row.append(self.g[row][col])\\n transpose.append(new_row)\\n return Matrix(transpose)\\n # TODO - your code here\",\n \"def solid(t, coord, ii, n_pixels, random_values):\\n\\n\\n return (100,100,100)\",\n \"def Controlled2(U):\\n '''Generalized controlled unitary tensor construction\\n Parameters:\\n -----------\\n U: input tensor which is assumed to be a square Matrix\\n\\n Returns:\\n --------\\n Controlled unitary\\n\\n '''\\n shp = U.shape\\n new_ten = scipy.linalg.block_diag(np.eye(*shp), U)\\n return new_ten.reshape(2, shp[0], 2, shp[1], 2, shp[2])\",\n \"def g_tensor(self,gpara,gperp,zeta_a):\\n gx = gperp\\n gy = gperp\\n gz = gpara\\n\\n self.gx = gx\\n self.gy = gy\\n self.gz = gz\\n self.g_grid = np.array([[gx*gx, gx*gy, gx*gz],[gy*gx, gy*gy, gy*gz],[gz*gx, gz*gy, gz*gz]])\\n # rotate the crystal coordinates so that I'm now in the coordinate system \\n # given by the zeeman tensor's principal axes\\n self.a = Ry(zeta_a) @ self.a\\n self.b = Ry(zeta_a) @ self.b\\n self.c = Ry(zeta_a) @ self.c\",\n \"def mesh_uniform(N_e, d, Omega):\",\n \"def hexapodZernikeMultiLinearModel_hexapodcoordinate():\\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\\n Vfile = '/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_validate.cp'\\n b=p.load(open(Tfile))\\n vb=p.load(open(Vfile))\\n nobs = len(b)\\n x = b[:,0]\\n y = b[:,1]\\n z = b[:,2]\\n theta = b[:,3]\\n phi = b[:,4]\\n fwhm = b[:,5]\\n e1 = b[:,6]\\n e2 = b[:,7]\\n thetax = theta*np.cos(np.deg2rad(phi))\\n thetay = theta*np.sin(np.deg2rad(phi))\\n xh = x*1000 # convert to hexapod coordinate\\n yh = -y*1000\\n zh = -z*1000\\n xtilth = - thetay\\n ytilth = - thetax\\n dataX = b[:,8:68]\\n coeff_xh = sm.WLS(xh,dataX).fit().params\\n coeff_yh = sm.WLS(yh,dataX).fit().params\\n coeff_zh = sm.WLS(zh,dataX).fit().params\\n coeff_xtilth = sm.WLS(xtilth,dataX).fit().params\\n coeff_ytilth = sm.WLS(ytilth,dataX).fit().params\\n coeff = np.array([coeff_xh,coeff_yh,coeff_zh,coeff_xtilth,coeff_ytilth])\\n vx = vb[:,0]\\n vy = vb[:,1]\\n vz = vb[:,2]\\n vtheta = vb[:,3]\\n vphi = vb[:,4]\\n vfwhm = vb[:,5]\\n ve1 = vb[:,6]\\n ve2 = vb[:,7]\\n vthetax = vtheta*np.cos(np.deg2rad(vphi))\\n vthetay = vtheta*np.sin(np.deg2rad(vphi))\\n vxh = vx*1000 # convert to hexapod coordinate\\n vyh = -vy*1000\\n vzh = -vz*1000\\n vxtilth = - vthetay\\n vytilth = - vthetax\\n vdataX = vb[:,8:68]\\n fit = np.dot(vdataX,coeff.T)\\n bp.bin_scatter(vxh,fit[:,0],nbins=20,fmt='bo',scatter=True)\\n bp.bin_scatter(vyh,fit[:,1],nbins=20,fmt='bo',scatter=True)\\n bp.bin_scatter(vzh,fit[:,2],nbins=20,fmt='bo',scatter=True)\\n bp.bin_scatter(vxtilth,fit[:,3],nbins=20,fmt='bo',scatter=True)\\n bp.bin_scatter(vytilth,fit[:,4],nbins=20,fmt='bo',scatter=True)\",\n \"def update_concentrations_batch(self): \\n #--- Update the cell concentrations ---\\n # dX_i/dt = mu_i*(1-rmp/100)*X_i*(1 - sum(i,(1-rmp/100)X(i))/carrying_capacity) or \\n # (X_i(t+dt) - X_i(t))/dt = mu*(1-rmp/100)*X_i(t)*(1 - sum(i,(1-rmp/100)*X_i(t))/carrying_capacity)\\n # where rmp is the random mortality percentage\\n # If concentration is negative set it to zero\\n members_gDW_per_ml_total = sum([(1 - self.random_mortality_percentage/100)*member.organism.gDW_per_ml[self._t] for member in self.community_members])\\n self._logisticG_factor_gDW_per_ml = 1 - members_gDW_per_ml_total/self.carrying_capacity['gDW_per_ml']\\n if len([member for member in self.community_members if member.organism.cells_per_ml != None]) == len(self.community_members):\\n members_cells_per_ml_total = sum([(1 - self.random_mortality_percentage/100)*member.organism.cells_per_ml[self._t] for member in self.community_members])\\n self._logisticG_factor_cells_per_ml = 1 - members_cells_per_ml_total/self.carrying_capacity['cells_per_ml']\\n\\n for member in self.community_members:\\n # We always need gDW_per_ml to update compound concentrations but\\n # providing cells_per_ml is optional\\n member.organism.gDW_per_ml[self._t + self._dt] = max(member.organism.mu[self._t]*(1-self.random_mortality_percentage/100)*member.organism.gDW_per_ml[self._t]*self._logisticG_factor_gDW_per_ml*self._dt + member.organism.gDW_per_ml[self._t],0)\\n\\n if member.organism.cells_per_ml is not None:\\n member.organism.cells_per_ml[self._t + self._dt] = max(member.organism.mu[self._t]*(1 - self.random_mortality_percentage/100)*member.organism.cells_per_ml[self._t]*self._logisticG_factor_cells_per_ml*self._dt + member.organism.cells_per_ml[self._t],0)\\n\\n # Total death rate (** newly added for DMMM_mortality **)\\n if member.organism.mu[self._t] < 0:\\n # In thise case random_mortality_rate has already been incorporated into mu\\n # (see DMMM.py)\\n member.organism.total_death_rate[self._t] = member.organism.mu[self._t] \\n else:\\n member.organism.total_death_rate[self._t] = member.organism.random_mortality_rate\\n\\n\\n #--- Update shared compound concentrations ---\\n # dC/dt = f where, f = sum(k,v_export_k*X_k) - sum(k,v_uptake_k*X_k) + dead_pool_rate\\n # (C(t+dt) - c(t))/dt = sum(k,v_export_k*X_k) - sum(k,v_uptake_k*X_k) + dead_pool \\n # where, dead_pool_rate = sum(k,-self.cell_pool_factor*cell_pool_concentration_k*total_death_rate_k*X_k)\\n # Here, cell_pool_concentration is the concentration of the compound pool \\n # per gDW or per cells, which should have already been assigned to each \\n # shared compound. The minus sign is because total_death_rate is negative\\n # while dead_pool_rate must be non-negative. Here, self.cell_pool_factor is\\n # the factor that should be multiplied by concentration of that compound \\n # (this is because sometimes we want to explore how the growth is affected if \\n # the cell pool is higher than the ones reported experimentally)\\n total_cmps_conc = sum([cmp.concentration[self._t] for cmp in self.shared_compounds])\\n self._logisticG_factor_cmps = 1 - total_cmps_conc/self.carrying_capacity['compounds_mM']\\n self._f = dict([(cmp,None) for cmp in self.shared_compounds])\\n\\n if not hasattr(self,'cell_pool_factor'):\\n self.cell_pool_factor = 1\\n\\n for shared_cmp in self.shared_compounds:\\n dead_pool_rate = -sum([self.cell_pool_factor*shared_cmp.cell_pool_concentration[member.organism.id]*member.organism.total_death_rate[self._t]*1000*member.organism.gDW_per_ml[self._t] for member in self.community_members])\\n if dead_pool_rate < 0:\\n raise userError('dead_pool_rate is negative')\\n\\n f = sum([r.flux[self._t]*1000*r.model.organism.gDW_per_ml[self._t] for r in shared_cmp.reactions]) + dead_pool_rate\\n self._f[shared_cmp] = f\\n\\n conc = f*self._logisticG_factor_cmps*self._dt + shared_cmp.concentration[self._t]\\n\\n if conc >= 0 or (conc < 0 and abs(conc) <= 1e-9):\\n conc = max(conc,0)\\n\\n shared_cmp.concentration[self._t + self._dt] = conc\",\n \"def olivine():\\n\\n rho = 3355.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 320.5; C[0,1] = 68.15; C[0,2] = 71.6; C[0,3] = 0.; C[0,4] = 0.; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = 196.5; C[1,2] = 76.8; C[1,3] = 0.; C[1,4] = 0.; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 233.5; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 64.; C[3,4] = 0.; C[3,5] = 0.\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 77.; C[4,5] = 0.\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 78.7\\n\\n return C, rho\",\n \"def calc_C(h, x0, nu_C, W):\\n M = len(nu_C)\\n C = np.zeros((W, M), dtype=float)\\n N = len(h)\\n B = np.zeros((2 * N + 2, W))\\n x = x0 * np.arange(0, N + 1, dtype=float) / N\\n h_ext = np.concatenate(([1.0], h))\\n rhs = np.r_[np.ones(N + 1, dtype=float), np.zeros(N + 1, dtype=float)]\\n rhs[0] = rhs[0] / np.sqrt(2.0)\\n rhs[N] = rhs[N] / np.sqrt(2.0)\\n for m, nu_val in enumerate(nu_C):\\n for r in range(W):\\n k = r - (W / 2) + 1\\n B[:N + 1, r] = h_ext * np.cos(2 * np.pi * (k - nu_val) * x)\\n B[N + 1:, r] = h_ext * np.sin(2 * np.pi * (k - nu_val) * x)\\n B[0, :] = B[0, :] / np.sqrt(2.0)\\n B[N, :] = B[N, :] / np.sqrt(2.0)\\n B[N + 1, :] = B[N + 1, :] / np.sqrt(2.0)\\n B[2 * N + 1, :] = B[2 * N + 1, :] / np.sqrt(2.0)\\n q, r = np.linalg.qr(B)\\n C[:, m] = solve_triangular(r, np.dot(q.transpose(), rhs))\\n # C[:,m] = np.linalg.lstsq(B, rhs)[0]\\n return C\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6207161","0.6204961","0.5940996","0.5841021","0.5796941","0.56329495","0.56159425","0.56084204","0.5568752","0.5554606","0.55243033","0.55191934","0.5518823","0.5498849","0.5498104","0.54870147","0.54841","0.54828954","0.5440627","0.54392284","0.5436503","0.5435244","0.5417631","0.54174536","0.5417357","0.5410658","0.54092276","0.540645","0.53841597","0.53841007","0.5373968","0.5364572","0.5358811","0.5355559","0.5350235","0.5331055","0.53091717","0.5307378","0.5283032","0.52801347","0.52624035","0.5258817","0.5252909","0.52525467","0.52500474","0.5247014","0.524565","0.5245398","0.524371","0.52436554","0.52400875","0.5234638","0.5231565","0.5221726","0.5214245","0.5210638","0.52049655","0.5203474","0.51995707","0.51976556","0.5194492","0.51876676","0.51852113","0.51839143","0.5182266","0.5180817","0.518032","0.517799","0.5177523","0.5177363","0.5174638","0.5174395","0.51712877","0.5167936","0.5160271","0.51582026","0.5156096","0.5149274","0.5144298","0.5141604","0.5136723","0.5134016","0.5128254","0.51262397","0.5124898","0.5121693","0.5118353","0.5117619","0.51157486","0.51155746","0.5113964","0.51086164","0.5106659","0.5105402","0.5097187","0.5096514","0.50946087","0.5089743","0.50865734","0.50864697","0.50847983"],"string":"[\n \"0.6207161\",\n \"0.6204961\",\n \"0.5940996\",\n \"0.5841021\",\n \"0.5796941\",\n \"0.56329495\",\n \"0.56159425\",\n \"0.56084204\",\n \"0.5568752\",\n \"0.5554606\",\n \"0.55243033\",\n \"0.55191934\",\n \"0.5518823\",\n \"0.5498849\",\n \"0.5498104\",\n \"0.54870147\",\n \"0.54841\",\n \"0.54828954\",\n \"0.5440627\",\n \"0.54392284\",\n \"0.5436503\",\n \"0.5435244\",\n \"0.5417631\",\n \"0.54174536\",\n \"0.5417357\",\n \"0.5410658\",\n \"0.54092276\",\n \"0.540645\",\n \"0.53841597\",\n \"0.53841007\",\n \"0.5373968\",\n \"0.5364572\",\n \"0.5358811\",\n \"0.5355559\",\n \"0.5350235\",\n \"0.5331055\",\n \"0.53091717\",\n \"0.5307378\",\n \"0.5283032\",\n \"0.52801347\",\n \"0.52624035\",\n \"0.5258817\",\n \"0.5252909\",\n \"0.52525467\",\n \"0.52500474\",\n \"0.5247014\",\n \"0.524565\",\n \"0.5245398\",\n \"0.524371\",\n \"0.52436554\",\n \"0.52400875\",\n \"0.5234638\",\n \"0.5231565\",\n \"0.5221726\",\n \"0.5214245\",\n \"0.5210638\",\n \"0.52049655\",\n \"0.5203474\",\n \"0.51995707\",\n \"0.51976556\",\n \"0.5194492\",\n \"0.51876676\",\n \"0.51852113\",\n \"0.51839143\",\n \"0.5182266\",\n \"0.5180817\",\n \"0.518032\",\n \"0.517799\",\n \"0.5177523\",\n \"0.5177363\",\n \"0.5174638\",\n \"0.5174395\",\n \"0.51712877\",\n \"0.5167936\",\n \"0.5160271\",\n \"0.51582026\",\n \"0.5156096\",\n \"0.5149274\",\n \"0.5144298\",\n \"0.5141604\",\n \"0.5136723\",\n \"0.5134016\",\n \"0.5128254\",\n \"0.51262397\",\n \"0.5124898\",\n \"0.5121693\",\n \"0.5118353\",\n \"0.5117619\",\n \"0.51157486\",\n \"0.51155746\",\n \"0.5113964\",\n \"0.51086164\",\n \"0.5106659\",\n \"0.5105402\",\n \"0.5097187\",\n \"0.5096514\",\n \"0.50946087\",\n \"0.5089743\",\n \"0.50865734\",\n \"0.50864697\",\n \"0.50847983\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94480,"cells":{"query":{"kind":"string","value":"Converts MillerBravais plane indices to cartesian normal vectors"},"document":{"kind":"string","value":"def mbplane(A, c=sqrt(8 / 3)):\n # for Sun Mg Potential: c=1.6281689374348\n if A[0] == 0 and A[1] == 0 and A[2] == 0:\n B = np.array([0, 0, 1])\n\n else:\n if A[0] == 0:\n p1 = np.array([-0.5 / A[1], 0.5 * sqrt(3) / A[1], 0])\n p2 = np.array([-0.5 / A[2], -0.5 * sqrt(3) / A[2], 0])\n elif A[1] == 0:\n p1 = np.array([-0.5 / A[2], -0.5 * sqrt(3) / A[2], 0])\n p2 = np.array([1 / A[0], 0, 0])\n else:\n p1 = np.array([1 / A[0], 0, 0])\n p2 = np.array([-0.5 / A[1], 0.5 * sqrt(3) / A[1], 0])\n if A[3] == 0:\n z = p1 + np.array([0, 0, 1])\n else:\n z = np.array([0, 0, c / A[3]])\n\n P1 = p1 - z\n P2 = p2 - z\n B = np.cross(P1, P2)\n return B"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def plane_equation(point_a, point_b, point_c):\n v1 = np.subtract(point_a, point_c)\n v2 = np.subtract(point_a, point_b)\n normal = np.cross(v1, v2)\n # print 'b4 norm', normal\n unit_normal = norm_vect(normal)\n # print 'unityyy', unit_normal\n return unit_normal","def get_normal_vector_of_plane(p1, p2, p3):\n v12 = np.array(p1) - np.array(p2)\n v13 = np.array(p1) - np.array(p3)\n nvec = np.cross(v12, v13)\n ## print 'norm: '+str(np.linalg.norm(nvec))\n return nvec / np.linalg.norm(nvec)","def compute_normalvect(self):\n normvect = np.zeros((len(self.tri_pnts),3,3))\n zvec = np.array([0, 0, 1])\n for itri, tri in enumerate(self.tri_pnts):\n #import pdb; pdb.set_trace()\n tri0, tri1, tri2 = tri\n x1,y1 = self.points[tri1]-self.points[tri0]\n v1 = np.array([x1,y1,0])\n x2,y2 = self.points[tri2]-self.points[tri1]\n v2 = np.array([x2,y2,0])\n x3,y3 = self.points[tri0]-self.points[tri2]\n v3 = np.array([x3,y3,0])\n v1 = v1/np.linalg.norm(v1)\n v2 = v2/np.linalg.norm(v2)\n v3 = v3/np.linalg.norm(v3)\n #import pdb; pdb.set_trace()\n normvect[itri,:,:] = np.cross(v1,zvec), np.cross(v2,zvec), np.cross(v3,zvec)\n #import pdb; pdb.set_trace()\n return normvect","def MillerNormalVectors_110():\r\n k_110 = np.array([[1, 1, 0], [0, 1, 1], [1, 0, 1],\r\n [1, -1, 0], [0, 1, -1], [-1, 0, 1]])/np.sqrt(2.0)\r\n return np.array([k_110[0, :], k_110[1, :], k_110[2, :],\r\n k_110[3, :], k_110[4, :], k_110[5, :],\r\n -k_110[0, :], -k_110[1, :], -k_110[2, :],\r\n -k_110[3, :], -k_110[4, :], -k_110[5, :]])","def unit_normals(self):\n return np.stack(self.centers_cartesian(), axis=-1)","def PlaneNormalVector(h, k, l):\r\n vec = np.array([h, k, l])\r\n return vec/np.linalg.norm(vec)","def MillerNormalVectors_111():\r\n k_111 = np.array(\r\n [[1, 1, 1], [-1, 1, 1], [1, -1, 1], [1, 1, -1]])/np.sqrt(3.0)\r\n return np.array([k_111[0, :], k_111[1, :], k_111[2, :], k_111[3, :],\r\n -k_111[0, :], -k_111[1, :], -k_111[2, :], -k_111[3, :]])","def normal(self) -> Vec:\n # The three points are in clockwise order, so compute differences\n # in the clockwise direction, then cross to get the normal.\n point_1 = self.planes[1] - self.planes[0]\n point_2 = self.planes[2] - self.planes[1]\n\n return Vec.cross(point_1, point_2).norm()","def normal_vector(origin, vectors):\n return np.cross(vectors[0] - origin, vectors[1] - origin)","def getNormalizedNormalVec(self):\n TriPos = self.position\n # calc normalized normal vecor for Tri\n # get vectors Vert1Vert2 & Vert2Vert3\n TriVectors = np.subtract(TriPos[1:],TriPos[:-1])\n # get crossproduct of Vert1Vert2 & Vert2Vert3 (= surface normal)\n TriNorm = np.cross(TriVectors[0],TriVectors[1])+0.0\n # get length of surface normal\n length = np.linalg.norm(TriNorm)\n # divide each component of surface normal by length (= normalized surface normal)\n NormalizedNormalVec = np.around(TriNorm / length, decimals=5) # rounded, otherwise different values, equals not found\n # create string of tuple for segment dict \n #SegmDict = str(tuple(NormalizedNormalVec))\n return NormalizedNormalVec.tolist()","def get_normals(self):\n c, s = np.cos(self.eangles), np.sin(self.eangles)\n r = np.array([[c, -s], [s, c]])\n us = np.array([[1, 0], [0, 1], [-1, 0], [0, -1]])\n nsyms = 4 if self.halfexts[0] == self.halfexts[1] else 2\n return [(np.dot(r, u), nsyms) for u in us]","def plot_plane(unit_normal, x_array, y_array, fore):\n # print'unit normal = ', unit_normal\n z = (((unit_normal[0] * (fore[0] - x_array)) + (unit_normal[1] * (fore[1] - y_array))) / unit_normal[2]) + fore[2]\n # print 'plane numbers\\n', z\n return z","def MillerNormalVectors_100():\r\n k_100 = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])\r\n return np.array([k_100[0, :], k_100[1, :], k_100[2, :],\r\n -k_100[0, :], -k_100[1, :], -k_100[2, :]])","def unit_normals(p,q,r): \n vx1 = p[0] - r[0] # x1 - x3. \n vy1 = p[1] - r[1] # y1 - y3. \n vz1 = p[2] - r[2] # z1 - z3. \n\n vx2 = q[0] - r[0] # x2 - x3. \n vy2 = q[1] - r[1] # y2 - y3. \n vz2 = q[2] - r[2] # z2 - z3. \n\n vnx = vy1*vz2 - vz1*vy2 \n vny = vz1*vx2 - vx1*vz2 \n vnz = vx1*vy2 - vy1*vx2 \n\n len_vn = math.sqrt(vnx*vnx + vny*vny + vnz*vnz) \n vnx = vnx/len_vn \n vny = vny/len_vn \n vnz = vnz/len_vn \n\n return vnx, vny, vnz","def make_inward_normal(tetrahedron):\n\n convert_to_np_array = lambda v: np.array([v.x, v.y, v.z])\n np_vertices = list(map(convert_to_np_array, [tetrahedron.get_vertex(i) for i in range(4)]))\n # This is the middle point\n # midpoint = np.mean(np_vertices, axis=0)\n\n midpoint = np_vertices[0]\n for i in range(1, 4):\n midpoint += np_vertices[i]\n midpoint = midpoint / 2.0\n\n for i in range(4):\n face = tetrahedron.get_face(i)\n d = distance(face, midpoint)\n if d < 0:\n face.nx *= -1.0\n face.ny *= -1.0\n face.nz *= -1.0\n face.d *= -1.0","def normal(self) -> Vec:\n return abs(self.up_axis.cross(self.forward()))","def calculate_plane_normal(patches):\n normals = []\n for patch in patches:\n normal = get_normal(patch)\n normals.append(normal)\n # Taken naive mean of normals\n # TODO outlier removal\n normals = np.mean(np.array(normals), axis=0)\n return normals","def _prepare_plane(self):\n verticies = [\n # main plane - note that the mainplane is scaled so the mat_plane\n # matrix will it transform to the correct coordinates\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\n -self.i_border[0]/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], self.i_border[1]/self._scaling[1],\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\n\n # coord plane\n 0, 0,\n 0, -self.o_wh[1],\n self.o_wh[0], -self.o_wh[1],\n self.o_wh[0], -self.o_wh[1],\n self.o_wh[0], 0,\n 0, 0,\n\n # axes\n 0, -self.o_wh[1], self.o_wh[0], -self.o_wh[1], #x\n 0, 0, 0, -self.o_wh[1], #y\n ]\n\n colors = [\n 1.0, 1.0, 1.0, 1.0, # outer box XXX Remove outer box...\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n .9, .9, .9, 9.0, # plot box\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n 0.0, 0.0, 0.0, 1.0, #lines\n 0.0, 0.0, 0.0, 1.0,\n 0.0, 0.0, 0.0, 1.0,\n 0.0, 0.0, 0.0, 1.0,\n ]\n\n self._fonts = []\n for u in range(1, self._unit_count[0]+1):\n verticies.append(self._unit_w[0]*u)\n verticies.append(-self.o_wh[1]+0.02)\n verticies.append(self._unit_w[0]*u)\n verticies.append(-self.o_wh[1]-0.02)\n colors += [0.0, 0.0, 0.0, 1.0]\n colors += [0.0, 0.0, 0.0, 1.0]\n self._fonts.append([\n '{:.2f}'.format(u*(self.i_axis[0]/self._unit_count[0])-self.i_origin[0]),\n (self._unit_w[0]*u+self.i_border[0]-0.05)*self._scaling[0],\n (-self.o_wh[1]+(self.i_border[3])*0.5)\n ])\n for u in range(0, self._unit_count[1]):\n verticies.append(0.02)\n verticies.append(-self._unit_w[1]*u)\n verticies.append(-0.02)\n verticies.append(-self._unit_w[1]*u)\n colors += [0.0, 0.0, 0.0, 1.0]\n colors += [0.0, 0.0, 0.0, 1.0]\n self._fonts.append([\n '{:.2f}'.format(self.i_axis[1]-u*self.i_axis[1]/self._unit_count[1]-self.i_origin[1]),\n (0.025)*self._scaling[0],\n (-(self._unit_w[1])*u-self.i_border[1]+0.01)*self._scaling[1]\n ])\n\n self._draw_plane_indicies = (0, 12)\n self._draw_line_indicies = (12, 4+self._unit_count[0]*2+self._unit_count[1]*2)\n\n # convert data into valid data format\n verticies = numpy.array(verticies, dtype=numpy.float32)\n colors = numpy.array(colors, dtype=numpy.float32)\n\n self._plane_vao = util.VAO()\n self._plane_vbo = util.VBO(2)\n\n with self._plane_vao:\n # plane verticies\n with self._plane_vbo.get(0):\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(verticies), verticies, GL_STATIC_DRAW)\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_position'), 2, GL_FLOAT, GL_FALSE, 0, None)\n glEnableVertexAttribArray(0)\n\n # place vertex colors\n with self._plane_vbo.get(1):\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(colors), colors, GL_STATIC_DRAW)\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_color'), 4, GL_FLOAT, GL_FALSE, 0, None)\n glEnableVertexAttribArray(1)","def face_normals(xyz, triangles):\n\n\tabc_xyz = face_attr(xyz, triangles)\n\n\tbc_xyz = abc_xyz[:,:,1:3] - abc_xyz[:,:,0:1]\n\tfn = tf.linalg.cross(bc_xyz[:,:,0], bc_xyz[:,:,1])\n\tfn = tf.math.l2_normalize(fn, -1)\n\treturn fn","def normal_vector(self, facet):\n assert len(facet) == 3\n pos = self.cluster.get_positions()\n v1 = pos[facet[1], :] - pos[facet[0], :]\n v2 = pos[facet[2], :] - pos[facet[0], :]\n n = np.cross(v1, v2)\n length = np.sqrt(np.sum(n**2))\n return n / length","def project_onto_plane(vect):\n x, y, z = vect\n \n return (x, y, 0.)","def convert_hkl_to_xyz2(self, hkl):\n # Use the hkl miller indices to calculate the normal to a plane in cartesian space\n p = []\n if not hkl[0] == 0:\n p.append(np.array(self.lattice[0] / hkl[0]))\n if not hkl[1] == 0:\n p.append(np.array(self.lattice[1] / hkl[1]))\n if not hkl[2] == 0:\n p.append(np.array(self.lattice[2] / hkl[2]))\n if hkl[0] == 0:\n p.append(self.lattice[0] + p[0])\n if hkl[1] == 0:\n p.append(self.lattice[1] + p[0])\n if hkl[2] == 0:\n p.append(self.lattice[2] + p[0])\n p12 = p[1] - p[0]\n p13 = p[2] - p[0]\n normal = np.cross(p12, p13)\n norm = np.linalg.norm(normal)\n if norm < 1.0e-8:\n print(\"Error in unit cell, calculation of normal to miller index failed\")\n exit(1)\n normal = normal / norm\n return normal","def get_normal_vectors(self, p, x1, y1, z1, x2, y2, z2, x3, y3, z3):\n x1.value, y1.value, z1.value, x2.value, y2.value, z2.value, x3.value, y3.value, z3.value = self._get_normal_vectors(p, x1.value, y1.value, z1.value, x2.value, y2.value, z2.value, x3.value, y3.value, z3.value)","def _normal_vector(o, p0_3d, p1_3d):\n # The vector between middle point of v1-v2 and object center location\n # is the normal vector I'm looking for\n vn = p0_3d.lerp(p1_3d, 0.5) - o.matrix_world.translation\n # normalize so I can to length computation on it\n vn.normalize()\n return vn","def vrrotvec2mat(ax_ang):\n\n #file_dir = os.path.dirname(os.path.realpath(__file__))\n #path_dir2 = file_dir + '/../geometry/'\n #sys.path.append(path_dir2)\n\n if ax_ang.ndim == 1:\n if np.size(ax_ang) == 5:\n ax_ang = np.reshape(ax_ang, (5, 1))\n msz = 1\n elif np.size(ax_ang) == 4:\n ax_ang = np.reshape(np.hstack((ax_ang, np.array([1]))), (5, 1))\n msz = 1\n else:\n raise Exception('Wrong Input Type')\n elif ax_ang.ndim == 2:\n if np.shape(ax_ang)[0] == 5:\n msz = np.shape(ax_ang)[1]\n elif np.shape(ax_ang)[1] == 5:\n ax_ang = ax_ang.transpose()\n msz = np.shape(ax_ang)[1]\n else:\n raise Exception('Wrong Input Type')\n else:\n raise Exception('Wrong Input Type')\n\n direction = ax_ang[0:3, :]\n angle = ax_ang[3, :]\n\n d = np.array(direction, dtype=np.float64)\n d /= np.linalg.norm(d, axis=0)\n x = d[0, :]\n y = d[1, :]\n z = d[2, :]\n c = np.cos(angle)\n s = np.sin(angle)\n tc = 1 - c\n\n mt11 = tc*x*x + c\n mt12 = tc*x*y - s*z\n mt13 = tc*x*z + s*y\n\n mt21 = tc*x*y + s*z\n mt22 = tc*y*y + c\n mt23 = tc*y*z - s*x\n\n mt31 = tc*x*z - s*y\n mt32 = tc*y*z + s*x\n mt33 = tc*z*z + c\n\n mtx = np.column_stack((mt11, mt12, mt13, mt21, mt22, mt23, mt31, mt32, mt33))\n\n inds1 = np.where(ax_ang[4, :] == -1)\n mtx[inds1, :] = -mtx[inds1, :]\n\n if msz == 1:\n mtx = mtx.reshape(3, 3)\n else:\n mtx = mtx.reshape(msz, 3, 3)\n\n return mtx","def vertexes(self):\n theta = self.orientation\n shifts = np.array([np.cos(theta), np.sin(theta)]) * self.a\n return self.coords + (shifts[:, None] * [-1, 1]).T","def normals(t, v):\n n = numpy.zeros((len(t), 3))\n for i in range(0, len(t)):\n p = vertices(t[i], v)\n n[i] = triangle.normal(p)\n return n","def generate_normals(v1, v2, v3, normalize_result=True):\n # make vectors relative to v2\n # we assume opengl counter-clockwise ordering\n a = v1 - v2\n b = v3 - v2\n n = cross(b, a)\n if normalize_result:\n n = normalize(n)\n return n","def getNormalVector(self):\n vector = self.unit_vector\n vector.rotate(math.pi / 2)\n return vector","def vec(self):\r\n\r\n xv = np.arange(self.dx / 2, self.lx, self.dx)\r\n yv = np.arange(-self.ly / 2 + self.dy / 2, self.ly / 2, self.dy)\r\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\r\n\r\n if self.ox != 0:\r\n xv = np.arange(self.ox, self.lx + self.ox, self.dx)\r\n yv = np.arange(self.oy, self.ly + self.oy, self.dy)\r\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\r\n\r\n return xv, yv, zv","def vector(self):\n \n v_list = Householder.triangle_operation(self)[1]\n \n return(v_list)","def normal_vectors(ATOM_list, frame, number_of_atoms, number_of_molecules, number_of_vectors, centerlist, referencelist, boxX, boxY, boxZ):\t\n\tNORMAL_VECTORS_out=open(\"normalvectors.xyz\",'a')\n\t\n\tNORMAL_VECTORS_check=open(\"check_normalvectors.xyz\",'a')\n\t\n\tANGLEDIST_VECTORS_out=open(\"angle_dist_vectors.xyz\",'a')\n\t\n\t\n\tVorzugsrichtung_out=open(\"sum_over_all_normalvectors.dat\",'a')\n\t\n\t\n\t\n\tNORMAL_VECTORS_check.write(str( (number_of_vectors*(2 + int(len(referencelist))) )*number_of_molecules )+'\\n')\n\tNORMAL_VECTORS_check.write(str(frame)+'\\n')\n\t\n\tNORMAL_VECTORS_out.write(str( (number_of_vectors*2)*number_of_molecules )+'\\n')\n\tNORMAL_VECTORS_out.write(str(frame)+'\\n')\n\n\tANGLEDIST_VECTORS_out.write(str( (number_of_vectors*2)*number_of_molecules )+'\\n')\n\tANGLEDIST_VECTORS_out.write(str(frame)+'\\n')\n\t\n\tvorzugsvektor = np.asarray([0,0,0])\n\treference=0\n\t\n\t\n\tfor l in range(0,number_of_molecules):\n\t\tfor vec_count in range(0,number_of_vectors):\n\t\t\tr = []\n\t\t\t#get the 'middle' of the DPI molecule\n\t\t\t\n\t\t\n\t\t\t#get geometric center\n\t\t\tcenter=np.asarray([0,0,0])\n\t\t\t#append all vectors defining the center\n\t\t\tfor i in range(len(centerlist[vec_count])):\n\t\t\t\t# x y z\n\t\t\t\tr.append( np.asarray( [ ATOM_list[centerlist[vec_count][i] + reference][1],ATOM_list[centerlist[vec_count][i] + reference][2],ATOM_list[centerlist[vec_count][i] + reference][3] ] ) ) \n\t\t\t\tcenter = center + r[i]\n\t\t\tcenter = center / len(centerlist[vec_count])\n\t\t\n\t\t\t#calculate all reference vectors\n\t\t\tr=[]\n\t\t\tfor i in range(len(referencelist[vec_count])):\n\t\t\t\tr.append(np.asarray( [ ATOM_list[referencelist[vec_count][i] + reference][1],ATOM_list[referencelist[vec_count][i] + reference][2],ATOM_list[referencelist[vec_count][i] + reference][3] ] ) )\n\t\t\n\t\t\t#get the cross products\n\t\t\tnormal_vec= np.asarray([0,0,0])\n\t\t\tfor i in range(len(r)):\n\t\t\t\tif (i<(len(r)-1)):\n\t\t\t\t\t\n\t\t\t\t\t#minimum image convenction\n\t\t\t\t\tif ( abs(r[i][0]-center[0]) < abs(r[i][0]-center[0]+boxX) ) and ( abs(r[i][0]-center[0]) < abs(r[i][0]-center[0]-boxX) ):\n\t\t\t\t\t\tdx = r[i][0]-center[0]\n\t\t\t\t\telif (abs(r[i][0]-center[0]+boxX) < abs(r[i][0]-center[0]-boxX) ):\n\t\t\t\t\t\tdx = r[i][0]-center[0]+boxX\n\t\t\t\t\telse:\n\t\t\t\t\t\tdx = r[i][0]-center[0]-boxX\n\t\t\t\t\t\n\t\t\t\t\tif ( abs(r[i][1]-center[1]) < abs(r[i][1]-center[1]+boxY) ) and ( abs(r[i][1]-center[1]) < abs(r[i][1]-center[1]-boxY) ):\n\t\t\t\t\t\tdy = r[i][1]-center[1]\n\t\t\t\t\telif (abs(r[i][1]-center[1]+boxY) < abs(r[i][1]-center[1]-boxY) ):\n\t\t\t\t\t\tdy = r[i][1]-center[1]+boxY\n\t\t\t\t\telse:\n\t\t\t\t\t\tdy = r[i][1]-center[1]-boxY\n\t\t\t\t\t\t\n\t\t\t\t\tif ( abs(r[i][2]-center[2]) < abs(r[i][2]-center[2]+boxZ) ) and ( abs(r[i][2]-center[2]) < abs(r[i][2]-center[2]-boxZ) ):\n\t\t\t\t\t\tdz = r[i][2]-center[2]\n\t\t\t\t\telif (abs(r[i][2]-center[2]+boxZ) < abs(r[i][2]-center[2]-boxZ) ):\n\t\t\t\t\t\tdz = r[i][2]-center[2]+boxZ\n\t\t\t\t\telse:\n\t\t\t\t\t\tdz = r[i][2]-center[2]-boxZ\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t#minimum image convenction\n\t\t\t\t\tif ( abs(r[i+1][0]-center[0]) < abs(r[i+1][0]-center[0]+boxX) ) and ( abs(r[i+1][0]-center[0]) < abs(r[i+1][0]-center[0]-boxX) ):\n\t\t\t\t\t\tdx2 = r[i+1][0]-center[0]\n\t\t\t\t\telif (abs(r[i+1][0]-center[0]+boxX) < abs(r[i+1][0]-center[0]-boxX) ):\n\t\t\t\t\t\tdx2 = r[i+1][0]-center[0]+boxX\n\t\t\t\t\telse:\n\t\t\t\t\t\tdx2 = r[i+1][0]-center[0]-boxX\n\t\t\t\t\t\n\t\t\t\t\tif ( abs(r[i+1][1]-center[1]) < abs(r[i+1][1]-center[1]+boxY) ) and ( abs(r[i+1][1]-center[1]) < abs(r[i+1][1]-center[1]-boxY) ):\n\t\t\t\t\t\tdy2 = r[i+1][1]-center[1]\n\t\t\t\t\telif (abs(r[i+1][1]-center[1]+boxY) < abs(r[i+1][1]-center[1]-boxY) ):\n\t\t\t\t\t\tdy2 = r[i+1][1]-center[1]+boxY\n\t\t\t\t\telse:\n\t\t\t\t\t\tdy2 = r[i+1][1]-center[1]-boxY\n\t\t\t\t\t\t\n\t\t\t\t\tif ( abs(r[i+1][2]-center[2]) < abs(r[i+1][2]-center[2]+boxZ) ) and ( abs(r[i+1][2]-center[2]) < abs(r[i+1][2]-center[2]-boxZ) ):\n\t\t\t\t\t\tdz2 = r[i+1][2]-center[2]\n\t\t\t\t\telif (abs(r[i+1][2]-center[2]+boxZ) < abs(r[i+1][2]-center[2]-boxZ) ):\n\t\t\t\t\t\tdz2 = r[i+1][2]-center[2]+boxZ\n\t\t\t\t\telse:\n\t\t\t\t\t\tdz2 = r[i+1][2]-center[2]-boxZ\n\t\t\t\t\t\n\t\t\t\t\tvec1=np.asarray([dx,dy,dz])\n\t\t\t\t\tvec2=np.asarray([dx2,dy2,dz2])\n\t\t\t\t\t#dy = r[i][1]-center[1]\n\t\t\t\t\t#dz = r[i][2]-center[2]\n\t\t\t\t\t#normal_vec = normal_vec + np.cross(r[i]-center, r[i+1]-center)\n\t\t\t\t\tnormal_vec = normal_vec + np.cross(vec1, vec2)/np.linalg.norm( np.cross(vec1, vec2) )\n\t\t\t\telif ( i==len(r) ):\n\t\t\t\t\t\n\t\t\t\t\t#minimum image convenction\n\t\t\t\t\tdx = min( abs(r[i][0]-center[0]), abs(r[i][0]-center[0]+boxX), abs(r[i][0]-center[0]-boxX) )\n\t\t\t\t\tdy = min( abs(r[i][1]-center[1]), abs(r[i][1]-center[1]+boxX), abs(r[i][1]-center[1]-boxX) )\n\t\t\t\t\tdz = min( abs(r[i][2]-center[2]), abs(r[i][2]-center[2]+boxX), abs(r[i][2]-center[2]-boxX) )\n\t\t\t\t\t\n\t\t\t\t\tdx2 = min( abs(r[0][0]-center[0]), abs(r[0][0]-center[0]+boxX), abs(r[0][0]-center[0]-boxX) )\n\t\t\t\t\tdy2 = min( abs(r[0][1]-center[1]), abs(r[0][1]-center[1]+boxX), abs(r[0][1]-center[1]-boxX) )\n\t\t\t\t\tdz2 = min( abs(r[0][2]-center[2]), abs(r[0][2]-center[2]+boxX), abs(r[0][2]-center[2]-boxX) )\n\t\t\t\t\t\n\t\t\t\t\tvec1=np.asarray([dx,dy,dz])\n\t\t\t\t\tvec2=np.asarray([dx2,dy2,dz2])\n\t\t\t\t\t#dy = r[i][1]-center[1]\n\t\t\t\t\t#dz = r[i][2]-center[2]\n\t\t\t\t\t#normal_vec = normal_vec + np.cross(r[i]-center, r[i+1]-center)\n\t\t\t\t\tnormal_vec = normal_vec + np.cross(vec1, vec2)/np.linalg.norm(np.cross(vec1, vec2))\n\t\t\t\t\t#normal_vec = normal_vec + np.cross(r[i]-center, r[0]-center) \n\t\t\n\t\t\t#normalize\n\t\t\tnormal_vec = normal_vec/np.linalg.norm(normal_vec)\n\t\t\n\t\t\t#\t#direction vectors\n\t\t\t#\tdir_vec1 = np.asarray([r[6][0],r[6][1],r[6][2]])\n\t\t\t#\tdir_vec2 = np.asarray([r[7][0],r[7][1],r[7][2]])\n\t\t\t#\tdir_vec3 = np.asarray([r[8][0],r[8][1],r[8][2]])\n\t\t\t#\tdir_vec4 = np.asarray([r[9][0],r[9][1],r[9][2]])\n\t\t\t#\tdir_vec = (dir_vec1 + dir_vec2 + dir_vec3 + dir_vec4)/4.0\n\t\t\t#\tdir_vec = mittelpunkt_dpi - dir_vec\t\t\t\n\n\t\t\t#change direction according to bending\n\t\t\t#\tif normal_vec[0]!=0 and dir_vec[0]!=0:\n\t\t\t#\t\tif normal_vec[0]/abs(normal_vec[0])!=dir_vec[0]/abs(dir_vec[0]):\n\t\t\t#\t\t\tnormal_vec[0] = -normal_vec[0]\n\t\t\t#\tif normal_vec[1]!=0 and dir_vec[1]!=0:\n\t\t#\t\t\tif normal_vec[1]/abs(normal_vec[1])!=dir_vec[1]/abs(dir_vec[1]):\n\t\t#\t\t\t\tnormal_vec[1] = -normal_vec[1]\n\t\t#\t\tif normal_vec[2]!=0 and dir_vec[2]!=0:\n\t\t#\t\t\tif normal_vec[2]/abs(normal_vec[2])!=dir_vec[2]/abs(dir_vec[2]):\n\t\t#\t\t\t\tnormal_vec[2] = -normal_vec[2]\n\n\t\t\t\n\t\t\t#check for a vorzugsvektor\n\t\t\tvorzugsvektor = vorzugsvektor + normal_vec\n\t\t\tNORMAL_VECTORS_out.write('C' +'\t'+ str((center)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tNORMAL_VECTORS_out.write('O' +'\t'+ str((center+normal_vec)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tANGLEDIST_VECTORS_out.write('C' +'\t'+ str((center)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tANGLEDIST_VECTORS_out.write('H' +'\t'+ str((normal_vec)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tNORMAL_VECTORS_check.write('C' +'\t'+ str((center)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tNORMAL_VECTORS_check.write('O' +'\t'+ str((center+normal_vec)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tNORMAL_VECTORS_check.write('H' +'\t'+ str((normal_vec)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tfor i in range(len(referencelist[vec_count])):\n\t\t\t\tNORMAL_VECTORS_check.write('N' +'\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][1])+'\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][2])+'\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][3])+ '\\n')\n\n\t\t#always skip 1 entire molecule forward\n\t\treference=reference + number_of_atoms/number_of_molecules\n\t\t\n\t#calculate a vorzugsvektor as sum over DIPBI normal vectors divided by number of DPBI vectors\n\tvorzugsvektor = vorzugsvektor/(number_of_vectors*frames*number_of_molecules)\n\tVorzugsrichtung_out.write(str(frame) + ' ' + str((vorzugsvektor)).replace('[', '').replace(']','')+'\\n')\n\tNORMAL_VECTORS_out.close()\n\tNORMAL_VECTORS_check.close()\n\treturn","def find_plane_angles(self, roof_motor_position):\n\n # Calcolo il punto mediano tra i vertici 2 e 3\n pc_x = (self.roof_vertex_x[1] + self.roof_vertex_x[2]) / 2\n pc_y = (self.roof_vertex_y[1] + self.roof_vertex_y[2]) / 2\n pc_z = (self.roof_vertex_z[1] + self.roof_vertex_z[2]) / 2\n\n # Questa non so cosa sia\n base_r = [[self.roof_vertex_x[0] - pc_x, self.roof_vertex_y[0] - pc_y, self.roof_vertex_z[0] - pc_z],\n [self.roof_vertex_x[1] - pc_x, self.roof_vertex_y[1] - pc_y, self.roof_vertex_z[1] - pc_z],\n [0.0, 0.0, 0.0]]\n\n # Questa e' la costruzione di una matrice\n mat_rot = [[0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0]]\n\n # Non so quale operazione è implementata, ma a me servono solo tre elementi, j=2, i=0,1, j=1, i=0\n # Primo elemento, j=1, i=0\n mr = math.sqrt((base_r[0][0] ** 2) + (base_r[0][1] ** 2) + (base_r[0][2] ** 2))\n mat_rot[1][0] = base_r[0][1] / mr\n # Secondo elemento, j=2, i=0\n mat_rot[2][0] = base_r[0][2] / mr\n # Terzo elemento, j=2, i=1\n mr = math.sqrt((base_r[1][0] ** 2) + (base_r[1][1] ** 2) + (base_r[1][2] ** 2))\n mat_rot[2][1] = base_r[1][2] / mr\n\n # In alternativa posso calcolare tutti gli elementi della matrice\n # for i in range(2):\n # mr = math.sqrt((base_r[i][0] ** 2) + (base_r[i][1] ** 2) + (base_r[i][2] ** 2))\n # for j in range(3):\n # base_r[i][j] /= mr\n # mat_rot[j][i] = base_r[i][j]\n\n # Sono elementi della matrice non utilizzati\n # base_r[2][0] = +base_r[1][1] * base_r[0][2] - base_r[0][1] * base_r[1][2]\n # base_r[2][1] = -base_r[1][0] * base_r[0][2] + base_r[0][0] * base_r[1][2]\n # base_r[2][2] = +base_r[1][0] * base_r[0][1] - base_r[0][0] * base_r[1][1]\n # for i in range(3):\n # mat_rot[i][2] = base_r[2][i]\n\n # Qui estraggo la terna di Tait-Bryan angles usata internamente, la Z1Y2X3\n k17 = mat_rot[2][0]\n k16 = mat_rot[1][0]\n l17 = mat_rot[2][1]\n m20 = math.asin(k17)\n i23 = math.cos(m20)\n i24 = k16 / i23\n i25 = l17 / i23\n m19 = math.asin(i24)\n self.zyx1_r = m19 + roof_motor_position\n self.zyx2_r = math.asin(k17)\n self.zyx3_r = math.asin(i25)\n self.zyx3 = self.zyx3_r / Kinematic.M_TO_RAD\n self.zyx2 = self.zyx2_r / Kinematic.M_TO_RAD\n self.zyx1 = self.zyx1_r / Kinematic.M_TO_RAD\n angles = self.zyx_r_to_xyz(self.zyx3_r, self.zyx2_r, self.zyx1_r)\n self.xyz1 = angles[2]\n self.xyz2 = angles[0]\n self.xyz3 = angles[1]\n self.xyz1_r = angles[5]\n self.xyz2_r = angles[3]\n self.xyz3_r = angles[4]","def _update_surface_normals(self):\n\n # This is the case if there are too few points to\n # compute normals so there can be values to remove\n\n #can be important for parallel\n self.swarm.shadow_particles_fetch()\n\n if self.empty:\n self.director.data[...] = 0.0\n else:\n\n particle_coords = self.swarm.particleCoordinates.data\n\n Nx = np.empty(self.swarm.particleLocalCount)\n Ny = np.empty(self.swarm.particleLocalCount)\n Nz = np.empty(self.swarm.particleLocalCount)\n\n for i, xyz in enumerate(particle_coords):\n r, neighbours = self.kdtree.query(particle_coords[i], k=4)\n\n # this point is neighbour[0] and neighbour points are neighbours[(1,2,3)]\n XYZ1 = self.kdtree.data[neighbours[1]]\n XYZ2 = self.kdtree.data[neighbours[2]]\n XYZ3 = self.kdtree.data[neighbours[3]]\n\n dXYZ1 = XYZ2 - XYZ1\n dXYZ2 = XYZ3 - XYZ1\n\n # Cross product of those 2 vectors can be use as the local normal (perhaps)\n\n Nx[i], Ny[i], Nz[i] = np.cross(dXYZ1, dXYZ2)\n #if i == 0:\n # print(Nx, Ny, Nz)\n # print(xyz[0], xyz[1],xyz[2])\n # print((self.insidePt[0] - xyz[0]) * Nx[i] )\n\n if (self.insidePt):\n sign = np.sign( (self.insidePt[0] - xyz[0]) * Nx[i] +\n (self.insidePt[1] - xyz[1]) * Ny[i] +\n (self.insidePt[2] - xyz[2]) * Nz[i] )\n Nx[i] *= sign\n Ny[i] *= sign\n Nz[i] *= sign\n\n\n for i in range(0, self.swarm.particleLocalCount):\n scale = 1.0 / np.sqrt(Nx[i]**2 + Ny[i]**2 + Nz[i]**2)\n Nx[i] *= scale\n Ny[i] *= scale\n Nz[i] *= scale\n\n\n self.director.data[:,0] = Nx[:]\n self.director.data[:,1] = Ny[:]\n self.director.data[:,2] = Nz[:]\n\n print(\"Surf Norms\")\n\n return","def uvmap(self, p):\n # bottom left corner of the plane\n p00 = self.position - (self.sx * self.n0) / 2 - (self.sy * self.n1) / 2\n dif_vector = p - p00\n u = np.dot(dif_vector, self.n0) / self.sx\n v = np.dot(dif_vector, self.n1) / self.sy\n return u, v","def vector_line(self):\n assert len(self.xcoords) == 2\n diff_x = self.xcoords[1] - self.xcoords[0]\n diff_z = self.zcoords[1] - self.zcoords[0]\n vec = np.hstack((diff_x, diff_z))\n return vec","def normal(self,points):\n ez=np.array([[0,0,1]])\n v=((points-self.pos()*ez)*self.C-ez)\n return (v/np.linalg.norm(v,axis=1)[:,np.newaxis])#*np.sign(self.C)","def generate_V(self):\n\n n_samples, n_dimensions, L = self.n_samples, self.n_dimensions, self.L\n\n V = np.zeros([L + 1, n_dimensions], dtype=int)\n V[1:, 0] = [1 << (self.scale - j) for j in range(1, L + 1)]\n\n for i in range(n_dimensions - 1):\n\n m = np.array(directions[i], dtype=int)\n s = len(m) - 1\n\n # The following code discards the first row of the ``m`` array\n # Because it has floating point errors, e.g. values of 2.24e-314\n if L <= s:\n V[1:, i + 1] = [m[j] << (self.scale - j) for j in range(1, L + 1)]\n else:\n V[1 : s + 1, i + 1] = [\n m[j] << (self.scale - j) for j in range(1, s + 1)\n ]\n for j in range(s + 1, L + 1):\n V[j, i + 1] = V[j - s, i + 1] ^ (V[j - s, i + 1] >> s)\n for k in range(1, s):\n V[j, i + 1] ^= ((m[0] >> (s - 1 - k)) & 1) * V[j - k][i + 1]\n\n return V","def getVectors(self):\n l = len(self.points)\n return [Vector.createFromTwoPoints(self.points[i % l], self.points[(i + 1) % l], \\\n color=self.side_color, width=self.side_width) for i in range(l)]","def getNormals(vertA, vertB, vertC):\n xA = vertA[0]\n xB = vertB[0]\n xC = vertC[0]\n yA = vertA[1]\n yB = vertB[1]\n yC = vertC[1]\n zA = vertA[2]\n zB = vertB[2]\n zC = vertC[2]\n ABx = xB - xA\n ABy = yB - yA\n ABz = zB - zA\n BCx = xC - xB\n BCy = yC - yB\n BCz = zC - zB\n Nx = ABy * BCz - ABz * BCy\n Ny = ABz * BCx - ABx * BCz\n Nz = ABx * BCy - ABy * BCx\n VecMag = math.sqrt(Nx ** 2 + Ny ** 2 + Nz ** 2)\n Ni = Nx / VecMag\n Nj = Ny / VecMag\n Nk = Nz / VecMag\n return [Ni, Nj, Nk]","def calculateMeshNormal(mesh_face_vertices):\n mesh_normal = []\n for mesh in mesh_face_vertices:\n v1x = mesh[1, 0] - mesh[0, 0]\n v1y = mesh[1, 1] - mesh[0, 1]\n v1z = mesh[1, 2] - mesh[0, 2]\n v2x = mesh[2, 0] - mesh[1, 0]\n v2y = mesh[2, 1] - mesh[1, 1]\n v2z = mesh[2, 2] - mesh[1, 2]\n \n normal = np.array([v1y * v2z - v1z * v2y, v1z * v2x - v1x * v2z, v1x * v2y - v1y * v2x])\n normal = normal / np.max((np.linalg.norm(normal), 1e-5))\n normal = (normal + 1) * 127.5\n mesh_normal.append(normal)\n return np.array(mesh_normal)","def volume_tetrahedron(xyz, A, B, C, D):\n\n AD = xyz[A, :] - xyz[D, :]\n BD = xyz[B, :] - xyz[D, :]\n CD = xyz[C, :] - xyz[D, :]\n\n V = (\n (BD[:, 0] * CD[:, 1] - BD[:, 1] * CD[:, 0]) * AD[:, 2]\n - (BD[:, 0] * CD[:, 2] - BD[:, 2] * CD[:, 0]) * AD[:, 1]\n + (BD[:, 1] * CD[:, 2] - BD[:, 2] * CD[:, 1]) * AD[:, 0]\n )\n return V / 6","def plane_from_points(a, b, c):\n ab = subtract_vectors(b, a)\n ac = subtract_vectors(c, a)\n n = normalize_vector(cross_vectors(ab, ac))\n return a, n","def landmarks_as_vectors(landmarks):\n mat = []\n for lm in landmarks:\n mat.append(lm.as_vector())\n return np.array(mat)","def plane(self):\n return plane(self.N, self.o)","def vector(molec, dihed, nonH, energy):\n #Torison\n if dihed:\n pass\n #XYZ\n else:\n coords = ()\n if nonH:\n for atom in molec.atoms:\n coords += atom.coords\n else:\n for atom in molec.atoms:\n if atom.atomicnum > 1:\n coords += atom.coords\n #Energy\n if energy:\n coords += (molec.energy/10.0,)\n return coords","def vert_normals(xyz, triangles):\n\n\tB, N, _ = _shape(xyz)\n\tM = _shape(triangles)[-2]\n\ttriangles = _i64(triangles)\n\t\n\tfn = face_normals(xyz, triangles)\n\tbfn = tf.reshape(tf.tile(fn, [1,1,3]), [B*M*3, 3])\n\tbt = tf.reshape(\n\t\ttriangles[tf.newaxis,:,:] + _i64(tf.range(B)[:,tf.newaxis,tf.newaxis] * N),\n\t\t[B*M*3])\n\tvn = tf.reshape(tf.math.unsorted_segment_sum(bfn, bt, B*N), [B,N,3])\n\tvn = tf.math.l2_normalize(vn, -1)\n\treturn vn","def hexgrid(self):\n n = self.n * 2\n vectors = []\n for u in range(-n, n+1):\n us = [u] * (2*n+1)\n if u < 0:\n vectors.extend(zip(us, range(-n-u, n+1), range(-n, n+u+1)))\n else:\n vectors.extend(zip(us, range(-n, n-u+1), range(-n+u, n+1)))\n return vectors","def uVectNorm(x1,y1,z1, # P\n x2,y2,z2, # Q\n x3,y3,z3): # R\n p1 = np.array([x1,y1,z1])\n p2 = np.array([x2,y2,z2])\n p3 = np.array([x3,y3,z3])\n\n v1 = p3-p1\n v2 = p2-p1\n\n cp = np.cross(v1,v2)\n a,b,c = cp\n\n d = np.dot(cp, p3)\n\n print(a,b,c)","def to_mesh(\n self,\n lims_x: array_like = (-1, 1),\n lims_y: array_like = (-1, 1),\n ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\n a, b, c, d = self.cartesian()\n x_center, y_center = self.point[:2]\n\n values_x = x_center + lims_x\n values_y = y_center + lims_y\n\n X, Y = np.meshgrid(values_x, values_y)\n\n if c != 0:\n Z = -(a * X + b * Y + d) / c\n\n elif b != 0:\n Z = -(a * X + c * Y + d) / b\n X, Y, Z = X, Z, Y\n\n else:\n Z = -(b * X + c * Y + d) / a\n X, Y, Z = Z, X, Y\n\n return X, Y, Z","def invgeochart(w):\n # u = torch.asin(w[...,2])\n u = torch.acos(w[...,2])\n # v = torch.acos(w[...,0]/torch.cos(u))\n v = torch.atan(w[...,1]/w[...,0])\n return torch.stack((u,v+np.pi))","def normal(axis_direction, axis_origin, point):\n # transform input into numpy arrays\n axis_direction = np.array(axis_direction, float)\n axis_origin = np.array(axis_origin, float)\n point = np.array(point, float)\n\n # vector from axis normal_origin to point\n vector = point - axis_origin\n\n # projection of vector on axis\n projection = np.dot(vector, axis_direction)*axis_direction\n\n # the normal vector from normal_origin to point\n normal_direction = vector - projection\n\n # normalized normal_direction\n normal_direction = normal_direction/np.linalg.norm(normal_direction)\n\n # opposite of the projection of vector on normal\n projection2 = - np.dot(normal_direction, vector)*normal_direction\n\n normal_origin = point + projection2\n\n return normal_direction, normal_origin","def voxelize4(self, materials):\n\t\tlayers = list()\n\t\tlayersR = list()\n\t\tlayersG = list()\n\t\tlayersB = list()\n\t\t\n\t\tlayerMaterial = list()\n\t\tself.volumeComposition = list()\n\t\tfor l in range(len(materials)):\n\t\t\tlayerMaterial.append(list())\n\t\t\tself.volumeComposition.append(list())\n\n\t\tvolumeGeneral = list()\n\t\tm = 0\n\t\tfor i in self.slicePoints:\n\t\t\t#print self.boolResult[m].shape\n\t\t\ttupleResultR = numpy.zeros(self.boolLayers[m].shape, dtype=uint8)\n\t\t\ttupleResultG = numpy.zeros(self.boolLayers[m].shape, dtype=uint8)\n\t\t\ttupleResultB = numpy.zeros(self.boolLayers[m].shape, dtype=uint8)\n\t\t\ttupleMaterial = list()\n\t\t\tfor l in range(len(materials)):\n\t\t\t\ttupleMaterial.append(numpy.zeros(self.boolLayers[m].shape, dtype=float))\n\t\t\t\n\t\t\tj = numpy.nditer(self.boolLayers[m], flags=['multi_index'], op_flags=['readwrite'])\n\t\t\twhile not j.finished:\n\t\t\t\tif j[0] == True:\n\t\t\t\t#tupleResult[j.multi_index] = round((i[direction] - minValue) * ratio)\n\t\t\t\t#tupleResult[j.multi_index] = 78\n\t\t\t\t\tprint type(j.multi_index)\n\t\t\t\t\tprint j.multi_index\n\t\t\t\t\t#tupleResult[j.multi_index] = planeWeight * math.fabs((j.multi_index[1] - planeOrigin[0]) * planeNormal[0] + (j.multi_index[0] - planeOrigin[1]) * planeNormal[1] + (i[2] - planeOrigin[2]) * planeNormal[2]) + pointWeight * math.sqrt(math.pow((j.multi_index[1]- pointValue[0]),2) + math.pow((j.multi_index[0] - pointValue[1]), 2)+math.pow((i[2] - pointValue[2]),2))\n\t\t\t\t\t\n\t\t\t\t\tdistanceList = []\n\t\t\t\t\ttotalDistance = 0.0\n\t\t\t\t\tfor k in range(len(materials)):\n\t\t\t\t\t\tif materials[k].controlSourceType == \"Plane\":\n\t\t\t\t\t\t\tGplane = math.fabs((j.multi_index[1] - materials[k].origin[0]) * materials[k].normal[0] + (j.multi_index[0] - materials[k].origin[1]) * materials[k].normal[1] + (i[2] - materials[k].origin[2]) * materials[k].normal[2])\n\t\t\t\t\t\t\tdistanceList.append(Gplane)\n\t\t\t\t\t\t\ttotalDistance += Gplane\n\t\t\t\t\t\tif materials[k].controlSourceType == \"Point\":\n\t\t\t\t\t\t\tGpoint = (math.sqrt(math.pow((j.multi_index[1]- materials[k].point[0]),2) + math.pow((j.multi_index[0] - materials[k].point[1]), 2)+math.pow((i[2] - materials[k].point[2]),2)))\n\t\t\t\t\t\t\tdistanceList.append(Gpoint)\n\t\t\t\t\t\t\ttotalDistance += Gpoint\n\t\t\t\t\tfor k in range(len(distanceList)):\n\t\t\t\t\t\tdistanceList[k] = distanceList[k] / totalDistance\n\t\t\t\t\t\tdistanceList[k] = 1.0 - distanceList[k]\n\t\t\t\t\t\t\n\t\t\t\t\t\ttupleMaterial[k][j.multi_index] = distanceList[k]\n\t\t\t\t\t\t\n\t\t\t\t\t\ttupleResultR[j.multi_index] += materials[k].materialColor[0] * distanceList[k] * materials[k].weight\n\t\t\t\t\t\ttupleResultG[j.multi_index] += materials[k].materialColor[1] * distanceList[k] * materials[k].weight\n\t\t\t\t\t\ttupleResultB[j.multi_index] += materials[k].materialColor[2] * distanceList[k] * materials[k].weight\n\t\t\t\t\t#if(tupleResult[j.multi_index] > 0):\n\t\t\t\t\t#\ttupleResult[j.multi_index] = round(tupleResult[j.multi_index]) \n\t\t\t\t\t#if(tupleResult[j.multi_index] == 0):\n\t\t\t\t\t#\t\ttupleResult[j.multi_index] = 1\n\t\t\t\t\t#if(tupleResult[j.multi_index] < 0):\n\t\t\t\t\t#\ttupleResult[j.multi_index] = round(0 - tupleResult[j.multi_index]) \n\t\t\t\telse:\n\t\t\t\t\ttupleResultR[j.multi_index] = 0\n\t\t\t\t\ttupleResultG[j.multi_index] = 0\n\t\t\t\t\ttupleResultB[j.multi_index] = 0\n\t\t\t\t\tfor k in range(len(materials)):\n\t\t\t\t\t\ttupleMaterial[k][j.multi_index] = 0.0\n\t\t\t\tj.iternext()\n\t\t\tlayersR.append(tupleResultR)\n\t\t\tlayersG.append(tupleResultG)\n\t\t\tlayersB.append(tupleResultB)\n\t\t\tfor k in range(len(materials)):\n\t\t\t\tlayerMaterial[k].append(tupleMaterial[k])\n\t\t\t\t\n\t\t\tm = m + 1\n\t\tprint \"i got here\"\n\t\tvolumeR=numpy.array(layersR) # create the 3d volume\n\t\tvolumeG=numpy.array(layersG) \n\t\tvolumeB=numpy.array(layersB)\n\t\tfor k in range(len(materials)):\n\t\t\tself.volumeComposition[k] = numpy.array(layerMaterial[k])\n\t\t\n\t\tvolumeGeneral.append(volumeR)\n\t\tvolumeGeneral.append(volumeG)\n\t\tvolumeGeneral.append(volumeB)\n\t\treturn volumeGeneral","def get_plane_of_points(\n self,\n normal_vector=\"z\",\n planar_coordinate=None,\n ):\n # Get results vectors\n if (normal_vector == \"z\"):\n x_flat = self.floris.grid.x_sorted_inertial_frame[0, 0].flatten()\n y_flat = self.floris.grid.y_sorted_inertial_frame[0, 0].flatten()\n z_flat = self.floris.grid.z_sorted_inertial_frame[0, 0].flatten()\n else:\n x_flat = self.floris.grid.x_sorted[0, 0].flatten()\n y_flat = self.floris.grid.y_sorted[0, 0].flatten()\n z_flat = self.floris.grid.z_sorted[0, 0].flatten()\n u_flat = self.floris.flow_field.u_sorted[0, 0].flatten()\n v_flat = self.floris.flow_field.v_sorted[0, 0].flatten()\n w_flat = self.floris.flow_field.w_sorted[0, 0].flatten()\n\n # Create a df of these\n if normal_vector == \"z\":\n df = pd.DataFrame(\n {\n \"x1\": x_flat,\n \"x2\": y_flat,\n \"x3\": z_flat,\n \"u\": u_flat,\n \"v\": v_flat,\n \"w\": w_flat,\n }\n )\n if normal_vector == \"x\":\n df = pd.DataFrame(\n {\n \"x1\": y_flat,\n \"x2\": z_flat,\n \"x3\": x_flat,\n \"u\": u_flat,\n \"v\": v_flat,\n \"w\": w_flat,\n }\n )\n if normal_vector == \"y\":\n df = pd.DataFrame(\n {\n \"x1\": x_flat,\n \"x2\": z_flat,\n \"x3\": y_flat,\n \"u\": u_flat,\n \"v\": v_flat,\n \"w\": w_flat,\n }\n )\n\n # Subset to plane\n # TODO: Seems sloppy as need more than one plane in the z-direction for GCH\n if planar_coordinate is not None:\n df = df[np.isclose(df.x3, planar_coordinate)] # , atol=0.1, rtol=0.0)]\n\n # Drop duplicates\n # TODO is this still needed now that we setup a grid for just this plane?\n df = df.drop_duplicates()\n\n # Sort values of df to make sure plotting is acceptable\n df = df.sort_values([\"x2\", \"x1\"]).reset_index(drop=True)\n\n return df","def get_fault_rotation_matrix(plane_normal: np.ndarray, cutoff_vecmag: float = 0.98):\n # Reference directions to try are z=1 (vertical) and y=1 (north).\n ref_dir1 = np.array([0.0, 0.0, 1.0], dtype=np.float64)\n ref_dir2 = np.array([0.0, 1.0, 0.0], dtype=np.float64)\n ref_dir = ref_dir1\n\n # If normal is nearly vertical, use north reference direction.\n if (np.dot(ref_dir1, plane_normal) > cutoff_vecmag):\n ref_dir = ref_dir2\n \n # Get two tangential directions in plane.\n tan_dir1 = rsqsim_api.fault.patch.cross_3d(ref_dir, plane_normal)\n tan_dir1 /= np.linalg.norm(tan_dir1)\n tan_dir2 = rsqsim_api.fault.patch.cross_3d(plane_normal, tan_dir1)\n tan_dir2 /= np.linalg.norm(tan_dir2)\n\n # Form rotation matrix.\n rotation_matrix = np.column_stack((tan_dir1, tan_dir2, plane_normal))\n\n return rotation_matrix","def unit_vectors(self):\n # return {'comp1': CartesianRepresentation(...),\n # 'comp2': CartesianRepresentation(...),\n # 'comp3': CartesianRepresentation(...)}\n raise Exception(\"Not yet implemented\")","def _generate_meshes(self, vectors, width):\n centers = np.repeat(vectors, 2, axis=0)\n offsets = segment_normal(vectors[::2, :], vectors[1::2, :])\n offsets = np.repeat(offsets, 4, axis=0)\n signs = np.ones((len(offsets), 2))\n signs[::2] = -1\n offsets = offsets*signs\n\n vertices = centers + width*offsets/2\n triangles = np.array([[2*i, 2*i+1, 2*i+2] if i % 2 == 0 else\n [2*i-1, 2*i, 2*i+1] for i in\n range(len(vectors))]).astype(np.uint32)\n\n return vertices, triangles","def reciprocal_lattice_vectors(a):\n b = np.zeros(shape=(3,3))\n b[:,0] = 2 * np.pi * np.cross(a[:,1], a[:,2]) / triple_product(a[:,0], a[:,1], a[:,2])\n b[:,1] = 2 * np.pi * np.cross(a[:,2], a[:,0]) / triple_product(a[:,1], a[:,2], a[:,0])\n b[:,2] = 2 * np.pi * np.cross(a[:,0], a[:,1]) / triple_product(a[:,2], a[:,0], a[:,1])\n return b","def transform_space(normal_map, rotmat):\n rotmat = np.array(rotmat)\n orig_shape = normal_map.shape\n normal = normal_map.reshape(-1, 3).T # 3-by-N\n\n normal_trans = rotmat.dot(normal)\n\n normal_map_trans = normal_trans.T.reshape(orig_shape)\n return normal_map_trans","def lin_a98rgb_to_xyz(rgb: Vector) -> Vector:\n\n return alg.dot(RGB_TO_XYZ, rgb, dims=alg.D2_D1)","def getNormDetXYZ(self):\n\t\t(node0,node1) = self.getTwoNodes()\n\t\tbeta_in = node0.getBeta()\n\t\tbeta_out = node1.getBeta()\n\t\tgamma_in = node0.getGamma()\n\t\tgamma_out = node1.getGamma()\n\t\tgb_in = beta_in*gamma_in\n\t\tgb_out = beta_out*gamma_out\n\t\t(det_x,det_y,det_z) = self.getDetXYZ(self.trMtrx)\n\t\treturn ((gb_out/gb_in)*det_x,(gb_out/gb_in)*det_y,(beta_in/beta_out)*det_z)","def point_form(boxes):\n return torch.cat((boxes[:, :2] - boxes[:, 2:] / 2, boxes[:, :2] + boxes[:, 2:] / 2), 1)","def point_form(boxes):\n return torch.cat((boxes[:, :2] - boxes[:, 2:] / 2, boxes[:, :2] + boxes[:, 2:] / 2), 1)","def world_to_camera_normals(inverted_camera_quaternation, world_normals):\n exr_x, exr_y, exr_z = world_normals[0], world_normals[1], world_normals[2]\n camera_normal = np.empty([exr_x.shape[0], exr_x.shape[1], 3], dtype=np.float32)\n for i in range(exr_x.shape[0]):\n for j in range(exr_x.shape[1]):\n pixel_camera_normal = _multiply_quaternion_vec3(inverted_camera_quaternation,\n [exr_x[i][j], exr_y[i][j], exr_z[i][j]])\n camera_normal[i][j][0] = pixel_camera_normal[0]\n camera_normal[i][j][1] = pixel_camera_normal[1]\n camera_normal[i][j][2] = pixel_camera_normal[2]\n\n camera_normal = camera_normal.transpose(2, 0, 1)\n return camera_normal","def _fit_plane_to_point_cloud(\n points_xyz: NDArrayFloat,\n) -> Tuple[float, float, float, float]:\n center_xyz: NDArrayFloat = np.mean(points_xyz, axis=0)\n out: Tuple[NDArrayFloat, NDArrayFloat, NDArrayFloat] = np.linalg.svd(\n points_xyz - center_xyz\n )\n vh = out[2]\n\n # Get the unitary normal vector\n a, b, c = float(vh[2, 0]), float(vh[2, 1]), float(vh[2, 2])\n d: float = -np.dot([a, b, c], center_xyz)\n return (a, b, c, d)","def project_vectors_ab(a, b):\n # print('dot = ', np.dot(a,b))\n # print('norm = ', np.linalg.norm(b))\n return np.dot(a, b) / np.linalg.norm(b)","def get_normal(self):\n c, s = np.cos(self.eangles), np.sin(self.eangles)\n r = np.array([[c, -s], [s, c]])\n u = np.array([1, 0])\n return np.dot(r, u)","def normalise(self):\n for at in self.atoms:\n if at.x < 0. :\n at.x = self.coordx + at.x\n if at.y < 0. :\n at.y = self.coordy + at.y\n if at.z < 0. :\n at.z = self.coordz + at.z","def miller(points):\r\n\r\n N = np.cross(points[1] - points[0], points[2] - points[0])\r\n O = np.array([0, 0, 0])\r\n P = points[0] # point of plane\r\n Ccs = map(np.array, [[1.0, 0, 0], [0, 1.0, 0], [0, 0, 1.0]])\r\n segments = ([np.dot(P - O, N) / np.dot(ort, N) if np.dot(ort, N) != 0 else\r\n np.nan for ort in Ccs])\r\n if any(x == 0 for x in segments): # Plane goes through origin.\r\n vertices = [ # top:\r\n np.array([1.0, 1.0, 1.0]),\r\n np.array([0.0, 0.0, 1.0]),\r\n np.array([1.0, 0.0, 1.0]),\r\n np.array([0.0, 1.0, 1.0]),\r\n # bottom, except 0,0,0:\r\n np.array([1.0, 0.0, 0.0]),\r\n np.array([0.0, 1.0, 0.0]),\r\n np.array([1.0, 1.0, 1.0]),\r\n ]\r\n for vertex in vertices:\r\n if np.dot(vertex - O, N) != 0: # vertex not in plane\r\n new_origin = vertex\r\n break\r\n # obtain new axes with center in new origin\r\n X = np.array([1 - new_origin[0], new_origin[1], new_origin[2]])\r\n Y = np.array([new_origin[0], 1 - new_origin[1], new_origin[2]])\r\n Z = np.array([new_origin[0], new_origin[1], 1 - new_origin[2]])\r\n new_Ccs = [X - new_origin, Y - new_origin, Z - new_origin]\r\n segments = ([np.dot(P - new_origin, N) / np.dot(ort, N) if\r\n np.dot(ort, N) != 0 else np.nan for ort in new_Ccs])\r\n # fix signs of indices: 0 -> 1, 1 -> -1 (\r\n segments = (1 - 2 * new_origin) * segments\r\n\r\n return sub_miller(segments)","def parse_normals(lines):\n print \" * Parsing normals\"\n return _parse_vn(lines, \"vn %.6f %.6f %.6f\")","def vector(self) -> np.ndarray:\n link_vectors = [link.vector for link in self.links]\n v = np.array(link_vectors).ravel()\n return v","def normalize(self):\r\n\r\n nlen = 1.0/math.sqrt(self*self)\r\n return vec4(self.x*nlen, self.y*nlen, self.z*nlen, self.w*nlen)","def xyz(self) -> np.ndarray:\n return self._vector[0:3]","def planeIndex(plane, center = False):\n return (planeBase(center = center) * np.array(plane)).sum()","def normal(self) -> Vector:\n return normalize(cross(self.d1, self.d2))","def normalVect(self, n=2):\n L = len(self.vertices)\n normals = []\n while len(normals) < n:\n j = randrange(L)\n v0 = vector(self.vertices[j].coords())\n v1 = vector(self.vertices[int(j + L / 3) % L].coords())\n v2 = vector(self.vertices[int(j + 2 * L / 3) % L].coords())\n try:\n normals.append(((v1 - v0) * (v2 - v0)).normalize())\n except ValueError:\n pass\n return (1 / len(normals)) * sum(normals, vector(0, 0, 0))","def normal(self) -> Vector:\n return self._normal","def _generate_uniform_planes(self):\n return np.random.randn(self.m, self.dim)","def to_raw(self):\n return [self.poses[i].to_absolute_xyz_rxryrz() + self.wrenches[i].parameters() for i in range(len(self.poses))]","def cartesian(self) -> Tuple[np.number, np.number, np.number, np.number]:\n if self.dimension > 3:\n raise ValueError(\"The plane dimension must be <= 3.\")\n\n # The normal must be 3D to extract the coefficients.\n a, b, c = self.normal.set_dimension(3)\n\n d = -self.normal.dot(self.point)\n\n return a, b, c, d","def Normal(self):\n return Vector(self.normal)","def normalize(self):\n return Vector(self.args + []) / self.magnitude()","def magni(vector):\n return(np.linalg.norm(vector))","def get_vectors(nodes, mode=\"xform\"):\n for each in nodes:\n position = (0, 0, 0)\n\n if mode == \"xform\":\n position = cmds.xform(\n each,\n query=True,\n translation=True,\n worldSpace=True,\n )\n\n elif mode == \"pivot\":\n position = cmds.xform(\n each,\n query=True,\n translation=True,\n rotatePivot=True,\n worldSpace=True,\n )\n\n # when using xform on component like faces or edge, the returned value\n # will be a list of each vertices position, so we need to average that\n if len(position) > 3:\n vectors = [\n MVector(position[i : i + 3])\n for i in range(0, len(position), 3)\n ]\n result = MVector()\n for vector in vectors:\n result += vector\n position = result / len(vectors)\n\n yield MVector(position)","def write_LG_normal(self, start=0, end=801):\n\n # get all the CoM info from postgres\n MW_data = self.read_com_db('MW')\n M31_data = self.read_com_db('M31')\n M33_data = self.read_com_db('M33')\n \n # pull out just the 3 columns giving position\n MW_coms = np.array([MW_data[xi] for xi in ('x','y','z')])\n M31_coms = np.array([M31_data[xi] for xi in ('x','y','z')])\n M33_coms = np.array([M33_data[xi] for xi in ('x','y','z')])\n\n # define 2 vectors that lie in the plane\n M31_MW = MW_coms - M31_coms\n M31_M33 = M33_coms - M31_coms\n\n # the normal we want comes from the vector cross product\n normals = np.cross(M31_MW, M31_M33, axis=0)\n normals /= norm(normals, axis=0)\n\n output = np.concatenate((MW_data['t'][:,np.newaxis], normals.T), axis=1)\n print(output.shape)\n \n # compose the filename for output\n fileout = './normals.txt'\n\n # write the data to file\n # we do this because we don't want to have to repeat this process \n # this code should only have to be called once\n np.savetxt(fileout, output, fmt = \"%11.3f\"*4, comments='#',\n header=\"{:>10s}{:>11s}{:>11s}{:>11s}\"\\\n .format('t', 'x_hat', 'y_hat', 'z_hat'))","def vincdecnorm(arr):\n tmp = convert(arr, GEOCENTRIC_CARTESIAN, GEOCENTRIC_SPHERICAL)\n return -tmp[..., 0], tmp[..., 1], tmp[..., 2]","def cxvec(self):\n return np.array([self.cx, self.cy])","def get_perpendicular(n: np.ndarray) -> np.ndarray:\n # find smallest component\n i = np.argmin(n)\n\n # get the other two indices\n a = (i + 1) % 3\n b = (i + 2) % 3\n\n result = np.zeros(3)\n result[i] = 0.0\n result[a] = n[b]\n result[b] = -n[a]\n return result","def _vehicle_to_world(cords, vehicle):\n\n bb_transform = carla.Transform(vehicle.bounding_box.location)\n bb_vehicle_matrix = ClientSideBoundingBoxes.get_matrix(bb_transform)\n vehicle_world_matrix = ClientSideBoundingBoxes.get_matrix(vehicle.get_transform())\n bb_world_matrix = np.dot(vehicle_world_matrix, bb_vehicle_matrix)\n world_cords = np.dot(bb_world_matrix, np.transpose(cords))\n return world_cords","def vector(self) -> Vector:\n return self._normal * self._distance_from_origin","def proj_to_plane(norm, d, pts):\n a = norm[0]\n b = norm[1]\n c = norm[2]\n\n p = []\n\n for i in range(len(pts)):\n x_p = pts[i][0]\n y_p = pts[i][1]\n z_p = pts[i][2]\n\n if a != 0:\n x_0 = (b * b + c * c) * x_p - a * b * y_p - a * c * z_p - a * d\n y_0 = (b * 1.0 / a) * (x_0 - x_p) + y_p\n z_0 = (c * 1.0 / a) * (x_0 - x_p) + z_p\n\n elif b != 0:\n x_0 = x_p \n y_0 = c * c * y_p - b * (d + c)\n z_0 = (c * 1.0 / b) *(y_0 - y_p) + z_p\n\n else:\n x_0 = x_p\n y_0 = y_p\n z_0 = - d * 1.0 / c\n\n p.append([x_0, y_0, z_0])\n \n return p","def proj_to_plane(norm, d, pts):\n a = norm[0]\n b = norm[1]\n c = norm[2]\n\n p = []\n\n for i in range(len(pts)):\n x_p = pts[i][0]\n y_p = pts[i][1]\n z_p = pts[i][2]\n\n if a != 0:\n x_0 = (b * b + c * c) * x_p - a * b * y_p - a * c * z_p - a * d\n y_0 = (b * 1.0 / a) * (x_0 - x_p) + y_p\n z_0 = (c * 1.0 / a) * (x_0 - x_p) + z_p\n\n elif b != 0:\n x_0 = x_p \n y_0 = c * c * y_p - b * (d + c)\n z_0 = (c * 1.0 / b) *(y_0 - y_p) + z_p\n\n else:\n x_0 = x_p\n y_0 = y_p\n z_0 = - d * 1.0 / c\n\n p.append([x_0, y_0, z_0])\n \n return p","def unit_vectors(x):\n xnew = x.copy()\n for v in range(x.shape[-1]):\n xnew[:, v] = x[:, v] / np.linalg.norm(x[:, v])\n return xnew","def _xyz_matrix():\n fx = 583.0\n fy = 583.0\n cx = 321\n cy = 249\n a = -0.0028300396\n b = 3.1006268\n mat = np.array([[1/fx, 0, 0, -cx/fx],\n [0, -1/fy, 0, cy/fy],\n [0, 0, 0, -1],\n [0, 0, a, b]])\n return mat","def project_point_plane(point, plane):\n base, normal = plane\n normal = normalize_vector(normal)\n vector = subtract_vectors(point, base)\n snormal = scale_vector(normal, dot_vectors(vector, normal))\n return subtract_vectors(point, snormal)","def normal_vector_3p(a: Vector, b: Vector, c: Vector) -> Vector:\n return (b - a).cross(c - a).normalize()","def normalise( vectors ):\n vectors = asarray( vectors, _aformat(vectors))\n vectors = reshape( vectors, (-1,3)) # Numpy 23.7 and 64-bit machines fail here, upgrade to 23.8\n mags = reshape( magnitude( vectors ), (-1, 1))\n mags = where( mags, mags, 1.0)\n return divide_safe( vectors, mags)","def getNormalizedVector(self):\n return self.scalarMultiplication(self.norm() ** -1.0)","def normalize_vectors(motion_vectors):\n if np.shape(motion_vectors)[0] == 0:\n return motion_vectors\n else:\n motion_vectors[:, 7] = motion_vectors[:, 7] / motion_vectors[:, 0] # motion_x\n motion_vectors[:, 8] = motion_vectors[:, 8] / motion_vectors[:, 0] # motion_y\n motion_vectors[:, 0] = -1 * np.ones_like(motion_vectors[:, 0])\n return motion_vectors","def cmesh(self):\n return numpy.meshgrid(*self.centers, indexing='ij')","def xyz2plane(x,y,z, new_x=[], plane=[], origin=None):\n # preliminary stuff\n if origin != None: x = x - origin\n a,b,c,d = plane\n bottom = np.sqrt(a*a + b*b + c*c) # normalize\n a,b,c,d = a/bottom, b/bottom, c/bottom, d/bottom\n px, py, pz = new_x\n bot = np.sqrt(px*px + py*py + pz*pz) #normalize\n px, py, pz = px/bot, py/bot, pz/bot\n p0 = [px,py,pz]\n # do rotation\n z_hat = [a,b,c]\n y_hat = cross(z_hat, p0)\n x_hat = cross(y_hat, z_hat)\n if type(x)==type(arr) or type(x)==type([]):\n xp, yp, zp = [], [], []\n for i in range(len(x)):\n xp.append(dot([x[i],y[i],z[i]], x_hat))\n yp.append(dot([x[i],y[i],z[i]], y_hat))\n zp.append(dot([x[i],y[i],z[i]], z_hat))\n else:\n xp = dot([x,y,z], x_hat)\n yp = dot([x,y,z], y_hat)\n zp = dot([x,y,z], z_hat)\n return xp, yp, zp"],"string":"[\n \"def plane_equation(point_a, point_b, point_c):\\n v1 = np.subtract(point_a, point_c)\\n v2 = np.subtract(point_a, point_b)\\n normal = np.cross(v1, v2)\\n # print 'b4 norm', normal\\n unit_normal = norm_vect(normal)\\n # print 'unityyy', unit_normal\\n return unit_normal\",\n \"def get_normal_vector_of_plane(p1, p2, p3):\\n v12 = np.array(p1) - np.array(p2)\\n v13 = np.array(p1) - np.array(p3)\\n nvec = np.cross(v12, v13)\\n ## print 'norm: '+str(np.linalg.norm(nvec))\\n return nvec / np.linalg.norm(nvec)\",\n \"def compute_normalvect(self):\\n normvect = np.zeros((len(self.tri_pnts),3,3))\\n zvec = np.array([0, 0, 1])\\n for itri, tri in enumerate(self.tri_pnts):\\n #import pdb; pdb.set_trace()\\n tri0, tri1, tri2 = tri\\n x1,y1 = self.points[tri1]-self.points[tri0]\\n v1 = np.array([x1,y1,0])\\n x2,y2 = self.points[tri2]-self.points[tri1]\\n v2 = np.array([x2,y2,0])\\n x3,y3 = self.points[tri0]-self.points[tri2]\\n v3 = np.array([x3,y3,0])\\n v1 = v1/np.linalg.norm(v1)\\n v2 = v2/np.linalg.norm(v2)\\n v3 = v3/np.linalg.norm(v3)\\n #import pdb; pdb.set_trace()\\n normvect[itri,:,:] = np.cross(v1,zvec), np.cross(v2,zvec), np.cross(v3,zvec)\\n #import pdb; pdb.set_trace()\\n return normvect\",\n \"def MillerNormalVectors_110():\\r\\n k_110 = np.array([[1, 1, 0], [0, 1, 1], [1, 0, 1],\\r\\n [1, -1, 0], [0, 1, -1], [-1, 0, 1]])/np.sqrt(2.0)\\r\\n return np.array([k_110[0, :], k_110[1, :], k_110[2, :],\\r\\n k_110[3, :], k_110[4, :], k_110[5, :],\\r\\n -k_110[0, :], -k_110[1, :], -k_110[2, :],\\r\\n -k_110[3, :], -k_110[4, :], -k_110[5, :]])\",\n \"def unit_normals(self):\\n return np.stack(self.centers_cartesian(), axis=-1)\",\n \"def PlaneNormalVector(h, k, l):\\r\\n vec = np.array([h, k, l])\\r\\n return vec/np.linalg.norm(vec)\",\n \"def MillerNormalVectors_111():\\r\\n k_111 = np.array(\\r\\n [[1, 1, 1], [-1, 1, 1], [1, -1, 1], [1, 1, -1]])/np.sqrt(3.0)\\r\\n return np.array([k_111[0, :], k_111[1, :], k_111[2, :], k_111[3, :],\\r\\n -k_111[0, :], -k_111[1, :], -k_111[2, :], -k_111[3, :]])\",\n \"def normal(self) -> Vec:\\n # The three points are in clockwise order, so compute differences\\n # in the clockwise direction, then cross to get the normal.\\n point_1 = self.planes[1] - self.planes[0]\\n point_2 = self.planes[2] - self.planes[1]\\n\\n return Vec.cross(point_1, point_2).norm()\",\n \"def normal_vector(origin, vectors):\\n return np.cross(vectors[0] - origin, vectors[1] - origin)\",\n \"def getNormalizedNormalVec(self):\\n TriPos = self.position\\n # calc normalized normal vecor for Tri\\n # get vectors Vert1Vert2 & Vert2Vert3\\n TriVectors = np.subtract(TriPos[1:],TriPos[:-1])\\n # get crossproduct of Vert1Vert2 & Vert2Vert3 (= surface normal)\\n TriNorm = np.cross(TriVectors[0],TriVectors[1])+0.0\\n # get length of surface normal\\n length = np.linalg.norm(TriNorm)\\n # divide each component of surface normal by length (= normalized surface normal)\\n NormalizedNormalVec = np.around(TriNorm / length, decimals=5) # rounded, otherwise different values, equals not found\\n # create string of tuple for segment dict \\n #SegmDict = str(tuple(NormalizedNormalVec))\\n return NormalizedNormalVec.tolist()\",\n \"def get_normals(self):\\n c, s = np.cos(self.eangles), np.sin(self.eangles)\\n r = np.array([[c, -s], [s, c]])\\n us = np.array([[1, 0], [0, 1], [-1, 0], [0, -1]])\\n nsyms = 4 if self.halfexts[0] == self.halfexts[1] else 2\\n return [(np.dot(r, u), nsyms) for u in us]\",\n \"def plot_plane(unit_normal, x_array, y_array, fore):\\n # print'unit normal = ', unit_normal\\n z = (((unit_normal[0] * (fore[0] - x_array)) + (unit_normal[1] * (fore[1] - y_array))) / unit_normal[2]) + fore[2]\\n # print 'plane numbers\\\\n', z\\n return z\",\n \"def MillerNormalVectors_100():\\r\\n k_100 = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])\\r\\n return np.array([k_100[0, :], k_100[1, :], k_100[2, :],\\r\\n -k_100[0, :], -k_100[1, :], -k_100[2, :]])\",\n \"def unit_normals(p,q,r): \\n vx1 = p[0] - r[0] # x1 - x3. \\n vy1 = p[1] - r[1] # y1 - y3. \\n vz1 = p[2] - r[2] # z1 - z3. \\n\\n vx2 = q[0] - r[0] # x2 - x3. \\n vy2 = q[1] - r[1] # y2 - y3. \\n vz2 = q[2] - r[2] # z2 - z3. \\n\\n vnx = vy1*vz2 - vz1*vy2 \\n vny = vz1*vx2 - vx1*vz2 \\n vnz = vx1*vy2 - vy1*vx2 \\n\\n len_vn = math.sqrt(vnx*vnx + vny*vny + vnz*vnz) \\n vnx = vnx/len_vn \\n vny = vny/len_vn \\n vnz = vnz/len_vn \\n\\n return vnx, vny, vnz\",\n \"def make_inward_normal(tetrahedron):\\n\\n convert_to_np_array = lambda v: np.array([v.x, v.y, v.z])\\n np_vertices = list(map(convert_to_np_array, [tetrahedron.get_vertex(i) for i in range(4)]))\\n # This is the middle point\\n # midpoint = np.mean(np_vertices, axis=0)\\n\\n midpoint = np_vertices[0]\\n for i in range(1, 4):\\n midpoint += np_vertices[i]\\n midpoint = midpoint / 2.0\\n\\n for i in range(4):\\n face = tetrahedron.get_face(i)\\n d = distance(face, midpoint)\\n if d < 0:\\n face.nx *= -1.0\\n face.ny *= -1.0\\n face.nz *= -1.0\\n face.d *= -1.0\",\n \"def normal(self) -> Vec:\\n return abs(self.up_axis.cross(self.forward()))\",\n \"def calculate_plane_normal(patches):\\n normals = []\\n for patch in patches:\\n normal = get_normal(patch)\\n normals.append(normal)\\n # Taken naive mean of normals\\n # TODO outlier removal\\n normals = np.mean(np.array(normals), axis=0)\\n return normals\",\n \"def _prepare_plane(self):\\n verticies = [\\n # main plane - note that the mainplane is scaled so the mat_plane\\n # matrix will it transform to the correct coordinates\\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\\n -self.i_border[0]/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], self.i_border[1]/self._scaling[1],\\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\\n\\n # coord plane\\n 0, 0,\\n 0, -self.o_wh[1],\\n self.o_wh[0], -self.o_wh[1],\\n self.o_wh[0], -self.o_wh[1],\\n self.o_wh[0], 0,\\n 0, 0,\\n\\n # axes\\n 0, -self.o_wh[1], self.o_wh[0], -self.o_wh[1], #x\\n 0, 0, 0, -self.o_wh[1], #y\\n ]\\n\\n colors = [\\n 1.0, 1.0, 1.0, 1.0, # outer box XXX Remove outer box...\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n .9, .9, .9, 9.0, # plot box\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n 0.0, 0.0, 0.0, 1.0, #lines\\n 0.0, 0.0, 0.0, 1.0,\\n 0.0, 0.0, 0.0, 1.0,\\n 0.0, 0.0, 0.0, 1.0,\\n ]\\n\\n self._fonts = []\\n for u in range(1, self._unit_count[0]+1):\\n verticies.append(self._unit_w[0]*u)\\n verticies.append(-self.o_wh[1]+0.02)\\n verticies.append(self._unit_w[0]*u)\\n verticies.append(-self.o_wh[1]-0.02)\\n colors += [0.0, 0.0, 0.0, 1.0]\\n colors += [0.0, 0.0, 0.0, 1.0]\\n self._fonts.append([\\n '{:.2f}'.format(u*(self.i_axis[0]/self._unit_count[0])-self.i_origin[0]),\\n (self._unit_w[0]*u+self.i_border[0]-0.05)*self._scaling[0],\\n (-self.o_wh[1]+(self.i_border[3])*0.5)\\n ])\\n for u in range(0, self._unit_count[1]):\\n verticies.append(0.02)\\n verticies.append(-self._unit_w[1]*u)\\n verticies.append(-0.02)\\n verticies.append(-self._unit_w[1]*u)\\n colors += [0.0, 0.0, 0.0, 1.0]\\n colors += [0.0, 0.0, 0.0, 1.0]\\n self._fonts.append([\\n '{:.2f}'.format(self.i_axis[1]-u*self.i_axis[1]/self._unit_count[1]-self.i_origin[1]),\\n (0.025)*self._scaling[0],\\n (-(self._unit_w[1])*u-self.i_border[1]+0.01)*self._scaling[1]\\n ])\\n\\n self._draw_plane_indicies = (0, 12)\\n self._draw_line_indicies = (12, 4+self._unit_count[0]*2+self._unit_count[1]*2)\\n\\n # convert data into valid data format\\n verticies = numpy.array(verticies, dtype=numpy.float32)\\n colors = numpy.array(colors, dtype=numpy.float32)\\n\\n self._plane_vao = util.VAO()\\n self._plane_vbo = util.VBO(2)\\n\\n with self._plane_vao:\\n # plane verticies\\n with self._plane_vbo.get(0):\\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(verticies), verticies, GL_STATIC_DRAW)\\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_position'), 2, GL_FLOAT, GL_FALSE, 0, None)\\n glEnableVertexAttribArray(0)\\n\\n # place vertex colors\\n with self._plane_vbo.get(1):\\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(colors), colors, GL_STATIC_DRAW)\\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_color'), 4, GL_FLOAT, GL_FALSE, 0, None)\\n glEnableVertexAttribArray(1)\",\n \"def face_normals(xyz, triangles):\\n\\n\\tabc_xyz = face_attr(xyz, triangles)\\n\\n\\tbc_xyz = abc_xyz[:,:,1:3] - abc_xyz[:,:,0:1]\\n\\tfn = tf.linalg.cross(bc_xyz[:,:,0], bc_xyz[:,:,1])\\n\\tfn = tf.math.l2_normalize(fn, -1)\\n\\treturn fn\",\n \"def normal_vector(self, facet):\\n assert len(facet) == 3\\n pos = self.cluster.get_positions()\\n v1 = pos[facet[1], :] - pos[facet[0], :]\\n v2 = pos[facet[2], :] - pos[facet[0], :]\\n n = np.cross(v1, v2)\\n length = np.sqrt(np.sum(n**2))\\n return n / length\",\n \"def project_onto_plane(vect):\\n x, y, z = vect\\n \\n return (x, y, 0.)\",\n \"def convert_hkl_to_xyz2(self, hkl):\\n # Use the hkl miller indices to calculate the normal to a plane in cartesian space\\n p = []\\n if not hkl[0] == 0:\\n p.append(np.array(self.lattice[0] / hkl[0]))\\n if not hkl[1] == 0:\\n p.append(np.array(self.lattice[1] / hkl[1]))\\n if not hkl[2] == 0:\\n p.append(np.array(self.lattice[2] / hkl[2]))\\n if hkl[0] == 0:\\n p.append(self.lattice[0] + p[0])\\n if hkl[1] == 0:\\n p.append(self.lattice[1] + p[0])\\n if hkl[2] == 0:\\n p.append(self.lattice[2] + p[0])\\n p12 = p[1] - p[0]\\n p13 = p[2] - p[0]\\n normal = np.cross(p12, p13)\\n norm = np.linalg.norm(normal)\\n if norm < 1.0e-8:\\n print(\\\"Error in unit cell, calculation of normal to miller index failed\\\")\\n exit(1)\\n normal = normal / norm\\n return normal\",\n \"def get_normal_vectors(self, p, x1, y1, z1, x2, y2, z2, x3, y3, z3):\\n x1.value, y1.value, z1.value, x2.value, y2.value, z2.value, x3.value, y3.value, z3.value = self._get_normal_vectors(p, x1.value, y1.value, z1.value, x2.value, y2.value, z2.value, x3.value, y3.value, z3.value)\",\n \"def _normal_vector(o, p0_3d, p1_3d):\\n # The vector between middle point of v1-v2 and object center location\\n # is the normal vector I'm looking for\\n vn = p0_3d.lerp(p1_3d, 0.5) - o.matrix_world.translation\\n # normalize so I can to length computation on it\\n vn.normalize()\\n return vn\",\n \"def vrrotvec2mat(ax_ang):\\n\\n #file_dir = os.path.dirname(os.path.realpath(__file__))\\n #path_dir2 = file_dir + '/../geometry/'\\n #sys.path.append(path_dir2)\\n\\n if ax_ang.ndim == 1:\\n if np.size(ax_ang) == 5:\\n ax_ang = np.reshape(ax_ang, (5, 1))\\n msz = 1\\n elif np.size(ax_ang) == 4:\\n ax_ang = np.reshape(np.hstack((ax_ang, np.array([1]))), (5, 1))\\n msz = 1\\n else:\\n raise Exception('Wrong Input Type')\\n elif ax_ang.ndim == 2:\\n if np.shape(ax_ang)[0] == 5:\\n msz = np.shape(ax_ang)[1]\\n elif np.shape(ax_ang)[1] == 5:\\n ax_ang = ax_ang.transpose()\\n msz = np.shape(ax_ang)[1]\\n else:\\n raise Exception('Wrong Input Type')\\n else:\\n raise Exception('Wrong Input Type')\\n\\n direction = ax_ang[0:3, :]\\n angle = ax_ang[3, :]\\n\\n d = np.array(direction, dtype=np.float64)\\n d /= np.linalg.norm(d, axis=0)\\n x = d[0, :]\\n y = d[1, :]\\n z = d[2, :]\\n c = np.cos(angle)\\n s = np.sin(angle)\\n tc = 1 - c\\n\\n mt11 = tc*x*x + c\\n mt12 = tc*x*y - s*z\\n mt13 = tc*x*z + s*y\\n\\n mt21 = tc*x*y + s*z\\n mt22 = tc*y*y + c\\n mt23 = tc*y*z - s*x\\n\\n mt31 = tc*x*z - s*y\\n mt32 = tc*y*z + s*x\\n mt33 = tc*z*z + c\\n\\n mtx = np.column_stack((mt11, mt12, mt13, mt21, mt22, mt23, mt31, mt32, mt33))\\n\\n inds1 = np.where(ax_ang[4, :] == -1)\\n mtx[inds1, :] = -mtx[inds1, :]\\n\\n if msz == 1:\\n mtx = mtx.reshape(3, 3)\\n else:\\n mtx = mtx.reshape(msz, 3, 3)\\n\\n return mtx\",\n \"def vertexes(self):\\n theta = self.orientation\\n shifts = np.array([np.cos(theta), np.sin(theta)]) * self.a\\n return self.coords + (shifts[:, None] * [-1, 1]).T\",\n \"def normals(t, v):\\n n = numpy.zeros((len(t), 3))\\n for i in range(0, len(t)):\\n p = vertices(t[i], v)\\n n[i] = triangle.normal(p)\\n return n\",\n \"def generate_normals(v1, v2, v3, normalize_result=True):\\n # make vectors relative to v2\\n # we assume opengl counter-clockwise ordering\\n a = v1 - v2\\n b = v3 - v2\\n n = cross(b, a)\\n if normalize_result:\\n n = normalize(n)\\n return n\",\n \"def getNormalVector(self):\\n vector = self.unit_vector\\n vector.rotate(math.pi / 2)\\n return vector\",\n \"def vec(self):\\r\\n\\r\\n xv = np.arange(self.dx / 2, self.lx, self.dx)\\r\\n yv = np.arange(-self.ly / 2 + self.dy / 2, self.ly / 2, self.dy)\\r\\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\\r\\n\\r\\n if self.ox != 0:\\r\\n xv = np.arange(self.ox, self.lx + self.ox, self.dx)\\r\\n yv = np.arange(self.oy, self.ly + self.oy, self.dy)\\r\\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\\r\\n\\r\\n return xv, yv, zv\",\n \"def vector(self):\\n \\n v_list = Householder.triangle_operation(self)[1]\\n \\n return(v_list)\",\n \"def normal_vectors(ATOM_list, frame, number_of_atoms, number_of_molecules, number_of_vectors, centerlist, referencelist, boxX, boxY, boxZ):\\t\\n\\tNORMAL_VECTORS_out=open(\\\"normalvectors.xyz\\\",'a')\\n\\t\\n\\tNORMAL_VECTORS_check=open(\\\"check_normalvectors.xyz\\\",'a')\\n\\t\\n\\tANGLEDIST_VECTORS_out=open(\\\"angle_dist_vectors.xyz\\\",'a')\\n\\t\\n\\t\\n\\tVorzugsrichtung_out=open(\\\"sum_over_all_normalvectors.dat\\\",'a')\\n\\t\\n\\t\\n\\t\\n\\tNORMAL_VECTORS_check.write(str( (number_of_vectors*(2 + int(len(referencelist))) )*number_of_molecules )+'\\\\n')\\n\\tNORMAL_VECTORS_check.write(str(frame)+'\\\\n')\\n\\t\\n\\tNORMAL_VECTORS_out.write(str( (number_of_vectors*2)*number_of_molecules )+'\\\\n')\\n\\tNORMAL_VECTORS_out.write(str(frame)+'\\\\n')\\n\\n\\tANGLEDIST_VECTORS_out.write(str( (number_of_vectors*2)*number_of_molecules )+'\\\\n')\\n\\tANGLEDIST_VECTORS_out.write(str(frame)+'\\\\n')\\n\\t\\n\\tvorzugsvektor = np.asarray([0,0,0])\\n\\treference=0\\n\\t\\n\\t\\n\\tfor l in range(0,number_of_molecules):\\n\\t\\tfor vec_count in range(0,number_of_vectors):\\n\\t\\t\\tr = []\\n\\t\\t\\t#get the 'middle' of the DPI molecule\\n\\t\\t\\t\\n\\t\\t\\n\\t\\t\\t#get geometric center\\n\\t\\t\\tcenter=np.asarray([0,0,0])\\n\\t\\t\\t#append all vectors defining the center\\n\\t\\t\\tfor i in range(len(centerlist[vec_count])):\\n\\t\\t\\t\\t# x y z\\n\\t\\t\\t\\tr.append( np.asarray( [ ATOM_list[centerlist[vec_count][i] + reference][1],ATOM_list[centerlist[vec_count][i] + reference][2],ATOM_list[centerlist[vec_count][i] + reference][3] ] ) ) \\n\\t\\t\\t\\tcenter = center + r[i]\\n\\t\\t\\tcenter = center / len(centerlist[vec_count])\\n\\t\\t\\n\\t\\t\\t#calculate all reference vectors\\n\\t\\t\\tr=[]\\n\\t\\t\\tfor i in range(len(referencelist[vec_count])):\\n\\t\\t\\t\\tr.append(np.asarray( [ ATOM_list[referencelist[vec_count][i] + reference][1],ATOM_list[referencelist[vec_count][i] + reference][2],ATOM_list[referencelist[vec_count][i] + reference][3] ] ) )\\n\\t\\t\\n\\t\\t\\t#get the cross products\\n\\t\\t\\tnormal_vec= np.asarray([0,0,0])\\n\\t\\t\\tfor i in range(len(r)):\\n\\t\\t\\t\\tif (i<(len(r)-1)):\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t#minimum image convenction\\n\\t\\t\\t\\t\\tif ( abs(r[i][0]-center[0]) < abs(r[i][0]-center[0]+boxX) ) and ( abs(r[i][0]-center[0]) < abs(r[i][0]-center[0]-boxX) ):\\n\\t\\t\\t\\t\\t\\tdx = r[i][0]-center[0]\\n\\t\\t\\t\\t\\telif (abs(r[i][0]-center[0]+boxX) < abs(r[i][0]-center[0]-boxX) ):\\n\\t\\t\\t\\t\\t\\tdx = r[i][0]-center[0]+boxX\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdx = r[i][0]-center[0]-boxX\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif ( abs(r[i][1]-center[1]) < abs(r[i][1]-center[1]+boxY) ) and ( abs(r[i][1]-center[1]) < abs(r[i][1]-center[1]-boxY) ):\\n\\t\\t\\t\\t\\t\\tdy = r[i][1]-center[1]\\n\\t\\t\\t\\t\\telif (abs(r[i][1]-center[1]+boxY) < abs(r[i][1]-center[1]-boxY) ):\\n\\t\\t\\t\\t\\t\\tdy = r[i][1]-center[1]+boxY\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdy = r[i][1]-center[1]-boxY\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif ( abs(r[i][2]-center[2]) < abs(r[i][2]-center[2]+boxZ) ) and ( abs(r[i][2]-center[2]) < abs(r[i][2]-center[2]-boxZ) ):\\n\\t\\t\\t\\t\\t\\tdz = r[i][2]-center[2]\\n\\t\\t\\t\\t\\telif (abs(r[i][2]-center[2]+boxZ) < abs(r[i][2]-center[2]-boxZ) ):\\n\\t\\t\\t\\t\\t\\tdz = r[i][2]-center[2]+boxZ\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdz = r[i][2]-center[2]-boxZ\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t#minimum image convenction\\n\\t\\t\\t\\t\\tif ( abs(r[i+1][0]-center[0]) < abs(r[i+1][0]-center[0]+boxX) ) and ( abs(r[i+1][0]-center[0]) < abs(r[i+1][0]-center[0]-boxX) ):\\n\\t\\t\\t\\t\\t\\tdx2 = r[i+1][0]-center[0]\\n\\t\\t\\t\\t\\telif (abs(r[i+1][0]-center[0]+boxX) < abs(r[i+1][0]-center[0]-boxX) ):\\n\\t\\t\\t\\t\\t\\tdx2 = r[i+1][0]-center[0]+boxX\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdx2 = r[i+1][0]-center[0]-boxX\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif ( abs(r[i+1][1]-center[1]) < abs(r[i+1][1]-center[1]+boxY) ) and ( abs(r[i+1][1]-center[1]) < abs(r[i+1][1]-center[1]-boxY) ):\\n\\t\\t\\t\\t\\t\\tdy2 = r[i+1][1]-center[1]\\n\\t\\t\\t\\t\\telif (abs(r[i+1][1]-center[1]+boxY) < abs(r[i+1][1]-center[1]-boxY) ):\\n\\t\\t\\t\\t\\t\\tdy2 = r[i+1][1]-center[1]+boxY\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdy2 = r[i+1][1]-center[1]-boxY\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif ( abs(r[i+1][2]-center[2]) < abs(r[i+1][2]-center[2]+boxZ) ) and ( abs(r[i+1][2]-center[2]) < abs(r[i+1][2]-center[2]-boxZ) ):\\n\\t\\t\\t\\t\\t\\tdz2 = r[i+1][2]-center[2]\\n\\t\\t\\t\\t\\telif (abs(r[i+1][2]-center[2]+boxZ) < abs(r[i+1][2]-center[2]-boxZ) ):\\n\\t\\t\\t\\t\\t\\tdz2 = r[i+1][2]-center[2]+boxZ\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdz2 = r[i+1][2]-center[2]-boxZ\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tvec1=np.asarray([dx,dy,dz])\\n\\t\\t\\t\\t\\tvec2=np.asarray([dx2,dy2,dz2])\\n\\t\\t\\t\\t\\t#dy = r[i][1]-center[1]\\n\\t\\t\\t\\t\\t#dz = r[i][2]-center[2]\\n\\t\\t\\t\\t\\t#normal_vec = normal_vec + np.cross(r[i]-center, r[i+1]-center)\\n\\t\\t\\t\\t\\tnormal_vec = normal_vec + np.cross(vec1, vec2)/np.linalg.norm( np.cross(vec1, vec2) )\\n\\t\\t\\t\\telif ( i==len(r) ):\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t#minimum image convenction\\n\\t\\t\\t\\t\\tdx = min( abs(r[i][0]-center[0]), abs(r[i][0]-center[0]+boxX), abs(r[i][0]-center[0]-boxX) )\\n\\t\\t\\t\\t\\tdy = min( abs(r[i][1]-center[1]), abs(r[i][1]-center[1]+boxX), abs(r[i][1]-center[1]-boxX) )\\n\\t\\t\\t\\t\\tdz = min( abs(r[i][2]-center[2]), abs(r[i][2]-center[2]+boxX), abs(r[i][2]-center[2]-boxX) )\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tdx2 = min( abs(r[0][0]-center[0]), abs(r[0][0]-center[0]+boxX), abs(r[0][0]-center[0]-boxX) )\\n\\t\\t\\t\\t\\tdy2 = min( abs(r[0][1]-center[1]), abs(r[0][1]-center[1]+boxX), abs(r[0][1]-center[1]-boxX) )\\n\\t\\t\\t\\t\\tdz2 = min( abs(r[0][2]-center[2]), abs(r[0][2]-center[2]+boxX), abs(r[0][2]-center[2]-boxX) )\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tvec1=np.asarray([dx,dy,dz])\\n\\t\\t\\t\\t\\tvec2=np.asarray([dx2,dy2,dz2])\\n\\t\\t\\t\\t\\t#dy = r[i][1]-center[1]\\n\\t\\t\\t\\t\\t#dz = r[i][2]-center[2]\\n\\t\\t\\t\\t\\t#normal_vec = normal_vec + np.cross(r[i]-center, r[i+1]-center)\\n\\t\\t\\t\\t\\tnormal_vec = normal_vec + np.cross(vec1, vec2)/np.linalg.norm(np.cross(vec1, vec2))\\n\\t\\t\\t\\t\\t#normal_vec = normal_vec + np.cross(r[i]-center, r[0]-center) \\n\\t\\t\\n\\t\\t\\t#normalize\\n\\t\\t\\tnormal_vec = normal_vec/np.linalg.norm(normal_vec)\\n\\t\\t\\n\\t\\t\\t#\\t#direction vectors\\n\\t\\t\\t#\\tdir_vec1 = np.asarray([r[6][0],r[6][1],r[6][2]])\\n\\t\\t\\t#\\tdir_vec2 = np.asarray([r[7][0],r[7][1],r[7][2]])\\n\\t\\t\\t#\\tdir_vec3 = np.asarray([r[8][0],r[8][1],r[8][2]])\\n\\t\\t\\t#\\tdir_vec4 = np.asarray([r[9][0],r[9][1],r[9][2]])\\n\\t\\t\\t#\\tdir_vec = (dir_vec1 + dir_vec2 + dir_vec3 + dir_vec4)/4.0\\n\\t\\t\\t#\\tdir_vec = mittelpunkt_dpi - dir_vec\\t\\t\\t\\n\\n\\t\\t\\t#change direction according to bending\\n\\t\\t\\t#\\tif normal_vec[0]!=0 and dir_vec[0]!=0:\\n\\t\\t\\t#\\t\\tif normal_vec[0]/abs(normal_vec[0])!=dir_vec[0]/abs(dir_vec[0]):\\n\\t\\t\\t#\\t\\t\\tnormal_vec[0] = -normal_vec[0]\\n\\t\\t\\t#\\tif normal_vec[1]!=0 and dir_vec[1]!=0:\\n\\t\\t#\\t\\t\\tif normal_vec[1]/abs(normal_vec[1])!=dir_vec[1]/abs(dir_vec[1]):\\n\\t\\t#\\t\\t\\t\\tnormal_vec[1] = -normal_vec[1]\\n\\t\\t#\\t\\tif normal_vec[2]!=0 and dir_vec[2]!=0:\\n\\t\\t#\\t\\t\\tif normal_vec[2]/abs(normal_vec[2])!=dir_vec[2]/abs(dir_vec[2]):\\n\\t\\t#\\t\\t\\t\\tnormal_vec[2] = -normal_vec[2]\\n\\n\\t\\t\\t\\n\\t\\t\\t#check for a vorzugsvektor\\n\\t\\t\\tvorzugsvektor = vorzugsvektor + normal_vec\\n\\t\\t\\tNORMAL_VECTORS_out.write('C' +'\\t'+ str((center)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tNORMAL_VECTORS_out.write('O' +'\\t'+ str((center+normal_vec)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tANGLEDIST_VECTORS_out.write('C' +'\\t'+ str((center)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tANGLEDIST_VECTORS_out.write('H' +'\\t'+ str((normal_vec)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tNORMAL_VECTORS_check.write('C' +'\\t'+ str((center)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tNORMAL_VECTORS_check.write('O' +'\\t'+ str((center+normal_vec)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tNORMAL_VECTORS_check.write('H' +'\\t'+ str((normal_vec)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tfor i in range(len(referencelist[vec_count])):\\n\\t\\t\\t\\tNORMAL_VECTORS_check.write('N' +'\\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][1])+'\\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][2])+'\\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][3])+ '\\\\n')\\n\\n\\t\\t#always skip 1 entire molecule forward\\n\\t\\treference=reference + number_of_atoms/number_of_molecules\\n\\t\\t\\n\\t#calculate a vorzugsvektor as sum over DIPBI normal vectors divided by number of DPBI vectors\\n\\tvorzugsvektor = vorzugsvektor/(number_of_vectors*frames*number_of_molecules)\\n\\tVorzugsrichtung_out.write(str(frame) + ' ' + str((vorzugsvektor)).replace('[', '').replace(']','')+'\\\\n')\\n\\tNORMAL_VECTORS_out.close()\\n\\tNORMAL_VECTORS_check.close()\\n\\treturn\",\n \"def find_plane_angles(self, roof_motor_position):\\n\\n # Calcolo il punto mediano tra i vertici 2 e 3\\n pc_x = (self.roof_vertex_x[1] + self.roof_vertex_x[2]) / 2\\n pc_y = (self.roof_vertex_y[1] + self.roof_vertex_y[2]) / 2\\n pc_z = (self.roof_vertex_z[1] + self.roof_vertex_z[2]) / 2\\n\\n # Questa non so cosa sia\\n base_r = [[self.roof_vertex_x[0] - pc_x, self.roof_vertex_y[0] - pc_y, self.roof_vertex_z[0] - pc_z],\\n [self.roof_vertex_x[1] - pc_x, self.roof_vertex_y[1] - pc_y, self.roof_vertex_z[1] - pc_z],\\n [0.0, 0.0, 0.0]]\\n\\n # Questa e' la costruzione di una matrice\\n mat_rot = [[0.0, 0.0, 0.0],\\n [0.0, 0.0, 0.0],\\n [0.0, 0.0, 0.0]]\\n\\n # Non so quale operazione è implementata, ma a me servono solo tre elementi, j=2, i=0,1, j=1, i=0\\n # Primo elemento, j=1, i=0\\n mr = math.sqrt((base_r[0][0] ** 2) + (base_r[0][1] ** 2) + (base_r[0][2] ** 2))\\n mat_rot[1][0] = base_r[0][1] / mr\\n # Secondo elemento, j=2, i=0\\n mat_rot[2][0] = base_r[0][2] / mr\\n # Terzo elemento, j=2, i=1\\n mr = math.sqrt((base_r[1][0] ** 2) + (base_r[1][1] ** 2) + (base_r[1][2] ** 2))\\n mat_rot[2][1] = base_r[1][2] / mr\\n\\n # In alternativa posso calcolare tutti gli elementi della matrice\\n # for i in range(2):\\n # mr = math.sqrt((base_r[i][0] ** 2) + (base_r[i][1] ** 2) + (base_r[i][2] ** 2))\\n # for j in range(3):\\n # base_r[i][j] /= mr\\n # mat_rot[j][i] = base_r[i][j]\\n\\n # Sono elementi della matrice non utilizzati\\n # base_r[2][0] = +base_r[1][1] * base_r[0][2] - base_r[0][1] * base_r[1][2]\\n # base_r[2][1] = -base_r[1][0] * base_r[0][2] + base_r[0][0] * base_r[1][2]\\n # base_r[2][2] = +base_r[1][0] * base_r[0][1] - base_r[0][0] * base_r[1][1]\\n # for i in range(3):\\n # mat_rot[i][2] = base_r[2][i]\\n\\n # Qui estraggo la terna di Tait-Bryan angles usata internamente, la Z1Y2X3\\n k17 = mat_rot[2][0]\\n k16 = mat_rot[1][0]\\n l17 = mat_rot[2][1]\\n m20 = math.asin(k17)\\n i23 = math.cos(m20)\\n i24 = k16 / i23\\n i25 = l17 / i23\\n m19 = math.asin(i24)\\n self.zyx1_r = m19 + roof_motor_position\\n self.zyx2_r = math.asin(k17)\\n self.zyx3_r = math.asin(i25)\\n self.zyx3 = self.zyx3_r / Kinematic.M_TO_RAD\\n self.zyx2 = self.zyx2_r / Kinematic.M_TO_RAD\\n self.zyx1 = self.zyx1_r / Kinematic.M_TO_RAD\\n angles = self.zyx_r_to_xyz(self.zyx3_r, self.zyx2_r, self.zyx1_r)\\n self.xyz1 = angles[2]\\n self.xyz2 = angles[0]\\n self.xyz3 = angles[1]\\n self.xyz1_r = angles[5]\\n self.xyz2_r = angles[3]\\n self.xyz3_r = angles[4]\",\n \"def _update_surface_normals(self):\\n\\n # This is the case if there are too few points to\\n # compute normals so there can be values to remove\\n\\n #can be important for parallel\\n self.swarm.shadow_particles_fetch()\\n\\n if self.empty:\\n self.director.data[...] = 0.0\\n else:\\n\\n particle_coords = self.swarm.particleCoordinates.data\\n\\n Nx = np.empty(self.swarm.particleLocalCount)\\n Ny = np.empty(self.swarm.particleLocalCount)\\n Nz = np.empty(self.swarm.particleLocalCount)\\n\\n for i, xyz in enumerate(particle_coords):\\n r, neighbours = self.kdtree.query(particle_coords[i], k=4)\\n\\n # this point is neighbour[0] and neighbour points are neighbours[(1,2,3)]\\n XYZ1 = self.kdtree.data[neighbours[1]]\\n XYZ2 = self.kdtree.data[neighbours[2]]\\n XYZ3 = self.kdtree.data[neighbours[3]]\\n\\n dXYZ1 = XYZ2 - XYZ1\\n dXYZ2 = XYZ3 - XYZ1\\n\\n # Cross product of those 2 vectors can be use as the local normal (perhaps)\\n\\n Nx[i], Ny[i], Nz[i] = np.cross(dXYZ1, dXYZ2)\\n #if i == 0:\\n # print(Nx, Ny, Nz)\\n # print(xyz[0], xyz[1],xyz[2])\\n # print((self.insidePt[0] - xyz[0]) * Nx[i] )\\n\\n if (self.insidePt):\\n sign = np.sign( (self.insidePt[0] - xyz[0]) * Nx[i] +\\n (self.insidePt[1] - xyz[1]) * Ny[i] +\\n (self.insidePt[2] - xyz[2]) * Nz[i] )\\n Nx[i] *= sign\\n Ny[i] *= sign\\n Nz[i] *= sign\\n\\n\\n for i in range(0, self.swarm.particleLocalCount):\\n scale = 1.0 / np.sqrt(Nx[i]**2 + Ny[i]**2 + Nz[i]**2)\\n Nx[i] *= scale\\n Ny[i] *= scale\\n Nz[i] *= scale\\n\\n\\n self.director.data[:,0] = Nx[:]\\n self.director.data[:,1] = Ny[:]\\n self.director.data[:,2] = Nz[:]\\n\\n print(\\\"Surf Norms\\\")\\n\\n return\",\n \"def uvmap(self, p):\\n # bottom left corner of the plane\\n p00 = self.position - (self.sx * self.n0) / 2 - (self.sy * self.n1) / 2\\n dif_vector = p - p00\\n u = np.dot(dif_vector, self.n0) / self.sx\\n v = np.dot(dif_vector, self.n1) / self.sy\\n return u, v\",\n \"def vector_line(self):\\n assert len(self.xcoords) == 2\\n diff_x = self.xcoords[1] - self.xcoords[0]\\n diff_z = self.zcoords[1] - self.zcoords[0]\\n vec = np.hstack((diff_x, diff_z))\\n return vec\",\n \"def normal(self,points):\\n ez=np.array([[0,0,1]])\\n v=((points-self.pos()*ez)*self.C-ez)\\n return (v/np.linalg.norm(v,axis=1)[:,np.newaxis])#*np.sign(self.C)\",\n \"def generate_V(self):\\n\\n n_samples, n_dimensions, L = self.n_samples, self.n_dimensions, self.L\\n\\n V = np.zeros([L + 1, n_dimensions], dtype=int)\\n V[1:, 0] = [1 << (self.scale - j) for j in range(1, L + 1)]\\n\\n for i in range(n_dimensions - 1):\\n\\n m = np.array(directions[i], dtype=int)\\n s = len(m) - 1\\n\\n # The following code discards the first row of the ``m`` array\\n # Because it has floating point errors, e.g. values of 2.24e-314\\n if L <= s:\\n V[1:, i + 1] = [m[j] << (self.scale - j) for j in range(1, L + 1)]\\n else:\\n V[1 : s + 1, i + 1] = [\\n m[j] << (self.scale - j) for j in range(1, s + 1)\\n ]\\n for j in range(s + 1, L + 1):\\n V[j, i + 1] = V[j - s, i + 1] ^ (V[j - s, i + 1] >> s)\\n for k in range(1, s):\\n V[j, i + 1] ^= ((m[0] >> (s - 1 - k)) & 1) * V[j - k][i + 1]\\n\\n return V\",\n \"def getVectors(self):\\n l = len(self.points)\\n return [Vector.createFromTwoPoints(self.points[i % l], self.points[(i + 1) % l], \\\\\\n color=self.side_color, width=self.side_width) for i in range(l)]\",\n \"def getNormals(vertA, vertB, vertC):\\n xA = vertA[0]\\n xB = vertB[0]\\n xC = vertC[0]\\n yA = vertA[1]\\n yB = vertB[1]\\n yC = vertC[1]\\n zA = vertA[2]\\n zB = vertB[2]\\n zC = vertC[2]\\n ABx = xB - xA\\n ABy = yB - yA\\n ABz = zB - zA\\n BCx = xC - xB\\n BCy = yC - yB\\n BCz = zC - zB\\n Nx = ABy * BCz - ABz * BCy\\n Ny = ABz * BCx - ABx * BCz\\n Nz = ABx * BCy - ABy * BCx\\n VecMag = math.sqrt(Nx ** 2 + Ny ** 2 + Nz ** 2)\\n Ni = Nx / VecMag\\n Nj = Ny / VecMag\\n Nk = Nz / VecMag\\n return [Ni, Nj, Nk]\",\n \"def calculateMeshNormal(mesh_face_vertices):\\n mesh_normal = []\\n for mesh in mesh_face_vertices:\\n v1x = mesh[1, 0] - mesh[0, 0]\\n v1y = mesh[1, 1] - mesh[0, 1]\\n v1z = mesh[1, 2] - mesh[0, 2]\\n v2x = mesh[2, 0] - mesh[1, 0]\\n v2y = mesh[2, 1] - mesh[1, 1]\\n v2z = mesh[2, 2] - mesh[1, 2]\\n \\n normal = np.array([v1y * v2z - v1z * v2y, v1z * v2x - v1x * v2z, v1x * v2y - v1y * v2x])\\n normal = normal / np.max((np.linalg.norm(normal), 1e-5))\\n normal = (normal + 1) * 127.5\\n mesh_normal.append(normal)\\n return np.array(mesh_normal)\",\n \"def volume_tetrahedron(xyz, A, B, C, D):\\n\\n AD = xyz[A, :] - xyz[D, :]\\n BD = xyz[B, :] - xyz[D, :]\\n CD = xyz[C, :] - xyz[D, :]\\n\\n V = (\\n (BD[:, 0] * CD[:, 1] - BD[:, 1] * CD[:, 0]) * AD[:, 2]\\n - (BD[:, 0] * CD[:, 2] - BD[:, 2] * CD[:, 0]) * AD[:, 1]\\n + (BD[:, 1] * CD[:, 2] - BD[:, 2] * CD[:, 1]) * AD[:, 0]\\n )\\n return V / 6\",\n \"def plane_from_points(a, b, c):\\n ab = subtract_vectors(b, a)\\n ac = subtract_vectors(c, a)\\n n = normalize_vector(cross_vectors(ab, ac))\\n return a, n\",\n \"def landmarks_as_vectors(landmarks):\\n mat = []\\n for lm in landmarks:\\n mat.append(lm.as_vector())\\n return np.array(mat)\",\n \"def plane(self):\\n return plane(self.N, self.o)\",\n \"def vector(molec, dihed, nonH, energy):\\n #Torison\\n if dihed:\\n pass\\n #XYZ\\n else:\\n coords = ()\\n if nonH:\\n for atom in molec.atoms:\\n coords += atom.coords\\n else:\\n for atom in molec.atoms:\\n if atom.atomicnum > 1:\\n coords += atom.coords\\n #Energy\\n if energy:\\n coords += (molec.energy/10.0,)\\n return coords\",\n \"def vert_normals(xyz, triangles):\\n\\n\\tB, N, _ = _shape(xyz)\\n\\tM = _shape(triangles)[-2]\\n\\ttriangles = _i64(triangles)\\n\\t\\n\\tfn = face_normals(xyz, triangles)\\n\\tbfn = tf.reshape(tf.tile(fn, [1,1,3]), [B*M*3, 3])\\n\\tbt = tf.reshape(\\n\\t\\ttriangles[tf.newaxis,:,:] + _i64(tf.range(B)[:,tf.newaxis,tf.newaxis] * N),\\n\\t\\t[B*M*3])\\n\\tvn = tf.reshape(tf.math.unsorted_segment_sum(bfn, bt, B*N), [B,N,3])\\n\\tvn = tf.math.l2_normalize(vn, -1)\\n\\treturn vn\",\n \"def hexgrid(self):\\n n = self.n * 2\\n vectors = []\\n for u in range(-n, n+1):\\n us = [u] * (2*n+1)\\n if u < 0:\\n vectors.extend(zip(us, range(-n-u, n+1), range(-n, n+u+1)))\\n else:\\n vectors.extend(zip(us, range(-n, n-u+1), range(-n+u, n+1)))\\n return vectors\",\n \"def uVectNorm(x1,y1,z1, # P\\n x2,y2,z2, # Q\\n x3,y3,z3): # R\\n p1 = np.array([x1,y1,z1])\\n p2 = np.array([x2,y2,z2])\\n p3 = np.array([x3,y3,z3])\\n\\n v1 = p3-p1\\n v2 = p2-p1\\n\\n cp = np.cross(v1,v2)\\n a,b,c = cp\\n\\n d = np.dot(cp, p3)\\n\\n print(a,b,c)\",\n \"def to_mesh(\\n self,\\n lims_x: array_like = (-1, 1),\\n lims_y: array_like = (-1, 1),\\n ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\\n a, b, c, d = self.cartesian()\\n x_center, y_center = self.point[:2]\\n\\n values_x = x_center + lims_x\\n values_y = y_center + lims_y\\n\\n X, Y = np.meshgrid(values_x, values_y)\\n\\n if c != 0:\\n Z = -(a * X + b * Y + d) / c\\n\\n elif b != 0:\\n Z = -(a * X + c * Y + d) / b\\n X, Y, Z = X, Z, Y\\n\\n else:\\n Z = -(b * X + c * Y + d) / a\\n X, Y, Z = Z, X, Y\\n\\n return X, Y, Z\",\n \"def invgeochart(w):\\n # u = torch.asin(w[...,2])\\n u = torch.acos(w[...,2])\\n # v = torch.acos(w[...,0]/torch.cos(u))\\n v = torch.atan(w[...,1]/w[...,0])\\n return torch.stack((u,v+np.pi))\",\n \"def normal(axis_direction, axis_origin, point):\\n # transform input into numpy arrays\\n axis_direction = np.array(axis_direction, float)\\n axis_origin = np.array(axis_origin, float)\\n point = np.array(point, float)\\n\\n # vector from axis normal_origin to point\\n vector = point - axis_origin\\n\\n # projection of vector on axis\\n projection = np.dot(vector, axis_direction)*axis_direction\\n\\n # the normal vector from normal_origin to point\\n normal_direction = vector - projection\\n\\n # normalized normal_direction\\n normal_direction = normal_direction/np.linalg.norm(normal_direction)\\n\\n # opposite of the projection of vector on normal\\n projection2 = - np.dot(normal_direction, vector)*normal_direction\\n\\n normal_origin = point + projection2\\n\\n return normal_direction, normal_origin\",\n \"def voxelize4(self, materials):\\n\\t\\tlayers = list()\\n\\t\\tlayersR = list()\\n\\t\\tlayersG = list()\\n\\t\\tlayersB = list()\\n\\t\\t\\n\\t\\tlayerMaterial = list()\\n\\t\\tself.volumeComposition = list()\\n\\t\\tfor l in range(len(materials)):\\n\\t\\t\\tlayerMaterial.append(list())\\n\\t\\t\\tself.volumeComposition.append(list())\\n\\n\\t\\tvolumeGeneral = list()\\n\\t\\tm = 0\\n\\t\\tfor i in self.slicePoints:\\n\\t\\t\\t#print self.boolResult[m].shape\\n\\t\\t\\ttupleResultR = numpy.zeros(self.boolLayers[m].shape, dtype=uint8)\\n\\t\\t\\ttupleResultG = numpy.zeros(self.boolLayers[m].shape, dtype=uint8)\\n\\t\\t\\ttupleResultB = numpy.zeros(self.boolLayers[m].shape, dtype=uint8)\\n\\t\\t\\ttupleMaterial = list()\\n\\t\\t\\tfor l in range(len(materials)):\\n\\t\\t\\t\\ttupleMaterial.append(numpy.zeros(self.boolLayers[m].shape, dtype=float))\\n\\t\\t\\t\\n\\t\\t\\tj = numpy.nditer(self.boolLayers[m], flags=['multi_index'], op_flags=['readwrite'])\\n\\t\\t\\twhile not j.finished:\\n\\t\\t\\t\\tif j[0] == True:\\n\\t\\t\\t\\t#tupleResult[j.multi_index] = round((i[direction] - minValue) * ratio)\\n\\t\\t\\t\\t#tupleResult[j.multi_index] = 78\\n\\t\\t\\t\\t\\tprint type(j.multi_index)\\n\\t\\t\\t\\t\\tprint j.multi_index\\n\\t\\t\\t\\t\\t#tupleResult[j.multi_index] = planeWeight * math.fabs((j.multi_index[1] - planeOrigin[0]) * planeNormal[0] + (j.multi_index[0] - planeOrigin[1]) * planeNormal[1] + (i[2] - planeOrigin[2]) * planeNormal[2]) + pointWeight * math.sqrt(math.pow((j.multi_index[1]- pointValue[0]),2) + math.pow((j.multi_index[0] - pointValue[1]), 2)+math.pow((i[2] - pointValue[2]),2))\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tdistanceList = []\\n\\t\\t\\t\\t\\ttotalDistance = 0.0\\n\\t\\t\\t\\t\\tfor k in range(len(materials)):\\n\\t\\t\\t\\t\\t\\tif materials[k].controlSourceType == \\\"Plane\\\":\\n\\t\\t\\t\\t\\t\\t\\tGplane = math.fabs((j.multi_index[1] - materials[k].origin[0]) * materials[k].normal[0] + (j.multi_index[0] - materials[k].origin[1]) * materials[k].normal[1] + (i[2] - materials[k].origin[2]) * materials[k].normal[2])\\n\\t\\t\\t\\t\\t\\t\\tdistanceList.append(Gplane)\\n\\t\\t\\t\\t\\t\\t\\ttotalDistance += Gplane\\n\\t\\t\\t\\t\\t\\tif materials[k].controlSourceType == \\\"Point\\\":\\n\\t\\t\\t\\t\\t\\t\\tGpoint = (math.sqrt(math.pow((j.multi_index[1]- materials[k].point[0]),2) + math.pow((j.multi_index[0] - materials[k].point[1]), 2)+math.pow((i[2] - materials[k].point[2]),2)))\\n\\t\\t\\t\\t\\t\\t\\tdistanceList.append(Gpoint)\\n\\t\\t\\t\\t\\t\\t\\ttotalDistance += Gpoint\\n\\t\\t\\t\\t\\tfor k in range(len(distanceList)):\\n\\t\\t\\t\\t\\t\\tdistanceList[k] = distanceList[k] / totalDistance\\n\\t\\t\\t\\t\\t\\tdistanceList[k] = 1.0 - distanceList[k]\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\ttupleMaterial[k][j.multi_index] = distanceList[k]\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\ttupleResultR[j.multi_index] += materials[k].materialColor[0] * distanceList[k] * materials[k].weight\\n\\t\\t\\t\\t\\t\\ttupleResultG[j.multi_index] += materials[k].materialColor[1] * distanceList[k] * materials[k].weight\\n\\t\\t\\t\\t\\t\\ttupleResultB[j.multi_index] += materials[k].materialColor[2] * distanceList[k] * materials[k].weight\\n\\t\\t\\t\\t\\t#if(tupleResult[j.multi_index] > 0):\\n\\t\\t\\t\\t\\t#\\ttupleResult[j.multi_index] = round(tupleResult[j.multi_index]) \\n\\t\\t\\t\\t\\t#if(tupleResult[j.multi_index] == 0):\\n\\t\\t\\t\\t\\t#\\t\\ttupleResult[j.multi_index] = 1\\n\\t\\t\\t\\t\\t#if(tupleResult[j.multi_index] < 0):\\n\\t\\t\\t\\t\\t#\\ttupleResult[j.multi_index] = round(0 - tupleResult[j.multi_index]) \\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\ttupleResultR[j.multi_index] = 0\\n\\t\\t\\t\\t\\ttupleResultG[j.multi_index] = 0\\n\\t\\t\\t\\t\\ttupleResultB[j.multi_index] = 0\\n\\t\\t\\t\\t\\tfor k in range(len(materials)):\\n\\t\\t\\t\\t\\t\\ttupleMaterial[k][j.multi_index] = 0.0\\n\\t\\t\\t\\tj.iternext()\\n\\t\\t\\tlayersR.append(tupleResultR)\\n\\t\\t\\tlayersG.append(tupleResultG)\\n\\t\\t\\tlayersB.append(tupleResultB)\\n\\t\\t\\tfor k in range(len(materials)):\\n\\t\\t\\t\\tlayerMaterial[k].append(tupleMaterial[k])\\n\\t\\t\\t\\t\\n\\t\\t\\tm = m + 1\\n\\t\\tprint \\\"i got here\\\"\\n\\t\\tvolumeR=numpy.array(layersR) # create the 3d volume\\n\\t\\tvolumeG=numpy.array(layersG) \\n\\t\\tvolumeB=numpy.array(layersB)\\n\\t\\tfor k in range(len(materials)):\\n\\t\\t\\tself.volumeComposition[k] = numpy.array(layerMaterial[k])\\n\\t\\t\\n\\t\\tvolumeGeneral.append(volumeR)\\n\\t\\tvolumeGeneral.append(volumeG)\\n\\t\\tvolumeGeneral.append(volumeB)\\n\\t\\treturn volumeGeneral\",\n \"def get_plane_of_points(\\n self,\\n normal_vector=\\\"z\\\",\\n planar_coordinate=None,\\n ):\\n # Get results vectors\\n if (normal_vector == \\\"z\\\"):\\n x_flat = self.floris.grid.x_sorted_inertial_frame[0, 0].flatten()\\n y_flat = self.floris.grid.y_sorted_inertial_frame[0, 0].flatten()\\n z_flat = self.floris.grid.z_sorted_inertial_frame[0, 0].flatten()\\n else:\\n x_flat = self.floris.grid.x_sorted[0, 0].flatten()\\n y_flat = self.floris.grid.y_sorted[0, 0].flatten()\\n z_flat = self.floris.grid.z_sorted[0, 0].flatten()\\n u_flat = self.floris.flow_field.u_sorted[0, 0].flatten()\\n v_flat = self.floris.flow_field.v_sorted[0, 0].flatten()\\n w_flat = self.floris.flow_field.w_sorted[0, 0].flatten()\\n\\n # Create a df of these\\n if normal_vector == \\\"z\\\":\\n df = pd.DataFrame(\\n {\\n \\\"x1\\\": x_flat,\\n \\\"x2\\\": y_flat,\\n \\\"x3\\\": z_flat,\\n \\\"u\\\": u_flat,\\n \\\"v\\\": v_flat,\\n \\\"w\\\": w_flat,\\n }\\n )\\n if normal_vector == \\\"x\\\":\\n df = pd.DataFrame(\\n {\\n \\\"x1\\\": y_flat,\\n \\\"x2\\\": z_flat,\\n \\\"x3\\\": x_flat,\\n \\\"u\\\": u_flat,\\n \\\"v\\\": v_flat,\\n \\\"w\\\": w_flat,\\n }\\n )\\n if normal_vector == \\\"y\\\":\\n df = pd.DataFrame(\\n {\\n \\\"x1\\\": x_flat,\\n \\\"x2\\\": z_flat,\\n \\\"x3\\\": y_flat,\\n \\\"u\\\": u_flat,\\n \\\"v\\\": v_flat,\\n \\\"w\\\": w_flat,\\n }\\n )\\n\\n # Subset to plane\\n # TODO: Seems sloppy as need more than one plane in the z-direction for GCH\\n if planar_coordinate is not None:\\n df = df[np.isclose(df.x3, planar_coordinate)] # , atol=0.1, rtol=0.0)]\\n\\n # Drop duplicates\\n # TODO is this still needed now that we setup a grid for just this plane?\\n df = df.drop_duplicates()\\n\\n # Sort values of df to make sure plotting is acceptable\\n df = df.sort_values([\\\"x2\\\", \\\"x1\\\"]).reset_index(drop=True)\\n\\n return df\",\n \"def get_fault_rotation_matrix(plane_normal: np.ndarray, cutoff_vecmag: float = 0.98):\\n # Reference directions to try are z=1 (vertical) and y=1 (north).\\n ref_dir1 = np.array([0.0, 0.0, 1.0], dtype=np.float64)\\n ref_dir2 = np.array([0.0, 1.0, 0.0], dtype=np.float64)\\n ref_dir = ref_dir1\\n\\n # If normal is nearly vertical, use north reference direction.\\n if (np.dot(ref_dir1, plane_normal) > cutoff_vecmag):\\n ref_dir = ref_dir2\\n \\n # Get two tangential directions in plane.\\n tan_dir1 = rsqsim_api.fault.patch.cross_3d(ref_dir, plane_normal)\\n tan_dir1 /= np.linalg.norm(tan_dir1)\\n tan_dir2 = rsqsim_api.fault.patch.cross_3d(plane_normal, tan_dir1)\\n tan_dir2 /= np.linalg.norm(tan_dir2)\\n\\n # Form rotation matrix.\\n rotation_matrix = np.column_stack((tan_dir1, tan_dir2, plane_normal))\\n\\n return rotation_matrix\",\n \"def unit_vectors(self):\\n # return {'comp1': CartesianRepresentation(...),\\n # 'comp2': CartesianRepresentation(...),\\n # 'comp3': CartesianRepresentation(...)}\\n raise Exception(\\\"Not yet implemented\\\")\",\n \"def _generate_meshes(self, vectors, width):\\n centers = np.repeat(vectors, 2, axis=0)\\n offsets = segment_normal(vectors[::2, :], vectors[1::2, :])\\n offsets = np.repeat(offsets, 4, axis=0)\\n signs = np.ones((len(offsets), 2))\\n signs[::2] = -1\\n offsets = offsets*signs\\n\\n vertices = centers + width*offsets/2\\n triangles = np.array([[2*i, 2*i+1, 2*i+2] if i % 2 == 0 else\\n [2*i-1, 2*i, 2*i+1] for i in\\n range(len(vectors))]).astype(np.uint32)\\n\\n return vertices, triangles\",\n \"def reciprocal_lattice_vectors(a):\\n b = np.zeros(shape=(3,3))\\n b[:,0] = 2 * np.pi * np.cross(a[:,1], a[:,2]) / triple_product(a[:,0], a[:,1], a[:,2])\\n b[:,1] = 2 * np.pi * np.cross(a[:,2], a[:,0]) / triple_product(a[:,1], a[:,2], a[:,0])\\n b[:,2] = 2 * np.pi * np.cross(a[:,0], a[:,1]) / triple_product(a[:,2], a[:,0], a[:,1])\\n return b\",\n \"def transform_space(normal_map, rotmat):\\n rotmat = np.array(rotmat)\\n orig_shape = normal_map.shape\\n normal = normal_map.reshape(-1, 3).T # 3-by-N\\n\\n normal_trans = rotmat.dot(normal)\\n\\n normal_map_trans = normal_trans.T.reshape(orig_shape)\\n return normal_map_trans\",\n \"def lin_a98rgb_to_xyz(rgb: Vector) -> Vector:\\n\\n return alg.dot(RGB_TO_XYZ, rgb, dims=alg.D2_D1)\",\n \"def getNormDetXYZ(self):\\n\\t\\t(node0,node1) = self.getTwoNodes()\\n\\t\\tbeta_in = node0.getBeta()\\n\\t\\tbeta_out = node1.getBeta()\\n\\t\\tgamma_in = node0.getGamma()\\n\\t\\tgamma_out = node1.getGamma()\\n\\t\\tgb_in = beta_in*gamma_in\\n\\t\\tgb_out = beta_out*gamma_out\\n\\t\\t(det_x,det_y,det_z) = self.getDetXYZ(self.trMtrx)\\n\\t\\treturn ((gb_out/gb_in)*det_x,(gb_out/gb_in)*det_y,(beta_in/beta_out)*det_z)\",\n \"def point_form(boxes):\\n return torch.cat((boxes[:, :2] - boxes[:, 2:] / 2, boxes[:, :2] + boxes[:, 2:] / 2), 1)\",\n \"def point_form(boxes):\\n return torch.cat((boxes[:, :2] - boxes[:, 2:] / 2, boxes[:, :2] + boxes[:, 2:] / 2), 1)\",\n \"def world_to_camera_normals(inverted_camera_quaternation, world_normals):\\n exr_x, exr_y, exr_z = world_normals[0], world_normals[1], world_normals[2]\\n camera_normal = np.empty([exr_x.shape[0], exr_x.shape[1], 3], dtype=np.float32)\\n for i in range(exr_x.shape[0]):\\n for j in range(exr_x.shape[1]):\\n pixel_camera_normal = _multiply_quaternion_vec3(inverted_camera_quaternation,\\n [exr_x[i][j], exr_y[i][j], exr_z[i][j]])\\n camera_normal[i][j][0] = pixel_camera_normal[0]\\n camera_normal[i][j][1] = pixel_camera_normal[1]\\n camera_normal[i][j][2] = pixel_camera_normal[2]\\n\\n camera_normal = camera_normal.transpose(2, 0, 1)\\n return camera_normal\",\n \"def _fit_plane_to_point_cloud(\\n points_xyz: NDArrayFloat,\\n) -> Tuple[float, float, float, float]:\\n center_xyz: NDArrayFloat = np.mean(points_xyz, axis=0)\\n out: Tuple[NDArrayFloat, NDArrayFloat, NDArrayFloat] = np.linalg.svd(\\n points_xyz - center_xyz\\n )\\n vh = out[2]\\n\\n # Get the unitary normal vector\\n a, b, c = float(vh[2, 0]), float(vh[2, 1]), float(vh[2, 2])\\n d: float = -np.dot([a, b, c], center_xyz)\\n return (a, b, c, d)\",\n \"def project_vectors_ab(a, b):\\n # print('dot = ', np.dot(a,b))\\n # print('norm = ', np.linalg.norm(b))\\n return np.dot(a, b) / np.linalg.norm(b)\",\n \"def get_normal(self):\\n c, s = np.cos(self.eangles), np.sin(self.eangles)\\n r = np.array([[c, -s], [s, c]])\\n u = np.array([1, 0])\\n return np.dot(r, u)\",\n \"def normalise(self):\\n for at in self.atoms:\\n if at.x < 0. :\\n at.x = self.coordx + at.x\\n if at.y < 0. :\\n at.y = self.coordy + at.y\\n if at.z < 0. :\\n at.z = self.coordz + at.z\",\n \"def miller(points):\\r\\n\\r\\n N = np.cross(points[1] - points[0], points[2] - points[0])\\r\\n O = np.array([0, 0, 0])\\r\\n P = points[0] # point of plane\\r\\n Ccs = map(np.array, [[1.0, 0, 0], [0, 1.0, 0], [0, 0, 1.0]])\\r\\n segments = ([np.dot(P - O, N) / np.dot(ort, N) if np.dot(ort, N) != 0 else\\r\\n np.nan for ort in Ccs])\\r\\n if any(x == 0 for x in segments): # Plane goes through origin.\\r\\n vertices = [ # top:\\r\\n np.array([1.0, 1.0, 1.0]),\\r\\n np.array([0.0, 0.0, 1.0]),\\r\\n np.array([1.0, 0.0, 1.0]),\\r\\n np.array([0.0, 1.0, 1.0]),\\r\\n # bottom, except 0,0,0:\\r\\n np.array([1.0, 0.0, 0.0]),\\r\\n np.array([0.0, 1.0, 0.0]),\\r\\n np.array([1.0, 1.0, 1.0]),\\r\\n ]\\r\\n for vertex in vertices:\\r\\n if np.dot(vertex - O, N) != 0: # vertex not in plane\\r\\n new_origin = vertex\\r\\n break\\r\\n # obtain new axes with center in new origin\\r\\n X = np.array([1 - new_origin[0], new_origin[1], new_origin[2]])\\r\\n Y = np.array([new_origin[0], 1 - new_origin[1], new_origin[2]])\\r\\n Z = np.array([new_origin[0], new_origin[1], 1 - new_origin[2]])\\r\\n new_Ccs = [X - new_origin, Y - new_origin, Z - new_origin]\\r\\n segments = ([np.dot(P - new_origin, N) / np.dot(ort, N) if\\r\\n np.dot(ort, N) != 0 else np.nan for ort in new_Ccs])\\r\\n # fix signs of indices: 0 -> 1, 1 -> -1 (\\r\\n segments = (1 - 2 * new_origin) * segments\\r\\n\\r\\n return sub_miller(segments)\",\n \"def parse_normals(lines):\\n print \\\" * Parsing normals\\\"\\n return _parse_vn(lines, \\\"vn %.6f %.6f %.6f\\\")\",\n \"def vector(self) -> np.ndarray:\\n link_vectors = [link.vector for link in self.links]\\n v = np.array(link_vectors).ravel()\\n return v\",\n \"def normalize(self):\\r\\n\\r\\n nlen = 1.0/math.sqrt(self*self)\\r\\n return vec4(self.x*nlen, self.y*nlen, self.z*nlen, self.w*nlen)\",\n \"def xyz(self) -> np.ndarray:\\n return self._vector[0:3]\",\n \"def planeIndex(plane, center = False):\\n return (planeBase(center = center) * np.array(plane)).sum()\",\n \"def normal(self) -> Vector:\\n return normalize(cross(self.d1, self.d2))\",\n \"def normalVect(self, n=2):\\n L = len(self.vertices)\\n normals = []\\n while len(normals) < n:\\n j = randrange(L)\\n v0 = vector(self.vertices[j].coords())\\n v1 = vector(self.vertices[int(j + L / 3) % L].coords())\\n v2 = vector(self.vertices[int(j + 2 * L / 3) % L].coords())\\n try:\\n normals.append(((v1 - v0) * (v2 - v0)).normalize())\\n except ValueError:\\n pass\\n return (1 / len(normals)) * sum(normals, vector(0, 0, 0))\",\n \"def normal(self) -> Vector:\\n return self._normal\",\n \"def _generate_uniform_planes(self):\\n return np.random.randn(self.m, self.dim)\",\n \"def to_raw(self):\\n return [self.poses[i].to_absolute_xyz_rxryrz() + self.wrenches[i].parameters() for i in range(len(self.poses))]\",\n \"def cartesian(self) -> Tuple[np.number, np.number, np.number, np.number]:\\n if self.dimension > 3:\\n raise ValueError(\\\"The plane dimension must be <= 3.\\\")\\n\\n # The normal must be 3D to extract the coefficients.\\n a, b, c = self.normal.set_dimension(3)\\n\\n d = -self.normal.dot(self.point)\\n\\n return a, b, c, d\",\n \"def Normal(self):\\n return Vector(self.normal)\",\n \"def normalize(self):\\n return Vector(self.args + []) / self.magnitude()\",\n \"def magni(vector):\\n return(np.linalg.norm(vector))\",\n \"def get_vectors(nodes, mode=\\\"xform\\\"):\\n for each in nodes:\\n position = (0, 0, 0)\\n\\n if mode == \\\"xform\\\":\\n position = cmds.xform(\\n each,\\n query=True,\\n translation=True,\\n worldSpace=True,\\n )\\n\\n elif mode == \\\"pivot\\\":\\n position = cmds.xform(\\n each,\\n query=True,\\n translation=True,\\n rotatePivot=True,\\n worldSpace=True,\\n )\\n\\n # when using xform on component like faces or edge, the returned value\\n # will be a list of each vertices position, so we need to average that\\n if len(position) > 3:\\n vectors = [\\n MVector(position[i : i + 3])\\n for i in range(0, len(position), 3)\\n ]\\n result = MVector()\\n for vector in vectors:\\n result += vector\\n position = result / len(vectors)\\n\\n yield MVector(position)\",\n \"def write_LG_normal(self, start=0, end=801):\\n\\n # get all the CoM info from postgres\\n MW_data = self.read_com_db('MW')\\n M31_data = self.read_com_db('M31')\\n M33_data = self.read_com_db('M33')\\n \\n # pull out just the 3 columns giving position\\n MW_coms = np.array([MW_data[xi] for xi in ('x','y','z')])\\n M31_coms = np.array([M31_data[xi] for xi in ('x','y','z')])\\n M33_coms = np.array([M33_data[xi] for xi in ('x','y','z')])\\n\\n # define 2 vectors that lie in the plane\\n M31_MW = MW_coms - M31_coms\\n M31_M33 = M33_coms - M31_coms\\n\\n # the normal we want comes from the vector cross product\\n normals = np.cross(M31_MW, M31_M33, axis=0)\\n normals /= norm(normals, axis=0)\\n\\n output = np.concatenate((MW_data['t'][:,np.newaxis], normals.T), axis=1)\\n print(output.shape)\\n \\n # compose the filename for output\\n fileout = './normals.txt'\\n\\n # write the data to file\\n # we do this because we don't want to have to repeat this process \\n # this code should only have to be called once\\n np.savetxt(fileout, output, fmt = \\\"%11.3f\\\"*4, comments='#',\\n header=\\\"{:>10s}{:>11s}{:>11s}{:>11s}\\\"\\\\\\n .format('t', 'x_hat', 'y_hat', 'z_hat'))\",\n \"def vincdecnorm(arr):\\n tmp = convert(arr, GEOCENTRIC_CARTESIAN, GEOCENTRIC_SPHERICAL)\\n return -tmp[..., 0], tmp[..., 1], tmp[..., 2]\",\n \"def cxvec(self):\\n return np.array([self.cx, self.cy])\",\n \"def get_perpendicular(n: np.ndarray) -> np.ndarray:\\n # find smallest component\\n i = np.argmin(n)\\n\\n # get the other two indices\\n a = (i + 1) % 3\\n b = (i + 2) % 3\\n\\n result = np.zeros(3)\\n result[i] = 0.0\\n result[a] = n[b]\\n result[b] = -n[a]\\n return result\",\n \"def _vehicle_to_world(cords, vehicle):\\n\\n bb_transform = carla.Transform(vehicle.bounding_box.location)\\n bb_vehicle_matrix = ClientSideBoundingBoxes.get_matrix(bb_transform)\\n vehicle_world_matrix = ClientSideBoundingBoxes.get_matrix(vehicle.get_transform())\\n bb_world_matrix = np.dot(vehicle_world_matrix, bb_vehicle_matrix)\\n world_cords = np.dot(bb_world_matrix, np.transpose(cords))\\n return world_cords\",\n \"def vector(self) -> Vector:\\n return self._normal * self._distance_from_origin\",\n \"def proj_to_plane(norm, d, pts):\\n a = norm[0]\\n b = norm[1]\\n c = norm[2]\\n\\n p = []\\n\\n for i in range(len(pts)):\\n x_p = pts[i][0]\\n y_p = pts[i][1]\\n z_p = pts[i][2]\\n\\n if a != 0:\\n x_0 = (b * b + c * c) * x_p - a * b * y_p - a * c * z_p - a * d\\n y_0 = (b * 1.0 / a) * (x_0 - x_p) + y_p\\n z_0 = (c * 1.0 / a) * (x_0 - x_p) + z_p\\n\\n elif b != 0:\\n x_0 = x_p \\n y_0 = c * c * y_p - b * (d + c)\\n z_0 = (c * 1.0 / b) *(y_0 - y_p) + z_p\\n\\n else:\\n x_0 = x_p\\n y_0 = y_p\\n z_0 = - d * 1.0 / c\\n\\n p.append([x_0, y_0, z_0])\\n \\n return p\",\n \"def proj_to_plane(norm, d, pts):\\n a = norm[0]\\n b = norm[1]\\n c = norm[2]\\n\\n p = []\\n\\n for i in range(len(pts)):\\n x_p = pts[i][0]\\n y_p = pts[i][1]\\n z_p = pts[i][2]\\n\\n if a != 0:\\n x_0 = (b * b + c * c) * x_p - a * b * y_p - a * c * z_p - a * d\\n y_0 = (b * 1.0 / a) * (x_0 - x_p) + y_p\\n z_0 = (c * 1.0 / a) * (x_0 - x_p) + z_p\\n\\n elif b != 0:\\n x_0 = x_p \\n y_0 = c * c * y_p - b * (d + c)\\n z_0 = (c * 1.0 / b) *(y_0 - y_p) + z_p\\n\\n else:\\n x_0 = x_p\\n y_0 = y_p\\n z_0 = - d * 1.0 / c\\n\\n p.append([x_0, y_0, z_0])\\n \\n return p\",\n \"def unit_vectors(x):\\n xnew = x.copy()\\n for v in range(x.shape[-1]):\\n xnew[:, v] = x[:, v] / np.linalg.norm(x[:, v])\\n return xnew\",\n \"def _xyz_matrix():\\n fx = 583.0\\n fy = 583.0\\n cx = 321\\n cy = 249\\n a = -0.0028300396\\n b = 3.1006268\\n mat = np.array([[1/fx, 0, 0, -cx/fx],\\n [0, -1/fy, 0, cy/fy],\\n [0, 0, 0, -1],\\n [0, 0, a, b]])\\n return mat\",\n \"def project_point_plane(point, plane):\\n base, normal = plane\\n normal = normalize_vector(normal)\\n vector = subtract_vectors(point, base)\\n snormal = scale_vector(normal, dot_vectors(vector, normal))\\n return subtract_vectors(point, snormal)\",\n \"def normal_vector_3p(a: Vector, b: Vector, c: Vector) -> Vector:\\n return (b - a).cross(c - a).normalize()\",\n \"def normalise( vectors ):\\n vectors = asarray( vectors, _aformat(vectors))\\n vectors = reshape( vectors, (-1,3)) # Numpy 23.7 and 64-bit machines fail here, upgrade to 23.8\\n mags = reshape( magnitude( vectors ), (-1, 1))\\n mags = where( mags, mags, 1.0)\\n return divide_safe( vectors, mags)\",\n \"def getNormalizedVector(self):\\n return self.scalarMultiplication(self.norm() ** -1.0)\",\n \"def normalize_vectors(motion_vectors):\\n if np.shape(motion_vectors)[0] == 0:\\n return motion_vectors\\n else:\\n motion_vectors[:, 7] = motion_vectors[:, 7] / motion_vectors[:, 0] # motion_x\\n motion_vectors[:, 8] = motion_vectors[:, 8] / motion_vectors[:, 0] # motion_y\\n motion_vectors[:, 0] = -1 * np.ones_like(motion_vectors[:, 0])\\n return motion_vectors\",\n \"def cmesh(self):\\n return numpy.meshgrid(*self.centers, indexing='ij')\",\n \"def xyz2plane(x,y,z, new_x=[], plane=[], origin=None):\\n # preliminary stuff\\n if origin != None: x = x - origin\\n a,b,c,d = plane\\n bottom = np.sqrt(a*a + b*b + c*c) # normalize\\n a,b,c,d = a/bottom, b/bottom, c/bottom, d/bottom\\n px, py, pz = new_x\\n bot = np.sqrt(px*px + py*py + pz*pz) #normalize\\n px, py, pz = px/bot, py/bot, pz/bot\\n p0 = [px,py,pz]\\n # do rotation\\n z_hat = [a,b,c]\\n y_hat = cross(z_hat, p0)\\n x_hat = cross(y_hat, z_hat)\\n if type(x)==type(arr) or type(x)==type([]):\\n xp, yp, zp = [], [], []\\n for i in range(len(x)):\\n xp.append(dot([x[i],y[i],z[i]], x_hat))\\n yp.append(dot([x[i],y[i],z[i]], y_hat))\\n zp.append(dot([x[i],y[i],z[i]], z_hat))\\n else:\\n xp = dot([x,y,z], x_hat)\\n yp = dot([x,y,z], y_hat)\\n zp = dot([x,y,z], z_hat)\\n return xp, yp, zp\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65218204","0.6503691","0.645618","0.640167","0.6362043","0.633903","0.6333386","0.62251955","0.61807","0.5980656","0.5965315","0.58766127","0.5865005","0.5738643","0.5692937","0.5692491","0.5678418","0.5664199","0.5654711","0.5653635","0.5626195","0.5603792","0.56004083","0.55972916","0.5576237","0.557578","0.5575689","0.5569174","0.5565067","0.5554855","0.55452615","0.5543654","0.5541321","0.55243504","0.54978675","0.54927","0.5487237","0.5482388","0.54647857","0.54364085","0.5430816","0.5428809","0.5426365","0.54191726","0.54181844","0.54102606","0.5399724","0.539954","0.53950816","0.5394196","0.539168","0.5386761","0.5374055","0.5373332","0.53619486","0.53525215","0.53517246","0.53505224","0.53494364","0.5345777","0.53441447","0.5337761","0.5337761","0.53366613","0.5333956","0.5332163","0.53274107","0.53262717","0.5320062","0.53166586","0.5301273","0.52975816","0.5293145","0.52875245","0.52871597","0.5286625","0.5265432","0.52644575","0.5262587","0.52565277","0.52516687","0.5249647","0.52492404","0.5246916","0.5245594","0.52381897","0.5231243","0.52287596","0.52152026","0.5212409","0.5201938","0.5201938","0.5200751","0.5196699","0.5195699","0.5191627","0.5188453","0.51880926","0.5177433","0.5175939","0.5173108"],"string":"[\n \"0.65218204\",\n \"0.6503691\",\n \"0.645618\",\n \"0.640167\",\n \"0.6362043\",\n \"0.633903\",\n \"0.6333386\",\n \"0.62251955\",\n \"0.61807\",\n \"0.5980656\",\n \"0.5965315\",\n \"0.58766127\",\n \"0.5865005\",\n \"0.5738643\",\n \"0.5692937\",\n \"0.5692491\",\n \"0.5678418\",\n \"0.5664199\",\n \"0.5654711\",\n \"0.5653635\",\n \"0.5626195\",\n \"0.5603792\",\n \"0.56004083\",\n \"0.55972916\",\n \"0.5576237\",\n \"0.557578\",\n \"0.5575689\",\n \"0.5569174\",\n \"0.5565067\",\n \"0.5554855\",\n \"0.55452615\",\n \"0.5543654\",\n \"0.5541321\",\n \"0.55243504\",\n \"0.54978675\",\n \"0.54927\",\n \"0.5487237\",\n \"0.5482388\",\n \"0.54647857\",\n \"0.54364085\",\n \"0.5430816\",\n \"0.5428809\",\n \"0.5426365\",\n \"0.54191726\",\n \"0.54181844\",\n \"0.54102606\",\n \"0.5399724\",\n \"0.539954\",\n \"0.53950816\",\n \"0.5394196\",\n \"0.539168\",\n \"0.5386761\",\n \"0.5374055\",\n \"0.5373332\",\n \"0.53619486\",\n \"0.53525215\",\n \"0.53517246\",\n \"0.53505224\",\n \"0.53494364\",\n \"0.5345777\",\n \"0.53441447\",\n \"0.5337761\",\n \"0.5337761\",\n \"0.53366613\",\n \"0.5333956\",\n \"0.5332163\",\n \"0.53274107\",\n \"0.53262717\",\n \"0.5320062\",\n \"0.53166586\",\n \"0.5301273\",\n \"0.52975816\",\n \"0.5293145\",\n \"0.52875245\",\n \"0.52871597\",\n \"0.5286625\",\n \"0.5265432\",\n \"0.52644575\",\n \"0.5262587\",\n \"0.52565277\",\n \"0.52516687\",\n \"0.5249647\",\n \"0.52492404\",\n \"0.5246916\",\n \"0.5245594\",\n \"0.52381897\",\n \"0.5231243\",\n \"0.52287596\",\n \"0.52152026\",\n \"0.5212409\",\n \"0.5201938\",\n \"0.5201938\",\n \"0.5200751\",\n \"0.5196699\",\n \"0.5195699\",\n \"0.5191627\",\n \"0.5188453\",\n \"0.51880926\",\n \"0.5177433\",\n \"0.5175939\",\n \"0.5173108\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94481,"cells":{"query":{"kind":"string","value":"Converts noncubic crystal indices to cartesiancoordinate vectors whilst preserving vector length."},"document":{"kind":"string","value":"def mbvector(A, c=sqrt(8 / 3)):\n la = len(A)\n sa = A.size\n if la == sa:\n B = np.array([0.0, 0.0, 0.0])\n a1 = A[0] * np.array([1.0, 0.0])\n a2 = A[1] * np.array([-0.5, 0.5 * sqrt(3)])\n a3 = A[2] * np.array([-0.5, -0.5 * sqrt(3)])\n B[0] = a1[0] + a2[0] + a3[0]\n B[1] = a1[1] + a2[1] + a3[1]\n B[2] = c * A[3]\n else:\n sa = A.shape\n B = np.zeros(shape=(sa[0], 3))\n for i in range(sa[0]):\n B[i, 0] = a1[0] + a2[0] + a3[0]\n B[i, 1] = a1[1] + a2[1] + a3[1]\n B[i, 2] = c * A[i, 3]\n return B"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def cxvec(self):\n return np.array([self.cx, self.cy])","def get_cartesian_coords(self):\n r = 1\n dec = self.dec + 90\n x = r * math.sin(np.deg2rad(dec)) * math.cos(np.deg2rad(self.ra))\n y = r * math.sin(np.deg2rad(dec)) * math.sin(np.deg2rad(self.ra))\n z = r * math.cos(np.deg2rad(dec))\n\n return [x, y, z]","def _position_cartesian2cylindrical(pos):\n\n \n #save cartesian position of each particle\n x=pos[:,0]\n y=pos[:,1]\n z=pos[:,2]\n\n rho= np.sqrt(x**2+y**2)\n theta=np.arctan2(y,x)\n\n\n return np.dstack((rho,theta,z))[0]","def Cvec(self):\n return vec(self.xc, self.yc)","def cylindrical2cartesian(cylinder):\n cart = np.zeros(cylinder.shape)\n cart[:, 0] = cylinder[:, 0] * np.cos(cylinder[:, 1])\n cart[:, 1] = cylinder[:, 0] * np.sin(cylinder[:, 1])\n cart[:, 2] = cylinder[:, 2]\n return cart","def _position_cylindrical2cartesian(pos):\n \n rho=pos[:,0]\n theta=pos[:,1]\n z=pos[:,2]\n\n x=rho*np.cos(theta)\n y=rho*np.sin(theta)\n z=z\n\n return np.dstack((x,y,z))[0]","def cartesian2cylindrical(coords):\n cyl = np.zeros(coords.shape)\n cyl[:, 0] = np.sqrt(coords[:, 0] ** 2 + coords[:, 1] ** 2)\n cyl[:, 1] = np.arctan2(coords[:, 1], coords[:, 0])\n cyl[:, 2] = coords[:, 2]\n return cyl","def cart_coords2d(self):\r\n\r\n mgx, mgy = self.meshup2d()\r\n coords = np.column_stack((mgx.flatten(), mgy.flatten()))\r\n\r\n return coords","def cart_coords(self):\r\n\r\n mgx, mgy, mgz = self.meshup()\r\n coords = np.column_stack((np.ravel(mgx, order='C'), np.ravel(mgy, order='C'), np.ravel(mgz, order='C')))\r\n\r\n return coords","def cartesian_to_cylindrical(grid, vec=None):\n\n grid = np.atleast_2d(grid)\n\n if vec is None:\n return np.hstack([\n mkvc(np.sqrt(grid[:, 0]**2 + grid[:, 1]**2), 2),\n mkvc(np.arctan2(grid[:, 1], grid[:, 0]), 2),\n mkvc(grid[:, 2], 2)\n ])\n\n if len(vec.shape) == 1 or vec.shape[1] == 1:\n vec = vec.reshape(grid.shape, order='F')\n\n theta = np.arctan2(grid[:, 1], grid[:, 0])\n\n return np.hstack([\n mkvc(np.cos(theta)*vec[:, 0] + np.sin(theta)*vec[:, 1], 2),\n mkvc(-np.sin(theta)*vec[:, 0] + np.cos(theta)*vec[:, 1], 2),\n mkvc(vec[:, 2], 2)\n ])","def cylindrical_to_cartesian(grid, vec=None):\n grid = np.atleast_2d(grid)\n\n if vec is None:\n return np.hstack([\n mkvc(grid[:, 0]*np.cos(grid[:, 1]), 2),\n mkvc(grid[:, 0]*np.sin(grid[:, 1]), 2),\n mkvc(grid[:, 2], 2)\n ])\n\n if len(vec.shape) == 1 or vec.shape[1] == 1:\n vec = vec.reshape(grid.shape, order='F')\n\n x = vec[:, 0] * np.cos(grid[:, 1]) - vec[:, 1] * np.sin(grid[:, 1])\n y = vec[:, 0] * np.sin(grid[:, 1]) + vec[:, 1] * np.cos(grid[:, 1])\n\n newvec = [x, y]\n if grid.shape[1] == 3:\n z = vec[:, 2]\n newvec += [z]\n\n return np.vstack(newvec).T","def coord_vecs(self):\n return [np.linspace(x0, x1, nx) for x0, x1, nx in zip(self.mins, self.maxs, self.shape)]","def spherical2cartesian(v):\n \n x = np.cos(v[0]) * np.cos(v[1]) \n y = np.cos(v[0]) * np.sin(v[1]) \n z = np.sin(v[0]) \n \n return [x,y,z]","def co_vertexes(self):\n theta = self.orientation + np.pi / 2\n shifts = np.array([np.cos(theta), np.sin(theta)]) * self.b\n return self.coords + (shifts[:, None] * [-1, 1]).T","def _position_spherical2cartesian(pos):\n \n r=pos[:,0]\n theta=pos[:,1]\n phi=pos[:,2]\n\n if any(theta>np.pi) or any(theta<0): #sanity check. not necessary for phi.\n raise ValueError, \"Theta beyond [0,pi]. Exiting.\"\n\n\n x=r*np.sin(theta)*np.cos(phi)\n y=r*np.sin(theta)*np.sin(phi)\n z=r*np.cos(theta)\n\n return np.dstack((x,y,z))[0]","def _spherical_to_cartesian(ra, dec):\n rar = np.radians(ra)\n decr = np.radians(dec)\n\n x = np.cos(rar) * np.cos(decr)\n y = np.sin(rar) * np.cos(decr)\n z = np.sin(decr)\n \n return x, y, z","def vertexes(self):\n theta = self.orientation\n shifts = np.array([np.cos(theta), np.sin(theta)]) * self.a\n return self.coords + (shifts[:, None] * [-1, 1]).T","def unit_vectors(self):\n # return {'comp1': CartesianRepresentation(...),\n # 'comp2': CartesianRepresentation(...),\n # 'comp3': CartesianRepresentation(...)}\n raise Exception(\"Not yet implemented\")","def cartesian_coordinates(self, *axes):","def _velocity_cylindrical2cartesian(pos,vel):\n \n \n #save cartesian position of each particle\n theta=pos[:,1]\n\n #save cyindrical velocities\n vr=vel[:,0]\n vtheta=vel[:,1]\n vz=vel[:,2]\n\n #compute cartesian velocities\n vx = vr*np.cos(theta) - vtheta*np.sin(theta)\n vy = vr*np.sin(theta) + vtheta*np.cos(theta)\n vz = vz\n\n return np.dstack((vx,vy,vz))[0]","def cartesian(self):\n raise NotImplementedError(\"This is not implemented.\")\n return CartCoord()","def cartesian(position):\n return [position[0] * cos(position[1]), position[0] * sin(position[1])]","def cartesian_2_cylindrical(grid, vec=None):\n return cartesian_to_cylindrical(grid, vec)","def _indices_to_coords(c,r):\n\n column = _index_to_column(c)\n row = r + 1\n\n return {'c': column, 'r': row, 'coord': f'{column}{row}'}","def vec(self):\r\n\r\n xv = np.arange(self.dx / 2, self.lx, self.dx)\r\n yv = np.arange(-self.ly / 2 + self.dy / 2, self.ly / 2, self.dy)\r\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\r\n\r\n if self.ox != 0:\r\n xv = np.arange(self.ox, self.lx + self.ox, self.dx)\r\n yv = np.arange(self.oy, self.ly + self.oy, self.dy)\r\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\r\n\r\n return xv, yv, zv","def hexgrid(self):\n n = self.n * 2\n vectors = []\n for u in range(-n, n+1):\n us = [u] * (2*n+1)\n if u < 0:\n vectors.extend(zip(us, range(-n-u, n+1), range(-n, n+u+1)))\n else:\n vectors.extend(zip(us, range(-n, n-u+1), range(-n+u, n+1)))\n return vectors","def _position_spherical2cylindrical(pos):\n \n\n r=pos[:,0]\n theta_spherical=pos[:,1]\n phi_spherical=pos[:,2]\n\n if any(theta_spherical>np.pi) or any(theta_spherical<0): #sanity check. not necessary for phi.\n raise ValueError, \"Theta beyond [0,pi]. Exiting.\"\n\n rho=r*np.sin(theta_spherical)\n theta_cylindrical=phi_spherical\n z=r*np.cos(theta_spherical)\n\n return np.dstack((rho,theta_cylindrical,z))[0]","def cartesian_coordinates(self):\n # extract RA items\n ra_hours, ra_minutes, ra_seconds = RA_RE.match(str(self.ra)).groups()\n # then cast\n ra_hours = int(ra_hours)\n ra_minutes = int(ra_minutes)\n ra_seconds = float(ra_seconds)\n\n # extract DEC items\n dec_sign, dec_degrees, dec_minutes, dec_seconds = DEC_RE.match(str(self.dec)).groups()\n # then cast\n dec_sign = -1 if dec_sign == '-' else 1\n dec_degrees = int(dec_degrees)\n dec_minutes = int(dec_minutes)\n dec_seconds = float(dec_seconds)\n\n # to degrees\n a = (ra_hours*15) + (ra_minutes*0.25) + (ra_seconds*0.004166)\n b = abs(dec_degrees + dec_minutes/60 + dec_seconds/3600) * dec_sign\n\n # to radians\n a = math.radians(a)\n b = math.radians(b)\n\n distance = float(self.distance)\n\n x = (distance * math.cos(b)) * math.cos(a)\n y = (distance * math.cos(b)) * math.sin(a)\n z = distance * math.sin(b)\n\n return x, y, z","def i_coords(self):\n ref_x = np.arange(-self.ref_w / 2, self.ref_w / 2 + 0.002, 0.002)\n\n if self.ref_shape == 'c': # Curved reflector\n dist_coords1 = [(ref_x[i], pos_on_semicircle(ref_x[i], self.R, self.c_xy)) for i in range(self.I)]\n dist_coords2 = [(ref_x[i + 1], pos_on_semicircle(ref_x[i + 1], self.R, self.c_xy)) for i in range(self.I)]\n a_i = [distance(dist_coords1[i], dist_coords2[i]) for i in range(self.I)]\n\n cx_i = [ref_x[i] + (ref_x[i + 1] - ref_x[i]) / 2 for i in range(self.I)]\n cy_i = [pos_on_semicircle(x, self.R, self.c_xy) for x in cx_i]\n i_coords = list(zip(cx_i, cy_i))\n else: # Flat reflector\n a_i = [(ref_x[i + 1] - ref_x[i]) / 2 for i in range(self.I)]\n cx_i = [ref_x[i] + (ref_x[i + 1] - ref_x[i]) / 2 for i in range(self.I)]\n i_coords = [(x, self.h) for x in cx_i]\n d = {'ref_x': ref_x, 'A_i': a_i, 'I_coords': i_coords, 'cx_i': cx_i}\n\n return d","def spherical2cartesian(spherical):\n spherical = np.array(spherical).squeeze()\n distance, azimuth, elevation = spherical\n x = distance * np.sin(azimuth) * np.cos(elevation)\n y = distance * np.sin(azimuth) * np.sin(elevation)\n z = distance * np.cos(azimuth)\n return np.array([x, y, z])","def cartesian2bary(self, x):\n lam = np.zeros((x.shape[0], 3))\n lam[:,:2] = np.einsum('ij,kj->ki', self.Tinv, x - self.xv[2])\n lam[:,2] = 1. - lam[:,0] - lam[:,1]\n return lam","def _velocity_cartesian2cylindrical(pos,vel):\n \n \n \n #save cartesian velocities\n vx=vel[:,0]\n vy=vel[:,1]\n vz=vel[:,2]\n\n #convert to cylindrical coordinates\n pos_cyl=_position_cartesian2cylindrical(pos) #cylindrical coordinates\n theta=pos_cyl[:,1]\n\n #compute cylindrical velocities\n vr=vx*np.cos(theta) + vy*np.sin(theta)\n vtheta=-vx*np.sin(theta) + vy*np.cos(theta)\n vz=vz\n \n\n return np.dstack((vr,vtheta,vz))[0]","def _velocity_spherical2cylindrical(pos,vel):\n \n pos_cart=_position_spherical2cartesian(pos)\n vel_cart=_velocity_spherical2cartesian(pos,vel)\n vel_cyl=_velocity_cartesian2cylindrical(pos_cart,vel_cart)\n\n return vel_cyl","def get_coords(self):\r\n # get the coordinates from V, skipping every 3 since it's a vector\r\n meshpts = self.V.tabulate_dof_coordinates()[::3]\r\n\r\n # create r vector if not already created\r\n try:\r\n self.r\r\n except:\r\n self.r = Function(self.V)\r\n\r\n # set the r vector\r\n self.r.vector()[:] = meshpts.flatten()","def _convert_coords_to_coordinates(self, vect) -> np.ndarray:\n # create empty vector of necessary shape\n # one coordinate for each endpoint of the vector\n pos = np.empty((2 * len(vect), 2), dtype=np.float32)\n\n # create pairs of points\n pos[0::2, 0] = vect[:, 0]\n pos[1::2, 0] = vect[:, 0]\n pos[0::2, 1] = vect[:, 1]\n pos[1::2, 1] = vect[:, 1]\n\n # adjust second of each pair according to x-y projection\n pos[1::2, 0] += vect[:, 2]\n pos[1::2, 1] += vect[:, 3]\n\n return pos","def to_cartes(self):\n if self.__coordsys in (Polar, PhySpherical, MathSpherical):\n self.__coordsys = Cartesian if self.__coordsys == Polar else Cartesian_3\n self.update_coord(vct.rec(self.list_repr()))","def c(self) -> np.ndarray:\n return self._vector[10:12]","def simple_cubic_cell_translation_integers(lattice, cutoff: float):\n n_vectors = lattice.shape[1]\n return [int(np.ceil(cutoff / np.linalg.norm(lattice[:, i])))\n for i in range(0, n_vectors)]","def vector_line(self):\n assert len(self.xcoords) == 2\n diff_x = self.xcoords[1] - self.xcoords[0]\n diff_z = self.zcoords[1] - self.zcoords[0]\n vec = np.hstack((diff_x, diff_z))\n return vec","def n_coords(self):\n trans_x = np.arange(-self.trans_dia / 2, self.trans_dia / 2 + 0.002, 0.002)\n a_n = [(trans_x[n + 1] - trans_x[n]) / 2 for n in range(self.N)]\n cx_n = [trans_x[n] + (trans_x[n + 1] - trans_x[n]) / 2 for n in range(self.N)]\n coords = [(x, 0) for x in cx_n]\n d = {'trans_x': trans_x, 'A_n': a_n, 'N_coords': coords}\n return d","def loc_to_cart(loc):\n return (loc % grid_size, loc % slice_size // grid_size, loc // slice_size)","def _spherical_to_cartesian_fast(ra, dec, threads):\n import numexpr as ne\n\n #nthreads = ne.detect_number_of_cores()\n nthreads = threads\n ne.set_num_threads(nthreads)\n\n pi = math.pi\n rar = ne.evaluate('ra*pi/180.0')\n decr = ne.evaluate('dec*pi/180.0')\n\n hold1=ne.evaluate('cos(decr)') \n\n x = ne.evaluate('cos(rar) * hold1')\n y = ne.evaluate('sin(rar) * hold1')\n z = ne.evaluate('sin(decr)')\n \n return x, y, z","def getCartesian(self, phi, theta, radius):\n point_x = round(sin(theta) * cos(phi) * radius,4)\n point_y = round(sin(theta) * sin(phi) * radius,4)\n point_z = round(cos(theta) * radius,4)\n return [point_x, point_y, point_z]","def spherical2cartesian(sphere):\n cart = np.zeros(sphere.shape, dtype=np.float64)\n sine_phi = np.sin(sphere[:, 2])\n\n cart[:, 0] = sphere[:, 0] * np.cos(sphere[:, 1]) * sine_phi\n cart[:, 1] = sphere[:, 0] * np.sin(sphere[:, 1]) * sine_phi\n cart[:, 2] = sphere[:, 0] * np.cos(sphere[:, 2])\n return cart","def cartesian_to_spherical(self, v):\n x = Vector.x(v)\n y = Vector.y(v)\n z = Vector.z(v)\n r = Vector.length(v)\n phi = atan2(y, x)\n theta = acos(z / r)\n \n return [r, phi, theta]","def to_cartesian(dimensions, angles):\n return Operator(transform=np.transpose(np.array(_basis_vectors(dimensions, angles))))","def to_cartesian(self):\n w = 1.73205 # sqrt(3)\n h = 2\n dx = 0.5 * w if self.y % 2 == 1 else 0\n x = 0.5 * w + self.x * w + dx\n y = 0.5 * h + 0.75 * self.y * h\n return (x, y)","def spherical_to_cartesian(self, r, phi, theta):\n x = r*cos(phi)*sin(theta)\n y = r*sin(phi)*sin(theta)\n z = r*cos(theta)\n \n return Vector(float(x), float(y), float(z))","def _velocity_spherical2cartesian(pos,vel):\n \n #save cartesian position of each particle\n r=pos[:,0]\n theta=pos[:,1]\n phi=pos[:,2]\n\n\n #save cyindrical velocities\n vr=vel[:,0]\n vtheta=vel[:,1]\n vphi=vel[:,2]\n\n\n #compute cartesian velocities\n vx = vr*np.sin(theta)*np.cos(phi) + vtheta*np.cos(theta)*np.cos(phi) - vphi*np.sin(phi)\n vy = vr*np.sin(theta)*np.sin(phi) + vtheta*np.cos(theta)*np.sin(phi) + vphi*np.cos(phi)\n vz = vr*np.cos(theta) - vtheta*np.sin(theta)\n\n return np.dstack((vx,vy,vz))[0]","def compute_normalvect(self):\n normvect = np.zeros((len(self.tri_pnts),3,3))\n zvec = np.array([0, 0, 1])\n for itri, tri in enumerate(self.tri_pnts):\n #import pdb; pdb.set_trace()\n tri0, tri1, tri2 = tri\n x1,y1 = self.points[tri1]-self.points[tri0]\n v1 = np.array([x1,y1,0])\n x2,y2 = self.points[tri2]-self.points[tri1]\n v2 = np.array([x2,y2,0])\n x3,y3 = self.points[tri0]-self.points[tri2]\n v3 = np.array([x3,y3,0])\n v1 = v1/np.linalg.norm(v1)\n v2 = v2/np.linalg.norm(v2)\n v3 = v3/np.linalg.norm(v3)\n #import pdb; pdb.set_trace()\n normvect[itri,:,:] = np.cross(v1,zvec), np.cross(v2,zvec), np.cross(v3,zvec)\n #import pdb; pdb.set_trace()\n return normvect","def to_cartesian(self): # TODO\n pass","def _calcOrderedCellVertexIDs(self):\n ids = numerix.zeros((8, self.nx, self.ny, self.nz), 'l')\n indices = numerix.indices((self.nx, self.ny, self.nz))\n ids[1] = indices[0] + (indices[1] + (indices[2] + 1) * (self.ny + 1) + 1) * (self.nx + 1)\n ids[0] = ids[1] + 1\n ids[3] = indices[0] + (indices[1] + (indices[2] + 1) * (self.ny + 1)) * (self.nx + 1)\n ids[2] = ids[3] + 1\n ids[5] = indices[0] + (indices[1] + indices[2] * (self.ny + 1) + 1) * (self.nx + 1)\n ids[4] = ids[5] + 1\n ids[7] = indices[0] + (indices[1] + indices[2] * (self.ny + 1)) * (self.nx + 1)\n ids[6] = ids[7] + 1\n\n return numerix.reshape(ids.swapaxes(1, 3), (8, self.numberOfCells))","def vector(molec, dihed, nonH, energy):\n #Torison\n if dihed:\n pass\n #XYZ\n else:\n coords = ()\n if nonH:\n for atom in molec.atoms:\n coords += atom.coords\n else:\n for atom in molec.atoms:\n if atom.atomicnum > 1:\n coords += atom.coords\n #Energy\n if energy:\n coords += (molec.energy/10.0,)\n return coords","def to_indices(self, world_coords):\n (x, y, z) = world_coords\n (cx, cy, cz) = self.center\n\n px = x - cx\n py = y - cy\n pz = z - cz\n\n # project u and v\n # TODO: Can this be done with some built-in Numpy operation?\n (ux, uy, uz) = self.u_dir\n (vx, vy, vz) = self.v_dir\n u = px * ux + py * uy + pz * uz\n v = px * vx + py * vy + pz * vz\n\n # rescale to pixel coordinates. u is up, v is down\n (H, W, _) = self.shape\n i = rescale(-1, 1, H - 1, 0, v)\n j = rescale(-1, 1, 0, W -1, u)\n\n return (i, j)","def spherical_to_cartesian(grid, vec=None):\n grid = np.atleast_2d(grid)\n\n if vec is None:\n return np.hstack([\n mkvc(grid[:, 0] * np.sin(grid[:, 2]) * np.cos(grid[:, 1]), 2),\n mkvc(grid[:, 0] * np.sin(grid[:, 2]) * np.sin(grid[:, 1]), 2),\n mkvc(grid[:, 0] * np.cos(grid[:, 2]), 2)\n ])\n\n if len(vec.shape) == 1 or vec.shape[1] == 1:\n vec = vec.reshape(grid.shape, order='F')\n\n x = (\n vec[:, 0] * np.sin(grid[:, 2]) * np.cos(grid[:, 1]) +\n vec[:, 2] * np.cos(grid[:, 2]) * np.cos(grid[:, 1]) -\n vec[:, 1] * np.sin(grid[:, 1])\n )\n y = (\n vec[:, 0] * np.sin(grid[:, 2]) * np.sin(grid[:, 1]) +\n vec[:, 2] * np.cos(grid[:, 2]) * np.sin(grid[:, 1]) -\n vec[:, 1] * np.cos(grid[:, 1])\n )\n z = (\n vec[:, 0] * np.cos(grid[:, 2]) -\n vec[:, 2] * np.sin(grid[:, 2])\n )\n\n newvec = [x, y, z]\n\n return np.vstack(newvec).T","def convert_cylinder_to_cartesian(dictionary):\n\n # Define num of points in x and y direction\n dictionary['nx'] = dictionary['nt'] # Angular number of points\n dictionary['ny'] = dictionary['nr'] # Radial number of points\n\n # Assemble gradient components into tensor\n if all(cyl_grad_u_key in dictionary for cyl_grad_u_key in CYL_GRAD_U_KEYS) and 'grad_u_cyl' not in dictionary:\n dictionary['grad_u_cyl'] = assemble_2nd_order_tensor(dictionary, CYL_GRAD_U_KEYS)\n elif 'grad_u_cyl' in dictionary:\n pass\n else:\n print('WARNING No gradient data available for conversion cylinder to cartesian coordinates.')\n\n # Loop all keys in dictionary\n for cyl_key in tuple(dictionary):\n if isinstance(dictionary[cyl_key], (np.ndarray, int, float, str)):\n if cyl_key in CYL_VEL_KEYS:\n velocity_cylinder_to_cartesian(dictionary, cyl_key, verbose=False)\n elif cyl_key == 'grad_u_cyl':\n gradient_cylinder_to_cartesian(dictionary, cyl_key)\n elif cyl_key in CYL_TAU_KEYS:\n tau_components_cylinder_to_cartesian(dictionary, cyl_key, verbose=False) # Requires off-diagonal elements in tau, for now just RENAMING\n elif cyl_key in CYL_ALL_BUDGET_KEYS:\n budget_tau_components_cylinder_to_cartesian(dictionary, cyl_key, verbose=False) # Just RENAMING budgets!\n elif cyl_key in CYL_RMS_KEYS:\n rms_velocity_cylinder_to_cartesian(dictionary, cyl_key, verbose=False) # Just RENAMING rms, requires off-diag tau for conversion\n else:\n pass\n else:\n assert False, 'Unknown variable type in dictionary for key %r with type %r' % (cyl_key, type(dictionary[cyl_key]))\n\n return 1","def cart_coord(contours, centers):\n cart_contours = []\n for i in range(len(contours)):\n contour = contours[i]\n center = centers[i]\n cart_contour = np.zeros((contour.shape[0], contour.shape[1]))\n for j in range(contour.shape[0]):\n cart_contour[j, 0] = contour[j, 1] * math.cos(contour[j, 0]) + center[0]\n cart_contour[j, 1] = contour[j, 1] * math.sin(contour[j, 0]) + center[1]\n cart_contours.append(cart_contour)\n return cart_contours","def transform_coord_to_vector(coords,vector_dim):\r\n\t\r\n\tnew_vector = [0] * vector_dim\r\n\tfor c in coords:\r\n\t\tnew_vector[c[0]] = c[1]\r\n\r\n\treturn new_vector","def get_vertices(self):\n vertices = []\n V = [[-self.base_vectors[:,n], self.base_vectors[:,n]] for n in range(self.base_vectors.shape[1])]\n combs = list(itertools.product(*V))\n for cb in combs:\n cb = np.sum(np.array(cb).T, axis=1, keepdims=True)\n vertices.append(self.base_vertices + cb)\n\n vertices = np.concatenate(vertices,axis=1)\n return vertices","def SphericalToCartesian(Spherical):\n\n # r,theta,phi -> x,y,z\n r = Spherical[:,0]\n st = np.sin(Spherical[:,1])\n sp = np.sin(Spherical[:,2])\n ct = np.cos(Spherical[:,1])\n cp = np.cos(Spherical[:,2])\n x = r*st*cp\n y = r*st*sp\n z = r*ct\n\n if (len(Spherical[0,:])==3):\n Cartesian = np.column_stack((x,y,z))\n return Cartesian\n else:\n # vr,vtheta,vphi -> vx,vy,vz\n vr = Spherical[:,3]\n vt = Spherical[:,4]\n vp = Spherical[:,5]\n vx = vr*st*cp - vt*ct*cp - vp*sp\n vy = vr*st*sp + vt*ct*sp + vp*cp\n vz = vr*ct - vt*st\n Cartesian= np.column_stack((x,y,z,vx,vy,vz))\n return Cartesian","def get_sound_vertices(self):\n\n vals = np.sum(np.abs(self.base_vectors), axis=1, keepdims=True)\n V = [[v,-v] for v in vals]\n combs = list(itertools.product(*V))\n\n vertices = []\n for cb in combs:\n vertices.append(self.base_vertices+np.array(cb))\n vertices = np.concatenate(vertices, axis=1)\n return vertices","def _geodetic_to_cartesian(cls, lat, lon, alt):\n C = Earth.r / np.sqrt(1 - (Earth.e * np.sin(lat)) ** 2)\n S = Earth.r * (1 - Earth.e ** 2) / np.sqrt(1 - (Earth.e * np.sin(lat)) ** 2)\n r_d = (C + alt) * np.cos(lat)\n r_k = (S + alt) * np.sin(lat)\n\n norm = np.sqrt(r_d ** 2 + r_k ** 2)\n return norm * np.array(\n [np.cos(lat) * np.cos(lon), np.cos(lat) * np.sin(lon), np.sin(lat)]\n )","def _CopyCoords(self):\n self.ccoords = numpy.zeros((self.mol.n_atoms, const.NUMDIM))\n for i in range(self.mol.n_atoms):\n for j in range(const.NUMDIM):\n self.ccoords[i][j] = self.mol.atoms[i].coords[j]","def xyz2ic_np(x, Z_indices, torsion_cut=None):\n from deep_boltzmann.models.MM import dist, angle, torsion\n global_ic = (Z_indices.min() < 0)\n if global_ic:\n bond_indices = Z_indices[1:, :2]\n angle_indices = Z_indices[2:, :3]\n torsion_indices = Z_indices[3:, :4]\n else:\n bond_indices = Z_indices[:, :2]\n angle_indices = Z_indices[:, :3]\n torsion_indices = Z_indices[:, :4]\n atom_indices = np.arange(int(3*(np.max(Z_indices)+1))).reshape((-1, 3))\n xbonds = dist(x[:, atom_indices[bond_indices[:, 0]]],\n x[:, atom_indices[bond_indices[:, 1]]])\n xangles = angle(x[:, atom_indices[angle_indices[:, 0]]],\n x[:, atom_indices[angle_indices[:, 1]]],\n x[:, atom_indices[angle_indices[:, 2]]])\n xtorsions = torsion(x[:, atom_indices[torsion_indices[:, 0]]],\n x[:, atom_indices[torsion_indices[:, 1]]],\n x[:, atom_indices[torsion_indices[:, 2]]],\n x[:, atom_indices[torsion_indices[:, 3]]])\n if torsion_cut is not None:\n xtorsions = np.where(xtorsions < torsion_cut, xtorsions+360, xtorsions)\n # Order ic's by atom\n if global_ic:\n iclist = [xbonds[:, 0:2], xangles[:, 0:1]]\n for i in range(Z_indices.shape[0]-3):\n iclist += [xbonds[:, i+2:i+3], xangles[:, i+1:i+2], xtorsions[:, i:i+1]]\n else:\n iclist = []\n for i in range(Z_indices.shape[0]):\n iclist += [xbonds[:, i:i+1], xangles[:, i:i+1], xtorsions[:, i:i+1]]\n ics = np.concatenate(iclist, axis=-1)\n return ics","def vec_x(self):\t\r\n if self.ox != 0:\r\n ov = self.ox\r\n lv = self.self.lx + self.ox\r\n else:\r\n ov = self.dx / 2\r\n lv = self.lx\r\n\r\n xv = \"\"\r\n for num in np.arange(ov, lv, self.dx):\r\n xv += str(num) + \" \"\r\n\r\n return xv","def cylindrical_2_cartesian(grid, vec=None):\n return cylindrical_to_cartesian(grid, vec)","def get_coordinate_lists(self, crs=None):\n x, y = self.vertices.vectors()[:2]\n if crs is not None and (crs != self.crs):\n x, y = _reproject((x,y), self.crs, crs)\n return x, y","def xvec(self):\n return np.array([self.x, self.y])","def GalacticToCartesian(Galactic,SolarPosition): \n \n # l,b,s->x,y,z\n cl = np.cos(Galactic[:,0])\n sl = np.sin(Galactic[:,0])\n cb = np.cos(Galactic[:,1])\n sb = np.sin(Galactic[:,1])\n x = SolarPosition[0]-Galactic[:,2]*cb*cl\n y = Galactic[:,2]*cb*sl\n z = Galactic[:,2]*sb+SolarPosition[1]\n\n if(len(Galactic[0,:])==3):\n Cartesian = np.column_stack((x,y,z))\n else:\n # vlos,mu_lcos(b),mu_b -> vx,vy,vz\n vl = pm2vel*Galactic[:,2]*Galactic[:,4]\n vb = pm2vel*Galactic[:,2]*Galactic[:,5]\n tmp2 = cb*Galactic[:,3]-sb*vb\n vx = cl*tmp2-sl*vl+SolarPosition[2]\n vy = sl*tmp2+cl*vl+SolarPosition[3]\n vz = sb*Galactic[:,3]+cb*vb+SolarPosition[4]\n Cartesian = np.column_stack((x,y,z,-vx,vy,vz))\n \n return Cartesian","def Indexes(self, latitudes, longitudes):\n res = self._transform.TransformPoints(\n np.column_stack((longitudes, latitudes)))\n res = list(zip(*res))\n x, y = np.array(res[0]), np.array(res[1])\n idx_col = self._inv_txf[0] + self._inv_txf[1] * x + self._inv_txf[2] * y\n idx_row = self._inv_txf[3] + self._inv_txf[4] * x + self._inv_txf[5] * y\n return idx_row.astype(int), idx_col.astype(int)","def getpos(self):\n return self.pos.cartesianas()","def cartesian2spherical(v):\n theta = np.arcsin(v[2]) \n phi = np.arctan2(v[1], v[0])\n \n return [theta, phi]","def to_cartesian(r, phi):\n x = r*np.cos(phi)\n y = r*np.sin(phi)\n return x, y","def _calc_coords(self):\n i = num.outer(num.arange(self.size[0]), num.ones(self.size[1]))\n i0 = self.pos[0] + (i * self.space[0])\n i1 = self.pos[0] + (i * self.space[0]) + self.bub[0]\n\n j = num.outer(num.ones(self.size[0]), num.arange(self.size[1]))\n j0 = self.pos[1] + (j * self.space[1])\n j1 = self.pos[1] + (j * self.space[1]) + self.bub[1]\n\n self.coords = num.dstack((i0, i1, j0, j1)).astype('i')","def _pole_to_cart(self,angles,distances):\n cart=[]\n for i in xrange(0,len(angles)-1):\n angle = angles[i]\n distance = distances[i] \n xs, ys = distance*cos(angle), distance*sin(angle)\n cart.append(tuple((xs,ys)))\n return cart","def coordinates(self, bin_indices):\n indices = numpy.asarray(bin_indices).transpose()\n coords = [numpy.interp(i, range(n), c)\n for (i, n, c) in zip(indices, self.shape, self.centers)]\n coords_arr = numpy.array(coords).transpose()\n return numpy.atleast_2d(coords_arr)","def convert_to_cartesian(grid: List[Tuple[float, float]], radius: float = 1.0) -> List[Tuple[float, float, float]]:\n\n # conversion radians -> degrees\n r2d = 180.0 / np.pi\n\n # calculate x/y/z coordinates, assuming r=1\n return [\n (\n radius * np.cos(lat / r2d) * np.cos(lon / r2d),\n radius * np.cos(lat / r2d) * np.sin(lon / r2d),\n radius * np.sin(lat / r2d),\n )\n for lon, lat in grid\n ]","def _pole_to_cart(Set):\n xS=[]\n yS=[]\n for s in Set:\n angle = s[0]\n distance = s[1] \n if distance !=0:\n xs, ys = distance*cos(angle), distance*sin(angle)\n xS.append(xs)\n yS.append(ys)\n return xS,yS","def _pole_to_cart(Set):\n xS=[]\n yS=[]\n for s in Set:\n angle = s[0]\n distance = s[1] \n if distance !=0:\n xs, ys = distance*cos(angle), distance*sin(angle)\n xS.append(xs)\n yS.append(ys)\n return xS,yS","def project_to_cylinder(points):\n r, phi, z = cs.cart2cyl(points[:, 0], points[:, 1], points[:, 2])\n # NOTE: z is unchanged\n # print(np.array_equal(z, points[:, 2]))\n # project onto unit cylinder\n x_cyl = points[:, 0] / r\n y_cyl = points[:, 1] / r\n z_cyl = (z - z.min()) / (z.max() - z.min())\n points_cyl = np.stack((x_cyl, y_cyl, z_cyl), axis=1)\n return points_cyl, r, phi, z","def _flatten_cartesian_coords(cartesian_coords):\n\n shape = cartesian_coords.shape\n if len(shape) > 2:\n cartesian_coords = cartesian_coords.reshape(shape[0] *\n shape[1], 3)\n return cartesian_coords","def _position_cylindrical2spherical(pos):\n\n rho=pos[:,0]\n theta_cylindrical=pos[:,1]\n z=pos[:,2]\n\n r=np.sqrt(rho**2+z**2)\n theta_spherical=np.arctan2(rho,z)\n phi=theta_cylindrical\n\n return np.dstack((r,theta_spherical,phi))[0]","def spherical_to_cartesian(r, lat, lon):\n import math\n\n if np.isscalar(r) and np.isscalar(lat) and np.isscalar(lon):\n x = r * math.cos(lat) * math.cos(lon)\n y = r * math.cos(lat) * math.sin(lon)\n z = r * math.sin(lat)\n else:\n x = r * np.cos(lat) * np.cos(lon)\n y = r * np.cos(lat) * np.sin(lon)\n z = r * np.sin(lat)\n\n return x, y, z","def generateAllRegionVectors():\n\tregionVectors = []\n\tfor i in range(NUM_REGION_VECTORS):\n\t\tregionVectors.append('{0:04x}'.format(i))\n\treturn regionVectors","def _rect_to_cyl_coords(self, x, y):\n theta = (np.pi * y) / (self.arch_radius * 2)\n y = self.arch_radius * np.sin(theta)\n z = self.arch_radius * np.cos(theta)\n return np.array([x, y, z])","def _generate_coords(self):\n coords = np.dstack([self.X.ravel(), self.Y.ravel()])[0]\n return coords, spatial.cKDTree(coords)","def makeComaInv(self):\n#\tChange here: Check sector range map an invert submatrix\n#\n#\n\t\tmapy = np.copy(self.coma) # coMA co PY\n\t\tif self.hasMassRange:\n\t\t\tzeroIndices = []\n\t\t\tfor s in range(self.nSect):\n\t\t\t\tfor i,b in enumerate(range(self.borders[s],self.borders[s+1])):\n\t\t\t\t\tif s in self.massRanges:\n\t\t\t\t\t\tbinCenterMass = self.binCenters[b]\n\t\t\t\t\t\tif binCenterMass < self.massRanges[s][0] or binCenterMass >= self.massRanges[s][1]:\n\t\t\t\t\t\t\tzeroIndices.append(b)\n\t\t\tfor i in range(len(self.coma)):\n\t\t\t\tfor zi in zeroIndices:\n\t\t\t\t\tmapy[i,2*zi ] = 0.\n\t\t\t\t\tmapy[i,2*zi+1] = 0.\n\t\t\t\t\tmapy[2*zi ,i] = 0.\n\t\t\t\t\tmapy[2*zi+1,i] = 0.\n\t\tif self.ownPinv:\n\t\t\tself.comaInv = utils.pinv(mapy, numLim = self.numLim)\n\t\telse:\n\t\t\tself.comaInv = la.pinv(mapy)","def _velocity_cylindrical2spherical(pos,vel):\n \n pos_cart=_position_cylindrical2cartesian(pos)\n vel_cart=_velocity_cylindrical2cartesian(pos,vel)\n vel_sph=_velocity_cartesian2spherical(pos_cart,vel_cart)\n\n return vel_sph","def cmesh(self):\n return numpy.meshgrid(*self.centers, indexing='ij')","def vec2cr(self, vec):\n T = np.array([[np.cos(vec[1]), 0, 0],\n [0, np.sin(vec[1]), 0],\n [0, 0, 1]])\n tmp = np.array([vec[0], vec[0], vec[2]])\n vec_cr = np.dot(T, tmp)\n return vec_cr","def ij_coordinates(self):\n\n x = np.arange(self.nx)\n y = np.arange(self.ny)\n return np.meshgrid(x, y)","def obs_ijpos(gridfile,lons,lats,coor):\n\n gfh= netCDF4.Dataset(gridfile)\n cartesian=0\n if (coor=='r'):\n try:\n \n latr=gfh.variables['lat_rho'][:,:]\n lonr=gfh.variables['lon_rho'][:,:]\n except:\n latr=gfh.variables['latitude'][:,:]\n lonr=gfh.variables['longitude'][:,:]\n \n\n try:\n xr=gfh.variables['xi_rho'][:]\n yr=gfh.variables['eta_rho'][:]\n except:\n try:\n xr=gfh.variables['x_rho'][:]\n yr=gfh.variables['y_rho'][:]\n except:\n print('Neither xi_rho/eta_rho or x_rho/y_rho on file.')\n print('This might slow down the calculations')\n\n\n elif (coor=='u'):\n latr=gfh.variables['lat_u'][:,:]\n lonr=gfh.variables['lon_u'][:,:]\n try:\n xr=gfh.variables['xi_u'][:]\n yr=gfh.variables['eta_u'][:]\n except:\n xr=gfh.variables['x_u'][:]\n yr=gfh.variables['y_u'][:]\n elif (coor=='v'):\n latr=gfh.variables['lat_v'][:,:]\n lonr=gfh.variables['lon_v'][:,:]\n try:\n xr=gfh.variables['xi_v'][:]\n yr=gfh.variables['eta_v'][:]\n except:\n xr=gfh.variables['x_v'][:]\n yr=gfh.variables['y_v'][:]\n\n IN = point_in_polygon(lonr, latr, lons, lats)\n ind=np.where(IN)[0]\n \n if lats.size >1: \n lons=lons[ind]; lats=lats[ind]\n # If there's no lons, lats left at this stage, return oipos, ojpos with -999 everywhere\n if not len(lons):\n return np.ones_like(IN)*-999, np.ones_like(IN)*-999\n \n try:\n try:\n mapstr=str(gfh.variables['h'].getncattr('mapping'))\n except:\n try:\n mapstr=str(gfh.variables['h'].getncattr('grid_mapping'))\n except:\n pass\n try:\n projstring=(gfh.variables[mapstr]).getncattr('proj4')\n except:\n try:\n projstring=(gfh.variables[mapstr]).getncattr('proj4string')\n except:\n pass\n try:\n projstring=(gfh.variables['grid_mapping']).getncattr('proj4')\n except:\n try:\n projstring=(gfh.variables['grid_mapping']).getncattr('proj4string')\n except:\n pass\n\n gridproj=proj.Proj(str(projstring))\n hasproj=1\n except:\n hasproj=0\n\n # Check if lat, lon spacing is uniform\n dx1=np.abs(lonr[0,1]-lonr[0,0])\n dx2=np.abs(lonr[0,-1]-lonr[0,-2])\n n=int(np.round(lonr.shape[1]/2))\n dx3=np.abs(lonr[0,n]-lonr[0,n-1])\n\n dy1=np.abs(latr[1,0]-latr[0,0])\n dy2=np.abs(latr[-1,0]-latr[-2,0])\n n=int(np.round(latr.shape[0]/2))\n dy3=np.abs(latr[n,0]-latr[n-1,0])\n\n if ( (dx1 == dx2) & (dx1==dx3) & (dx2==dx3) & (dy1 == dy2) & (dy1==dy3) & (dy2==dy3) ):\n cartesian=1\n gridproj=proj.Proj(\"+proj=latlong +datum=WGS84\")\n \n\n \n if hasproj:\n dx=xr[1]-xr[0]\n dy=yr[1]-yr[0]\n [x,y]=gridproj(lons,lats)\n ipos=(x-xr[0])/dx\n jpos=(y-yr[0])/dy\n\n elif cartesian:\n [x1,y1]=gridproj(lonr[0,0],latr[0,0])\n [x2,y2]=gridproj(lonr[0,1],latr[0,1])\n dx=x2-x1\n [x2,y2]=gridproj(lonr[1,0],latr[1,0])\n dy=y2-y1\n [x,y]=gridproj(lons,lats)\n [x0,y0]=gridproj(lonr[0,0],latr[0,0])\n\n ipos=(x-x0)/dx\n jpos=(y-y0)/dy\n\n else:\n x=np.linspace(0,lonr.shape[1]-1,lonr.shape[1])\n y=np.linspace(0,lonr.shape[0]-1,lonr.shape[0])\n xi=np.zeros_like(lonr); yi=np.zeros([lonr.shape[1],lonr.shape[0]])\n xi[:,:]=x; yi[:,:]=y; yi=np.swapaxes(yi,1,0)\n zi=scipy.interpolate.griddata((lonr.flatten(),latr.flatten()),xi.flatten(),(lons,lats))\n ipos=zi\n zi=scipy.interpolate.griddata((lonr.flatten(),latr.flatten()),yi.flatten(),(lons,lats))\n jpos=zi\n \n if 'ind' in locals():\n oipos=np.ones(IN.shape)*-999.; ojpos=np.ones(IN.shape)*-999.\n oipos[ind]=ipos; ojpos[ind]=jpos\n else:\n oipos=ipos\n ojpos=jpos\n if not IN:\n oipos = np.array([-999.])\n ojpos = np.array([-999.])\n gfh.close()\n return oipos,ojpos","def convert_coords_cart_sphere(coords_cart):\n shape = coords_cart.shape\n coords = coords_cart.reshape(3,-1)\n\n lat, lon, alt = np.zeros_like(coords)\n for i in range(coords.shape[1]):\n p_rec = [coords[0, i], coords[1, i], coords[2, i]]\n p_lat = sp.spiceypy.reclat(p_rec)\n alt[i], lon[i], lat[i] = p_lat\n \n lat = lat*180/np.pi\n lon = lon*180/np.pi\n alt = alt - mars_r \n\n coords_sphere = np.array([lat, lon, alt]).reshape(shape)\n return coords_sphere","def vector(self):\n return np.array([self.lat, self.lng])","def vec2cr(self, vec):\n T = np.array([[np.sin(vec[1])*np.cos(vec[2]), 0, 0],\n [0, np.sin(vec[1])*np.sin(vec[2]), 0],\n [0, 0, np.cos(vec[1])]])\n tmp = np.array([vec[0], vec[0], vec[0]])\n return np.dot(T, tmp)","def genVector(width, height, x_mult=1, y_mult=1):\n centerX = (width - 1) / 2.0\n centerY = (height - 1) / 2.0\n\n return [[int(math.sqrt(math.pow(x - centerX, 2 * x_mult) + math.pow(y - centerY, 2 * y_mult))) for x in range(width)] for y in range(height)]","def cartesian_To_Center(self, x, y, z):\n\n if x > 0.0 and -self.L_cap <= y <= 0.0:\n s = self.L_cap + y\n xc = x - self.rb\n yc = z\n else:\n theta = full_arctan2(y, x)\n if theta <= self.ang:\n s = theta * self.rb + self.L_cap\n xc = np.sqrt(x ** 2 + y ** 2) - self.rb\n yc = z\n elif self.ang < theta <= 2 * np.pi: # i'm being lazy here and not limiting the real end\n x0, y0 = np.cos(self.ang) * self.rb, np.sin(self.ang) * self.rb\n thetaEndPerp = np.pi - np.arctan(-1 / np.tan(self.ang))\n x, y = x - x0, y - y0\n deltaS, xc = np.cos(thetaEndPerp) * x + np.sin(-thetaEndPerp) * y, np.sin(thetaEndPerp) * x + np.cos(\n thetaEndPerp) * y\n yc = z\n xc = -xc\n s = (self.ang * self.rb + self.L_cap) + deltaS\n else:\n raise ValueError\n return s, xc, yc","def getCartesianPoints(rTheta, center):\n if rTheta.ndim == 2:\n x = rTheta[:, 0] * np.cos(rTheta[:, 1]) + center[0]\n y = rTheta[:, 0] * np.sin(rTheta[:, 1]) + center[1]\n else:\n x = rTheta[0] * np.cos(rTheta[1]) + center[0]\n y = rTheta[0] * np.sin(rTheta[1]) + center[1]\n\n return np.array([x, y]).T","def get_valid_index_from_cartesian_grid(cart_grid, lons, lats,\n radius_of_influence):\n\n def _get_lons(x, y):\n return np.rad2deg(np.arccos(x / np.sqrt(x ** 2 + y ** 2))) * np.sign(y)\n\n def _get_lats(z):\n return 90 - np.rad2deg(np.arccos(z / R))\n\n # Get sides of target grid and transform to lon lats\n lons_side1 = _get_lons(cart_grid[0, :, 0], cart_grid[0, :, 1])\n lons_side2 = _get_lons(cart_grid[:, -1, 0], cart_grid[:, -1, 1])\n lons_side3 = _get_lons(cart_grid[-1, ::-1, 0], cart_grid[-1, ::-1, 1])\n lons_side4 = _get_lons(cart_grid[::-1, 0, 0], cart_grid[::-1, 0, 1])\n\n lats_side1 = _get_lats(cart_grid[0, :, 2])\n lats_side2 = _get_lats(cart_grid[:, -1, 2])\n lats_side3 = _get_lats(cart_grid[-1, ::-1, 2])\n lats_side4 = _get_lats(cart_grid[::-1, 0, 2])\n\n valid_index = _get_valid_index(lons_side1, lons_side2, lons_side3, lons_side4,\n lats_side1, lats_side2, lats_side3, lats_side4,\n lons, lats, radius_of_influence)\n\n return valid_index","def xyz(self) -> np.ndarray:\n return self._vector[0:3]","def clinopyroxene_92():\n\n rho = 3327.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 257.3; C[0,1] = 85.9; C[0,2] = 76.2; C[0,3] = 0.; C[0,4] = 7.1; C[0,5] = 0.\n C[1,0] = C[0,1]; C[1,1] = 216.2; C[1,2] = 71.8; C[1,3] = 0.; C[1,4] = 13.3; C[1,5] = 0.\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 260.2; C[2,3] = 0.; C[2,4] = 33.7; C[2,5] = 0.\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 80.2; C[3,4] = 0.; C[3,5] = 10.2\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 70.6; C[4,5] = 0.\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 85.8\n\n return C, rho"],"string":"[\n \"def cxvec(self):\\n return np.array([self.cx, self.cy])\",\n \"def get_cartesian_coords(self):\\n r = 1\\n dec = self.dec + 90\\n x = r * math.sin(np.deg2rad(dec)) * math.cos(np.deg2rad(self.ra))\\n y = r * math.sin(np.deg2rad(dec)) * math.sin(np.deg2rad(self.ra))\\n z = r * math.cos(np.deg2rad(dec))\\n\\n return [x, y, z]\",\n \"def _position_cartesian2cylindrical(pos):\\n\\n \\n #save cartesian position of each particle\\n x=pos[:,0]\\n y=pos[:,1]\\n z=pos[:,2]\\n\\n rho= np.sqrt(x**2+y**2)\\n theta=np.arctan2(y,x)\\n\\n\\n return np.dstack((rho,theta,z))[0]\",\n \"def Cvec(self):\\n return vec(self.xc, self.yc)\",\n \"def cylindrical2cartesian(cylinder):\\n cart = np.zeros(cylinder.shape)\\n cart[:, 0] = cylinder[:, 0] * np.cos(cylinder[:, 1])\\n cart[:, 1] = cylinder[:, 0] * np.sin(cylinder[:, 1])\\n cart[:, 2] = cylinder[:, 2]\\n return cart\",\n \"def _position_cylindrical2cartesian(pos):\\n \\n rho=pos[:,0]\\n theta=pos[:,1]\\n z=pos[:,2]\\n\\n x=rho*np.cos(theta)\\n y=rho*np.sin(theta)\\n z=z\\n\\n return np.dstack((x,y,z))[0]\",\n \"def cartesian2cylindrical(coords):\\n cyl = np.zeros(coords.shape)\\n cyl[:, 0] = np.sqrt(coords[:, 0] ** 2 + coords[:, 1] ** 2)\\n cyl[:, 1] = np.arctan2(coords[:, 1], coords[:, 0])\\n cyl[:, 2] = coords[:, 2]\\n return cyl\",\n \"def cart_coords2d(self):\\r\\n\\r\\n mgx, mgy = self.meshup2d()\\r\\n coords = np.column_stack((mgx.flatten(), mgy.flatten()))\\r\\n\\r\\n return coords\",\n \"def cart_coords(self):\\r\\n\\r\\n mgx, mgy, mgz = self.meshup()\\r\\n coords = np.column_stack((np.ravel(mgx, order='C'), np.ravel(mgy, order='C'), np.ravel(mgz, order='C')))\\r\\n\\r\\n return coords\",\n \"def cartesian_to_cylindrical(grid, vec=None):\\n\\n grid = np.atleast_2d(grid)\\n\\n if vec is None:\\n return np.hstack([\\n mkvc(np.sqrt(grid[:, 0]**2 + grid[:, 1]**2), 2),\\n mkvc(np.arctan2(grid[:, 1], grid[:, 0]), 2),\\n mkvc(grid[:, 2], 2)\\n ])\\n\\n if len(vec.shape) == 1 or vec.shape[1] == 1:\\n vec = vec.reshape(grid.shape, order='F')\\n\\n theta = np.arctan2(grid[:, 1], grid[:, 0])\\n\\n return np.hstack([\\n mkvc(np.cos(theta)*vec[:, 0] + np.sin(theta)*vec[:, 1], 2),\\n mkvc(-np.sin(theta)*vec[:, 0] + np.cos(theta)*vec[:, 1], 2),\\n mkvc(vec[:, 2], 2)\\n ])\",\n \"def cylindrical_to_cartesian(grid, vec=None):\\n grid = np.atleast_2d(grid)\\n\\n if vec is None:\\n return np.hstack([\\n mkvc(grid[:, 0]*np.cos(grid[:, 1]), 2),\\n mkvc(grid[:, 0]*np.sin(grid[:, 1]), 2),\\n mkvc(grid[:, 2], 2)\\n ])\\n\\n if len(vec.shape) == 1 or vec.shape[1] == 1:\\n vec = vec.reshape(grid.shape, order='F')\\n\\n x = vec[:, 0] * np.cos(grid[:, 1]) - vec[:, 1] * np.sin(grid[:, 1])\\n y = vec[:, 0] * np.sin(grid[:, 1]) + vec[:, 1] * np.cos(grid[:, 1])\\n\\n newvec = [x, y]\\n if grid.shape[1] == 3:\\n z = vec[:, 2]\\n newvec += [z]\\n\\n return np.vstack(newvec).T\",\n \"def coord_vecs(self):\\n return [np.linspace(x0, x1, nx) for x0, x1, nx in zip(self.mins, self.maxs, self.shape)]\",\n \"def spherical2cartesian(v):\\n \\n x = np.cos(v[0]) * np.cos(v[1]) \\n y = np.cos(v[0]) * np.sin(v[1]) \\n z = np.sin(v[0]) \\n \\n return [x,y,z]\",\n \"def co_vertexes(self):\\n theta = self.orientation + np.pi / 2\\n shifts = np.array([np.cos(theta), np.sin(theta)]) * self.b\\n return self.coords + (shifts[:, None] * [-1, 1]).T\",\n \"def _position_spherical2cartesian(pos):\\n \\n r=pos[:,0]\\n theta=pos[:,1]\\n phi=pos[:,2]\\n\\n if any(theta>np.pi) or any(theta<0): #sanity check. not necessary for phi.\\n raise ValueError, \\\"Theta beyond [0,pi]. Exiting.\\\"\\n\\n\\n x=r*np.sin(theta)*np.cos(phi)\\n y=r*np.sin(theta)*np.sin(phi)\\n z=r*np.cos(theta)\\n\\n return np.dstack((x,y,z))[0]\",\n \"def _spherical_to_cartesian(ra, dec):\\n rar = np.radians(ra)\\n decr = np.radians(dec)\\n\\n x = np.cos(rar) * np.cos(decr)\\n y = np.sin(rar) * np.cos(decr)\\n z = np.sin(decr)\\n \\n return x, y, z\",\n \"def vertexes(self):\\n theta = self.orientation\\n shifts = np.array([np.cos(theta), np.sin(theta)]) * self.a\\n return self.coords + (shifts[:, None] * [-1, 1]).T\",\n \"def unit_vectors(self):\\n # return {'comp1': CartesianRepresentation(...),\\n # 'comp2': CartesianRepresentation(...),\\n # 'comp3': CartesianRepresentation(...)}\\n raise Exception(\\\"Not yet implemented\\\")\",\n \"def cartesian_coordinates(self, *axes):\",\n \"def _velocity_cylindrical2cartesian(pos,vel):\\n \\n \\n #save cartesian position of each particle\\n theta=pos[:,1]\\n\\n #save cyindrical velocities\\n vr=vel[:,0]\\n vtheta=vel[:,1]\\n vz=vel[:,2]\\n\\n #compute cartesian velocities\\n vx = vr*np.cos(theta) - vtheta*np.sin(theta)\\n vy = vr*np.sin(theta) + vtheta*np.cos(theta)\\n vz = vz\\n\\n return np.dstack((vx,vy,vz))[0]\",\n \"def cartesian(self):\\n raise NotImplementedError(\\\"This is not implemented.\\\")\\n return CartCoord()\",\n \"def cartesian(position):\\n return [position[0] * cos(position[1]), position[0] * sin(position[1])]\",\n \"def cartesian_2_cylindrical(grid, vec=None):\\n return cartesian_to_cylindrical(grid, vec)\",\n \"def _indices_to_coords(c,r):\\n\\n column = _index_to_column(c)\\n row = r + 1\\n\\n return {'c': column, 'r': row, 'coord': f'{column}{row}'}\",\n \"def vec(self):\\r\\n\\r\\n xv = np.arange(self.dx / 2, self.lx, self.dx)\\r\\n yv = np.arange(-self.ly / 2 + self.dy / 2, self.ly / 2, self.dy)\\r\\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\\r\\n\\r\\n if self.ox != 0:\\r\\n xv = np.arange(self.ox, self.lx + self.ox, self.dx)\\r\\n yv = np.arange(self.oy, self.ly + self.oy, self.dy)\\r\\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\\r\\n\\r\\n return xv, yv, zv\",\n \"def hexgrid(self):\\n n = self.n * 2\\n vectors = []\\n for u in range(-n, n+1):\\n us = [u] * (2*n+1)\\n if u < 0:\\n vectors.extend(zip(us, range(-n-u, n+1), range(-n, n+u+1)))\\n else:\\n vectors.extend(zip(us, range(-n, n-u+1), range(-n+u, n+1)))\\n return vectors\",\n \"def _position_spherical2cylindrical(pos):\\n \\n\\n r=pos[:,0]\\n theta_spherical=pos[:,1]\\n phi_spherical=pos[:,2]\\n\\n if any(theta_spherical>np.pi) or any(theta_spherical<0): #sanity check. not necessary for phi.\\n raise ValueError, \\\"Theta beyond [0,pi]. Exiting.\\\"\\n\\n rho=r*np.sin(theta_spherical)\\n theta_cylindrical=phi_spherical\\n z=r*np.cos(theta_spherical)\\n\\n return np.dstack((rho,theta_cylindrical,z))[0]\",\n \"def cartesian_coordinates(self):\\n # extract RA items\\n ra_hours, ra_minutes, ra_seconds = RA_RE.match(str(self.ra)).groups()\\n # then cast\\n ra_hours = int(ra_hours)\\n ra_minutes = int(ra_minutes)\\n ra_seconds = float(ra_seconds)\\n\\n # extract DEC items\\n dec_sign, dec_degrees, dec_minutes, dec_seconds = DEC_RE.match(str(self.dec)).groups()\\n # then cast\\n dec_sign = -1 if dec_sign == '-' else 1\\n dec_degrees = int(dec_degrees)\\n dec_minutes = int(dec_minutes)\\n dec_seconds = float(dec_seconds)\\n\\n # to degrees\\n a = (ra_hours*15) + (ra_minutes*0.25) + (ra_seconds*0.004166)\\n b = abs(dec_degrees + dec_minutes/60 + dec_seconds/3600) * dec_sign\\n\\n # to radians\\n a = math.radians(a)\\n b = math.radians(b)\\n\\n distance = float(self.distance)\\n\\n x = (distance * math.cos(b)) * math.cos(a)\\n y = (distance * math.cos(b)) * math.sin(a)\\n z = distance * math.sin(b)\\n\\n return x, y, z\",\n \"def i_coords(self):\\n ref_x = np.arange(-self.ref_w / 2, self.ref_w / 2 + 0.002, 0.002)\\n\\n if self.ref_shape == 'c': # Curved reflector\\n dist_coords1 = [(ref_x[i], pos_on_semicircle(ref_x[i], self.R, self.c_xy)) for i in range(self.I)]\\n dist_coords2 = [(ref_x[i + 1], pos_on_semicircle(ref_x[i + 1], self.R, self.c_xy)) for i in range(self.I)]\\n a_i = [distance(dist_coords1[i], dist_coords2[i]) for i in range(self.I)]\\n\\n cx_i = [ref_x[i] + (ref_x[i + 1] - ref_x[i]) / 2 for i in range(self.I)]\\n cy_i = [pos_on_semicircle(x, self.R, self.c_xy) for x in cx_i]\\n i_coords = list(zip(cx_i, cy_i))\\n else: # Flat reflector\\n a_i = [(ref_x[i + 1] - ref_x[i]) / 2 for i in range(self.I)]\\n cx_i = [ref_x[i] + (ref_x[i + 1] - ref_x[i]) / 2 for i in range(self.I)]\\n i_coords = [(x, self.h) for x in cx_i]\\n d = {'ref_x': ref_x, 'A_i': a_i, 'I_coords': i_coords, 'cx_i': cx_i}\\n\\n return d\",\n \"def spherical2cartesian(spherical):\\n spherical = np.array(spherical).squeeze()\\n distance, azimuth, elevation = spherical\\n x = distance * np.sin(azimuth) * np.cos(elevation)\\n y = distance * np.sin(azimuth) * np.sin(elevation)\\n z = distance * np.cos(azimuth)\\n return np.array([x, y, z])\",\n \"def cartesian2bary(self, x):\\n lam = np.zeros((x.shape[0], 3))\\n lam[:,:2] = np.einsum('ij,kj->ki', self.Tinv, x - self.xv[2])\\n lam[:,2] = 1. - lam[:,0] - lam[:,1]\\n return lam\",\n \"def _velocity_cartesian2cylindrical(pos,vel):\\n \\n \\n \\n #save cartesian velocities\\n vx=vel[:,0]\\n vy=vel[:,1]\\n vz=vel[:,2]\\n\\n #convert to cylindrical coordinates\\n pos_cyl=_position_cartesian2cylindrical(pos) #cylindrical coordinates\\n theta=pos_cyl[:,1]\\n\\n #compute cylindrical velocities\\n vr=vx*np.cos(theta) + vy*np.sin(theta)\\n vtheta=-vx*np.sin(theta) + vy*np.cos(theta)\\n vz=vz\\n \\n\\n return np.dstack((vr,vtheta,vz))[0]\",\n \"def _velocity_spherical2cylindrical(pos,vel):\\n \\n pos_cart=_position_spherical2cartesian(pos)\\n vel_cart=_velocity_spherical2cartesian(pos,vel)\\n vel_cyl=_velocity_cartesian2cylindrical(pos_cart,vel_cart)\\n\\n return vel_cyl\",\n \"def get_coords(self):\\r\\n # get the coordinates from V, skipping every 3 since it's a vector\\r\\n meshpts = self.V.tabulate_dof_coordinates()[::3]\\r\\n\\r\\n # create r vector if not already created\\r\\n try:\\r\\n self.r\\r\\n except:\\r\\n self.r = Function(self.V)\\r\\n\\r\\n # set the r vector\\r\\n self.r.vector()[:] = meshpts.flatten()\",\n \"def _convert_coords_to_coordinates(self, vect) -> np.ndarray:\\n # create empty vector of necessary shape\\n # one coordinate for each endpoint of the vector\\n pos = np.empty((2 * len(vect), 2), dtype=np.float32)\\n\\n # create pairs of points\\n pos[0::2, 0] = vect[:, 0]\\n pos[1::2, 0] = vect[:, 0]\\n pos[0::2, 1] = vect[:, 1]\\n pos[1::2, 1] = vect[:, 1]\\n\\n # adjust second of each pair according to x-y projection\\n pos[1::2, 0] += vect[:, 2]\\n pos[1::2, 1] += vect[:, 3]\\n\\n return pos\",\n \"def to_cartes(self):\\n if self.__coordsys in (Polar, PhySpherical, MathSpherical):\\n self.__coordsys = Cartesian if self.__coordsys == Polar else Cartesian_3\\n self.update_coord(vct.rec(self.list_repr()))\",\n \"def c(self) -> np.ndarray:\\n return self._vector[10:12]\",\n \"def simple_cubic_cell_translation_integers(lattice, cutoff: float):\\n n_vectors = lattice.shape[1]\\n return [int(np.ceil(cutoff / np.linalg.norm(lattice[:, i])))\\n for i in range(0, n_vectors)]\",\n \"def vector_line(self):\\n assert len(self.xcoords) == 2\\n diff_x = self.xcoords[1] - self.xcoords[0]\\n diff_z = self.zcoords[1] - self.zcoords[0]\\n vec = np.hstack((diff_x, diff_z))\\n return vec\",\n \"def n_coords(self):\\n trans_x = np.arange(-self.trans_dia / 2, self.trans_dia / 2 + 0.002, 0.002)\\n a_n = [(trans_x[n + 1] - trans_x[n]) / 2 for n in range(self.N)]\\n cx_n = [trans_x[n] + (trans_x[n + 1] - trans_x[n]) / 2 for n in range(self.N)]\\n coords = [(x, 0) for x in cx_n]\\n d = {'trans_x': trans_x, 'A_n': a_n, 'N_coords': coords}\\n return d\",\n \"def loc_to_cart(loc):\\n return (loc % grid_size, loc % slice_size // grid_size, loc // slice_size)\",\n \"def _spherical_to_cartesian_fast(ra, dec, threads):\\n import numexpr as ne\\n\\n #nthreads = ne.detect_number_of_cores()\\n nthreads = threads\\n ne.set_num_threads(nthreads)\\n\\n pi = math.pi\\n rar = ne.evaluate('ra*pi/180.0')\\n decr = ne.evaluate('dec*pi/180.0')\\n\\n hold1=ne.evaluate('cos(decr)') \\n\\n x = ne.evaluate('cos(rar) * hold1')\\n y = ne.evaluate('sin(rar) * hold1')\\n z = ne.evaluate('sin(decr)')\\n \\n return x, y, z\",\n \"def getCartesian(self, phi, theta, radius):\\n point_x = round(sin(theta) * cos(phi) * radius,4)\\n point_y = round(sin(theta) * sin(phi) * radius,4)\\n point_z = round(cos(theta) * radius,4)\\n return [point_x, point_y, point_z]\",\n \"def spherical2cartesian(sphere):\\n cart = np.zeros(sphere.shape, dtype=np.float64)\\n sine_phi = np.sin(sphere[:, 2])\\n\\n cart[:, 0] = sphere[:, 0] * np.cos(sphere[:, 1]) * sine_phi\\n cart[:, 1] = sphere[:, 0] * np.sin(sphere[:, 1]) * sine_phi\\n cart[:, 2] = sphere[:, 0] * np.cos(sphere[:, 2])\\n return cart\",\n \"def cartesian_to_spherical(self, v):\\n x = Vector.x(v)\\n y = Vector.y(v)\\n z = Vector.z(v)\\n r = Vector.length(v)\\n phi = atan2(y, x)\\n theta = acos(z / r)\\n \\n return [r, phi, theta]\",\n \"def to_cartesian(dimensions, angles):\\n return Operator(transform=np.transpose(np.array(_basis_vectors(dimensions, angles))))\",\n \"def to_cartesian(self):\\n w = 1.73205 # sqrt(3)\\n h = 2\\n dx = 0.5 * w if self.y % 2 == 1 else 0\\n x = 0.5 * w + self.x * w + dx\\n y = 0.5 * h + 0.75 * self.y * h\\n return (x, y)\",\n \"def spherical_to_cartesian(self, r, phi, theta):\\n x = r*cos(phi)*sin(theta)\\n y = r*sin(phi)*sin(theta)\\n z = r*cos(theta)\\n \\n return Vector(float(x), float(y), float(z))\",\n \"def _velocity_spherical2cartesian(pos,vel):\\n \\n #save cartesian position of each particle\\n r=pos[:,0]\\n theta=pos[:,1]\\n phi=pos[:,2]\\n\\n\\n #save cyindrical velocities\\n vr=vel[:,0]\\n vtheta=vel[:,1]\\n vphi=vel[:,2]\\n\\n\\n #compute cartesian velocities\\n vx = vr*np.sin(theta)*np.cos(phi) + vtheta*np.cos(theta)*np.cos(phi) - vphi*np.sin(phi)\\n vy = vr*np.sin(theta)*np.sin(phi) + vtheta*np.cos(theta)*np.sin(phi) + vphi*np.cos(phi)\\n vz = vr*np.cos(theta) - vtheta*np.sin(theta)\\n\\n return np.dstack((vx,vy,vz))[0]\",\n \"def compute_normalvect(self):\\n normvect = np.zeros((len(self.tri_pnts),3,3))\\n zvec = np.array([0, 0, 1])\\n for itri, tri in enumerate(self.tri_pnts):\\n #import pdb; pdb.set_trace()\\n tri0, tri1, tri2 = tri\\n x1,y1 = self.points[tri1]-self.points[tri0]\\n v1 = np.array([x1,y1,0])\\n x2,y2 = self.points[tri2]-self.points[tri1]\\n v2 = np.array([x2,y2,0])\\n x3,y3 = self.points[tri0]-self.points[tri2]\\n v3 = np.array([x3,y3,0])\\n v1 = v1/np.linalg.norm(v1)\\n v2 = v2/np.linalg.norm(v2)\\n v3 = v3/np.linalg.norm(v3)\\n #import pdb; pdb.set_trace()\\n normvect[itri,:,:] = np.cross(v1,zvec), np.cross(v2,zvec), np.cross(v3,zvec)\\n #import pdb; pdb.set_trace()\\n return normvect\",\n \"def to_cartesian(self): # TODO\\n pass\",\n \"def _calcOrderedCellVertexIDs(self):\\n ids = numerix.zeros((8, self.nx, self.ny, self.nz), 'l')\\n indices = numerix.indices((self.nx, self.ny, self.nz))\\n ids[1] = indices[0] + (indices[1] + (indices[2] + 1) * (self.ny + 1) + 1) * (self.nx + 1)\\n ids[0] = ids[1] + 1\\n ids[3] = indices[0] + (indices[1] + (indices[2] + 1) * (self.ny + 1)) * (self.nx + 1)\\n ids[2] = ids[3] + 1\\n ids[5] = indices[0] + (indices[1] + indices[2] * (self.ny + 1) + 1) * (self.nx + 1)\\n ids[4] = ids[5] + 1\\n ids[7] = indices[0] + (indices[1] + indices[2] * (self.ny + 1)) * (self.nx + 1)\\n ids[6] = ids[7] + 1\\n\\n return numerix.reshape(ids.swapaxes(1, 3), (8, self.numberOfCells))\",\n \"def vector(molec, dihed, nonH, energy):\\n #Torison\\n if dihed:\\n pass\\n #XYZ\\n else:\\n coords = ()\\n if nonH:\\n for atom in molec.atoms:\\n coords += atom.coords\\n else:\\n for atom in molec.atoms:\\n if atom.atomicnum > 1:\\n coords += atom.coords\\n #Energy\\n if energy:\\n coords += (molec.energy/10.0,)\\n return coords\",\n \"def to_indices(self, world_coords):\\n (x, y, z) = world_coords\\n (cx, cy, cz) = self.center\\n\\n px = x - cx\\n py = y - cy\\n pz = z - cz\\n\\n # project u and v\\n # TODO: Can this be done with some built-in Numpy operation?\\n (ux, uy, uz) = self.u_dir\\n (vx, vy, vz) = self.v_dir\\n u = px * ux + py * uy + pz * uz\\n v = px * vx + py * vy + pz * vz\\n\\n # rescale to pixel coordinates. u is up, v is down\\n (H, W, _) = self.shape\\n i = rescale(-1, 1, H - 1, 0, v)\\n j = rescale(-1, 1, 0, W -1, u)\\n\\n return (i, j)\",\n \"def spherical_to_cartesian(grid, vec=None):\\n grid = np.atleast_2d(grid)\\n\\n if vec is None:\\n return np.hstack([\\n mkvc(grid[:, 0] * np.sin(grid[:, 2]) * np.cos(grid[:, 1]), 2),\\n mkvc(grid[:, 0] * np.sin(grid[:, 2]) * np.sin(grid[:, 1]), 2),\\n mkvc(grid[:, 0] * np.cos(grid[:, 2]), 2)\\n ])\\n\\n if len(vec.shape) == 1 or vec.shape[1] == 1:\\n vec = vec.reshape(grid.shape, order='F')\\n\\n x = (\\n vec[:, 0] * np.sin(grid[:, 2]) * np.cos(grid[:, 1]) +\\n vec[:, 2] * np.cos(grid[:, 2]) * np.cos(grid[:, 1]) -\\n vec[:, 1] * np.sin(grid[:, 1])\\n )\\n y = (\\n vec[:, 0] * np.sin(grid[:, 2]) * np.sin(grid[:, 1]) +\\n vec[:, 2] * np.cos(grid[:, 2]) * np.sin(grid[:, 1]) -\\n vec[:, 1] * np.cos(grid[:, 1])\\n )\\n z = (\\n vec[:, 0] * np.cos(grid[:, 2]) -\\n vec[:, 2] * np.sin(grid[:, 2])\\n )\\n\\n newvec = [x, y, z]\\n\\n return np.vstack(newvec).T\",\n \"def convert_cylinder_to_cartesian(dictionary):\\n\\n # Define num of points in x and y direction\\n dictionary['nx'] = dictionary['nt'] # Angular number of points\\n dictionary['ny'] = dictionary['nr'] # Radial number of points\\n\\n # Assemble gradient components into tensor\\n if all(cyl_grad_u_key in dictionary for cyl_grad_u_key in CYL_GRAD_U_KEYS) and 'grad_u_cyl' not in dictionary:\\n dictionary['grad_u_cyl'] = assemble_2nd_order_tensor(dictionary, CYL_GRAD_U_KEYS)\\n elif 'grad_u_cyl' in dictionary:\\n pass\\n else:\\n print('WARNING No gradient data available for conversion cylinder to cartesian coordinates.')\\n\\n # Loop all keys in dictionary\\n for cyl_key in tuple(dictionary):\\n if isinstance(dictionary[cyl_key], (np.ndarray, int, float, str)):\\n if cyl_key in CYL_VEL_KEYS:\\n velocity_cylinder_to_cartesian(dictionary, cyl_key, verbose=False)\\n elif cyl_key == 'grad_u_cyl':\\n gradient_cylinder_to_cartesian(dictionary, cyl_key)\\n elif cyl_key in CYL_TAU_KEYS:\\n tau_components_cylinder_to_cartesian(dictionary, cyl_key, verbose=False) # Requires off-diagonal elements in tau, for now just RENAMING\\n elif cyl_key in CYL_ALL_BUDGET_KEYS:\\n budget_tau_components_cylinder_to_cartesian(dictionary, cyl_key, verbose=False) # Just RENAMING budgets!\\n elif cyl_key in CYL_RMS_KEYS:\\n rms_velocity_cylinder_to_cartesian(dictionary, cyl_key, verbose=False) # Just RENAMING rms, requires off-diag tau for conversion\\n else:\\n pass\\n else:\\n assert False, 'Unknown variable type in dictionary for key %r with type %r' % (cyl_key, type(dictionary[cyl_key]))\\n\\n return 1\",\n \"def cart_coord(contours, centers):\\n cart_contours = []\\n for i in range(len(contours)):\\n contour = contours[i]\\n center = centers[i]\\n cart_contour = np.zeros((contour.shape[0], contour.shape[1]))\\n for j in range(contour.shape[0]):\\n cart_contour[j, 0] = contour[j, 1] * math.cos(contour[j, 0]) + center[0]\\n cart_contour[j, 1] = contour[j, 1] * math.sin(contour[j, 0]) + center[1]\\n cart_contours.append(cart_contour)\\n return cart_contours\",\n \"def transform_coord_to_vector(coords,vector_dim):\\r\\n\\t\\r\\n\\tnew_vector = [0] * vector_dim\\r\\n\\tfor c in coords:\\r\\n\\t\\tnew_vector[c[0]] = c[1]\\r\\n\\r\\n\\treturn new_vector\",\n \"def get_vertices(self):\\n vertices = []\\n V = [[-self.base_vectors[:,n], self.base_vectors[:,n]] for n in range(self.base_vectors.shape[1])]\\n combs = list(itertools.product(*V))\\n for cb in combs:\\n cb = np.sum(np.array(cb).T, axis=1, keepdims=True)\\n vertices.append(self.base_vertices + cb)\\n\\n vertices = np.concatenate(vertices,axis=1)\\n return vertices\",\n \"def SphericalToCartesian(Spherical):\\n\\n # r,theta,phi -> x,y,z\\n r = Spherical[:,0]\\n st = np.sin(Spherical[:,1])\\n sp = np.sin(Spherical[:,2])\\n ct = np.cos(Spherical[:,1])\\n cp = np.cos(Spherical[:,2])\\n x = r*st*cp\\n y = r*st*sp\\n z = r*ct\\n\\n if (len(Spherical[0,:])==3):\\n Cartesian = np.column_stack((x,y,z))\\n return Cartesian\\n else:\\n # vr,vtheta,vphi -> vx,vy,vz\\n vr = Spherical[:,3]\\n vt = Spherical[:,4]\\n vp = Spherical[:,5]\\n vx = vr*st*cp - vt*ct*cp - vp*sp\\n vy = vr*st*sp + vt*ct*sp + vp*cp\\n vz = vr*ct - vt*st\\n Cartesian= np.column_stack((x,y,z,vx,vy,vz))\\n return Cartesian\",\n \"def get_sound_vertices(self):\\n\\n vals = np.sum(np.abs(self.base_vectors), axis=1, keepdims=True)\\n V = [[v,-v] for v in vals]\\n combs = list(itertools.product(*V))\\n\\n vertices = []\\n for cb in combs:\\n vertices.append(self.base_vertices+np.array(cb))\\n vertices = np.concatenate(vertices, axis=1)\\n return vertices\",\n \"def _geodetic_to_cartesian(cls, lat, lon, alt):\\n C = Earth.r / np.sqrt(1 - (Earth.e * np.sin(lat)) ** 2)\\n S = Earth.r * (1 - Earth.e ** 2) / np.sqrt(1 - (Earth.e * np.sin(lat)) ** 2)\\n r_d = (C + alt) * np.cos(lat)\\n r_k = (S + alt) * np.sin(lat)\\n\\n norm = np.sqrt(r_d ** 2 + r_k ** 2)\\n return norm * np.array(\\n [np.cos(lat) * np.cos(lon), np.cos(lat) * np.sin(lon), np.sin(lat)]\\n )\",\n \"def _CopyCoords(self):\\n self.ccoords = numpy.zeros((self.mol.n_atoms, const.NUMDIM))\\n for i in range(self.mol.n_atoms):\\n for j in range(const.NUMDIM):\\n self.ccoords[i][j] = self.mol.atoms[i].coords[j]\",\n \"def xyz2ic_np(x, Z_indices, torsion_cut=None):\\n from deep_boltzmann.models.MM import dist, angle, torsion\\n global_ic = (Z_indices.min() < 0)\\n if global_ic:\\n bond_indices = Z_indices[1:, :2]\\n angle_indices = Z_indices[2:, :3]\\n torsion_indices = Z_indices[3:, :4]\\n else:\\n bond_indices = Z_indices[:, :2]\\n angle_indices = Z_indices[:, :3]\\n torsion_indices = Z_indices[:, :4]\\n atom_indices = np.arange(int(3*(np.max(Z_indices)+1))).reshape((-1, 3))\\n xbonds = dist(x[:, atom_indices[bond_indices[:, 0]]],\\n x[:, atom_indices[bond_indices[:, 1]]])\\n xangles = angle(x[:, atom_indices[angle_indices[:, 0]]],\\n x[:, atom_indices[angle_indices[:, 1]]],\\n x[:, atom_indices[angle_indices[:, 2]]])\\n xtorsions = torsion(x[:, atom_indices[torsion_indices[:, 0]]],\\n x[:, atom_indices[torsion_indices[:, 1]]],\\n x[:, atom_indices[torsion_indices[:, 2]]],\\n x[:, atom_indices[torsion_indices[:, 3]]])\\n if torsion_cut is not None:\\n xtorsions = np.where(xtorsions < torsion_cut, xtorsions+360, xtorsions)\\n # Order ic's by atom\\n if global_ic:\\n iclist = [xbonds[:, 0:2], xangles[:, 0:1]]\\n for i in range(Z_indices.shape[0]-3):\\n iclist += [xbonds[:, i+2:i+3], xangles[:, i+1:i+2], xtorsions[:, i:i+1]]\\n else:\\n iclist = []\\n for i in range(Z_indices.shape[0]):\\n iclist += [xbonds[:, i:i+1], xangles[:, i:i+1], xtorsions[:, i:i+1]]\\n ics = np.concatenate(iclist, axis=-1)\\n return ics\",\n \"def vec_x(self):\\t\\r\\n if self.ox != 0:\\r\\n ov = self.ox\\r\\n lv = self.self.lx + self.ox\\r\\n else:\\r\\n ov = self.dx / 2\\r\\n lv = self.lx\\r\\n\\r\\n xv = \\\"\\\"\\r\\n for num in np.arange(ov, lv, self.dx):\\r\\n xv += str(num) + \\\" \\\"\\r\\n\\r\\n return xv\",\n \"def cylindrical_2_cartesian(grid, vec=None):\\n return cylindrical_to_cartesian(grid, vec)\",\n \"def get_coordinate_lists(self, crs=None):\\n x, y = self.vertices.vectors()[:2]\\n if crs is not None and (crs != self.crs):\\n x, y = _reproject((x,y), self.crs, crs)\\n return x, y\",\n \"def xvec(self):\\n return np.array([self.x, self.y])\",\n \"def GalacticToCartesian(Galactic,SolarPosition): \\n \\n # l,b,s->x,y,z\\n cl = np.cos(Galactic[:,0])\\n sl = np.sin(Galactic[:,0])\\n cb = np.cos(Galactic[:,1])\\n sb = np.sin(Galactic[:,1])\\n x = SolarPosition[0]-Galactic[:,2]*cb*cl\\n y = Galactic[:,2]*cb*sl\\n z = Galactic[:,2]*sb+SolarPosition[1]\\n\\n if(len(Galactic[0,:])==3):\\n Cartesian = np.column_stack((x,y,z))\\n else:\\n # vlos,mu_lcos(b),mu_b -> vx,vy,vz\\n vl = pm2vel*Galactic[:,2]*Galactic[:,4]\\n vb = pm2vel*Galactic[:,2]*Galactic[:,5]\\n tmp2 = cb*Galactic[:,3]-sb*vb\\n vx = cl*tmp2-sl*vl+SolarPosition[2]\\n vy = sl*tmp2+cl*vl+SolarPosition[3]\\n vz = sb*Galactic[:,3]+cb*vb+SolarPosition[4]\\n Cartesian = np.column_stack((x,y,z,-vx,vy,vz))\\n \\n return Cartesian\",\n \"def Indexes(self, latitudes, longitudes):\\n res = self._transform.TransformPoints(\\n np.column_stack((longitudes, latitudes)))\\n res = list(zip(*res))\\n x, y = np.array(res[0]), np.array(res[1])\\n idx_col = self._inv_txf[0] + self._inv_txf[1] * x + self._inv_txf[2] * y\\n idx_row = self._inv_txf[3] + self._inv_txf[4] * x + self._inv_txf[5] * y\\n return idx_row.astype(int), idx_col.astype(int)\",\n \"def getpos(self):\\n return self.pos.cartesianas()\",\n \"def cartesian2spherical(v):\\n theta = np.arcsin(v[2]) \\n phi = np.arctan2(v[1], v[0])\\n \\n return [theta, phi]\",\n \"def to_cartesian(r, phi):\\n x = r*np.cos(phi)\\n y = r*np.sin(phi)\\n return x, y\",\n \"def _calc_coords(self):\\n i = num.outer(num.arange(self.size[0]), num.ones(self.size[1]))\\n i0 = self.pos[0] + (i * self.space[0])\\n i1 = self.pos[0] + (i * self.space[0]) + self.bub[0]\\n\\n j = num.outer(num.ones(self.size[0]), num.arange(self.size[1]))\\n j0 = self.pos[1] + (j * self.space[1])\\n j1 = self.pos[1] + (j * self.space[1]) + self.bub[1]\\n\\n self.coords = num.dstack((i0, i1, j0, j1)).astype('i')\",\n \"def _pole_to_cart(self,angles,distances):\\n cart=[]\\n for i in xrange(0,len(angles)-1):\\n angle = angles[i]\\n distance = distances[i] \\n xs, ys = distance*cos(angle), distance*sin(angle)\\n cart.append(tuple((xs,ys)))\\n return cart\",\n \"def coordinates(self, bin_indices):\\n indices = numpy.asarray(bin_indices).transpose()\\n coords = [numpy.interp(i, range(n), c)\\n for (i, n, c) in zip(indices, self.shape, self.centers)]\\n coords_arr = numpy.array(coords).transpose()\\n return numpy.atleast_2d(coords_arr)\",\n \"def convert_to_cartesian(grid: List[Tuple[float, float]], radius: float = 1.0) -> List[Tuple[float, float, float]]:\\n\\n # conversion radians -> degrees\\n r2d = 180.0 / np.pi\\n\\n # calculate x/y/z coordinates, assuming r=1\\n return [\\n (\\n radius * np.cos(lat / r2d) * np.cos(lon / r2d),\\n radius * np.cos(lat / r2d) * np.sin(lon / r2d),\\n radius * np.sin(lat / r2d),\\n )\\n for lon, lat in grid\\n ]\",\n \"def _pole_to_cart(Set):\\n xS=[]\\n yS=[]\\n for s in Set:\\n angle = s[0]\\n distance = s[1] \\n if distance !=0:\\n xs, ys = distance*cos(angle), distance*sin(angle)\\n xS.append(xs)\\n yS.append(ys)\\n return xS,yS\",\n \"def _pole_to_cart(Set):\\n xS=[]\\n yS=[]\\n for s in Set:\\n angle = s[0]\\n distance = s[1] \\n if distance !=0:\\n xs, ys = distance*cos(angle), distance*sin(angle)\\n xS.append(xs)\\n yS.append(ys)\\n return xS,yS\",\n \"def project_to_cylinder(points):\\n r, phi, z = cs.cart2cyl(points[:, 0], points[:, 1], points[:, 2])\\n # NOTE: z is unchanged\\n # print(np.array_equal(z, points[:, 2]))\\n # project onto unit cylinder\\n x_cyl = points[:, 0] / r\\n y_cyl = points[:, 1] / r\\n z_cyl = (z - z.min()) / (z.max() - z.min())\\n points_cyl = np.stack((x_cyl, y_cyl, z_cyl), axis=1)\\n return points_cyl, r, phi, z\",\n \"def _flatten_cartesian_coords(cartesian_coords):\\n\\n shape = cartesian_coords.shape\\n if len(shape) > 2:\\n cartesian_coords = cartesian_coords.reshape(shape[0] *\\n shape[1], 3)\\n return cartesian_coords\",\n \"def _position_cylindrical2spherical(pos):\\n\\n rho=pos[:,0]\\n theta_cylindrical=pos[:,1]\\n z=pos[:,2]\\n\\n r=np.sqrt(rho**2+z**2)\\n theta_spherical=np.arctan2(rho,z)\\n phi=theta_cylindrical\\n\\n return np.dstack((r,theta_spherical,phi))[0]\",\n \"def spherical_to_cartesian(r, lat, lon):\\n import math\\n\\n if np.isscalar(r) and np.isscalar(lat) and np.isscalar(lon):\\n x = r * math.cos(lat) * math.cos(lon)\\n y = r * math.cos(lat) * math.sin(lon)\\n z = r * math.sin(lat)\\n else:\\n x = r * np.cos(lat) * np.cos(lon)\\n y = r * np.cos(lat) * np.sin(lon)\\n z = r * np.sin(lat)\\n\\n return x, y, z\",\n \"def generateAllRegionVectors():\\n\\tregionVectors = []\\n\\tfor i in range(NUM_REGION_VECTORS):\\n\\t\\tregionVectors.append('{0:04x}'.format(i))\\n\\treturn regionVectors\",\n \"def _rect_to_cyl_coords(self, x, y):\\n theta = (np.pi * y) / (self.arch_radius * 2)\\n y = self.arch_radius * np.sin(theta)\\n z = self.arch_radius * np.cos(theta)\\n return np.array([x, y, z])\",\n \"def _generate_coords(self):\\n coords = np.dstack([self.X.ravel(), self.Y.ravel()])[0]\\n return coords, spatial.cKDTree(coords)\",\n \"def makeComaInv(self):\\n#\\tChange here: Check sector range map an invert submatrix\\n#\\n#\\n\\t\\tmapy = np.copy(self.coma) # coMA co PY\\n\\t\\tif self.hasMassRange:\\n\\t\\t\\tzeroIndices = []\\n\\t\\t\\tfor s in range(self.nSect):\\n\\t\\t\\t\\tfor i,b in enumerate(range(self.borders[s],self.borders[s+1])):\\n\\t\\t\\t\\t\\tif s in self.massRanges:\\n\\t\\t\\t\\t\\t\\tbinCenterMass = self.binCenters[b]\\n\\t\\t\\t\\t\\t\\tif binCenterMass < self.massRanges[s][0] or binCenterMass >= self.massRanges[s][1]:\\n\\t\\t\\t\\t\\t\\t\\tzeroIndices.append(b)\\n\\t\\t\\tfor i in range(len(self.coma)):\\n\\t\\t\\t\\tfor zi in zeroIndices:\\n\\t\\t\\t\\t\\tmapy[i,2*zi ] = 0.\\n\\t\\t\\t\\t\\tmapy[i,2*zi+1] = 0.\\n\\t\\t\\t\\t\\tmapy[2*zi ,i] = 0.\\n\\t\\t\\t\\t\\tmapy[2*zi+1,i] = 0.\\n\\t\\tif self.ownPinv:\\n\\t\\t\\tself.comaInv = utils.pinv(mapy, numLim = self.numLim)\\n\\t\\telse:\\n\\t\\t\\tself.comaInv = la.pinv(mapy)\",\n \"def _velocity_cylindrical2spherical(pos,vel):\\n \\n pos_cart=_position_cylindrical2cartesian(pos)\\n vel_cart=_velocity_cylindrical2cartesian(pos,vel)\\n vel_sph=_velocity_cartesian2spherical(pos_cart,vel_cart)\\n\\n return vel_sph\",\n \"def cmesh(self):\\n return numpy.meshgrid(*self.centers, indexing='ij')\",\n \"def vec2cr(self, vec):\\n T = np.array([[np.cos(vec[1]), 0, 0],\\n [0, np.sin(vec[1]), 0],\\n [0, 0, 1]])\\n tmp = np.array([vec[0], vec[0], vec[2]])\\n vec_cr = np.dot(T, tmp)\\n return vec_cr\",\n \"def ij_coordinates(self):\\n\\n x = np.arange(self.nx)\\n y = np.arange(self.ny)\\n return np.meshgrid(x, y)\",\n \"def obs_ijpos(gridfile,lons,lats,coor):\\n\\n gfh= netCDF4.Dataset(gridfile)\\n cartesian=0\\n if (coor=='r'):\\n try:\\n \\n latr=gfh.variables['lat_rho'][:,:]\\n lonr=gfh.variables['lon_rho'][:,:]\\n except:\\n latr=gfh.variables['latitude'][:,:]\\n lonr=gfh.variables['longitude'][:,:]\\n \\n\\n try:\\n xr=gfh.variables['xi_rho'][:]\\n yr=gfh.variables['eta_rho'][:]\\n except:\\n try:\\n xr=gfh.variables['x_rho'][:]\\n yr=gfh.variables['y_rho'][:]\\n except:\\n print('Neither xi_rho/eta_rho or x_rho/y_rho on file.')\\n print('This might slow down the calculations')\\n\\n\\n elif (coor=='u'):\\n latr=gfh.variables['lat_u'][:,:]\\n lonr=gfh.variables['lon_u'][:,:]\\n try:\\n xr=gfh.variables['xi_u'][:]\\n yr=gfh.variables['eta_u'][:]\\n except:\\n xr=gfh.variables['x_u'][:]\\n yr=gfh.variables['y_u'][:]\\n elif (coor=='v'):\\n latr=gfh.variables['lat_v'][:,:]\\n lonr=gfh.variables['lon_v'][:,:]\\n try:\\n xr=gfh.variables['xi_v'][:]\\n yr=gfh.variables['eta_v'][:]\\n except:\\n xr=gfh.variables['x_v'][:]\\n yr=gfh.variables['y_v'][:]\\n\\n IN = point_in_polygon(lonr, latr, lons, lats)\\n ind=np.where(IN)[0]\\n \\n if lats.size >1: \\n lons=lons[ind]; lats=lats[ind]\\n # If there's no lons, lats left at this stage, return oipos, ojpos with -999 everywhere\\n if not len(lons):\\n return np.ones_like(IN)*-999, np.ones_like(IN)*-999\\n \\n try:\\n try:\\n mapstr=str(gfh.variables['h'].getncattr('mapping'))\\n except:\\n try:\\n mapstr=str(gfh.variables['h'].getncattr('grid_mapping'))\\n except:\\n pass\\n try:\\n projstring=(gfh.variables[mapstr]).getncattr('proj4')\\n except:\\n try:\\n projstring=(gfh.variables[mapstr]).getncattr('proj4string')\\n except:\\n pass\\n try:\\n projstring=(gfh.variables['grid_mapping']).getncattr('proj4')\\n except:\\n try:\\n projstring=(gfh.variables['grid_mapping']).getncattr('proj4string')\\n except:\\n pass\\n\\n gridproj=proj.Proj(str(projstring))\\n hasproj=1\\n except:\\n hasproj=0\\n\\n # Check if lat, lon spacing is uniform\\n dx1=np.abs(lonr[0,1]-lonr[0,0])\\n dx2=np.abs(lonr[0,-1]-lonr[0,-2])\\n n=int(np.round(lonr.shape[1]/2))\\n dx3=np.abs(lonr[0,n]-lonr[0,n-1])\\n\\n dy1=np.abs(latr[1,0]-latr[0,0])\\n dy2=np.abs(latr[-1,0]-latr[-2,0])\\n n=int(np.round(latr.shape[0]/2))\\n dy3=np.abs(latr[n,0]-latr[n-1,0])\\n\\n if ( (dx1 == dx2) & (dx1==dx3) & (dx2==dx3) & (dy1 == dy2) & (dy1==dy3) & (dy2==dy3) ):\\n cartesian=1\\n gridproj=proj.Proj(\\\"+proj=latlong +datum=WGS84\\\")\\n \\n\\n \\n if hasproj:\\n dx=xr[1]-xr[0]\\n dy=yr[1]-yr[0]\\n [x,y]=gridproj(lons,lats)\\n ipos=(x-xr[0])/dx\\n jpos=(y-yr[0])/dy\\n\\n elif cartesian:\\n [x1,y1]=gridproj(lonr[0,0],latr[0,0])\\n [x2,y2]=gridproj(lonr[0,1],latr[0,1])\\n dx=x2-x1\\n [x2,y2]=gridproj(lonr[1,0],latr[1,0])\\n dy=y2-y1\\n [x,y]=gridproj(lons,lats)\\n [x0,y0]=gridproj(lonr[0,0],latr[0,0])\\n\\n ipos=(x-x0)/dx\\n jpos=(y-y0)/dy\\n\\n else:\\n x=np.linspace(0,lonr.shape[1]-1,lonr.shape[1])\\n y=np.linspace(0,lonr.shape[0]-1,lonr.shape[0])\\n xi=np.zeros_like(lonr); yi=np.zeros([lonr.shape[1],lonr.shape[0]])\\n xi[:,:]=x; yi[:,:]=y; yi=np.swapaxes(yi,1,0)\\n zi=scipy.interpolate.griddata((lonr.flatten(),latr.flatten()),xi.flatten(),(lons,lats))\\n ipos=zi\\n zi=scipy.interpolate.griddata((lonr.flatten(),latr.flatten()),yi.flatten(),(lons,lats))\\n jpos=zi\\n \\n if 'ind' in locals():\\n oipos=np.ones(IN.shape)*-999.; ojpos=np.ones(IN.shape)*-999.\\n oipos[ind]=ipos; ojpos[ind]=jpos\\n else:\\n oipos=ipos\\n ojpos=jpos\\n if not IN:\\n oipos = np.array([-999.])\\n ojpos = np.array([-999.])\\n gfh.close()\\n return oipos,ojpos\",\n \"def convert_coords_cart_sphere(coords_cart):\\n shape = coords_cart.shape\\n coords = coords_cart.reshape(3,-1)\\n\\n lat, lon, alt = np.zeros_like(coords)\\n for i in range(coords.shape[1]):\\n p_rec = [coords[0, i], coords[1, i], coords[2, i]]\\n p_lat = sp.spiceypy.reclat(p_rec)\\n alt[i], lon[i], lat[i] = p_lat\\n \\n lat = lat*180/np.pi\\n lon = lon*180/np.pi\\n alt = alt - mars_r \\n\\n coords_sphere = np.array([lat, lon, alt]).reshape(shape)\\n return coords_sphere\",\n \"def vector(self):\\n return np.array([self.lat, self.lng])\",\n \"def vec2cr(self, vec):\\n T = np.array([[np.sin(vec[1])*np.cos(vec[2]), 0, 0],\\n [0, np.sin(vec[1])*np.sin(vec[2]), 0],\\n [0, 0, np.cos(vec[1])]])\\n tmp = np.array([vec[0], vec[0], vec[0]])\\n return np.dot(T, tmp)\",\n \"def genVector(width, height, x_mult=1, y_mult=1):\\n centerX = (width - 1) / 2.0\\n centerY = (height - 1) / 2.0\\n\\n return [[int(math.sqrt(math.pow(x - centerX, 2 * x_mult) + math.pow(y - centerY, 2 * y_mult))) for x in range(width)] for y in range(height)]\",\n \"def cartesian_To_Center(self, x, y, z):\\n\\n if x > 0.0 and -self.L_cap <= y <= 0.0:\\n s = self.L_cap + y\\n xc = x - self.rb\\n yc = z\\n else:\\n theta = full_arctan2(y, x)\\n if theta <= self.ang:\\n s = theta * self.rb + self.L_cap\\n xc = np.sqrt(x ** 2 + y ** 2) - self.rb\\n yc = z\\n elif self.ang < theta <= 2 * np.pi: # i'm being lazy here and not limiting the real end\\n x0, y0 = np.cos(self.ang) * self.rb, np.sin(self.ang) * self.rb\\n thetaEndPerp = np.pi - np.arctan(-1 / np.tan(self.ang))\\n x, y = x - x0, y - y0\\n deltaS, xc = np.cos(thetaEndPerp) * x + np.sin(-thetaEndPerp) * y, np.sin(thetaEndPerp) * x + np.cos(\\n thetaEndPerp) * y\\n yc = z\\n xc = -xc\\n s = (self.ang * self.rb + self.L_cap) + deltaS\\n else:\\n raise ValueError\\n return s, xc, yc\",\n \"def getCartesianPoints(rTheta, center):\\n if rTheta.ndim == 2:\\n x = rTheta[:, 0] * np.cos(rTheta[:, 1]) + center[0]\\n y = rTheta[:, 0] * np.sin(rTheta[:, 1]) + center[1]\\n else:\\n x = rTheta[0] * np.cos(rTheta[1]) + center[0]\\n y = rTheta[0] * np.sin(rTheta[1]) + center[1]\\n\\n return np.array([x, y]).T\",\n \"def get_valid_index_from_cartesian_grid(cart_grid, lons, lats,\\n radius_of_influence):\\n\\n def _get_lons(x, y):\\n return np.rad2deg(np.arccos(x / np.sqrt(x ** 2 + y ** 2))) * np.sign(y)\\n\\n def _get_lats(z):\\n return 90 - np.rad2deg(np.arccos(z / R))\\n\\n # Get sides of target grid and transform to lon lats\\n lons_side1 = _get_lons(cart_grid[0, :, 0], cart_grid[0, :, 1])\\n lons_side2 = _get_lons(cart_grid[:, -1, 0], cart_grid[:, -1, 1])\\n lons_side3 = _get_lons(cart_grid[-1, ::-1, 0], cart_grid[-1, ::-1, 1])\\n lons_side4 = _get_lons(cart_grid[::-1, 0, 0], cart_grid[::-1, 0, 1])\\n\\n lats_side1 = _get_lats(cart_grid[0, :, 2])\\n lats_side2 = _get_lats(cart_grid[:, -1, 2])\\n lats_side3 = _get_lats(cart_grid[-1, ::-1, 2])\\n lats_side4 = _get_lats(cart_grid[::-1, 0, 2])\\n\\n valid_index = _get_valid_index(lons_side1, lons_side2, lons_side3, lons_side4,\\n lats_side1, lats_side2, lats_side3, lats_side4,\\n lons, lats, radius_of_influence)\\n\\n return valid_index\",\n \"def xyz(self) -> np.ndarray:\\n return self._vector[0:3]\",\n \"def clinopyroxene_92():\\n\\n rho = 3327.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 257.3; C[0,1] = 85.9; C[0,2] = 76.2; C[0,3] = 0.; C[0,4] = 7.1; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = 216.2; C[1,2] = 71.8; C[1,3] = 0.; C[1,4] = 13.3; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 260.2; C[2,3] = 0.; C[2,4] = 33.7; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 80.2; C[3,4] = 0.; C[3,5] = 10.2\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 70.6; C[4,5] = 0.\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 85.8\\n\\n return C, rho\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64601624","0.6313934","0.6292211","0.618065","0.61797065","0.6153555","0.6128813","0.6096424","0.60606337","0.5981715","0.5911841","0.5836146","0.5835889","0.5830214","0.5827372","0.58222485","0.5816691","0.58102924","0.5799981","0.5760489","0.5751354","0.5748558","0.5740479","0.5717262","0.5714478","0.57007945","0.56984246","0.56829655","0.56776106","0.5676023","0.5672115","0.56676286","0.5665785","0.56495583","0.56142163","0.56037945","0.55991584","0.55893624","0.5581877","0.5577612","0.5573838","0.55519015","0.55320084","0.55216295","0.55012953","0.5501059","0.5499086","0.549157","0.5487052","0.5468904","0.5457314","0.5449211","0.5448474","0.5440645","0.5430514","0.5429232","0.5429023","0.5418254","0.5406763","0.5393729","0.5390427","0.5389233","0.53799546","0.5375552","0.53645676","0.5363169","0.5362318","0.5357137","0.5350047","0.53295374","0.53186387","0.531567","0.5305278","0.5304285","0.5290035","0.52839786","0.52764845","0.525828","0.525828","0.52554756","0.5255068","0.524927","0.523444","0.52331614","0.5230122","0.52154994","0.5210283","0.5207927","0.5203832","0.51977295","0.5195773","0.5193249","0.51853085","0.51827264","0.51771927","0.5174082","0.5172851","0.51648176","0.5159826","0.51567745","0.515663"],"string":"[\n \"0.64601624\",\n \"0.6313934\",\n \"0.6292211\",\n \"0.618065\",\n \"0.61797065\",\n \"0.6153555\",\n \"0.6128813\",\n \"0.6096424\",\n \"0.60606337\",\n \"0.5981715\",\n \"0.5911841\",\n \"0.5836146\",\n \"0.5835889\",\n \"0.5830214\",\n \"0.5827372\",\n \"0.58222485\",\n \"0.5816691\",\n \"0.58102924\",\n \"0.5799981\",\n \"0.5760489\",\n \"0.5751354\",\n \"0.5748558\",\n \"0.5740479\",\n \"0.5717262\",\n \"0.5714478\",\n \"0.57007945\",\n \"0.56984246\",\n \"0.56829655\",\n \"0.56776106\",\n \"0.5676023\",\n \"0.5672115\",\n \"0.56676286\",\n \"0.5665785\",\n \"0.56495583\",\n \"0.56142163\",\n \"0.56037945\",\n \"0.55991584\",\n \"0.55893624\",\n \"0.5581877\",\n \"0.5577612\",\n \"0.5573838\",\n \"0.55519015\",\n \"0.55320084\",\n \"0.55216295\",\n \"0.55012953\",\n \"0.5501059\",\n \"0.5499086\",\n \"0.549157\",\n \"0.5487052\",\n \"0.5468904\",\n \"0.5457314\",\n \"0.5449211\",\n \"0.5448474\",\n \"0.5440645\",\n \"0.5430514\",\n \"0.5429232\",\n \"0.5429023\",\n \"0.5418254\",\n \"0.5406763\",\n \"0.5393729\",\n \"0.5390427\",\n \"0.5389233\",\n \"0.53799546\",\n \"0.5375552\",\n \"0.53645676\",\n \"0.5363169\",\n \"0.5362318\",\n \"0.5357137\",\n \"0.5350047\",\n \"0.53295374\",\n \"0.53186387\",\n \"0.531567\",\n \"0.5305278\",\n \"0.5304285\",\n \"0.5290035\",\n \"0.52839786\",\n \"0.52764845\",\n \"0.525828\",\n \"0.525828\",\n \"0.52554756\",\n \"0.5255068\",\n \"0.524927\",\n \"0.523444\",\n \"0.52331614\",\n \"0.5230122\",\n \"0.52154994\",\n \"0.5210283\",\n \"0.5207927\",\n \"0.5203832\",\n \"0.51977295\",\n \"0.5195773\",\n \"0.5193249\",\n \"0.51853085\",\n \"0.51827264\",\n \"0.51771927\",\n \"0.5174082\",\n \"0.5172851\",\n \"0.51648176\",\n \"0.5159826\",\n \"0.51567745\",\n \"0.515663\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94482,"cells":{"query":{"kind":"string","value":"Converts cartesian normal vectors into MillerBravais plane indices"},"document":{"kind":"string","value":"def mvector(B, c):\n # for Sun Mg Potential: c=1.6281689374348\n A = np.zeros(shape=4)\n A[0] = (2 / 3) * B[0]\n A[1] = 0.5 * ((2 / sqrt(3)) * B[1] - A[0])\n A[2] = -A[0] - A[1]\n A[3] = B[2] / c\n return A"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def plane_equation(point_a, point_b, point_c):\n v1 = np.subtract(point_a, point_c)\n v2 = np.subtract(point_a, point_b)\n normal = np.cross(v1, v2)\n # print 'b4 norm', normal\n unit_normal = norm_vect(normal)\n # print 'unityyy', unit_normal\n return unit_normal","def normal_vector(origin, vectors):\n return np.cross(vectors[0] - origin, vectors[1] - origin)","def MillerNormalVectors_110():\r\n k_110 = np.array([[1, 1, 0], [0, 1, 1], [1, 0, 1],\r\n [1, -1, 0], [0, 1, -1], [-1, 0, 1]])/np.sqrt(2.0)\r\n return np.array([k_110[0, :], k_110[1, :], k_110[2, :],\r\n k_110[3, :], k_110[4, :], k_110[5, :],\r\n -k_110[0, :], -k_110[1, :], -k_110[2, :],\r\n -k_110[3, :], -k_110[4, :], -k_110[5, :]])","def compute_normalvect(self):\n normvect = np.zeros((len(self.tri_pnts),3,3))\n zvec = np.array([0, 0, 1])\n for itri, tri in enumerate(self.tri_pnts):\n #import pdb; pdb.set_trace()\n tri0, tri1, tri2 = tri\n x1,y1 = self.points[tri1]-self.points[tri0]\n v1 = np.array([x1,y1,0])\n x2,y2 = self.points[tri2]-self.points[tri1]\n v2 = np.array([x2,y2,0])\n x3,y3 = self.points[tri0]-self.points[tri2]\n v3 = np.array([x3,y3,0])\n v1 = v1/np.linalg.norm(v1)\n v2 = v2/np.linalg.norm(v2)\n v3 = v3/np.linalg.norm(v3)\n #import pdb; pdb.set_trace()\n normvect[itri,:,:] = np.cross(v1,zvec), np.cross(v2,zvec), np.cross(v3,zvec)\n #import pdb; pdb.set_trace()\n return normvect","def MillerNormalVectors_111():\r\n k_111 = np.array(\r\n [[1, 1, 1], [-1, 1, 1], [1, -1, 1], [1, 1, -1]])/np.sqrt(3.0)\r\n return np.array([k_111[0, :], k_111[1, :], k_111[2, :], k_111[3, :],\r\n -k_111[0, :], -k_111[1, :], -k_111[2, :], -k_111[3, :]])","def PlaneNormalVector(h, k, l):\r\n vec = np.array([h, k, l])\r\n return vec/np.linalg.norm(vec)","def get_normal_vector_of_plane(p1, p2, p3):\n v12 = np.array(p1) - np.array(p2)\n v13 = np.array(p1) - np.array(p3)\n nvec = np.cross(v12, v13)\n ## print 'norm: '+str(np.linalg.norm(nvec))\n return nvec / np.linalg.norm(nvec)","def unit_normals(self):\n return np.stack(self.centers_cartesian(), axis=-1)","def project_onto_plane(vect):\n x, y, z = vect\n \n return (x, y, 0.)","def plane_from_points(a, b, c):\n ab = subtract_vectors(b, a)\n ac = subtract_vectors(c, a)\n n = normalize_vector(cross_vectors(ab, ac))\n return a, n","def MillerNormalVectors_100():\r\n k_100 = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])\r\n return np.array([k_100[0, :], k_100[1, :], k_100[2, :],\r\n -k_100[0, :], -k_100[1, :], -k_100[2, :]])","def _generate_meshes(self, vectors, width):\n centers = np.repeat(vectors, 2, axis=0)\n offsets = segment_normal(vectors[::2, :], vectors[1::2, :])\n offsets = np.repeat(offsets, 4, axis=0)\n signs = np.ones((len(offsets), 2))\n signs[::2] = -1\n offsets = offsets*signs\n\n vertices = centers + width*offsets/2\n triangles = np.array([[2*i, 2*i+1, 2*i+2] if i % 2 == 0 else\n [2*i-1, 2*i, 2*i+1] for i in\n range(len(vectors))]).astype(np.uint32)\n\n return vertices, triangles","def project_vectors_ab(a, b):\n # print('dot = ', np.dot(a,b))\n # print('norm = ', np.linalg.norm(b))\n return np.dot(a, b) / np.linalg.norm(b)","def planeIndex(plane, center = False):\n return (planeBase(center = center) * np.array(plane)).sum()","def project_vectors(self, vectors):\n X = vectors - self._mean\n return np.dot(X, self.components.T)","def unit_vectors(self):\n # return {'comp1': CartesianRepresentation(...),\n # 'comp2': CartesianRepresentation(...),\n # 'comp3': CartesianRepresentation(...)}\n raise Exception(\"Not yet implemented\")","def normal_vectors(ATOM_list, frame, number_of_atoms, number_of_molecules, number_of_vectors, centerlist, referencelist, boxX, boxY, boxZ):\t\n\tNORMAL_VECTORS_out=open(\"normalvectors.xyz\",'a')\n\t\n\tNORMAL_VECTORS_check=open(\"check_normalvectors.xyz\",'a')\n\t\n\tANGLEDIST_VECTORS_out=open(\"angle_dist_vectors.xyz\",'a')\n\t\n\t\n\tVorzugsrichtung_out=open(\"sum_over_all_normalvectors.dat\",'a')\n\t\n\t\n\t\n\tNORMAL_VECTORS_check.write(str( (number_of_vectors*(2 + int(len(referencelist))) )*number_of_molecules )+'\\n')\n\tNORMAL_VECTORS_check.write(str(frame)+'\\n')\n\t\n\tNORMAL_VECTORS_out.write(str( (number_of_vectors*2)*number_of_molecules )+'\\n')\n\tNORMAL_VECTORS_out.write(str(frame)+'\\n')\n\n\tANGLEDIST_VECTORS_out.write(str( (number_of_vectors*2)*number_of_molecules )+'\\n')\n\tANGLEDIST_VECTORS_out.write(str(frame)+'\\n')\n\t\n\tvorzugsvektor = np.asarray([0,0,0])\n\treference=0\n\t\n\t\n\tfor l in range(0,number_of_molecules):\n\t\tfor vec_count in range(0,number_of_vectors):\n\t\t\tr = []\n\t\t\t#get the 'middle' of the DPI molecule\n\t\t\t\n\t\t\n\t\t\t#get geometric center\n\t\t\tcenter=np.asarray([0,0,0])\n\t\t\t#append all vectors defining the center\n\t\t\tfor i in range(len(centerlist[vec_count])):\n\t\t\t\t# x y z\n\t\t\t\tr.append( np.asarray( [ ATOM_list[centerlist[vec_count][i] + reference][1],ATOM_list[centerlist[vec_count][i] + reference][2],ATOM_list[centerlist[vec_count][i] + reference][3] ] ) ) \n\t\t\t\tcenter = center + r[i]\n\t\t\tcenter = center / len(centerlist[vec_count])\n\t\t\n\t\t\t#calculate all reference vectors\n\t\t\tr=[]\n\t\t\tfor i in range(len(referencelist[vec_count])):\n\t\t\t\tr.append(np.asarray( [ ATOM_list[referencelist[vec_count][i] + reference][1],ATOM_list[referencelist[vec_count][i] + reference][2],ATOM_list[referencelist[vec_count][i] + reference][3] ] ) )\n\t\t\n\t\t\t#get the cross products\n\t\t\tnormal_vec= np.asarray([0,0,0])\n\t\t\tfor i in range(len(r)):\n\t\t\t\tif (i<(len(r)-1)):\n\t\t\t\t\t\n\t\t\t\t\t#minimum image convenction\n\t\t\t\t\tif ( abs(r[i][0]-center[0]) < abs(r[i][0]-center[0]+boxX) ) and ( abs(r[i][0]-center[0]) < abs(r[i][0]-center[0]-boxX) ):\n\t\t\t\t\t\tdx = r[i][0]-center[0]\n\t\t\t\t\telif (abs(r[i][0]-center[0]+boxX) < abs(r[i][0]-center[0]-boxX) ):\n\t\t\t\t\t\tdx = r[i][0]-center[0]+boxX\n\t\t\t\t\telse:\n\t\t\t\t\t\tdx = r[i][0]-center[0]-boxX\n\t\t\t\t\t\n\t\t\t\t\tif ( abs(r[i][1]-center[1]) < abs(r[i][1]-center[1]+boxY) ) and ( abs(r[i][1]-center[1]) < abs(r[i][1]-center[1]-boxY) ):\n\t\t\t\t\t\tdy = r[i][1]-center[1]\n\t\t\t\t\telif (abs(r[i][1]-center[1]+boxY) < abs(r[i][1]-center[1]-boxY) ):\n\t\t\t\t\t\tdy = r[i][1]-center[1]+boxY\n\t\t\t\t\telse:\n\t\t\t\t\t\tdy = r[i][1]-center[1]-boxY\n\t\t\t\t\t\t\n\t\t\t\t\tif ( abs(r[i][2]-center[2]) < abs(r[i][2]-center[2]+boxZ) ) and ( abs(r[i][2]-center[2]) < abs(r[i][2]-center[2]-boxZ) ):\n\t\t\t\t\t\tdz = r[i][2]-center[2]\n\t\t\t\t\telif (abs(r[i][2]-center[2]+boxZ) < abs(r[i][2]-center[2]-boxZ) ):\n\t\t\t\t\t\tdz = r[i][2]-center[2]+boxZ\n\t\t\t\t\telse:\n\t\t\t\t\t\tdz = r[i][2]-center[2]-boxZ\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t#minimum image convenction\n\t\t\t\t\tif ( abs(r[i+1][0]-center[0]) < abs(r[i+1][0]-center[0]+boxX) ) and ( abs(r[i+1][0]-center[0]) < abs(r[i+1][0]-center[0]-boxX) ):\n\t\t\t\t\t\tdx2 = r[i+1][0]-center[0]\n\t\t\t\t\telif (abs(r[i+1][0]-center[0]+boxX) < abs(r[i+1][0]-center[0]-boxX) ):\n\t\t\t\t\t\tdx2 = r[i+1][0]-center[0]+boxX\n\t\t\t\t\telse:\n\t\t\t\t\t\tdx2 = r[i+1][0]-center[0]-boxX\n\t\t\t\t\t\n\t\t\t\t\tif ( abs(r[i+1][1]-center[1]) < abs(r[i+1][1]-center[1]+boxY) ) and ( abs(r[i+1][1]-center[1]) < abs(r[i+1][1]-center[1]-boxY) ):\n\t\t\t\t\t\tdy2 = r[i+1][1]-center[1]\n\t\t\t\t\telif (abs(r[i+1][1]-center[1]+boxY) < abs(r[i+1][1]-center[1]-boxY) ):\n\t\t\t\t\t\tdy2 = r[i+1][1]-center[1]+boxY\n\t\t\t\t\telse:\n\t\t\t\t\t\tdy2 = r[i+1][1]-center[1]-boxY\n\t\t\t\t\t\t\n\t\t\t\t\tif ( abs(r[i+1][2]-center[2]) < abs(r[i+1][2]-center[2]+boxZ) ) and ( abs(r[i+1][2]-center[2]) < abs(r[i+1][2]-center[2]-boxZ) ):\n\t\t\t\t\t\tdz2 = r[i+1][2]-center[2]\n\t\t\t\t\telif (abs(r[i+1][2]-center[2]+boxZ) < abs(r[i+1][2]-center[2]-boxZ) ):\n\t\t\t\t\t\tdz2 = r[i+1][2]-center[2]+boxZ\n\t\t\t\t\telse:\n\t\t\t\t\t\tdz2 = r[i+1][2]-center[2]-boxZ\n\t\t\t\t\t\n\t\t\t\t\tvec1=np.asarray([dx,dy,dz])\n\t\t\t\t\tvec2=np.asarray([dx2,dy2,dz2])\n\t\t\t\t\t#dy = r[i][1]-center[1]\n\t\t\t\t\t#dz = r[i][2]-center[2]\n\t\t\t\t\t#normal_vec = normal_vec + np.cross(r[i]-center, r[i+1]-center)\n\t\t\t\t\tnormal_vec = normal_vec + np.cross(vec1, vec2)/np.linalg.norm( np.cross(vec1, vec2) )\n\t\t\t\telif ( i==len(r) ):\n\t\t\t\t\t\n\t\t\t\t\t#minimum image convenction\n\t\t\t\t\tdx = min( abs(r[i][0]-center[0]), abs(r[i][0]-center[0]+boxX), abs(r[i][0]-center[0]-boxX) )\n\t\t\t\t\tdy = min( abs(r[i][1]-center[1]), abs(r[i][1]-center[1]+boxX), abs(r[i][1]-center[1]-boxX) )\n\t\t\t\t\tdz = min( abs(r[i][2]-center[2]), abs(r[i][2]-center[2]+boxX), abs(r[i][2]-center[2]-boxX) )\n\t\t\t\t\t\n\t\t\t\t\tdx2 = min( abs(r[0][0]-center[0]), abs(r[0][0]-center[0]+boxX), abs(r[0][0]-center[0]-boxX) )\n\t\t\t\t\tdy2 = min( abs(r[0][1]-center[1]), abs(r[0][1]-center[1]+boxX), abs(r[0][1]-center[1]-boxX) )\n\t\t\t\t\tdz2 = min( abs(r[0][2]-center[2]), abs(r[0][2]-center[2]+boxX), abs(r[0][2]-center[2]-boxX) )\n\t\t\t\t\t\n\t\t\t\t\tvec1=np.asarray([dx,dy,dz])\n\t\t\t\t\tvec2=np.asarray([dx2,dy2,dz2])\n\t\t\t\t\t#dy = r[i][1]-center[1]\n\t\t\t\t\t#dz = r[i][2]-center[2]\n\t\t\t\t\t#normal_vec = normal_vec + np.cross(r[i]-center, r[i+1]-center)\n\t\t\t\t\tnormal_vec = normal_vec + np.cross(vec1, vec2)/np.linalg.norm(np.cross(vec1, vec2))\n\t\t\t\t\t#normal_vec = normal_vec + np.cross(r[i]-center, r[0]-center) \n\t\t\n\t\t\t#normalize\n\t\t\tnormal_vec = normal_vec/np.linalg.norm(normal_vec)\n\t\t\n\t\t\t#\t#direction vectors\n\t\t\t#\tdir_vec1 = np.asarray([r[6][0],r[6][1],r[6][2]])\n\t\t\t#\tdir_vec2 = np.asarray([r[7][0],r[7][1],r[7][2]])\n\t\t\t#\tdir_vec3 = np.asarray([r[8][0],r[8][1],r[8][2]])\n\t\t\t#\tdir_vec4 = np.asarray([r[9][0],r[9][1],r[9][2]])\n\t\t\t#\tdir_vec = (dir_vec1 + dir_vec2 + dir_vec3 + dir_vec4)/4.0\n\t\t\t#\tdir_vec = mittelpunkt_dpi - dir_vec\t\t\t\n\n\t\t\t#change direction according to bending\n\t\t\t#\tif normal_vec[0]!=0 and dir_vec[0]!=0:\n\t\t\t#\t\tif normal_vec[0]/abs(normal_vec[0])!=dir_vec[0]/abs(dir_vec[0]):\n\t\t\t#\t\t\tnormal_vec[0] = -normal_vec[0]\n\t\t\t#\tif normal_vec[1]!=0 and dir_vec[1]!=0:\n\t\t#\t\t\tif normal_vec[1]/abs(normal_vec[1])!=dir_vec[1]/abs(dir_vec[1]):\n\t\t#\t\t\t\tnormal_vec[1] = -normal_vec[1]\n\t\t#\t\tif normal_vec[2]!=0 and dir_vec[2]!=0:\n\t\t#\t\t\tif normal_vec[2]/abs(normal_vec[2])!=dir_vec[2]/abs(dir_vec[2]):\n\t\t#\t\t\t\tnormal_vec[2] = -normal_vec[2]\n\n\t\t\t\n\t\t\t#check for a vorzugsvektor\n\t\t\tvorzugsvektor = vorzugsvektor + normal_vec\n\t\t\tNORMAL_VECTORS_out.write('C' +'\t'+ str((center)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tNORMAL_VECTORS_out.write('O' +'\t'+ str((center+normal_vec)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tANGLEDIST_VECTORS_out.write('C' +'\t'+ str((center)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tANGLEDIST_VECTORS_out.write('H' +'\t'+ str((normal_vec)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tNORMAL_VECTORS_check.write('C' +'\t'+ str((center)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tNORMAL_VECTORS_check.write('O' +'\t'+ str((center+normal_vec)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tNORMAL_VECTORS_check.write('H' +'\t'+ str((normal_vec)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tfor i in range(len(referencelist[vec_count])):\n\t\t\t\tNORMAL_VECTORS_check.write('N' +'\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][1])+'\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][2])+'\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][3])+ '\\n')\n\n\t\t#always skip 1 entire molecule forward\n\t\treference=reference + number_of_atoms/number_of_molecules\n\t\t\n\t#calculate a vorzugsvektor as sum over DIPBI normal vectors divided by number of DPBI vectors\n\tvorzugsvektor = vorzugsvektor/(number_of_vectors*frames*number_of_molecules)\n\tVorzugsrichtung_out.write(str(frame) + ' ' + str((vorzugsvektor)).replace('[', '').replace(']','')+'\\n')\n\tNORMAL_VECTORS_out.close()\n\tNORMAL_VECTORS_check.close()\n\treturn","def _fit_plane_to_point_cloud(\n points_xyz: NDArrayFloat,\n) -> Tuple[float, float, float, float]:\n center_xyz: NDArrayFloat = np.mean(points_xyz, axis=0)\n out: Tuple[NDArrayFloat, NDArrayFloat, NDArrayFloat] = np.linalg.svd(\n points_xyz - center_xyz\n )\n vh = out[2]\n\n # Get the unitary normal vector\n a, b, c = float(vh[2, 0]), float(vh[2, 1]), float(vh[2, 2])\n d: float = -np.dot([a, b, c], center_xyz)\n return (a, b, c, d)","def vector_line(self):\n assert len(self.xcoords) == 2\n diff_x = self.xcoords[1] - self.xcoords[0]\n diff_z = self.zcoords[1] - self.zcoords[0]\n vec = np.hstack((diff_x, diff_z))\n return vec","def uvmap(self, p):\n # bottom left corner of the plane\n p00 = self.position - (self.sx * self.n0) / 2 - (self.sy * self.n1) / 2\n dif_vector = p - p00\n u = np.dot(dif_vector, self.n0) / self.sx\n v = np.dot(dif_vector, self.n1) / self.sy\n return u, v","def point_form(boxes):\n return torch.cat((boxes[:, :2] - boxes[:, 2:] / 2, boxes[:, :2] + boxes[:, 2:] / 2), 1)","def point_form(boxes):\n return torch.cat((boxes[:, :2] - boxes[:, 2:] / 2, boxes[:, :2] + boxes[:, 2:] / 2), 1)","def plot_plane(unit_normal, x_array, y_array, fore):\n # print'unit normal = ', unit_normal\n z = (((unit_normal[0] * (fore[0] - x_array)) + (unit_normal[1] * (fore[1] - y_array))) / unit_normal[2]) + fore[2]\n # print 'plane numbers\\n', z\n return z","def uv(vec):\n return vec / sqrt(dot(vec, vec))","def vec(self):\r\n\r\n xv = np.arange(self.dx / 2, self.lx, self.dx)\r\n yv = np.arange(-self.ly / 2 + self.dy / 2, self.ly / 2, self.dy)\r\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\r\n\r\n if self.ox != 0:\r\n xv = np.arange(self.ox, self.lx + self.ox, self.dx)\r\n yv = np.arange(self.oy, self.ly + self.oy, self.dy)\r\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\r\n\r\n return xv, yv, zv","def _normal_vector(o, p0_3d, p1_3d):\n # The vector between middle point of v1-v2 and object center location\n # is the normal vector I'm looking for\n vn = p0_3d.lerp(p1_3d, 0.5) - o.matrix_world.translation\n # normalize so I can to length computation on it\n vn.normalize()\n return vn","def project_vectors(self, vectors):\n return np.dot(vectors, self.components.T)","def generate_normals(v1, v2, v3, normalize_result=True):\n # make vectors relative to v2\n # we assume opengl counter-clockwise ordering\n a = v1 - v2\n b = v3 - v2\n n = cross(b, a)\n if normalize_result:\n n = normalize(n)\n return n","def find_plane_angles(self, roof_motor_position):\n\n # Calcolo il punto mediano tra i vertici 2 e 3\n pc_x = (self.roof_vertex_x[1] + self.roof_vertex_x[2]) / 2\n pc_y = (self.roof_vertex_y[1] + self.roof_vertex_y[2]) / 2\n pc_z = (self.roof_vertex_z[1] + self.roof_vertex_z[2]) / 2\n\n # Questa non so cosa sia\n base_r = [[self.roof_vertex_x[0] - pc_x, self.roof_vertex_y[0] - pc_y, self.roof_vertex_z[0] - pc_z],\n [self.roof_vertex_x[1] - pc_x, self.roof_vertex_y[1] - pc_y, self.roof_vertex_z[1] - pc_z],\n [0.0, 0.0, 0.0]]\n\n # Questa e' la costruzione di una matrice\n mat_rot = [[0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0]]\n\n # Non so quale operazione è implementata, ma a me servono solo tre elementi, j=2, i=0,1, j=1, i=0\n # Primo elemento, j=1, i=0\n mr = math.sqrt((base_r[0][0] ** 2) + (base_r[0][1] ** 2) + (base_r[0][2] ** 2))\n mat_rot[1][0] = base_r[0][1] / mr\n # Secondo elemento, j=2, i=0\n mat_rot[2][0] = base_r[0][2] / mr\n # Terzo elemento, j=2, i=1\n mr = math.sqrt((base_r[1][0] ** 2) + (base_r[1][1] ** 2) + (base_r[1][2] ** 2))\n mat_rot[2][1] = base_r[1][2] / mr\n\n # In alternativa posso calcolare tutti gli elementi della matrice\n # for i in range(2):\n # mr = math.sqrt((base_r[i][0] ** 2) + (base_r[i][1] ** 2) + (base_r[i][2] ** 2))\n # for j in range(3):\n # base_r[i][j] /= mr\n # mat_rot[j][i] = base_r[i][j]\n\n # Sono elementi della matrice non utilizzati\n # base_r[2][0] = +base_r[1][1] * base_r[0][2] - base_r[0][1] * base_r[1][2]\n # base_r[2][1] = -base_r[1][0] * base_r[0][2] + base_r[0][0] * base_r[1][2]\n # base_r[2][2] = +base_r[1][0] * base_r[0][1] - base_r[0][0] * base_r[1][1]\n # for i in range(3):\n # mat_rot[i][2] = base_r[2][i]\n\n # Qui estraggo la terna di Tait-Bryan angles usata internamente, la Z1Y2X3\n k17 = mat_rot[2][0]\n k16 = mat_rot[1][0]\n l17 = mat_rot[2][1]\n m20 = math.asin(k17)\n i23 = math.cos(m20)\n i24 = k16 / i23\n i25 = l17 / i23\n m19 = math.asin(i24)\n self.zyx1_r = m19 + roof_motor_position\n self.zyx2_r = math.asin(k17)\n self.zyx3_r = math.asin(i25)\n self.zyx3 = self.zyx3_r / Kinematic.M_TO_RAD\n self.zyx2 = self.zyx2_r / Kinematic.M_TO_RAD\n self.zyx1 = self.zyx1_r / Kinematic.M_TO_RAD\n angles = self.zyx_r_to_xyz(self.zyx3_r, self.zyx2_r, self.zyx1_r)\n self.xyz1 = angles[2]\n self.xyz2 = angles[0]\n self.xyz3 = angles[1]\n self.xyz1_r = angles[5]\n self.xyz2_r = angles[3]\n self.xyz3_r = angles[4]","def normal(self) -> Vec:\n # The three points are in clockwise order, so compute differences\n # in the clockwise direction, then cross to get the normal.\n point_1 = self.planes[1] - self.planes[0]\n point_2 = self.planes[2] - self.planes[1]\n\n return Vec.cross(point_1, point_2).norm()","def test_perpendicular_to_vectors():\n random_state = np.random.RandomState(0)\n a = pr.norm_vector(pr.random_vector(random_state))\n a1 = pr.norm_vector(pr.random_vector(random_state))\n b = pr.norm_vector(pr.perpendicular_to_vectors(a, a1))\n c = pr.norm_vector(pr.perpendicular_to_vectors(a, b))\n assert_almost_equal(pr.angle_between_vectors(a, b), np.pi / 2.0)\n assert_almost_equal(pr.angle_between_vectors(a, c), np.pi / 2.0)\n assert_almost_equal(pr.angle_between_vectors(b, c), np.pi / 2.0)\n assert_array_almost_equal(pr.perpendicular_to_vectors(b, c), a)\n assert_array_almost_equal(pr.perpendicular_to_vectors(c, a), b)","def get_normals(self):\n c, s = np.cos(self.eangles), np.sin(self.eangles)\n r = np.array([[c, -s], [s, c]])\n us = np.array([[1, 0], [0, 1], [-1, 0], [0, -1]])\n nsyms = 4 if self.halfexts[0] == self.halfexts[1] else 2\n return [(np.dot(r, u), nsyms) for u in us]","def invgeochart(w):\n # u = torch.asin(w[...,2])\n u = torch.acos(w[...,2])\n # v = torch.acos(w[...,0]/torch.cos(u))\n v = torch.atan(w[...,1]/w[...,0])\n return torch.stack((u,v+np.pi))","def unit_normals(p,q,r): \n vx1 = p[0] - r[0] # x1 - x3. \n vy1 = p[1] - r[1] # y1 - y3. \n vz1 = p[2] - r[2] # z1 - z3. \n\n vx2 = q[0] - r[0] # x2 - x3. \n vy2 = q[1] - r[1] # y2 - y3. \n vz2 = q[2] - r[2] # z2 - z3. \n\n vnx = vy1*vz2 - vz1*vy2 \n vny = vz1*vx2 - vx1*vz2 \n vnz = vx1*vy2 - vy1*vx2 \n\n len_vn = math.sqrt(vnx*vnx + vny*vny + vnz*vnz) \n vnx = vnx/len_vn \n vny = vny/len_vn \n vnz = vnz/len_vn \n\n return vnx, vny, vnz","def vertexes(self):\n theta = self.orientation\n shifts = np.array([np.cos(theta), np.sin(theta)]) * self.a\n return self.coords + (shifts[:, None] * [-1, 1]).T","def miller(points):\r\n\r\n N = np.cross(points[1] - points[0], points[2] - points[0])\r\n O = np.array([0, 0, 0])\r\n P = points[0] # point of plane\r\n Ccs = map(np.array, [[1.0, 0, 0], [0, 1.0, 0], [0, 0, 1.0]])\r\n segments = ([np.dot(P - O, N) / np.dot(ort, N) if np.dot(ort, N) != 0 else\r\n np.nan for ort in Ccs])\r\n if any(x == 0 for x in segments): # Plane goes through origin.\r\n vertices = [ # top:\r\n np.array([1.0, 1.0, 1.0]),\r\n np.array([0.0, 0.0, 1.0]),\r\n np.array([1.0, 0.0, 1.0]),\r\n np.array([0.0, 1.0, 1.0]),\r\n # bottom, except 0,0,0:\r\n np.array([1.0, 0.0, 0.0]),\r\n np.array([0.0, 1.0, 0.0]),\r\n np.array([1.0, 1.0, 1.0]),\r\n ]\r\n for vertex in vertices:\r\n if np.dot(vertex - O, N) != 0: # vertex not in plane\r\n new_origin = vertex\r\n break\r\n # obtain new axes with center in new origin\r\n X = np.array([1 - new_origin[0], new_origin[1], new_origin[2]])\r\n Y = np.array([new_origin[0], 1 - new_origin[1], new_origin[2]])\r\n Z = np.array([new_origin[0], new_origin[1], 1 - new_origin[2]])\r\n new_Ccs = [X - new_origin, Y - new_origin, Z - new_origin]\r\n segments = ([np.dot(P - new_origin, N) / np.dot(ort, N) if\r\n np.dot(ort, N) != 0 else np.nan for ort in new_Ccs])\r\n # fix signs of indices: 0 -> 1, 1 -> -1 (\r\n segments = (1 - 2 * new_origin) * segments\r\n\r\n return sub_miller(segments)","def vector(self):\n \n v_list = Householder.triangle_operation(self)[1]\n \n return(v_list)","def onBase():\n return (vector(1, 0, 0), vector(0, 1, 0), vector(0, 0, 1))","def magni(vector):\n return(np.linalg.norm(vector))","def vector(molec, dihed, nonH, energy):\n #Torison\n if dihed:\n pass\n #XYZ\n else:\n coords = ()\n if nonH:\n for atom in molec.atoms:\n coords += atom.coords\n else:\n for atom in molec.atoms:\n if atom.atomicnum > 1:\n coords += atom.coords\n #Energy\n if energy:\n coords += (molec.energy/10.0,)\n return coords","def cxvec(self):\n return np.array([self.cx, self.cy])","def to_indices(self, world_coords):\n (x, y, z) = world_coords\n (cx, cy, cz) = self.center\n\n px = x - cx\n py = y - cy\n pz = z - cz\n\n # project u and v\n # TODO: Can this be done with some built-in Numpy operation?\n (ux, uy, uz) = self.u_dir\n (vx, vy, vz) = self.v_dir\n u = px * ux + py * uy + pz * uz\n v = px * vx + py * vy + pz * vz\n\n # rescale to pixel coordinates. u is up, v is down\n (H, W, _) = self.shape\n i = rescale(-1, 1, H - 1, 0, v)\n j = rescale(-1, 1, 0, W -1, u)\n\n return (i, j)","def generate_V(self):\n\n n_samples, n_dimensions, L = self.n_samples, self.n_dimensions, self.L\n\n V = np.zeros([L + 1, n_dimensions], dtype=int)\n V[1:, 0] = [1 << (self.scale - j) for j in range(1, L + 1)]\n\n for i in range(n_dimensions - 1):\n\n m = np.array(directions[i], dtype=int)\n s = len(m) - 1\n\n # The following code discards the first row of the ``m`` array\n # Because it has floating point errors, e.g. values of 2.24e-314\n if L <= s:\n V[1:, i + 1] = [m[j] << (self.scale - j) for j in range(1, L + 1)]\n else:\n V[1 : s + 1, i + 1] = [\n m[j] << (self.scale - j) for j in range(1, s + 1)\n ]\n for j in range(s + 1, L + 1):\n V[j, i + 1] = V[j - s, i + 1] ^ (V[j - s, i + 1] >> s)\n for k in range(1, s):\n V[j, i + 1] ^= ((m[0] >> (s - 1 - k)) & 1) * V[j - k][i + 1]\n\n return V","def test_perpendicular_to_vector():\n assert_almost_equal(pr.angle_between_vectors(\n pr.unitx, pr.perpendicular_to_vector(pr.unitx)), np.pi / 2.0)\n assert_almost_equal(pr.angle_between_vectors(\n pr.unity, pr.perpendicular_to_vector(pr.unity)), np.pi / 2.0)\n assert_almost_equal(pr.angle_between_vectors(\n pr.unitz, pr.perpendicular_to_vector(pr.unitz)), np.pi / 2.0)\n random_state = np.random.RandomState(0)\n for _ in range(5):\n a = pr.norm_vector(pr.random_vector(random_state))\n assert_almost_equal(pr.angle_between_vectors(\n a, pr.perpendicular_to_vector(a)), np.pi / 2.0)\n b = a - np.array([a[0], 0.0, 0.0])\n assert_almost_equal(pr.angle_between_vectors(\n b, pr.perpendicular_to_vector(b)), np.pi / 2.0)\n c = a - np.array([0.0, a[1], 0.0])\n assert_almost_equal(pr.angle_between_vectors(\n c, pr.perpendicular_to_vector(c)), np.pi / 2.0)\n d = a - np.array([0.0, 0.0, a[2]])\n assert_almost_equal(pr.angle_between_vectors(\n d, pr.perpendicular_to_vector(d)), np.pi / 2.0)","def uVectNorm(x1,y1,z1, # P\n x2,y2,z2, # Q\n x3,y3,z3): # R\n p1 = np.array([x1,y1,z1])\n p2 = np.array([x2,y2,z2])\n p3 = np.array([x3,y3,z3])\n\n v1 = p3-p1\n v2 = p2-p1\n\n cp = np.cross(v1,v2)\n a,b,c = cp\n\n d = np.dot(cp, p3)\n\n print(a,b,c)","def cartesian_of_projective(z):\n alpha = z[0,:]\n beta = z[1,:]\n vz = np.real(np.conj(alpha)*alpha - np.conj(beta)*beta)\n vx_plus_ivy = 2*np.conj(alpha)*beta\n vx = np.real(vx_plus_ivy)\n vy = np.imag(vx_plus_ivy)\n return vx, vy, vz","def perp_2d_vec(vec):\n return normalized(np.dot(R90, vec))","def get_plane_of_points(\n self,\n normal_vector=\"z\",\n planar_coordinate=None,\n ):\n # Get results vectors\n if (normal_vector == \"z\"):\n x_flat = self.floris.grid.x_sorted_inertial_frame[0, 0].flatten()\n y_flat = self.floris.grid.y_sorted_inertial_frame[0, 0].flatten()\n z_flat = self.floris.grid.z_sorted_inertial_frame[0, 0].flatten()\n else:\n x_flat = self.floris.grid.x_sorted[0, 0].flatten()\n y_flat = self.floris.grid.y_sorted[0, 0].flatten()\n z_flat = self.floris.grid.z_sorted[0, 0].flatten()\n u_flat = self.floris.flow_field.u_sorted[0, 0].flatten()\n v_flat = self.floris.flow_field.v_sorted[0, 0].flatten()\n w_flat = self.floris.flow_field.w_sorted[0, 0].flatten()\n\n # Create a df of these\n if normal_vector == \"z\":\n df = pd.DataFrame(\n {\n \"x1\": x_flat,\n \"x2\": y_flat,\n \"x3\": z_flat,\n \"u\": u_flat,\n \"v\": v_flat,\n \"w\": w_flat,\n }\n )\n if normal_vector == \"x\":\n df = pd.DataFrame(\n {\n \"x1\": y_flat,\n \"x2\": z_flat,\n \"x3\": x_flat,\n \"u\": u_flat,\n \"v\": v_flat,\n \"w\": w_flat,\n }\n )\n if normal_vector == \"y\":\n df = pd.DataFrame(\n {\n \"x1\": x_flat,\n \"x2\": z_flat,\n \"x3\": y_flat,\n \"u\": u_flat,\n \"v\": v_flat,\n \"w\": w_flat,\n }\n )\n\n # Subset to plane\n # TODO: Seems sloppy as need more than one plane in the z-direction for GCH\n if planar_coordinate is not None:\n df = df[np.isclose(df.x3, planar_coordinate)] # , atol=0.1, rtol=0.0)]\n\n # Drop duplicates\n # TODO is this still needed now that we setup a grid for just this plane?\n df = df.drop_duplicates()\n\n # Sort values of df to make sure plotting is acceptable\n df = df.sort_values([\"x2\", \"x1\"]).reset_index(drop=True)\n\n return df","def fit_plane_to_point_cloud(pc: np.ndarray) -> Tuple[Any, Any, Any, Any]:\n center = pc.sum(axis=0) / pc.shape[0]\n u, s, vh = np.linalg.svd(pc - center)\n\n # Get the unitary normal vector\n u_norm = vh[2, :]\n d = -np.dot(u_norm, center)\n a, b, c = u_norm\n return a, b, c, d","def getVectors(self):\n l = len(self.points)\n return [Vector.createFromTwoPoints(self.points[i % l], self.points[(i + 1) % l], \\\n color=self.side_color, width=self.side_width) for i in range(l)]","def to_mesh(\n self,\n lims_x: array_like = (-1, 1),\n lims_y: array_like = (-1, 1),\n ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\n a, b, c, d = self.cartesian()\n x_center, y_center = self.point[:2]\n\n values_x = x_center + lims_x\n values_y = y_center + lims_y\n\n X, Y = np.meshgrid(values_x, values_y)\n\n if c != 0:\n Z = -(a * X + b * Y + d) / c\n\n elif b != 0:\n Z = -(a * X + c * Y + d) / b\n X, Y, Z = X, Z, Y\n\n else:\n Z = -(b * X + c * Y + d) / a\n X, Y, Z = Z, X, Y\n\n return X, Y, Z","def normalize_vectors(motion_vectors):\n if np.shape(motion_vectors)[0] == 0:\n return motion_vectors\n else:\n motion_vectors[:, 7] = motion_vectors[:, 7] / motion_vectors[:, 0] # motion_x\n motion_vectors[:, 8] = motion_vectors[:, 8] / motion_vectors[:, 0] # motion_y\n motion_vectors[:, 0] = -1 * np.ones_like(motion_vectors[:, 0])\n return motion_vectors","def test_from_two_vectors(self):\r\n for _ in range(20):\r\n v0 = np.random.randn(3)\r\n v1 = np.random.randn(3)\r\n v0 /= np.linalg.norm(v0)\r\n v1 /= np.linalg.norm(v1)\r\n\r\n q = from_two_vectors(v0, v1)\r\n R = to_rotation(q)\r\n\r\n zero_vec = R @ v0 - v1\r\n self.assertAlmostEqual(np.linalg.norm(zero_vec), 0.0)\r\n\r\n q_inv = from_two_vectors(v1, v0)\r\n R_inv = to_rotation(q_inv)\r\n zero_matrix = R @ R_inv - np.identity(3)\r\n self.assertAlmostEqual(np.linalg.norm(zero_matrix), 0.0)","def make_inward_normal(tetrahedron):\n\n convert_to_np_array = lambda v: np.array([v.x, v.y, v.z])\n np_vertices = list(map(convert_to_np_array, [tetrahedron.get_vertex(i) for i in range(4)]))\n # This is the middle point\n # midpoint = np.mean(np_vertices, axis=0)\n\n midpoint = np_vertices[0]\n for i in range(1, 4):\n midpoint += np_vertices[i]\n midpoint = midpoint / 2.0\n\n for i in range(4):\n face = tetrahedron.get_face(i)\n d = distance(face, midpoint)\n if d < 0:\n face.nx *= -1.0\n face.ny *= -1.0\n face.nz *= -1.0\n face.d *= -1.0","def landmarks_as_vectors(landmarks):\n mat = []\n for lm in landmarks:\n mat.append(lm.as_vector())\n return np.array(mat)","def _orthogonal_vector(vector):\n return -1 * vector[1], vector[0]","def find_perpendicular_vector(vt):\n x, y = vt\n return np.array([y, -x])","def lic_flow(vectors,len_pix=10):\n vectors = np.asarray(vectors)\n m,n,two = vectors.shape\n if two!=2:\n raise ValueError\n\n result = np.zeros((2*len_pix+1,m,n,2),dtype=np.int32) # FIXME: int16?\n center = len_pix\n result[center,:,:,0] = np.arange(m)[:,np.newaxis]\n result[center,:,:,1] = np.arange(n)[np.newaxis,:]\n\n for i in range(m):\n for j in range(n):\n y = i\n x = j\n fx = 0.5\n fy = 0.5\n for k in range(len_pix):\n vx, vy = vectors[y,x]\n print x, y, vx, vy\n if vx>=0:\n tx = (1-fx)/vx\n else:\n tx = -fx/vx\n if vy>=0:\n ty = (1-fy)/vy\n else:\n ty = -fy/vy\n if tx<ty:\n print \"x step\"\n if vx>0:\n x+=1\n fy+=vy*tx\n fx=0.\n else:\n x-=1\n fy+=vy*tx\n fx=1.\n else:\n print \"y step\"\n if vy>0:\n y+=1\n fx+=vx*ty\n fy=0.\n else:\n y-=1\n fx+=vx*ty\n fy=1.\n if x<0: x=0\n if y<0: y=0\n if x>=n: x=n-1\n if y>=m: y=m-1\n result[center+k+1,i,j,:] = y, x\n\n\n\n return result","def face_normals(xyz, triangles):\n\n\tabc_xyz = face_attr(xyz, triangles)\n\n\tbc_xyz = abc_xyz[:,:,1:3] - abc_xyz[:,:,0:1]\n\tfn = tf.linalg.cross(bc_xyz[:,:,0], bc_xyz[:,:,1])\n\tfn = tf.math.l2_normalize(fn, -1)\n\treturn fn","def vector_potential(self, xyz):\n r = self.distance(xyz)\n a = (\n (self.current * self.length) / (4*np.pi*r) *\n np.exp(-i*self.wavenumber*r)\n )\n a = np.kron(np.ones(1, 3), np.atleast_2d(a).T)\n return self.dot_orientation(a)","def vrrotvec2mat(ax_ang):\n\n #file_dir = os.path.dirname(os.path.realpath(__file__))\n #path_dir2 = file_dir + '/../geometry/'\n #sys.path.append(path_dir2)\n\n if ax_ang.ndim == 1:\n if np.size(ax_ang) == 5:\n ax_ang = np.reshape(ax_ang, (5, 1))\n msz = 1\n elif np.size(ax_ang) == 4:\n ax_ang = np.reshape(np.hstack((ax_ang, np.array([1]))), (5, 1))\n msz = 1\n else:\n raise Exception('Wrong Input Type')\n elif ax_ang.ndim == 2:\n if np.shape(ax_ang)[0] == 5:\n msz = np.shape(ax_ang)[1]\n elif np.shape(ax_ang)[1] == 5:\n ax_ang = ax_ang.transpose()\n msz = np.shape(ax_ang)[1]\n else:\n raise Exception('Wrong Input Type')\n else:\n raise Exception('Wrong Input Type')\n\n direction = ax_ang[0:3, :]\n angle = ax_ang[3, :]\n\n d = np.array(direction, dtype=np.float64)\n d /= np.linalg.norm(d, axis=0)\n x = d[0, :]\n y = d[1, :]\n z = d[2, :]\n c = np.cos(angle)\n s = np.sin(angle)\n tc = 1 - c\n\n mt11 = tc*x*x + c\n mt12 = tc*x*y - s*z\n mt13 = tc*x*z + s*y\n\n mt21 = tc*x*y + s*z\n mt22 = tc*y*y + c\n mt23 = tc*y*z - s*x\n\n mt31 = tc*x*z - s*y\n mt32 = tc*y*z + s*x\n mt33 = tc*z*z + c\n\n mtx = np.column_stack((mt11, mt12, mt13, mt21, mt22, mt23, mt31, mt32, mt33))\n\n inds1 = np.where(ax_ang[4, :] == -1)\n mtx[inds1, :] = -mtx[inds1, :]\n\n if msz == 1:\n mtx = mtx.reshape(3, 3)\n else:\n mtx = mtx.reshape(msz, 3, 3)\n\n return mtx","def spherical2cartesian(v):\n \n x = np.cos(v[0]) * np.cos(v[1]) \n y = np.cos(v[0]) * np.sin(v[1]) \n z = np.sin(v[0]) \n \n return [x,y,z]","def vincdecnorm(arr):\n tmp = convert(arr, GEOCENTRIC_CARTESIAN, GEOCENTRIC_SPHERICAL)\n return -tmp[..., 0], tmp[..., 1], tmp[..., 2]","def _prepare_plane(self):\n verticies = [\n # main plane - note that the mainplane is scaled so the mat_plane\n # matrix will it transform to the correct coordinates\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\n -self.i_border[0]/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], self.i_border[1]/self._scaling[1],\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\n\n # coord plane\n 0, 0,\n 0, -self.o_wh[1],\n self.o_wh[0], -self.o_wh[1],\n self.o_wh[0], -self.o_wh[1],\n self.o_wh[0], 0,\n 0, 0,\n\n # axes\n 0, -self.o_wh[1], self.o_wh[0], -self.o_wh[1], #x\n 0, 0, 0, -self.o_wh[1], #y\n ]\n\n colors = [\n 1.0, 1.0, 1.0, 1.0, # outer box XXX Remove outer box...\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n .9, .9, .9, 9.0, # plot box\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n 0.0, 0.0, 0.0, 1.0, #lines\n 0.0, 0.0, 0.0, 1.0,\n 0.0, 0.0, 0.0, 1.0,\n 0.0, 0.0, 0.0, 1.0,\n ]\n\n self._fonts = []\n for u in range(1, self._unit_count[0]+1):\n verticies.append(self._unit_w[0]*u)\n verticies.append(-self.o_wh[1]+0.02)\n verticies.append(self._unit_w[0]*u)\n verticies.append(-self.o_wh[1]-0.02)\n colors += [0.0, 0.0, 0.0, 1.0]\n colors += [0.0, 0.0, 0.0, 1.0]\n self._fonts.append([\n '{:.2f}'.format(u*(self.i_axis[0]/self._unit_count[0])-self.i_origin[0]),\n (self._unit_w[0]*u+self.i_border[0]-0.05)*self._scaling[0],\n (-self.o_wh[1]+(self.i_border[3])*0.5)\n ])\n for u in range(0, self._unit_count[1]):\n verticies.append(0.02)\n verticies.append(-self._unit_w[1]*u)\n verticies.append(-0.02)\n verticies.append(-self._unit_w[1]*u)\n colors += [0.0, 0.0, 0.0, 1.0]\n colors += [0.0, 0.0, 0.0, 1.0]\n self._fonts.append([\n '{:.2f}'.format(self.i_axis[1]-u*self.i_axis[1]/self._unit_count[1]-self.i_origin[1]),\n (0.025)*self._scaling[0],\n (-(self._unit_w[1])*u-self.i_border[1]+0.01)*self._scaling[1]\n ])\n\n self._draw_plane_indicies = (0, 12)\n self._draw_line_indicies = (12, 4+self._unit_count[0]*2+self._unit_count[1]*2)\n\n # convert data into valid data format\n verticies = numpy.array(verticies, dtype=numpy.float32)\n colors = numpy.array(colors, dtype=numpy.float32)\n\n self._plane_vao = util.VAO()\n self._plane_vbo = util.VBO(2)\n\n with self._plane_vao:\n # plane verticies\n with self._plane_vbo.get(0):\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(verticies), verticies, GL_STATIC_DRAW)\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_position'), 2, GL_FLOAT, GL_FALSE, 0, None)\n glEnableVertexAttribArray(0)\n\n # place vertex colors\n with self._plane_vbo.get(1):\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(colors), colors, GL_STATIC_DRAW)\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_color'), 4, GL_FLOAT, GL_FALSE, 0, None)\n glEnableVertexAttribArray(1)","def unit_vectors(x):\n xnew = x.copy()\n for v in range(x.shape[-1]):\n xnew[:, v] = x[:, v] / np.linalg.norm(x[:, v])\n return xnew","def _spherical_to_cartesian(ra, dec):\n rar = np.radians(ra)\n decr = np.radians(dec)\n\n x = np.cos(rar) * np.cos(decr)\n y = np.sin(rar) * np.cos(decr)\n z = np.sin(decr)\n \n return x, y, z","def vector_convert(self, pos) :\n delta = AUTO_width2//3\n bright_list = []\n for i in range(-1,2):\n for j in range(-1,2) :\n b = 0\n count = 0\n for x in range(max(0, pos[0] + i*delta), min(self.m_x, pos[0] + (i+1)*delta)):\n for y in range(max(0, pos[1] + j*delta), min(self.m_y, pos[1] + (j+1)*delta)):\n b += self.current_array[x][y]\n count += 1\n if count == 0 :\n bright_list.append(0)\n else :\n if b == 0 : #prevent 0 divde\n b = 1\n bright_list.append(b/count)\n bright_list = np.array(bright_list)\n m = np.max(bright_list)/self.current_total_avg\n bright_list = bright_list/np.min(bright_list) -1\n bright_list = np.append(bright_list, m)\n return bright_list","def reciprocal_lattice_vectors(a):\n b = np.zeros(shape=(3,3))\n b[:,0] = 2 * np.pi * np.cross(a[:,1], a[:,2]) / triple_product(a[:,0], a[:,1], a[:,2])\n b[:,1] = 2 * np.pi * np.cross(a[:,2], a[:,0]) / triple_product(a[:,1], a[:,2], a[:,0])\n b[:,2] = 2 * np.pi * np.cross(a[:,0], a[:,1]) / triple_product(a[:,2], a[:,0], a[:,1])\n return b","def hexgrid(self):\n n = self.n * 2\n vectors = []\n for u in range(-n, n+1):\n us = [u] * (2*n+1)\n if u < 0:\n vectors.extend(zip(us, range(-n-u, n+1), range(-n, n+u+1)))\n else:\n vectors.extend(zip(us, range(-n, n-u+1), range(-n+u, n+1)))\n return vectors","def lin_a98rgb_to_xyz(rgb: Vector) -> Vector:\n\n return alg.dot(RGB_TO_XYZ, rgb, dims=alg.D2_D1)","def getNormalizedNormalVec(self):\n TriPos = self.position\n # calc normalized normal vecor for Tri\n # get vectors Vert1Vert2 & Vert2Vert3\n TriVectors = np.subtract(TriPos[1:],TriPos[:-1])\n # get crossproduct of Vert1Vert2 & Vert2Vert3 (= surface normal)\n TriNorm = np.cross(TriVectors[0],TriVectors[1])+0.0\n # get length of surface normal\n length = np.linalg.norm(TriNorm)\n # divide each component of surface normal by length (= normalized surface normal)\n NormalizedNormalVec = np.around(TriNorm / length, decimals=5) # rounded, otherwise different values, equals not found\n # create string of tuple for segment dict \n #SegmDict = str(tuple(NormalizedNormalVec))\n return NormalizedNormalVec.tolist()","def project_point_plane(point, plane):\n base, normal = plane\n normal = normalize_vector(normal)\n vector = subtract_vectors(point, base)\n snormal = scale_vector(normal, dot_vectors(vector, normal))\n return subtract_vectors(point, snormal)","def unit_vectors(direction, inclination, mask=None):\n UnitX = np.sin(0.5 * np.pi - inclination) * np.cos(direction)\n UnitY = np.sin(0.5 * np.pi - inclination) * np.sin(direction)\n UnitZ = np.cos(0.5 * np.pi - inclination)\n\n if mask:\n _mask = np.logical_not(mask)\n UnitX[_mask] = 0\n UnitY[_mask] = 0\n UnitZ[_mask] = 0\n\n return UnitX, UnitY, UnitZ","def normal_vector(self, facet):\n assert len(facet) == 3\n pos = self.cluster.get_positions()\n v1 = pos[facet[1], :] - pos[facet[0], :]\n v2 = pos[facet[2], :] - pos[facet[0], :]\n n = np.cross(v1, v2)\n length = np.sqrt(np.sum(n**2))\n return n / length","def el2rv(mu,a,e,i,capom,om,f):\n\n prec = 1.0e-13 #user can change this if more precision needed (just runs slower)\n\n #compute the unit vector\n u = om + f\n xhat = np.cos(u)*np.cos(capom) - np.cos(i)*np.sin(capom)*np.sin(u)\n yhat = np.cos(u)*np.sin(capom) + np.cos(i)*np.cos(capom)*np.sin(u)\n zhat = np.sin(i)*np.sin(u)\n\n #compute the angular momentum vector (unit vector)\n hx = np.sin(capom)*np.sin(i)\n hy = -np.cos(capom)*np.sin(i)\n hz = np.cos(i)\n\n #assuming not parabolic, here the magnitudes of the vectors\n r = a * (1.0 - e*e) / (1.0 + e*np.cos(f))\n h = ( mu*a*(1.0 - e*e) )**0.5\n\n #position vectors\n x = r * xhat\n y = r * yhat\n z = r * zhat\n\n #compute components of vector theta hat\n thx = hy * zhat - hz * yhat\n thy = hz * xhat - hx * zhat\n thz = hx * yhat - hy * xhat\n\n #obtain the velocity vector's components and calculate v\n thdot = h/(r*r)\n rdot = e*mu*np.sin(f)/h\n\n vx = r * thdot * thx + rdot * xhat\n vy = r * thdot * thy + rdot * yhat\n vz = r * thdot * thz + rdot * zhat\n\n return x,y,z","def normal(axis_direction, axis_origin, point):\n # transform input into numpy arrays\n axis_direction = np.array(axis_direction, float)\n axis_origin = np.array(axis_origin, float)\n point = np.array(point, float)\n\n # vector from axis normal_origin to point\n vector = point - axis_origin\n\n # projection of vector on axis\n projection = np.dot(vector, axis_direction)*axis_direction\n\n # the normal vector from normal_origin to point\n normal_direction = vector - projection\n\n # normalized normal_direction\n normal_direction = normal_direction/np.linalg.norm(normal_direction)\n\n # opposite of the projection of vector on normal\n projection2 = - np.dot(normal_direction, vector)*normal_direction\n\n normal_origin = point + projection2\n\n return normal_direction, normal_origin","def get_perpendicular2d(vector):\n if vector[1] == 0:\n return np.asarray([0.,1.])\n v2_0 = 1.0\n v2_1 = -(vector[0]/vector[1])\n v2 = np.asarray([v2_0, v2_1])\n return v2 / np.linalg.norm(v2)","def vector_perp(v):\n assert len(v) == 2\n x, y = v\n return Vector(-y, x)","def _vehicle_to_world(cords, vehicle):\n\n bb_transform = carla.Transform(vehicle.bounding_box.location)\n bb_vehicle_matrix = ClientSideBoundingBoxes.get_matrix(bb_transform)\n vehicle_world_matrix = ClientSideBoundingBoxes.get_matrix(vehicle.get_transform())\n bb_world_matrix = np.dot(vehicle_world_matrix, bb_vehicle_matrix)\n world_cords = np.dot(bb_world_matrix, np.transpose(cords))\n return world_cords","def find_direction_vector(line):\n pt1, pt2 = line\n pt1 = np.array(pt1).reshape(2,)\n pt2 = np.array(pt2).reshape(2,)\n direct = pt2 - pt1\n direct_norm = normalize(direct)\n return direct_norm","def apply_direction_scale( vectors, direction, scale ):\n \"\"\"\n scaling is defined as:\n \n [p'][1 + (k - 1)n.x^2, (k - 1)n.x n.y^2, (k - 1)n.x n.z ]\n S(n,k) = [q'][(k - 1)n.x n.y, 1 + (k - 1)n.y, (k - 1)n.y n.z ]\n [r'][(k - 1)n.x n.z, (k - 1)n.y n.z, 1 + (k - 1)n.z^2 ]\n \n where:\n v' is the resulting vector after scaling\n v is the vector to scale\n n is the direction of the scaling\n n.x is the x component of n\n n.y is the y component of n\n n.z is the z component of n\n k is the scaling factor\n \"\"\"\n scaleMinus1 = scale - 1\n matrix = numpy.array(\n [\n # m1\n [\n # m11 = 1 + (k - 1)n.x^2\n 1 + scaleMinus1 * (direction[ 0 ]**2),\n # m12 = (k - 1)n.x n.y^2\n scaleMinus1 * direction[ 0 ] * direction[ 1 ]**2,\n # m13 = (k - 1)n.x n.z\n scaleMinus1 * direction[ 0 ] * direction[ 2 ]\n ],\n # m2\n [\n # m21 = (k - 1)n.x n.y\n scaleMinus1 * direction[ 0 ] * direction[ 1 ],\n # m22 = 1 + (k - 1)n.y\n 1 + scaleMinus1 * direction[ 1 ],\n # m23 = (k - 1)n.y n.z\n scaleMinus1 * direction[ 1 ] * direction[ 2 ]\n ],\n # m3\n [\n # m31 = (k - 1)n.x n.z\n scaleMinus1 * direction[ 0 ] * direction[ 2 ],\n # m32 = (k - 1)n.y n.z\n scaleMinus1 * direction[ 1 ] * direction[ 2 ],\n # m33 = 1 + (k - 1)n.z^2\n 1 + scaleMinus1 * direction[ 2 ]**2\n ]\n ],\n dtype = numpy.float\n )\n \n return numpy.dot( vectors, matrix )","def build_coord(norm, d, pts):\n # Compute the origin as the mean point of the points, and this point has to be on the plane\n \n n = len(pts) \n x_total = 0\n y_total = 0\n z_total = 0\n \n for i in range(n):\n x_total += pts[i][0]\n y_total += pts[i][1]\n z_total += pts[i][2]\n\n x_o = x_total * 1.0 / n\n y_o = y_total * 1.0 / n\n z_o = z_total * 1.0 / n\n p_o = [x_o, y_o, z_o]\n \n # Choose p be the projection of a vector in the z-axis to the plane\n # If the plane is not perpendicular to the z-axis\n if ((norm[2] != 1) and (norm[2] != -1)): \n # Choose a point\n o_z = [x_o, y_o, z_o + 1]\n \n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\n \n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\n\n x_c = (x_p - x_o) * 1.0 / dist \n y_c = (y_p - y_o) * 1.0 / dist\n z_c = (z_p - z_o) * 1.0 / dist\n # Thus we have unit vector in x direction\n e_y = [x_c, y_c, z_c]\n #Compute the unit vector in y direction\n e_x = np.cross(e_y, norm).tolist()\n else:\n e_x = [1, 0, 0]\n e_y = [0, 1, 0]\n \n return [e_x, e_y, norm] , p_o","def normals(t, v):\n n = numpy.zeros((len(t), 3))\n for i in range(0, len(t)):\n p = vertices(t[i], v)\n n[i] = triangle.normal(p)\n return n","def make_lattice(min,max,lattice_vectors):\n xs = np.roll(np.arange(min[0],max[0]),max[0])\n ys = np.roll(np.arange(min[1],max[1]),max[1])\n lattice = np.dstack(np.meshgrid(xs,ys)).reshape(-1,2)\n lattice = np.matmul(lattice,lattice_vectors)\n return lattice","def _build_mcid_vectors(self, model: BDF, nplies: int):\n etype = 3 # vtkLine\n\n nodes, bars = export_mcids_all(model, eids=None, log=None, debug=False)\n for iply, nodesi in nodes.items():\n barsi = bars[iply]\n if iply == -1:\n name = 'element material coord'\n else:\n name = f'mcid ply={iply+1}'\n\n nbars = len(barsi)\n if nbars == 0:\n # isotropic\n continue\n assert nbars > 0, model.card_count\n\n is_visible = False\n self.gui.create_alternate_vtk_grid(\n name, color=RED_FLOAT, line_width=3, opacity=1.0,\n representation='surface', is_visible=is_visible, is_pickable=False)\n grid = self.gui.alt_grids[name]\n grid.Allocate(nbars, 1000)\n\n nodes_array = np.array(nodesi, dtype='float32')\n elements = np.array(barsi, dtype='int32')\n assert elements.min() == 0, elements.min()\n points = numpy_to_vtk_points(nodes_array, points=None, dtype='<f', deep=1)\n grid.SetPoints(points)\n create_vtk_cells_of_constant_element_type(grid, elements, etype)\n return","def mni2vxl(coord):\n i = int((90.0 - coord[0]) / 2)\n j = int((coord[1] + 126) / 2)\n k = int((coord[2] + 72) / 2)\n return (i, j, k)","def z_to_vector(vector):\n norm = np.linalg.norm(vector)\n if norm == 0:\n return np.identity(3)\n v = np.array(vector) / norm\n phi = np.arccos(v[2])\n if any(v[:2]):\n #projection of vector to unit circle\n axis_proj = v[:2] / np.linalg.norm(v[:2])\n theta = np.arccos(axis_proj[0])\n if axis_proj[1] < 0:\n theta = -theta\n else:\n theta = 0\n phi_down = np.array([\n [np.cos(phi), 0, np.sin(phi)],\n [0, 1, 0],\n [-np.sin(phi), 0, np.cos(phi)]\n ])\n return np.dot(rotation_about_z(theta), phi_down)","def unit_vector(vector):\n #print 'unit_vector'\n #print vector\n #print type(vector)\n #npvector = np.array(vector)\n return vector / np.linalg.norm(vector)","def get_perpendicular(n: np.ndarray) -> np.ndarray:\n # find smallest component\n i = np.argmin(n)\n\n # get the other two indices\n a = (i + 1) % 3\n b = (i + 2) % 3\n\n result = np.zeros(3)\n result[i] = 0.0\n result[a] = n[b]\n result[b] = -n[a]\n return result","def get_vectors(nodes, mode=\"xform\"):\n for each in nodes:\n position = (0, 0, 0)\n\n if mode == \"xform\":\n position = cmds.xform(\n each,\n query=True,\n translation=True,\n worldSpace=True,\n )\n\n elif mode == \"pivot\":\n position = cmds.xform(\n each,\n query=True,\n translation=True,\n rotatePivot=True,\n worldSpace=True,\n )\n\n # when using xform on component like faces or edge, the returned value\n # will be a list of each vertices position, so we need to average that\n if len(position) > 3:\n vectors = [\n MVector(position[i : i + 3])\n for i in range(0, len(position), 3)\n ]\n result = MVector()\n for vector in vectors:\n result += vector\n position = result / len(vectors)\n\n yield MVector(position)","def convert_hkl_to_xyz2(self, hkl):\n # Use the hkl miller indices to calculate the normal to a plane in cartesian space\n p = []\n if not hkl[0] == 0:\n p.append(np.array(self.lattice[0] / hkl[0]))\n if not hkl[1] == 0:\n p.append(np.array(self.lattice[1] / hkl[1]))\n if not hkl[2] == 0:\n p.append(np.array(self.lattice[2] / hkl[2]))\n if hkl[0] == 0:\n p.append(self.lattice[0] + p[0])\n if hkl[1] == 0:\n p.append(self.lattice[1] + p[0])\n if hkl[2] == 0:\n p.append(self.lattice[2] + p[0])\n p12 = p[1] - p[0]\n p13 = p[2] - p[0]\n normal = np.cross(p12, p13)\n norm = np.linalg.norm(normal)\n if norm < 1.0e-8:\n print(\"Error in unit cell, calculation of normal to miller index failed\")\n exit(1)\n normal = normal / norm\n return normal","def grab_40_vectors(x1,x2,y1,y2) -> list:\n\n if x1 > x2:\n x1,x2 = x2,x1\n if y1 > y2:\n y1,y2 = y2,y1\n\n height = abs(y2-y1)\n length = abs(x2-x1)\n\n height_delta = height/10\n length_delta = length/10\n\n left_vertical_edge = [(x1, y1+height_delta*i) for i in range(0,11)]\n # print(left_vertical_edge)\n right_vertical_edge = [(x2,y1+height_delta*i) for i in range(0,11)]\n # print(right_vertical_edge)\n bottom_horizontal_edge = [(x1+length_delta*i,y1) for i in range(0,11)]\n # print(bottom_horizontal_edge)\n top_horizontal_edge = [(x1+length_delta*i,y2) for i in range(0,11)]\n # print(top_horizontal_edge)\n\n all_vectors = left_vertical_edge+right_vertical_edge+bottom_horizontal_edge+top_horizontal_edge\n return(all_vectors)","def npxywha2vertex(box):\n batch = box.shape[0]\n\n center = box[:,:2]\n w = box[:,2]\n h = box[:,3]\n rad = box[:,4]\n\n # calculate two vector\n verti = np.empty((batch,2), dtype=np.float32)\n verti[:,0] = (h/2) * np.sin(rad)\n verti[:,1] = - (h/2) * np.cos(rad)\n\n hori = np.empty((batch,2), dtype=np.float32)\n hori[:,0] = (w/2) * np.cos(rad)\n hori[:,1] = (w/2) * np.sin(rad)\n\n tl = center + verti - hori\n tr = center + verti + hori\n br = center - verti + hori\n bl = center - verti - hori\n\n return np.concatenate([tl,tr,br,bl], axis=1)","def npxywha2vertex(box):\n batch = box.shape[0]\n\n center = box[:,:2]\n w = box[:,2]\n h = box[:,3]\n rad = box[:,4]\n\n # calculate two vector\n verti = np.empty((batch,2), dtype=np.float32)\n verti[:,0] = (h/2) * np.sin(rad)\n verti[:,1] = - (h/2) * np.cos(rad)\n\n hori = np.empty((batch,2), dtype=np.float32)\n hori[:,0] = (w/2) * np.cos(rad)\n hori[:,1] = (w/2) * np.sin(rad)\n\n tl = center + verti - hori\n tr = center + verti + hori\n br = center - verti + hori\n bl = center - verti - hori\n\n return np.concatenate([tl,tr,br,bl], axis=1)","def volume_tetrahedron(xyz, A, B, C, D):\n\n AD = xyz[A, :] - xyz[D, :]\n BD = xyz[B, :] - xyz[D, :]\n CD = xyz[C, :] - xyz[D, :]\n\n V = (\n (BD[:, 0] * CD[:, 1] - BD[:, 1] * CD[:, 0]) * AD[:, 2]\n - (BD[:, 0] * CD[:, 2] - BD[:, 2] * CD[:, 0]) * AD[:, 1]\n + (BD[:, 1] * CD[:, 2] - BD[:, 2] * CD[:, 1]) * AD[:, 0]\n )\n return V / 6","def build_coord(norm, d, pts):\n # Compute the origin as the mean point of the points, and this point has to be on the plane\n \n n = len(pts)\n x_total = 0\n y_total = 0\n z_total = 0\n \n for i in range(n):\n x_total += pts[i][0]\n y_total += pts[i][1]\n z_total += pts[i][2]\n\n x_o = x_total * 1.0 / n\n y_o = y_total * 1.0 / n\n z_o = z_total * 1.0 / n\n p_o = [x_o, y_o, z_o]\n \n # Choose p be the projection of a vector in the z-axis to the plane\n # If the plane is not perpendicular to the z-axis\n if ((norm[2] != 1) and (norm[2] != -1)): \n # Choose a point\n o_z = [x_o, y_o, z_o + 1]\n \n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\n \n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\n\n x_c = (x_p - x_o) * 1.0 / dist \n y_c = (y_p - y_o) * 1.0 / dist\n z_c = (z_p - z_o) * 1.0 / dist\n # Thus we have unit vector in x direction\n e_y = [x_c, y_c, z_c]\n #Compute the unit vector in y direction\n e_x = np.cross(e_y, norm).tolist()\n else:\n e_x = [1, 0, 0]\n e_y = [0, 1, 0]\n \n return [e_x, e_y, norm] , p_o","def normal(self) -> Vec:\n return abs(self.up_axis.cross(self.forward()))","def vector(self) -> Vector:\n return self._normal * self._distance_from_origin","def map_vects(self, input_vects):\n \n if not self._trained:\n raise ValueError(\"SOM not trained yet\")\n \n to_return = []\n \n distances = []\n \n \n contador_adyacentes = 0\n \n matriz = np.array(list(self._neuron_locations(self._m, self._n)))\n \n m = self._m\n \n n = self._n\n \n matrices = []\n \n matrices = np.stack((matriz,\n matriz + np.array([m,n]), \n matriz - np.array([m,n]), \n matriz + np.array([m,0]),\n matriz - np.array([m,0]),\n matriz + np.array([0,n]),\n matriz - np.array([0,n]),\n matriz + np.array([m,-n]),\n matriz + np.array([-m,n])\n ))\n \n distancias_matriz = []\n\n for i in range(n*m):\n distancias_matriz.append([])\n for j in range(m*n):\n distancias_matriz[i].append(np.min(np.sum(np.power(np.subtract(matriz[i], matrices[:,j]),2), axis = 1)))\n \n distancias_matriz = np.array(distancias_matriz)\n \n \n for vect in input_vects:\n\n # min_index is the index of the BMU\n \n lista_indices = [i for i in range(len(self._weightages))]\n \n min_index = min(lista_indices,\n key=lambda x: np.linalg.norm(vect - self._weightages[x]))\n\n # min_index_2 is the index of the 2nd BMU\n \n lista_indices.pop(min_index) # El indice es el mismo que el valor\n \n min_index_2 = min(lista_indices,\n key=lambda x: np.linalg.norm(vect - self._weightages[x])) \n \n r2 = np.sqrt(2)\n\n if np.sqrt(distancias_matriz[min_index][min_index_2]) > r2: \n# print('loc 1')\n# print(locaciones[min_index])\n# print('loc 2')\n# print(locaciones[min_index_2])\n contador_adyacentes += 1\n\n\n distance = np.linalg.norm(vect - self._weightages[min_index])\n \n distances.append(distance)\n \n to_return.append(self._locations[min_index]) \n \n # Quantization Error qe (the mean of all distances to the BMU)!\n self.distances = distances \n \n # Topographic error te\n self.proporcion = contador_adyacentes / len(input_vects)\n \n self.prom_dist = np.mean(self.distances)\n \n return to_return","def co_vertexes(self):\n theta = self.orientation + np.pi / 2\n shifts = np.array([np.cos(theta), np.sin(theta)]) * self.b\n return self.coords + (shifts[:, None] * [-1, 1]).T"],"string":"[\n \"def plane_equation(point_a, point_b, point_c):\\n v1 = np.subtract(point_a, point_c)\\n v2 = np.subtract(point_a, point_b)\\n normal = np.cross(v1, v2)\\n # print 'b4 norm', normal\\n unit_normal = norm_vect(normal)\\n # print 'unityyy', unit_normal\\n return unit_normal\",\n \"def normal_vector(origin, vectors):\\n return np.cross(vectors[0] - origin, vectors[1] - origin)\",\n \"def MillerNormalVectors_110():\\r\\n k_110 = np.array([[1, 1, 0], [0, 1, 1], [1, 0, 1],\\r\\n [1, -1, 0], [0, 1, -1], [-1, 0, 1]])/np.sqrt(2.0)\\r\\n return np.array([k_110[0, :], k_110[1, :], k_110[2, :],\\r\\n k_110[3, :], k_110[4, :], k_110[5, :],\\r\\n -k_110[0, :], -k_110[1, :], -k_110[2, :],\\r\\n -k_110[3, :], -k_110[4, :], -k_110[5, :]])\",\n \"def compute_normalvect(self):\\n normvect = np.zeros((len(self.tri_pnts),3,3))\\n zvec = np.array([0, 0, 1])\\n for itri, tri in enumerate(self.tri_pnts):\\n #import pdb; pdb.set_trace()\\n tri0, tri1, tri2 = tri\\n x1,y1 = self.points[tri1]-self.points[tri0]\\n v1 = np.array([x1,y1,0])\\n x2,y2 = self.points[tri2]-self.points[tri1]\\n v2 = np.array([x2,y2,0])\\n x3,y3 = self.points[tri0]-self.points[tri2]\\n v3 = np.array([x3,y3,0])\\n v1 = v1/np.linalg.norm(v1)\\n v2 = v2/np.linalg.norm(v2)\\n v3 = v3/np.linalg.norm(v3)\\n #import pdb; pdb.set_trace()\\n normvect[itri,:,:] = np.cross(v1,zvec), np.cross(v2,zvec), np.cross(v3,zvec)\\n #import pdb; pdb.set_trace()\\n return normvect\",\n \"def MillerNormalVectors_111():\\r\\n k_111 = np.array(\\r\\n [[1, 1, 1], [-1, 1, 1], [1, -1, 1], [1, 1, -1]])/np.sqrt(3.0)\\r\\n return np.array([k_111[0, :], k_111[1, :], k_111[2, :], k_111[3, :],\\r\\n -k_111[0, :], -k_111[1, :], -k_111[2, :], -k_111[3, :]])\",\n \"def PlaneNormalVector(h, k, l):\\r\\n vec = np.array([h, k, l])\\r\\n return vec/np.linalg.norm(vec)\",\n \"def get_normal_vector_of_plane(p1, p2, p3):\\n v12 = np.array(p1) - np.array(p2)\\n v13 = np.array(p1) - np.array(p3)\\n nvec = np.cross(v12, v13)\\n ## print 'norm: '+str(np.linalg.norm(nvec))\\n return nvec / np.linalg.norm(nvec)\",\n \"def unit_normals(self):\\n return np.stack(self.centers_cartesian(), axis=-1)\",\n \"def project_onto_plane(vect):\\n x, y, z = vect\\n \\n return (x, y, 0.)\",\n \"def plane_from_points(a, b, c):\\n ab = subtract_vectors(b, a)\\n ac = subtract_vectors(c, a)\\n n = normalize_vector(cross_vectors(ab, ac))\\n return a, n\",\n \"def MillerNormalVectors_100():\\r\\n k_100 = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])\\r\\n return np.array([k_100[0, :], k_100[1, :], k_100[2, :],\\r\\n -k_100[0, :], -k_100[1, :], -k_100[2, :]])\",\n \"def _generate_meshes(self, vectors, width):\\n centers = np.repeat(vectors, 2, axis=0)\\n offsets = segment_normal(vectors[::2, :], vectors[1::2, :])\\n offsets = np.repeat(offsets, 4, axis=0)\\n signs = np.ones((len(offsets), 2))\\n signs[::2] = -1\\n offsets = offsets*signs\\n\\n vertices = centers + width*offsets/2\\n triangles = np.array([[2*i, 2*i+1, 2*i+2] if i % 2 == 0 else\\n [2*i-1, 2*i, 2*i+1] for i in\\n range(len(vectors))]).astype(np.uint32)\\n\\n return vertices, triangles\",\n \"def project_vectors_ab(a, b):\\n # print('dot = ', np.dot(a,b))\\n # print('norm = ', np.linalg.norm(b))\\n return np.dot(a, b) / np.linalg.norm(b)\",\n \"def planeIndex(plane, center = False):\\n return (planeBase(center = center) * np.array(plane)).sum()\",\n \"def project_vectors(self, vectors):\\n X = vectors - self._mean\\n return np.dot(X, self.components.T)\",\n \"def unit_vectors(self):\\n # return {'comp1': CartesianRepresentation(...),\\n # 'comp2': CartesianRepresentation(...),\\n # 'comp3': CartesianRepresentation(...)}\\n raise Exception(\\\"Not yet implemented\\\")\",\n \"def normal_vectors(ATOM_list, frame, number_of_atoms, number_of_molecules, number_of_vectors, centerlist, referencelist, boxX, boxY, boxZ):\\t\\n\\tNORMAL_VECTORS_out=open(\\\"normalvectors.xyz\\\",'a')\\n\\t\\n\\tNORMAL_VECTORS_check=open(\\\"check_normalvectors.xyz\\\",'a')\\n\\t\\n\\tANGLEDIST_VECTORS_out=open(\\\"angle_dist_vectors.xyz\\\",'a')\\n\\t\\n\\t\\n\\tVorzugsrichtung_out=open(\\\"sum_over_all_normalvectors.dat\\\",'a')\\n\\t\\n\\t\\n\\t\\n\\tNORMAL_VECTORS_check.write(str( (number_of_vectors*(2 + int(len(referencelist))) )*number_of_molecules )+'\\\\n')\\n\\tNORMAL_VECTORS_check.write(str(frame)+'\\\\n')\\n\\t\\n\\tNORMAL_VECTORS_out.write(str( (number_of_vectors*2)*number_of_molecules )+'\\\\n')\\n\\tNORMAL_VECTORS_out.write(str(frame)+'\\\\n')\\n\\n\\tANGLEDIST_VECTORS_out.write(str( (number_of_vectors*2)*number_of_molecules )+'\\\\n')\\n\\tANGLEDIST_VECTORS_out.write(str(frame)+'\\\\n')\\n\\t\\n\\tvorzugsvektor = np.asarray([0,0,0])\\n\\treference=0\\n\\t\\n\\t\\n\\tfor l in range(0,number_of_molecules):\\n\\t\\tfor vec_count in range(0,number_of_vectors):\\n\\t\\t\\tr = []\\n\\t\\t\\t#get the 'middle' of the DPI molecule\\n\\t\\t\\t\\n\\t\\t\\n\\t\\t\\t#get geometric center\\n\\t\\t\\tcenter=np.asarray([0,0,0])\\n\\t\\t\\t#append all vectors defining the center\\n\\t\\t\\tfor i in range(len(centerlist[vec_count])):\\n\\t\\t\\t\\t# x y z\\n\\t\\t\\t\\tr.append( np.asarray( [ ATOM_list[centerlist[vec_count][i] + reference][1],ATOM_list[centerlist[vec_count][i] + reference][2],ATOM_list[centerlist[vec_count][i] + reference][3] ] ) ) \\n\\t\\t\\t\\tcenter = center + r[i]\\n\\t\\t\\tcenter = center / len(centerlist[vec_count])\\n\\t\\t\\n\\t\\t\\t#calculate all reference vectors\\n\\t\\t\\tr=[]\\n\\t\\t\\tfor i in range(len(referencelist[vec_count])):\\n\\t\\t\\t\\tr.append(np.asarray( [ ATOM_list[referencelist[vec_count][i] + reference][1],ATOM_list[referencelist[vec_count][i] + reference][2],ATOM_list[referencelist[vec_count][i] + reference][3] ] ) )\\n\\t\\t\\n\\t\\t\\t#get the cross products\\n\\t\\t\\tnormal_vec= np.asarray([0,0,0])\\n\\t\\t\\tfor i in range(len(r)):\\n\\t\\t\\t\\tif (i<(len(r)-1)):\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t#minimum image convenction\\n\\t\\t\\t\\t\\tif ( abs(r[i][0]-center[0]) < abs(r[i][0]-center[0]+boxX) ) and ( abs(r[i][0]-center[0]) < abs(r[i][0]-center[0]-boxX) ):\\n\\t\\t\\t\\t\\t\\tdx = r[i][0]-center[0]\\n\\t\\t\\t\\t\\telif (abs(r[i][0]-center[0]+boxX) < abs(r[i][0]-center[0]-boxX) ):\\n\\t\\t\\t\\t\\t\\tdx = r[i][0]-center[0]+boxX\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdx = r[i][0]-center[0]-boxX\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif ( abs(r[i][1]-center[1]) < abs(r[i][1]-center[1]+boxY) ) and ( abs(r[i][1]-center[1]) < abs(r[i][1]-center[1]-boxY) ):\\n\\t\\t\\t\\t\\t\\tdy = r[i][1]-center[1]\\n\\t\\t\\t\\t\\telif (abs(r[i][1]-center[1]+boxY) < abs(r[i][1]-center[1]-boxY) ):\\n\\t\\t\\t\\t\\t\\tdy = r[i][1]-center[1]+boxY\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdy = r[i][1]-center[1]-boxY\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif ( abs(r[i][2]-center[2]) < abs(r[i][2]-center[2]+boxZ) ) and ( abs(r[i][2]-center[2]) < abs(r[i][2]-center[2]-boxZ) ):\\n\\t\\t\\t\\t\\t\\tdz = r[i][2]-center[2]\\n\\t\\t\\t\\t\\telif (abs(r[i][2]-center[2]+boxZ) < abs(r[i][2]-center[2]-boxZ) ):\\n\\t\\t\\t\\t\\t\\tdz = r[i][2]-center[2]+boxZ\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdz = r[i][2]-center[2]-boxZ\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t#minimum image convenction\\n\\t\\t\\t\\t\\tif ( abs(r[i+1][0]-center[0]) < abs(r[i+1][0]-center[0]+boxX) ) and ( abs(r[i+1][0]-center[0]) < abs(r[i+1][0]-center[0]-boxX) ):\\n\\t\\t\\t\\t\\t\\tdx2 = r[i+1][0]-center[0]\\n\\t\\t\\t\\t\\telif (abs(r[i+1][0]-center[0]+boxX) < abs(r[i+1][0]-center[0]-boxX) ):\\n\\t\\t\\t\\t\\t\\tdx2 = r[i+1][0]-center[0]+boxX\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdx2 = r[i+1][0]-center[0]-boxX\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif ( abs(r[i+1][1]-center[1]) < abs(r[i+1][1]-center[1]+boxY) ) and ( abs(r[i+1][1]-center[1]) < abs(r[i+1][1]-center[1]-boxY) ):\\n\\t\\t\\t\\t\\t\\tdy2 = r[i+1][1]-center[1]\\n\\t\\t\\t\\t\\telif (abs(r[i+1][1]-center[1]+boxY) < abs(r[i+1][1]-center[1]-boxY) ):\\n\\t\\t\\t\\t\\t\\tdy2 = r[i+1][1]-center[1]+boxY\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdy2 = r[i+1][1]-center[1]-boxY\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif ( abs(r[i+1][2]-center[2]) < abs(r[i+1][2]-center[2]+boxZ) ) and ( abs(r[i+1][2]-center[2]) < abs(r[i+1][2]-center[2]-boxZ) ):\\n\\t\\t\\t\\t\\t\\tdz2 = r[i+1][2]-center[2]\\n\\t\\t\\t\\t\\telif (abs(r[i+1][2]-center[2]+boxZ) < abs(r[i+1][2]-center[2]-boxZ) ):\\n\\t\\t\\t\\t\\t\\tdz2 = r[i+1][2]-center[2]+boxZ\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdz2 = r[i+1][2]-center[2]-boxZ\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tvec1=np.asarray([dx,dy,dz])\\n\\t\\t\\t\\t\\tvec2=np.asarray([dx2,dy2,dz2])\\n\\t\\t\\t\\t\\t#dy = r[i][1]-center[1]\\n\\t\\t\\t\\t\\t#dz = r[i][2]-center[2]\\n\\t\\t\\t\\t\\t#normal_vec = normal_vec + np.cross(r[i]-center, r[i+1]-center)\\n\\t\\t\\t\\t\\tnormal_vec = normal_vec + np.cross(vec1, vec2)/np.linalg.norm( np.cross(vec1, vec2) )\\n\\t\\t\\t\\telif ( i==len(r) ):\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t#minimum image convenction\\n\\t\\t\\t\\t\\tdx = min( abs(r[i][0]-center[0]), abs(r[i][0]-center[0]+boxX), abs(r[i][0]-center[0]-boxX) )\\n\\t\\t\\t\\t\\tdy = min( abs(r[i][1]-center[1]), abs(r[i][1]-center[1]+boxX), abs(r[i][1]-center[1]-boxX) )\\n\\t\\t\\t\\t\\tdz = min( abs(r[i][2]-center[2]), abs(r[i][2]-center[2]+boxX), abs(r[i][2]-center[2]-boxX) )\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tdx2 = min( abs(r[0][0]-center[0]), abs(r[0][0]-center[0]+boxX), abs(r[0][0]-center[0]-boxX) )\\n\\t\\t\\t\\t\\tdy2 = min( abs(r[0][1]-center[1]), abs(r[0][1]-center[1]+boxX), abs(r[0][1]-center[1]-boxX) )\\n\\t\\t\\t\\t\\tdz2 = min( abs(r[0][2]-center[2]), abs(r[0][2]-center[2]+boxX), abs(r[0][2]-center[2]-boxX) )\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tvec1=np.asarray([dx,dy,dz])\\n\\t\\t\\t\\t\\tvec2=np.asarray([dx2,dy2,dz2])\\n\\t\\t\\t\\t\\t#dy = r[i][1]-center[1]\\n\\t\\t\\t\\t\\t#dz = r[i][2]-center[2]\\n\\t\\t\\t\\t\\t#normal_vec = normal_vec + np.cross(r[i]-center, r[i+1]-center)\\n\\t\\t\\t\\t\\tnormal_vec = normal_vec + np.cross(vec1, vec2)/np.linalg.norm(np.cross(vec1, vec2))\\n\\t\\t\\t\\t\\t#normal_vec = normal_vec + np.cross(r[i]-center, r[0]-center) \\n\\t\\t\\n\\t\\t\\t#normalize\\n\\t\\t\\tnormal_vec = normal_vec/np.linalg.norm(normal_vec)\\n\\t\\t\\n\\t\\t\\t#\\t#direction vectors\\n\\t\\t\\t#\\tdir_vec1 = np.asarray([r[6][0],r[6][1],r[6][2]])\\n\\t\\t\\t#\\tdir_vec2 = np.asarray([r[7][0],r[7][1],r[7][2]])\\n\\t\\t\\t#\\tdir_vec3 = np.asarray([r[8][0],r[8][1],r[8][2]])\\n\\t\\t\\t#\\tdir_vec4 = np.asarray([r[9][0],r[9][1],r[9][2]])\\n\\t\\t\\t#\\tdir_vec = (dir_vec1 + dir_vec2 + dir_vec3 + dir_vec4)/4.0\\n\\t\\t\\t#\\tdir_vec = mittelpunkt_dpi - dir_vec\\t\\t\\t\\n\\n\\t\\t\\t#change direction according to bending\\n\\t\\t\\t#\\tif normal_vec[0]!=0 and dir_vec[0]!=0:\\n\\t\\t\\t#\\t\\tif normal_vec[0]/abs(normal_vec[0])!=dir_vec[0]/abs(dir_vec[0]):\\n\\t\\t\\t#\\t\\t\\tnormal_vec[0] = -normal_vec[0]\\n\\t\\t\\t#\\tif normal_vec[1]!=0 and dir_vec[1]!=0:\\n\\t\\t#\\t\\t\\tif normal_vec[1]/abs(normal_vec[1])!=dir_vec[1]/abs(dir_vec[1]):\\n\\t\\t#\\t\\t\\t\\tnormal_vec[1] = -normal_vec[1]\\n\\t\\t#\\t\\tif normal_vec[2]!=0 and dir_vec[2]!=0:\\n\\t\\t#\\t\\t\\tif normal_vec[2]/abs(normal_vec[2])!=dir_vec[2]/abs(dir_vec[2]):\\n\\t\\t#\\t\\t\\t\\tnormal_vec[2] = -normal_vec[2]\\n\\n\\t\\t\\t\\n\\t\\t\\t#check for a vorzugsvektor\\n\\t\\t\\tvorzugsvektor = vorzugsvektor + normal_vec\\n\\t\\t\\tNORMAL_VECTORS_out.write('C' +'\\t'+ str((center)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tNORMAL_VECTORS_out.write('O' +'\\t'+ str((center+normal_vec)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tANGLEDIST_VECTORS_out.write('C' +'\\t'+ str((center)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tANGLEDIST_VECTORS_out.write('H' +'\\t'+ str((normal_vec)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tNORMAL_VECTORS_check.write('C' +'\\t'+ str((center)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tNORMAL_VECTORS_check.write('O' +'\\t'+ str((center+normal_vec)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tNORMAL_VECTORS_check.write('H' +'\\t'+ str((normal_vec)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tfor i in range(len(referencelist[vec_count])):\\n\\t\\t\\t\\tNORMAL_VECTORS_check.write('N' +'\\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][1])+'\\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][2])+'\\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][3])+ '\\\\n')\\n\\n\\t\\t#always skip 1 entire molecule forward\\n\\t\\treference=reference + number_of_atoms/number_of_molecules\\n\\t\\t\\n\\t#calculate a vorzugsvektor as sum over DIPBI normal vectors divided by number of DPBI vectors\\n\\tvorzugsvektor = vorzugsvektor/(number_of_vectors*frames*number_of_molecules)\\n\\tVorzugsrichtung_out.write(str(frame) + ' ' + str((vorzugsvektor)).replace('[', '').replace(']','')+'\\\\n')\\n\\tNORMAL_VECTORS_out.close()\\n\\tNORMAL_VECTORS_check.close()\\n\\treturn\",\n \"def _fit_plane_to_point_cloud(\\n points_xyz: NDArrayFloat,\\n) -> Tuple[float, float, float, float]:\\n center_xyz: NDArrayFloat = np.mean(points_xyz, axis=0)\\n out: Tuple[NDArrayFloat, NDArrayFloat, NDArrayFloat] = np.linalg.svd(\\n points_xyz - center_xyz\\n )\\n vh = out[2]\\n\\n # Get the unitary normal vector\\n a, b, c = float(vh[2, 0]), float(vh[2, 1]), float(vh[2, 2])\\n d: float = -np.dot([a, b, c], center_xyz)\\n return (a, b, c, d)\",\n \"def vector_line(self):\\n assert len(self.xcoords) == 2\\n diff_x = self.xcoords[1] - self.xcoords[0]\\n diff_z = self.zcoords[1] - self.zcoords[0]\\n vec = np.hstack((diff_x, diff_z))\\n return vec\",\n \"def uvmap(self, p):\\n # bottom left corner of the plane\\n p00 = self.position - (self.sx * self.n0) / 2 - (self.sy * self.n1) / 2\\n dif_vector = p - p00\\n u = np.dot(dif_vector, self.n0) / self.sx\\n v = np.dot(dif_vector, self.n1) / self.sy\\n return u, v\",\n \"def point_form(boxes):\\n return torch.cat((boxes[:, :2] - boxes[:, 2:] / 2, boxes[:, :2] + boxes[:, 2:] / 2), 1)\",\n \"def point_form(boxes):\\n return torch.cat((boxes[:, :2] - boxes[:, 2:] / 2, boxes[:, :2] + boxes[:, 2:] / 2), 1)\",\n \"def plot_plane(unit_normal, x_array, y_array, fore):\\n # print'unit normal = ', unit_normal\\n z = (((unit_normal[0] * (fore[0] - x_array)) + (unit_normal[1] * (fore[1] - y_array))) / unit_normal[2]) + fore[2]\\n # print 'plane numbers\\\\n', z\\n return z\",\n \"def uv(vec):\\n return vec / sqrt(dot(vec, vec))\",\n \"def vec(self):\\r\\n\\r\\n xv = np.arange(self.dx / 2, self.lx, self.dx)\\r\\n yv = np.arange(-self.ly / 2 + self.dy / 2, self.ly / 2, self.dy)\\r\\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\\r\\n\\r\\n if self.ox != 0:\\r\\n xv = np.arange(self.ox, self.lx + self.ox, self.dx)\\r\\n yv = np.arange(self.oy, self.ly + self.oy, self.dy)\\r\\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\\r\\n\\r\\n return xv, yv, zv\",\n \"def _normal_vector(o, p0_3d, p1_3d):\\n # The vector between middle point of v1-v2 and object center location\\n # is the normal vector I'm looking for\\n vn = p0_3d.lerp(p1_3d, 0.5) - o.matrix_world.translation\\n # normalize so I can to length computation on it\\n vn.normalize()\\n return vn\",\n \"def project_vectors(self, vectors):\\n return np.dot(vectors, self.components.T)\",\n \"def generate_normals(v1, v2, v3, normalize_result=True):\\n # make vectors relative to v2\\n # we assume opengl counter-clockwise ordering\\n a = v1 - v2\\n b = v3 - v2\\n n = cross(b, a)\\n if normalize_result:\\n n = normalize(n)\\n return n\",\n \"def find_plane_angles(self, roof_motor_position):\\n\\n # Calcolo il punto mediano tra i vertici 2 e 3\\n pc_x = (self.roof_vertex_x[1] + self.roof_vertex_x[2]) / 2\\n pc_y = (self.roof_vertex_y[1] + self.roof_vertex_y[2]) / 2\\n pc_z = (self.roof_vertex_z[1] + self.roof_vertex_z[2]) / 2\\n\\n # Questa non so cosa sia\\n base_r = [[self.roof_vertex_x[0] - pc_x, self.roof_vertex_y[0] - pc_y, self.roof_vertex_z[0] - pc_z],\\n [self.roof_vertex_x[1] - pc_x, self.roof_vertex_y[1] - pc_y, self.roof_vertex_z[1] - pc_z],\\n [0.0, 0.0, 0.0]]\\n\\n # Questa e' la costruzione di una matrice\\n mat_rot = [[0.0, 0.0, 0.0],\\n [0.0, 0.0, 0.0],\\n [0.0, 0.0, 0.0]]\\n\\n # Non so quale operazione è implementata, ma a me servono solo tre elementi, j=2, i=0,1, j=1, i=0\\n # Primo elemento, j=1, i=0\\n mr = math.sqrt((base_r[0][0] ** 2) + (base_r[0][1] ** 2) + (base_r[0][2] ** 2))\\n mat_rot[1][0] = base_r[0][1] / mr\\n # Secondo elemento, j=2, i=0\\n mat_rot[2][0] = base_r[0][2] / mr\\n # Terzo elemento, j=2, i=1\\n mr = math.sqrt((base_r[1][0] ** 2) + (base_r[1][1] ** 2) + (base_r[1][2] ** 2))\\n mat_rot[2][1] = base_r[1][2] / mr\\n\\n # In alternativa posso calcolare tutti gli elementi della matrice\\n # for i in range(2):\\n # mr = math.sqrt((base_r[i][0] ** 2) + (base_r[i][1] ** 2) + (base_r[i][2] ** 2))\\n # for j in range(3):\\n # base_r[i][j] /= mr\\n # mat_rot[j][i] = base_r[i][j]\\n\\n # Sono elementi della matrice non utilizzati\\n # base_r[2][0] = +base_r[1][1] * base_r[0][2] - base_r[0][1] * base_r[1][2]\\n # base_r[2][1] = -base_r[1][0] * base_r[0][2] + base_r[0][0] * base_r[1][2]\\n # base_r[2][2] = +base_r[1][0] * base_r[0][1] - base_r[0][0] * base_r[1][1]\\n # for i in range(3):\\n # mat_rot[i][2] = base_r[2][i]\\n\\n # Qui estraggo la terna di Tait-Bryan angles usata internamente, la Z1Y2X3\\n k17 = mat_rot[2][0]\\n k16 = mat_rot[1][0]\\n l17 = mat_rot[2][1]\\n m20 = math.asin(k17)\\n i23 = math.cos(m20)\\n i24 = k16 / i23\\n i25 = l17 / i23\\n m19 = math.asin(i24)\\n self.zyx1_r = m19 + roof_motor_position\\n self.zyx2_r = math.asin(k17)\\n self.zyx3_r = math.asin(i25)\\n self.zyx3 = self.zyx3_r / Kinematic.M_TO_RAD\\n self.zyx2 = self.zyx2_r / Kinematic.M_TO_RAD\\n self.zyx1 = self.zyx1_r / Kinematic.M_TO_RAD\\n angles = self.zyx_r_to_xyz(self.zyx3_r, self.zyx2_r, self.zyx1_r)\\n self.xyz1 = angles[2]\\n self.xyz2 = angles[0]\\n self.xyz3 = angles[1]\\n self.xyz1_r = angles[5]\\n self.xyz2_r = angles[3]\\n self.xyz3_r = angles[4]\",\n \"def normal(self) -> Vec:\\n # The three points are in clockwise order, so compute differences\\n # in the clockwise direction, then cross to get the normal.\\n point_1 = self.planes[1] - self.planes[0]\\n point_2 = self.planes[2] - self.planes[1]\\n\\n return Vec.cross(point_1, point_2).norm()\",\n \"def test_perpendicular_to_vectors():\\n random_state = np.random.RandomState(0)\\n a = pr.norm_vector(pr.random_vector(random_state))\\n a1 = pr.norm_vector(pr.random_vector(random_state))\\n b = pr.norm_vector(pr.perpendicular_to_vectors(a, a1))\\n c = pr.norm_vector(pr.perpendicular_to_vectors(a, b))\\n assert_almost_equal(pr.angle_between_vectors(a, b), np.pi / 2.0)\\n assert_almost_equal(pr.angle_between_vectors(a, c), np.pi / 2.0)\\n assert_almost_equal(pr.angle_between_vectors(b, c), np.pi / 2.0)\\n assert_array_almost_equal(pr.perpendicular_to_vectors(b, c), a)\\n assert_array_almost_equal(pr.perpendicular_to_vectors(c, a), b)\",\n \"def get_normals(self):\\n c, s = np.cos(self.eangles), np.sin(self.eangles)\\n r = np.array([[c, -s], [s, c]])\\n us = np.array([[1, 0], [0, 1], [-1, 0], [0, -1]])\\n nsyms = 4 if self.halfexts[0] == self.halfexts[1] else 2\\n return [(np.dot(r, u), nsyms) for u in us]\",\n \"def invgeochart(w):\\n # u = torch.asin(w[...,2])\\n u = torch.acos(w[...,2])\\n # v = torch.acos(w[...,0]/torch.cos(u))\\n v = torch.atan(w[...,1]/w[...,0])\\n return torch.stack((u,v+np.pi))\",\n \"def unit_normals(p,q,r): \\n vx1 = p[0] - r[0] # x1 - x3. \\n vy1 = p[1] - r[1] # y1 - y3. \\n vz1 = p[2] - r[2] # z1 - z3. \\n\\n vx2 = q[0] - r[0] # x2 - x3. \\n vy2 = q[1] - r[1] # y2 - y3. \\n vz2 = q[2] - r[2] # z2 - z3. \\n\\n vnx = vy1*vz2 - vz1*vy2 \\n vny = vz1*vx2 - vx1*vz2 \\n vnz = vx1*vy2 - vy1*vx2 \\n\\n len_vn = math.sqrt(vnx*vnx + vny*vny + vnz*vnz) \\n vnx = vnx/len_vn \\n vny = vny/len_vn \\n vnz = vnz/len_vn \\n\\n return vnx, vny, vnz\",\n \"def vertexes(self):\\n theta = self.orientation\\n shifts = np.array([np.cos(theta), np.sin(theta)]) * self.a\\n return self.coords + (shifts[:, None] * [-1, 1]).T\",\n \"def miller(points):\\r\\n\\r\\n N = np.cross(points[1] - points[0], points[2] - points[0])\\r\\n O = np.array([0, 0, 0])\\r\\n P = points[0] # point of plane\\r\\n Ccs = map(np.array, [[1.0, 0, 0], [0, 1.0, 0], [0, 0, 1.0]])\\r\\n segments = ([np.dot(P - O, N) / np.dot(ort, N) if np.dot(ort, N) != 0 else\\r\\n np.nan for ort in Ccs])\\r\\n if any(x == 0 for x in segments): # Plane goes through origin.\\r\\n vertices = [ # top:\\r\\n np.array([1.0, 1.0, 1.0]),\\r\\n np.array([0.0, 0.0, 1.0]),\\r\\n np.array([1.0, 0.0, 1.0]),\\r\\n np.array([0.0, 1.0, 1.0]),\\r\\n # bottom, except 0,0,0:\\r\\n np.array([1.0, 0.0, 0.0]),\\r\\n np.array([0.0, 1.0, 0.0]),\\r\\n np.array([1.0, 1.0, 1.0]),\\r\\n ]\\r\\n for vertex in vertices:\\r\\n if np.dot(vertex - O, N) != 0: # vertex not in plane\\r\\n new_origin = vertex\\r\\n break\\r\\n # obtain new axes with center in new origin\\r\\n X = np.array([1 - new_origin[0], new_origin[1], new_origin[2]])\\r\\n Y = np.array([new_origin[0], 1 - new_origin[1], new_origin[2]])\\r\\n Z = np.array([new_origin[0], new_origin[1], 1 - new_origin[2]])\\r\\n new_Ccs = [X - new_origin, Y - new_origin, Z - new_origin]\\r\\n segments = ([np.dot(P - new_origin, N) / np.dot(ort, N) if\\r\\n np.dot(ort, N) != 0 else np.nan for ort in new_Ccs])\\r\\n # fix signs of indices: 0 -> 1, 1 -> -1 (\\r\\n segments = (1 - 2 * new_origin) * segments\\r\\n\\r\\n return sub_miller(segments)\",\n \"def vector(self):\\n \\n v_list = Householder.triangle_operation(self)[1]\\n \\n return(v_list)\",\n \"def onBase():\\n return (vector(1, 0, 0), vector(0, 1, 0), vector(0, 0, 1))\",\n \"def magni(vector):\\n return(np.linalg.norm(vector))\",\n \"def vector(molec, dihed, nonH, energy):\\n #Torison\\n if dihed:\\n pass\\n #XYZ\\n else:\\n coords = ()\\n if nonH:\\n for atom in molec.atoms:\\n coords += atom.coords\\n else:\\n for atom in molec.atoms:\\n if atom.atomicnum > 1:\\n coords += atom.coords\\n #Energy\\n if energy:\\n coords += (molec.energy/10.0,)\\n return coords\",\n \"def cxvec(self):\\n return np.array([self.cx, self.cy])\",\n \"def to_indices(self, world_coords):\\n (x, y, z) = world_coords\\n (cx, cy, cz) = self.center\\n\\n px = x - cx\\n py = y - cy\\n pz = z - cz\\n\\n # project u and v\\n # TODO: Can this be done with some built-in Numpy operation?\\n (ux, uy, uz) = self.u_dir\\n (vx, vy, vz) = self.v_dir\\n u = px * ux + py * uy + pz * uz\\n v = px * vx + py * vy + pz * vz\\n\\n # rescale to pixel coordinates. u is up, v is down\\n (H, W, _) = self.shape\\n i = rescale(-1, 1, H - 1, 0, v)\\n j = rescale(-1, 1, 0, W -1, u)\\n\\n return (i, j)\",\n \"def generate_V(self):\\n\\n n_samples, n_dimensions, L = self.n_samples, self.n_dimensions, self.L\\n\\n V = np.zeros([L + 1, n_dimensions], dtype=int)\\n V[1:, 0] = [1 << (self.scale - j) for j in range(1, L + 1)]\\n\\n for i in range(n_dimensions - 1):\\n\\n m = np.array(directions[i], dtype=int)\\n s = len(m) - 1\\n\\n # The following code discards the first row of the ``m`` array\\n # Because it has floating point errors, e.g. values of 2.24e-314\\n if L <= s:\\n V[1:, i + 1] = [m[j] << (self.scale - j) for j in range(1, L + 1)]\\n else:\\n V[1 : s + 1, i + 1] = [\\n m[j] << (self.scale - j) for j in range(1, s + 1)\\n ]\\n for j in range(s + 1, L + 1):\\n V[j, i + 1] = V[j - s, i + 1] ^ (V[j - s, i + 1] >> s)\\n for k in range(1, s):\\n V[j, i + 1] ^= ((m[0] >> (s - 1 - k)) & 1) * V[j - k][i + 1]\\n\\n return V\",\n \"def test_perpendicular_to_vector():\\n assert_almost_equal(pr.angle_between_vectors(\\n pr.unitx, pr.perpendicular_to_vector(pr.unitx)), np.pi / 2.0)\\n assert_almost_equal(pr.angle_between_vectors(\\n pr.unity, pr.perpendicular_to_vector(pr.unity)), np.pi / 2.0)\\n assert_almost_equal(pr.angle_between_vectors(\\n pr.unitz, pr.perpendicular_to_vector(pr.unitz)), np.pi / 2.0)\\n random_state = np.random.RandomState(0)\\n for _ in range(5):\\n a = pr.norm_vector(pr.random_vector(random_state))\\n assert_almost_equal(pr.angle_between_vectors(\\n a, pr.perpendicular_to_vector(a)), np.pi / 2.0)\\n b = a - np.array([a[0], 0.0, 0.0])\\n assert_almost_equal(pr.angle_between_vectors(\\n b, pr.perpendicular_to_vector(b)), np.pi / 2.0)\\n c = a - np.array([0.0, a[1], 0.0])\\n assert_almost_equal(pr.angle_between_vectors(\\n c, pr.perpendicular_to_vector(c)), np.pi / 2.0)\\n d = a - np.array([0.0, 0.0, a[2]])\\n assert_almost_equal(pr.angle_between_vectors(\\n d, pr.perpendicular_to_vector(d)), np.pi / 2.0)\",\n \"def uVectNorm(x1,y1,z1, # P\\n x2,y2,z2, # Q\\n x3,y3,z3): # R\\n p1 = np.array([x1,y1,z1])\\n p2 = np.array([x2,y2,z2])\\n p3 = np.array([x3,y3,z3])\\n\\n v1 = p3-p1\\n v2 = p2-p1\\n\\n cp = np.cross(v1,v2)\\n a,b,c = cp\\n\\n d = np.dot(cp, p3)\\n\\n print(a,b,c)\",\n \"def cartesian_of_projective(z):\\n alpha = z[0,:]\\n beta = z[1,:]\\n vz = np.real(np.conj(alpha)*alpha - np.conj(beta)*beta)\\n vx_plus_ivy = 2*np.conj(alpha)*beta\\n vx = np.real(vx_plus_ivy)\\n vy = np.imag(vx_plus_ivy)\\n return vx, vy, vz\",\n \"def perp_2d_vec(vec):\\n return normalized(np.dot(R90, vec))\",\n \"def get_plane_of_points(\\n self,\\n normal_vector=\\\"z\\\",\\n planar_coordinate=None,\\n ):\\n # Get results vectors\\n if (normal_vector == \\\"z\\\"):\\n x_flat = self.floris.grid.x_sorted_inertial_frame[0, 0].flatten()\\n y_flat = self.floris.grid.y_sorted_inertial_frame[0, 0].flatten()\\n z_flat = self.floris.grid.z_sorted_inertial_frame[0, 0].flatten()\\n else:\\n x_flat = self.floris.grid.x_sorted[0, 0].flatten()\\n y_flat = self.floris.grid.y_sorted[0, 0].flatten()\\n z_flat = self.floris.grid.z_sorted[0, 0].flatten()\\n u_flat = self.floris.flow_field.u_sorted[0, 0].flatten()\\n v_flat = self.floris.flow_field.v_sorted[0, 0].flatten()\\n w_flat = self.floris.flow_field.w_sorted[0, 0].flatten()\\n\\n # Create a df of these\\n if normal_vector == \\\"z\\\":\\n df = pd.DataFrame(\\n {\\n \\\"x1\\\": x_flat,\\n \\\"x2\\\": y_flat,\\n \\\"x3\\\": z_flat,\\n \\\"u\\\": u_flat,\\n \\\"v\\\": v_flat,\\n \\\"w\\\": w_flat,\\n }\\n )\\n if normal_vector == \\\"x\\\":\\n df = pd.DataFrame(\\n {\\n \\\"x1\\\": y_flat,\\n \\\"x2\\\": z_flat,\\n \\\"x3\\\": x_flat,\\n \\\"u\\\": u_flat,\\n \\\"v\\\": v_flat,\\n \\\"w\\\": w_flat,\\n }\\n )\\n if normal_vector == \\\"y\\\":\\n df = pd.DataFrame(\\n {\\n \\\"x1\\\": x_flat,\\n \\\"x2\\\": z_flat,\\n \\\"x3\\\": y_flat,\\n \\\"u\\\": u_flat,\\n \\\"v\\\": v_flat,\\n \\\"w\\\": w_flat,\\n }\\n )\\n\\n # Subset to plane\\n # TODO: Seems sloppy as need more than one plane in the z-direction for GCH\\n if planar_coordinate is not None:\\n df = df[np.isclose(df.x3, planar_coordinate)] # , atol=0.1, rtol=0.0)]\\n\\n # Drop duplicates\\n # TODO is this still needed now that we setup a grid for just this plane?\\n df = df.drop_duplicates()\\n\\n # Sort values of df to make sure plotting is acceptable\\n df = df.sort_values([\\\"x2\\\", \\\"x1\\\"]).reset_index(drop=True)\\n\\n return df\",\n \"def fit_plane_to_point_cloud(pc: np.ndarray) -> Tuple[Any, Any, Any, Any]:\\n center = pc.sum(axis=0) / pc.shape[0]\\n u, s, vh = np.linalg.svd(pc - center)\\n\\n # Get the unitary normal vector\\n u_norm = vh[2, :]\\n d = -np.dot(u_norm, center)\\n a, b, c = u_norm\\n return a, b, c, d\",\n \"def getVectors(self):\\n l = len(self.points)\\n return [Vector.createFromTwoPoints(self.points[i % l], self.points[(i + 1) % l], \\\\\\n color=self.side_color, width=self.side_width) for i in range(l)]\",\n \"def to_mesh(\\n self,\\n lims_x: array_like = (-1, 1),\\n lims_y: array_like = (-1, 1),\\n ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\\n a, b, c, d = self.cartesian()\\n x_center, y_center = self.point[:2]\\n\\n values_x = x_center + lims_x\\n values_y = y_center + lims_y\\n\\n X, Y = np.meshgrid(values_x, values_y)\\n\\n if c != 0:\\n Z = -(a * X + b * Y + d) / c\\n\\n elif b != 0:\\n Z = -(a * X + c * Y + d) / b\\n X, Y, Z = X, Z, Y\\n\\n else:\\n Z = -(b * X + c * Y + d) / a\\n X, Y, Z = Z, X, Y\\n\\n return X, Y, Z\",\n \"def normalize_vectors(motion_vectors):\\n if np.shape(motion_vectors)[0] == 0:\\n return motion_vectors\\n else:\\n motion_vectors[:, 7] = motion_vectors[:, 7] / motion_vectors[:, 0] # motion_x\\n motion_vectors[:, 8] = motion_vectors[:, 8] / motion_vectors[:, 0] # motion_y\\n motion_vectors[:, 0] = -1 * np.ones_like(motion_vectors[:, 0])\\n return motion_vectors\",\n \"def test_from_two_vectors(self):\\r\\n for _ in range(20):\\r\\n v0 = np.random.randn(3)\\r\\n v1 = np.random.randn(3)\\r\\n v0 /= np.linalg.norm(v0)\\r\\n v1 /= np.linalg.norm(v1)\\r\\n\\r\\n q = from_two_vectors(v0, v1)\\r\\n R = to_rotation(q)\\r\\n\\r\\n zero_vec = R @ v0 - v1\\r\\n self.assertAlmostEqual(np.linalg.norm(zero_vec), 0.0)\\r\\n\\r\\n q_inv = from_two_vectors(v1, v0)\\r\\n R_inv = to_rotation(q_inv)\\r\\n zero_matrix = R @ R_inv - np.identity(3)\\r\\n self.assertAlmostEqual(np.linalg.norm(zero_matrix), 0.0)\",\n \"def make_inward_normal(tetrahedron):\\n\\n convert_to_np_array = lambda v: np.array([v.x, v.y, v.z])\\n np_vertices = list(map(convert_to_np_array, [tetrahedron.get_vertex(i) for i in range(4)]))\\n # This is the middle point\\n # midpoint = np.mean(np_vertices, axis=0)\\n\\n midpoint = np_vertices[0]\\n for i in range(1, 4):\\n midpoint += np_vertices[i]\\n midpoint = midpoint / 2.0\\n\\n for i in range(4):\\n face = tetrahedron.get_face(i)\\n d = distance(face, midpoint)\\n if d < 0:\\n face.nx *= -1.0\\n face.ny *= -1.0\\n face.nz *= -1.0\\n face.d *= -1.0\",\n \"def landmarks_as_vectors(landmarks):\\n mat = []\\n for lm in landmarks:\\n mat.append(lm.as_vector())\\n return np.array(mat)\",\n \"def _orthogonal_vector(vector):\\n return -1 * vector[1], vector[0]\",\n \"def find_perpendicular_vector(vt):\\n x, y = vt\\n return np.array([y, -x])\",\n \"def lic_flow(vectors,len_pix=10):\\n vectors = np.asarray(vectors)\\n m,n,two = vectors.shape\\n if two!=2:\\n raise ValueError\\n\\n result = np.zeros((2*len_pix+1,m,n,2),dtype=np.int32) # FIXME: int16?\\n center = len_pix\\n result[center,:,:,0] = np.arange(m)[:,np.newaxis]\\n result[center,:,:,1] = np.arange(n)[np.newaxis,:]\\n\\n for i in range(m):\\n for j in range(n):\\n y = i\\n x = j\\n fx = 0.5\\n fy = 0.5\\n for k in range(len_pix):\\n vx, vy = vectors[y,x]\\n print x, y, vx, vy\\n if vx>=0:\\n tx = (1-fx)/vx\\n else:\\n tx = -fx/vx\\n if vy>=0:\\n ty = (1-fy)/vy\\n else:\\n ty = -fy/vy\\n if tx<ty:\\n print \\\"x step\\\"\\n if vx>0:\\n x+=1\\n fy+=vy*tx\\n fx=0.\\n else:\\n x-=1\\n fy+=vy*tx\\n fx=1.\\n else:\\n print \\\"y step\\\"\\n if vy>0:\\n y+=1\\n fx+=vx*ty\\n fy=0.\\n else:\\n y-=1\\n fx+=vx*ty\\n fy=1.\\n if x<0: x=0\\n if y<0: y=0\\n if x>=n: x=n-1\\n if y>=m: y=m-1\\n result[center+k+1,i,j,:] = y, x\\n\\n\\n\\n return result\",\n \"def face_normals(xyz, triangles):\\n\\n\\tabc_xyz = face_attr(xyz, triangles)\\n\\n\\tbc_xyz = abc_xyz[:,:,1:3] - abc_xyz[:,:,0:1]\\n\\tfn = tf.linalg.cross(bc_xyz[:,:,0], bc_xyz[:,:,1])\\n\\tfn = tf.math.l2_normalize(fn, -1)\\n\\treturn fn\",\n \"def vector_potential(self, xyz):\\n r = self.distance(xyz)\\n a = (\\n (self.current * self.length) / (4*np.pi*r) *\\n np.exp(-i*self.wavenumber*r)\\n )\\n a = np.kron(np.ones(1, 3), np.atleast_2d(a).T)\\n return self.dot_orientation(a)\",\n \"def vrrotvec2mat(ax_ang):\\n\\n #file_dir = os.path.dirname(os.path.realpath(__file__))\\n #path_dir2 = file_dir + '/../geometry/'\\n #sys.path.append(path_dir2)\\n\\n if ax_ang.ndim == 1:\\n if np.size(ax_ang) == 5:\\n ax_ang = np.reshape(ax_ang, (5, 1))\\n msz = 1\\n elif np.size(ax_ang) == 4:\\n ax_ang = np.reshape(np.hstack((ax_ang, np.array([1]))), (5, 1))\\n msz = 1\\n else:\\n raise Exception('Wrong Input Type')\\n elif ax_ang.ndim == 2:\\n if np.shape(ax_ang)[0] == 5:\\n msz = np.shape(ax_ang)[1]\\n elif np.shape(ax_ang)[1] == 5:\\n ax_ang = ax_ang.transpose()\\n msz = np.shape(ax_ang)[1]\\n else:\\n raise Exception('Wrong Input Type')\\n else:\\n raise Exception('Wrong Input Type')\\n\\n direction = ax_ang[0:3, :]\\n angle = ax_ang[3, :]\\n\\n d = np.array(direction, dtype=np.float64)\\n d /= np.linalg.norm(d, axis=0)\\n x = d[0, :]\\n y = d[1, :]\\n z = d[2, :]\\n c = np.cos(angle)\\n s = np.sin(angle)\\n tc = 1 - c\\n\\n mt11 = tc*x*x + c\\n mt12 = tc*x*y - s*z\\n mt13 = tc*x*z + s*y\\n\\n mt21 = tc*x*y + s*z\\n mt22 = tc*y*y + c\\n mt23 = tc*y*z - s*x\\n\\n mt31 = tc*x*z - s*y\\n mt32 = tc*y*z + s*x\\n mt33 = tc*z*z + c\\n\\n mtx = np.column_stack((mt11, mt12, mt13, mt21, mt22, mt23, mt31, mt32, mt33))\\n\\n inds1 = np.where(ax_ang[4, :] == -1)\\n mtx[inds1, :] = -mtx[inds1, :]\\n\\n if msz == 1:\\n mtx = mtx.reshape(3, 3)\\n else:\\n mtx = mtx.reshape(msz, 3, 3)\\n\\n return mtx\",\n \"def spherical2cartesian(v):\\n \\n x = np.cos(v[0]) * np.cos(v[1]) \\n y = np.cos(v[0]) * np.sin(v[1]) \\n z = np.sin(v[0]) \\n \\n return [x,y,z]\",\n \"def vincdecnorm(arr):\\n tmp = convert(arr, GEOCENTRIC_CARTESIAN, GEOCENTRIC_SPHERICAL)\\n return -tmp[..., 0], tmp[..., 1], tmp[..., 2]\",\n \"def _prepare_plane(self):\\n verticies = [\\n # main plane - note that the mainplane is scaled so the mat_plane\\n # matrix will it transform to the correct coordinates\\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\\n -self.i_border[0]/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], self.i_border[1]/self._scaling[1],\\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\\n\\n # coord plane\\n 0, 0,\\n 0, -self.o_wh[1],\\n self.o_wh[0], -self.o_wh[1],\\n self.o_wh[0], -self.o_wh[1],\\n self.o_wh[0], 0,\\n 0, 0,\\n\\n # axes\\n 0, -self.o_wh[1], self.o_wh[0], -self.o_wh[1], #x\\n 0, 0, 0, -self.o_wh[1], #y\\n ]\\n\\n colors = [\\n 1.0, 1.0, 1.0, 1.0, # outer box XXX Remove outer box...\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n .9, .9, .9, 9.0, # plot box\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n 0.0, 0.0, 0.0, 1.0, #lines\\n 0.0, 0.0, 0.0, 1.0,\\n 0.0, 0.0, 0.0, 1.0,\\n 0.0, 0.0, 0.0, 1.0,\\n ]\\n\\n self._fonts = []\\n for u in range(1, self._unit_count[0]+1):\\n verticies.append(self._unit_w[0]*u)\\n verticies.append(-self.o_wh[1]+0.02)\\n verticies.append(self._unit_w[0]*u)\\n verticies.append(-self.o_wh[1]-0.02)\\n colors += [0.0, 0.0, 0.0, 1.0]\\n colors += [0.0, 0.0, 0.0, 1.0]\\n self._fonts.append([\\n '{:.2f}'.format(u*(self.i_axis[0]/self._unit_count[0])-self.i_origin[0]),\\n (self._unit_w[0]*u+self.i_border[0]-0.05)*self._scaling[0],\\n (-self.o_wh[1]+(self.i_border[3])*0.5)\\n ])\\n for u in range(0, self._unit_count[1]):\\n verticies.append(0.02)\\n verticies.append(-self._unit_w[1]*u)\\n verticies.append(-0.02)\\n verticies.append(-self._unit_w[1]*u)\\n colors += [0.0, 0.0, 0.0, 1.0]\\n colors += [0.0, 0.0, 0.0, 1.0]\\n self._fonts.append([\\n '{:.2f}'.format(self.i_axis[1]-u*self.i_axis[1]/self._unit_count[1]-self.i_origin[1]),\\n (0.025)*self._scaling[0],\\n (-(self._unit_w[1])*u-self.i_border[1]+0.01)*self._scaling[1]\\n ])\\n\\n self._draw_plane_indicies = (0, 12)\\n self._draw_line_indicies = (12, 4+self._unit_count[0]*2+self._unit_count[1]*2)\\n\\n # convert data into valid data format\\n verticies = numpy.array(verticies, dtype=numpy.float32)\\n colors = numpy.array(colors, dtype=numpy.float32)\\n\\n self._plane_vao = util.VAO()\\n self._plane_vbo = util.VBO(2)\\n\\n with self._plane_vao:\\n # plane verticies\\n with self._plane_vbo.get(0):\\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(verticies), verticies, GL_STATIC_DRAW)\\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_position'), 2, GL_FLOAT, GL_FALSE, 0, None)\\n glEnableVertexAttribArray(0)\\n\\n # place vertex colors\\n with self._plane_vbo.get(1):\\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(colors), colors, GL_STATIC_DRAW)\\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_color'), 4, GL_FLOAT, GL_FALSE, 0, None)\\n glEnableVertexAttribArray(1)\",\n \"def unit_vectors(x):\\n xnew = x.copy()\\n for v in range(x.shape[-1]):\\n xnew[:, v] = x[:, v] / np.linalg.norm(x[:, v])\\n return xnew\",\n \"def _spherical_to_cartesian(ra, dec):\\n rar = np.radians(ra)\\n decr = np.radians(dec)\\n\\n x = np.cos(rar) * np.cos(decr)\\n y = np.sin(rar) * np.cos(decr)\\n z = np.sin(decr)\\n \\n return x, y, z\",\n \"def vector_convert(self, pos) :\\n delta = AUTO_width2//3\\n bright_list = []\\n for i in range(-1,2):\\n for j in range(-1,2) :\\n b = 0\\n count = 0\\n for x in range(max(0, pos[0] + i*delta), min(self.m_x, pos[0] + (i+1)*delta)):\\n for y in range(max(0, pos[1] + j*delta), min(self.m_y, pos[1] + (j+1)*delta)):\\n b += self.current_array[x][y]\\n count += 1\\n if count == 0 :\\n bright_list.append(0)\\n else :\\n if b == 0 : #prevent 0 divde\\n b = 1\\n bright_list.append(b/count)\\n bright_list = np.array(bright_list)\\n m = np.max(bright_list)/self.current_total_avg\\n bright_list = bright_list/np.min(bright_list) -1\\n bright_list = np.append(bright_list, m)\\n return bright_list\",\n \"def reciprocal_lattice_vectors(a):\\n b = np.zeros(shape=(3,3))\\n b[:,0] = 2 * np.pi * np.cross(a[:,1], a[:,2]) / triple_product(a[:,0], a[:,1], a[:,2])\\n b[:,1] = 2 * np.pi * np.cross(a[:,2], a[:,0]) / triple_product(a[:,1], a[:,2], a[:,0])\\n b[:,2] = 2 * np.pi * np.cross(a[:,0], a[:,1]) / triple_product(a[:,2], a[:,0], a[:,1])\\n return b\",\n \"def hexgrid(self):\\n n = self.n * 2\\n vectors = []\\n for u in range(-n, n+1):\\n us = [u] * (2*n+1)\\n if u < 0:\\n vectors.extend(zip(us, range(-n-u, n+1), range(-n, n+u+1)))\\n else:\\n vectors.extend(zip(us, range(-n, n-u+1), range(-n+u, n+1)))\\n return vectors\",\n \"def lin_a98rgb_to_xyz(rgb: Vector) -> Vector:\\n\\n return alg.dot(RGB_TO_XYZ, rgb, dims=alg.D2_D1)\",\n \"def getNormalizedNormalVec(self):\\n TriPos = self.position\\n # calc normalized normal vecor for Tri\\n # get vectors Vert1Vert2 & Vert2Vert3\\n TriVectors = np.subtract(TriPos[1:],TriPos[:-1])\\n # get crossproduct of Vert1Vert2 & Vert2Vert3 (= surface normal)\\n TriNorm = np.cross(TriVectors[0],TriVectors[1])+0.0\\n # get length of surface normal\\n length = np.linalg.norm(TriNorm)\\n # divide each component of surface normal by length (= normalized surface normal)\\n NormalizedNormalVec = np.around(TriNorm / length, decimals=5) # rounded, otherwise different values, equals not found\\n # create string of tuple for segment dict \\n #SegmDict = str(tuple(NormalizedNormalVec))\\n return NormalizedNormalVec.tolist()\",\n \"def project_point_plane(point, plane):\\n base, normal = plane\\n normal = normalize_vector(normal)\\n vector = subtract_vectors(point, base)\\n snormal = scale_vector(normal, dot_vectors(vector, normal))\\n return subtract_vectors(point, snormal)\",\n \"def unit_vectors(direction, inclination, mask=None):\\n UnitX = np.sin(0.5 * np.pi - inclination) * np.cos(direction)\\n UnitY = np.sin(0.5 * np.pi - inclination) * np.sin(direction)\\n UnitZ = np.cos(0.5 * np.pi - inclination)\\n\\n if mask:\\n _mask = np.logical_not(mask)\\n UnitX[_mask] = 0\\n UnitY[_mask] = 0\\n UnitZ[_mask] = 0\\n\\n return UnitX, UnitY, UnitZ\",\n \"def normal_vector(self, facet):\\n assert len(facet) == 3\\n pos = self.cluster.get_positions()\\n v1 = pos[facet[1], :] - pos[facet[0], :]\\n v2 = pos[facet[2], :] - pos[facet[0], :]\\n n = np.cross(v1, v2)\\n length = np.sqrt(np.sum(n**2))\\n return n / length\",\n \"def el2rv(mu,a,e,i,capom,om,f):\\n\\n prec = 1.0e-13 #user can change this if more precision needed (just runs slower)\\n\\n #compute the unit vector\\n u = om + f\\n xhat = np.cos(u)*np.cos(capom) - np.cos(i)*np.sin(capom)*np.sin(u)\\n yhat = np.cos(u)*np.sin(capom) + np.cos(i)*np.cos(capom)*np.sin(u)\\n zhat = np.sin(i)*np.sin(u)\\n\\n #compute the angular momentum vector (unit vector)\\n hx = np.sin(capom)*np.sin(i)\\n hy = -np.cos(capom)*np.sin(i)\\n hz = np.cos(i)\\n\\n #assuming not parabolic, here the magnitudes of the vectors\\n r = a * (1.0 - e*e) / (1.0 + e*np.cos(f))\\n h = ( mu*a*(1.0 - e*e) )**0.5\\n\\n #position vectors\\n x = r * xhat\\n y = r * yhat\\n z = r * zhat\\n\\n #compute components of vector theta hat\\n thx = hy * zhat - hz * yhat\\n thy = hz * xhat - hx * zhat\\n thz = hx * yhat - hy * xhat\\n\\n #obtain the velocity vector's components and calculate v\\n thdot = h/(r*r)\\n rdot = e*mu*np.sin(f)/h\\n\\n vx = r * thdot * thx + rdot * xhat\\n vy = r * thdot * thy + rdot * yhat\\n vz = r * thdot * thz + rdot * zhat\\n\\n return x,y,z\",\n \"def normal(axis_direction, axis_origin, point):\\n # transform input into numpy arrays\\n axis_direction = np.array(axis_direction, float)\\n axis_origin = np.array(axis_origin, float)\\n point = np.array(point, float)\\n\\n # vector from axis normal_origin to point\\n vector = point - axis_origin\\n\\n # projection of vector on axis\\n projection = np.dot(vector, axis_direction)*axis_direction\\n\\n # the normal vector from normal_origin to point\\n normal_direction = vector - projection\\n\\n # normalized normal_direction\\n normal_direction = normal_direction/np.linalg.norm(normal_direction)\\n\\n # opposite of the projection of vector on normal\\n projection2 = - np.dot(normal_direction, vector)*normal_direction\\n\\n normal_origin = point + projection2\\n\\n return normal_direction, normal_origin\",\n \"def get_perpendicular2d(vector):\\n if vector[1] == 0:\\n return np.asarray([0.,1.])\\n v2_0 = 1.0\\n v2_1 = -(vector[0]/vector[1])\\n v2 = np.asarray([v2_0, v2_1])\\n return v2 / np.linalg.norm(v2)\",\n \"def vector_perp(v):\\n assert len(v) == 2\\n x, y = v\\n return Vector(-y, x)\",\n \"def _vehicle_to_world(cords, vehicle):\\n\\n bb_transform = carla.Transform(vehicle.bounding_box.location)\\n bb_vehicle_matrix = ClientSideBoundingBoxes.get_matrix(bb_transform)\\n vehicle_world_matrix = ClientSideBoundingBoxes.get_matrix(vehicle.get_transform())\\n bb_world_matrix = np.dot(vehicle_world_matrix, bb_vehicle_matrix)\\n world_cords = np.dot(bb_world_matrix, np.transpose(cords))\\n return world_cords\",\n \"def find_direction_vector(line):\\n pt1, pt2 = line\\n pt1 = np.array(pt1).reshape(2,)\\n pt2 = np.array(pt2).reshape(2,)\\n direct = pt2 - pt1\\n direct_norm = normalize(direct)\\n return direct_norm\",\n \"def apply_direction_scale( vectors, direction, scale ):\\n \\\"\\\"\\\"\\n scaling is defined as:\\n \\n [p'][1 + (k - 1)n.x^2, (k - 1)n.x n.y^2, (k - 1)n.x n.z ]\\n S(n,k) = [q'][(k - 1)n.x n.y, 1 + (k - 1)n.y, (k - 1)n.y n.z ]\\n [r'][(k - 1)n.x n.z, (k - 1)n.y n.z, 1 + (k - 1)n.z^2 ]\\n \\n where:\\n v' is the resulting vector after scaling\\n v is the vector to scale\\n n is the direction of the scaling\\n n.x is the x component of n\\n n.y is the y component of n\\n n.z is the z component of n\\n k is the scaling factor\\n \\\"\\\"\\\"\\n scaleMinus1 = scale - 1\\n matrix = numpy.array(\\n [\\n # m1\\n [\\n # m11 = 1 + (k - 1)n.x^2\\n 1 + scaleMinus1 * (direction[ 0 ]**2),\\n # m12 = (k - 1)n.x n.y^2\\n scaleMinus1 * direction[ 0 ] * direction[ 1 ]**2,\\n # m13 = (k - 1)n.x n.z\\n scaleMinus1 * direction[ 0 ] * direction[ 2 ]\\n ],\\n # m2\\n [\\n # m21 = (k - 1)n.x n.y\\n scaleMinus1 * direction[ 0 ] * direction[ 1 ],\\n # m22 = 1 + (k - 1)n.y\\n 1 + scaleMinus1 * direction[ 1 ],\\n # m23 = (k - 1)n.y n.z\\n scaleMinus1 * direction[ 1 ] * direction[ 2 ]\\n ],\\n # m3\\n [\\n # m31 = (k - 1)n.x n.z\\n scaleMinus1 * direction[ 0 ] * direction[ 2 ],\\n # m32 = (k - 1)n.y n.z\\n scaleMinus1 * direction[ 1 ] * direction[ 2 ],\\n # m33 = 1 + (k - 1)n.z^2\\n 1 + scaleMinus1 * direction[ 2 ]**2\\n ]\\n ],\\n dtype = numpy.float\\n )\\n \\n return numpy.dot( vectors, matrix )\",\n \"def build_coord(norm, d, pts):\\n # Compute the origin as the mean point of the points, and this point has to be on the plane\\n \\n n = len(pts) \\n x_total = 0\\n y_total = 0\\n z_total = 0\\n \\n for i in range(n):\\n x_total += pts[i][0]\\n y_total += pts[i][1]\\n z_total += pts[i][2]\\n\\n x_o = x_total * 1.0 / n\\n y_o = y_total * 1.0 / n\\n z_o = z_total * 1.0 / n\\n p_o = [x_o, y_o, z_o]\\n \\n # Choose p be the projection of a vector in the z-axis to the plane\\n # If the plane is not perpendicular to the z-axis\\n if ((norm[2] != 1) and (norm[2] != -1)): \\n # Choose a point\\n o_z = [x_o, y_o, z_o + 1]\\n \\n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\\n \\n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\\n\\n x_c = (x_p - x_o) * 1.0 / dist \\n y_c = (y_p - y_o) * 1.0 / dist\\n z_c = (z_p - z_o) * 1.0 / dist\\n # Thus we have unit vector in x direction\\n e_y = [x_c, y_c, z_c]\\n #Compute the unit vector in y direction\\n e_x = np.cross(e_y, norm).tolist()\\n else:\\n e_x = [1, 0, 0]\\n e_y = [0, 1, 0]\\n \\n return [e_x, e_y, norm] , p_o\",\n \"def normals(t, v):\\n n = numpy.zeros((len(t), 3))\\n for i in range(0, len(t)):\\n p = vertices(t[i], v)\\n n[i] = triangle.normal(p)\\n return n\",\n \"def make_lattice(min,max,lattice_vectors):\\n xs = np.roll(np.arange(min[0],max[0]),max[0])\\n ys = np.roll(np.arange(min[1],max[1]),max[1])\\n lattice = np.dstack(np.meshgrid(xs,ys)).reshape(-1,2)\\n lattice = np.matmul(lattice,lattice_vectors)\\n return lattice\",\n \"def _build_mcid_vectors(self, model: BDF, nplies: int):\\n etype = 3 # vtkLine\\n\\n nodes, bars = export_mcids_all(model, eids=None, log=None, debug=False)\\n for iply, nodesi in nodes.items():\\n barsi = bars[iply]\\n if iply == -1:\\n name = 'element material coord'\\n else:\\n name = f'mcid ply={iply+1}'\\n\\n nbars = len(barsi)\\n if nbars == 0:\\n # isotropic\\n continue\\n assert nbars > 0, model.card_count\\n\\n is_visible = False\\n self.gui.create_alternate_vtk_grid(\\n name, color=RED_FLOAT, line_width=3, opacity=1.0,\\n representation='surface', is_visible=is_visible, is_pickable=False)\\n grid = self.gui.alt_grids[name]\\n grid.Allocate(nbars, 1000)\\n\\n nodes_array = np.array(nodesi, dtype='float32')\\n elements = np.array(barsi, dtype='int32')\\n assert elements.min() == 0, elements.min()\\n points = numpy_to_vtk_points(nodes_array, points=None, dtype='<f', deep=1)\\n grid.SetPoints(points)\\n create_vtk_cells_of_constant_element_type(grid, elements, etype)\\n return\",\n \"def mni2vxl(coord):\\n i = int((90.0 - coord[0]) / 2)\\n j = int((coord[1] + 126) / 2)\\n k = int((coord[2] + 72) / 2)\\n return (i, j, k)\",\n \"def z_to_vector(vector):\\n norm = np.linalg.norm(vector)\\n if norm == 0:\\n return np.identity(3)\\n v = np.array(vector) / norm\\n phi = np.arccos(v[2])\\n if any(v[:2]):\\n #projection of vector to unit circle\\n axis_proj = v[:2] / np.linalg.norm(v[:2])\\n theta = np.arccos(axis_proj[0])\\n if axis_proj[1] < 0:\\n theta = -theta\\n else:\\n theta = 0\\n phi_down = np.array([\\n [np.cos(phi), 0, np.sin(phi)],\\n [0, 1, 0],\\n [-np.sin(phi), 0, np.cos(phi)]\\n ])\\n return np.dot(rotation_about_z(theta), phi_down)\",\n \"def unit_vector(vector):\\n #print 'unit_vector'\\n #print vector\\n #print type(vector)\\n #npvector = np.array(vector)\\n return vector / np.linalg.norm(vector)\",\n \"def get_perpendicular(n: np.ndarray) -> np.ndarray:\\n # find smallest component\\n i = np.argmin(n)\\n\\n # get the other two indices\\n a = (i + 1) % 3\\n b = (i + 2) % 3\\n\\n result = np.zeros(3)\\n result[i] = 0.0\\n result[a] = n[b]\\n result[b] = -n[a]\\n return result\",\n \"def get_vectors(nodes, mode=\\\"xform\\\"):\\n for each in nodes:\\n position = (0, 0, 0)\\n\\n if mode == \\\"xform\\\":\\n position = cmds.xform(\\n each,\\n query=True,\\n translation=True,\\n worldSpace=True,\\n )\\n\\n elif mode == \\\"pivot\\\":\\n position = cmds.xform(\\n each,\\n query=True,\\n translation=True,\\n rotatePivot=True,\\n worldSpace=True,\\n )\\n\\n # when using xform on component like faces or edge, the returned value\\n # will be a list of each vertices position, so we need to average that\\n if len(position) > 3:\\n vectors = [\\n MVector(position[i : i + 3])\\n for i in range(0, len(position), 3)\\n ]\\n result = MVector()\\n for vector in vectors:\\n result += vector\\n position = result / len(vectors)\\n\\n yield MVector(position)\",\n \"def convert_hkl_to_xyz2(self, hkl):\\n # Use the hkl miller indices to calculate the normal to a plane in cartesian space\\n p = []\\n if not hkl[0] == 0:\\n p.append(np.array(self.lattice[0] / hkl[0]))\\n if not hkl[1] == 0:\\n p.append(np.array(self.lattice[1] / hkl[1]))\\n if not hkl[2] == 0:\\n p.append(np.array(self.lattice[2] / hkl[2]))\\n if hkl[0] == 0:\\n p.append(self.lattice[0] + p[0])\\n if hkl[1] == 0:\\n p.append(self.lattice[1] + p[0])\\n if hkl[2] == 0:\\n p.append(self.lattice[2] + p[0])\\n p12 = p[1] - p[0]\\n p13 = p[2] - p[0]\\n normal = np.cross(p12, p13)\\n norm = np.linalg.norm(normal)\\n if norm < 1.0e-8:\\n print(\\\"Error in unit cell, calculation of normal to miller index failed\\\")\\n exit(1)\\n normal = normal / norm\\n return normal\",\n \"def grab_40_vectors(x1,x2,y1,y2) -> list:\\n\\n if x1 > x2:\\n x1,x2 = x2,x1\\n if y1 > y2:\\n y1,y2 = y2,y1\\n\\n height = abs(y2-y1)\\n length = abs(x2-x1)\\n\\n height_delta = height/10\\n length_delta = length/10\\n\\n left_vertical_edge = [(x1, y1+height_delta*i) for i in range(0,11)]\\n # print(left_vertical_edge)\\n right_vertical_edge = [(x2,y1+height_delta*i) for i in range(0,11)]\\n # print(right_vertical_edge)\\n bottom_horizontal_edge = [(x1+length_delta*i,y1) for i in range(0,11)]\\n # print(bottom_horizontal_edge)\\n top_horizontal_edge = [(x1+length_delta*i,y2) for i in range(0,11)]\\n # print(top_horizontal_edge)\\n\\n all_vectors = left_vertical_edge+right_vertical_edge+bottom_horizontal_edge+top_horizontal_edge\\n return(all_vectors)\",\n \"def npxywha2vertex(box):\\n batch = box.shape[0]\\n\\n center = box[:,:2]\\n w = box[:,2]\\n h = box[:,3]\\n rad = box[:,4]\\n\\n # calculate two vector\\n verti = np.empty((batch,2), dtype=np.float32)\\n verti[:,0] = (h/2) * np.sin(rad)\\n verti[:,1] = - (h/2) * np.cos(rad)\\n\\n hori = np.empty((batch,2), dtype=np.float32)\\n hori[:,0] = (w/2) * np.cos(rad)\\n hori[:,1] = (w/2) * np.sin(rad)\\n\\n tl = center + verti - hori\\n tr = center + verti + hori\\n br = center - verti + hori\\n bl = center - verti - hori\\n\\n return np.concatenate([tl,tr,br,bl], axis=1)\",\n \"def npxywha2vertex(box):\\n batch = box.shape[0]\\n\\n center = box[:,:2]\\n w = box[:,2]\\n h = box[:,3]\\n rad = box[:,4]\\n\\n # calculate two vector\\n verti = np.empty((batch,2), dtype=np.float32)\\n verti[:,0] = (h/2) * np.sin(rad)\\n verti[:,1] = - (h/2) * np.cos(rad)\\n\\n hori = np.empty((batch,2), dtype=np.float32)\\n hori[:,0] = (w/2) * np.cos(rad)\\n hori[:,1] = (w/2) * np.sin(rad)\\n\\n tl = center + verti - hori\\n tr = center + verti + hori\\n br = center - verti + hori\\n bl = center - verti - hori\\n\\n return np.concatenate([tl,tr,br,bl], axis=1)\",\n \"def volume_tetrahedron(xyz, A, B, C, D):\\n\\n AD = xyz[A, :] - xyz[D, :]\\n BD = xyz[B, :] - xyz[D, :]\\n CD = xyz[C, :] - xyz[D, :]\\n\\n V = (\\n (BD[:, 0] * CD[:, 1] - BD[:, 1] * CD[:, 0]) * AD[:, 2]\\n - (BD[:, 0] * CD[:, 2] - BD[:, 2] * CD[:, 0]) * AD[:, 1]\\n + (BD[:, 1] * CD[:, 2] - BD[:, 2] * CD[:, 1]) * AD[:, 0]\\n )\\n return V / 6\",\n \"def build_coord(norm, d, pts):\\n # Compute the origin as the mean point of the points, and this point has to be on the plane\\n \\n n = len(pts)\\n x_total = 0\\n y_total = 0\\n z_total = 0\\n \\n for i in range(n):\\n x_total += pts[i][0]\\n y_total += pts[i][1]\\n z_total += pts[i][2]\\n\\n x_o = x_total * 1.0 / n\\n y_o = y_total * 1.0 / n\\n z_o = z_total * 1.0 / n\\n p_o = [x_o, y_o, z_o]\\n \\n # Choose p be the projection of a vector in the z-axis to the plane\\n # If the plane is not perpendicular to the z-axis\\n if ((norm[2] != 1) and (norm[2] != -1)): \\n # Choose a point\\n o_z = [x_o, y_o, z_o + 1]\\n \\n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\\n \\n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\\n\\n x_c = (x_p - x_o) * 1.0 / dist \\n y_c = (y_p - y_o) * 1.0 / dist\\n z_c = (z_p - z_o) * 1.0 / dist\\n # Thus we have unit vector in x direction\\n e_y = [x_c, y_c, z_c]\\n #Compute the unit vector in y direction\\n e_x = np.cross(e_y, norm).tolist()\\n else:\\n e_x = [1, 0, 0]\\n e_y = [0, 1, 0]\\n \\n return [e_x, e_y, norm] , p_o\",\n \"def normal(self) -> Vec:\\n return abs(self.up_axis.cross(self.forward()))\",\n \"def vector(self) -> Vector:\\n return self._normal * self._distance_from_origin\",\n \"def map_vects(self, input_vects):\\n \\n if not self._trained:\\n raise ValueError(\\\"SOM not trained yet\\\")\\n \\n to_return = []\\n \\n distances = []\\n \\n \\n contador_adyacentes = 0\\n \\n matriz = np.array(list(self._neuron_locations(self._m, self._n)))\\n \\n m = self._m\\n \\n n = self._n\\n \\n matrices = []\\n \\n matrices = np.stack((matriz,\\n matriz + np.array([m,n]), \\n matriz - np.array([m,n]), \\n matriz + np.array([m,0]),\\n matriz - np.array([m,0]),\\n matriz + np.array([0,n]),\\n matriz - np.array([0,n]),\\n matriz + np.array([m,-n]),\\n matriz + np.array([-m,n])\\n ))\\n \\n distancias_matriz = []\\n\\n for i in range(n*m):\\n distancias_matriz.append([])\\n for j in range(m*n):\\n distancias_matriz[i].append(np.min(np.sum(np.power(np.subtract(matriz[i], matrices[:,j]),2), axis = 1)))\\n \\n distancias_matriz = np.array(distancias_matriz)\\n \\n \\n for vect in input_vects:\\n\\n # min_index is the index of the BMU\\n \\n lista_indices = [i for i in range(len(self._weightages))]\\n \\n min_index = min(lista_indices,\\n key=lambda x: np.linalg.norm(vect - self._weightages[x]))\\n\\n # min_index_2 is the index of the 2nd BMU\\n \\n lista_indices.pop(min_index) # El indice es el mismo que el valor\\n \\n min_index_2 = min(lista_indices,\\n key=lambda x: np.linalg.norm(vect - self._weightages[x])) \\n \\n r2 = np.sqrt(2)\\n\\n if np.sqrt(distancias_matriz[min_index][min_index_2]) > r2: \\n# print('loc 1')\\n# print(locaciones[min_index])\\n# print('loc 2')\\n# print(locaciones[min_index_2])\\n contador_adyacentes += 1\\n\\n\\n distance = np.linalg.norm(vect - self._weightages[min_index])\\n \\n distances.append(distance)\\n \\n to_return.append(self._locations[min_index]) \\n \\n # Quantization Error qe (the mean of all distances to the BMU)!\\n self.distances = distances \\n \\n # Topographic error te\\n self.proporcion = contador_adyacentes / len(input_vects)\\n \\n self.prom_dist = np.mean(self.distances)\\n \\n return to_return\",\n \"def co_vertexes(self):\\n theta = self.orientation + np.pi / 2\\n shifts = np.array([np.cos(theta), np.sin(theta)]) * self.b\\n return self.coords + (shifts[:, None] * [-1, 1]).T\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6565002","0.65067965","0.64226294","0.62855655","0.6252082","0.6249797","0.62446517","0.6125102","0.60917956","0.5859786","0.58306587","0.57857585","0.5702033","0.5697134","0.5696204","0.56910414","0.56821984","0.5681735","0.5674337","0.56567013","0.5653223","0.5653223","0.56456405","0.56343573","0.56310534","0.56244004","0.5618517","0.5592912","0.5588631","0.5583483","0.5568483","0.5563822","0.55624014","0.5552205","0.5534117","0.55322695","0.55308044","0.552635","0.55246085","0.55213064","0.5498682","0.5497379","0.54937226","0.54920965","0.5488526","0.54808295","0.54722506","0.5455926","0.5448821","0.5439921","0.54376096","0.5432535","0.54266435","0.5423324","0.5423088","0.5412957","0.5412921","0.54030323","0.5401576","0.5390089","0.53845066","0.5383754","0.5378276","0.53781855","0.53724825","0.5367523","0.53658897","0.5359341","0.533856","0.53376716","0.53370017","0.5334416","0.5334016","0.5333367","0.5322789","0.5319204","0.5319012","0.530903","0.53003305","0.52959144","0.52794033","0.52785915","0.5271678","0.5267434","0.5267149","0.52645385","0.5261402","0.52582544","0.525679","0.52499723","0.5248222","0.524565","0.52450895","0.52450895","0.5243755","0.52430314","0.52380353","0.5233742","0.5233335","0.5232909"],"string":"[\n \"0.6565002\",\n \"0.65067965\",\n \"0.64226294\",\n \"0.62855655\",\n \"0.6252082\",\n \"0.6249797\",\n \"0.62446517\",\n \"0.6125102\",\n \"0.60917956\",\n \"0.5859786\",\n \"0.58306587\",\n \"0.57857585\",\n \"0.5702033\",\n \"0.5697134\",\n \"0.5696204\",\n \"0.56910414\",\n \"0.56821984\",\n \"0.5681735\",\n \"0.5674337\",\n \"0.56567013\",\n \"0.5653223\",\n \"0.5653223\",\n \"0.56456405\",\n \"0.56343573\",\n \"0.56310534\",\n \"0.56244004\",\n \"0.5618517\",\n \"0.5592912\",\n \"0.5588631\",\n \"0.5583483\",\n \"0.5568483\",\n \"0.5563822\",\n \"0.55624014\",\n \"0.5552205\",\n \"0.5534117\",\n \"0.55322695\",\n \"0.55308044\",\n \"0.552635\",\n \"0.55246085\",\n \"0.55213064\",\n \"0.5498682\",\n \"0.5497379\",\n \"0.54937226\",\n \"0.54920965\",\n \"0.5488526\",\n \"0.54808295\",\n \"0.54722506\",\n \"0.5455926\",\n \"0.5448821\",\n \"0.5439921\",\n \"0.54376096\",\n \"0.5432535\",\n \"0.54266435\",\n \"0.5423324\",\n \"0.5423088\",\n \"0.5412957\",\n \"0.5412921\",\n \"0.54030323\",\n \"0.5401576\",\n \"0.5390089\",\n \"0.53845066\",\n \"0.5383754\",\n \"0.5378276\",\n \"0.53781855\",\n \"0.53724825\",\n \"0.5367523\",\n \"0.53658897\",\n \"0.5359341\",\n \"0.533856\",\n \"0.53376716\",\n \"0.53370017\",\n \"0.5334416\",\n \"0.5334016\",\n \"0.5333367\",\n \"0.5322789\",\n \"0.5319204\",\n \"0.5319012\",\n \"0.530903\",\n \"0.53003305\",\n \"0.52959144\",\n \"0.52794033\",\n \"0.52785915\",\n \"0.5271678\",\n \"0.5267434\",\n \"0.5267149\",\n \"0.52645385\",\n \"0.5261402\",\n \"0.52582544\",\n \"0.525679\",\n \"0.52499723\",\n \"0.5248222\",\n \"0.524565\",\n \"0.52450895\",\n \"0.52450895\",\n \"0.5243755\",\n \"0.52430314\",\n \"0.52380353\",\n \"0.5233742\",\n \"0.5233335\",\n \"0.5232909\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5339138"},"document_rank":{"kind":"string","value":"68"}}},{"rowIdx":94483,"cells":{"query":{"kind":"string","value":"Converts cartesian vectors into MillerBravais vector indices"},"document":{"kind":"string","value":"def mplane(B, c):\n # for Sun Mg Potential: c=1.6281689374348\n A = np.zeros(shape=4)\n s = A.shape\n phi = 0\n l = 0\n b = 0\n for i in range(s[0]):\n A[0] = (2 / 3) * B[0]\n A[1] = 0.5 * ((2 / sqrt(3)) * B[1] - A[0])\n A[2] = -A[0] - A[1]\n phi = atan(B[1] / B[0])\n b = 0.5 * sqrt(3) / sin(2 * pi / 3 - phi)\n l = sqrt(B[0] ** 2 + B[1] ** 2)\n A[3] = c * B[2] / (l * b)\n return A"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def cartesian2bary(self, x):\n lam = np.zeros((x.shape[0], 3))\n lam[:,:2] = np.einsum('ij,kj->ki', self.Tinv, x - self.xv[2])\n lam[:,2] = 1. - lam[:,0] - lam[:,1]\n return lam","def project_vectors(self, vectors):\n return np.dot(vectors, self.components.T)","def cxvec(self):\n return np.array([self.cx, self.cy])","def project_vectors(self, vectors):\n X = vectors - self._mean\n return np.dot(X, self.components.T)","def unit_vectors(self):\n # return {'comp1': CartesianRepresentation(...),\n # 'comp2': CartesianRepresentation(...),\n # 'comp3': CartesianRepresentation(...)}\n raise Exception(\"Not yet implemented\")","def to_indices(self, world_coords):\n (x, y, z) = world_coords\n (cx, cy, cz) = self.center\n\n px = x - cx\n py = y - cy\n pz = z - cz\n\n # project u and v\n # TODO: Can this be done with some built-in Numpy operation?\n (ux, uy, uz) = self.u_dir\n (vx, vy, vz) = self.v_dir\n u = px * ux + py * uy + pz * uz\n v = px * vx + py * vy + pz * vz\n\n # rescale to pixel coordinates. u is up, v is down\n (H, W, _) = self.shape\n i = rescale(-1, 1, H - 1, 0, v)\n j = rescale(-1, 1, 0, W -1, u)\n\n return (i, j)","def _build_mcid_vectors(self, model: BDF, nplies: int):\n etype = 3 # vtkLine\n\n nodes, bars = export_mcids_all(model, eids=None, log=None, debug=False)\n for iply, nodesi in nodes.items():\n barsi = bars[iply]\n if iply == -1:\n name = 'element material coord'\n else:\n name = f'mcid ply={iply+1}'\n\n nbars = len(barsi)\n if nbars == 0:\n # isotropic\n continue\n assert nbars > 0, model.card_count\n\n is_visible = False\n self.gui.create_alternate_vtk_grid(\n name, color=RED_FLOAT, line_width=3, opacity=1.0,\n representation='surface', is_visible=is_visible, is_pickable=False)\n grid = self.gui.alt_grids[name]\n grid.Allocate(nbars, 1000)\n\n nodes_array = np.array(nodesi, dtype='float32')\n elements = np.array(barsi, dtype='int32')\n assert elements.min() == 0, elements.min()\n points = numpy_to_vtk_points(nodes_array, points=None, dtype='<f', deep=1)\n grid.SetPoints(points)\n create_vtk_cells_of_constant_element_type(grid, elements, etype)\n return","def vector(self):\n \n v_list = Householder.triangle_operation(self)[1]\n \n return(v_list)","def toIndexes(self, binaryVector):\n\t\treturn n.array([i for i,v in enumerate(binaryVector) if v], dtype=\"int32\")","def bary2cartesian(self, lam):\n return np.einsum('ij,jk', lam, self.xv)","def onBase():\n return (vector(1, 0, 0), vector(0, 1, 0), vector(0, 0, 1))","def vector(molec, dihed, nonH, energy):\n #Torison\n if dihed:\n pass\n #XYZ\n else:\n coords = ()\n if nonH:\n for atom in molec.atoms:\n coords += atom.coords\n else:\n for atom in molec.atoms:\n if atom.atomicnum > 1:\n coords += atom.coords\n #Energy\n if energy:\n coords += (molec.energy/10.0,)\n return coords","def transform_coord_to_vector(coords,vector_dim):\r\n\t\r\n\tnew_vector = [0] * vector_dim\r\n\tfor c in coords:\r\n\t\tnew_vector[c[0]] = c[1]\r\n\r\n\treturn new_vector","def spherical2cartesian(v):\n \n x = np.cos(v[0]) * np.cos(v[1]) \n y = np.cos(v[0]) * np.sin(v[1]) \n z = np.sin(v[0]) \n \n return [x,y,z]","def map_vects(self, input_vects):\n \n if not self._trained:\n raise ValueError(\"SOM not trained yet\")\n \n to_return = []\n \n distances = []\n \n \n contador_adyacentes = 0\n \n matriz = np.array(list(self._neuron_locations(self._m, self._n)))\n \n m = self._m\n \n n = self._n\n \n matrices = []\n \n matrices = np.stack((matriz,\n matriz + np.array([m,n]), \n matriz - np.array([m,n]), \n matriz + np.array([m,0]),\n matriz - np.array([m,0]),\n matriz + np.array([0,n]),\n matriz - np.array([0,n]),\n matriz + np.array([m,-n]),\n matriz + np.array([-m,n])\n ))\n \n distancias_matriz = []\n\n for i in range(n*m):\n distancias_matriz.append([])\n for j in range(m*n):\n distancias_matriz[i].append(np.min(np.sum(np.power(np.subtract(matriz[i], matrices[:,j]),2), axis = 1)))\n \n distancias_matriz = np.array(distancias_matriz)\n \n \n for vect in input_vects:\n\n # min_index is the index of the BMU\n \n lista_indices = [i for i in range(len(self._weightages))]\n \n min_index = min(lista_indices,\n key=lambda x: np.linalg.norm(vect - self._weightages[x]))\n\n # min_index_2 is the index of the 2nd BMU\n \n lista_indices.pop(min_index) # El indice es el mismo que el valor\n \n min_index_2 = min(lista_indices,\n key=lambda x: np.linalg.norm(vect - self._weightages[x])) \n \n r2 = np.sqrt(2)\n\n if np.sqrt(distancias_matriz[min_index][min_index_2]) > r2: \n# print('loc 1')\n# print(locaciones[min_index])\n# print('loc 2')\n# print(locaciones[min_index_2])\n contador_adyacentes += 1\n\n\n distance = np.linalg.norm(vect - self._weightages[min_index])\n \n distances.append(distance)\n \n to_return.append(self._locations[min_index]) \n \n # Quantization Error qe (the mean of all distances to the BMU)!\n self.distances = distances \n \n # Topographic error te\n self.proporcion = contador_adyacentes / len(input_vects)\n \n self.prom_dist = np.mean(self.distances)\n \n return to_return","def Indexes(self, latitudes, longitudes):\n res = self._transform.TransformPoints(\n np.column_stack((longitudes, latitudes)))\n res = list(zip(*res))\n x, y = np.array(res[0]), np.array(res[1])\n idx_col = self._inv_txf[0] + self._inv_txf[1] * x + self._inv_txf[2] * y\n idx_row = self._inv_txf[3] + self._inv_txf[4] * x + self._inv_txf[5] * y\n return idx_row.astype(int), idx_col.astype(int)","def vector_convert(self, pos) :\n delta = AUTO_width2//3\n bright_list = []\n for i in range(-1,2):\n for j in range(-1,2) :\n b = 0\n count = 0\n for x in range(max(0, pos[0] + i*delta), min(self.m_x, pos[0] + (i+1)*delta)):\n for y in range(max(0, pos[1] + j*delta), min(self.m_y, pos[1] + (j+1)*delta)):\n b += self.current_array[x][y]\n count += 1\n if count == 0 :\n bright_list.append(0)\n else :\n if b == 0 : #prevent 0 divde\n b = 1\n bright_list.append(b/count)\n bright_list = np.array(bright_list)\n m = np.max(bright_list)/self.current_total_avg\n bright_list = bright_list/np.min(bright_list) -1\n bright_list = np.append(bright_list, m)\n return bright_list","def hoggar_indices():\n return list(product([0,1], repeat=6))","def crearIndices(self):\n l = self.encontrarCaracteres()\n i=0\n for c in l:\n self.indices[c] = i\n i+=1","def vector_to_locations_map_matrix(vector,senzory_map):\n xs = dict(zip(np.unique(senzory_map[:,0]), it.count()))\n ys = dict(zip(np.negative(np.unique(senzory_map[:,1])), it.count()))\n matrix = np.full((len(ys),len(xs)) + vector.shape[1:], np.nan, dtype=float)\n for i in xrange(vector.shape[0]):\n x,y = senzory_map[i]\n matrix[(ys[y],xs[x])] = vector[i]\n return matrix","def MillerNormalVectors_110():\r\n k_110 = np.array([[1, 1, 0], [0, 1, 1], [1, 0, 1],\r\n [1, -1, 0], [0, 1, -1], [-1, 0, 1]])/np.sqrt(2.0)\r\n return np.array([k_110[0, :], k_110[1, :], k_110[2, :],\r\n k_110[3, :], k_110[4, :], k_110[5, :],\r\n -k_110[0, :], -k_110[1, :], -k_110[2, :],\r\n -k_110[3, :], -k_110[4, :], -k_110[5, :]])","def coord_indices_of(self, v_list):\n return [self.coord_index_of(v) for v in v_list]","def posIdc(vec):\n for idx in vec:\n if idx == 0:\n continue\n if idx > 0:\n return tuple(vec)\n else:\n return tuple(-np.array(vec))","def generateAllRegionVectors():\n\tregionVectors = []\n\tfor i in range(NUM_REGION_VECTORS):\n\t\tregionVectors.append('{0:04x}'.format(i))\n\treturn regionVectors","def vector_indx_to_map_matrix_indx(index,senzory_map):\n xs = dict(zip(np.unique(senzory_map[:,0]), it.count()))\n ys = dict(zip(np.negative(np.unique(senzory_map[:,1])), it.count()))\n x, y = senzory_map[index]\n return ys[y],xs[x]","def test_conversions(self):\n voxels = np.array([[0, 0, 0], [1, 2, 2], [1, 0, 0], [0, 1, 0], [0, 0, 1]])\n size_x, size_y = 2, 3\n expected_indices = np.array([0, 17, 1, 2, 6])\n indices = _linearize_voxels(voxels, size_x, size_y)\n np.testing.assert_array_equal(indices, expected_indices)\n round_trip_voxels = _vectorize_voxels(indices, size_x, size_y)\n np.testing.assert_array_equal(round_trip_voxels, voxels)","def _vectorise_bag_of_pos_with_dependency(words, indexes):\n matrixes = []\n for i, index in enumerate(indexes):\n poss = _get_bag_of_pos_with_dependency(words, index)\n matrixes.append(\" \".join(poss))\n return cv_dependencies.transform(matrixes).toarray().flatten()","def lic_flow(vectors,len_pix=10):\n vectors = np.asarray(vectors)\n m,n,two = vectors.shape\n if two!=2:\n raise ValueError\n\n result = np.zeros((2*len_pix+1,m,n,2),dtype=np.int32) # FIXME: int16?\n center = len_pix\n result[center,:,:,0] = np.arange(m)[:,np.newaxis]\n result[center,:,:,1] = np.arange(n)[np.newaxis,:]\n\n for i in range(m):\n for j in range(n):\n y = i\n x = j\n fx = 0.5\n fy = 0.5\n for k in range(len_pix):\n vx, vy = vectors[y,x]\n print x, y, vx, vy\n if vx>=0:\n tx = (1-fx)/vx\n else:\n tx = -fx/vx\n if vy>=0:\n ty = (1-fy)/vy\n else:\n ty = -fy/vy\n if tx<ty:\n print \"x step\"\n if vx>0:\n x+=1\n fy+=vy*tx\n fx=0.\n else:\n x-=1\n fy+=vy*tx\n fx=1.\n else:\n print \"y step\"\n if vy>0:\n y+=1\n fx+=vx*ty\n fy=0.\n else:\n y-=1\n fx+=vx*ty\n fy=1.\n if x<0: x=0\n if y<0: y=0\n if x>=n: x=n-1\n if y>=m: y=m-1\n result[center+k+1,i,j,:] = y, x\n\n\n\n return result","def vector2Nodes(self, vector):\n nodes = []\n loop = 0\n\n for n in self.nNodes:\n temp = []\n for i in range(n):\n temp.append(vector[loop])\n loop += 1\n nodes.append(temp)\n return nodes","def proVec(*args):\r\n resultado = []\r\n i,j,k = (args[0][1] * args[1][2]) - (args[0][2] * args[1][1]) , ((args[0][0] * args[1][2]) - (args[0][2] * args[1][0])) * (-1) , (args[0][0] * args[1][1]) - (args[0][1] * args[1][0])\r\n resultado.append(i)\r\n resultado.append(j)\r\n resultado.append(k)\r\n return resultado","def project_vectors_ab(a, b):\n # print('dot = ', np.dot(a,b))\n # print('norm = ', np.linalg.norm(b))\n return np.dot(a, b) / np.linalg.norm(b)","def Cvec(self):\n return vec(self.xc, self.yc)","def cross_vectors(u, v):\n return [u[1] * v[2] - u[2] * v[1],\n u[2] * v[0] - u[0] * v[2],\n u[0] * v[1] - u[1] * v[0]]","def vector(self):\n return (self.row, self.col)","def vertexes(self):\n theta = self.orientation\n shifts = np.array([np.cos(theta), np.sin(theta)]) * self.a\n return self.coords + (shifts[:, None] * [-1, 1]).T","def grab_40_vectors(x1,x2,y1,y2) -> list:\n\n if x1 > x2:\n x1,x2 = x2,x1\n if y1 > y2:\n y1,y2 = y2,y1\n\n height = abs(y2-y1)\n length = abs(x2-x1)\n\n height_delta = height/10\n length_delta = length/10\n\n left_vertical_edge = [(x1, y1+height_delta*i) for i in range(0,11)]\n # print(left_vertical_edge)\n right_vertical_edge = [(x2,y1+height_delta*i) for i in range(0,11)]\n # print(right_vertical_edge)\n bottom_horizontal_edge = [(x1+length_delta*i,y1) for i in range(0,11)]\n # print(bottom_horizontal_edge)\n top_horizontal_edge = [(x1+length_delta*i,y2) for i in range(0,11)]\n # print(top_horizontal_edge)\n\n all_vectors = left_vertical_edge+right_vertical_edge+bottom_horizontal_edge+top_horizontal_edge\n return(all_vectors)","def vec(self):\r\n\r\n xv = np.arange(self.dx / 2, self.lx, self.dx)\r\n yv = np.arange(-self.ly / 2 + self.dy / 2, self.ly / 2, self.dy)\r\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\r\n\r\n if self.ox != 0:\r\n xv = np.arange(self.ox, self.lx + self.ox, self.dx)\r\n yv = np.arange(self.oy, self.ly + self.oy, self.dy)\r\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\r\n\r\n return xv, yv, zv","def xvec(self):\n return np.array([self.x, self.y])","def projection_to_vector(projection):\n\tglobal __n_graphs\n\tglobal __graph_id_to_list_id\n\n\tvector = np.zeros(__n_graphs)\n\tfor p in projection:\n\t\tlist_id = __graph_id_to_list_id[p.id]\n\t\tvector[list_id] = 1\n\treturn vector","def mni2vxl(coord):\n i = int((90.0 - coord[0]) / 2)\n j = int((coord[1] + 126) / 2)\n k = int((coord[2] + 72) / 2)\n return (i, j, k)","def vector(self) -> np.ndarray:\n link_vectors = [link.vector for link in self.links]\n v = np.array(link_vectors).ravel()\n return v","def cartesian_of_projective(z):\n alpha = z[0,:]\n beta = z[1,:]\n vz = np.real(np.conj(alpha)*alpha - np.conj(beta)*beta)\n vx_plus_ivy = 2*np.conj(alpha)*beta\n vx = np.real(vx_plus_ivy)\n vy = np.imag(vx_plus_ivy)\n return vx, vy, vz","def box_to_indices(box):\r\n start_row = (box // 3) * 3\r\n start_col = (box % 3) * 3\r\n return [(row, col) for row in range(start_row, start_row + 3)\r\n for col in range(start_col, start_col + 3)]","def cartesian_to_cylindrical(grid, vec=None):\n\n grid = np.atleast_2d(grid)\n\n if vec is None:\n return np.hstack([\n mkvc(np.sqrt(grid[:, 0]**2 + grid[:, 1]**2), 2),\n mkvc(np.arctan2(grid[:, 1], grid[:, 0]), 2),\n mkvc(grid[:, 2], 2)\n ])\n\n if len(vec.shape) == 1 or vec.shape[1] == 1:\n vec = vec.reshape(grid.shape, order='F')\n\n theta = np.arctan2(grid[:, 1], grid[:, 0])\n\n return np.hstack([\n mkvc(np.cos(theta)*vec[:, 0] + np.sin(theta)*vec[:, 1], 2),\n mkvc(-np.sin(theta)*vec[:, 0] + np.cos(theta)*vec[:, 1], 2),\n mkvc(vec[:, 2], 2)\n ])","def generate_V(self):\n\n n_samples, n_dimensions, L = self.n_samples, self.n_dimensions, self.L\n\n V = np.zeros([L + 1, n_dimensions], dtype=int)\n V[1:, 0] = [1 << (self.scale - j) for j in range(1, L + 1)]\n\n for i in range(n_dimensions - 1):\n\n m = np.array(directions[i], dtype=int)\n s = len(m) - 1\n\n # The following code discards the first row of the ``m`` array\n # Because it has floating point errors, e.g. values of 2.24e-314\n if L <= s:\n V[1:, i + 1] = [m[j] << (self.scale - j) for j in range(1, L + 1)]\n else:\n V[1 : s + 1, i + 1] = [\n m[j] << (self.scale - j) for j in range(1, s + 1)\n ]\n for j in range(s + 1, L + 1):\n V[j, i + 1] = V[j - s, i + 1] ^ (V[j - s, i + 1] >> s)\n for k in range(1, s):\n V[j, i + 1] ^= ((m[0] >> (s - 1 - k)) & 1) * V[j - k][i + 1]\n\n return V","def co_vertexes(self):\n theta = self.orientation + np.pi / 2\n shifts = np.array([np.cos(theta), np.sin(theta)]) * self.b\n return self.coords + (shifts[:, None] * [-1, 1]).T","def coor2idx(x, y):\r\n a = round(x/4000,0)*4000\r\n b = (round_down(y/4000,0)+0.5)*4000\r\n i = int((a - 24000)/4000) + 1\r\n j = int((b - 22000)/4000) + 1\r\n return i, j","def compute_barycentrics_native(coords, mesh):\n triangle_indices = mesh.find_simplex(coords)\n X = mesh.transform[triangle_indices, :2]\n Y = coords - mesh.transform[triangle_indices, 2]\n b = np.einsum('ijk,ik->ij', X, Y)\n bcoords = np.c_[b, 1 - b.sum(axis=1)]\n return bcoords, triangle_indices","def vec_cross(a,b):\r\n return [a[1] * b[2] - a[2] * b[1],\r\n a[2] * b[0] - a[0] * b[2],\r\n a[0] * b[1] - a[1] * b[0]]","def reconstruct_vectors(self, vectors):\n return self.instance_vectors(self.project_vectors(vectors))","def _velocity_cylindrical2cartesian(pos,vel):\n \n \n #save cartesian position of each particle\n theta=pos[:,1]\n\n #save cyindrical velocities\n vr=vel[:,0]\n vtheta=vel[:,1]\n vz=vel[:,2]\n\n #compute cartesian velocities\n vx = vr*np.cos(theta) - vtheta*np.sin(theta)\n vy = vr*np.sin(theta) + vtheta*np.cos(theta)\n vz = vz\n\n return np.dstack((vx,vy,vz))[0]","def levelsets_to_vector_field(levelsets, stepsize):\r\n vector_field_shape = levelsets[0][0].shape\r\n y_comp_combined = np.ndarray(vector_field_shape)\r\n x_comp_combined = np.ndarray(vector_field_shape)\r\n y_comp_combined.fill(np.nan)\r\n x_comp_combined.fill(np.nan)\r\n\r\n for source, target in levelsets:\r\n labels_present = set(np.array([source.flatten(),target.flatten()]).flatten())\r\n labels_present.remove(0)#relates to background\r\n\r\n #print(labels_present)\r\n for l in labels_present:\r\n\r\n source_cluster = source == l\r\n target_cluster = target == l\r\n\r\n\r\n \"\"\"plt.imshow(source_cluster.astype(np.int32)+target_cluster.astype(np.int32))\r\n plt.show()\r\n print(\"-----------\")\"\"\"\r\n\r\n #plot_gradient_field(source_cluster.astype(np.int32), target_cluster.astype(np.int32))\r\n\r\n y_comp, x_comp = array_to_vector_field(source_cluster, target_cluster, stepsize=stepsize)\r\n y_comp_combined[~np.isnan(y_comp)] = y_comp[~np.isnan(y_comp)]\r\n x_comp_combined[~np.isnan(x_comp)] = x_comp[~np.isnan(x_comp)]\r\n return y_comp_combined, x_comp_combined","def getVector(c1, c2):\n return [c1[0] - c2[0], c1[1] - c2[1], c1[2] - c2[2]]","def vector(self,\n i: int,\n j: int) -> np.ndarray:\n return self[j].coord - self[i].coord","def get_vectors(dim, R2):\n\n #collecting base vectors\n base_vecs = []\n numbers = get_set(dim, R2)\n while len(numbers) >= dim:\n vec = get_base_vector(dim, R2, deepcopy(numbers))\n if vec is not False:\n base_vecs += [np.sqrt(vec)]\n numbers.remove(max(numbers))\n #permuting base vectors\n uvecs = []\n for vec in base_vecs:\n for per_vec in permutations(vec):\n uvecs += [per_vec]\n uvecs = list(set(uvecs))\n\n #adding all possible sign options\n vecs = []\n for vec in uvecs:\n for sign in sign_possibilities(dim):\n vecs += [tuple([int(a*b) for a, b in zip(sign, vec)])]\n vecs = list(set(vecs))\n return vecs","def align_to_pole_vector():\n selection_list = pm.ls(sl=1)\n\n ik_handle = \"\"\n control_object = \"\"\n\n for obj in selection_list:\n if pm.nodeType(obj) == 'ikHandle':\n ik_handle = obj\n else:\n control_object = obj\n\n temp = pm.listConnections((ik_handle + '.startJoint'), s=1)\n start_joint = temp[0]\n start_joint_pos = pm.xform(start_joint, q=True, ws=True, t=True)\n\n temp = pm.listConnections((ik_handle + '.endEffector'), s=1)\n end_effector = temp[0]\n pm.xform(\n control_object,\n ws=True,\n t=(start_joint_pos[0], start_joint_pos[1], start_joint_pos[2])\n )\n\n pm.parent(control_object, end_effector)\n pm.setAttr(control_object + '.r', 0, 0, 0)\n\n pm.parent(control_object, w=True)","def hexgrid(self):\n n = self.n * 2\n vectors = []\n for u in range(-n, n+1):\n us = [u] * (2*n+1)\n if u < 0:\n vectors.extend(zip(us, range(-n-u, n+1), range(-n, n+u+1)))\n else:\n vectors.extend(zip(us, range(-n, n-u+1), range(-n+u, n+1)))\n return vectors","def MillerNormalVectors_111():\r\n k_111 = np.array(\r\n [[1, 1, 1], [-1, 1, 1], [1, -1, 1], [1, 1, -1]])/np.sqrt(3.0)\r\n return np.array([k_111[0, :], k_111[1, :], k_111[2, :], k_111[3, :],\r\n -k_111[0, :], -k_111[1, :], -k_111[2, :], -k_111[3, :]])","def cylindrical_to_cartesian(grid, vec=None):\n grid = np.atleast_2d(grid)\n\n if vec is None:\n return np.hstack([\n mkvc(grid[:, 0]*np.cos(grid[:, 1]), 2),\n mkvc(grid[:, 0]*np.sin(grid[:, 1]), 2),\n mkvc(grid[:, 2], 2)\n ])\n\n if len(vec.shape) == 1 or vec.shape[1] == 1:\n vec = vec.reshape(grid.shape, order='F')\n\n x = vec[:, 0] * np.cos(grid[:, 1]) - vec[:, 1] * np.sin(grid[:, 1])\n y = vec[:, 0] * np.sin(grid[:, 1]) + vec[:, 1] * np.cos(grid[:, 1])\n\n newvec = [x, y]\n if grid.shape[1] == 3:\n z = vec[:, 2]\n newvec += [z]\n\n return np.vstack(newvec).T","def create_vector(bit_set, size_vector=128, size_block=32):\n vector = [0] * size_vector\n for i in bit_set:\n index = i[1]\n if index == 0:\n vector[(i[0]) * size_block] = 1\n else:\n vector[(i[0] + 1) * size_block - index] = 1 # we decal to the left so we start from the end of the array\n return vector","def binary_vector_to_objects(self, vector: np.ndarray) -> Sequence[Any]:\n return [self.idx_to_obj[i] for i, value in enumerate(vector) if value == 1]","def cartesian_2_cylindrical(grid, vec=None):\n return cartesian_to_cylindrical(grid, vec)","def mainIndices(self):\n return self.i1, self.i2","def landmarks_as_vectors(landmarks):\n mat = []\n for lm in landmarks:\n mat.append(lm.as_vector())\n return np.array(mat)","def _pair_indices(self):\n indices_src = []\n indices_dst = []\n for i in range(self.walk_len):\n for j in range(max(i - self.l, 0), i):\n indices_src.append(i)\n indices_dst.append(j)\n for j in range(i + 1, min(i + self.r + 1, self.walk_len)):\n indices_src.append(i)\n indices_dst.append(j)\n return indices_src, indices_dst","def vector_edge_to_node(self,c,v_normal_j):\n nodes=self.grid.cell_to_nodes(c)\n Nsides=len(nodes)\n modn=lambda ni: nodes[ni%Nsides]\n node_vectors=np.zeros((Nsides,2),np.float64)\n for ns in range(Nsides):\n j_prev = self.grid.nodes_to_edge(modn(ns-1),modn(ns))\n j_next = self.grid.nodes_to_edge(modn(ns),modn(ns+1))\n # Looking for the vector which satisfies\n # dot(vec,n_prev) = flux_prev\n # dot(vec,n_next) = flux_next\n mat = np.array([self.normal_j[j_prev],\n self.normal_j[j_next]])\n projected = np.array([v_normal_j[j_prev],v_normal_j[j_next]])\n node_vectors[ns,:] = np.linalg.solve(mat,projected)\n return node_vectors","def get_bar_vector(model, elem, node1, node2, xyz1):\n cd1 = node1.Cd()\n cd2 = node2.Cd()\n if model is None:\n cd1_ref = node1.cd_ref\n cd2_ref = node2.cd_ref\n\n # get the vector v, which defines the projection on to the elemental\n # coordinate frame\n if elem.g0:\n #msg = 'which is required by %s eid=%s\\n%s' % (elem.type, elem.g0, str(elem))\n g0_ref = elem.g0_ref\n n0 = g0_ref.get_position()\n v = n0 - xyz1\n else:\n v = cd1_ref.transform_node_to_global(elem.x)\n\n else:\n msg = ', which is required by %s=%s' % (elem.type, elem.eid)\n cd1_ref = model.Coord(cd1)\n cd2_ref = model.Coord(cd2)\n\n # get the vector v, which defines the projection on to the elemental\n # coordinate frame\n if elem.g0:\n #msg = 'which is required by %s eid=%s\\n%s' % (elem.type, elem.g0, str(elem))\n g0_ref = model.Node(elem.g0, msg=msg)\n n0 = g0_ref.get_position()\n v = n0 - xyz1\n else:\n v = cd1_ref.transform_node_to_global(elem.x)\n cd1_ref = model.Coord(cd1)\n cd2_ref = model.Coord(cd2)\n\n return v, cd1, cd1_ref, cd2, cd2_ref","def vector(p0, p1):\n a = p1[0] - p0[0]\n b = p1[1] - p0[1]\n return (a, b)","def efficient_integer_vectors(self):\n return self._efficient_integer_vectors","def getVectors(self,graph):\n return [Vector.createFromTwoTuples(graph[i],graph[i+1]) for i in range(len(graph)-1)]","def normal_vector(origin, vectors):\n return np.cross(vectors[0] - origin, vectors[1] - origin)","def build_amg_index_sets(L_sizes):\n neqns = L_sizes[0][0]\n velocityDOF=[]\n for start in range(1,3):\n velocityDOF.append(np.arange(start=start,\n stop=1+neqns,\n step=3,\n dtype='i'))\n velocityDOF_full=np.vstack(velocityDOF).transpose().flatten()\n velocity_u_DOF = []\n velocity_u_DOF.append(np.arange(start=0,\n stop=2*neqns//3,\n step=2,\n dtype='i'))\n velocity_u_DOF_full = np.vstack(velocity_u_DOF).transpose().flatten()\n velocity_v_DOF = []\n velocity_v_DOF.append(np.arange(start=1,\n stop=1+2*neqns//3,\n step=2,\n dtype='i'))\n velocity_v_DOF_full = np.vstack(velocity_v_DOF).transpose().flatten()\n isvelocity = PETSc.IS()\n isvelocity.createGeneral(velocityDOF_full)\n isu = PETSc.IS()\n isu.createGeneral(velocity_u_DOF_full)\n isv = PETSc.IS()\n isv.createGeneral(velocity_v_DOF_full)\n return [isvelocity, isu, isv]","def get_vertices(self):\n vertices = []\n V = [[-self.base_vectors[:,n], self.base_vectors[:,n]] for n in range(self.base_vectors.shape[1])]\n combs = list(itertools.product(*V))\n for cb in combs:\n cb = np.sum(np.array(cb).T, axis=1, keepdims=True)\n vertices.append(self.base_vertices + cb)\n\n vertices = np.concatenate(vertices,axis=1)\n return vertices","def basis_vector_matrix(*e):\n return np.array(e).T","def get_bar_yz_transform(v, ihat, eid, xyz1, xyz2, nid1, nid2, i, Li):\n vhat = v / norm(v) # j\n try:\n z = np.cross(ihat, vhat) # k\n except ValueError:\n msg = 'Invalid vector length\\n'\n msg += 'xyz1=%s\\n' % str(xyz1)\n msg += 'xyz2=%s\\n' % str(xyz2)\n msg += 'nid1=%s\\n' % str(nid1)\n msg += 'nid2=%s\\n' % str(nid2)\n msg += 'i =%s\\n' % str(i)\n msg += 'Li =%s\\n' % str(Li)\n msg += 'ihat=%s\\n' % str(ihat)\n msg += 'v =%s\\n' % str(v)\n msg += 'vhat=%s\\n' % str(vhat)\n msg += 'z=cross(ihat, vhat)'\n print(msg)\n raise ValueError(msg)\n\n zhat = z / norm(z)\n yhat = np.cross(zhat, ihat) # j\n\n if norm(ihat) == 0.0 or norm(yhat) == 0.0 or norm(z) == 0.0:\n print(' invalid_orientation - eid=%s yhat=%s zhat=%s v=%s i=%s n%s=%s n%s=%s' % (\n eid, yhat, zhat, v, i, nid1, xyz1, nid2, xyz2))\n elif not np.allclose(norm(yhat), 1.0) or not np.allclose(norm(zhat), 1.0) or Li == 0.0:\n print(' length_error - eid=%s Li=%s Lyhat=%s Lzhat=%s'\n ' v=%s i=%s n%s=%s n%s=%s' % (\n eid, Li, norm(yhat), norm(zhat), v, i, nid1, xyz1, nid2, xyz2))\n return yhat, zhat","def _gu_matvec(x1, x2):\n return (x1 @ x2[..., np.newaxis])[..., 0]","def vector_line(self):\n assert len(self.xcoords) == 2\n diff_x = self.xcoords[1] - self.xcoords[0]\n diff_z = self.zcoords[1] - self.zcoords[0]\n vec = np.hstack((diff_x, diff_z))\n return vec","def gains_vector(m):\n\n n_ant, n_chan, n_dir, _ = m.shape\n row_shape = n_ant * n_chan * n_dir\n g = np.zeros((2*row_shape), dtype=np.complex128)\n\n for nu in range(n_chan):\n for s in range(n_dir):\n for a in range(n_ant):\n row = a + n_ant * s + n_ant * n_dir * nu \n g[row] = m[a, nu, s, 0]\n g[row + row_shape] = m[a, nu, s, 1]\n \n return g","def _indices_to_coords(c,r):\n\n column = _index_to_column(c)\n row = r + 1\n\n return {'c': column, 'r': row, 'coord': f'{column}{row}'}","def vector(self):\n return self.q[1:4]","def project_onto_plane(vect):\n x, y, z = vect\n \n return (x, y, 0.)","def _ivector_index_to_node(i_components,_intermediate_node): \n return Vector(\n index= [\n _intermediate_node[uid_i]\n for uid_i in i_components.iterkeys()\n \n ],\n value=i_components._value\n )","def getVectors(self):\n l = len(self.points)\n return [Vector.createFromTwoPoints(self.points[i % l], self.points[(i + 1) % l], \\\n color=self.side_color, width=self.side_width) for i in range(l)]","def _position_cartesian2cylindrical(pos):\n\n \n #save cartesian position of each particle\n x=pos[:,0]\n y=pos[:,1]\n z=pos[:,2]\n\n rho= np.sqrt(x**2+y**2)\n theta=np.arctan2(y,x)\n\n\n return np.dstack((rho,theta,z))[0]","def parallelpiped_volume(lattice_vectors):\n a = lattice_vectors[:, 0]\n b = lattice_vectors[:, 1]\n c = lattice_vectors[:, 2]\n return triple_product(a, b, c)","def indices(shape):\n iterables = [range(v) for v in shape]\n return product(*iterables)","def indices(shape):\n iterables = [range(v) for v in shape]\n return product(*iterables)","def indexes_to_objects(self, index_vector: np.ndarray) -> Sequence[Any]:\n return [self.idx_to_obj[idx] for idx in index_vector if idx in self.idx_to_obj]","def indices(self):\n _indices = []\n for h in self.miller.indices():\n _indices.append(self.indices_hkl(*h)[0])\n return _indices","def _vectorise_bag_of_pos(words, indexes, N, targets=[]):\n matrixes = []\n for i, index in enumerate(indexes):\n poss = _get_bag_of_pos(words, index, N, target_len=len(targets[i].split()))\n matrixes.append(\" \".join(poss))\n return cv_normal.transform(matrixes).toarray().flatten()","def get_vectors(nodes, mode=\"xform\"):\n for each in nodes:\n position = (0, 0, 0)\n\n if mode == \"xform\":\n position = cmds.xform(\n each,\n query=True,\n translation=True,\n worldSpace=True,\n )\n\n elif mode == \"pivot\":\n position = cmds.xform(\n each,\n query=True,\n translation=True,\n rotatePivot=True,\n worldSpace=True,\n )\n\n # when using xform on component like faces or edge, the returned value\n # will be a list of each vertices position, so we need to average that\n if len(position) > 3:\n vectors = [\n MVector(position[i : i + 3])\n for i in range(0, len(position), 3)\n ]\n result = MVector()\n for vector in vectors:\n result += vector\n position = result / len(vectors)\n\n yield MVector(position)","def vec_x(self):\t\r\n if self.ox != 0:\r\n ov = self.ox\r\n lv = self.self.lx + self.ox\r\n else:\r\n ov = self.dx / 2\r\n lv = self.lx\r\n\r\n xv = \"\"\r\n for num in np.arange(ov, lv, self.dx):\r\n xv += str(num) + \" \"\r\n\r\n return xv","def cartesian2spherical(v):\n theta = np.arcsin(v[2]) \n phi = np.arctan2(v[1], v[0])\n \n return [theta, phi]","def get_uncut_indices(atoms, orig, vec1, offset=None):\n\n if isinstance(orig, int):\n orig = atoms.get_positions()[orig]\n else:\n orig = np.array(orig)\n if isinstance(vec1, int):\n vec1 = atoms.get_positions()[vec1]\n else:\n vec1 = np.array(vec1)\n\n# if vec2 and isinstance(vec2, int):\n# vec2 = atoms.get_positions()[vec2]\n# elif vec2:\n# vec2 = np.array(vec2)\n# if vec3 and isinstance(vec3, int):\n# vec3 = atoms.get_positions()[vec3]\n# elif vec3:\n# vec3 = np.array(vec3)\n#\n# if vec2:\n# plane_vec = np.cross(vec1-orig, vec2-orig)\n# else:\n# plane_vec = vec1-orig\n#\n# nplane_vec = plane_vec/np.linalg.norm(plane_vec)\n#\n# if vec2 and vec3 and nplane_vec.dot(vec3-orig) < 0:\n# nplane_vec *= -1\n\n plane_vec = vec1 - orig\n nplane_vec = plane_vec/np.linalg.norm(plane_vec)\n\n if offset:\n orig += offset*nplane_vec\n\n atom_indices = [i for i,a in enumerate(atoms) if (a.position - orig).dot(nplane_vec) > 0]\n return atom_indices","def _velocity_cartesian2cylindrical(pos,vel):\n \n \n \n #save cartesian velocities\n vx=vel[:,0]\n vy=vel[:,1]\n vz=vel[:,2]\n\n #convert to cylindrical coordinates\n pos_cyl=_position_cartesian2cylindrical(pos) #cylindrical coordinates\n theta=pos_cyl[:,1]\n\n #compute cylindrical velocities\n vr=vx*np.cos(theta) + vy*np.sin(theta)\n vtheta=-vx*np.sin(theta) + vy*np.cos(theta)\n vz=vz\n \n\n return np.dstack((vr,vtheta,vz))[0]","def vector_perp(v):\n assert len(v) == 2\n x, y = v\n return Vector(-y, x)","def rasterize(x):\n for i, y in enumerate(x):\n for v in y:\n yield i, v","def rotate_c(X,a_set,vector):\r\n\taxis_vector = math.radians(-X) * np.array([0,0,1])\r\n\tr = R.from_rotvec(axis_vector)\r\n\treturn list(r.apply(vector))","def cylindrical_2_cartesian(grid, vec=None):\n return cylindrical_to_cartesian(grid, vec)","def f_v(_a, _vs, _Ps, _Ps0): # _aはスカラ, _vsはベクトル, _Ps, _Ps0は３行2列の行列\n center_pos = _Ps[0]\n center_pos_0 = _Ps0[0]\n idx_iter = Index_iterator(1, 8)\n #中心点から各点へのベクトル\n x = []\n x0 = []\n for p in (_Ps):\n x.append(p - center_pos)\n for p in _Ps(_Ps0):\n x0.append(p - center_pos_0)\n\n x01 = (_Ps[1]-center_pos) \n x02 = (_Ps[2]-center_pos) \n x03 = (_Ps[3]-center_pos) \n x04 = (_Ps[4]-center_pos) \n x05 = (_Ps[5]-center_pos) \n x06 = (_Ps[6]-center_pos) \n x07 = (_Ps[7]-center_pos) \n x08 = (_Ps[8]-center_pos)\n print('p_id', center_pos, end='\\t')\n print('x01:', x01, end=\"\\t\")\n print('x03:', x03, end=\"\\t\")\n print('x05:', x05, end=\"\\t\")\n print('x07:', x07)\n x001 = (_Ps0[1]-_Ps0[0]) \n x002 = (_Ps0[2]-_Ps0[0]) \n x003 = (_Ps0[3]-_Ps0[0]) \n x004 = (_Ps0[4]-_Ps0[0]) \n x005 = (_Ps0[5]-_Ps0[0]) \n x006 = (_Ps0[6]-_Ps0[0]) \n x007 = (_Ps0[7]-_Ps0[0]) \n x008 = (_Ps0[8]-_Ps0[0]) \n \n #中心点周りの面の面積\n def calc_area(j,k,l):\n s = LA.norm(np.cross(x[j],x[k]))/2 \\\n + LA.norm(np.cross(x[k],x[l]))/2\n return s\n\n s = []\n s0 = []\n hen = [1,3,5,7]\n for i in range(4):\n j,k,l = [n for n in idx_iter.get_indexes(start_idx=hen[i], 3)]\n s[i] = calc_area(j,k,l)\n s0[i] = calc_area(j,k,l)\n\n # s0123 = LA.norm(np.cross(x[1],x[2]))/2\\\n # +LA.norm(np.cross(x[2],x[3]))/2\n # s4367 = LA.norm(np.cross(x[3],x[4]))/2\\\n # +LA.norm(np.cross(x[4],x[5]))/2\n # s4785 = LA.norm(np.cross(x[5],x[6]))/2\\\n # +LA.norm(np.cross(x[6],x[7]))/2\n # s4521 = LA.norm(np.cross(x[7],x[8]))/2\\\n # +LA.norm(np.cross(x[8],x[1]))/2\n # s04103 = LA.norm(np.cross(x0[1],x0[2]))/2\\\n # +LA.norm(np.cross(x0[2],x0[3]))/2\n # s04367 = LA.norm(np.cross(x0[3],x0[4]))/2\\\n # +LA.norm(np.cross(x0[4],x0[7]))/2\n # s04785 = LA.norm(np.cross(x0[7],x0[8]))/2\\\n # +LA.norm(np.cross(x0[8],x0[5]))/2\n # s04521 = LA.norm(np.cross(x0[5],x0[2]))/2\\\n # +LA.norm(np.cross(x0[2],x0[1]))/2\n \n #各方向への平均面積(ここだけ反時計回り順で設定してる)\n S_iminus = (s[1] + s[2]) / 2 #43方向\n S_Jminus = (s[1] + s[4]) / 2 #41方向\n S_iplus = (s[3] + s[4]) / 2 #45方向\n S_Jplus = (s[3] + s[2]) / 2 #47方向\n S_iminus0 = (s0[1] + s0[2]) / 2 #43方向\n S_Jminus0 = (s0[1] + s0[4]) / 2 #41方向\n S_iplus0 = (s0[3] + s0[4]) / 2 #45方向\n S_Jplus0 = (s0[3] + s0[2]) / 2 #47方向\n # 各方向への厚み\n h_iminus = h_0 / ((poisson/(1-poisson) * (S_iminus - S_iminus0) / S_iminus0) + 1) #43方向\n h_Jminus = h_0 / ((poisson/(1-poisson) * (S_Jminus - S_Jminus0) / S_Jminus0) + 1) #41方向\n h_iplus = h_0 / ((poisson/(1-poisson) * (S_iplus - S_iplus0) / S_iplus0) + 1) #45方向\n h_Jplus = h_0 / ((poisson/(1-poisson) * (S_Jplus - S_Jplus0) / S_Jplus0) + 1) #47方向\n # 各断片の重心\n g = []\n kado = [2,4,6,8]\n hen = [1,3,5,7]\n for i in range(len(kado)):\n _kado = kado[i]\n _hen1, _ = [idx for idx in idx_iter.get_indexes_reverse(_kado, 2)]\n _hen2, _ = [idx for idx in idx_iter.get_indexes(_kado, 2)]\n _hen = [_hen1, _hen2]\n _g1 = (center_pos + _Ps[_kado] + _Ps[_hen1])/3\n _g2 = (center_pos + _Ps[_kado] + _Ps[_hen2])/3\n g.append([_g1, _g2])\n\n g401 = (center_pos + _Ps[0] + _Ps[1]) / 3\n g430 = (center_pos + _Ps[3] + _Ps[0]) / 3\n g436 = (center_pos + _Ps[3] + _Ps[6]) / 3\n g467 = (center_pos + _Ps[6] + _Ps[7]) / 3\n g478 = (center_pos + _Ps[7] + _Ps[8]) / 3\n g485 = (center_pos + _Ps[8] + _Ps[5]) / 3\n g452 = (center_pos + _Ps[5] + _Ps[2]) / 3\n g421 = (center_pos + _Ps[2] + _Ps[1]) / 3\n g0401 = (_Ps0[4] + _Ps0[0] + _Ps0[1]) / 3\n g0430 = (_Ps0[4] + _Ps0[3] + _Ps0[0]) / 3\n g0436 = (_Ps0[4] + _Ps0[3] + _Ps0[6]) / 3\n g0467 = (_Ps0[4] + _Ps0[6] + _Ps0[7]) / 3\n g0478 = (_Ps0[4] + _Ps0[7] + _Ps0[8]) / 3\n g0485 = (_Ps0[4] + _Ps0[8] + _Ps0[5]) / 3\n g0452 = (_Ps0[4] + _Ps0[5] + _Ps0[2]) / 3\n g0421 = (_Ps0[4] + _Ps0[2] + _Ps0[1]) / 3\n \n # 各断片面積\n triangle_area = []\n kado = [2,4,6,8]\n for i in range(len(kado)):\n j, k = [idx for idx in idx_iter.get_indexes_reverse(kado[i], 1)]\n _s1 = LA.norm(np.cross(x[j],x[k]))/2\n j, k = [idx for idx in idx_iter.get_indexes(kado[i], 1)]\n _s2 = LA.norm(np.cross(x[j],x[k]))/2\n triangle_area.append([_s1, _s2])\n\n s410 = LA.norm(np.cross(x[1],x[2]))/2\n s403 = LA.norm(np.cross(x[2],x[3]))/2\n s436 = LA.norm(np.cross(x[3],x[4]))/2\n s467 = LA.norm(np.cross(x[4],x[5]))/2\n s478 = LA.norm(np.cross(x[5],x[6]))/2\n s485 = LA.norm(np.cross(x[6],x[7]))/2\n s452 = LA.norm(np.cross(x[7],x[8]))/2\n s421 = LA.norm(np.cross(x[8],x[1]))/2\n s0410 = LA.norm(np.cross(x0[1],x0[2]))/2\n s0403 = LA.norm(np.cross(x0[2],x0[3]))/2\n s0436 = LA.norm(np.cross(x0[3],x0[4]))/2\n s0467 = LA.norm(np.cross(x0[4],x0[5]))/2\n s0478 = LA.norm(np.cross(x0[5],x0[6]))/2\n s0485 = LA.norm(np.cross(x0[6],x0[7]))/2\n s0452 = LA.norm(np.cross(x0[7],x0[8]))/2\n s0421 = LA.norm(np.cross(x0[8],x0[1]))/2\n # 四角の重心\n\n center_g_square = []\n for i in range(len(g)):\n _g = (triangle_area[i][0]*g[i][0] + triangle_area[i][1]*g[i][1])/(triangle_area[i][0] + triangle_area[i][1])\n center_g.append(_g)\n g4103 = (s410*g401 + s403*g430) / (s410 + s403)\n g4367 = (s436*g436 + s467*g467) / (s436 + s467)\n g4785 = (s478*g478 + s485*g485) / (s478 + s485)\n g4521 = (s452*g452 + s421*g421) / (s452 + s421)\n g04103 = (s0410*g0401 + s0403*g0430) / (s0410 + s0403)\n g04367 = (s0436*g0436 + s0467*g0467) / (s0436 + s0467)\n g04785 = (s0478*g0478 + s0485*g0485) / (s0478 + s0485)\n g04521 = (s0452*g0452 + s0421*g0421) / (s0452 + s0421)\n # 各重心間の距離\n Lj82 = LA.norm(g4521 - g4103)\n Lj24 = LA.norm(g4103 - g4367)\n Lj46 = LA.norm(g4367 - g4785)\n Lj68 = LA.norm(g4785 - g4521)\n \n # ひずみ\n eps_i41 = (LA.norm(x01) - LA.norm(x041)) / LA.norm(x041)\n eps_J41 = (LA.norm(g4521 - g4103) - LA.norm(g04521 - g04103)) / LA.norm(g04521 - g04103)\n eps_i43 = (LA.norm(x03) - LA.norm(x043)) / LA.norm(x043)\n eps_J43 = (LA.norm(g4103 - g4367) - LA.norm(g04103 - g04367)) / LA.norm(g04103 - g04367)\n eps_i47 = (LA.norm(x01) - LA.norm(x041)) / LA.norm(x041)\n eps_J47 = (LA.norm(g4367 - g4785) - LA.norm(g04367 - g04785)) / LA.norm(g04367 - g04785)\n eps_i45 = (LA.norm(x01) - LA.norm(x041)) / LA.norm(x041)\n eps_J45 = (LA.norm(g4785 - g4521) - LA.norm(g04785 - g04521)) / LA.norm(g04785 - g04521)\n # 張力\n F_T1 = (young_modulus * h_Jminus * Lj82 * (eps_i41 + poisson * eps_J41) / (1 - poisson**2))*x01/LA.norm(x01)\n F_T3 = (young_modulus * h_iminus * Lj24 * (eps_i43 + poisson * eps_J43) / (1 - poisson**2))*x03/LA.norm(x03)\n F_T5 = (young_modulus * h_Jplus * Lj46 * (eps_i47 + poisson * eps_J47) / (1 - poisson**2))*x05/LA.norm(x05)\n F_T7 = (young_modulus * h_iplus * Lj68 * (eps_i45 + poisson * eps_J45) / (1 - poisson**2))*x07/LA.norm(x07)\n # せん断ひずみ\n gamma513 = (math.acos((np.dot(x07,x01))/(LA.norm(x07)*LA.norm(x01))) - math.acos((np.dot(x045,x041))/(LA.norm(x045)*LA.norm(x041)))\\\n + math.acos((np.dot(x03,x01))/(LA.norm(x03)*LA.norm(x01))) - math.acos((np.dot(x043,x041))/(LA.norm(x043)*LA.norm(x041))))/2\n gamma137 = (math.acos((np.dot(x01,x03))/(LA.norm(x01)*LA.norm(x03))) - math.acos((np.dot(x041,x043))/(LA.norm(x041)*LA.norm(x043)))\\\n + math.acos((np.dot(x03,x05))/(LA.norm(x03)*LA.norm(x05))) - math.acos((np.dot(x043,x047))/(LA.norm(x043)*LA.norm(x047))))/2\n gamma375 = (math.acos((np.dot(x05,x03))/(LA.norm(x05)*LA.norm(x03))) - math.acos((np.dot(x047,x043))/(LA.norm(x047)*LA.norm(x043)))\\\n + math.acos((np.dot(x07,x05))/(LA.norm(x07)*LA.norm(x05))) - math.acos((np.dot(x045,x047))/(LA.norm(x045)*LA.norm(x047))))/2\n gamma751 = (math.acos((np.dot(x05,x07))/(LA.norm(x05)*LA.norm(x07))) - math.acos((np.dot(x047,x045))/(LA.norm(x047)*LA.norm(x045)))\\\n + math.acos((np.dot(x07,x01))/(LA.norm(x07)*LA.norm(x01))) - math.acos((np.dot(x045,x041))/(LA.norm(x045)*LA.norm(x041))))/2\n # せん断力\n F_S41 = ((young_modulus * h_Jminus * LA.norm(x01) * gamma513)/(2 * (1 + poisson)))*x01/LA.norm(x01)\n F_S43 = ((young_modulus * h_Jminus * LA.norm(x03) * gamma137)/(2 * (1 + poisson)))*x03/LA.norm(x03)\n F_S47 = ((young_modulus * h_Jminus * LA.norm(x05) * gamma375)/(2 * (1 + poisson)))*x05/LA.norm(x05)\n F_S45 = ((young_modulus * h_Jminus * LA.norm(x07) * gamma751)/(2 * (1 + poisson)))*x07/LA.norm(x07)\n \n # J方向の曲げ力\n n_j_cross = np.cross(x05, x01)\n if any(n_j_cross):\n n_J = n_j_cross/LA.norm(n_j_cross)\n else: \n\n l_Jalfa = LA.norm(_Ps[1] - _Ps[7])\n cos_Jalfa = (LA.norm(x01)**2 + LA.norm(x05)**2 - l_Jalfa**2) / (2 * LA.norm(x01) * LA.norm(x05))\n if cos_Jalfa > 1.0:\n cos_Jalfa = 1.0\n elif cos_Jalfa < -1.0:\n cos_Jalfa = -1.0\n sin_Jalfa = math.sqrt(1 - cos_Jalfa**2)\n CJa2 = math.sqrt((cos_Jalfa + 1)/2)\n SJa2 = math.sqrt((1 - cos_Jalfa)/2)\n zJC = (_Ps[7][2]-_Ps[1][2])/(_Ps[7][0]-_Ps[1][0]) * (center_pos[0]-_Ps[1][0]) + _Ps[1][2] #曲げ力の方向の場合わけに必要\n if center_pos[2] > zJC:\n e_j = np.dot(np.array([[CJa2 + (n_J[0]**2) * (1 - CJa2), n_J[0] * n_J[1] * (1 - CJa2) + n_J[2] * SJa2, n_J[0] * n_J[2] * (1 - CJa2) - n_J[1] * SJa2],\\\n [n_J[1] * n_J[0] * (1 - CJa2) - n_J[2] * SJa2, CJa2 + (n_J[1]**2) * (1 - CJa2), n_J[1] * n_J[2] * (1 - CJa2) + n_J[0] * SJa2],\\\n [n_J[2] * n_J[0] * (1 - CJa2) + n_J[1] * SJa2, n_J[2] * n_J[1] * (1 - CJa2) - n_J[0] * SJa2, CJa2 + (n_J[2]**2) * (1 - CJa2)]]), (_Ps[7] - center_pos)/LA.norm(_Ps[7] - center_pos))\n else:\n e_j = np.dot(np.array([[CJa2 + (n_J[0]**2) * (1 - CJa2), n_J[0] * n_J[1] * (1 - CJa2) - n_J[2] * SJa2, n_J[0] * n_J[2] * (1 - CJa2) + n_J[1] * SJa2],\\\n [n_J[1] * n_J[0] * (1 - CJa2) + n_J[2] * SJa2, CJa2 + (n_J[1]**2) * (1 - CJa2), n_J[1] * n_J[2] * (1 - CJa2) - n_J[0] * SJa2],\\\n [n_J[2] * n_J[0] * (1 - CJa2) - n_J[1] * SJa2, n_J[2] * n_J[1] * (1 - CJa2) + n_J[0] * SJa2, CJa2 + (n_J[2]**2) * (1 - CJa2)]]), (_Ps[7] - center_pos)/LA.norm(_Ps[7] - center_pos))\n d_etha_J = (2 * sin_Jalfa / l_Jalfa) - (2 * math.sqrt(1 - np.dot(x041,x047)**2/(LA.norm(x041)*LA.norm(x047))**2)/(LA.norm(x041 - x047)))\n\n n_i = np.cross(x07,x03)/LA.norm(np.cross(x03,x07)) \n cos_ialfa = np.dot(x03,x07) / (LA.norm(x03) * LA.norm(x07))\n sin_ialfa = math.sqrt(1 - cos_ialfa**2)\n Cia2 = math.sqrt((cos_ialfa + 1)/2)\n Sia2 = math.sqrt((1 - cos_ialfa)/2)\n ziC = (_Ps[5][2]-_Ps[3][2])/(_Ps[5][0]-_Ps[3][0]) * (center_pos[0]-_Ps[3][0]) + _Ps[3][2]\n if center_pos[2] > ziC:\n e_i = np.dot(np.array([[Cia2 + (n_i[0]**2) * (1 - Cia2), n_i[0] * n_i[1] * (1 - Cia2) + n_i[2] * Sia2, n_i[0] * n_i[2] * (1 - Cia2) - n_i[1] * Sia2],\\\n [n_i[1] * n_i[0] * (1 - Cia2) - n_i[2] * Sia2, Cia2 + (n_i[1]**2) * (1 - Cia2), n_i[1] * n_i[2] * (1 - Cia2) + n_i[0] * Sia2],\\\n [n_i[2] * n_i[0] * (1 - Cia2) + n_i[1] * Sia2, n_i[2] * n_i[1] * (1 - Cia2) - n_i[0] * Sia2, Cia2 + (n_i[2]**2) * (1 - Cia2)]]), (_Ps[7] - center_pos)/LA.norm(_Ps[7] - center_pos))\n else:\n e_i = np.dot(np.array([[Cia2 + (n_i[0]**2) * (1 - Cia2), n_i[0] * n_i[1] * (1 - Cia2) - n_i[2] * Sia2, n_i[0] * n_i[2] * (1 - Cia2) + n_i[1] * Sia2],\\\n [n_i[1] * n_i[0] * (1 - Cia2) + n_i[2] * Sia2, Cia2 + (n_i[1]**2) * (1 - Cia2), n_i[1] * n_i[2] * (1 - Cia2) - n_i[0] * Sia2],\\\n [n_i[2] * n_i[0] * (1 - Cia2) - n_i[1] * Sia2, n_i[2] * n_i[1] * (1 - Cia2) + n_i[0] * Sia2, Cia2 + (n_i[2]**2) * (1 - Cia2)]]), (_Ps[5] - center_pos)/LA.norm(_Ps[5] - center_pos))\n d_etha_i = (2 * sin_ialfa / LA.norm(x07 - x03)) - (2 * math.sqrt(1 - np.dot(x043,x045)**2/(LA.norm(x043)*LA.norm(x045))**2)/(LA.norm(x043 - x045)))\n\n\n l_J = (Lj20 + Lj06 + Lj68 + Lj82) / 4\n h = (h_iminus + h_iplus + h_Jminus + h_Jplus) / 4\n I = (l_J * h**3) / 12\n M_i = (young_modulus * I * (d_etha_i + poisson * d_etha_J)/(1 - poisson**2))\n M_J = (young_modulus * I * (d_etha_J + poisson * d_etha_i)/(1 - poisson**2))\n #曲げ力\n F_Bi = M_i / LA.norm(x03) + M_i / LA.norm(x07) * e_i\n F_BJ = M_J / LA.norm(x01) + M_J / LA.norm(x05) * e_j\n #空気力\n # S = (S_iminus + S_iplus + S_Jminus + S_Jplus) / 4\n # F_A = p * S\n F_A = np.array([0.0, 0.0, -0.1]) * _a\n\n # 運動方程式（支配方程式）\n S_0 = (S_iminus0 + S_iplus0 + S_Jminus0 + S_Jplus0) / 4\n F_T = F_T41 + F_T43 + F_T45 + F_T47\n F_S = F_S41 + F_S43 + F_S45 + F_S47\n F_B = F_Bi + F_BJ\n return (F_T + F_S + F_B + F_A) / (rho * h_0 * S_0) - c * _vs","def findSubsetIndices(min_lat,max_lat,min_lon,max_lon,lats,lons):\n res=np.zeros((4),dtype=np.float64)\n minLon=min_lon; maxLon=max_lon\n\n distances1 = []; distances2 = []\n indices=[]; index=1\n\n for point in lats:\n s1 = max_lat-point # (vector subtract)\n s2 = min_lat-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n distances1 = []; distances2 = []; index=1\n\n for point in lons:\n s1 = maxLon-point # (vector subtract)\n s2 = minLon-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n minJ=indices[1][2]\n maxJ=indices[0][2]\n minI=indices[3][2]\n maxI=indices[2][2]\n\n res[0]=minI; res[1]=maxI; res[2]=minJ; res[3]=maxJ\n return res"],"string":"[\n \"def cartesian2bary(self, x):\\n lam = np.zeros((x.shape[0], 3))\\n lam[:,:2] = np.einsum('ij,kj->ki', self.Tinv, x - self.xv[2])\\n lam[:,2] = 1. - lam[:,0] - lam[:,1]\\n return lam\",\n \"def project_vectors(self, vectors):\\n return np.dot(vectors, self.components.T)\",\n \"def cxvec(self):\\n return np.array([self.cx, self.cy])\",\n \"def project_vectors(self, vectors):\\n X = vectors - self._mean\\n return np.dot(X, self.components.T)\",\n \"def unit_vectors(self):\\n # return {'comp1': CartesianRepresentation(...),\\n # 'comp2': CartesianRepresentation(...),\\n # 'comp3': CartesianRepresentation(...)}\\n raise Exception(\\\"Not yet implemented\\\")\",\n \"def to_indices(self, world_coords):\\n (x, y, z) = world_coords\\n (cx, cy, cz) = self.center\\n\\n px = x - cx\\n py = y - cy\\n pz = z - cz\\n\\n # project u and v\\n # TODO: Can this be done with some built-in Numpy operation?\\n (ux, uy, uz) = self.u_dir\\n (vx, vy, vz) = self.v_dir\\n u = px * ux + py * uy + pz * uz\\n v = px * vx + py * vy + pz * vz\\n\\n # rescale to pixel coordinates. u is up, v is down\\n (H, W, _) = self.shape\\n i = rescale(-1, 1, H - 1, 0, v)\\n j = rescale(-1, 1, 0, W -1, u)\\n\\n return (i, j)\",\n \"def _build_mcid_vectors(self, model: BDF, nplies: int):\\n etype = 3 # vtkLine\\n\\n nodes, bars = export_mcids_all(model, eids=None, log=None, debug=False)\\n for iply, nodesi in nodes.items():\\n barsi = bars[iply]\\n if iply == -1:\\n name = 'element material coord'\\n else:\\n name = f'mcid ply={iply+1}'\\n\\n nbars = len(barsi)\\n if nbars == 0:\\n # isotropic\\n continue\\n assert nbars > 0, model.card_count\\n\\n is_visible = False\\n self.gui.create_alternate_vtk_grid(\\n name, color=RED_FLOAT, line_width=3, opacity=1.0,\\n representation='surface', is_visible=is_visible, is_pickable=False)\\n grid = self.gui.alt_grids[name]\\n grid.Allocate(nbars, 1000)\\n\\n nodes_array = np.array(nodesi, dtype='float32')\\n elements = np.array(barsi, dtype='int32')\\n assert elements.min() == 0, elements.min()\\n points = numpy_to_vtk_points(nodes_array, points=None, dtype='<f', deep=1)\\n grid.SetPoints(points)\\n create_vtk_cells_of_constant_element_type(grid, elements, etype)\\n return\",\n \"def vector(self):\\n \\n v_list = Householder.triangle_operation(self)[1]\\n \\n return(v_list)\",\n \"def toIndexes(self, binaryVector):\\n\\t\\treturn n.array([i for i,v in enumerate(binaryVector) if v], dtype=\\\"int32\\\")\",\n \"def bary2cartesian(self, lam):\\n return np.einsum('ij,jk', lam, self.xv)\",\n \"def onBase():\\n return (vector(1, 0, 0), vector(0, 1, 0), vector(0, 0, 1))\",\n \"def vector(molec, dihed, nonH, energy):\\n #Torison\\n if dihed:\\n pass\\n #XYZ\\n else:\\n coords = ()\\n if nonH:\\n for atom in molec.atoms:\\n coords += atom.coords\\n else:\\n for atom in molec.atoms:\\n if atom.atomicnum > 1:\\n coords += atom.coords\\n #Energy\\n if energy:\\n coords += (molec.energy/10.0,)\\n return coords\",\n \"def transform_coord_to_vector(coords,vector_dim):\\r\\n\\t\\r\\n\\tnew_vector = [0] * vector_dim\\r\\n\\tfor c in coords:\\r\\n\\t\\tnew_vector[c[0]] = c[1]\\r\\n\\r\\n\\treturn new_vector\",\n \"def spherical2cartesian(v):\\n \\n x = np.cos(v[0]) * np.cos(v[1]) \\n y = np.cos(v[0]) * np.sin(v[1]) \\n z = np.sin(v[0]) \\n \\n return [x,y,z]\",\n \"def map_vects(self, input_vects):\\n \\n if not self._trained:\\n raise ValueError(\\\"SOM not trained yet\\\")\\n \\n to_return = []\\n \\n distances = []\\n \\n \\n contador_adyacentes = 0\\n \\n matriz = np.array(list(self._neuron_locations(self._m, self._n)))\\n \\n m = self._m\\n \\n n = self._n\\n \\n matrices = []\\n \\n matrices = np.stack((matriz,\\n matriz + np.array([m,n]), \\n matriz - np.array([m,n]), \\n matriz + np.array([m,0]),\\n matriz - np.array([m,0]),\\n matriz + np.array([0,n]),\\n matriz - np.array([0,n]),\\n matriz + np.array([m,-n]),\\n matriz + np.array([-m,n])\\n ))\\n \\n distancias_matriz = []\\n\\n for i in range(n*m):\\n distancias_matriz.append([])\\n for j in range(m*n):\\n distancias_matriz[i].append(np.min(np.sum(np.power(np.subtract(matriz[i], matrices[:,j]),2), axis = 1)))\\n \\n distancias_matriz = np.array(distancias_matriz)\\n \\n \\n for vect in input_vects:\\n\\n # min_index is the index of the BMU\\n \\n lista_indices = [i for i in range(len(self._weightages))]\\n \\n min_index = min(lista_indices,\\n key=lambda x: np.linalg.norm(vect - self._weightages[x]))\\n\\n # min_index_2 is the index of the 2nd BMU\\n \\n lista_indices.pop(min_index) # El indice es el mismo que el valor\\n \\n min_index_2 = min(lista_indices,\\n key=lambda x: np.linalg.norm(vect - self._weightages[x])) \\n \\n r2 = np.sqrt(2)\\n\\n if np.sqrt(distancias_matriz[min_index][min_index_2]) > r2: \\n# print('loc 1')\\n# print(locaciones[min_index])\\n# print('loc 2')\\n# print(locaciones[min_index_2])\\n contador_adyacentes += 1\\n\\n\\n distance = np.linalg.norm(vect - self._weightages[min_index])\\n \\n distances.append(distance)\\n \\n to_return.append(self._locations[min_index]) \\n \\n # Quantization Error qe (the mean of all distances to the BMU)!\\n self.distances = distances \\n \\n # Topographic error te\\n self.proporcion = contador_adyacentes / len(input_vects)\\n \\n self.prom_dist = np.mean(self.distances)\\n \\n return to_return\",\n \"def Indexes(self, latitudes, longitudes):\\n res = self._transform.TransformPoints(\\n np.column_stack((longitudes, latitudes)))\\n res = list(zip(*res))\\n x, y = np.array(res[0]), np.array(res[1])\\n idx_col = self._inv_txf[0] + self._inv_txf[1] * x + self._inv_txf[2] * y\\n idx_row = self._inv_txf[3] + self._inv_txf[4] * x + self._inv_txf[5] * y\\n return idx_row.astype(int), idx_col.astype(int)\",\n \"def vector_convert(self, pos) :\\n delta = AUTO_width2//3\\n bright_list = []\\n for i in range(-1,2):\\n for j in range(-1,2) :\\n b = 0\\n count = 0\\n for x in range(max(0, pos[0] + i*delta), min(self.m_x, pos[0] + (i+1)*delta)):\\n for y in range(max(0, pos[1] + j*delta), min(self.m_y, pos[1] + (j+1)*delta)):\\n b += self.current_array[x][y]\\n count += 1\\n if count == 0 :\\n bright_list.append(0)\\n else :\\n if b == 0 : #prevent 0 divde\\n b = 1\\n bright_list.append(b/count)\\n bright_list = np.array(bright_list)\\n m = np.max(bright_list)/self.current_total_avg\\n bright_list = bright_list/np.min(bright_list) -1\\n bright_list = np.append(bright_list, m)\\n return bright_list\",\n \"def hoggar_indices():\\n return list(product([0,1], repeat=6))\",\n \"def crearIndices(self):\\n l = self.encontrarCaracteres()\\n i=0\\n for c in l:\\n self.indices[c] = i\\n i+=1\",\n \"def vector_to_locations_map_matrix(vector,senzory_map):\\n xs = dict(zip(np.unique(senzory_map[:,0]), it.count()))\\n ys = dict(zip(np.negative(np.unique(senzory_map[:,1])), it.count()))\\n matrix = np.full((len(ys),len(xs)) + vector.shape[1:], np.nan, dtype=float)\\n for i in xrange(vector.shape[0]):\\n x,y = senzory_map[i]\\n matrix[(ys[y],xs[x])] = vector[i]\\n return matrix\",\n \"def MillerNormalVectors_110():\\r\\n k_110 = np.array([[1, 1, 0], [0, 1, 1], [1, 0, 1],\\r\\n [1, -1, 0], [0, 1, -1], [-1, 0, 1]])/np.sqrt(2.0)\\r\\n return np.array([k_110[0, :], k_110[1, :], k_110[2, :],\\r\\n k_110[3, :], k_110[4, :], k_110[5, :],\\r\\n -k_110[0, :], -k_110[1, :], -k_110[2, :],\\r\\n -k_110[3, :], -k_110[4, :], -k_110[5, :]])\",\n \"def coord_indices_of(self, v_list):\\n return [self.coord_index_of(v) for v in v_list]\",\n \"def posIdc(vec):\\n for idx in vec:\\n if idx == 0:\\n continue\\n if idx > 0:\\n return tuple(vec)\\n else:\\n return tuple(-np.array(vec))\",\n \"def generateAllRegionVectors():\\n\\tregionVectors = []\\n\\tfor i in range(NUM_REGION_VECTORS):\\n\\t\\tregionVectors.append('{0:04x}'.format(i))\\n\\treturn regionVectors\",\n \"def vector_indx_to_map_matrix_indx(index,senzory_map):\\n xs = dict(zip(np.unique(senzory_map[:,0]), it.count()))\\n ys = dict(zip(np.negative(np.unique(senzory_map[:,1])), it.count()))\\n x, y = senzory_map[index]\\n return ys[y],xs[x]\",\n \"def test_conversions(self):\\n voxels = np.array([[0, 0, 0], [1, 2, 2], [1, 0, 0], [0, 1, 0], [0, 0, 1]])\\n size_x, size_y = 2, 3\\n expected_indices = np.array([0, 17, 1, 2, 6])\\n indices = _linearize_voxels(voxels, size_x, size_y)\\n np.testing.assert_array_equal(indices, expected_indices)\\n round_trip_voxels = _vectorize_voxels(indices, size_x, size_y)\\n np.testing.assert_array_equal(round_trip_voxels, voxels)\",\n \"def _vectorise_bag_of_pos_with_dependency(words, indexes):\\n matrixes = []\\n for i, index in enumerate(indexes):\\n poss = _get_bag_of_pos_with_dependency(words, index)\\n matrixes.append(\\\" \\\".join(poss))\\n return cv_dependencies.transform(matrixes).toarray().flatten()\",\n \"def lic_flow(vectors,len_pix=10):\\n vectors = np.asarray(vectors)\\n m,n,two = vectors.shape\\n if two!=2:\\n raise ValueError\\n\\n result = np.zeros((2*len_pix+1,m,n,2),dtype=np.int32) # FIXME: int16?\\n center = len_pix\\n result[center,:,:,0] = np.arange(m)[:,np.newaxis]\\n result[center,:,:,1] = np.arange(n)[np.newaxis,:]\\n\\n for i in range(m):\\n for j in range(n):\\n y = i\\n x = j\\n fx = 0.5\\n fy = 0.5\\n for k in range(len_pix):\\n vx, vy = vectors[y,x]\\n print x, y, vx, vy\\n if vx>=0:\\n tx = (1-fx)/vx\\n else:\\n tx = -fx/vx\\n if vy>=0:\\n ty = (1-fy)/vy\\n else:\\n ty = -fy/vy\\n if tx<ty:\\n print \\\"x step\\\"\\n if vx>0:\\n x+=1\\n fy+=vy*tx\\n fx=0.\\n else:\\n x-=1\\n fy+=vy*tx\\n fx=1.\\n else:\\n print \\\"y step\\\"\\n if vy>0:\\n y+=1\\n fx+=vx*ty\\n fy=0.\\n else:\\n y-=1\\n fx+=vx*ty\\n fy=1.\\n if x<0: x=0\\n if y<0: y=0\\n if x>=n: x=n-1\\n if y>=m: y=m-1\\n result[center+k+1,i,j,:] = y, x\\n\\n\\n\\n return result\",\n \"def vector2Nodes(self, vector):\\n nodes = []\\n loop = 0\\n\\n for n in self.nNodes:\\n temp = []\\n for i in range(n):\\n temp.append(vector[loop])\\n loop += 1\\n nodes.append(temp)\\n return nodes\",\n \"def proVec(*args):\\r\\n resultado = []\\r\\n i,j,k = (args[0][1] * args[1][2]) - (args[0][2] * args[1][1]) , ((args[0][0] * args[1][2]) - (args[0][2] * args[1][0])) * (-1) , (args[0][0] * args[1][1]) - (args[0][1] * args[1][0])\\r\\n resultado.append(i)\\r\\n resultado.append(j)\\r\\n resultado.append(k)\\r\\n return resultado\",\n \"def project_vectors_ab(a, b):\\n # print('dot = ', np.dot(a,b))\\n # print('norm = ', np.linalg.norm(b))\\n return np.dot(a, b) / np.linalg.norm(b)\",\n \"def Cvec(self):\\n return vec(self.xc, self.yc)\",\n \"def cross_vectors(u, v):\\n return [u[1] * v[2] - u[2] * v[1],\\n u[2] * v[0] - u[0] * v[2],\\n u[0] * v[1] - u[1] * v[0]]\",\n \"def vector(self):\\n return (self.row, self.col)\",\n \"def vertexes(self):\\n theta = self.orientation\\n shifts = np.array([np.cos(theta), np.sin(theta)]) * self.a\\n return self.coords + (shifts[:, None] * [-1, 1]).T\",\n \"def grab_40_vectors(x1,x2,y1,y2) -> list:\\n\\n if x1 > x2:\\n x1,x2 = x2,x1\\n if y1 > y2:\\n y1,y2 = y2,y1\\n\\n height = abs(y2-y1)\\n length = abs(x2-x1)\\n\\n height_delta = height/10\\n length_delta = length/10\\n\\n left_vertical_edge = [(x1, y1+height_delta*i) for i in range(0,11)]\\n # print(left_vertical_edge)\\n right_vertical_edge = [(x2,y1+height_delta*i) for i in range(0,11)]\\n # print(right_vertical_edge)\\n bottom_horizontal_edge = [(x1+length_delta*i,y1) for i in range(0,11)]\\n # print(bottom_horizontal_edge)\\n top_horizontal_edge = [(x1+length_delta*i,y2) for i in range(0,11)]\\n # print(top_horizontal_edge)\\n\\n all_vectors = left_vertical_edge+right_vertical_edge+bottom_horizontal_edge+top_horizontal_edge\\n return(all_vectors)\",\n \"def vec(self):\\r\\n\\r\\n xv = np.arange(self.dx / 2, self.lx, self.dx)\\r\\n yv = np.arange(-self.ly / 2 + self.dy / 2, self.ly / 2, self.dy)\\r\\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\\r\\n\\r\\n if self.ox != 0:\\r\\n xv = np.arange(self.ox, self.lx + self.ox, self.dx)\\r\\n yv = np.arange(self.oy, self.ly + self.oy, self.dy)\\r\\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\\r\\n\\r\\n return xv, yv, zv\",\n \"def xvec(self):\\n return np.array([self.x, self.y])\",\n \"def projection_to_vector(projection):\\n\\tglobal __n_graphs\\n\\tglobal __graph_id_to_list_id\\n\\n\\tvector = np.zeros(__n_graphs)\\n\\tfor p in projection:\\n\\t\\tlist_id = __graph_id_to_list_id[p.id]\\n\\t\\tvector[list_id] = 1\\n\\treturn vector\",\n \"def mni2vxl(coord):\\n i = int((90.0 - coord[0]) / 2)\\n j = int((coord[1] + 126) / 2)\\n k = int((coord[2] + 72) / 2)\\n return (i, j, k)\",\n \"def vector(self) -> np.ndarray:\\n link_vectors = [link.vector for link in self.links]\\n v = np.array(link_vectors).ravel()\\n return v\",\n \"def cartesian_of_projective(z):\\n alpha = z[0,:]\\n beta = z[1,:]\\n vz = np.real(np.conj(alpha)*alpha - np.conj(beta)*beta)\\n vx_plus_ivy = 2*np.conj(alpha)*beta\\n vx = np.real(vx_plus_ivy)\\n vy = np.imag(vx_plus_ivy)\\n return vx, vy, vz\",\n \"def box_to_indices(box):\\r\\n start_row = (box // 3) * 3\\r\\n start_col = (box % 3) * 3\\r\\n return [(row, col) for row in range(start_row, start_row + 3)\\r\\n for col in range(start_col, start_col + 3)]\",\n \"def cartesian_to_cylindrical(grid, vec=None):\\n\\n grid = np.atleast_2d(grid)\\n\\n if vec is None:\\n return np.hstack([\\n mkvc(np.sqrt(grid[:, 0]**2 + grid[:, 1]**2), 2),\\n mkvc(np.arctan2(grid[:, 1], grid[:, 0]), 2),\\n mkvc(grid[:, 2], 2)\\n ])\\n\\n if len(vec.shape) == 1 or vec.shape[1] == 1:\\n vec = vec.reshape(grid.shape, order='F')\\n\\n theta = np.arctan2(grid[:, 1], grid[:, 0])\\n\\n return np.hstack([\\n mkvc(np.cos(theta)*vec[:, 0] + np.sin(theta)*vec[:, 1], 2),\\n mkvc(-np.sin(theta)*vec[:, 0] + np.cos(theta)*vec[:, 1], 2),\\n mkvc(vec[:, 2], 2)\\n ])\",\n \"def generate_V(self):\\n\\n n_samples, n_dimensions, L = self.n_samples, self.n_dimensions, self.L\\n\\n V = np.zeros([L + 1, n_dimensions], dtype=int)\\n V[1:, 0] = [1 << (self.scale - j) for j in range(1, L + 1)]\\n\\n for i in range(n_dimensions - 1):\\n\\n m = np.array(directions[i], dtype=int)\\n s = len(m) - 1\\n\\n # The following code discards the first row of the ``m`` array\\n # Because it has floating point errors, e.g. values of 2.24e-314\\n if L <= s:\\n V[1:, i + 1] = [m[j] << (self.scale - j) for j in range(1, L + 1)]\\n else:\\n V[1 : s + 1, i + 1] = [\\n m[j] << (self.scale - j) for j in range(1, s + 1)\\n ]\\n for j in range(s + 1, L + 1):\\n V[j, i + 1] = V[j - s, i + 1] ^ (V[j - s, i + 1] >> s)\\n for k in range(1, s):\\n V[j, i + 1] ^= ((m[0] >> (s - 1 - k)) & 1) * V[j - k][i + 1]\\n\\n return V\",\n \"def co_vertexes(self):\\n theta = self.orientation + np.pi / 2\\n shifts = np.array([np.cos(theta), np.sin(theta)]) * self.b\\n return self.coords + (shifts[:, None] * [-1, 1]).T\",\n \"def coor2idx(x, y):\\r\\n a = round(x/4000,0)*4000\\r\\n b = (round_down(y/4000,0)+0.5)*4000\\r\\n i = int((a - 24000)/4000) + 1\\r\\n j = int((b - 22000)/4000) + 1\\r\\n return i, j\",\n \"def compute_barycentrics_native(coords, mesh):\\n triangle_indices = mesh.find_simplex(coords)\\n X = mesh.transform[triangle_indices, :2]\\n Y = coords - mesh.transform[triangle_indices, 2]\\n b = np.einsum('ijk,ik->ij', X, Y)\\n bcoords = np.c_[b, 1 - b.sum(axis=1)]\\n return bcoords, triangle_indices\",\n \"def vec_cross(a,b):\\r\\n return [a[1] * b[2] - a[2] * b[1],\\r\\n a[2] * b[0] - a[0] * b[2],\\r\\n a[0] * b[1] - a[1] * b[0]]\",\n \"def reconstruct_vectors(self, vectors):\\n return self.instance_vectors(self.project_vectors(vectors))\",\n \"def _velocity_cylindrical2cartesian(pos,vel):\\n \\n \\n #save cartesian position of each particle\\n theta=pos[:,1]\\n\\n #save cyindrical velocities\\n vr=vel[:,0]\\n vtheta=vel[:,1]\\n vz=vel[:,2]\\n\\n #compute cartesian velocities\\n vx = vr*np.cos(theta) - vtheta*np.sin(theta)\\n vy = vr*np.sin(theta) + vtheta*np.cos(theta)\\n vz = vz\\n\\n return np.dstack((vx,vy,vz))[0]\",\n \"def levelsets_to_vector_field(levelsets, stepsize):\\r\\n vector_field_shape = levelsets[0][0].shape\\r\\n y_comp_combined = np.ndarray(vector_field_shape)\\r\\n x_comp_combined = np.ndarray(vector_field_shape)\\r\\n y_comp_combined.fill(np.nan)\\r\\n x_comp_combined.fill(np.nan)\\r\\n\\r\\n for source, target in levelsets:\\r\\n labels_present = set(np.array([source.flatten(),target.flatten()]).flatten())\\r\\n labels_present.remove(0)#relates to background\\r\\n\\r\\n #print(labels_present)\\r\\n for l in labels_present:\\r\\n\\r\\n source_cluster = source == l\\r\\n target_cluster = target == l\\r\\n\\r\\n\\r\\n \\\"\\\"\\\"plt.imshow(source_cluster.astype(np.int32)+target_cluster.astype(np.int32))\\r\\n plt.show()\\r\\n print(\\\"-----------\\\")\\\"\\\"\\\"\\r\\n\\r\\n #plot_gradient_field(source_cluster.astype(np.int32), target_cluster.astype(np.int32))\\r\\n\\r\\n y_comp, x_comp = array_to_vector_field(source_cluster, target_cluster, stepsize=stepsize)\\r\\n y_comp_combined[~np.isnan(y_comp)] = y_comp[~np.isnan(y_comp)]\\r\\n x_comp_combined[~np.isnan(x_comp)] = x_comp[~np.isnan(x_comp)]\\r\\n return y_comp_combined, x_comp_combined\",\n \"def getVector(c1, c2):\\n return [c1[0] - c2[0], c1[1] - c2[1], c1[2] - c2[2]]\",\n \"def vector(self,\\n i: int,\\n j: int) -> np.ndarray:\\n return self[j].coord - self[i].coord\",\n \"def get_vectors(dim, R2):\\n\\n #collecting base vectors\\n base_vecs = []\\n numbers = get_set(dim, R2)\\n while len(numbers) >= dim:\\n vec = get_base_vector(dim, R2, deepcopy(numbers))\\n if vec is not False:\\n base_vecs += [np.sqrt(vec)]\\n numbers.remove(max(numbers))\\n #permuting base vectors\\n uvecs = []\\n for vec in base_vecs:\\n for per_vec in permutations(vec):\\n uvecs += [per_vec]\\n uvecs = list(set(uvecs))\\n\\n #adding all possible sign options\\n vecs = []\\n for vec in uvecs:\\n for sign in sign_possibilities(dim):\\n vecs += [tuple([int(a*b) for a, b in zip(sign, vec)])]\\n vecs = list(set(vecs))\\n return vecs\",\n \"def align_to_pole_vector():\\n selection_list = pm.ls(sl=1)\\n\\n ik_handle = \\\"\\\"\\n control_object = \\\"\\\"\\n\\n for obj in selection_list:\\n if pm.nodeType(obj) == 'ikHandle':\\n ik_handle = obj\\n else:\\n control_object = obj\\n\\n temp = pm.listConnections((ik_handle + '.startJoint'), s=1)\\n start_joint = temp[0]\\n start_joint_pos = pm.xform(start_joint, q=True, ws=True, t=True)\\n\\n temp = pm.listConnections((ik_handle + '.endEffector'), s=1)\\n end_effector = temp[0]\\n pm.xform(\\n control_object,\\n ws=True,\\n t=(start_joint_pos[0], start_joint_pos[1], start_joint_pos[2])\\n )\\n\\n pm.parent(control_object, end_effector)\\n pm.setAttr(control_object + '.r', 0, 0, 0)\\n\\n pm.parent(control_object, w=True)\",\n \"def hexgrid(self):\\n n = self.n * 2\\n vectors = []\\n for u in range(-n, n+1):\\n us = [u] * (2*n+1)\\n if u < 0:\\n vectors.extend(zip(us, range(-n-u, n+1), range(-n, n+u+1)))\\n else:\\n vectors.extend(zip(us, range(-n, n-u+1), range(-n+u, n+1)))\\n return vectors\",\n \"def MillerNormalVectors_111():\\r\\n k_111 = np.array(\\r\\n [[1, 1, 1], [-1, 1, 1], [1, -1, 1], [1, 1, -1]])/np.sqrt(3.0)\\r\\n return np.array([k_111[0, :], k_111[1, :], k_111[2, :], k_111[3, :],\\r\\n -k_111[0, :], -k_111[1, :], -k_111[2, :], -k_111[3, :]])\",\n \"def cylindrical_to_cartesian(grid, vec=None):\\n grid = np.atleast_2d(grid)\\n\\n if vec is None:\\n return np.hstack([\\n mkvc(grid[:, 0]*np.cos(grid[:, 1]), 2),\\n mkvc(grid[:, 0]*np.sin(grid[:, 1]), 2),\\n mkvc(grid[:, 2], 2)\\n ])\\n\\n if len(vec.shape) == 1 or vec.shape[1] == 1:\\n vec = vec.reshape(grid.shape, order='F')\\n\\n x = vec[:, 0] * np.cos(grid[:, 1]) - vec[:, 1] * np.sin(grid[:, 1])\\n y = vec[:, 0] * np.sin(grid[:, 1]) + vec[:, 1] * np.cos(grid[:, 1])\\n\\n newvec = [x, y]\\n if grid.shape[1] == 3:\\n z = vec[:, 2]\\n newvec += [z]\\n\\n return np.vstack(newvec).T\",\n \"def create_vector(bit_set, size_vector=128, size_block=32):\\n vector = [0] * size_vector\\n for i in bit_set:\\n index = i[1]\\n if index == 0:\\n vector[(i[0]) * size_block] = 1\\n else:\\n vector[(i[0] + 1) * size_block - index] = 1 # we decal to the left so we start from the end of the array\\n return vector\",\n \"def binary_vector_to_objects(self, vector: np.ndarray) -> Sequence[Any]:\\n return [self.idx_to_obj[i] for i, value in enumerate(vector) if value == 1]\",\n \"def cartesian_2_cylindrical(grid, vec=None):\\n return cartesian_to_cylindrical(grid, vec)\",\n \"def mainIndices(self):\\n return self.i1, self.i2\",\n \"def landmarks_as_vectors(landmarks):\\n mat = []\\n for lm in landmarks:\\n mat.append(lm.as_vector())\\n return np.array(mat)\",\n \"def _pair_indices(self):\\n indices_src = []\\n indices_dst = []\\n for i in range(self.walk_len):\\n for j in range(max(i - self.l, 0), i):\\n indices_src.append(i)\\n indices_dst.append(j)\\n for j in range(i + 1, min(i + self.r + 1, self.walk_len)):\\n indices_src.append(i)\\n indices_dst.append(j)\\n return indices_src, indices_dst\",\n \"def vector_edge_to_node(self,c,v_normal_j):\\n nodes=self.grid.cell_to_nodes(c)\\n Nsides=len(nodes)\\n modn=lambda ni: nodes[ni%Nsides]\\n node_vectors=np.zeros((Nsides,2),np.float64)\\n for ns in range(Nsides):\\n j_prev = self.grid.nodes_to_edge(modn(ns-1),modn(ns))\\n j_next = self.grid.nodes_to_edge(modn(ns),modn(ns+1))\\n # Looking for the vector which satisfies\\n # dot(vec,n_prev) = flux_prev\\n # dot(vec,n_next) = flux_next\\n mat = np.array([self.normal_j[j_prev],\\n self.normal_j[j_next]])\\n projected = np.array([v_normal_j[j_prev],v_normal_j[j_next]])\\n node_vectors[ns,:] = np.linalg.solve(mat,projected)\\n return node_vectors\",\n \"def get_bar_vector(model, elem, node1, node2, xyz1):\\n cd1 = node1.Cd()\\n cd2 = node2.Cd()\\n if model is None:\\n cd1_ref = node1.cd_ref\\n cd2_ref = node2.cd_ref\\n\\n # get the vector v, which defines the projection on to the elemental\\n # coordinate frame\\n if elem.g0:\\n #msg = 'which is required by %s eid=%s\\\\n%s' % (elem.type, elem.g0, str(elem))\\n g0_ref = elem.g0_ref\\n n0 = g0_ref.get_position()\\n v = n0 - xyz1\\n else:\\n v = cd1_ref.transform_node_to_global(elem.x)\\n\\n else:\\n msg = ', which is required by %s=%s' % (elem.type, elem.eid)\\n cd1_ref = model.Coord(cd1)\\n cd2_ref = model.Coord(cd2)\\n\\n # get the vector v, which defines the projection on to the elemental\\n # coordinate frame\\n if elem.g0:\\n #msg = 'which is required by %s eid=%s\\\\n%s' % (elem.type, elem.g0, str(elem))\\n g0_ref = model.Node(elem.g0, msg=msg)\\n n0 = g0_ref.get_position()\\n v = n0 - xyz1\\n else:\\n v = cd1_ref.transform_node_to_global(elem.x)\\n cd1_ref = model.Coord(cd1)\\n cd2_ref = model.Coord(cd2)\\n\\n return v, cd1, cd1_ref, cd2, cd2_ref\",\n \"def vector(p0, p1):\\n a = p1[0] - p0[0]\\n b = p1[1] - p0[1]\\n return (a, b)\",\n \"def efficient_integer_vectors(self):\\n return self._efficient_integer_vectors\",\n \"def getVectors(self,graph):\\n return [Vector.createFromTwoTuples(graph[i],graph[i+1]) for i in range(len(graph)-1)]\",\n \"def normal_vector(origin, vectors):\\n return np.cross(vectors[0] - origin, vectors[1] - origin)\",\n \"def build_amg_index_sets(L_sizes):\\n neqns = L_sizes[0][0]\\n velocityDOF=[]\\n for start in range(1,3):\\n velocityDOF.append(np.arange(start=start,\\n stop=1+neqns,\\n step=3,\\n dtype='i'))\\n velocityDOF_full=np.vstack(velocityDOF).transpose().flatten()\\n velocity_u_DOF = []\\n velocity_u_DOF.append(np.arange(start=0,\\n stop=2*neqns//3,\\n step=2,\\n dtype='i'))\\n velocity_u_DOF_full = np.vstack(velocity_u_DOF).transpose().flatten()\\n velocity_v_DOF = []\\n velocity_v_DOF.append(np.arange(start=1,\\n stop=1+2*neqns//3,\\n step=2,\\n dtype='i'))\\n velocity_v_DOF_full = np.vstack(velocity_v_DOF).transpose().flatten()\\n isvelocity = PETSc.IS()\\n isvelocity.createGeneral(velocityDOF_full)\\n isu = PETSc.IS()\\n isu.createGeneral(velocity_u_DOF_full)\\n isv = PETSc.IS()\\n isv.createGeneral(velocity_v_DOF_full)\\n return [isvelocity, isu, isv]\",\n \"def get_vertices(self):\\n vertices = []\\n V = [[-self.base_vectors[:,n], self.base_vectors[:,n]] for n in range(self.base_vectors.shape[1])]\\n combs = list(itertools.product(*V))\\n for cb in combs:\\n cb = np.sum(np.array(cb).T, axis=1, keepdims=True)\\n vertices.append(self.base_vertices + cb)\\n\\n vertices = np.concatenate(vertices,axis=1)\\n return vertices\",\n \"def basis_vector_matrix(*e):\\n return np.array(e).T\",\n \"def get_bar_yz_transform(v, ihat, eid, xyz1, xyz2, nid1, nid2, i, Li):\\n vhat = v / norm(v) # j\\n try:\\n z = np.cross(ihat, vhat) # k\\n except ValueError:\\n msg = 'Invalid vector length\\\\n'\\n msg += 'xyz1=%s\\\\n' % str(xyz1)\\n msg += 'xyz2=%s\\\\n' % str(xyz2)\\n msg += 'nid1=%s\\\\n' % str(nid1)\\n msg += 'nid2=%s\\\\n' % str(nid2)\\n msg += 'i =%s\\\\n' % str(i)\\n msg += 'Li =%s\\\\n' % str(Li)\\n msg += 'ihat=%s\\\\n' % str(ihat)\\n msg += 'v =%s\\\\n' % str(v)\\n msg += 'vhat=%s\\\\n' % str(vhat)\\n msg += 'z=cross(ihat, vhat)'\\n print(msg)\\n raise ValueError(msg)\\n\\n zhat = z / norm(z)\\n yhat = np.cross(zhat, ihat) # j\\n\\n if norm(ihat) == 0.0 or norm(yhat) == 0.0 or norm(z) == 0.0:\\n print(' invalid_orientation - eid=%s yhat=%s zhat=%s v=%s i=%s n%s=%s n%s=%s' % (\\n eid, yhat, zhat, v, i, nid1, xyz1, nid2, xyz2))\\n elif not np.allclose(norm(yhat), 1.0) or not np.allclose(norm(zhat), 1.0) or Li == 0.0:\\n print(' length_error - eid=%s Li=%s Lyhat=%s Lzhat=%s'\\n ' v=%s i=%s n%s=%s n%s=%s' % (\\n eid, Li, norm(yhat), norm(zhat), v, i, nid1, xyz1, nid2, xyz2))\\n return yhat, zhat\",\n \"def _gu_matvec(x1, x2):\\n return (x1 @ x2[..., np.newaxis])[..., 0]\",\n \"def vector_line(self):\\n assert len(self.xcoords) == 2\\n diff_x = self.xcoords[1] - self.xcoords[0]\\n diff_z = self.zcoords[1] - self.zcoords[0]\\n vec = np.hstack((diff_x, diff_z))\\n return vec\",\n \"def gains_vector(m):\\n\\n n_ant, n_chan, n_dir, _ = m.shape\\n row_shape = n_ant * n_chan * n_dir\\n g = np.zeros((2*row_shape), dtype=np.complex128)\\n\\n for nu in range(n_chan):\\n for s in range(n_dir):\\n for a in range(n_ant):\\n row = a + n_ant * s + n_ant * n_dir * nu \\n g[row] = m[a, nu, s, 0]\\n g[row + row_shape] = m[a, nu, s, 1]\\n \\n return g\",\n \"def _indices_to_coords(c,r):\\n\\n column = _index_to_column(c)\\n row = r + 1\\n\\n return {'c': column, 'r': row, 'coord': f'{column}{row}'}\",\n \"def vector(self):\\n return self.q[1:4]\",\n \"def project_onto_plane(vect):\\n x, y, z = vect\\n \\n return (x, y, 0.)\",\n \"def _ivector_index_to_node(i_components,_intermediate_node): \\n return Vector(\\n index= [\\n _intermediate_node[uid_i]\\n for uid_i in i_components.iterkeys()\\n \\n ],\\n value=i_components._value\\n )\",\n \"def getVectors(self):\\n l = len(self.points)\\n return [Vector.createFromTwoPoints(self.points[i % l], self.points[(i + 1) % l], \\\\\\n color=self.side_color, width=self.side_width) for i in range(l)]\",\n \"def _position_cartesian2cylindrical(pos):\\n\\n \\n #save cartesian position of each particle\\n x=pos[:,0]\\n y=pos[:,1]\\n z=pos[:,2]\\n\\n rho= np.sqrt(x**2+y**2)\\n theta=np.arctan2(y,x)\\n\\n\\n return np.dstack((rho,theta,z))[0]\",\n \"def parallelpiped_volume(lattice_vectors):\\n a = lattice_vectors[:, 0]\\n b = lattice_vectors[:, 1]\\n c = lattice_vectors[:, 2]\\n return triple_product(a, b, c)\",\n \"def indices(shape):\\n iterables = [range(v) for v in shape]\\n return product(*iterables)\",\n \"def indices(shape):\\n iterables = [range(v) for v in shape]\\n return product(*iterables)\",\n \"def indexes_to_objects(self, index_vector: np.ndarray) -> Sequence[Any]:\\n return [self.idx_to_obj[idx] for idx in index_vector if idx in self.idx_to_obj]\",\n \"def indices(self):\\n _indices = []\\n for h in self.miller.indices():\\n _indices.append(self.indices_hkl(*h)[0])\\n return _indices\",\n \"def _vectorise_bag_of_pos(words, indexes, N, targets=[]):\\n matrixes = []\\n for i, index in enumerate(indexes):\\n poss = _get_bag_of_pos(words, index, N, target_len=len(targets[i].split()))\\n matrixes.append(\\\" \\\".join(poss))\\n return cv_normal.transform(matrixes).toarray().flatten()\",\n \"def get_vectors(nodes, mode=\\\"xform\\\"):\\n for each in nodes:\\n position = (0, 0, 0)\\n\\n if mode == \\\"xform\\\":\\n position = cmds.xform(\\n each,\\n query=True,\\n translation=True,\\n worldSpace=True,\\n )\\n\\n elif mode == \\\"pivot\\\":\\n position = cmds.xform(\\n each,\\n query=True,\\n translation=True,\\n rotatePivot=True,\\n worldSpace=True,\\n )\\n\\n # when using xform on component like faces or edge, the returned value\\n # will be a list of each vertices position, so we need to average that\\n if len(position) > 3:\\n vectors = [\\n MVector(position[i : i + 3])\\n for i in range(0, len(position), 3)\\n ]\\n result = MVector()\\n for vector in vectors:\\n result += vector\\n position = result / len(vectors)\\n\\n yield MVector(position)\",\n \"def vec_x(self):\\t\\r\\n if self.ox != 0:\\r\\n ov = self.ox\\r\\n lv = self.self.lx + self.ox\\r\\n else:\\r\\n ov = self.dx / 2\\r\\n lv = self.lx\\r\\n\\r\\n xv = \\\"\\\"\\r\\n for num in np.arange(ov, lv, self.dx):\\r\\n xv += str(num) + \\\" \\\"\\r\\n\\r\\n return xv\",\n \"def cartesian2spherical(v):\\n theta = np.arcsin(v[2]) \\n phi = np.arctan2(v[1], v[0])\\n \\n return [theta, phi]\",\n \"def get_uncut_indices(atoms, orig, vec1, offset=None):\\n\\n if isinstance(orig, int):\\n orig = atoms.get_positions()[orig]\\n else:\\n orig = np.array(orig)\\n if isinstance(vec1, int):\\n vec1 = atoms.get_positions()[vec1]\\n else:\\n vec1 = np.array(vec1)\\n\\n# if vec2 and isinstance(vec2, int):\\n# vec2 = atoms.get_positions()[vec2]\\n# elif vec2:\\n# vec2 = np.array(vec2)\\n# if vec3 and isinstance(vec3, int):\\n# vec3 = atoms.get_positions()[vec3]\\n# elif vec3:\\n# vec3 = np.array(vec3)\\n#\\n# if vec2:\\n# plane_vec = np.cross(vec1-orig, vec2-orig)\\n# else:\\n# plane_vec = vec1-orig\\n#\\n# nplane_vec = plane_vec/np.linalg.norm(plane_vec)\\n#\\n# if vec2 and vec3 and nplane_vec.dot(vec3-orig) < 0:\\n# nplane_vec *= -1\\n\\n plane_vec = vec1 - orig\\n nplane_vec = plane_vec/np.linalg.norm(plane_vec)\\n\\n if offset:\\n orig += offset*nplane_vec\\n\\n atom_indices = [i for i,a in enumerate(atoms) if (a.position - orig).dot(nplane_vec) > 0]\\n return atom_indices\",\n \"def _velocity_cartesian2cylindrical(pos,vel):\\n \\n \\n \\n #save cartesian velocities\\n vx=vel[:,0]\\n vy=vel[:,1]\\n vz=vel[:,2]\\n\\n #convert to cylindrical coordinates\\n pos_cyl=_position_cartesian2cylindrical(pos) #cylindrical coordinates\\n theta=pos_cyl[:,1]\\n\\n #compute cylindrical velocities\\n vr=vx*np.cos(theta) + vy*np.sin(theta)\\n vtheta=-vx*np.sin(theta) + vy*np.cos(theta)\\n vz=vz\\n \\n\\n return np.dstack((vr,vtheta,vz))[0]\",\n \"def vector_perp(v):\\n assert len(v) == 2\\n x, y = v\\n return Vector(-y, x)\",\n \"def rasterize(x):\\n for i, y in enumerate(x):\\n for v in y:\\n yield i, v\",\n \"def rotate_c(X,a_set,vector):\\r\\n\\taxis_vector = math.radians(-X) * np.array([0,0,1])\\r\\n\\tr = R.from_rotvec(axis_vector)\\r\\n\\treturn list(r.apply(vector))\",\n \"def cylindrical_2_cartesian(grid, vec=None):\\n return cylindrical_to_cartesian(grid, vec)\",\n \"def f_v(_a, _vs, _Ps, _Ps0): # _aはスカラ, _vsはベクトル, _Ps, _Ps0は３行2列の行列\\n center_pos = _Ps[0]\\n center_pos_0 = _Ps0[0]\\n idx_iter = Index_iterator(1, 8)\\n #中心点から各点へのベクトル\\n x = []\\n x0 = []\\n for p in (_Ps):\\n x.append(p - center_pos)\\n for p in _Ps(_Ps0):\\n x0.append(p - center_pos_0)\\n\\n x01 = (_Ps[1]-center_pos) \\n x02 = (_Ps[2]-center_pos) \\n x03 = (_Ps[3]-center_pos) \\n x04 = (_Ps[4]-center_pos) \\n x05 = (_Ps[5]-center_pos) \\n x06 = (_Ps[6]-center_pos) \\n x07 = (_Ps[7]-center_pos) \\n x08 = (_Ps[8]-center_pos)\\n print('p_id', center_pos, end='\\\\t')\\n print('x01:', x01, end=\\\"\\\\t\\\")\\n print('x03:', x03, end=\\\"\\\\t\\\")\\n print('x05:', x05, end=\\\"\\\\t\\\")\\n print('x07:', x07)\\n x001 = (_Ps0[1]-_Ps0[0]) \\n x002 = (_Ps0[2]-_Ps0[0]) \\n x003 = (_Ps0[3]-_Ps0[0]) \\n x004 = (_Ps0[4]-_Ps0[0]) \\n x005 = (_Ps0[5]-_Ps0[0]) \\n x006 = (_Ps0[6]-_Ps0[0]) \\n x007 = (_Ps0[7]-_Ps0[0]) \\n x008 = (_Ps0[8]-_Ps0[0]) \\n \\n #中心点周りの面の面積\\n def calc_area(j,k,l):\\n s = LA.norm(np.cross(x[j],x[k]))/2 \\\\\\n + LA.norm(np.cross(x[k],x[l]))/2\\n return s\\n\\n s = []\\n s0 = []\\n hen = [1,3,5,7]\\n for i in range(4):\\n j,k,l = [n for n in idx_iter.get_indexes(start_idx=hen[i], 3)]\\n s[i] = calc_area(j,k,l)\\n s0[i] = calc_area(j,k,l)\\n\\n # s0123 = LA.norm(np.cross(x[1],x[2]))/2\\\\\\n # +LA.norm(np.cross(x[2],x[3]))/2\\n # s4367 = LA.norm(np.cross(x[3],x[4]))/2\\\\\\n # +LA.norm(np.cross(x[4],x[5]))/2\\n # s4785 = LA.norm(np.cross(x[5],x[6]))/2\\\\\\n # +LA.norm(np.cross(x[6],x[7]))/2\\n # s4521 = LA.norm(np.cross(x[7],x[8]))/2\\\\\\n # +LA.norm(np.cross(x[8],x[1]))/2\\n # s04103 = LA.norm(np.cross(x0[1],x0[2]))/2\\\\\\n # +LA.norm(np.cross(x0[2],x0[3]))/2\\n # s04367 = LA.norm(np.cross(x0[3],x0[4]))/2\\\\\\n # +LA.norm(np.cross(x0[4],x0[7]))/2\\n # s04785 = LA.norm(np.cross(x0[7],x0[8]))/2\\\\\\n # +LA.norm(np.cross(x0[8],x0[5]))/2\\n # s04521 = LA.norm(np.cross(x0[5],x0[2]))/2\\\\\\n # +LA.norm(np.cross(x0[2],x0[1]))/2\\n \\n #各方向への平均面積(ここだけ反時計回り順で設定してる)\\n S_iminus = (s[1] + s[2]) / 2 #43方向\\n S_Jminus = (s[1] + s[4]) / 2 #41方向\\n S_iplus = (s[3] + s[4]) / 2 #45方向\\n S_Jplus = (s[3] + s[2]) / 2 #47方向\\n S_iminus0 = (s0[1] + s0[2]) / 2 #43方向\\n S_Jminus0 = (s0[1] + s0[4]) / 2 #41方向\\n S_iplus0 = (s0[3] + s0[4]) / 2 #45方向\\n S_Jplus0 = (s0[3] + s0[2]) / 2 #47方向\\n # 各方向への厚み\\n h_iminus = h_0 / ((poisson/(1-poisson) * (S_iminus - S_iminus0) / S_iminus0) + 1) #43方向\\n h_Jminus = h_0 / ((poisson/(1-poisson) * (S_Jminus - S_Jminus0) / S_Jminus0) + 1) #41方向\\n h_iplus = h_0 / ((poisson/(1-poisson) * (S_iplus - S_iplus0) / S_iplus0) + 1) #45方向\\n h_Jplus = h_0 / ((poisson/(1-poisson) * (S_Jplus - S_Jplus0) / S_Jplus0) + 1) #47方向\\n # 各断片の重心\\n g = []\\n kado = [2,4,6,8]\\n hen = [1,3,5,7]\\n for i in range(len(kado)):\\n _kado = kado[i]\\n _hen1, _ = [idx for idx in idx_iter.get_indexes_reverse(_kado, 2)]\\n _hen2, _ = [idx for idx in idx_iter.get_indexes(_kado, 2)]\\n _hen = [_hen1, _hen2]\\n _g1 = (center_pos + _Ps[_kado] + _Ps[_hen1])/3\\n _g2 = (center_pos + _Ps[_kado] + _Ps[_hen2])/3\\n g.append([_g1, _g2])\\n\\n g401 = (center_pos + _Ps[0] + _Ps[1]) / 3\\n g430 = (center_pos + _Ps[3] + _Ps[0]) / 3\\n g436 = (center_pos + _Ps[3] + _Ps[6]) / 3\\n g467 = (center_pos + _Ps[6] + _Ps[7]) / 3\\n g478 = (center_pos + _Ps[7] + _Ps[8]) / 3\\n g485 = (center_pos + _Ps[8] + _Ps[5]) / 3\\n g452 = (center_pos + _Ps[5] + _Ps[2]) / 3\\n g421 = (center_pos + _Ps[2] + _Ps[1]) / 3\\n g0401 = (_Ps0[4] + _Ps0[0] + _Ps0[1]) / 3\\n g0430 = (_Ps0[4] + _Ps0[3] + _Ps0[0]) / 3\\n g0436 = (_Ps0[4] + _Ps0[3] + _Ps0[6]) / 3\\n g0467 = (_Ps0[4] + _Ps0[6] + _Ps0[7]) / 3\\n g0478 = (_Ps0[4] + _Ps0[7] + _Ps0[8]) / 3\\n g0485 = (_Ps0[4] + _Ps0[8] + _Ps0[5]) / 3\\n g0452 = (_Ps0[4] + _Ps0[5] + _Ps0[2]) / 3\\n g0421 = (_Ps0[4] + _Ps0[2] + _Ps0[1]) / 3\\n \\n # 各断片面積\\n triangle_area = []\\n kado = [2,4,6,8]\\n for i in range(len(kado)):\\n j, k = [idx for idx in idx_iter.get_indexes_reverse(kado[i], 1)]\\n _s1 = LA.norm(np.cross(x[j],x[k]))/2\\n j, k = [idx for idx in idx_iter.get_indexes(kado[i], 1)]\\n _s2 = LA.norm(np.cross(x[j],x[k]))/2\\n triangle_area.append([_s1, _s2])\\n\\n s410 = LA.norm(np.cross(x[1],x[2]))/2\\n s403 = LA.norm(np.cross(x[2],x[3]))/2\\n s436 = LA.norm(np.cross(x[3],x[4]))/2\\n s467 = LA.norm(np.cross(x[4],x[5]))/2\\n s478 = LA.norm(np.cross(x[5],x[6]))/2\\n s485 = LA.norm(np.cross(x[6],x[7]))/2\\n s452 = LA.norm(np.cross(x[7],x[8]))/2\\n s421 = LA.norm(np.cross(x[8],x[1]))/2\\n s0410 = LA.norm(np.cross(x0[1],x0[2]))/2\\n s0403 = LA.norm(np.cross(x0[2],x0[3]))/2\\n s0436 = LA.norm(np.cross(x0[3],x0[4]))/2\\n s0467 = LA.norm(np.cross(x0[4],x0[5]))/2\\n s0478 = LA.norm(np.cross(x0[5],x0[6]))/2\\n s0485 = LA.norm(np.cross(x0[6],x0[7]))/2\\n s0452 = LA.norm(np.cross(x0[7],x0[8]))/2\\n s0421 = LA.norm(np.cross(x0[8],x0[1]))/2\\n # 四角の重心\\n\\n center_g_square = []\\n for i in range(len(g)):\\n _g = (triangle_area[i][0]*g[i][0] + triangle_area[i][1]*g[i][1])/(triangle_area[i][0] + triangle_area[i][1])\\n center_g.append(_g)\\n g4103 = (s410*g401 + s403*g430) / (s410 + s403)\\n g4367 = (s436*g436 + s467*g467) / (s436 + s467)\\n g4785 = (s478*g478 + s485*g485) / (s478 + s485)\\n g4521 = (s452*g452 + s421*g421) / (s452 + s421)\\n g04103 = (s0410*g0401 + s0403*g0430) / (s0410 + s0403)\\n g04367 = (s0436*g0436 + s0467*g0467) / (s0436 + s0467)\\n g04785 = (s0478*g0478 + s0485*g0485) / (s0478 + s0485)\\n g04521 = (s0452*g0452 + s0421*g0421) / (s0452 + s0421)\\n # 各重心間の距離\\n Lj82 = LA.norm(g4521 - g4103)\\n Lj24 = LA.norm(g4103 - g4367)\\n Lj46 = LA.norm(g4367 - g4785)\\n Lj68 = LA.norm(g4785 - g4521)\\n \\n # ひずみ\\n eps_i41 = (LA.norm(x01) - LA.norm(x041)) / LA.norm(x041)\\n eps_J41 = (LA.norm(g4521 - g4103) - LA.norm(g04521 - g04103)) / LA.norm(g04521 - g04103)\\n eps_i43 = (LA.norm(x03) - LA.norm(x043)) / LA.norm(x043)\\n eps_J43 = (LA.norm(g4103 - g4367) - LA.norm(g04103 - g04367)) / LA.norm(g04103 - g04367)\\n eps_i47 = (LA.norm(x01) - LA.norm(x041)) / LA.norm(x041)\\n eps_J47 = (LA.norm(g4367 - g4785) - LA.norm(g04367 - g04785)) / LA.norm(g04367 - g04785)\\n eps_i45 = (LA.norm(x01) - LA.norm(x041)) / LA.norm(x041)\\n eps_J45 = (LA.norm(g4785 - g4521) - LA.norm(g04785 - g04521)) / LA.norm(g04785 - g04521)\\n # 張力\\n F_T1 = (young_modulus * h_Jminus * Lj82 * (eps_i41 + poisson * eps_J41) / (1 - poisson**2))*x01/LA.norm(x01)\\n F_T3 = (young_modulus * h_iminus * Lj24 * (eps_i43 + poisson * eps_J43) / (1 - poisson**2))*x03/LA.norm(x03)\\n F_T5 = (young_modulus * h_Jplus * Lj46 * (eps_i47 + poisson * eps_J47) / (1 - poisson**2))*x05/LA.norm(x05)\\n F_T7 = (young_modulus * h_iplus * Lj68 * (eps_i45 + poisson * eps_J45) / (1 - poisson**2))*x07/LA.norm(x07)\\n # せん断ひずみ\\n gamma513 = (math.acos((np.dot(x07,x01))/(LA.norm(x07)*LA.norm(x01))) - math.acos((np.dot(x045,x041))/(LA.norm(x045)*LA.norm(x041)))\\\\\\n + math.acos((np.dot(x03,x01))/(LA.norm(x03)*LA.norm(x01))) - math.acos((np.dot(x043,x041))/(LA.norm(x043)*LA.norm(x041))))/2\\n gamma137 = (math.acos((np.dot(x01,x03))/(LA.norm(x01)*LA.norm(x03))) - math.acos((np.dot(x041,x043))/(LA.norm(x041)*LA.norm(x043)))\\\\\\n + math.acos((np.dot(x03,x05))/(LA.norm(x03)*LA.norm(x05))) - math.acos((np.dot(x043,x047))/(LA.norm(x043)*LA.norm(x047))))/2\\n gamma375 = (math.acos((np.dot(x05,x03))/(LA.norm(x05)*LA.norm(x03))) - math.acos((np.dot(x047,x043))/(LA.norm(x047)*LA.norm(x043)))\\\\\\n + math.acos((np.dot(x07,x05))/(LA.norm(x07)*LA.norm(x05))) - math.acos((np.dot(x045,x047))/(LA.norm(x045)*LA.norm(x047))))/2\\n gamma751 = (math.acos((np.dot(x05,x07))/(LA.norm(x05)*LA.norm(x07))) - math.acos((np.dot(x047,x045))/(LA.norm(x047)*LA.norm(x045)))\\\\\\n + math.acos((np.dot(x07,x01))/(LA.norm(x07)*LA.norm(x01))) - math.acos((np.dot(x045,x041))/(LA.norm(x045)*LA.norm(x041))))/2\\n # せん断力\\n F_S41 = ((young_modulus * h_Jminus * LA.norm(x01) * gamma513)/(2 * (1 + poisson)))*x01/LA.norm(x01)\\n F_S43 = ((young_modulus * h_Jminus * LA.norm(x03) * gamma137)/(2 * (1 + poisson)))*x03/LA.norm(x03)\\n F_S47 = ((young_modulus * h_Jminus * LA.norm(x05) * gamma375)/(2 * (1 + poisson)))*x05/LA.norm(x05)\\n F_S45 = ((young_modulus * h_Jminus * LA.norm(x07) * gamma751)/(2 * (1 + poisson)))*x07/LA.norm(x07)\\n \\n # J方向の曲げ力\\n n_j_cross = np.cross(x05, x01)\\n if any(n_j_cross):\\n n_J = n_j_cross/LA.norm(n_j_cross)\\n else: \\n\\n l_Jalfa = LA.norm(_Ps[1] - _Ps[7])\\n cos_Jalfa = (LA.norm(x01)**2 + LA.norm(x05)**2 - l_Jalfa**2) / (2 * LA.norm(x01) * LA.norm(x05))\\n if cos_Jalfa > 1.0:\\n cos_Jalfa = 1.0\\n elif cos_Jalfa < -1.0:\\n cos_Jalfa = -1.0\\n sin_Jalfa = math.sqrt(1 - cos_Jalfa**2)\\n CJa2 = math.sqrt((cos_Jalfa + 1)/2)\\n SJa2 = math.sqrt((1 - cos_Jalfa)/2)\\n zJC = (_Ps[7][2]-_Ps[1][2])/(_Ps[7][0]-_Ps[1][0]) * (center_pos[0]-_Ps[1][0]) + _Ps[1][2] #曲げ力の方向の場合わけに必要\\n if center_pos[2] > zJC:\\n e_j = np.dot(np.array([[CJa2 + (n_J[0]**2) * (1 - CJa2), n_J[0] * n_J[1] * (1 - CJa2) + n_J[2] * SJa2, n_J[0] * n_J[2] * (1 - CJa2) - n_J[1] * SJa2],\\\\\\n [n_J[1] * n_J[0] * (1 - CJa2) - n_J[2] * SJa2, CJa2 + (n_J[1]**2) * (1 - CJa2), n_J[1] * n_J[2] * (1 - CJa2) + n_J[0] * SJa2],\\\\\\n [n_J[2] * n_J[0] * (1 - CJa2) + n_J[1] * SJa2, n_J[2] * n_J[1] * (1 - CJa2) - n_J[0] * SJa2, CJa2 + (n_J[2]**2) * (1 - CJa2)]]), (_Ps[7] - center_pos)/LA.norm(_Ps[7] - center_pos))\\n else:\\n e_j = np.dot(np.array([[CJa2 + (n_J[0]**2) * (1 - CJa2), n_J[0] * n_J[1] * (1 - CJa2) - n_J[2] * SJa2, n_J[0] * n_J[2] * (1 - CJa2) + n_J[1] * SJa2],\\\\\\n [n_J[1] * n_J[0] * (1 - CJa2) + n_J[2] * SJa2, CJa2 + (n_J[1]**2) * (1 - CJa2), n_J[1] * n_J[2] * (1 - CJa2) - n_J[0] * SJa2],\\\\\\n [n_J[2] * n_J[0] * (1 - CJa2) - n_J[1] * SJa2, n_J[2] * n_J[1] * (1 - CJa2) + n_J[0] * SJa2, CJa2 + (n_J[2]**2) * (1 - CJa2)]]), (_Ps[7] - center_pos)/LA.norm(_Ps[7] - center_pos))\\n d_etha_J = (2 * sin_Jalfa / l_Jalfa) - (2 * math.sqrt(1 - np.dot(x041,x047)**2/(LA.norm(x041)*LA.norm(x047))**2)/(LA.norm(x041 - x047)))\\n\\n n_i = np.cross(x07,x03)/LA.norm(np.cross(x03,x07)) \\n cos_ialfa = np.dot(x03,x07) / (LA.norm(x03) * LA.norm(x07))\\n sin_ialfa = math.sqrt(1 - cos_ialfa**2)\\n Cia2 = math.sqrt((cos_ialfa + 1)/2)\\n Sia2 = math.sqrt((1 - cos_ialfa)/2)\\n ziC = (_Ps[5][2]-_Ps[3][2])/(_Ps[5][0]-_Ps[3][0]) * (center_pos[0]-_Ps[3][0]) + _Ps[3][2]\\n if center_pos[2] > ziC:\\n e_i = np.dot(np.array([[Cia2 + (n_i[0]**2) * (1 - Cia2), n_i[0] * n_i[1] * (1 - Cia2) + n_i[2] * Sia2, n_i[0] * n_i[2] * (1 - Cia2) - n_i[1] * Sia2],\\\\\\n [n_i[1] * n_i[0] * (1 - Cia2) - n_i[2] * Sia2, Cia2 + (n_i[1]**2) * (1 - Cia2), n_i[1] * n_i[2] * (1 - Cia2) + n_i[0] * Sia2],\\\\\\n [n_i[2] * n_i[0] * (1 - Cia2) + n_i[1] * Sia2, n_i[2] * n_i[1] * (1 - Cia2) - n_i[0] * Sia2, Cia2 + (n_i[2]**2) * (1 - Cia2)]]), (_Ps[7] - center_pos)/LA.norm(_Ps[7] - center_pos))\\n else:\\n e_i = np.dot(np.array([[Cia2 + (n_i[0]**2) * (1 - Cia2), n_i[0] * n_i[1] * (1 - Cia2) - n_i[2] * Sia2, n_i[0] * n_i[2] * (1 - Cia2) + n_i[1] * Sia2],\\\\\\n [n_i[1] * n_i[0] * (1 - Cia2) + n_i[2] * Sia2, Cia2 + (n_i[1]**2) * (1 - Cia2), n_i[1] * n_i[2] * (1 - Cia2) - n_i[0] * Sia2],\\\\\\n [n_i[2] * n_i[0] * (1 - Cia2) - n_i[1] * Sia2, n_i[2] * n_i[1] * (1 - Cia2) + n_i[0] * Sia2, Cia2 + (n_i[2]**2) * (1 - Cia2)]]), (_Ps[5] - center_pos)/LA.norm(_Ps[5] - center_pos))\\n d_etha_i = (2 * sin_ialfa / LA.norm(x07 - x03)) - (2 * math.sqrt(1 - np.dot(x043,x045)**2/(LA.norm(x043)*LA.norm(x045))**2)/(LA.norm(x043 - x045)))\\n\\n\\n l_J = (Lj20 + Lj06 + Lj68 + Lj82) / 4\\n h = (h_iminus + h_iplus + h_Jminus + h_Jplus) / 4\\n I = (l_J * h**3) / 12\\n M_i = (young_modulus * I * (d_etha_i + poisson * d_etha_J)/(1 - poisson**2))\\n M_J = (young_modulus * I * (d_etha_J + poisson * d_etha_i)/(1 - poisson**2))\\n #曲げ力\\n F_Bi = M_i / LA.norm(x03) + M_i / LA.norm(x07) * e_i\\n F_BJ = M_J / LA.norm(x01) + M_J / LA.norm(x05) * e_j\\n #空気力\\n # S = (S_iminus + S_iplus + S_Jminus + S_Jplus) / 4\\n # F_A = p * S\\n F_A = np.array([0.0, 0.0, -0.1]) * _a\\n\\n # 運動方程式（支配方程式）\\n S_0 = (S_iminus0 + S_iplus0 + S_Jminus0 + S_Jplus0) / 4\\n F_T = F_T41 + F_T43 + F_T45 + F_T47\\n F_S = F_S41 + F_S43 + F_S45 + F_S47\\n F_B = F_Bi + F_BJ\\n return (F_T + F_S + F_B + F_A) / (rho * h_0 * S_0) - c * _vs\",\n \"def findSubsetIndices(min_lat,max_lat,min_lon,max_lon,lats,lons):\\n res=np.zeros((4),dtype=np.float64)\\n minLon=min_lon; maxLon=max_lon\\n\\n distances1 = []; distances2 = []\\n indices=[]; index=1\\n\\n for point in lats:\\n s1 = max_lat-point # (vector subtract)\\n s2 = min_lat-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n distances1 = []; distances2 = []; index=1\\n\\n for point in lons:\\n s1 = maxLon-point # (vector subtract)\\n s2 = minLon-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n minJ=indices[1][2]\\n maxJ=indices[0][2]\\n minI=indices[3][2]\\n maxI=indices[2][2]\\n\\n res[0]=minI; res[1]=maxI; res[2]=minJ; res[3]=maxJ\\n return res\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60982597","0.6096606","0.5928866","0.5878671","0.5862804","0.5852861","0.57384753","0.5711407","0.56912196","0.5668883","0.5655643","0.56316304","0.55861735","0.5576225","0.5573143","0.5563656","0.5560922","0.5555036","0.5547608","0.55325174","0.55281603","0.55171657","0.5516207","0.5478087","0.5474469","0.54581535","0.54415643","0.543062","0.5429404","0.5425177","0.5419891","0.54198706","0.5398031","0.5397846","0.5390511","0.53832984","0.5380352","0.53785366","0.53638804","0.53596413","0.53572553","0.53536993","0.53378713","0.53319407","0.5328499","0.5328136","0.5326036","0.5324848","0.5324257","0.53165376","0.5293981","0.5278637","0.52779746","0.52695066","0.5267684","0.5265762","0.526208","0.5259298","0.52577424","0.524781","0.52405286","0.5239216","0.52364236","0.5234949","0.52334297","0.5231333","0.5230561","0.5217625","0.5215844","0.52138925","0.52061105","0.5205662","0.52043104","0.5201963","0.5200004","0.51984555","0.51931953","0.5189005","0.5183911","0.5173909","0.51738536","0.5173031","0.5172515","0.51714724","0.5164081","0.5161983","0.5161983","0.51607823","0.5156468","0.51549184","0.5150606","0.51479226","0.51472294","0.51422495","0.5139925","0.5138278","0.51368934","0.51363045","0.5135037","0.5128967","0.5123523"],"string":"[\n \"0.60982597\",\n \"0.6096606\",\n \"0.5928866\",\n \"0.5878671\",\n \"0.5862804\",\n \"0.5852861\",\n \"0.57384753\",\n \"0.5711407\",\n \"0.56912196\",\n \"0.5668883\",\n \"0.5655643\",\n \"0.56316304\",\n \"0.55861735\",\n \"0.5576225\",\n \"0.5573143\",\n \"0.5563656\",\n \"0.5560922\",\n \"0.5555036\",\n \"0.5547608\",\n \"0.55325174\",\n \"0.55281603\",\n \"0.55171657\",\n \"0.5516207\",\n \"0.5478087\",\n \"0.5474469\",\n \"0.54581535\",\n \"0.54415643\",\n \"0.543062\",\n \"0.5429404\",\n \"0.5425177\",\n \"0.5419891\",\n \"0.54198706\",\n \"0.5398031\",\n \"0.5397846\",\n \"0.5390511\",\n \"0.53832984\",\n \"0.5380352\",\n \"0.53785366\",\n \"0.53638804\",\n \"0.53596413\",\n \"0.53572553\",\n \"0.53536993\",\n \"0.53378713\",\n \"0.53319407\",\n \"0.5328499\",\n \"0.5328136\",\n \"0.5326036\",\n \"0.5324848\",\n \"0.5324257\",\n \"0.53165376\",\n \"0.5293981\",\n \"0.5278637\",\n \"0.52779746\",\n \"0.52695066\",\n \"0.5267684\",\n \"0.5265762\",\n \"0.526208\",\n \"0.5259298\",\n \"0.52577424\",\n \"0.524781\",\n \"0.52405286\",\n \"0.5239216\",\n \"0.52364236\",\n \"0.5234949\",\n \"0.52334297\",\n \"0.5231333\",\n \"0.5230561\",\n \"0.5217625\",\n \"0.5215844\",\n \"0.52138925\",\n \"0.52061105\",\n \"0.5205662\",\n \"0.52043104\",\n \"0.5201963\",\n \"0.5200004\",\n \"0.51984555\",\n \"0.51931953\",\n \"0.5189005\",\n \"0.5183911\",\n \"0.5173909\",\n \"0.51738536\",\n \"0.5173031\",\n \"0.5172515\",\n \"0.51714724\",\n \"0.5164081\",\n \"0.5161983\",\n \"0.5161983\",\n \"0.51607823\",\n \"0.5156468\",\n \"0.51549184\",\n \"0.5150606\",\n \"0.51479226\",\n \"0.51472294\",\n \"0.51422495\",\n \"0.5139925\",\n \"0.5138278\",\n \"0.51368934\",\n \"0.51363045\",\n \"0.5135037\",\n \"0.5128967\",\n \"0.5123523\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94484,"cells":{"query":{"kind":"string","value":"Rotates coordinate system from x1,z1 to x2,z2"},"document":{"kind":"string","value":"def rotation(x1, z1, x2, z2):\n e1 = np.zeros(shape=(3, 3))\n e2 = np.zeros(shape=(3, 3))\n e1[0, :] = x1 / np.linalg.norm(x1)\n e1[2, :] = z1 / np.linalg.norm(z1)\n e1[1, :] = np.cross(e1[2, :], e1[0, :])\n e2[0, :] = x2 / np.linalg.norm(x2)\n e2[2, :] = z2 / np.linalg.norm(z2)\n e2[1, :] = np.cross(e2[2, :], e2[0, :])\n R = np.zeros(shape=(3, 3))\n for i in range(3):\n for j in range(3):\n R[i, j] = np.dot(e1[i, :], e2[j, :])\n R = np.transpose(R)\n return R"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def rotateZ(self, *args, **kwargs):\n ...","def rotation(x,y,z):\r\n phi = np.arctan(z/sqrt(x**2+y**2))\r\n lamb = np.arctan2(y,x)\r\n G = np.array([[-sin(lamb), cos(lamb), 0],\r\n [-sin(phi) * cos(lamb), -sin(phi) * sin(lamb), cos(phi)],\r\n [cos(phi) * cos(lamb), cos(phi) * sin(lamb), sin(phi)]])\r\n return (G)","def xyz_to_zyx(xyz1, xyz2, xyz3):\n\n # Converto gli angoli in ingresso in gradi\n xyz1_r = xyz1 / 180.0 * Kinematic.M_PI\n xyz2_r = xyz2 / 180.0 * Kinematic.M_PI\n xyz3_r = xyz3 / 180.0 * Kinematic.M_PI\n\n # Calcolo l'elemento 3:1 della prima matrice (s1s3 - c1c3s2)\n minus_s2_xyz = (math.sin(xyz1_r) * math.sin(xyz3_r)) - (math.cos(xyz1_r) * math.cos(xyz3_r) * math.sin(xyz2_r))\n\n # Calcolo l'elemento 2:1 della prima matrice (c1s3 + c3s1s2)\n c2s1_xyz = (math.cos(xyz1_r) * math.sin(xyz3_r)) + (math.cos(xyz3_r) * math.sin(xyz1_r) * math.sin(xyz2_r))\n\n # Calcolo l'elemento 2:3 della prima matrice (c3s1 + c1s2s3)\n c2s3_xyz = (math.cos(xyz3_r) * math.sin(xyz1_r)) + (math.cos(xyz1_r)) - (math.sin(xyz2_r) * math.sin(xyz3_r))\n\n # Ora trovo gli angoli\n zyx2_r = math.asin(-minus_s2_xyz)\n c2_xyz = math.cos(zyx2_r)\n zyx1_r = math.asin(c2s1_xyz / c2_xyz)\n zyx3_r = math.asin(c2s3_xyz / c2_xyz)\n zyx3 = zyx3_r / Kinematic.M_PI * 180.0\n zyx2 = zyx2_r / Kinematic.M_PI * 180.0\n zyx1 = zyx1_r / Kinematic.M_PI * 180.0\n\n return [zyx3, zyx2, zyx1, zyx3_r, zyx2_r, zyx1_r]","def rotateZ(self, angle):\r\n if angle:\r\n c = cos(radians(angle))\r\n s = sin(radians(angle))\r\n self.mtrx = dot([[c, s, 0, 0],\r\n [-s, c, 0, 0],\r\n [0, 0, 1, 0],\r\n [0, 0, 0, 1]],\r\n self.mtrx)\r\n self.rtn[2] = angle\r\n self.was_moved = True","def rotateZ(self, angle):\n\t\trad = angle * math.pi / 180\n\t\tcosa = math.cos(rad)\n\t\tsina = math.sin(rad)\n\t\tx = self.x * cosa - self.y * sina\n\t\ty = self.x * sina + self.y * cosa\n\t\treturn Point3D(x, y, self.z)","def rotateZ(self, angle):\r\n rad = angle * math.pi / 180\r\n cosa = math.cos(rad)\r\n sina = math.sin(rad)\r\n x = self.x * cosa - self.y * sina\r\n y = self.x * sina + self.y * cosa\r\n return Point3D(x, y, self.z)","def rotateZ(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def rotateZ(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def rotateZ(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def rotateZ(self, angle):\n rad = angle * math.pi / 180\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def z_rotation(self):\n before = ('R', 'r', 'U', 'u', 'L', 'l', 'D', 'd', 'M', 'E', 'x', 'y')\n after = ('U', 'u', 'L', 'l', 'D', 'd', 'R', 'r', 'E', 'M\\'', \"y\", \"x'\")\n solve = self.solve_helper.maketrans(dict(zip(before, after)))\n solve_trans = self.solve_helper.translate(solve)\n solve_trans = solve_trans.replace(\"\\'\\'\", \"\")\n self.solve_helper = solve_trans","def rotateZ(self, angle):\n rad = math.radians(angle)\n cosa = math.cos(rad)\n sina = math.sin(rad)\n x = self.x * cosa - self.y * sina\n y = self.x * sina + self.y * cosa\n return Point3D(x, y, self.z)","def rotate_3D(atom, source_atom):\n from lauescript.cryst.match import get_transform\n\n lst2 = [np.array([0, 0, 0]), source_atom.orientation[0], source_atom.orientation[1]]\n lst1 = [np.array([0, 0, 0]), atom.orientation[0], atom.orientation[1]]\n\n matrix = get_transform(lst1, lst2, matrix=True)\n\n adp = source_atom.adp['cart_int']\n\n atom.adp['cart_int'] = rotate_adp(adp, matrix)","def rotateAlignXform(self):\n r = np.concatenate(([self.x], [self.y], [self.z]), 0)\n r = np.concatenate((r, np.array([[0,0,0]])), 0)\n r = np.concatenate((r, np.array([0,0,0,1]).reshape(-1,1)), 1)\n return r","def _rotate_xy(self, xyz, angle):\n theta = np.deg2rad(angle)\n x = xyz[:,0].copy()\n y = xyz[:,1].copy()\n xyz[:,0] = x * np.cos(theta) - y * np.sin(theta)\n xyz[:,1] = x * np.sin(theta) + y * np.cos(theta)\n xyz[:,2] = xyz[:,2]\n return xyz","def rotate_z(self, angle):\n angle *= np.pi / 180\n return self.transform(np.matrix([[np.cos(angle), -np.sin(angle), 0],\n [np.sin(angle), np.cos(angle), 0],\n [0, 0, 1]]))","def rotatematrix(m, x, y ,z):\r\n for i in xrange(x):\r\n m = rotatem_x(m)\r\n for i in xrange(y):\r\n m = rotatem_y(m)\r\n for i in xrange(z):\r\n m = rotatem_z(m)\r\n return m","def rotateZ(self, ang):\n if ang != 0.0:\n x = self.getX() * cos(ang) - self.getY() * sin(ang)\n y = self.getX() * sin(ang) + self.getY() * cos(ang)\n z = self.getZ()\n self.setX(x)\n self.setY(y)\n self.setZ(z)","def rotation(self, p1, p2, p3):\n return (p2[0] - p1[0]) * (p3[1] - p1[1]) - (p2[1] - p1[1]) * (p3[0] - p1[0])","def rotate(self, x=0, y=0, z=0):\n\t\tquaternion = R.from_euler('xyz', [x, y, z], degrees=True)\n\t\trotation_matrix = np.array(quaternion.as_matrix())\n\t\trotation_matrix = np.pad(rotation_matrix, [(0, 1), (0, 1)], mode='constant')\n\t\trotation_matrix[3,3] = 1\n\n\t\tself.matrix = np.matmul(self.matrix, rotation_matrix)","def rotate_about_z(self, deg):\n if self.x is None:\n raise AttributeError('rotate_about_z: no X component')\n if self.y is None:\n raise AttributeError('rotate_about_z: no Y component')\n\n sine = sin(radians(deg))\n cosine = cos(radians(deg))\n x_new = self.x*cosine - self.y*sine\n self.y = self.y*cosine + self.x*sine\n self.x = x_new","def rotation(X, Y, C, S) :\n Xrot = X*C + Y*S \n Yrot = Y*C - X*S \n return Xrot, Yrot","def rotateZ(self, point):\n\n rad = self.offset_rotation.z * math.pi / 180\n\n cosa = math.cos(rad)\n sina = math.sin(rad)\n\n x = point.x * cosa - point.y * sina\n y = point.x * sina + point.y * cosa\n\n return OpenMaya.MVector(x, y, point.z)","def getEllipsYZRotMatrix(a1, a2):\n adir = a2 - a1\n amid = a1 + 0.5 * adir\n kath = np.sqrt((adir[0] * adir[0] + adir[1] * adir[1]) / 4.0)\n octantA2 = octant(a2)\n theta = np.arctan( abs( (adir[2]/2) / kath) )\n #[1, 4, 6, 7 ] => left rotation\n #[2, 3, 5, 8 ] => right rotation\n if octantA2 in [2, 3, 5, 8]: \n theta = -theta \n print \"theta =\" , np.rad2deg(theta)\n RotY = np.matrix( [ [ np.cos(theta), 0.0, np.sin(theta) ],\n [ 0.0 , 1.0, 0.0 ],\n [ -np.sin(theta), 0.0, np.cos(theta) ]\n ]) \n \n psi = np.arctan( abs( adir[1] / adir[0] ) )\n #[2, 4, 6, 8 ] => left rotation\n #[1, 3, 5, 7 ] => right rotation\n if octantA2 in [1, 3, 5, 7]:\n psi = -psi\n print \"psi =\" , np.rad2deg(psi)\n RotZ = np.matrix( [ [ np.cos(psi), -np.sin(psi), 0.0 ],\n [ np.sin(psi), np.cos(psi), 0.0 ],\n [ 0.0 , 0.0 , 1.0 ]\n ])\n return np.asarray( RotY * RotZ )","def rotate(self, z_dim=False):\n self.x_displacement = np.format_float_scientific(\n self.length / 2 * np.cos(self.angle * np.pi / 360), precision=1\n )\n self.y_displacement = np.format_float_scientific(\n self.length / 2 * np.sin(self.angle * np.pi / 360), precision=1\n )\n zd = z_dim\n if zd == True:\n self.z_angle = random.uniform(1, 180)\n self.z_displacement = np.format_float_scientific(\n self.length / 2 * np.sin(self.z_angle * np.pi / 360), precision=1\n )\n else:\n self.z_displacement = 0\n self.z_angle = 0\n return [self.x_displacement, self.y_displacement, self.z_displacement]","def rotate3(x, angle_x=0, angle_y=0, angle_z=0, origin=(0, 0, 0)):\n origin = np.asarray(origin)\n x = np.asarray(x) - origin\n r = rotation_matrix3(angle_x, angle_y, angle_z)\n return x.dot(r.T) + origin","def rotate(self, ra1, dec1, ra2, dec2, ra3, dec3):\n # Turns Right Ascension/Declination into Azimuth/Zenith for healpy\n phi1 = ra1 - np.pi\n zen1 = np.pi/2. - dec1\n phi2 = ra2 - np.pi\n zen2 = np.pi/2. - dec2\n phi3 = ra3 - np.pi\n zen3 = np.pi/2. - dec3\n\n # Rotate each ra1 and dec1 towards the pole?\n x = np.array([hp.rotator.rotateDirection(\n hp.rotator.get_rotation_matrix((dp, -dz, 0.))[0], z, p)\n for z, p, dz, dp in zip(zen1, phi1, zen2, phi2)])\n\n # Rotate **all** these vectors towards ra3, dec3 (source_path)\n zen, phi = hp.rotator.rotateDirection(np.dot(\n hp.rotator.get_rotation_matrix((-phi3, 0, 0))[0],\n hp.rotator.get_rotation_matrix((0, zen3, 0.))[0]), x[:, 0], x[:, 1])\n\n dec = np.pi/2. - zen\n ra = phi + np.pi\n return np.atleast_1d(ra), np.atleast_1d(dec)","def coord_rotate_rad(x, y, z):\n #-- 1 --\n xt = math.asin ( math.sin(x) * math.sin(y) +\n math.cos(x) * math.cos(y) * math.cos(z) )\n #-- 2 --\n yt = math.acos ( ( math.sin(x) - math.sin(y) * math.sin(xt) ) /\n ( math.cos(y) * math.cos(xt) ) )\n #-- 3 --\n if math.sin(z) > 0.0:\n yt = TWO_PI - yt\n\n #-- 4 --\n return (xt, yt)","def reverseXZrotation(self):\n rot = np.zeros((3, 3), dtype = 'float64')\n rot[0, 0] = np.cos(self.currtheta)\n rot[0, 1] = -np.sin(self.currtheta)\n rot[0, 2] = 0.0\n rot[1, 0] = np.sin(self.currtheta) * np.cos(self.currphi)\n rot[1, 1] = np.cos(self.currtheta) * np.cos(self.currphi)\n rot[1, 2] = - np.sin(self.currphi)\n rot[2, 0] = np.sin(self.currtheta) * np.sin(self.currphi)\n rot[2, 1] = np.cos(self.currtheta) * np.sin(self.currphi)\n rot[2, 2] = np.cos(self.currphi)\n\n self.ds = np.dot(rot, self.ds1)","def zx_rotation(vector,theta):\r\n R = np.array([[np.cos(theta),0,np.sin(theta)],\r\n [0,1,0],\r\n [-np.sin(theta),0,np.cos(theta)]\r\n ])\r\n return np.dot(R,vector)","def xyz2plane(x,y,z, new_x=[], plane=[], origin=None):\n # preliminary stuff\n if origin != None: x = x - origin\n a,b,c,d = plane\n bottom = np.sqrt(a*a + b*b + c*c) # normalize\n a,b,c,d = a/bottom, b/bottom, c/bottom, d/bottom\n px, py, pz = new_x\n bot = np.sqrt(px*px + py*py + pz*pz) #normalize\n px, py, pz = px/bot, py/bot, pz/bot\n p0 = [px,py,pz]\n # do rotation\n z_hat = [a,b,c]\n y_hat = cross(z_hat, p0)\n x_hat = cross(y_hat, z_hat)\n if type(x)==type(arr) or type(x)==type([]):\n xp, yp, zp = [], [], []\n for i in range(len(x)):\n xp.append(dot([x[i],y[i],z[i]], x_hat))\n yp.append(dot([x[i],y[i],z[i]], y_hat))\n zp.append(dot([x[i],y[i],z[i]], z_hat))\n else:\n xp = dot([x,y,z], x_hat)\n yp = dot([x,y,z], y_hat)\n zp = dot([x,y,z], z_hat)\n return xp, yp, zp","def rotated_coord_transform(lon, lat, np_lon, np_lat,\n direction='rot2geo'):\n\n # Convert degrees to radians\n lon = (lon * math.pi) / 180.\n lat = (lat * math.pi) / 180.\n\n# SP_lon = SP_coor(1)\n# SP_lat = SP_coor(2)\n\n theta = 90. - np_lat # Rotation around y-axis\n phi = np_lon + 180. # Rotation around z-axis\n\n # Convert degrees to radians\n phi = (phi * math.pi) / 180.\n theta = (theta * math.pi) / 180.\n\n # Convert from spherical to cartesian coordinates\n x = math.cos(lon) * math.cos(lat)\n y = math.sin(lon) * math.cos(lat)\n z = math.sin(lat)\n\n # Regular -> Rotated\n if direction == 'geo2rot':\n\n x_new = (math.cos(theta) * math.cos(phi) * x +\n math.cos(theta) * math.sin(phi) * y +\n math.sin(theta) * z)\n y_new = (- math.sin(phi) * x +\n math.cos(phi) * y)\n z_new = (- math.sin(theta) * math.cos(phi) * x -\n math.sin(theta) * math.sin(phi) * y +\n math.cos(theta) * z)\n\n # Rotated -> Regular\n elif direction == 'rot2geo':\n \n phi = - phi\n theta = - theta\n \n x_new = (math.cos(theta) * math.cos(phi) * x +\n math.sin(phi) * y +\n math.sin(theta) * math.cos(phi) * z)\n y_new = (- math.cos(theta) * math.sin(phi) * x +\n math.cos(phi) * y -\n math.sin(theta) * math.sin(phi) * z)\n z_new = (- math.sin(theta) * x +\n math.cos(theta) * z)\n\n # Convert cartesian back to spherical coordinates\n lon_new = math.atan2(y_new, x_new)\n lat_new = math.asin(z_new)\n\n # Convert radians back to degrees\n lon_new = (lon_new * 180.) / math.pi\n lat_new = (lat_new * 180.) / math.pi;\n\n return (lon_new, lat_new)","def rotate_z(angle):\n log.dev(\"lib.mathp.rotate_z is deprecated. Use lib.rotation.R3 instead.\")\n\n cosA = np.cos(angle)\n sinA = np.sin(angle)\n R = np.array([[cosA, sinA, 0], [-sinA, cosA, 0], [0, 0, 1]])\n return R","def rot(wx, wy, order, dist):\n for _ in range(dist//90):\n if order == \"R\":\n wx, wy = wy, -wx\n elif order == \"L\":\n wx, wy = -wy, wx\n return wx, wy","def zyx_r_to_xyz(zyx3_r, zyx2_r, zyx1_r):\n\n # Calcolo l'elemento 1:3 della prima matrice (s1s3 + c1c3s2)\n s2_xyz = (math.sin(zyx1_r) * math.sin(zyx3_r)) + (math.cos(zyx1_r) * math.cos(zyx3_r) * math.sin(zyx2_r))\n\n # Calcolo l'elemento 2:3 della prima matrice (c3s1s2 - c1s3)\n minus_c2s1_xyz = (math.cos(zyx3_r) * math.sin(zyx1_r) * math.sin(zyx2_r)) - \\\n (math.cos(zyx1_r) * math.sin(zyx3_r))\n\n # Calcolo l'elemento 1:2 della prima matrice (c1s2s3 - c3s1)\n minus_c2s3_xyz = (math.cos(zyx1_r) * math.sin(zyx2_r) * math.sin(zyx3_r)) - \\\n (math.cos(zyx3_r) * math.sin(zyx1_r))\n\n # Ora trovo gli angoli\n xyz1_r = math.asin(s2_xyz)\n c2_xyz = math.cos(xyz1_r)\n xyz2_r = math.asin(- minus_c2s1_xyz / c2_xyz)\n xyz3_r = math.asin(- minus_c2s3_xyz / c2_xyz)\n xyz1 = xyz1_r / Kinematic.M_PI * 180.0\n xyz2 = xyz2_r / Kinematic.M_PI * 180.0\n xyz3 = xyz3_r / Kinematic.M_PI * 180.0\n\n return [xyz1, xyz2, xyz3, xyz1_r, xyz2_r, xyz3_r]","def rotate2(x, angle, origin=(0, 0)):\n origin = np.asarray(origin)\n x = np.asarray(x) - origin\n r = rotation_matrix2(angle)\n return x.dot(r.T) + origin","def axisAnglesToRotMat(xrot, yrot, zrot):\n\n xmat = np.eye(3)\n ymat = np.eye(3)\n zmat = np.eye(3)\n\n xmat[1, 1] = np.cos(xrot)\n xmat[1, 2] = -np.sin(xrot)\n xmat[2, 1] = np.sin(xrot)\n xmat[2, 2] = np.cos(xrot)\n\n ymat[0, 0] = np.cos(yrot)\n ymat[0, 2] = np.sin(yrot)\n ymat[2, 0] = -np.sin(yrot)\n ymat[2, 2] = np.cos(yrot)\n\n zmat[0, 0] = np.cos(zrot)\n zmat[0, 1] = -np.sin(zrot)\n zmat[1, 0] = np.sin(zrot)\n zmat[1, 1] = np.cos(zrot)\n\n return concat(zmat, ymat, xmat)","def axisAnglesToRotMat(xrot, yrot, zrot):\n\n xmat = np.eye(3)\n ymat = np.eye(3)\n zmat = np.eye(3)\n\n xmat[1, 1] = np.cos(xrot)\n xmat[1, 2] = -np.sin(xrot)\n xmat[2, 1] = np.sin(xrot)\n xmat[2, 2] = np.cos(xrot)\n\n ymat[0, 0] = np.cos(yrot)\n ymat[0, 2] = np.sin(yrot)\n ymat[2, 0] = -np.sin(yrot)\n ymat[2, 2] = np.cos(yrot)\n\n zmat[0, 0] = np.cos(zrot)\n zmat[0, 1] = -np.sin(zrot)\n zmat[1, 0] = np.sin(zrot)\n zmat[1, 1] = np.cos(zrot)\n\n return concat(zmat, ymat, xmat)","def rotateZ(self, theta):\n rot_m = numpy.array([[numpy.sin(theta), numpy.cos(theta)], \\\n [numpy.cos(theta), -numpy.sin(theta)]])\n for sec in self.all:\n for i in range(int(nrn.n3d())):\n xy = numpy.dot([nrn.x3d(i), nrn.y3d(i)], rot_m)\n nrn.pt3dchange(i, float(xy[0]), float(xy[1]), nrn.z3d(i), \\\n nrn.diam3d(i))","def generate(self):\n inside = self.crystal.is_inside(self.x,self.y,self.z)\n X = np.vstack((self.x[inside],self.y[inside],self.z[inside]))\n return self.rot.rotate(X)","def rot_z(angle):\n sangle = math.sin(angle)\n cangle = math.cos(angle)\n rz = np.array([[cangle, sangle, 0.0],\n [-sangle, cangle, 0.0],\n [0.0, 0.0, 1.0]])\n return rz","def test_rotate_around_v3_z_axis(self):\n from pedemath.vec3 import rotate_around_vector_v3\n\n vec_a = Vec3(3, 4, 5)\n vec_b = Vec3(0, 0, 1)\n\n result = rotate_around_vector_v3(vec_a, math.pi, vec_b)\n expected = Vec3(-3, -4, 5)\n\n self.assertAlmostEqual(result.x, expected.x)\n self.assertAlmostEqual(result.y, expected.y)\n self.assertAlmostEqual(result.z, expected.z)","def convert_coordinate_system_2d(x, z):\n\n return x, -z","def _orient_coordinates(self, coord1: np.ndarray, coord2: np.ndarray) -> np.ndarray:\n rc_settings = self.settings[self.rc_key]\n # Rotate directions towards each other\n r = np.array(rc_settings[\"x_alignment_0\"]).reshape((3, 3))\n coord1 = (r.T.dot(coord1.T)).T\n r = np.array(rc_settings[\"x_alignment_1\"]).reshape((3, 3))\n coord2 = (r.T.dot(coord2.T)).T\n # Rotate around x-axis\n angle = rc_settings[\"x_rotation\"]\n x_rot = np.array(\n [\n [1.0, 0.0, 0.0],\n [0.0, np.cos(angle), -np.sin(angle)],\n [0.0, np.sin(angle), np.cos(angle)],\n ]\n )\n coord2 = x_rot.dot(coord2.T).T\n # Displace coordinates of the molecules along the x-axis\n coord2 += np.array([rc_settings[\"x_spread\"], 0.0, 0.0])\n coord1 -= np.array([rc_settings[\"x_spread\"], 0.0, 0.0])\n return np.concatenate((coord1, coord2), axis=0)","def rotate_points_from_normals(xyz, n0, n1, x0=np.r_[0., 0., 0.]):\n\n R = rotation_matrix_from_normals(n0, n1)\n\n if xyz.shape[1] != 3:\n raise AssertionError(\"Grid xyz should be 3 wide\")\n\n return (xyz - x0)@R.T + x0","def rotz(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, -s, 0],\n [s, c, 0],\n [0, 0, 1]])","def rotz(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, -s, 0],\n [s, c, 0],\n [0, 0, 1]])","def rotz(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, -s, 0],\n [s, c, 0],\n [0, 0, 1]])","def rotz(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, -s, 0],\n [s, c, 0],\n [0, 0, 1]])","def rotz(t):\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]])","def rotateXYZ(self, angle):\n return self.transform(Matrix3(\n Vec3(1, 0, 0),\n Vec3(0, math.cos(angle), -math.sin(angle)),\n Vec3(0, math.sin(angle), math.cos(angle)),\n ) * Matrix3(\n Vec3(math.cos(angle), 0, math.sin(angle)),\n Vec3(0, 1, 0),\n Vec3(-math.sin(angle), 0, math.cos(angle)),\n ) * Matrix3(\n Vec3(math.cos(angle), -math.sin(angle), 0),\n Vec3(math.sin(angle), math.cos(angle), 0),\n Vec3(0, 0, 1),\n ))","def rotate_points(points, rot):\n t0 = time.time()\n points_rot = points.transpose()\n points_rot = rot @ points_rot\n points_rot = points_rot.transpose()\n # print(f\"Rotation Took {(time.time() - t0) * 1000:.1f} ms\")\n return points_rot","def Rotate(X,Y,sintheta=0,costheta=1):\n X1 = X * costheta - Y * sintheta \n Y1 = X * sintheta + Y * costheta \n return X1,Y1","def coord_space(\n a0: numpy.ndarray, a1: numpy.ndarray, a2: numpy.ndarray, rev: bool = False\n) -> Tuple[numpy.ndarray, Optional[numpy.ndarray]]:\n # dbg = False\n # if dbg:\n # print(a0.transpose())\n # print(a1.transpose())\n # print(a2.transpose())\n\n # a0 = acs[0]\n # a1 = acs[1]\n # a2 = acs[2]\n\n global gtm\n global gmry\n global gmrz, gmrz2\n\n tm = gtm\n mry = gmry\n mrz = gmrz\n mrz2 = gmrz2\n\n # tx acs[1] to origin\n # tm = homog_trans_mtx(-a1[0][0], -a1[1][0], -a1[2][0])\n set_homog_trans_mtx(-a1[0], -a1[1], -a1[2], tm)\n\n # directly translate a2 using a1\n p = a2 - a1\n sc = get_spherical_coordinates(p)\n\n # if dbg:\n # print(\"p\", p.transpose())\n # print(\"sc\", sc)\n\n # mrz = homog_rot_mtx(-sc[1], \"z\") # rotate translated a2 -azimuth about Z\n set_Z_homog_rot_mtx(-sc[1], mrz)\n # mry = homog_rot_mtx(-sc[2], \"y\") # rotate translated a2 -polar_angle about Y\n set_Y_homog_rot_mtx(-sc[2], mry)\n\n # mt completes a1-a2 on Z-axis, still need to align a0 with XZ plane\n # mt = mry @ mrz @ tm # python 3.5 and later\n mt = gmry.dot(gmrz.dot(gtm))\n\n # if dbg:\n # print(\"tm:\\n\", tm)\n # print(\"mrz:\\n\", mrz)\n # print(\"mry:\\n\", mry)\n # # print(\"mt \", mt)\n\n p = mt.dot(a0)\n\n # if dbg:\n # print(\"mt:\\n\", mt, \"\\na0:\\n\", a0, \"\\np:\\n\", p)\n\n # need azimuth of translated a0\n # sc2 = get_spherical_coordinates(p)\n # print(sc2)\n azimuth2 = _get_azimuth(p[0], p[1])\n\n # rotate a0 -azimuth2 about Z to align with X\n # mrz2 = homog_rot_mtx(-azimuth2, \"z\")\n set_Z_homog_rot_mtx(-azimuth2, mrz2)\n\n # mt = mrz2 @ mt\n mt = gmrz2.dot(mt)\n\n # if dbg:\n # print(\"mt:\", mt, \"\\na0:\", a0, \"\\np:\", p)\n # # print(p, \"\\n\", azimuth2, \"\\n\", mrz2, \"\\n\", mt)\n\n # if dbg:\n # print(\"mt:\\n\", mt)\n # print(\"<<<<<<==============================\")\n\n if not rev:\n return mt, None\n\n # rev=True, so generate the reverse transformation\n\n # rotate a0 theta about Z, reversing alignment with X\n # mrz2 = homog_rot_mtx(azimuth2, \"z\")\n set_Z_homog_rot_mtx(azimuth2, mrz2)\n # rotate a2 phi about Y\n # mry = homog_rot_mtx(sc[2], \"y\")\n set_Y_homog_rot_mtx(sc[2], mry)\n # rotate a2 theta about Z\n # mrz = homog_rot_mtx(sc[1], \"z\")\n set_Z_homog_rot_mtx(sc[1], mrz)\n # translation matrix origin to a1\n # tm = homog_trans_mtx(a1[0][0], a1[1][0], a1[2][0])\n set_homog_trans_mtx(a1[0], a1[1], a1[2], tm)\n\n # mr = tm @ mrz @ mry @ mrz2\n mr = gtm.dot(gmrz.dot(gmry.dot(gmrz2)))\n # mr = numpy.dot(tm, numpy.dot(mrz, numpy.dot(mry, mrz2)))\n\n return mt, mr","def rotate(xy, theta):\n sin_theta, cos_theta = sin(theta), cos(theta)\n R = np.array([[cos_theta, -sin_theta], [sin_theta, cos_theta]])\n return np.dot(R, xy)","def orient(ps, origin, v1, v2):\r\n \r\n ps = np.vstack((v1, v2, ps))\r\n ps -= origin\r\n if ps[0][1] == 0:\r\n a = 0\r\n else:\r\n a = np.arcsin(np.fabs(ps[0][1]) / np.sqrt(ps[0][1] ** 2 + ps[0][2] ** 2))\r\n if (ps[0][1] < 0 <= ps[0][2]) or (ps[0][1] > 0 > ps[0][2]):\r\n a = 2 * np.pi - a\r\n if (ps[0][1] * np.sin(a) + ps[0][2] * np.cos(a)) < 0:\r\n a = np.pi + a \r\n ps = rotate(a, ps, 0)\r\n if ps[0][0] == 0:\r\n b = 0\r\n else:\r\n b = np.arcsin(np.fabs(ps[0][0]) / np.sqrt(ps[0][0] ** 2 + ps[0][2] ** 2))\r\n if (ps[0][0] < 0 and ps[0][2] < 0) or (ps[0][0] > 0 and ps[0][2] > 0):\r\n b = 2 * np.pi - b\r\n if (ps[0][2] * np.cos(b) - ps[0][0] * np.sin(b)) < 0:\r\n b = np.pi + b\r\n ps = rotate(b, ps, 1)\r\n if ps[1][1] == 0:\r\n c = 0\r\n else:\r\n c = np.arcsin(np.fabs(ps[1][1]) / np.sqrt(ps[1][0]**2 + ps[1][1]**2))\r\n if (ps[1][0] < 0 and ps[1][1] < 0) or (ps[1][0] > 0 and ps[1][1] > 0):\r\n c = 2 * np.pi - c\r\n if (ps[1][0] * np.cos(c) - ps[1][1] * np.sin(c)) < 0:\r\n c = np.pi + c\r\n ps = rotate(c, ps, 2)\r\n return ps[2:]","def rotate_coordinate(x, y, angle, rotc_x, rotc_y):\n rad = math.radians(angle)\n return rotc_x + (x - rotc_x) * math.cos(rad) + (y - rotc_y) * math.sin(rad),\\\n rotc_y - (x - rotc_x) * math.sin(rad) + (y - rotc_y) * math.cos(rad)","def rotation_from_sphere_points_torch(x, y):\n if x.dim() == 1:\n x = x.unsqueeze(-2)\n if y.dim() == 1:\n y = y.unsqueeze(-2)\n\n dim = x.shape[1]\n\n # Compute the inner product\n inner_product = torch.mm(x, y.T)\n # Clamp in case any value is not in the interval [-1,1]\n # A small number is added/substracted to the bounds to avoid NaNs during backward computation.\n inner_product = inner_product.clamp(-1. + 1e-15, 1. - 1e-15)\n\n # Compute intermediate vector\n c_vec = x - y * inner_product\n c_vec = c_vec / torch.norm(c_vec)\n\n R = torch.eye(dim, dim, dtype=inner_product.dtype) + \\\n torch.sin(torch.acos(inner_product)) * (torch.mm(y.T, c_vec) - torch.mm(c_vec.T, y)) + \\\n (inner_product - 1.) * (torch.mm(y.T, y) + torch.mm(c_vec.T, c_vec))\n\n return R","def make_rotation_transform(self, cnt):\n neg = -1 if (cnt&1) else 1 #flip signs on negatives\n rotate = cnt % len(self.dirs) % 3\n\n def transform(vec):\n newvec = [None for _ in range(3)]\n for idx in range(3):\n #print(f'idx:{idx}, modded:{(idx+rotate)%3}')\n newvec[(idx+rotate)%3] = neg*vec[idx]\n newvec = self.coord_cls(system=self,x=newvec[0],y=newvec[1],z=newvec[2])\n # newvec = self.coord_cls(system=self, x=neg*vec[(0+rotate)%3],\n # y=neg*vec[(1+rotate)%3], z=neg*vec[(2+rotate)%3])\n logger.debug(\"Cnt: %s Rot#: %s, Neg: %s, Src Vec: %s, Rotated Vec: %s\",\n cnt, rotate, neg, vec, newvec)\n return newvec\n\n return transform","def RotationMatrix(theta, x, y, z, point=None):\n\treturn mach.rotation_matrix(theta, [x, y, z])","def orientToXYZR( a, b ):\n if allclose(a,b):\n return (0,1,0,0)\n an,bn = normalise( (a,b) )\n angle = arccos(dot(an,bn))\n x,y,z = crossProduct( a, b )[0]\n if allclose( (x,y,z), 0.0):\n y = 1.0\n return (x,y,z,angle)","def apply_rotation_z(self, theta=0.0 ):\n \n theta = radians(theta)\n new_rotation_matrix = [[ +cos(theta) , -sin(theta) , 0 ],\n [ +sin(theta) , +cos(theta) , 0 ],\n [ 0 , 0 , 1 ]] \n \n self.rotation_matrix_exp = np.dot( new_rotation_matrix, self.rotation_matrix_exp )","def matrix_rotate_3d_z(deg: float) -> np.matrix:\n from numpy import cos, sin, pi\n rad_z = -deg * pi/180\n c_z = cos(rad_z)\n s_z = sin(rad_z)\n return np.matrix([[c_z, -s_z, 0], [s_z, c_z, 0], [0, 0, 1]])","def rotate(self,angle):\n radians = (angle * math.pi)/180\n self.direction += angle\n for object in self.objects:\n y = object.position[0]\n x = object.position[1]\n\n object.position[0] = x * math.sin(radians) + y * math.cos(radians)\n object.position[1] = x * math.cos(radians) - y * math.sin(radians)","def _rotate_coords(self, x, y, theta, ox, oy):\n s, c = self._pkgs['numpy'].sin(theta), self._pkgs['numpy'].cos(theta)\n x, y = self._pkgs['numpy'].asarray(x) - ox, self._pkgs['numpy'].asarray(y) - oy\n return x * c - y * s + ox, x * s + y * c + oy","def test_transform_3d(transform, alpha = 1):\r\n points = 20*[None]\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n points[i] = vec3(x, y, z)\r\n tr_x = random.randrange(-40, 41)\r\n tr_y = random.randrange(-40, 41)\r\n tr_z = random.randrange(-40, 41)\r\n mapping = [(p, vec3(p.x + tr_x, p.y + tr_y, p.z + tr_z)) for p in points]\r\n print(\"Translation\")\r\n print(\"Input\".ljust(30), \"Translation\".ljust(30), \"Transformation\".ljust(30))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n v_in = vec3(x, y, z)\r\n v_translate = vec3(x + tr_x, y + tr_y, z + tr_z)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(30), str(v_translate.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\r\n print()\r\n th_x = 2*math.pi*random.random()\r\n th_y = 2*math.pi*random.random()\r\n th_z = 2*math.pi*random.random()\r\n points_rot = [vec3(p.x, p.y*math.cos(th_x) - p.z*math.sin(th_x), p.y*math.sin(th_x) + p.z*math.cos(th_x)) for p in points]\r\n points_rot = [vec3(p.z*math.sin(th_y) + p.x*math.cos(th_y), p.y, p.z*math.cos(th_y) - p.x*math.sin(th_y)) for p in points_rot]\r\n points_rot = [vec3(p.x*math.cos(th_z) - p.y*math.sin(th_z), p.x*math.sin(th_z) + p.y*math.cos(th_z), p.z) for p in points_rot]\r\n mapping = [(points[i], points_rot[i]) for i in range(len(points))]\r\n print(\"Rotation\")\r\n print(\"Input\".ljust(30), \"Rotation\".ljust(30), \"Transformation\".ljust(30))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n v_in = vec3(x, y, z)\r\n v_rotate = vec3(v_in.x, v_in.y*math.cos(th_x) - v_in.z*math.sin(th_x), v_in.y*math.sin(th_x) + v_in.z*math.cos(th_x))\r\n v_rotate = vec3(v_rotate.z*math.sin(th_y) + v_rotate.x*math.cos(th_y), v_rotate.y, v_rotate.z*math.cos(th_y) - v_rotate.x*math.sin(th_y))\r\n v_rotate = vec3(v_rotate.x*math.cos(th_z) - v_rotate.y*math.sin(th_z), v_rotate.x*math.sin(th_z) + v_rotate.y*math.cos(th_z), v_rotate.z)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(30), str(v_rotate.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\r\n print()\r\n k = math.exp(2*random.random() - 1)\r\n mapping = [(p, vec3(k*p.x, k*p.y, k*p.z)) for p in points]\r\n print(\"Uniform scaling\")\r\n print(\"Input\".ljust(30), \"Scaling\".ljust(30), \"Transformation\".ljust(30))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n v_in = vec3(x, y, z)\r\n v_scale = vec3(k*x, k*y, k*z)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(30), str(v_scale.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\r\n print()\r\n k_x = math.exp(2*random.random() - 1)\r\n k_y = 3*random.random() + 1\r\n k_z = 3*random.random() + 1\r\n if (k_x >= k_y + math.exp(-1)): k_y = k_x - k_y\r\n else: k_y = k_x + k_y\r\n if ((k_x + k_y)/2 >= k_z + math.exp(-1)): k_z = (k_x + k_y)/2 - k_z\r\n else: k_z = (k_x + k_y)/2 + k_z\r\n mapping = [(p, vec3(k_x*p.x, k_y*p.y, k_z*p.z)) for p in points]\r\n print(\"Non-uniform scaling\")\r\n print(\"Input\".ljust(30), \"Scaling\".ljust(30), \"Transformation\".ljust(30))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n z = random.randrange(-40, 41)\r\n v_in = vec3(x, y, z)\r\n v_scale = vec3(k_x*x, k_y*y, k_z*z)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(30), str(v_scale.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\r\n print()","def rotate_points(points,quaternions):\n \n res = np.zeros((quaternions.shape[0],points.shape[0],4)) \n res[:,:,1:] = points \n conjugates = conjugate(quaternions) \n \n for ix in range(len(points)):\n res[:,ix,:] = multiply_quaternions(quaternions,res[:,ix,:])\n res[:,ix,:] = multiply_quaternions(res[:,ix,:],conjugates)\n return res[:,:,1:]","def rotate((x, y), theta):\n\n return math.cos(theta) * x + math.sin(theta) * y, -math.sin(theta) * x + math.cos(theta) * y","def get_vtktransform_rotate_global_to_local(v1, v2, v3):\n\n\n x = np.array([1.0, 0.0, 0.0])\n y = np.array([0.0, 1.0, 0.0])\n z = np.array([0.0, 0.0, 1.0])\n\n rot_mat = np.zeros((3, 3), dtype=float)\n rot_mat[0, 0] = np.dot(v1, x)\n rot_mat[0, 1] = np.dot(v1, y)\n rot_mat[0, 2] = np.dot(v1, z)\n rot_mat[1, 0] = np.dot(v2, x)\n rot_mat[1, 1] = np.dot(v2, y)\n rot_mat[1, 2] = np.dot(v2, z)\n rot_mat[2, 0] = np.dot(v3, x)\n rot_mat[2, 1] = np.dot(v3, y)\n rot_mat[2, 2] = np.dot(v3, z)\n\n rot_mat = np.column_stack((rot_mat, np.array([0.0, 0.0, 0.0])))\n rot_mat = np.vstack((rot_mat, np.array([0.0, 0.0, 0.0, 1.0])))\n\n vtkM = vtk.vtkMatrix4x4()\n\n for i in range(4):\n for j in range(4):\n vtkM.SetElement(i, j, rot_mat[i, j])\n\n transform = vtk.vtkTransform()\n transform.PreMultiply()\n transform.SetMatrix(vtkM)\n\n return transform","def rotation_2d(points, angles):\n rot_sin = np.sin(angles)\n rot_cos = np.cos(angles)\n rot_mat_T = np.stack([[rot_cos, -rot_sin], [rot_sin, rot_cos]])\n return np.einsum('aij,jka->aik', points, rot_mat_T)","def convert_coordinate_system_3d(x, y, z):\n\n return x, -z, y","def transform(x, y, Xscale, Yscale, Angle):\r\n global XScale\r\n global YScale\r\n\r\n xScaled = x * Xscale\r\n yScaled = y * Yscale\r\n dist0 = sqrt(pow(xScaled,2) + pow(yScaled,2))\r\n dirXY = atan2(xScaled, yScaled)\r\n rotX = dist0 * cos(dirXY + Angle)\r\n rotY = dist0 * sin(dirXY + Angle)\r\n # x += rotX\r\n # y += rotY\r\n #print '%4f, %4f' %(rotX, rotY)\r\n return (x+rotX, y+rotY)","def rotate(self,X):\n alpha = random.rand() * 2*pi\n beta = self.beta_sample()\n R = Rotator.rotation_matrix(alpha,beta,0.0)\n X = np.dot(R, X)\n if self.random_flip and (random.rand() > 0.5):\n X[2,:] = -X[2,:]\n X[1,:] = -X[1,:]\n return X","def rotate_shape(shape, xy_center, angle_degrees):","def rotate(self, rx: float = 0, ry: float = 0, rz: float = 0,\n center: Onion[Iterable[Onion[float, int]], Point3D] = None) -> 'Component':\n transform = self._local_transform\n\n if center is None:\n center_point = self._origin\n elif isinstance(center, Point3D):\n center_point = center\n elif isinstance(center, Point):\n center_point = center.point\n else:\n center_coordinates = list(center)[0:3]\n while len(center_coordinates) < 3:\n center_coordinates.append(0)\n center_point = Point3D.create(*center_coordinates)\n\n if rx != 0:\n rotation = Matrix3D.create()\n rotation.setToRotation(math.radians(rx), self._pos_x, center_point)\n transform.transformBy(rotation)\n if ry != 0:\n rotation = Matrix3D.create()\n rotation.setToRotation(math.radians(ry), self._pos_y, center_point)\n transform.transformBy(rotation)\n if rz != 0:\n rotation = Matrix3D.create()\n rotation.setToRotation(math.radians(rz), self._pos_z, center_point)\n transform.transformBy(rotation)\n self._reset_cache()\n return self","def Rot_layer(self, w):\n for idx, element in enumerate(w):\n qml.Rot(element[0], element[1], element[2], wires=idx)","def rotation3Dz(theta):\n rmat = np.zeros((3,3))\n rmat[0,0] = rmat[1,1] = np.cos(theta)\n rmat[0,1] = np.sin(theta)\n rmat[1,0] = -rmat[0,1]\n rmat[2,2] = 1\n return rmat","def rotate(self, x_angle, y_angle, z_angle, center=None):\n self._transform(\n Object.generate_rotation_matrix(x_angle, y_angle, z_angle),\n center)","def getOblateXRotMatrix(aStar1, aStar2):\n aStarDir = aStar2 - a1\n aStarmid = aStar1 + 0.5 * aStarDir\n kath = np.sqrt((aStarDir[0] * aStarDir[0] + aStarDir[1] * aStarDir[1]) / 4.0)\n phi = np.arctan( abs( (aStarDir[2]/2) / kath) )\n octantAStar2 = octant(aStar2)\n if octantAStar2 in [1, 2, 7, 8]: #\n phi = -phi\n print \"phi =\" , np.rad2deg(phi)\n RotX = np.matrix( [ [ 1.0, 0.0 , 0.0 ],\n [ 0.0, np.cos(phi), np.sin(phi)],\n [ 0.0, -np.sin(phi), np.cos(phi)]\n ])\n return np.asarray( RotX )","def rotate_z(p, a=0):\n # turn value to radians\n a = math.radians(a)\n translation_mat = np.matrix([\n [math.cos(a),math.sin(a),0,0],\n [-math.sin(a),math.cos(a),0,0],\n [0,0,0,0],\n [0,0,0,1],\n ], dtype=\"float32\")\n\n new_p = p @ translation_mat\n\n return new_p","def ZYZRot(A, B, G, scal=1.0):\n from math import cos\n from math import sin\n from math import radians\n\n rot = np.zeros((3, 3))\n ca = cos(radians(A))\n cb = cos(radians(B))\n cg = cos(radians(G))\n sa = sin(radians(A))\n sb = sin(radians(B))\n sg = sin(radians(G))\n rot[0][0] = ((-sg * sa) + (cb * ca * cg)) * scal\n rot[0][1] = ((sg * ca) + (cb * sa * cg)) * scal\n rot[0][2] = ((-cg * sb)) * scal\n rot[1][0] = ((-cg * sa) - (cb * ca * sg)) * scal\n rot[1][1] = ((cg * ca) - (cb * sa * sg)) * scal\n rot[1][2] = ((sg * sb)) * scal\n rot[2][0] = ((sb * ca)) * scal\n rot[2][1] = ((sb * sa)) * scal\n rot[2][2] = (cb) * scal\n return rot","def rotation(self) -> float:\n xs, ys = self.xcoords.data, self.ycoords.data\n rot = 0\n if xs.ndim == 2:\n ddx1 = xs[0, -1] - xs[0, 0]\n ddy1 = ys[0, -1] - ys[0, 0]\n if not np.isclose(ddx1, 0):\n rot = math.degrees(math.atan(ddy1 / ddx1))\n else:\n rot = -90\n if ddx1 < 0:\n rot = 180 + rot\n elif ddy1 < 0:\n rot = 360 + rot\n return rot","def rotate_about(self, rotation, point):\n\t\tif not isinstance(point,Vector3d):\n\t\t\tpoint = Vector3d(*point)\n\t\treturn (self - point).rotate(rotation) + point","def RotationZ(theta):\n\n return Rotation([0., 0., 1.], theta)","def rotate(points, angle=0):\n # x = np.cos(R) * X - np.sin(R) * Y\n # y = np.sin(R) * X + np.cos(R) * Y\n X = points[0]\n Y = points[1]\n x = np.cos(angle) * X - np.sin(angle) * Y\n y = np.sin(angle) * X + np.cos(angle) * Y\n return [x, y]","def _rotate_about_origin(self, angle, axis):\n matrix = rotation_matrix(angle, axis)\n self._normal = matrix.dot(self._normal)\n self._position = matrix.dot(self._position)","def rotate_SS(x_pos, y_pos, time1, time2):\n # Rotate centroid of SS for given times\n lon, lat = pixels_to_latlon(x_pos, y_pos) # convert to latlon\n\n hgx = astropy.units.Quantity(lon - 90., astropy.units.deg)\n hgy = astropy.units.Quantity(lat - 90., astropy.units.deg)\n\n start_coord = SkyCoord(hgx, hgy, frame=frames.HeliographicStonyhurst, obstime = time1)\n rotated_coord = solar_rotate_coordinate(start_coord, time2)\n\n new_lat = rotated_coord.lat.value + 90.\n new_lon = rotated_coord.lon.value + 90.\n\n new_x, new_y = latlon_to_pixels(new_lon, new_lat)\n\n return new_x, new_y","def test_transform_2d(transform, alpha = 1):\r\n points = 20*[None]\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n points[i] = vec2(x, y)\r\n tr_x = random.randrange(-40, 41)\r\n tr_y = random.randrange(-40, 41)\r\n mapping = [(p, vec2(p.x + tr_x, p.y + tr_y)) for p in points]\r\n print(\"Translation\")\r\n print(\"Input\".ljust(20), \"Translation\".ljust(20), \"Transformation\".ljust(20))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n v_in = vec2(x, y)\r\n v_translate = vec2(x + tr_x, y + tr_y)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(20), str(v_translate.str_repr(4)).ljust(20), str(v_transform.str_repr(4)).ljust(20))\r\n print()\r\n th = 2*math.pi*random.random()\r\n mapping = [(p, vec2(p.x*math.cos(th) - p.y*math.sin(th), p.x*math.sin(th) + p.y*math.cos(th))) for p in points]\r\n print(\"Rotation\")\r\n print(\"Input\".ljust(20), \"Rotation\".ljust(20), \"Transformation\".ljust(20))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n v_in = vec2(x, y)\r\n v_rotate = vec2(x*math.cos(th) - y*math.sin(th), x*math.sin(th) + y*math.cos(th))\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(20), str(v_rotate.str_repr(4)).ljust(20), str(v_transform.str_repr(4)).ljust(20))\r\n print()\r\n k = math.exp(2*random.random() - 1)\r\n mapping = [(p, vec2(k*p.x, k*p.y)) for p in points]\r\n print(\"Uniform scaling\")\r\n print(\"Input\".ljust(20), \"Scaling\".ljust(20), \"Transformation\".ljust(20))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n v_in = vec2(x, y)\r\n v_scale = vec2(k*x, k*y)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(20), str(v_scale.str_repr(4)).ljust(20), str(v_transform.str_repr(4)).ljust(20))\r\n print()\r\n k_x = math.exp(2*random.random() - 1)\r\n k_y = 3*random.random() + 1\r\n if (k_x >= k_y + math.exp(-1)): k_y = k_x - k_y\r\n else: k_y = k_x + k_y\r\n mapping = [(p, vec2(k_x*p.x, k_y*p.y)) for p in points]\r\n print(\"Non-uniform scaling\")\r\n print(\"Input\".ljust(20), \"Scaling\".ljust(20), \"Transformation\".ljust(20))\r\n for i in range(20):\r\n x = random.randrange(-40, 41)\r\n y = random.randrange(-40, 41)\r\n v_in = vec2(x, y)\r\n v_scale = vec2(k_x*x, k_y*y)\r\n v_transform = transform(v_in, mapping, alpha)\r\n print(str(v_in).ljust(20), str(v_scale.str_repr(4)).ljust(20), str(v_transform.str_repr(4)).ljust(20))\r\n print()","def xform_Z_rot( self , thetaZrad ):\r\n self.xform_homog( homogeneous_Z( thetaZrad , [ 0 , 0 , 0 ] ) )","def rotate(X):\n return X","def _rotate_(self, x: np.array, m: np.array) -> (np.array, np.array):\n # get a random angle\n angle = np.random.randint(0, self.rotate)\n # get a random sign for the angle\n sign = np.random.randint(0, 2)\n x = rotate(x, -sign * angle, reshape=False)\n m = rotate(m, -sign * angle, axes=(0, 1),\n mode='nearest',\n reshape=False)\n return x, m","def _rotate(self):\n new_points = list()\n for i in range(len(self._points)):\n x = self._points[i][0]\n y = self._points[i][1]\n new_x = self._center[0] + self._center[1] - y\n new_y = self._center[1] - self._center[0] + x\n new_points.append((new_x, new_y))\n return new_points","def rotate((x,y)):\n orientation = parameter('Orientation',90) # in degrees counter-clockwise\n if orientation == None: orienation = 0\n w,h = image_size()\n if orientation == 0: return (x,y)\n if orientation == -90: return (h-y,x)\n if orientation == 90: return (y,w-x)\n if orientation == 180: return (w-x,h-y)\n return (x,y)","def rotate(points, q):\n # Rotation is achieved by a quaternion sandwich: q * p * (q^-1)\n # This implementation computes the two quaternion products one after the other\n res = np.zeros((len(points), 4))\n # q*p\n res[:, 0] = -np.sum(q[1:]*points, axis=1)\n res[:, 1:] = q[0]*points + np.cross(q[1:], points)\n # (q*p) * q^-1\n res2 = np.zeros((len(points), 4))\n res2[:, 0] = res[:, 0]*q[0] - np.dot(res[:, 1:].copy(), -q[1:].copy())\n res2[:, 1:] = res[:, 0].copy().reshape((-1, 1))*(-q[1:]) + (q[0]*res[:, 1:]) + np.cross(res[:, 1:], -q[1:])\n return res2[:, 1:]","def rotscatx(im, p0, rot=10., sca=1., p1=([0.,0.]), order = 1 ):\n\n # affine discussion based on:\n # http://answerpot.com/showthread.php?3899770-%231736%3A+Proper+order+of+translation+and+rotation+in+scipy.ndimage.affine_transform\n\n # make a rotation matrix\n theta = np.deg2rad(rot)\n rotate = np.identity(2)\n\n rotate[:2,:2] = [np.cos(theta),np.sin(theta)],[-np.sin(theta),np.cos(theta)]\n\n # make a scaling matrix\n scale = np.identity(2)\n scale *= sca\n\n # make affine matrix\n affine = np.dot(scale, rotate)\n\n # affine transform the input centre point\n p0aff = np.dot(affine, p0)\n\n return ndimage.interpolation.affine_transform(im, affine, offset=p0aff-p0+p1, order=order)","def rotate(origin, point, angle): # Library export\r\n ox, oy = origin\r\n px, py = point\r\n\r\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\r\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\r\n return (qx, qy)","def rotate(self, coord):\r\n [x, y] = coord\r\n xrot = x*math.cos(self.heading) - y*math.sin(self.heading)\r\n yrot = x*math.sin(self.heading) + y*math.cos(self.heading)\r\n return [xrot, yrot]","def _rot(axis, angle):\n if axis == 1:\n return Matrix([[1, 0, 0],\n [0, cos(angle), -sin(angle)],\n [0, sin(angle), cos(angle)]])\n elif axis == 2:\n return Matrix([[cos(angle), 0, sin(angle)],\n [0, 1, 0],\n [-sin(angle), 0, cos(angle)]])\n elif axis == 3:\n return Matrix([[cos(angle), -sin(angle), 0],\n [sin(angle), cos(angle), 0],\n [0, 0, 1]])","def turn(self, angle=pi, points=[]):\n for point in points:\n point.rotate(angle, self)","def _rotate_origin(x, y, rotation_deg):\n rotation_rad = np.deg2rad(rotation_deg)\n # Rotation is set negative to make counterclockwise rotation\n xx = x * np.cos(-rotation_rad) + y * np.sin(-rotation_rad)\n yy = -x * np.sin(-rotation_rad) + y * np.cos(-rotation_rad)\n return xx, yy"],"string":"[\n \"def rotateZ(self, *args, **kwargs):\\n ...\",\n \"def rotation(x,y,z):\\r\\n phi = np.arctan(z/sqrt(x**2+y**2))\\r\\n lamb = np.arctan2(y,x)\\r\\n G = np.array([[-sin(lamb), cos(lamb), 0],\\r\\n [-sin(phi) * cos(lamb), -sin(phi) * sin(lamb), cos(phi)],\\r\\n [cos(phi) * cos(lamb), cos(phi) * sin(lamb), sin(phi)]])\\r\\n return (G)\",\n \"def xyz_to_zyx(xyz1, xyz2, xyz3):\\n\\n # Converto gli angoli in ingresso in gradi\\n xyz1_r = xyz1 / 180.0 * Kinematic.M_PI\\n xyz2_r = xyz2 / 180.0 * Kinematic.M_PI\\n xyz3_r = xyz3 / 180.0 * Kinematic.M_PI\\n\\n # Calcolo l'elemento 3:1 della prima matrice (s1s3 - c1c3s2)\\n minus_s2_xyz = (math.sin(xyz1_r) * math.sin(xyz3_r)) - (math.cos(xyz1_r) * math.cos(xyz3_r) * math.sin(xyz2_r))\\n\\n # Calcolo l'elemento 2:1 della prima matrice (c1s3 + c3s1s2)\\n c2s1_xyz = (math.cos(xyz1_r) * math.sin(xyz3_r)) + (math.cos(xyz3_r) * math.sin(xyz1_r) * math.sin(xyz2_r))\\n\\n # Calcolo l'elemento 2:3 della prima matrice (c3s1 + c1s2s3)\\n c2s3_xyz = (math.cos(xyz3_r) * math.sin(xyz1_r)) + (math.cos(xyz1_r)) - (math.sin(xyz2_r) * math.sin(xyz3_r))\\n\\n # Ora trovo gli angoli\\n zyx2_r = math.asin(-minus_s2_xyz)\\n c2_xyz = math.cos(zyx2_r)\\n zyx1_r = math.asin(c2s1_xyz / c2_xyz)\\n zyx3_r = math.asin(c2s3_xyz / c2_xyz)\\n zyx3 = zyx3_r / Kinematic.M_PI * 180.0\\n zyx2 = zyx2_r / Kinematic.M_PI * 180.0\\n zyx1 = zyx1_r / Kinematic.M_PI * 180.0\\n\\n return [zyx3, zyx2, zyx1, zyx3_r, zyx2_r, zyx1_r]\",\n \"def rotateZ(self, angle):\\r\\n if angle:\\r\\n c = cos(radians(angle))\\r\\n s = sin(radians(angle))\\r\\n self.mtrx = dot([[c, s, 0, 0],\\r\\n [-s, c, 0, 0],\\r\\n [0, 0, 1, 0],\\r\\n [0, 0, 0, 1]],\\r\\n self.mtrx)\\r\\n self.rtn[2] = angle\\r\\n self.was_moved = True\",\n \"def rotateZ(self, angle):\\n\\t\\trad = angle * math.pi / 180\\n\\t\\tcosa = math.cos(rad)\\n\\t\\tsina = math.sin(rad)\\n\\t\\tx = self.x * cosa - self.y * sina\\n\\t\\ty = self.x * sina + self.y * cosa\\n\\t\\treturn Point3D(x, y, self.z)\",\n \"def rotateZ(self, angle):\\r\\n rad = angle * math.pi / 180\\r\\n cosa = math.cos(rad)\\r\\n sina = math.sin(rad)\\r\\n x = self.x * cosa - self.y * sina\\r\\n y = self.x * sina + self.y * cosa\\r\\n return Point3D(x, y, self.z)\",\n \"def rotateZ(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def rotateZ(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def rotateZ(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def rotateZ(self, angle):\\n rad = angle * math.pi / 180\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def z_rotation(self):\\n before = ('R', 'r', 'U', 'u', 'L', 'l', 'D', 'd', 'M', 'E', 'x', 'y')\\n after = ('U', 'u', 'L', 'l', 'D', 'd', 'R', 'r', 'E', 'M\\\\'', \\\"y\\\", \\\"x'\\\")\\n solve = self.solve_helper.maketrans(dict(zip(before, after)))\\n solve_trans = self.solve_helper.translate(solve)\\n solve_trans = solve_trans.replace(\\\"\\\\'\\\\'\\\", \\\"\\\")\\n self.solve_helper = solve_trans\",\n \"def rotateZ(self, angle):\\n rad = math.radians(angle)\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n x = self.x * cosa - self.y * sina\\n y = self.x * sina + self.y * cosa\\n return Point3D(x, y, self.z)\",\n \"def rotate_3D(atom, source_atom):\\n from lauescript.cryst.match import get_transform\\n\\n lst2 = [np.array([0, 0, 0]), source_atom.orientation[0], source_atom.orientation[1]]\\n lst1 = [np.array([0, 0, 0]), atom.orientation[0], atom.orientation[1]]\\n\\n matrix = get_transform(lst1, lst2, matrix=True)\\n\\n adp = source_atom.adp['cart_int']\\n\\n atom.adp['cart_int'] = rotate_adp(adp, matrix)\",\n \"def rotateAlignXform(self):\\n r = np.concatenate(([self.x], [self.y], [self.z]), 0)\\n r = np.concatenate((r, np.array([[0,0,0]])), 0)\\n r = np.concatenate((r, np.array([0,0,0,1]).reshape(-1,1)), 1)\\n return r\",\n \"def _rotate_xy(self, xyz, angle):\\n theta = np.deg2rad(angle)\\n x = xyz[:,0].copy()\\n y = xyz[:,1].copy()\\n xyz[:,0] = x * np.cos(theta) - y * np.sin(theta)\\n xyz[:,1] = x * np.sin(theta) + y * np.cos(theta)\\n xyz[:,2] = xyz[:,2]\\n return xyz\",\n \"def rotate_z(self, angle):\\n angle *= np.pi / 180\\n return self.transform(np.matrix([[np.cos(angle), -np.sin(angle), 0],\\n [np.sin(angle), np.cos(angle), 0],\\n [0, 0, 1]]))\",\n \"def rotatematrix(m, x, y ,z):\\r\\n for i in xrange(x):\\r\\n m = rotatem_x(m)\\r\\n for i in xrange(y):\\r\\n m = rotatem_y(m)\\r\\n for i in xrange(z):\\r\\n m = rotatem_z(m)\\r\\n return m\",\n \"def rotateZ(self, ang):\\n if ang != 0.0:\\n x = self.getX() * cos(ang) - self.getY() * sin(ang)\\n y = self.getX() * sin(ang) + self.getY() * cos(ang)\\n z = self.getZ()\\n self.setX(x)\\n self.setY(y)\\n self.setZ(z)\",\n \"def rotation(self, p1, p2, p3):\\n return (p2[0] - p1[0]) * (p3[1] - p1[1]) - (p2[1] - p1[1]) * (p3[0] - p1[0])\",\n \"def rotate(self, x=0, y=0, z=0):\\n\\t\\tquaternion = R.from_euler('xyz', [x, y, z], degrees=True)\\n\\t\\trotation_matrix = np.array(quaternion.as_matrix())\\n\\t\\trotation_matrix = np.pad(rotation_matrix, [(0, 1), (0, 1)], mode='constant')\\n\\t\\trotation_matrix[3,3] = 1\\n\\n\\t\\tself.matrix = np.matmul(self.matrix, rotation_matrix)\",\n \"def rotate_about_z(self, deg):\\n if self.x is None:\\n raise AttributeError('rotate_about_z: no X component')\\n if self.y is None:\\n raise AttributeError('rotate_about_z: no Y component')\\n\\n sine = sin(radians(deg))\\n cosine = cos(radians(deg))\\n x_new = self.x*cosine - self.y*sine\\n self.y = self.y*cosine + self.x*sine\\n self.x = x_new\",\n \"def rotation(X, Y, C, S) :\\n Xrot = X*C + Y*S \\n Yrot = Y*C - X*S \\n return Xrot, Yrot\",\n \"def rotateZ(self, point):\\n\\n rad = self.offset_rotation.z * math.pi / 180\\n\\n cosa = math.cos(rad)\\n sina = math.sin(rad)\\n\\n x = point.x * cosa - point.y * sina\\n y = point.x * sina + point.y * cosa\\n\\n return OpenMaya.MVector(x, y, point.z)\",\n \"def getEllipsYZRotMatrix(a1, a2):\\n adir = a2 - a1\\n amid = a1 + 0.5 * adir\\n kath = np.sqrt((adir[0] * adir[0] + adir[1] * adir[1]) / 4.0)\\n octantA2 = octant(a2)\\n theta = np.arctan( abs( (adir[2]/2) / kath) )\\n #[1, 4, 6, 7 ] => left rotation\\n #[2, 3, 5, 8 ] => right rotation\\n if octantA2 in [2, 3, 5, 8]: \\n theta = -theta \\n print \\\"theta =\\\" , np.rad2deg(theta)\\n RotY = np.matrix( [ [ np.cos(theta), 0.0, np.sin(theta) ],\\n [ 0.0 , 1.0, 0.0 ],\\n [ -np.sin(theta), 0.0, np.cos(theta) ]\\n ]) \\n \\n psi = np.arctan( abs( adir[1] / adir[0] ) )\\n #[2, 4, 6, 8 ] => left rotation\\n #[1, 3, 5, 7 ] => right rotation\\n if octantA2 in [1, 3, 5, 7]:\\n psi = -psi\\n print \\\"psi =\\\" , np.rad2deg(psi)\\n RotZ = np.matrix( [ [ np.cos(psi), -np.sin(psi), 0.0 ],\\n [ np.sin(psi), np.cos(psi), 0.0 ],\\n [ 0.0 , 0.0 , 1.0 ]\\n ])\\n return np.asarray( RotY * RotZ )\",\n \"def rotate(self, z_dim=False):\\n self.x_displacement = np.format_float_scientific(\\n self.length / 2 * np.cos(self.angle * np.pi / 360), precision=1\\n )\\n self.y_displacement = np.format_float_scientific(\\n self.length / 2 * np.sin(self.angle * np.pi / 360), precision=1\\n )\\n zd = z_dim\\n if zd == True:\\n self.z_angle = random.uniform(1, 180)\\n self.z_displacement = np.format_float_scientific(\\n self.length / 2 * np.sin(self.z_angle * np.pi / 360), precision=1\\n )\\n else:\\n self.z_displacement = 0\\n self.z_angle = 0\\n return [self.x_displacement, self.y_displacement, self.z_displacement]\",\n \"def rotate3(x, angle_x=0, angle_y=0, angle_z=0, origin=(0, 0, 0)):\\n origin = np.asarray(origin)\\n x = np.asarray(x) - origin\\n r = rotation_matrix3(angle_x, angle_y, angle_z)\\n return x.dot(r.T) + origin\",\n \"def rotate(self, ra1, dec1, ra2, dec2, ra3, dec3):\\n # Turns Right Ascension/Declination into Azimuth/Zenith for healpy\\n phi1 = ra1 - np.pi\\n zen1 = np.pi/2. - dec1\\n phi2 = ra2 - np.pi\\n zen2 = np.pi/2. - dec2\\n phi3 = ra3 - np.pi\\n zen3 = np.pi/2. - dec3\\n\\n # Rotate each ra1 and dec1 towards the pole?\\n x = np.array([hp.rotator.rotateDirection(\\n hp.rotator.get_rotation_matrix((dp, -dz, 0.))[0], z, p)\\n for z, p, dz, dp in zip(zen1, phi1, zen2, phi2)])\\n\\n # Rotate **all** these vectors towards ra3, dec3 (source_path)\\n zen, phi = hp.rotator.rotateDirection(np.dot(\\n hp.rotator.get_rotation_matrix((-phi3, 0, 0))[0],\\n hp.rotator.get_rotation_matrix((0, zen3, 0.))[0]), x[:, 0], x[:, 1])\\n\\n dec = np.pi/2. - zen\\n ra = phi + np.pi\\n return np.atleast_1d(ra), np.atleast_1d(dec)\",\n \"def coord_rotate_rad(x, y, z):\\n #-- 1 --\\n xt = math.asin ( math.sin(x) * math.sin(y) +\\n math.cos(x) * math.cos(y) * math.cos(z) )\\n #-- 2 --\\n yt = math.acos ( ( math.sin(x) - math.sin(y) * math.sin(xt) ) /\\n ( math.cos(y) * math.cos(xt) ) )\\n #-- 3 --\\n if math.sin(z) > 0.0:\\n yt = TWO_PI - yt\\n\\n #-- 4 --\\n return (xt, yt)\",\n \"def reverseXZrotation(self):\\n rot = np.zeros((3, 3), dtype = 'float64')\\n rot[0, 0] = np.cos(self.currtheta)\\n rot[0, 1] = -np.sin(self.currtheta)\\n rot[0, 2] = 0.0\\n rot[1, 0] = np.sin(self.currtheta) * np.cos(self.currphi)\\n rot[1, 1] = np.cos(self.currtheta) * np.cos(self.currphi)\\n rot[1, 2] = - np.sin(self.currphi)\\n rot[2, 0] = np.sin(self.currtheta) * np.sin(self.currphi)\\n rot[2, 1] = np.cos(self.currtheta) * np.sin(self.currphi)\\n rot[2, 2] = np.cos(self.currphi)\\n\\n self.ds = np.dot(rot, self.ds1)\",\n \"def zx_rotation(vector,theta):\\r\\n R = np.array([[np.cos(theta),0,np.sin(theta)],\\r\\n [0,1,0],\\r\\n [-np.sin(theta),0,np.cos(theta)]\\r\\n ])\\r\\n return np.dot(R,vector)\",\n \"def xyz2plane(x,y,z, new_x=[], plane=[], origin=None):\\n # preliminary stuff\\n if origin != None: x = x - origin\\n a,b,c,d = plane\\n bottom = np.sqrt(a*a + b*b + c*c) # normalize\\n a,b,c,d = a/bottom, b/bottom, c/bottom, d/bottom\\n px, py, pz = new_x\\n bot = np.sqrt(px*px + py*py + pz*pz) #normalize\\n px, py, pz = px/bot, py/bot, pz/bot\\n p0 = [px,py,pz]\\n # do rotation\\n z_hat = [a,b,c]\\n y_hat = cross(z_hat, p0)\\n x_hat = cross(y_hat, z_hat)\\n if type(x)==type(arr) or type(x)==type([]):\\n xp, yp, zp = [], [], []\\n for i in range(len(x)):\\n xp.append(dot([x[i],y[i],z[i]], x_hat))\\n yp.append(dot([x[i],y[i],z[i]], y_hat))\\n zp.append(dot([x[i],y[i],z[i]], z_hat))\\n else:\\n xp = dot([x,y,z], x_hat)\\n yp = dot([x,y,z], y_hat)\\n zp = dot([x,y,z], z_hat)\\n return xp, yp, zp\",\n \"def rotated_coord_transform(lon, lat, np_lon, np_lat,\\n direction='rot2geo'):\\n\\n # Convert degrees to radians\\n lon = (lon * math.pi) / 180.\\n lat = (lat * math.pi) / 180.\\n\\n# SP_lon = SP_coor(1)\\n# SP_lat = SP_coor(2)\\n\\n theta = 90. - np_lat # Rotation around y-axis\\n phi = np_lon + 180. # Rotation around z-axis\\n\\n # Convert degrees to radians\\n phi = (phi * math.pi) / 180.\\n theta = (theta * math.pi) / 180.\\n\\n # Convert from spherical to cartesian coordinates\\n x = math.cos(lon) * math.cos(lat)\\n y = math.sin(lon) * math.cos(lat)\\n z = math.sin(lat)\\n\\n # Regular -> Rotated\\n if direction == 'geo2rot':\\n\\n x_new = (math.cos(theta) * math.cos(phi) * x +\\n math.cos(theta) * math.sin(phi) * y +\\n math.sin(theta) * z)\\n y_new = (- math.sin(phi) * x +\\n math.cos(phi) * y)\\n z_new = (- math.sin(theta) * math.cos(phi) * x -\\n math.sin(theta) * math.sin(phi) * y +\\n math.cos(theta) * z)\\n\\n # Rotated -> Regular\\n elif direction == 'rot2geo':\\n \\n phi = - phi\\n theta = - theta\\n \\n x_new = (math.cos(theta) * math.cos(phi) * x +\\n math.sin(phi) * y +\\n math.sin(theta) * math.cos(phi) * z)\\n y_new = (- math.cos(theta) * math.sin(phi) * x +\\n math.cos(phi) * y -\\n math.sin(theta) * math.sin(phi) * z)\\n z_new = (- math.sin(theta) * x +\\n math.cos(theta) * z)\\n\\n # Convert cartesian back to spherical coordinates\\n lon_new = math.atan2(y_new, x_new)\\n lat_new = math.asin(z_new)\\n\\n # Convert radians back to degrees\\n lon_new = (lon_new * 180.) / math.pi\\n lat_new = (lat_new * 180.) / math.pi;\\n\\n return (lon_new, lat_new)\",\n \"def rotate_z(angle):\\n log.dev(\\\"lib.mathp.rotate_z is deprecated. Use lib.rotation.R3 instead.\\\")\\n\\n cosA = np.cos(angle)\\n sinA = np.sin(angle)\\n R = np.array([[cosA, sinA, 0], [-sinA, cosA, 0], [0, 0, 1]])\\n return R\",\n \"def rot(wx, wy, order, dist):\\n for _ in range(dist//90):\\n if order == \\\"R\\\":\\n wx, wy = wy, -wx\\n elif order == \\\"L\\\":\\n wx, wy = -wy, wx\\n return wx, wy\",\n \"def zyx_r_to_xyz(zyx3_r, zyx2_r, zyx1_r):\\n\\n # Calcolo l'elemento 1:3 della prima matrice (s1s3 + c1c3s2)\\n s2_xyz = (math.sin(zyx1_r) * math.sin(zyx3_r)) + (math.cos(zyx1_r) * math.cos(zyx3_r) * math.sin(zyx2_r))\\n\\n # Calcolo l'elemento 2:3 della prima matrice (c3s1s2 - c1s3)\\n minus_c2s1_xyz = (math.cos(zyx3_r) * math.sin(zyx1_r) * math.sin(zyx2_r)) - \\\\\\n (math.cos(zyx1_r) * math.sin(zyx3_r))\\n\\n # Calcolo l'elemento 1:2 della prima matrice (c1s2s3 - c3s1)\\n minus_c2s3_xyz = (math.cos(zyx1_r) * math.sin(zyx2_r) * math.sin(zyx3_r)) - \\\\\\n (math.cos(zyx3_r) * math.sin(zyx1_r))\\n\\n # Ora trovo gli angoli\\n xyz1_r = math.asin(s2_xyz)\\n c2_xyz = math.cos(xyz1_r)\\n xyz2_r = math.asin(- minus_c2s1_xyz / c2_xyz)\\n xyz3_r = math.asin(- minus_c2s3_xyz / c2_xyz)\\n xyz1 = xyz1_r / Kinematic.M_PI * 180.0\\n xyz2 = xyz2_r / Kinematic.M_PI * 180.0\\n xyz3 = xyz3_r / Kinematic.M_PI * 180.0\\n\\n return [xyz1, xyz2, xyz3, xyz1_r, xyz2_r, xyz3_r]\",\n \"def rotate2(x, angle, origin=(0, 0)):\\n origin = np.asarray(origin)\\n x = np.asarray(x) - origin\\n r = rotation_matrix2(angle)\\n return x.dot(r.T) + origin\",\n \"def axisAnglesToRotMat(xrot, yrot, zrot):\\n\\n xmat = np.eye(3)\\n ymat = np.eye(3)\\n zmat = np.eye(3)\\n\\n xmat[1, 1] = np.cos(xrot)\\n xmat[1, 2] = -np.sin(xrot)\\n xmat[2, 1] = np.sin(xrot)\\n xmat[2, 2] = np.cos(xrot)\\n\\n ymat[0, 0] = np.cos(yrot)\\n ymat[0, 2] = np.sin(yrot)\\n ymat[2, 0] = -np.sin(yrot)\\n ymat[2, 2] = np.cos(yrot)\\n\\n zmat[0, 0] = np.cos(zrot)\\n zmat[0, 1] = -np.sin(zrot)\\n zmat[1, 0] = np.sin(zrot)\\n zmat[1, 1] = np.cos(zrot)\\n\\n return concat(zmat, ymat, xmat)\",\n \"def axisAnglesToRotMat(xrot, yrot, zrot):\\n\\n xmat = np.eye(3)\\n ymat = np.eye(3)\\n zmat = np.eye(3)\\n\\n xmat[1, 1] = np.cos(xrot)\\n xmat[1, 2] = -np.sin(xrot)\\n xmat[2, 1] = np.sin(xrot)\\n xmat[2, 2] = np.cos(xrot)\\n\\n ymat[0, 0] = np.cos(yrot)\\n ymat[0, 2] = np.sin(yrot)\\n ymat[2, 0] = -np.sin(yrot)\\n ymat[2, 2] = np.cos(yrot)\\n\\n zmat[0, 0] = np.cos(zrot)\\n zmat[0, 1] = -np.sin(zrot)\\n zmat[1, 0] = np.sin(zrot)\\n zmat[1, 1] = np.cos(zrot)\\n\\n return concat(zmat, ymat, xmat)\",\n \"def rotateZ(self, theta):\\n rot_m = numpy.array([[numpy.sin(theta), numpy.cos(theta)], \\\\\\n [numpy.cos(theta), -numpy.sin(theta)]])\\n for sec in self.all:\\n for i in range(int(nrn.n3d())):\\n xy = numpy.dot([nrn.x3d(i), nrn.y3d(i)], rot_m)\\n nrn.pt3dchange(i, float(xy[0]), float(xy[1]), nrn.z3d(i), \\\\\\n nrn.diam3d(i))\",\n \"def generate(self):\\n inside = self.crystal.is_inside(self.x,self.y,self.z)\\n X = np.vstack((self.x[inside],self.y[inside],self.z[inside]))\\n return self.rot.rotate(X)\",\n \"def rot_z(angle):\\n sangle = math.sin(angle)\\n cangle = math.cos(angle)\\n rz = np.array([[cangle, sangle, 0.0],\\n [-sangle, cangle, 0.0],\\n [0.0, 0.0, 1.0]])\\n return rz\",\n \"def test_rotate_around_v3_z_axis(self):\\n from pedemath.vec3 import rotate_around_vector_v3\\n\\n vec_a = Vec3(3, 4, 5)\\n vec_b = Vec3(0, 0, 1)\\n\\n result = rotate_around_vector_v3(vec_a, math.pi, vec_b)\\n expected = Vec3(-3, -4, 5)\\n\\n self.assertAlmostEqual(result.x, expected.x)\\n self.assertAlmostEqual(result.y, expected.y)\\n self.assertAlmostEqual(result.z, expected.z)\",\n \"def convert_coordinate_system_2d(x, z):\\n\\n return x, -z\",\n \"def _orient_coordinates(self, coord1: np.ndarray, coord2: np.ndarray) -> np.ndarray:\\n rc_settings = self.settings[self.rc_key]\\n # Rotate directions towards each other\\n r = np.array(rc_settings[\\\"x_alignment_0\\\"]).reshape((3, 3))\\n coord1 = (r.T.dot(coord1.T)).T\\n r = np.array(rc_settings[\\\"x_alignment_1\\\"]).reshape((3, 3))\\n coord2 = (r.T.dot(coord2.T)).T\\n # Rotate around x-axis\\n angle = rc_settings[\\\"x_rotation\\\"]\\n x_rot = np.array(\\n [\\n [1.0, 0.0, 0.0],\\n [0.0, np.cos(angle), -np.sin(angle)],\\n [0.0, np.sin(angle), np.cos(angle)],\\n ]\\n )\\n coord2 = x_rot.dot(coord2.T).T\\n # Displace coordinates of the molecules along the x-axis\\n coord2 += np.array([rc_settings[\\\"x_spread\\\"], 0.0, 0.0])\\n coord1 -= np.array([rc_settings[\\\"x_spread\\\"], 0.0, 0.0])\\n return np.concatenate((coord1, coord2), axis=0)\",\n \"def rotate_points_from_normals(xyz, n0, n1, x0=np.r_[0., 0., 0.]):\\n\\n R = rotation_matrix_from_normals(n0, n1)\\n\\n if xyz.shape[1] != 3:\\n raise AssertionError(\\\"Grid xyz should be 3 wide\\\")\\n\\n return (xyz - x0)@R.T + x0\",\n \"def rotz(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, -s, 0],\\n [s, c, 0],\\n [0, 0, 1]])\",\n \"def rotz(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, -s, 0],\\n [s, c, 0],\\n [0, 0, 1]])\",\n \"def rotz(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, -s, 0],\\n [s, c, 0],\\n [0, 0, 1]])\",\n \"def rotz(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, -s, 0],\\n [s, c, 0],\\n [0, 0, 1]])\",\n \"def rotz(t):\\n c = np.cos(t)\\n s = np.sin(t)\\n return np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]])\",\n \"def rotateXYZ(self, angle):\\n return self.transform(Matrix3(\\n Vec3(1, 0, 0),\\n Vec3(0, math.cos(angle), -math.sin(angle)),\\n Vec3(0, math.sin(angle), math.cos(angle)),\\n ) * Matrix3(\\n Vec3(math.cos(angle), 0, math.sin(angle)),\\n Vec3(0, 1, 0),\\n Vec3(-math.sin(angle), 0, math.cos(angle)),\\n ) * Matrix3(\\n Vec3(math.cos(angle), -math.sin(angle), 0),\\n Vec3(math.sin(angle), math.cos(angle), 0),\\n Vec3(0, 0, 1),\\n ))\",\n \"def rotate_points(points, rot):\\n t0 = time.time()\\n points_rot = points.transpose()\\n points_rot = rot @ points_rot\\n points_rot = points_rot.transpose()\\n # print(f\\\"Rotation Took {(time.time() - t0) * 1000:.1f} ms\\\")\\n return points_rot\",\n \"def Rotate(X,Y,sintheta=0,costheta=1):\\n X1 = X * costheta - Y * sintheta \\n Y1 = X * sintheta + Y * costheta \\n return X1,Y1\",\n \"def coord_space(\\n a0: numpy.ndarray, a1: numpy.ndarray, a2: numpy.ndarray, rev: bool = False\\n) -> Tuple[numpy.ndarray, Optional[numpy.ndarray]]:\\n # dbg = False\\n # if dbg:\\n # print(a0.transpose())\\n # print(a1.transpose())\\n # print(a2.transpose())\\n\\n # a0 = acs[0]\\n # a1 = acs[1]\\n # a2 = acs[2]\\n\\n global gtm\\n global gmry\\n global gmrz, gmrz2\\n\\n tm = gtm\\n mry = gmry\\n mrz = gmrz\\n mrz2 = gmrz2\\n\\n # tx acs[1] to origin\\n # tm = homog_trans_mtx(-a1[0][0], -a1[1][0], -a1[2][0])\\n set_homog_trans_mtx(-a1[0], -a1[1], -a1[2], tm)\\n\\n # directly translate a2 using a1\\n p = a2 - a1\\n sc = get_spherical_coordinates(p)\\n\\n # if dbg:\\n # print(\\\"p\\\", p.transpose())\\n # print(\\\"sc\\\", sc)\\n\\n # mrz = homog_rot_mtx(-sc[1], \\\"z\\\") # rotate translated a2 -azimuth about Z\\n set_Z_homog_rot_mtx(-sc[1], mrz)\\n # mry = homog_rot_mtx(-sc[2], \\\"y\\\") # rotate translated a2 -polar_angle about Y\\n set_Y_homog_rot_mtx(-sc[2], mry)\\n\\n # mt completes a1-a2 on Z-axis, still need to align a0 with XZ plane\\n # mt = mry @ mrz @ tm # python 3.5 and later\\n mt = gmry.dot(gmrz.dot(gtm))\\n\\n # if dbg:\\n # print(\\\"tm:\\\\n\\\", tm)\\n # print(\\\"mrz:\\\\n\\\", mrz)\\n # print(\\\"mry:\\\\n\\\", mry)\\n # # print(\\\"mt \\\", mt)\\n\\n p = mt.dot(a0)\\n\\n # if dbg:\\n # print(\\\"mt:\\\\n\\\", mt, \\\"\\\\na0:\\\\n\\\", a0, \\\"\\\\np:\\\\n\\\", p)\\n\\n # need azimuth of translated a0\\n # sc2 = get_spherical_coordinates(p)\\n # print(sc2)\\n azimuth2 = _get_azimuth(p[0], p[1])\\n\\n # rotate a0 -azimuth2 about Z to align with X\\n # mrz2 = homog_rot_mtx(-azimuth2, \\\"z\\\")\\n set_Z_homog_rot_mtx(-azimuth2, mrz2)\\n\\n # mt = mrz2 @ mt\\n mt = gmrz2.dot(mt)\\n\\n # if dbg:\\n # print(\\\"mt:\\\", mt, \\\"\\\\na0:\\\", a0, \\\"\\\\np:\\\", p)\\n # # print(p, \\\"\\\\n\\\", azimuth2, \\\"\\\\n\\\", mrz2, \\\"\\\\n\\\", mt)\\n\\n # if dbg:\\n # print(\\\"mt:\\\\n\\\", mt)\\n # print(\\\"<<<<<<==============================\\\")\\n\\n if not rev:\\n return mt, None\\n\\n # rev=True, so generate the reverse transformation\\n\\n # rotate a0 theta about Z, reversing alignment with X\\n # mrz2 = homog_rot_mtx(azimuth2, \\\"z\\\")\\n set_Z_homog_rot_mtx(azimuth2, mrz2)\\n # rotate a2 phi about Y\\n # mry = homog_rot_mtx(sc[2], \\\"y\\\")\\n set_Y_homog_rot_mtx(sc[2], mry)\\n # rotate a2 theta about Z\\n # mrz = homog_rot_mtx(sc[1], \\\"z\\\")\\n set_Z_homog_rot_mtx(sc[1], mrz)\\n # translation matrix origin to a1\\n # tm = homog_trans_mtx(a1[0][0], a1[1][0], a1[2][0])\\n set_homog_trans_mtx(a1[0], a1[1], a1[2], tm)\\n\\n # mr = tm @ mrz @ mry @ mrz2\\n mr = gtm.dot(gmrz.dot(gmry.dot(gmrz2)))\\n # mr = numpy.dot(tm, numpy.dot(mrz, numpy.dot(mry, mrz2)))\\n\\n return mt, mr\",\n \"def rotate(xy, theta):\\n sin_theta, cos_theta = sin(theta), cos(theta)\\n R = np.array([[cos_theta, -sin_theta], [sin_theta, cos_theta]])\\n return np.dot(R, xy)\",\n \"def orient(ps, origin, v1, v2):\\r\\n \\r\\n ps = np.vstack((v1, v2, ps))\\r\\n ps -= origin\\r\\n if ps[0][1] == 0:\\r\\n a = 0\\r\\n else:\\r\\n a = np.arcsin(np.fabs(ps[0][1]) / np.sqrt(ps[0][1] ** 2 + ps[0][2] ** 2))\\r\\n if (ps[0][1] < 0 <= ps[0][2]) or (ps[0][1] > 0 > ps[0][2]):\\r\\n a = 2 * np.pi - a\\r\\n if (ps[0][1] * np.sin(a) + ps[0][2] * np.cos(a)) < 0:\\r\\n a = np.pi + a \\r\\n ps = rotate(a, ps, 0)\\r\\n if ps[0][0] == 0:\\r\\n b = 0\\r\\n else:\\r\\n b = np.arcsin(np.fabs(ps[0][0]) / np.sqrt(ps[0][0] ** 2 + ps[0][2] ** 2))\\r\\n if (ps[0][0] < 0 and ps[0][2] < 0) or (ps[0][0] > 0 and ps[0][2] > 0):\\r\\n b = 2 * np.pi - b\\r\\n if (ps[0][2] * np.cos(b) - ps[0][0] * np.sin(b)) < 0:\\r\\n b = np.pi + b\\r\\n ps = rotate(b, ps, 1)\\r\\n if ps[1][1] == 0:\\r\\n c = 0\\r\\n else:\\r\\n c = np.arcsin(np.fabs(ps[1][1]) / np.sqrt(ps[1][0]**2 + ps[1][1]**2))\\r\\n if (ps[1][0] < 0 and ps[1][1] < 0) or (ps[1][0] > 0 and ps[1][1] > 0):\\r\\n c = 2 * np.pi - c\\r\\n if (ps[1][0] * np.cos(c) - ps[1][1] * np.sin(c)) < 0:\\r\\n c = np.pi + c\\r\\n ps = rotate(c, ps, 2)\\r\\n return ps[2:]\",\n \"def rotate_coordinate(x, y, angle, rotc_x, rotc_y):\\n rad = math.radians(angle)\\n return rotc_x + (x - rotc_x) * math.cos(rad) + (y - rotc_y) * math.sin(rad),\\\\\\n rotc_y - (x - rotc_x) * math.sin(rad) + (y - rotc_y) * math.cos(rad)\",\n \"def rotation_from_sphere_points_torch(x, y):\\n if x.dim() == 1:\\n x = x.unsqueeze(-2)\\n if y.dim() == 1:\\n y = y.unsqueeze(-2)\\n\\n dim = x.shape[1]\\n\\n # Compute the inner product\\n inner_product = torch.mm(x, y.T)\\n # Clamp in case any value is not in the interval [-1,1]\\n # A small number is added/substracted to the bounds to avoid NaNs during backward computation.\\n inner_product = inner_product.clamp(-1. + 1e-15, 1. - 1e-15)\\n\\n # Compute intermediate vector\\n c_vec = x - y * inner_product\\n c_vec = c_vec / torch.norm(c_vec)\\n\\n R = torch.eye(dim, dim, dtype=inner_product.dtype) + \\\\\\n torch.sin(torch.acos(inner_product)) * (torch.mm(y.T, c_vec) - torch.mm(c_vec.T, y)) + \\\\\\n (inner_product - 1.) * (torch.mm(y.T, y) + torch.mm(c_vec.T, c_vec))\\n\\n return R\",\n \"def make_rotation_transform(self, cnt):\\n neg = -1 if (cnt&1) else 1 #flip signs on negatives\\n rotate = cnt % len(self.dirs) % 3\\n\\n def transform(vec):\\n newvec = [None for _ in range(3)]\\n for idx in range(3):\\n #print(f'idx:{idx}, modded:{(idx+rotate)%3}')\\n newvec[(idx+rotate)%3] = neg*vec[idx]\\n newvec = self.coord_cls(system=self,x=newvec[0],y=newvec[1],z=newvec[2])\\n # newvec = self.coord_cls(system=self, x=neg*vec[(0+rotate)%3],\\n # y=neg*vec[(1+rotate)%3], z=neg*vec[(2+rotate)%3])\\n logger.debug(\\\"Cnt: %s Rot#: %s, Neg: %s, Src Vec: %s, Rotated Vec: %s\\\",\\n cnt, rotate, neg, vec, newvec)\\n return newvec\\n\\n return transform\",\n \"def RotationMatrix(theta, x, y, z, point=None):\\n\\treturn mach.rotation_matrix(theta, [x, y, z])\",\n \"def orientToXYZR( a, b ):\\n if allclose(a,b):\\n return (0,1,0,0)\\n an,bn = normalise( (a,b) )\\n angle = arccos(dot(an,bn))\\n x,y,z = crossProduct( a, b )[0]\\n if allclose( (x,y,z), 0.0):\\n y = 1.0\\n return (x,y,z,angle)\",\n \"def apply_rotation_z(self, theta=0.0 ):\\n \\n theta = radians(theta)\\n new_rotation_matrix = [[ +cos(theta) , -sin(theta) , 0 ],\\n [ +sin(theta) , +cos(theta) , 0 ],\\n [ 0 , 0 , 1 ]] \\n \\n self.rotation_matrix_exp = np.dot( new_rotation_matrix, self.rotation_matrix_exp )\",\n \"def matrix_rotate_3d_z(deg: float) -> np.matrix:\\n from numpy import cos, sin, pi\\n rad_z = -deg * pi/180\\n c_z = cos(rad_z)\\n s_z = sin(rad_z)\\n return np.matrix([[c_z, -s_z, 0], [s_z, c_z, 0], [0, 0, 1]])\",\n \"def rotate(self,angle):\\n radians = (angle * math.pi)/180\\n self.direction += angle\\n for object in self.objects:\\n y = object.position[0]\\n x = object.position[1]\\n\\n object.position[0] = x * math.sin(radians) + y * math.cos(radians)\\n object.position[1] = x * math.cos(radians) - y * math.sin(radians)\",\n \"def _rotate_coords(self, x, y, theta, ox, oy):\\n s, c = self._pkgs['numpy'].sin(theta), self._pkgs['numpy'].cos(theta)\\n x, y = self._pkgs['numpy'].asarray(x) - ox, self._pkgs['numpy'].asarray(y) - oy\\n return x * c - y * s + ox, x * s + y * c + oy\",\n \"def test_transform_3d(transform, alpha = 1):\\r\\n points = 20*[None]\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n points[i] = vec3(x, y, z)\\r\\n tr_x = random.randrange(-40, 41)\\r\\n tr_y = random.randrange(-40, 41)\\r\\n tr_z = random.randrange(-40, 41)\\r\\n mapping = [(p, vec3(p.x + tr_x, p.y + tr_y, p.z + tr_z)) for p in points]\\r\\n print(\\\"Translation\\\")\\r\\n print(\\\"Input\\\".ljust(30), \\\"Translation\\\".ljust(30), \\\"Transformation\\\".ljust(30))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n v_in = vec3(x, y, z)\\r\\n v_translate = vec3(x + tr_x, y + tr_y, z + tr_z)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(30), str(v_translate.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\\r\\n print()\\r\\n th_x = 2*math.pi*random.random()\\r\\n th_y = 2*math.pi*random.random()\\r\\n th_z = 2*math.pi*random.random()\\r\\n points_rot = [vec3(p.x, p.y*math.cos(th_x) - p.z*math.sin(th_x), p.y*math.sin(th_x) + p.z*math.cos(th_x)) for p in points]\\r\\n points_rot = [vec3(p.z*math.sin(th_y) + p.x*math.cos(th_y), p.y, p.z*math.cos(th_y) - p.x*math.sin(th_y)) for p in points_rot]\\r\\n points_rot = [vec3(p.x*math.cos(th_z) - p.y*math.sin(th_z), p.x*math.sin(th_z) + p.y*math.cos(th_z), p.z) for p in points_rot]\\r\\n mapping = [(points[i], points_rot[i]) for i in range(len(points))]\\r\\n print(\\\"Rotation\\\")\\r\\n print(\\\"Input\\\".ljust(30), \\\"Rotation\\\".ljust(30), \\\"Transformation\\\".ljust(30))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n v_in = vec3(x, y, z)\\r\\n v_rotate = vec3(v_in.x, v_in.y*math.cos(th_x) - v_in.z*math.sin(th_x), v_in.y*math.sin(th_x) + v_in.z*math.cos(th_x))\\r\\n v_rotate = vec3(v_rotate.z*math.sin(th_y) + v_rotate.x*math.cos(th_y), v_rotate.y, v_rotate.z*math.cos(th_y) - v_rotate.x*math.sin(th_y))\\r\\n v_rotate = vec3(v_rotate.x*math.cos(th_z) - v_rotate.y*math.sin(th_z), v_rotate.x*math.sin(th_z) + v_rotate.y*math.cos(th_z), v_rotate.z)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(30), str(v_rotate.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\\r\\n print()\\r\\n k = math.exp(2*random.random() - 1)\\r\\n mapping = [(p, vec3(k*p.x, k*p.y, k*p.z)) for p in points]\\r\\n print(\\\"Uniform scaling\\\")\\r\\n print(\\\"Input\\\".ljust(30), \\\"Scaling\\\".ljust(30), \\\"Transformation\\\".ljust(30))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n v_in = vec3(x, y, z)\\r\\n v_scale = vec3(k*x, k*y, k*z)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(30), str(v_scale.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\\r\\n print()\\r\\n k_x = math.exp(2*random.random() - 1)\\r\\n k_y = 3*random.random() + 1\\r\\n k_z = 3*random.random() + 1\\r\\n if (k_x >= k_y + math.exp(-1)): k_y = k_x - k_y\\r\\n else: k_y = k_x + k_y\\r\\n if ((k_x + k_y)/2 >= k_z + math.exp(-1)): k_z = (k_x + k_y)/2 - k_z\\r\\n else: k_z = (k_x + k_y)/2 + k_z\\r\\n mapping = [(p, vec3(k_x*p.x, k_y*p.y, k_z*p.z)) for p in points]\\r\\n print(\\\"Non-uniform scaling\\\")\\r\\n print(\\\"Input\\\".ljust(30), \\\"Scaling\\\".ljust(30), \\\"Transformation\\\".ljust(30))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n z = random.randrange(-40, 41)\\r\\n v_in = vec3(x, y, z)\\r\\n v_scale = vec3(k_x*x, k_y*y, k_z*z)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(30), str(v_scale.str_repr(4)).ljust(30), str(v_transform.str_repr(4)).ljust(30))\\r\\n print()\",\n \"def rotate_points(points,quaternions):\\n \\n res = np.zeros((quaternions.shape[0],points.shape[0],4)) \\n res[:,:,1:] = points \\n conjugates = conjugate(quaternions) \\n \\n for ix in range(len(points)):\\n res[:,ix,:] = multiply_quaternions(quaternions,res[:,ix,:])\\n res[:,ix,:] = multiply_quaternions(res[:,ix,:],conjugates)\\n return res[:,:,1:]\",\n \"def rotate((x, y), theta):\\n\\n return math.cos(theta) * x + math.sin(theta) * y, -math.sin(theta) * x + math.cos(theta) * y\",\n \"def get_vtktransform_rotate_global_to_local(v1, v2, v3):\\n\\n\\n x = np.array([1.0, 0.0, 0.0])\\n y = np.array([0.0, 1.0, 0.0])\\n z = np.array([0.0, 0.0, 1.0])\\n\\n rot_mat = np.zeros((3, 3), dtype=float)\\n rot_mat[0, 0] = np.dot(v1, x)\\n rot_mat[0, 1] = np.dot(v1, y)\\n rot_mat[0, 2] = np.dot(v1, z)\\n rot_mat[1, 0] = np.dot(v2, x)\\n rot_mat[1, 1] = np.dot(v2, y)\\n rot_mat[1, 2] = np.dot(v2, z)\\n rot_mat[2, 0] = np.dot(v3, x)\\n rot_mat[2, 1] = np.dot(v3, y)\\n rot_mat[2, 2] = np.dot(v3, z)\\n\\n rot_mat = np.column_stack((rot_mat, np.array([0.0, 0.0, 0.0])))\\n rot_mat = np.vstack((rot_mat, np.array([0.0, 0.0, 0.0, 1.0])))\\n\\n vtkM = vtk.vtkMatrix4x4()\\n\\n for i in range(4):\\n for j in range(4):\\n vtkM.SetElement(i, j, rot_mat[i, j])\\n\\n transform = vtk.vtkTransform()\\n transform.PreMultiply()\\n transform.SetMatrix(vtkM)\\n\\n return transform\",\n \"def rotation_2d(points, angles):\\n rot_sin = np.sin(angles)\\n rot_cos = np.cos(angles)\\n rot_mat_T = np.stack([[rot_cos, -rot_sin], [rot_sin, rot_cos]])\\n return np.einsum('aij,jka->aik', points, rot_mat_T)\",\n \"def convert_coordinate_system_3d(x, y, z):\\n\\n return x, -z, y\",\n \"def transform(x, y, Xscale, Yscale, Angle):\\r\\n global XScale\\r\\n global YScale\\r\\n\\r\\n xScaled = x * Xscale\\r\\n yScaled = y * Yscale\\r\\n dist0 = sqrt(pow(xScaled,2) + pow(yScaled,2))\\r\\n dirXY = atan2(xScaled, yScaled)\\r\\n rotX = dist0 * cos(dirXY + Angle)\\r\\n rotY = dist0 * sin(dirXY + Angle)\\r\\n # x += rotX\\r\\n # y += rotY\\r\\n #print '%4f, %4f' %(rotX, rotY)\\r\\n return (x+rotX, y+rotY)\",\n \"def rotate(self,X):\\n alpha = random.rand() * 2*pi\\n beta = self.beta_sample()\\n R = Rotator.rotation_matrix(alpha,beta,0.0)\\n X = np.dot(R, X)\\n if self.random_flip and (random.rand() > 0.5):\\n X[2,:] = -X[2,:]\\n X[1,:] = -X[1,:]\\n return X\",\n \"def rotate_shape(shape, xy_center, angle_degrees):\",\n \"def rotate(self, rx: float = 0, ry: float = 0, rz: float = 0,\\n center: Onion[Iterable[Onion[float, int]], Point3D] = None) -> 'Component':\\n transform = self._local_transform\\n\\n if center is None:\\n center_point = self._origin\\n elif isinstance(center, Point3D):\\n center_point = center\\n elif isinstance(center, Point):\\n center_point = center.point\\n else:\\n center_coordinates = list(center)[0:3]\\n while len(center_coordinates) < 3:\\n center_coordinates.append(0)\\n center_point = Point3D.create(*center_coordinates)\\n\\n if rx != 0:\\n rotation = Matrix3D.create()\\n rotation.setToRotation(math.radians(rx), self._pos_x, center_point)\\n transform.transformBy(rotation)\\n if ry != 0:\\n rotation = Matrix3D.create()\\n rotation.setToRotation(math.radians(ry), self._pos_y, center_point)\\n transform.transformBy(rotation)\\n if rz != 0:\\n rotation = Matrix3D.create()\\n rotation.setToRotation(math.radians(rz), self._pos_z, center_point)\\n transform.transformBy(rotation)\\n self._reset_cache()\\n return self\",\n \"def Rot_layer(self, w):\\n for idx, element in enumerate(w):\\n qml.Rot(element[0], element[1], element[2], wires=idx)\",\n \"def rotation3Dz(theta):\\n rmat = np.zeros((3,3))\\n rmat[0,0] = rmat[1,1] = np.cos(theta)\\n rmat[0,1] = np.sin(theta)\\n rmat[1,0] = -rmat[0,1]\\n rmat[2,2] = 1\\n return rmat\",\n \"def rotate(self, x_angle, y_angle, z_angle, center=None):\\n self._transform(\\n Object.generate_rotation_matrix(x_angle, y_angle, z_angle),\\n center)\",\n \"def getOblateXRotMatrix(aStar1, aStar2):\\n aStarDir = aStar2 - a1\\n aStarmid = aStar1 + 0.5 * aStarDir\\n kath = np.sqrt((aStarDir[0] * aStarDir[0] + aStarDir[1] * aStarDir[1]) / 4.0)\\n phi = np.arctan( abs( (aStarDir[2]/2) / kath) )\\n octantAStar2 = octant(aStar2)\\n if octantAStar2 in [1, 2, 7, 8]: #\\n phi = -phi\\n print \\\"phi =\\\" , np.rad2deg(phi)\\n RotX = np.matrix( [ [ 1.0, 0.0 , 0.0 ],\\n [ 0.0, np.cos(phi), np.sin(phi)],\\n [ 0.0, -np.sin(phi), np.cos(phi)]\\n ])\\n return np.asarray( RotX )\",\n \"def rotate_z(p, a=0):\\n # turn value to radians\\n a = math.radians(a)\\n translation_mat = np.matrix([\\n [math.cos(a),math.sin(a),0,0],\\n [-math.sin(a),math.cos(a),0,0],\\n [0,0,0,0],\\n [0,0,0,1],\\n ], dtype=\\\"float32\\\")\\n\\n new_p = p @ translation_mat\\n\\n return new_p\",\n \"def ZYZRot(A, B, G, scal=1.0):\\n from math import cos\\n from math import sin\\n from math import radians\\n\\n rot = np.zeros((3, 3))\\n ca = cos(radians(A))\\n cb = cos(radians(B))\\n cg = cos(radians(G))\\n sa = sin(radians(A))\\n sb = sin(radians(B))\\n sg = sin(radians(G))\\n rot[0][0] = ((-sg * sa) + (cb * ca * cg)) * scal\\n rot[0][1] = ((sg * ca) + (cb * sa * cg)) * scal\\n rot[0][2] = ((-cg * sb)) * scal\\n rot[1][0] = ((-cg * sa) - (cb * ca * sg)) * scal\\n rot[1][1] = ((cg * ca) - (cb * sa * sg)) * scal\\n rot[1][2] = ((sg * sb)) * scal\\n rot[2][0] = ((sb * ca)) * scal\\n rot[2][1] = ((sb * sa)) * scal\\n rot[2][2] = (cb) * scal\\n return rot\",\n \"def rotation(self) -> float:\\n xs, ys = self.xcoords.data, self.ycoords.data\\n rot = 0\\n if xs.ndim == 2:\\n ddx1 = xs[0, -1] - xs[0, 0]\\n ddy1 = ys[0, -1] - ys[0, 0]\\n if not np.isclose(ddx1, 0):\\n rot = math.degrees(math.atan(ddy1 / ddx1))\\n else:\\n rot = -90\\n if ddx1 < 0:\\n rot = 180 + rot\\n elif ddy1 < 0:\\n rot = 360 + rot\\n return rot\",\n \"def rotate_about(self, rotation, point):\\n\\t\\tif not isinstance(point,Vector3d):\\n\\t\\t\\tpoint = Vector3d(*point)\\n\\t\\treturn (self - point).rotate(rotation) + point\",\n \"def RotationZ(theta):\\n\\n return Rotation([0., 0., 1.], theta)\",\n \"def rotate(points, angle=0):\\n # x = np.cos(R) * X - np.sin(R) * Y\\n # y = np.sin(R) * X + np.cos(R) * Y\\n X = points[0]\\n Y = points[1]\\n x = np.cos(angle) * X - np.sin(angle) * Y\\n y = np.sin(angle) * X + np.cos(angle) * Y\\n return [x, y]\",\n \"def _rotate_about_origin(self, angle, axis):\\n matrix = rotation_matrix(angle, axis)\\n self._normal = matrix.dot(self._normal)\\n self._position = matrix.dot(self._position)\",\n \"def rotate_SS(x_pos, y_pos, time1, time2):\\n # Rotate centroid of SS for given times\\n lon, lat = pixels_to_latlon(x_pos, y_pos) # convert to latlon\\n\\n hgx = astropy.units.Quantity(lon - 90., astropy.units.deg)\\n hgy = astropy.units.Quantity(lat - 90., astropy.units.deg)\\n\\n start_coord = SkyCoord(hgx, hgy, frame=frames.HeliographicStonyhurst, obstime = time1)\\n rotated_coord = solar_rotate_coordinate(start_coord, time2)\\n\\n new_lat = rotated_coord.lat.value + 90.\\n new_lon = rotated_coord.lon.value + 90.\\n\\n new_x, new_y = latlon_to_pixels(new_lon, new_lat)\\n\\n return new_x, new_y\",\n \"def test_transform_2d(transform, alpha = 1):\\r\\n points = 20*[None]\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n points[i] = vec2(x, y)\\r\\n tr_x = random.randrange(-40, 41)\\r\\n tr_y = random.randrange(-40, 41)\\r\\n mapping = [(p, vec2(p.x + tr_x, p.y + tr_y)) for p in points]\\r\\n print(\\\"Translation\\\")\\r\\n print(\\\"Input\\\".ljust(20), \\\"Translation\\\".ljust(20), \\\"Transformation\\\".ljust(20))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n v_in = vec2(x, y)\\r\\n v_translate = vec2(x + tr_x, y + tr_y)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(20), str(v_translate.str_repr(4)).ljust(20), str(v_transform.str_repr(4)).ljust(20))\\r\\n print()\\r\\n th = 2*math.pi*random.random()\\r\\n mapping = [(p, vec2(p.x*math.cos(th) - p.y*math.sin(th), p.x*math.sin(th) + p.y*math.cos(th))) for p in points]\\r\\n print(\\\"Rotation\\\")\\r\\n print(\\\"Input\\\".ljust(20), \\\"Rotation\\\".ljust(20), \\\"Transformation\\\".ljust(20))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n v_in = vec2(x, y)\\r\\n v_rotate = vec2(x*math.cos(th) - y*math.sin(th), x*math.sin(th) + y*math.cos(th))\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(20), str(v_rotate.str_repr(4)).ljust(20), str(v_transform.str_repr(4)).ljust(20))\\r\\n print()\\r\\n k = math.exp(2*random.random() - 1)\\r\\n mapping = [(p, vec2(k*p.x, k*p.y)) for p in points]\\r\\n print(\\\"Uniform scaling\\\")\\r\\n print(\\\"Input\\\".ljust(20), \\\"Scaling\\\".ljust(20), \\\"Transformation\\\".ljust(20))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n v_in = vec2(x, y)\\r\\n v_scale = vec2(k*x, k*y)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(20), str(v_scale.str_repr(4)).ljust(20), str(v_transform.str_repr(4)).ljust(20))\\r\\n print()\\r\\n k_x = math.exp(2*random.random() - 1)\\r\\n k_y = 3*random.random() + 1\\r\\n if (k_x >= k_y + math.exp(-1)): k_y = k_x - k_y\\r\\n else: k_y = k_x + k_y\\r\\n mapping = [(p, vec2(k_x*p.x, k_y*p.y)) for p in points]\\r\\n print(\\\"Non-uniform scaling\\\")\\r\\n print(\\\"Input\\\".ljust(20), \\\"Scaling\\\".ljust(20), \\\"Transformation\\\".ljust(20))\\r\\n for i in range(20):\\r\\n x = random.randrange(-40, 41)\\r\\n y = random.randrange(-40, 41)\\r\\n v_in = vec2(x, y)\\r\\n v_scale = vec2(k_x*x, k_y*y)\\r\\n v_transform = transform(v_in, mapping, alpha)\\r\\n print(str(v_in).ljust(20), str(v_scale.str_repr(4)).ljust(20), str(v_transform.str_repr(4)).ljust(20))\\r\\n print()\",\n \"def xform_Z_rot( self , thetaZrad ):\\r\\n self.xform_homog( homogeneous_Z( thetaZrad , [ 0 , 0 , 0 ] ) )\",\n \"def rotate(X):\\n return X\",\n \"def _rotate_(self, x: np.array, m: np.array) -> (np.array, np.array):\\n # get a random angle\\n angle = np.random.randint(0, self.rotate)\\n # get a random sign for the angle\\n sign = np.random.randint(0, 2)\\n x = rotate(x, -sign * angle, reshape=False)\\n m = rotate(m, -sign * angle, axes=(0, 1),\\n mode='nearest',\\n reshape=False)\\n return x, m\",\n \"def _rotate(self):\\n new_points = list()\\n for i in range(len(self._points)):\\n x = self._points[i][0]\\n y = self._points[i][1]\\n new_x = self._center[0] + self._center[1] - y\\n new_y = self._center[1] - self._center[0] + x\\n new_points.append((new_x, new_y))\\n return new_points\",\n \"def rotate((x,y)):\\n orientation = parameter('Orientation',90) # in degrees counter-clockwise\\n if orientation == None: orienation = 0\\n w,h = image_size()\\n if orientation == 0: return (x,y)\\n if orientation == -90: return (h-y,x)\\n if orientation == 90: return (y,w-x)\\n if orientation == 180: return (w-x,h-y)\\n return (x,y)\",\n \"def rotate(points, q):\\n # Rotation is achieved by a quaternion sandwich: q * p * (q^-1)\\n # This implementation computes the two quaternion products one after the other\\n res = np.zeros((len(points), 4))\\n # q*p\\n res[:, 0] = -np.sum(q[1:]*points, axis=1)\\n res[:, 1:] = q[0]*points + np.cross(q[1:], points)\\n # (q*p) * q^-1\\n res2 = np.zeros((len(points), 4))\\n res2[:, 0] = res[:, 0]*q[0] - np.dot(res[:, 1:].copy(), -q[1:].copy())\\n res2[:, 1:] = res[:, 0].copy().reshape((-1, 1))*(-q[1:]) + (q[0]*res[:, 1:]) + np.cross(res[:, 1:], -q[1:])\\n return res2[:, 1:]\",\n \"def rotscatx(im, p0, rot=10., sca=1., p1=([0.,0.]), order = 1 ):\\n\\n # affine discussion based on:\\n # http://answerpot.com/showthread.php?3899770-%231736%3A+Proper+order+of+translation+and+rotation+in+scipy.ndimage.affine_transform\\n\\n # make a rotation matrix\\n theta = np.deg2rad(rot)\\n rotate = np.identity(2)\\n\\n rotate[:2,:2] = [np.cos(theta),np.sin(theta)],[-np.sin(theta),np.cos(theta)]\\n\\n # make a scaling matrix\\n scale = np.identity(2)\\n scale *= sca\\n\\n # make affine matrix\\n affine = np.dot(scale, rotate)\\n\\n # affine transform the input centre point\\n p0aff = np.dot(affine, p0)\\n\\n return ndimage.interpolation.affine_transform(im, affine, offset=p0aff-p0+p1, order=order)\",\n \"def rotate(origin, point, angle): # Library export\\r\\n ox, oy = origin\\r\\n px, py = point\\r\\n\\r\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\r\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\r\\n return (qx, qy)\",\n \"def rotate(self, coord):\\r\\n [x, y] = coord\\r\\n xrot = x*math.cos(self.heading) - y*math.sin(self.heading)\\r\\n yrot = x*math.sin(self.heading) + y*math.cos(self.heading)\\r\\n return [xrot, yrot]\",\n \"def _rot(axis, angle):\\n if axis == 1:\\n return Matrix([[1, 0, 0],\\n [0, cos(angle), -sin(angle)],\\n [0, sin(angle), cos(angle)]])\\n elif axis == 2:\\n return Matrix([[cos(angle), 0, sin(angle)],\\n [0, 1, 0],\\n [-sin(angle), 0, cos(angle)]])\\n elif axis == 3:\\n return Matrix([[cos(angle), -sin(angle), 0],\\n [sin(angle), cos(angle), 0],\\n [0, 0, 1]])\",\n \"def turn(self, angle=pi, points=[]):\\n for point in points:\\n point.rotate(angle, self)\",\n \"def _rotate_origin(x, y, rotation_deg):\\n rotation_rad = np.deg2rad(rotation_deg)\\n # Rotation is set negative to make counterclockwise rotation\\n xx = x * np.cos(-rotation_rad) + y * np.sin(-rotation_rad)\\n yy = -x * np.sin(-rotation_rad) + y * np.cos(-rotation_rad)\\n return xx, yy\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72137934","0.6789719","0.66737","0.6606905","0.6600858","0.65760684","0.65532327","0.65532327","0.65532327","0.65532327","0.6507178","0.64992857","0.64870286","0.6475885","0.6472012","0.6458319","0.6445637","0.6438456","0.6432099","0.643071","0.6415745","0.63936764","0.6378334","0.6357315","0.6333337","0.6327351","0.63028276","0.6252775","0.62398326","0.62350905","0.62304157","0.6212601","0.6208406","0.6199241","0.61804044","0.6133457","0.6122813","0.6122813","0.60993534","0.609394","0.60440755","0.6040684","0.60312086","0.6014965","0.600369","0.6003688","0.6003688","0.6003688","0.6003688","0.5998399","0.59899783","0.5967277","0.59567386","0.5936621","0.5916456","0.5895321","0.58930653","0.58928514","0.58878493","0.5885491","0.588351","0.5872881","0.5869865","0.58680475","0.58530927","0.5851159","0.5851138","0.5850591","0.5839208","0.5838016","0.5837326","0.583401","0.58328736","0.58270174","0.58221984","0.58200437","0.5812933","0.5807555","0.5807412","0.5802091","0.57991236","0.5796421","0.5789164","0.5787207","0.5786502","0.57856184","0.57802576","0.5779632","0.5779483","0.5771062","0.57693255","0.5768406","0.57635295","0.57528687","0.5739296","0.5737962","0.57370317","0.5736355","0.5733135","0.5732601"],"string":"[\n \"0.72137934\",\n \"0.6789719\",\n \"0.66737\",\n \"0.6606905\",\n \"0.6600858\",\n \"0.65760684\",\n \"0.65532327\",\n \"0.65532327\",\n \"0.65532327\",\n \"0.65532327\",\n \"0.6507178\",\n \"0.64992857\",\n \"0.64870286\",\n \"0.6475885\",\n \"0.6472012\",\n \"0.6458319\",\n \"0.6445637\",\n \"0.6438456\",\n \"0.6432099\",\n \"0.643071\",\n \"0.6415745\",\n \"0.63936764\",\n \"0.6378334\",\n \"0.6357315\",\n \"0.6333337\",\n \"0.6327351\",\n \"0.63028276\",\n \"0.6252775\",\n \"0.62398326\",\n \"0.62350905\",\n \"0.62304157\",\n \"0.6212601\",\n \"0.6208406\",\n \"0.6199241\",\n \"0.61804044\",\n \"0.6133457\",\n \"0.6122813\",\n \"0.6122813\",\n \"0.60993534\",\n \"0.609394\",\n \"0.60440755\",\n \"0.6040684\",\n \"0.60312086\",\n \"0.6014965\",\n \"0.600369\",\n \"0.6003688\",\n \"0.6003688\",\n \"0.6003688\",\n \"0.6003688\",\n \"0.5998399\",\n \"0.59899783\",\n \"0.5967277\",\n \"0.59567386\",\n \"0.5936621\",\n \"0.5916456\",\n \"0.5895321\",\n \"0.58930653\",\n \"0.58928514\",\n \"0.58878493\",\n \"0.5885491\",\n \"0.588351\",\n \"0.5872881\",\n \"0.5869865\",\n \"0.58680475\",\n \"0.58530927\",\n \"0.5851159\",\n \"0.5851138\",\n \"0.5850591\",\n \"0.5839208\",\n \"0.5838016\",\n \"0.5837326\",\n \"0.583401\",\n \"0.58328736\",\n \"0.58270174\",\n \"0.58221984\",\n \"0.58200437\",\n \"0.5812933\",\n \"0.5807555\",\n \"0.5807412\",\n \"0.5802091\",\n \"0.57991236\",\n \"0.5796421\",\n \"0.5789164\",\n \"0.5787207\",\n \"0.5786502\",\n \"0.57856184\",\n \"0.57802576\",\n \"0.5779632\",\n \"0.5779483\",\n \"0.5771062\",\n \"0.57693255\",\n \"0.5768406\",\n \"0.57635295\",\n \"0.57528687\",\n \"0.5739296\",\n \"0.5737962\",\n \"0.57370317\",\n \"0.5736355\",\n \"0.5733135\",\n \"0.5732601\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77712363"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94485,"cells":{"query":{"kind":"string","value":"Converts strain state to displacements With the convention that ux=f(x,y), uy=f(y,z), uz=f(z,x)"},"document":{"kind":"string","value":"def strain2disp(e, A):\n l = A.shape\n u = np.zeros(shape=l)\n for i in range(l[0]):\n u[i, 0] = e[0, 0] * A[i, 0] + e[0, 1] * A[i, 1]\n u[i, 1] = e[1, 1] * A[i, 1] + e[1, 2] * A[i, 2]\n u[i, 2] = e[2, 2] * A[i, 2] + e[0, 2] * A[i, 0]\n return u"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def reverse_state(self):\n state = np.array(self.get_reverse_state_arr())\n om = utils.build_occupancy_maps(utils.build_humans(state))\n # print(\"OM: \", om.size())\n # We only have a batch of one so just get the first element of\n # transform and rotate\n state = utils.transform_and_rotate(state.reshape((1, -1)))[0]\n # print(\"State: \", state.size())\n return torch.cat((state, om), dim=1).unsqueeze(0)","def to_se3(self, state: Vector) -> RigidTransform:\n return (state[:9],state[9:])","def to_se3(self, state: Vector) -> RigidTransform:\n return (state[:9],state[9:12])","def reflect_state(self, s):\n s[2:8] = reflect_control_vector(s[2:8])\n s[11:17] = reflect_control_vector(s[11:17])\n return s","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n x = F.relu(self.fc3(x))\n return self.fc4(x)","def forward(self, state):\n x = self._format(state)\n x = self.activation_fc(self.input_layer(x))\n for hidden_layer in self.hidden_layers:\n x = self.activation_fc(hidden_layer(x))\n x = self.output_layer(x)\n x = self.out_activation_fc(x)\n return self.rescale_fn(x)","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n return self.fc3(x)","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n return self.fc3(x)","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n return self.fc3(x)","def _state_convert(self, raw_state):\n variables_dict = dict()\n variables_dict[\"s_t\"] = np.hstack((0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.0, 0.0, 1.0))\n variables_dict[\"v_t\"] = np.hstack((0.0, 0.0, 0.0, 0.0, 0.0, 0.0))\n variables_dict[\"add_s_t\"] = np.hstack((0.8, 0.8))\n variables_dict[\"add_v_t\"] = np.hstack((0.0, 0.0))\n variables_dict[\"flag_t\"] = 0.0\n variables_dict[\"add_dist_min\"] = np.hstack((1000.0, 1000.0, 1000.0, 1000.0))\n variables_dict[\"dist_min\"] = np.hstack((1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0))\n variables_dict[\"ego_lane\"] = raw_state[16]\n variables_dict[\"lane_ids\"] = raw_state[18]\n variables_dict[\"ego_lane\"] = variables_dict[\"lane_ids\"].index(variables_dict[\"ego_lane\"])\n if variables_dict[\"ego_lane\"] == 0 or variables_dict[\"ego_lane\"] == 2:\n variables_dict[\"s_t\"][variables_dict[\"ego_lane\"]] = 1.0\n variables_dict[\"s_t\"][variables_dict[\"ego_lane\"] + 3] = 1.0\n variables_dict[\"flag_t\"] = 1 if variables_dict[\"ego_lane\"] == 0 else -1\n\n variables_dict[\"ego_raw_speed\"] = raw_state[3]\n variables_dict[\"filter_speed\"] = (variables_dict[\"ego_raw_speed\"]\n if variables_dict[\"ego_raw_speed\"] >= 10.0 else 10.0)\n variables_dict[\"s_t\"][6] = variables_dict[\"ego_raw_speed\"] / SPEED_RANGE\n objects = raw_state[-1]\n # print(\"ego_speed\",ego_raw_speed,\"ego_lane\",ego_lane)\n if objects[0] is not None:\n # for i in range(len(objects)):\n for i, _object in enumerate(objects):\n lane_id = objects[i][0]\n dist = abs(objects[i][1]) * np.sign(objects[i][1])\n speed = objects[i][2]\n pre_post = np.sign(dist)\n flag = 0 if pre_post == 1.0 else 1\n\n if abs(dist) < VIEW_RANGE:\n for j in range(3):\n adjacent_lane = variables_dict[\"ego_lane\"] - 1 + j\n dist_index = j + flag * 3\n if (lane_id == adjacent_lane and abs(dist) < variables_dict[\"dist_min\"][dist_index]):\n self.min_dist(\n variables_dict[\"v_t\"],\n variables_dict[\"s_t\"],\n dist_index,\n speed,\n dist,\n variables_dict[\"filter_speed\"],\n )\n variables_dict[\"dist_min\"][dist_index] = abs(dist)\n\n if abs(dist) < variables_dict[\"add_dist_min\"][flag]:\n if (variables_dict[\"ego_lane\"] == 0 and lane_id == variables_dict[\"ego_lane\"] + 2\n or variables_dict[\"ego_lane\"] == len(variables_dict[\"lane_ids\"]) - 1\n and lane_id == variables_dict[\"ego_lane\"] - 2):\n self.min_dist(\n variables_dict[\"add_v_t\"],\n variables_dict[\"add_s_t\"],\n flag,\n speed,\n dist,\n variables_dict[\"filter_speed\"],\n )\n\n state = np.hstack((\n variables_dict[\"s_t\"],\n variables_dict[\"v_t\"],\n variables_dict[\"add_s_t\"],\n variables_dict[\"add_v_t\"],\n variables_dict[\"flag_t\"],\n ))\n return state","def forward(self, state):\n output = self.conv_layers(state)\n output = output.view(-1, 7*7*64)\n output = self.fc(output)\n return output","def forward(self, state):\n '''\n state = F.relu(self.conv1(state))\n state = F.relu(self.conv2(state))\n state = F.relu(self.conv3(state))\n state = F.relu(self.fc1(state))\n \n action = F.relu(self.fc2(state))\n \n return action\n '''\n \n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n x = self.fc3(x)\n \n return x","def _reduce_states(self, fw_st, bw_st):\n hidden_dim = self._hps.hidden_dim\n with tf.variable_scope('reduce_final_st'):\n\n # Define weights and biases to reduce the cell and reduce the state\n w_reduce_c = tf.get_variable('w_reduce_c', [hidden_dim * 2, hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\n w_reduce_h = tf.get_variable('w_reduce_h', [hidden_dim * 2, hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\n bias_reduce_c = tf.get_variable('bias_reduce_c', [hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\n bias_reduce_h = tf.get_variable('bias_reduce_h', [hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\n\n # Apply linear layer\n old_c = tf.concat(axis=1, values=[fw_st.c, bw_st.c]) # Concatenation of fw and bw cell\n old_h = tf.concat(axis=1, values=[fw_st.h, bw_st.h]) # Concatenation of fw and bw state\n new_c = tf.nn.relu(tf.matmul(old_c, w_reduce_c) + bias_reduce_c) # Get new cell from old cell\n new_h = tf.nn.relu(tf.matmul(old_h, w_reduce_h) + bias_reduce_h) # Get new state from old state\n return tf.contrib.rnn.LSTMStateTuple(new_c, new_h) # Return new cell and state","def forward(self, state):\n\t\tx = F.relu(self.fc1(state))\n\t\tx = F.relu(self.fc2(x))\n\t\tx = F.tanh(self.fc3(x)) # outputs are in the range [-1, 1]\n\n\t\treturn x","def transition_up(self, x, filters, name):\n with tf.name_scope(name):\n x = tf.layers.conv2d_transpose(x,\n filters=filters,\n kernel_size=[3, 3],\n strides=[2, 2],\n padding='SAME',\n activation=None,\n kernel_initializer=tf.contrib.layers.xavier_initializer(),\n name=name+'_trans_conv3x3')\n\n return x","def forward(self, state):\n x = self.nonlin(self.fc1(self.in_fn(state)))\n x = self.drop_layer(x)\n x = self.nonlin(self.fc2(x))\n x = self.drop_layer(x)\n return self.fc3(x)","def state_action(self, s, a):\r\n s_x, s_y = s[0][0], s[0][1]\r\n s_vx, s_vy = s[1][0], s[1][1]\r\n a_x, a_y = a[0] + 1, a[1] + 1\r\n s_a = (s_x, s_y, s_vx, s_vy, a_x, a_y)\r\n\r\n return s_a","def forward(self, state):\n x = F.relu(self.linear1(state))\n x = F.relu(self.linear2(x))\n x = self.linear3(x)\n return x","def convert_state(self, x, v):\n \n\n #print(self.offset[0] * self.tiling_displacement[len(self.tiling_displacement)-1][0] / self.tile_width[0])\n\n #state = 0\n n_features = self.total_tiles[0] * self.total_tiles[1] * self.n_tilings\n state = np.zeros(n_features, dtype=int)\n print(np.shape(state))\n\n for i in range(self.n_tilings):\n # Finds the index of the tile in both dimensions\n x_tile = (x - self.offset[0] * self.tiling_displacement[i][0] - self.x_range[0] + self.extra_tiles[0] * self.tile_width[0]) // self.tile_width[0]\n v_tile = (v - self.offset[1] * self.tiling_displacement[i][1] - self.v_range[0] + self.extra_tiles[1] * self.tile_width[1]) // self.tile_width[1]\n \n #x_tile = (x - self.offset[0] * self.tiling_displacement[i][0] - self.x_range[0] + self.extra_tiles[0] * self.tile_width[0]) // self.tile_width[0]\n #v_tile = (v - self.offset[1] * self.tiling_displacement[i][1] - self.v_range[0] + self.extra_tiles[1] * self.tile_width[1]) // self.tile_width[1]\n\n index = int(i * (self.total_tiles[0]*self.total_tiles[1]) + x_tile * self.total_tiles[0] + v_tile)\n print(\"INDEX\" , index)\n state[index] = 1\n\n\n\n\n \"\"\"\n # adds the correct bit (corresponding to the state of the tiling) to the state integer\n state += 2 ** (i * self.n_tiles**2 + x_tile * self.n_tiles + v_tile)\n \"\"\"\n print (\"Tiling %s: (%s,%s)\" % (i, x_tile, v_tile))\n\n return state","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n #return self.fc3(x)\n return F.softmax(self.fc3(x), dim=1)","def _normalizeState(self, Z : vector) -> vector:\n return Z * self.D","def _preprocess_state(self, state):\n\n def normalize_matrix(matrix, min_val, max_val):\n \"\"\"normalizes all elements in matrix to be between min val and max val\n \"\"\"\n return (max_val - min_val) * (matrix - np.min(matrix)) / (np.max(matrix) - np.min(matrix)) + min_val\n\n A, b, c0, cuts_a, cuts_b = state\n\n min_lhs = np.min([np.min(A), np.min(cuts_a)])\n max_lhs = np.max([np.max(A), np.max(cuts_a)])\n min_rhs = np.min([np.min(b), np.min(cuts_b)])\n max_rhs = np.max([np.max(b), np.max(cuts_b)])\n\n A = normalize_matrix(A, min_lhs, max_lhs)\n cuts_a = normalize_matrix(cuts_a, min_lhs, max_lhs)\n\n b = normalize_matrix(b, min_rhs, max_rhs)\n cuts_b = normalize_matrix(cuts_b, min_rhs, max_rhs)\n\n processed_state = (A, b, c0, cuts_a, cuts_b)\n condensed_state = self._condense_state(processed_state)\n return condensed_state","def forward(self, state: list) -> list:\n x = F.relu(self.fc1_layer(state))\n x = F.relu(self.fc2_layer(x))\n x = F.tanh(self.fc3_layer(x))\n\n return x","def sim_to_state(self):\n # As mentioned earlier, we only need z-axis variables.\n # This will keep our state nice and small.\n return [\n self.sim.pose[Z_AXIS],\n self.sim.v[Z_AXIS],\n self.sim.linear_accel[Z_AXIS]\n ]","def make_state_appliable_4ch(state):\n size = len(state)\n st_appl = np.zeros((size,)*4, dtype=complex)\n for p1 in range(size):\n for p2 in range(size):\n for p3 in range(size):\n for p4 in range(size):\n st_appl[p1, p2, p3, p4] = state[p1, p2, p3, p4] * sqrt(factorial(p1) * factorial(p2) * factorial(p3) * factorial(p4))\n return st_appl","def normalize_state(self):\n self.state = 2 * (self.state - 0.5)","def split_state(U):\n return U[0], U[1], U[2], U[3], U[4], U[5], r(U)","def forward(self, state, action):\n s1 = F.relu(self.fcs1(state))\n s2 = F.relu(self.fcs2(s1))\n\n a1 = F.relu(self.fca1(action))\n\n x = torch.cat((s2, a1), dim=1)\n x = F.relu(self.fc2(x))\n x = self.fc3(x)\n\n return x","def synchronize_state(self):\n theta = self.unicycle_state[:,2]\n v = self.unicycle_state[:,3]\n self.position[:, :2] = self.unicycle_state[:,:2]\n self.orientation[:,2] = theta\n vx = v * np.cos(theta)\n vy = v * np.sin(theta)\n\n self.velocity[:, 0] = vx\n self.velocity[:, 1] = vy\n\n self.angular_velocity[:, 2] = self.unicycle_state[:, 4]","def forward(self, state):\n x = F.relu(self.input(state))\n for layer in self.layers:\n x = F.relu(layer(x))\n if self.duel:\n # Value function estimator\n val = F.relu(self.val_fc_input(x))\n val = self.val_fc_output(val)\n # Advantage function estimator\n adv = F.relu(self.adv_fc_input(x))\n adv = self.adv_fc_output(adv)\n # Subtract mean so that V and A are uniquely identifiable for a given Q\n return val + adv - adv.mean(1).unsqueeze(1).expand(state.size(0), self.action_size)\n else:\n return self.output(x)","def _conformState(self, state : vector) -> vector:\n '''@Z : vector'''\n \n return AbstractRecursiveFilter.conformState(self.order, state)","def call(self, state):\n x = tf.cast(state, tf.float32)\n x = self.flatten(x)\n x -= self.min_vals\n x /= self.max_vals - self.min_vals\n x = 2.0 * x - 1.0 # Rescale in range [-1, 1].\n x = self.dense1(x)\n x = self.dense2(x)\n x = self.last_layer(x)\n return x","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n return F.tanh(self.fc3(x))","def forward(self, state):\n x = state\n for layer in self.linear_layers[:-1]:\n x = F.relu(layer(x))\n x = self.linear_layers[-1](x)\n return x","def transl(x, y, z):\n displace_vector = [[x],\n [y],\n [z]]\n return np.matrix(displace_vector)","def gather_state(self):\n self.x[0,0:self.n] = self.m[0:self.n]\n self.x[1,0:self.n] = self.r[0:self.n,0]\n self.x[2,0:self.n] = self.r[0:self.n,1]\n self.x[3,0:self.n] = self.r[0:self.n,2]\n self.x[4,0:self.n] = self.v[0:self.n,0]\n self.x[5,0:self.n] = self.v[0:self.n,1]\n self.x[6,0:self.n] = self.v[0:self.n,2]\n return(self.x)","def simplify(self):\n state_copy = copy.deepcopy(self)\n state_copy.space.spacecrafts = [state_copy.spacecraft] + state_copy.space.close_spacecrafts_to(\n state_copy.spacecraft, self.PERCEPTION_DISTANCE)\n\n return state_copy","def forward(self, x):\n x = F.relu(self.affine1(x))\n x = F.relu(self.affine2(x))\n x = F.relu(self.affine3(x))\n x = F.relu(self.affine4(x))\n x = F.relu(self.affine5(x))\n\n # actor: choses action to take from state s_t \n # by returning probability of each action\n action_prob = F.softplus(self.action_head(x)).reshape(-1) + 1e-20\n\n # critic: evaluates being in the state s_t\n state_values = self.value_head(x)\n\n # return values for both actor and critic as a tuple of 2 values:\n # 1. a list with the probability of each action over the action space\n # 2. the value from state s_t \n return action_prob, state_values","def forward(self, x):\n x=T.div(x,255.0)\n \n #print(state[20:,20:,0])\n #print(state[:,0,:,:])\n conv1 = F.relu(self.conv1(x))\n conv2 = F.relu(self.conv2(conv1))\n conv3 = F.relu(self.conv3(conv2))\n ###\n conv_state = conv3.view(conv3.size()[0], -1)\n flat1 = F.relu(self.fc1(conv_state))\n flat2 = F.relu(self.fc2(flat1))\n\n V = self.V(flat2)\n A = self.A(flat2)\n\n return V, A\n return x","def getTranslation(fracs):\n \n \n \n # Determine whether the shift needs to be from inf to 0 \n # or from -inf to 0\n \n # Along all x fractionals\n if abs(max(fracs[0]))>=abs(min(fracs[0])):\n minX = min([x for x in fracs[0] if x>0])\n else:\n minX = min([x for x in fracs[0] if x<0])\n \n # Along all y fractionals\n if abs(max(fracs[1]))>=abs(min(fracs[1])):\n minY = min([x for x in fracs[1] if x>0])\n else:\n minY = min([x for x in fracs[1] if x<0])\n \n # Along all z fractionals\n # Need to consider all atoms lying in a single\n # plane (e.g. graphene), thus the final \"else\"\n # statement\n if abs(max(fracs[2]))>abs(min(fracs[2])):\n minZ = min([x for x in fracs[2] if x>0])\n elif abs(max(fracs[2]))<abs(min(fracs[2])):\n minZ = min([x for x in fracs[2] if x<0])\n else:\n minZ = max(fracs[2])\n\n shift_vector = np.array([minX,minY,minZ])\n \n return(shift_vector)","def forward(self, state, action):\n s1 = F.relu(self.fcs1(state))\n a1 = F.relu(self.fca1(action))\n x = torch.cat((s1, a1), dim=1)\n\n x = self.fc3(x)\n\n return x","def forward(self, state):#forward pass\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n return torch.tanh(self.fc3(x))","def gather_state(self):\n self.x[0,0:self.n] = self.m[0:self.n]\n self.x[1,0:self.n] = self.r[0:self.n,0]\n self.x[2,0:self.n] = self.r[0:self.n,1]\n self.x[3,0:self.n] = self.r[0:self.n,2]\n self.x[4,0:self.n] = self.v[0:self.n,0]\n self.x[5,0:self.n] = self.v[0:self.n,1]\n self.x[6,0:self.n] = self.v[0:self.n,2]\n self.x[7,0:self.n] = self.rho[0:self.n]\n self.x[8,0:self.n] = self.p[0:self.n]\n # added second component of pressure\n self.x[9,0:self.n] = self.pco[0:self.n]\n self.x[10,0:self.n] = self.u[0:self.n]\n return(self.x)","def states(grid, dt,\n u, v,\n ldelta_ux, ldelta_vx,\n ldelta_uy, ldelta_vy,\n gradp_x, gradp_y,\n u_MAC, v_MAC):\n\n # get the full u and v left and right states (including transverse\n # terms) on both the x- and y-interfaces\n u_xl, u_xr, u_yl, u_yr, v_xl, v_xr, v_yl, v_yr = get_interface_states(grid, dt,\n u, v,\n ldelta_ux, ldelta_vx,\n ldelta_uy, ldelta_vy,\n gradp_x, gradp_y)\n\n # upwind using the MAC velocity to determine which state exists on\n # the interface\n u_xint = burgers_interface.upwind(grid, u_xl, u_xr, u_MAC)\n v_xint = burgers_interface.upwind(grid, v_xl, v_xr, u_MAC)\n u_yint = burgers_interface.upwind(grid, u_yl, u_yr, v_MAC)\n v_yint = burgers_interface.upwind(grid, v_yl, v_yr, v_MAC)\n\n return u_xint, v_xint, u_yint, v_yint","def forward(self, state):\n \n x = F.relu(self.fc1(state)) \n x = F.relu(self.fc2(x)) \n x = F.tanh(self.fc3(x)) \n \n \n ####x = F.relu(self.bn1(self.fc1(state)))\n ####x = F.relu(self.bn2(self.fc2(x)))\n ####x = torch.tanh(self.bn3(self.fc3(x)))\n ##x = torch.tanh(self.fc3(x))\n\n return x","def finnLaplace(u):\n laplace=u[0:-2, 1:-1] + u[2:, 1:-1] + u[1:-1, 0:-2] + u[1:-1, 2:] - 4 * u[1:-1, 1:-1]\n return laplace","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n x = F.relu(self.fc3(x))\n x = F.relu(self.fc4(x))\n\n return F.tanh(self.fc5(x))","def strain_rates(\n u1, # velocity-1 component\n u2, # velocity-2 component\n u3, # velocity-3 component\n h = False, # spatial step size\n dim = False): # number of spatial steps\n #---------------------------------------------------------------------#\n # Default settings #\n #---------------------------------------------------------------------#\n if h is False:\n pi = np.pi\n N = 64\n h = (2.0*pi)/N\n if dim is False:\n dim = 64\n #---------------------------------------------------------------------#\n # Strain rates #\n #---------------------------------------------------------------------#\n St = np.empty((6, dim, dim, dim))\n St[0] = np.gradient(u1, h, edge_order=2)[2] # S11\n St[1] = 0.5*(np.gradient(u1, h, edge_order=2)[1] +\\\n np.gradient(u2, h, edge_order=2)[2]) # S12\n St[2] = 0.5*(np.gradient(u1, h, edge_order=2)[0] +\\\n np.gradient(u3, h, edge_order=2)[2]) # S13\n St[3] = np.gradient(u2, h, edge_order=2)[1] # S22\n St[4] = 0.5*(np.gradient(u2, h, edge_order=2)[0] +\\\n np.gradient(u3, h, edge_order=2)[1]) # S23\n St[5] = (np.gradient(u3, h, edge_order=2)[0]) # S33\n\n return St","def __update_state(self, x0, u):\n N = int(len(u) / 2)\n lower_triangular_ones_matrix = np.tril(np.ones((N, N)))\n kron = np.kron(lower_triangular_ones_matrix, np.eye(2))\n\n new_state = np.vstack([np.eye(2)] * int(N)) @ x0 + kron @ u * self.nmpc_timestep\n\n return new_state","def forward(self, state):\n x = self.fc(state)\n return x","def _build_gains(self):\n flip_nibbles = True\n\n p = (100, 4, flip_nibbles)\n d = (1000, 4, flip_nibbles)\n i = (0, 4, flip_nibbles)\n il = (0, 4, flip_nibbles)\n ol = (255, 2)\n cl = (0, 2)\n el = (4000, 4, flip_nibbles)\n sr = (1, 2)\n db = (1, 2)\n sm = (1, 2)\n gains = self._build_hexstr(p, d, i, il, ol, cl, el, sr, db, sm)\n return \"F6{}\".format(gains)","def _condense_state(self, s):\n def append_col(A, b):\n expanded_b = np.expand_dims(b, 1)\n return np.append(A, expanded_b, 1)\n\n A, b, c0, cuts_a, cuts_b = s\n Ab = append_col(A, b)\n cuts = append_col(cuts_a, cuts_b)\n return (Ab, c0, cuts)","def fL():\n for n in b.allNodes():\n n.autoplace()","def forward(self, state):\n x = state.unsqueeze(1)\n x = F.relu(self.cnl1(x))\n x = F.relu(self.cnl2(x))\n x = F.relu(self.cnl3(x))\n x = x.view(x.shape[0], -1) # flatten\n x = F.relu(self.dense1(x))\n x = self.out(x)\n return x","def preprocess_state(states):\n states_pp = np.copy(states)\n \n # Paint black over the sum of rewards\n states_pp[:, 85:, :15] = [0.0, 0.0, 0.0]\n\n # Replace the colors defined bellow\n def replace_color(old_color, new_color):\n mask = np.all(states_pp == old_color, axis=3)\n states_pp[mask] = new_color\n\n # Black bar\n replace_color([000., 000., 000.], [120.0, 120.0, 120.0])\n\n # Road\n #new_road_color = [255.0, 255.0, 255.0]\n new_road_color = [102.0, 102.0, 102.0]\n replace_color([102., 102., 102.], new_road_color)\n replace_color([105., 105., 105.], new_road_color)\n replace_color([107., 107., 107.], new_road_color)\n # Curbs\n replace_color([255., 000., 000.], new_road_color)\n replace_color([255., 255., 255.], new_road_color)\n # Grass\n #new_grass_color = [0.0, 0.0, 0.0]\n new_grass_color = [102., 229., 102.]\n replace_color([102., 229., 102.], new_grass_color)\n replace_color([102., 204., 102.], new_grass_color)\n\n # Float RGB represenattion\n states_pp /= 255.\n\n # Converting to gray scale\n states_pp = rgb2gray(states_pp)\n\n return states_pp","def stateToCode(self, state):\n\n multiplier = 1\n code = \"\"\n for i in range(self.num_joints-1, -1, -1):\n num_angles = len(self.angles[i])\n code += str(int((state / multiplier ) % num_angles))\n multiplier *= len(self.angles[i])\n\n # Return the reversed code\n return code [::-1]","def _fuse_back(self):\n with tf.variable_scope('fusion'):\n #self.fuse_p_encodes, _ = rnn('lstm', self.match_p_encodes, self.p_length,\n # self.hidden_size, layer_num=1)\n self.fuse_p_encodes = tc.layers.fully_connected(self.match_p_encodes, self.hidden_size)\n if self.use_dropout:\n self.fuse_p_encodes = tf.nn.dropout(self.fuse_p_encodes, self.dropout_keep_prob)","def _preprocess_state(self, state):\r\n if np.isinf(self.observation_space.low).any() or np.isinf(self.observation_space.high).any(): return state\r\n return (state - self.observation_space.low) /(self.observation_space.high)","def forward(self, x):\n x = self.arch(x)\n x = self.swish(x)\n x_out = self.arch._fcOut(x)\n return x_out","def down_optimized_block(x, out_channels, name, act=tf.nn.relu):\n with tf.variable_scope(name):\n x_0 = x\n x = ops.snconv2d(x, out_channels, 3, 3, 1, 1, name='sn_conv1')\n x = act(x)\n x = ops.snconv2d(x, out_channels, 3, 3, 1, 1, name='sn_conv2')\n x = dsample(x)\n x_0 = dsample(x_0)\n x_0 = ops.snconv2d(x_0, out_channels, 1, 1, 1, 1, name='sn_conv3')\n return x + x_0","def featurize_state(self,state):\r\n try:\r\n state=(state[0].item(),state[1].item())\r\n except:\r\n pass\r\n \r\n scaled_x = np.divide(np.add(state[0],-self.x_mean),np.add(self.x_max,-self.x_min))\r\n scaled_vx = np.divide(np.add(state[1],-self.vx_mean),np.add(self.vx_max,-self.vx_min))\r\n return [scaled_x,scaled_vx]","def unfold_params(params, nstates=2):\n init = params[:nstates]\n # emiss = params[nstates:nstates * 5].reshape((nstates, 4))\n trans = params[nstates:(nstates * (nstates + 1))].reshape((nstates, nstates))\n scale = params[-1]\n return init, trans, scale","def rollout(self, us):\n xs = [self.initialState]\n for m, d, u in zip(self.runningModels, self.runningDatas, us):\n xs.append(m.calc(d, xs[-1], u)[0].copy())\n return xs","def forward(self, state, action) -> float:\n xs = F.relu(self.fcs1_layer(state))\n x = torch.cat((xs, action), dim=1)\n x = F.relu(self.fc2_layer(x))\n x = self.dropout(x)\n x = self.fc3_layer(x)\n\n return x","def transition_down(self, x, training, filters, name):\n with tf.name_scope(name):\n x = self.batch_norm(x, training, name=name+'_bn')\n x = tf.nn.relu(x, name=name+'relu')\n x = tf.layers.conv2d(x,\n filters=filters,\n kernel_size=[1, 1],\n strides=[1, 1],\n padding='SAME',\n dilation_rate=[1, 1],\n activation=None,\n kernel_initializer=tf.contrib.layers.xavier_initializer(),\n name=name+'_conv1x1')\n x = tf.layers.dropout(x, rate=0.2, training=training, name=name+'_dropout')\n x = tf.nn.max_pool(x, [1, 4, 4, 1], [1, 2, 2, 1], padding='SAME', name=name+'_maxpool2x2')\n\n return x","def state_eq(t, x, u, tu):\n # u = u[0, :]\n u_interp = np.interp(t, tu, u[0, :])\n # print(f'u: {u}')\n return np.vstack((x[1], -x[1] + u_interp))","def forward(self, s):\n \n fc1_out = self.fc1(s)\n fc1_act = F.dropout(F.relu(fc1_out), p=0.3)\n fc2_out = self.fc2(fc1_act)\n fc2_act = F.dropout(F.relu(fc2_out), p=0.3)\n fc3_out = self.fc3(fc2_act)\n output = F.sigmoid(fc3_out) # output size = batch_size x 28\n\n return output","def sparsify(self, state):\n print(\"running L0 projection-based (unstructured) sparsification. \\n \")\n model = state.model\n masks = self.get_masks(model)\n self.apply_masks(model, masks)","def state_transition(self):\n self.x = np.dot(self.F, self.x)\n self.x_noisy = noise_fun(np.dot(self.F, self.x_noisy), self.Q)\n return self.x","def _apply_cz(self, state, axes, **kwargs):\n ndim = self._ndim(state)\n sl_0 = _get_slice(0, axes[0], ndim)\n sl_1 = _get_slice(1, axes[0], ndim)\n\n if axes[1] > axes[0]:\n target_axes = [axes[1] - 1]\n else:\n target_axes = [axes[1]]\n\n state_z = self._apply_z(state[sl_1], axes=target_axes)\n return self._stack([state[sl_0], state_z], axis=axes[0])","def computePosition(self, state):\n d = 0\n if state[5] == \"East\":\n d = 0\n elif state[5] == \"West\":\n d = 1\n elif state[5] == \"North\":\n d = 2\n else:\n d = 3\n return state[0]*64+state[1]*32+state[2]*16+state[3]*8+state[4]*4+d","def forward(self, state):\n x = f.relu(self.fc1(state))\n x = f.relu(self.fc2(x))\n return torch.tanh(self.fc3(x))","def forward(self, state, action):\n xs = F.relu(self.fcs1(state))\n x = torch.cat((xs, action), dim=1)\n x = F.relu(self.fc2(x))\n return self.fc3(x)","def test_displace_xyz(self):\n xyz = {'symbols': ('N', 'H', 'H', 'N', 'H', 'H', 'N', 'H'), 'isotopes': (14, 1, 1, 14, 1, 1, 14, 1),\n 'coords': ((-0.447353, 0.680147, -0.090895), (-0.451171, 1.142121, 0.814701),\n (0.674665, 0.380874, -0.232312), (-1.228559, -0.471121, -0.003769),\n (-1.815912, -0.503291, 0.815499), (-1.782278, -0.570663, -0.841674),\n (1.909708, -0.148579, -0.070033), (1.740013, -0.849123, 0.669738))}\n displacement = np.array([[-0.03, -0.02, -0.0], [0.04, -0.08, 0.05], [0.92, -0.34, 0.08], [0.0, 0.04, 0.0],\n [0.0, -0.05, 0.01], [0.09, -0.09, -0.04], [-0.05, 0.02, -0.01], [0.0, 0.03, -0.01]],\n np.float64)\n xyz_1, xyz_2 = converter.displace_xyz(xyz=xyz, displacement=displacement)\n expected_xyz_1 = {'symbols': ('N', 'H', 'H', 'N', 'H', 'H', 'N', 'H'), 'isotopes': (14, 1, 1, 14, 1, 1, 14, 1),\n 'coords': ((-0.4754185110901118, 0.6614366592732588, -0.090895),\n (-0.44113195107970876, 1.1220429021594176, 0.827249811150364),\n (0.9055631251666977, 0.29554208417752476, -0.2122339021594176),\n (-1.228559, -0.43370031854651764, -0.003769),\n (-1.815912, -0.515839811150364, 0.8180087622300728),\n (-1.7596901399293448, -0.5932508600706552, -0.8517130489202912),\n (1.862932148183147, -0.1298686592732588, -0.07938817036337059),\n (1.740013, -0.8415937133097816, 0.6672282377699272))}\n expected_xyz_2 = {'symbols': ('N', 'H', 'H', 'N', 'H', 'H', 'N', 'H'), 'isotopes': (14, 1, 1, 14, 1, 1, 14, 1),\n 'coords': ((-0.4192874889098882, 0.6988573407267411, -0.090895),\n (-0.4612100489202912, 1.1621990978405823, 0.802152188849636),\n (0.44376687483330224, 0.4662059158224752, -0.2523900978405824),\n (-1.228559, -0.5085416814534824, -0.003769),\n (-1.815912, -0.49074218884963605, 0.8129892377699272),\n (-1.8048658600706553, -0.5480751399293449, -0.8316349510797089),\n (1.956483851816853, -0.16728934072674118, -0.060677829636629405),\n (1.740013, -0.8566522866902183, 0.6722477622300729))}\n self.assertEqual(xyz_1, expected_xyz_1)\n self.assertEqual(xyz_2, expected_xyz_2)\n\n xyz_1, xyz_2 = converter.displace_xyz(xyz=xyz, displacement=displacement, amplitude=0.5)\n expected_xyz_1 = {'symbols': ('N', 'H', 'H', 'N', 'H', 'H', 'N', 'H'), 'isotopes': (14, 1, 1, 14, 1, 1, 14, 1),\n 'coords': ((-0.5034840221802236, 0.6427263185465175, -0.090895),\n (-0.4310929021594176, 1.101964804318835, 0.839798622300728),\n (1.1364612503333955, 0.2102101683550495, -0.19215580431883517),\n (-1.228559, -0.39627963709303526, -0.003769),\n (-1.815912, -0.528388622300728, 0.8205185244601456),\n (-1.7371022798586897, -0.6158387201413105, -0.8617520978405825),\n (1.816156296366294, -0.11115831854651761, -0.08874334072674119),\n (1.740013, -0.8340644266195631, 0.6647184755398544))}\n expected_xyz_2 = {'symbols': ('N', 'H', 'H', 'N', 'H', 'H', 'N', 'H'), 'isotopes': (14, 1, 1, 14, 1, 1, 14, 1),\n 'coords': ((-0.3912219778197764, 0.7175676814534824, -0.090895),\n (-0.4712490978405824, 1.1822771956811648, 0.789603377699272),\n (0.21286874966660452, 0.5515378316449505, -0.2724681956811648),\n (-1.228559, -0.5459623629069648, -0.003769),\n (-1.815912, -0.47819337769927206, 0.8104794755398543),\n (-1.8274537201413104, -0.5254872798586896, -0.8215959021594176),\n (2.003259703633706, -0.18599968145348236, -0.05132265927325881),\n (1.740013, -0.8641815733804368, 0.6747575244601457))}\n self.assertEqual(xyz_1, expected_xyz_1)\n self.assertEqual(xyz_2, expected_xyz_2)","def displacement_from_surface_loads(self, loads: {dict, Loads, typing.Sequence[np.ndarray]},\n grid_spacing: {typing.Sequence[float], float},\n deflections: str = 'xyz',\n current_state: dict = None,\n span: typing.Optional[typing.Sequence[int]] = None,\n simple: bool = False) -> Displacements:\n if not isinstance(loads, Loads):\n if isinstance(loads, dict):\n try:\n loads = {key: value for key, value in loads if value is not None}\n loads = Loads(**{key: np.array(value, dtype=float) for key, value in loads.items()})\n except TypeError:\n raise ValueError(\"Unrecognised keys in loads dict, allowed keys are x,y,z found keys are: \"\n f\"{', '.join(loads.keys())}\")\n elif isinstance(loads, Sequence):\n try:\n loads = Loads(*[np.array(ld, dtype=float) if ld is not None else None for ld in loads])\n except TypeError:\n raise ValueError(f\"length of the loads sequence must be 3, length is {len(loads)}\")\n\n valid_directions = 'xyz'\n load_directions = [vd for vd, el in zip(valid_directions, loads) if el is not None]\n\n shapes = [ld.shape for ld in loads if ld is not None]\n\n if len(set(shapes)) != 1:\n raise ValueError(\"Load vectors are not all the same shape\")\n\n if span is None:\n span = shapes[0]\n\n if not isinstance(grid_spacing, Sequence):\n grid_spacing = (grid_spacing,) * 2\n elif len(grid_spacing) == 1:\n grid_spacing *= 2\n elif len(grid_spacing) > 2:\n raise ValueError(\"Too many elements in grid_spacing sequence, should be 1 or 2\")\n\n # u_a=ifft(fft(K_ab) * fft(sigma_b))\n\n if simple:\n comp_names = [ld * 2 for ld in load_directions] # ['xx', 'yy'] etc.\n else:\n comp_names = list(product(deflections, load_directions))\n comp_names = [a + b for a, b in comp_names] # 'xy'...\n\n # get the influence matrix components from the class methods\n\n components = self.influence_matrix(span=span, grid_spacing=grid_spacing, components=comp_names)\n displacements = _solve_im_loading(loads, components)\n return displacements","def forward(self, state, action):\n\t\tx = F.relu(self.fc1(state))\n\t\tx = F.relu(self.fc2(torch.cat([x, action], dim=1))) # add action too for the mapping\n\t\tx = F.relu(self.fc3(x))\n\n\t\treturn x","def Lorenz(s):\n x = s[0]\n y = s[1]\n z = s[2]\n \n # constants for the equations\n sigma = 10.0\n rho = 28.0\n beta = 8.0/3.0\n \n # Return the state derivatives.\n return [sigma * (y-x), (rho-z)*x -y, x*y - beta*z]","def affine_backward(dout, cache):\n #raise NotImplementedError\n #######################################################################\n # #\n # #\n # TODO: YOUR CODE HERE #\n # #\n # #\n #######################################################################\n x,w,b=cache\n \n dx=np.dot(dout,(w.transpose()))\n D=w.shape[0]\n N=x.shape[0]\n dw=np.dot(x.transpose(),dout)\n db=np.dot(dout.transpose(),np.ones(N))\n return dx,dw,db","def forward(self, state, action):\n xs = f.relu(self.fcs1(state))\n x = torch.cat((xs, action), dim=1)\n x = f.relu(self.fc2(x))\n return self.fc3(x)","def transition(name, year, grids, control):\n ## SETUP -------------------------------------------------\n cc = control['cohorts'][name + '_Control']\n from_cohort_a0 = grids.area[name + '--0', year]\n from_cohort = grids.area[name, year]\n transitions_to = cc['transitions_to']\n to_cohort_a0 = grids.area[transitions_to + '--0', year]\n to_cohort = grids.area[transitions_to + '--0', year]\n ice_slope = \\\n grids.ice.get_ice_slope_grid( name )\\\n .reshape(grids.shape).astype(np.float32)\n ALD, PL = grids.ald['ALD', year], grids.ald[name ,year] \n AOI = grids.area.area_of_interest()\n POIn = grids.poi[name, year]\n POInm1 = grids.poi[name, year-1]\n drainage = grids.drainage.grid.reshape(grids.shape)\n above_idx = drainage == 'above'\n porosity = grids.ald.porosity[name]\n\n max_rot = cc['max_terrain_transition']\n\n if cc['POI_Function'] == 'Sigmoid2':\n params = np.array([\n cc['Parameters']['above']['sigmoid2_K'],\n cc['Parameters']['above']['sigmoid2_C'],\n cc['Parameters']['above']['sigmoid2_A'],\n cc['Parameters']['above']['sigmoid2_B'],\n cc['Parameters']['below']['sigmoid2_K'],\n cc['Parameters']['below']['sigmoid2_C'],\n cc['Parameters']['below']['sigmoid2_A'],\n cc['Parameters']['below']['sigmoid2_B'],\n ]).astype(np.float32)\n poi_func = calc_new_sig2_poi\n elif cc['POI_Function'] == 'Sigmoid':\n params = np.array([\n cc['Parameters']['above']['sigmoid_A1'],\n cc['Parameters']['above']['sigmoid_A2'],\n cc['Parameters']['above']['sigmoid_x0'],\n cc['Parameters']['above']['sigmoid_dx'],\n cc['Parameters']['below']['sigmoid_A1'],\n cc['Parameters']['below']['sigmoid_A2'],\n cc['Parameters']['below']['sigmoid_x0'],\n cc['Parameters']['below']['sigmoid_dx'],\n ]).astype(np.float32)\n poi_func = calc_new_sig_poi\n elif cc['POI_Function'] == 'Hill':\n params = np.array([\n cc['Parameters']['above']['hill_B'],\n cc['Parameters']['above']['hill_N'],\n cc['Parameters']['below']['hill_B'],\n cc['Parameters']['below']['hill_N'],\n ]).astype(np.float32)\n poi_func = calc_new_hill_poi\n elif cc['POI_Function'] == 'Linear':\n params = np.array([\n cc['Parameters']['above']['linear_a'],\n cc['Parameters']['above']['linear_b'],\n cc['Parameters']['below']['linear_a'],\n cc['Parameters']['below']['linear_b'],\n ]).astype(np.float32)\n poi_func = calc_linear_linear_poi\n else:\n raise KeyError(\"Not a valid function type\")\n\n present = from_cohort > 0\n pl_breach = ALD >= PL\n current_cell_mask = np.logical_and(np.logical_and(AOI, present), pl_breach)\n\n ## work ---------------\n blocks = (32, 32)\n threads = (\n int(np.ceil(ALD.shape[0] / blocks[0])),\n int(np.ceil(ALD.shape[1] / blocks[1]))\n )\n \n X = np.zeros(ALD.shape)\n calc_x[blocks, threads](X, ALD,PL)#.astype(np.float32)\n\n \n new_poi = np.zeros(X.shape)\n poi_func(new_poi, params, X, above_idx)\n\n\n update_poi[blocks, threads](POIn, POInm1, new_poi, current_cell_mask)\n \n\n # not cuda'd\n ALD[current_cell_mask] = \\\n ALD[current_cell_mask] + \\\n (ALD[current_cell_mask] - PL[ current_cell_mask ] ) * porosity\n\n rate_of_transition = np.zeros(POIn.shape) \n calc_rot[blocks, threads](rate_of_transition, POIn, ice_slope, max_rot)\n\n change = np.zeros(POIn.shape) \n calc_change[blocks, threads](\n change, rate_of_transition, from_cohort, present\n )\n \n # not cuda'd\n to_cohort_a0[present] = to_cohort[present] + change[present]\n from_cohort_a0[present] = from_cohort[present] - change[present]","def prepare_displaced_squeezed_state(self, alpha, r, phi, mode):\n\n self.circuit.squeeze(r, phi, mode)\n self.circuit.displace(alpha, mode)","def forward(self, state):\n\n # connect layers to each other and put relu activations between them\n for layer in self.hidden_layers:\n state = layer(state)\n state = F.relu(state)\n value = self.value_layer(state)\n return value","def _evolve_swap_element(self, state, element):\n new_state = PhotonicState()\n for in_modes, amp in state.items():\n out_modes = []\n for in_mode in in_modes:\n offset_in_mode = in_mode - element.offset \n if offset_in_mode in element.in_modes:\n index = element.in_modes.index(offset_in_mode)\n out_mode = element.out_modes[index] + element.offset\n else:\n out_mode = in_mode \n out_modes.append(out_mode)\n new_state[tuple(sorted(out_modes))] = amp \n return new_state","def res(self, t, y, yd, sw):\n if sw[0]:\n# print('state 1')\n G = scipy.array([\n [0, 1, 0],\n [0, 0, 1]\n ])\n gvec = y[3:5]\n elif sw[1]:\n# print('state 2')\n G = scipy.array([\n [0, self.hS, 0],\n [1, self.rS, 0]\n ])\n gvec = scipy.array([self.rS - self.r0 + self.hS * y[1],\n y[5] + self.rS * y[6]])\n elif sw[2]:\n# print('state 3, phi_bp: ', y[7], 'res: ', self.hB * y[2] - self.lS - self.lG + self.lB + self.r0)\n G = scipy.array([\n [0, - self.hS, 0],\n [1, self.rS, 0]\n ])\n gvec = scipy.array([self.rS - self.r0 - self.hS * y[1],\n y[5] + self.rS * y[6]])\n\n ff = scipy.array([- (self.mS + self.mB) * self.g,\n self.cp * (y[2] - y[1]) - self.mB * self.lS * self.g,\n self.cp * (y[1] - y[2]) - self.mB * self.lG * self.g])\n\n res_1 = yd[0:5] - y[5:10]\n res_2 = scipy.dot(self.M, yd[5:8]) - ff + scipy.dot(G.T, y[3:5])\n res_3 = gvec\n\n return scipy.hstack((res_1, res_2, res_3)).flatten()","def reconstructY(self, inputs):\n if self.act_dec is None:\n act_dec = lambda x: x\n else:\n act_dec = self.act_dec\n return act_dec(self.decodeY(inputs))","def _apply_state_vector(self, state, device_wires):\n\n # translate to wire labels used by device\n device_wires = self.map_wires(device_wires)\n dim = 2 ** len(device_wires)\n\n state = self._asarray(state, dtype=self.C_DTYPE)\n batch_size = self._get_batch_size(state, (dim,), dim)\n output_shape = [2] * self.num_wires\n if batch_size is not None:\n output_shape.insert(0, batch_size)\n\n if len(device_wires) == self.num_wires and sorted(device_wires) == device_wires:\n # Initialize the entire device state with the input state\n self._state = self._reshape(state, output_shape)\n return\n\n # generate basis states on subset of qubits via the cartesian product\n basis_states = np.array(list(itertools.product([0, 1], repeat=len(device_wires))))\n\n # get basis states to alter on full set of qubits\n unravelled_indices = np.zeros((2 ** len(device_wires), self.num_wires), dtype=int)\n unravelled_indices[:, device_wires] = basis_states\n\n # get indices for which the state is changed to input state vector elements\n ravelled_indices = np.ravel_multi_index(unravelled_indices.T, [2] * self.num_wires)\n\n if batch_size is not None:\n state = self._scatter(\n (slice(None), ravelled_indices), state, [batch_size, 2**self.num_wires]\n )\n else:\n state = self._scatter(ravelled_indices, state, [2**self.num_wires])\n state = self._reshape(state, output_shape)\n self._state = self._asarray(state, dtype=self.C_DTYPE)","def transposition_string(self, state):\n return state.__str__()","def fromState(state):","def transform_state(state):\n # TODO: automate n_enemies calculation -> only valid fot n_enemies = n_friends\n n_agents = len(state.agents)\n n_enemies = n_agents // 2 # TODO: improve this\n states_v = torch.zeros(n_agents, 5 + n_enemies) # 5 = x, y, alive, ammo, aim, enemy visible ? (x n_enemies)\n for agent_idx, agent in enumerate(state.agents):\n states_v[agent_idx, 0] = state.position[agent][0] # x\n states_v[agent_idx, 1] = state.position[agent][1] # y\n states_v[agent_idx, 2] = state.alive[agent]\n states_v[agent_idx, 3] = state.ammo[agent] / 5 # args.ammo\n states_v[agent_idx, 4] = -1 if state.aim[agent] is None else state.aim[agent].id\n idx = 5\n for other in state.agents:\n if (agent, other) in state.visible:\n states_v[agent_idx, idx] = int(state.visible[(agent, other)])\n idx += 1\n return states_v","def forward(self, x):\n out_conv1 = self.conv1(x)\n out_conv2 = self.conv2(out_conv1)\n out_conv3 = self.conv3(out_conv2)\n out_conv4 = self.conv4(out_conv3)\n out_conv5 = self.conv5(out_conv4)\n out_conv6 = self.conv6(out_conv5)\n out_conv7 = self.conv7(out_conv6)\n\n out_upconv7 = self.crop_top_left(self.upconv7(out_conv7), out_conv6)\n concat7 = torch.cat((out_upconv7, out_conv6), 1)\n out_iconv7 = self.iconv7(concat7)\n\n out_upconv6 = self.crop_top_left(self.upconv6(out_iconv7), out_conv5)\n concat6 = torch.cat((out_upconv6, out_conv5), 1)\n out_iconv6 = self.iconv6(concat6)\n\n out_upconv5 = self.crop_top_left(self.upconv5(out_iconv6), out_conv4)\n concat5 = torch.cat((out_upconv5, out_conv4), 1)\n out_iconv5 = self.iconv5(concat5)\n\n out_upconv4 = self.crop_top_left(self.upconv4(out_iconv5), out_conv3)\n concat4 = torch.cat((out_upconv4, out_conv3), 1)\n out_iconv4 = self.iconv4(concat4)\n disp4 = self.alpha * self.predict_disp4(out_iconv4) + self.beta\n\n out_upconv3 = self.crop_top_left(self.upconv3(out_iconv4), out_conv2)\n disp4_up = self.crop_top_left(torch.nn.functional.interpolate(disp4,\n scale_factor=2,\n mode='bilinear',\n align_corners=False), out_conv2)\n concat3 = torch.cat((out_upconv3, out_conv2, disp4_up), 1)\n out_iconv3 = self.iconv3(concat3)\n disp3 = self.alpha * self.predict_disp3(out_iconv3) + self.beta\n\n out_upconv2 = self.crop_top_left(self.upconv2(out_iconv3), out_conv1)\n disp3_up = self.crop_top_left(torch.nn.functional.interpolate(disp3,\n scale_factor=2,\n mode='bilinear',\n align_corners=False), out_conv1)\n concat2 = torch.cat((out_upconv2, out_conv1, disp3_up), 1)\n out_iconv2 = self.iconv2(concat2)\n disp2 = self.alpha * self.predict_disp2(out_iconv2) + self.beta\n\n out_upconv1 = self.crop_top_left(self.upconv1(out_iconv2), x)\n disp2_up = self.crop_top_left(torch.nn.functional.interpolate(disp2,\n scale_factor=2,\n mode='bilinear',\n align_corners=False), x)\n concat1 = torch.cat((out_upconv1, disp2_up), 1)\n out_iconv1 = self.iconv1(concat1)\n disp1 = self.alpha * self.predict_disp1(out_iconv1) + self.beta\n\n if self.training:\n return disp1, disp2\n else:\n return disp1","def obs2state(observation):\n l1 = [val.tolist() for val in list(observation.values())]\n l2 = []\n for sublist in l1:\n try:\n l2.extend(sublist)\n except:\n l2.append(sublist)\n return torch.FloatTensor(l2).view(1, -1)","def backward(self, dY, dcn = None, cache=None):\n if self.Reversed:\n dY = dY[::-1,:,:]\n\n cache = self.Cache if cache is None else cache\n y = cache['y']\n C = cache['C']\n S = cache['S']\n Z = cache['Z']\n c0 = cache['c0']\n U = cache['U']\n FN = cache['FN']\n FNf = cache['FNf']\n \n n, b, _ = dY.shape\n d = self.NC # hidden size\n input_size = U.shape[2]-1-d # - C - bias\n\n # views\n X = U[:,:,1:input_size+1]\n Ff = FNf[:,:,:d]\n F = FN[:,:,:d]\n Nf = FNf[:,:,d:]\n N = FN[:,:,d:]\n \n #Wxf = self.W[1:1+input_size,:d] # view\n #Wxn = self.W[1:1+input_size,d:] # view\n #Wsf = self.W[1+input_size:,:d] # view\n #Wsn = self.W[1+input_size:,d:] # view\n \n Wx = self.W[1:1+input_size,:]\n Ws = self.W[1+input_size:,:]\n\n gW = np.zeros(self.W.shape)\n gV = np.zeros(self.V.shape)\n gX = np.empty_like(X)\n gS = np.empty_like(C)\n \n NmS = Nf - S\n \n #print \"S:\", S\n #print \"N:\", N\n\n dZ = np.dot(dY, self.V.T) # [n, nb, nout] dot [nout, nin+1+nc] -> [n, nb, nin+1+nc]\n dC = dcn if not dcn is None else np.zeros((b, d))\n dFprime = Ff*(1.0-Ff)\n dNprime = 1.0-Nf**2\n\n gFN = np.empty((n, b, d*2))\n gFN[:,:,:d] = NmS*dFprime\n gFN[:,:,d:] = Ff*dNprime\n gF = gFN[:,:,:d]\n gN = gFN[:,:,d:]\n\n gCgFNt = np.empty((b, d*2))\n\n #if dcn is not None: dC[n-1] += dcn.copy() # carry over gradients from later\n for t in reversed(xrange(n)):\n gC = dC + dZ[t,:,-d:]\n\n gCgFNt[:,:d] = gC*gF[t]\n gCgFNt[:,d:] = gC*gN[t]\n \n gX[t] = np.dot(gCgFNt, Wx.T) + dZ[t,:,1:1+input_size]\n gS[t] = np.dot(gCgFNt, Ws.T) + gC*(1-Ff[t])\n\n gV += np.dot(Z[t].T, dY[t]) # [mb, in+1+nc] [mb, out] -> \n gW += np.dot(U[t].T, gCgFNt)\n \n dC = gS[t]\n \n return gX, gW, gV, gS[0]","def state(self):\n state = np.array(self.get_state_arr())\n om = utils.build_occupancy_maps(utils.build_humans(state))\n # We only have a batch of one so just get the first element of\n # transform and rotate\n state = utils.transform_and_rotate(state.reshape((1, -1)))[0]\n return torch.cat((state, om), dim=1)","def stoichiometry(self, fluid):\n air = self.air_alias.val\n fuel = self.fuel_alias.val\n flue_gas = self.fuel_alias.val + '_fg'\n\n ###################################################################\n # calculate fuel and air mass flow\n m_fuel = 0\n for i in self.inl:\n m_fuel += i.m.val_SI * i.fluid.val[fuel]\n\n m_air = 0\n for i in self.inl:\n m_air += i.m.val_SI * i.fluid.val[air]\n\n m_air_min = self.air_min * m_fuel\n\n ###################################################################\n # calculate lambda if not specified\n if not self.lamb.is_set:\n self.lamb.val = m_air / (self.air_min * m_fuel)\n\n ###################################################################\n # calculate excess fuel if lambda is smaller than 1\n m_fuel_exc = 0\n if self.lamb.val < 1:\n m_fuel_exc = m_fuel - m_air / (self.lamb.val * self.air_min)\n\n ###################################################################\n # equation for air\n if fluid == air:\n if self.lamb.val >= 1:\n dm = -m_air_min\n else:\n dm = -m_air\n\n ###################################################################\n # equation for fuel\n elif fluid == fuel:\n dm = -(m_fuel - m_fuel_exc)\n\n ###################################################################\n # equation for flue gas\n elif fluid == flue_gas:\n dm = m_air_min + m_fuel\n\n ###################################################################\n # equation for other components\n else:\n dm = 0\n\n res = dm\n for i in self.inl:\n res += i.fluid.val[fluid] * i.m.val_SI\n for o in self.outl:\n res -= o.fluid.val[fluid] * o.m.val_SI\n return res","def _apply_swap(self, state, axes, **kwargs):\n all_axes = list(range(len(state.shape)))\n all_axes[axes[0]] = axes[1]\n all_axes[axes[1]] = axes[0]\n return self._transpose(state, all_axes)","def _do_single_state(state, sign=True):\n states = []\n for p in ParallelHamiltonianBuilder.plaquettes:\n # First apply the U term.\n new_state, s = apply_u_dagger(state, p, sign=sign)\n\n # If U term was not successful, try the U^dagger term.\n # (the order could have been switched - there's always only one\n # possibility for overlap to be generated)\n if not new_state:\n new_state, s = apply_u(state, p, sign=sign)\n\n if new_state:\n c = ParallelHamiltonianBuilder.inv_lookuptable.get(new_state)\n if c is not None:\n states.append([state, c, s])\n\n return states","def forward(self, state, action): #concatenate the action -value\n\n xu = torch.cat([state, action], 1)\n\n x1 = F.relu(self.fc1(xu))\n x1 = F.relu(self.fc2(x1))\n x1 = self.fc3(x1)\n\n x2 = F.relu(self.fc4(xu))\n x2 = F.relu(self.fc5(x2))\n x2 = self.fc6(x2)\n \n return x1, x2","def constraint_transition_update(mvi, impact_surfaces, release_surfaces, transfer_state):\n mvi.set_single_state(2, transfer_state['t'], transfer_state['q'], transfer_state['p']) \n\n # Remove the constraints from the system.\n remove_constraints(mvi, release_surfaces)\n\n # Apply the impact map to the end of the interval.\n impact_update(mvi, impact_surfaces, transfer_state) \n\n mvi._state1_impacts = impact_surfaces\n mvi._state1_releases = release_surfaces","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n x = self.fc3(x)\n action = self.tanh(x)\n\n action = action.cpu().data.numpy() * self.action_lim\n action = torch.FloatTensor(action)\n\n return action","def forward(self, state):\n x = F.relu(self.linear1(state))\n x = F.relu(self.linear2(x))\n x = torch.tanh(self.linear3(x))\n\n return x","def forward(self, state):\r\n x = F.relu(self.linear1(state))\r\n x = F.relu(self.linear2(x))\r\n #x = torch.tanh(self.linear3(x))\r\n #x = F.relu(self.linear3(x))\r\n #x = nn.LeakyReLU(self.linear3(x), negative_slope=0.1)# .negativ_slope nur für leakyReLU relevant\r\n x = F.leaky_relu(self.linear3(x), 0.1)\r\n #x = F.softmax(self.linear3(x), dim=0)\r\n \r\n return x#.negativ_slope"],"string":"[\n \"def reverse_state(self):\\n state = np.array(self.get_reverse_state_arr())\\n om = utils.build_occupancy_maps(utils.build_humans(state))\\n # print(\\\"OM: \\\", om.size())\\n # We only have a batch of one so just get the first element of\\n # transform and rotate\\n state = utils.transform_and_rotate(state.reshape((1, -1)))[0]\\n # print(\\\"State: \\\", state.size())\\n return torch.cat((state, om), dim=1).unsqueeze(0)\",\n \"def to_se3(self, state: Vector) -> RigidTransform:\\n return (state[:9],state[9:])\",\n \"def to_se3(self, state: Vector) -> RigidTransform:\\n return (state[:9],state[9:12])\",\n \"def reflect_state(self, s):\\n s[2:8] = reflect_control_vector(s[2:8])\\n s[11:17] = reflect_control_vector(s[11:17])\\n return s\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n x = F.relu(self.fc3(x))\\n return self.fc4(x)\",\n \"def forward(self, state):\\n x = self._format(state)\\n x = self.activation_fc(self.input_layer(x))\\n for hidden_layer in self.hidden_layers:\\n x = self.activation_fc(hidden_layer(x))\\n x = self.output_layer(x)\\n x = self.out_activation_fc(x)\\n return self.rescale_fn(x)\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n return self.fc3(x)\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n return self.fc3(x)\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n return self.fc3(x)\",\n \"def _state_convert(self, raw_state):\\n variables_dict = dict()\\n variables_dict[\\\"s_t\\\"] = np.hstack((0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.0, 0.0, 1.0))\\n variables_dict[\\\"v_t\\\"] = np.hstack((0.0, 0.0, 0.0, 0.0, 0.0, 0.0))\\n variables_dict[\\\"add_s_t\\\"] = np.hstack((0.8, 0.8))\\n variables_dict[\\\"add_v_t\\\"] = np.hstack((0.0, 0.0))\\n variables_dict[\\\"flag_t\\\"] = 0.0\\n variables_dict[\\\"add_dist_min\\\"] = np.hstack((1000.0, 1000.0, 1000.0, 1000.0))\\n variables_dict[\\\"dist_min\\\"] = np.hstack((1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0))\\n variables_dict[\\\"ego_lane\\\"] = raw_state[16]\\n variables_dict[\\\"lane_ids\\\"] = raw_state[18]\\n variables_dict[\\\"ego_lane\\\"] = variables_dict[\\\"lane_ids\\\"].index(variables_dict[\\\"ego_lane\\\"])\\n if variables_dict[\\\"ego_lane\\\"] == 0 or variables_dict[\\\"ego_lane\\\"] == 2:\\n variables_dict[\\\"s_t\\\"][variables_dict[\\\"ego_lane\\\"]] = 1.0\\n variables_dict[\\\"s_t\\\"][variables_dict[\\\"ego_lane\\\"] + 3] = 1.0\\n variables_dict[\\\"flag_t\\\"] = 1 if variables_dict[\\\"ego_lane\\\"] == 0 else -1\\n\\n variables_dict[\\\"ego_raw_speed\\\"] = raw_state[3]\\n variables_dict[\\\"filter_speed\\\"] = (variables_dict[\\\"ego_raw_speed\\\"]\\n if variables_dict[\\\"ego_raw_speed\\\"] >= 10.0 else 10.0)\\n variables_dict[\\\"s_t\\\"][6] = variables_dict[\\\"ego_raw_speed\\\"] / SPEED_RANGE\\n objects = raw_state[-1]\\n # print(\\\"ego_speed\\\",ego_raw_speed,\\\"ego_lane\\\",ego_lane)\\n if objects[0] is not None:\\n # for i in range(len(objects)):\\n for i, _object in enumerate(objects):\\n lane_id = objects[i][0]\\n dist = abs(objects[i][1]) * np.sign(objects[i][1])\\n speed = objects[i][2]\\n pre_post = np.sign(dist)\\n flag = 0 if pre_post == 1.0 else 1\\n\\n if abs(dist) < VIEW_RANGE:\\n for j in range(3):\\n adjacent_lane = variables_dict[\\\"ego_lane\\\"] - 1 + j\\n dist_index = j + flag * 3\\n if (lane_id == adjacent_lane and abs(dist) < variables_dict[\\\"dist_min\\\"][dist_index]):\\n self.min_dist(\\n variables_dict[\\\"v_t\\\"],\\n variables_dict[\\\"s_t\\\"],\\n dist_index,\\n speed,\\n dist,\\n variables_dict[\\\"filter_speed\\\"],\\n )\\n variables_dict[\\\"dist_min\\\"][dist_index] = abs(dist)\\n\\n if abs(dist) < variables_dict[\\\"add_dist_min\\\"][flag]:\\n if (variables_dict[\\\"ego_lane\\\"] == 0 and lane_id == variables_dict[\\\"ego_lane\\\"] + 2\\n or variables_dict[\\\"ego_lane\\\"] == len(variables_dict[\\\"lane_ids\\\"]) - 1\\n and lane_id == variables_dict[\\\"ego_lane\\\"] - 2):\\n self.min_dist(\\n variables_dict[\\\"add_v_t\\\"],\\n variables_dict[\\\"add_s_t\\\"],\\n flag,\\n speed,\\n dist,\\n variables_dict[\\\"filter_speed\\\"],\\n )\\n\\n state = np.hstack((\\n variables_dict[\\\"s_t\\\"],\\n variables_dict[\\\"v_t\\\"],\\n variables_dict[\\\"add_s_t\\\"],\\n variables_dict[\\\"add_v_t\\\"],\\n variables_dict[\\\"flag_t\\\"],\\n ))\\n return state\",\n \"def forward(self, state):\\n output = self.conv_layers(state)\\n output = output.view(-1, 7*7*64)\\n output = self.fc(output)\\n return output\",\n \"def forward(self, state):\\n '''\\n state = F.relu(self.conv1(state))\\n state = F.relu(self.conv2(state))\\n state = F.relu(self.conv3(state))\\n state = F.relu(self.fc1(state))\\n \\n action = F.relu(self.fc2(state))\\n \\n return action\\n '''\\n \\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n x = self.fc3(x)\\n \\n return x\",\n \"def _reduce_states(self, fw_st, bw_st):\\n hidden_dim = self._hps.hidden_dim\\n with tf.variable_scope('reduce_final_st'):\\n\\n # Define weights and biases to reduce the cell and reduce the state\\n w_reduce_c = tf.get_variable('w_reduce_c', [hidden_dim * 2, hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\\n w_reduce_h = tf.get_variable('w_reduce_h', [hidden_dim * 2, hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\\n bias_reduce_c = tf.get_variable('bias_reduce_c', [hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\\n bias_reduce_h = tf.get_variable('bias_reduce_h', [hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\\n\\n # Apply linear layer\\n old_c = tf.concat(axis=1, values=[fw_st.c, bw_st.c]) # Concatenation of fw and bw cell\\n old_h = tf.concat(axis=1, values=[fw_st.h, bw_st.h]) # Concatenation of fw and bw state\\n new_c = tf.nn.relu(tf.matmul(old_c, w_reduce_c) + bias_reduce_c) # Get new cell from old cell\\n new_h = tf.nn.relu(tf.matmul(old_h, w_reduce_h) + bias_reduce_h) # Get new state from old state\\n return tf.contrib.rnn.LSTMStateTuple(new_c, new_h) # Return new cell and state\",\n \"def forward(self, state):\\n\\t\\tx = F.relu(self.fc1(state))\\n\\t\\tx = F.relu(self.fc2(x))\\n\\t\\tx = F.tanh(self.fc3(x)) # outputs are in the range [-1, 1]\\n\\n\\t\\treturn x\",\n \"def transition_up(self, x, filters, name):\\n with tf.name_scope(name):\\n x = tf.layers.conv2d_transpose(x,\\n filters=filters,\\n kernel_size=[3, 3],\\n strides=[2, 2],\\n padding='SAME',\\n activation=None,\\n kernel_initializer=tf.contrib.layers.xavier_initializer(),\\n name=name+'_trans_conv3x3')\\n\\n return x\",\n \"def forward(self, state):\\n x = self.nonlin(self.fc1(self.in_fn(state)))\\n x = self.drop_layer(x)\\n x = self.nonlin(self.fc2(x))\\n x = self.drop_layer(x)\\n return self.fc3(x)\",\n \"def state_action(self, s, a):\\r\\n s_x, s_y = s[0][0], s[0][1]\\r\\n s_vx, s_vy = s[1][0], s[1][1]\\r\\n a_x, a_y = a[0] + 1, a[1] + 1\\r\\n s_a = (s_x, s_y, s_vx, s_vy, a_x, a_y)\\r\\n\\r\\n return s_a\",\n \"def forward(self, state):\\n x = F.relu(self.linear1(state))\\n x = F.relu(self.linear2(x))\\n x = self.linear3(x)\\n return x\",\n \"def convert_state(self, x, v):\\n \\n\\n #print(self.offset[0] * self.tiling_displacement[len(self.tiling_displacement)-1][0] / self.tile_width[0])\\n\\n #state = 0\\n n_features = self.total_tiles[0] * self.total_tiles[1] * self.n_tilings\\n state = np.zeros(n_features, dtype=int)\\n print(np.shape(state))\\n\\n for i in range(self.n_tilings):\\n # Finds the index of the tile in both dimensions\\n x_tile = (x - self.offset[0] * self.tiling_displacement[i][0] - self.x_range[0] + self.extra_tiles[0] * self.tile_width[0]) // self.tile_width[0]\\n v_tile = (v - self.offset[1] * self.tiling_displacement[i][1] - self.v_range[0] + self.extra_tiles[1] * self.tile_width[1]) // self.tile_width[1]\\n \\n #x_tile = (x - self.offset[0] * self.tiling_displacement[i][0] - self.x_range[0] + self.extra_tiles[0] * self.tile_width[0]) // self.tile_width[0]\\n #v_tile = (v - self.offset[1] * self.tiling_displacement[i][1] - self.v_range[0] + self.extra_tiles[1] * self.tile_width[1]) // self.tile_width[1]\\n\\n index = int(i * (self.total_tiles[0]*self.total_tiles[1]) + x_tile * self.total_tiles[0] + v_tile)\\n print(\\\"INDEX\\\" , index)\\n state[index] = 1\\n\\n\\n\\n\\n \\\"\\\"\\\"\\n # adds the correct bit (corresponding to the state of the tiling) to the state integer\\n state += 2 ** (i * self.n_tiles**2 + x_tile * self.n_tiles + v_tile)\\n \\\"\\\"\\\"\\n print (\\\"Tiling %s: (%s,%s)\\\" % (i, x_tile, v_tile))\\n\\n return state\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n #return self.fc3(x)\\n return F.softmax(self.fc3(x), dim=1)\",\n \"def _normalizeState(self, Z : vector) -> vector:\\n return Z * self.D\",\n \"def _preprocess_state(self, state):\\n\\n def normalize_matrix(matrix, min_val, max_val):\\n \\\"\\\"\\\"normalizes all elements in matrix to be between min val and max val\\n \\\"\\\"\\\"\\n return (max_val - min_val) * (matrix - np.min(matrix)) / (np.max(matrix) - np.min(matrix)) + min_val\\n\\n A, b, c0, cuts_a, cuts_b = state\\n\\n min_lhs = np.min([np.min(A), np.min(cuts_a)])\\n max_lhs = np.max([np.max(A), np.max(cuts_a)])\\n min_rhs = np.min([np.min(b), np.min(cuts_b)])\\n max_rhs = np.max([np.max(b), np.max(cuts_b)])\\n\\n A = normalize_matrix(A, min_lhs, max_lhs)\\n cuts_a = normalize_matrix(cuts_a, min_lhs, max_lhs)\\n\\n b = normalize_matrix(b, min_rhs, max_rhs)\\n cuts_b = normalize_matrix(cuts_b, min_rhs, max_rhs)\\n\\n processed_state = (A, b, c0, cuts_a, cuts_b)\\n condensed_state = self._condense_state(processed_state)\\n return condensed_state\",\n \"def forward(self, state: list) -> list:\\n x = F.relu(self.fc1_layer(state))\\n x = F.relu(self.fc2_layer(x))\\n x = F.tanh(self.fc3_layer(x))\\n\\n return x\",\n \"def sim_to_state(self):\\n # As mentioned earlier, we only need z-axis variables.\\n # This will keep our state nice and small.\\n return [\\n self.sim.pose[Z_AXIS],\\n self.sim.v[Z_AXIS],\\n self.sim.linear_accel[Z_AXIS]\\n ]\",\n \"def make_state_appliable_4ch(state):\\n size = len(state)\\n st_appl = np.zeros((size,)*4, dtype=complex)\\n for p1 in range(size):\\n for p2 in range(size):\\n for p3 in range(size):\\n for p4 in range(size):\\n st_appl[p1, p2, p3, p4] = state[p1, p2, p3, p4] * sqrt(factorial(p1) * factorial(p2) * factorial(p3) * factorial(p4))\\n return st_appl\",\n \"def normalize_state(self):\\n self.state = 2 * (self.state - 0.5)\",\n \"def split_state(U):\\n return U[0], U[1], U[2], U[3], U[4], U[5], r(U)\",\n \"def forward(self, state, action):\\n s1 = F.relu(self.fcs1(state))\\n s2 = F.relu(self.fcs2(s1))\\n\\n a1 = F.relu(self.fca1(action))\\n\\n x = torch.cat((s2, a1), dim=1)\\n x = F.relu(self.fc2(x))\\n x = self.fc3(x)\\n\\n return x\",\n \"def synchronize_state(self):\\n theta = self.unicycle_state[:,2]\\n v = self.unicycle_state[:,3]\\n self.position[:, :2] = self.unicycle_state[:,:2]\\n self.orientation[:,2] = theta\\n vx = v * np.cos(theta)\\n vy = v * np.sin(theta)\\n\\n self.velocity[:, 0] = vx\\n self.velocity[:, 1] = vy\\n\\n self.angular_velocity[:, 2] = self.unicycle_state[:, 4]\",\n \"def forward(self, state):\\n x = F.relu(self.input(state))\\n for layer in self.layers:\\n x = F.relu(layer(x))\\n if self.duel:\\n # Value function estimator\\n val = F.relu(self.val_fc_input(x))\\n val = self.val_fc_output(val)\\n # Advantage function estimator\\n adv = F.relu(self.adv_fc_input(x))\\n adv = self.adv_fc_output(adv)\\n # Subtract mean so that V and A are uniquely identifiable for a given Q\\n return val + adv - adv.mean(1).unsqueeze(1).expand(state.size(0), self.action_size)\\n else:\\n return self.output(x)\",\n \"def _conformState(self, state : vector) -> vector:\\n '''@Z : vector'''\\n \\n return AbstractRecursiveFilter.conformState(self.order, state)\",\n \"def call(self, state):\\n x = tf.cast(state, tf.float32)\\n x = self.flatten(x)\\n x -= self.min_vals\\n x /= self.max_vals - self.min_vals\\n x = 2.0 * x - 1.0 # Rescale in range [-1, 1].\\n x = self.dense1(x)\\n x = self.dense2(x)\\n x = self.last_layer(x)\\n return x\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n return F.tanh(self.fc3(x))\",\n \"def forward(self, state):\\n x = state\\n for layer in self.linear_layers[:-1]:\\n x = F.relu(layer(x))\\n x = self.linear_layers[-1](x)\\n return x\",\n \"def transl(x, y, z):\\n displace_vector = [[x],\\n [y],\\n [z]]\\n return np.matrix(displace_vector)\",\n \"def gather_state(self):\\n self.x[0,0:self.n] = self.m[0:self.n]\\n self.x[1,0:self.n] = self.r[0:self.n,0]\\n self.x[2,0:self.n] = self.r[0:self.n,1]\\n self.x[3,0:self.n] = self.r[0:self.n,2]\\n self.x[4,0:self.n] = self.v[0:self.n,0]\\n self.x[5,0:self.n] = self.v[0:self.n,1]\\n self.x[6,0:self.n] = self.v[0:self.n,2]\\n return(self.x)\",\n \"def simplify(self):\\n state_copy = copy.deepcopy(self)\\n state_copy.space.spacecrafts = [state_copy.spacecraft] + state_copy.space.close_spacecrafts_to(\\n state_copy.spacecraft, self.PERCEPTION_DISTANCE)\\n\\n return state_copy\",\n \"def forward(self, x):\\n x = F.relu(self.affine1(x))\\n x = F.relu(self.affine2(x))\\n x = F.relu(self.affine3(x))\\n x = F.relu(self.affine4(x))\\n x = F.relu(self.affine5(x))\\n\\n # actor: choses action to take from state s_t \\n # by returning probability of each action\\n action_prob = F.softplus(self.action_head(x)).reshape(-1) + 1e-20\\n\\n # critic: evaluates being in the state s_t\\n state_values = self.value_head(x)\\n\\n # return values for both actor and critic as a tuple of 2 values:\\n # 1. a list with the probability of each action over the action space\\n # 2. the value from state s_t \\n return action_prob, state_values\",\n \"def forward(self, x):\\n x=T.div(x,255.0)\\n \\n #print(state[20:,20:,0])\\n #print(state[:,0,:,:])\\n conv1 = F.relu(self.conv1(x))\\n conv2 = F.relu(self.conv2(conv1))\\n conv3 = F.relu(self.conv3(conv2))\\n ###\\n conv_state = conv3.view(conv3.size()[0], -1)\\n flat1 = F.relu(self.fc1(conv_state))\\n flat2 = F.relu(self.fc2(flat1))\\n\\n V = self.V(flat2)\\n A = self.A(flat2)\\n\\n return V, A\\n return x\",\n \"def getTranslation(fracs):\\n \\n \\n \\n # Determine whether the shift needs to be from inf to 0 \\n # or from -inf to 0\\n \\n # Along all x fractionals\\n if abs(max(fracs[0]))>=abs(min(fracs[0])):\\n minX = min([x for x in fracs[0] if x>0])\\n else:\\n minX = min([x for x in fracs[0] if x<0])\\n \\n # Along all y fractionals\\n if abs(max(fracs[1]))>=abs(min(fracs[1])):\\n minY = min([x for x in fracs[1] if x>0])\\n else:\\n minY = min([x for x in fracs[1] if x<0])\\n \\n # Along all z fractionals\\n # Need to consider all atoms lying in a single\\n # plane (e.g. graphene), thus the final \\\"else\\\"\\n # statement\\n if abs(max(fracs[2]))>abs(min(fracs[2])):\\n minZ = min([x for x in fracs[2] if x>0])\\n elif abs(max(fracs[2]))<abs(min(fracs[2])):\\n minZ = min([x for x in fracs[2] if x<0])\\n else:\\n minZ = max(fracs[2])\\n\\n shift_vector = np.array([minX,minY,minZ])\\n \\n return(shift_vector)\",\n \"def forward(self, state, action):\\n s1 = F.relu(self.fcs1(state))\\n a1 = F.relu(self.fca1(action))\\n x = torch.cat((s1, a1), dim=1)\\n\\n x = self.fc3(x)\\n\\n return x\",\n \"def forward(self, state):#forward pass\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n return torch.tanh(self.fc3(x))\",\n \"def gather_state(self):\\n self.x[0,0:self.n] = self.m[0:self.n]\\n self.x[1,0:self.n] = self.r[0:self.n,0]\\n self.x[2,0:self.n] = self.r[0:self.n,1]\\n self.x[3,0:self.n] = self.r[0:self.n,2]\\n self.x[4,0:self.n] = self.v[0:self.n,0]\\n self.x[5,0:self.n] = self.v[0:self.n,1]\\n self.x[6,0:self.n] = self.v[0:self.n,2]\\n self.x[7,0:self.n] = self.rho[0:self.n]\\n self.x[8,0:self.n] = self.p[0:self.n]\\n # added second component of pressure\\n self.x[9,0:self.n] = self.pco[0:self.n]\\n self.x[10,0:self.n] = self.u[0:self.n]\\n return(self.x)\",\n \"def states(grid, dt,\\n u, v,\\n ldelta_ux, ldelta_vx,\\n ldelta_uy, ldelta_vy,\\n gradp_x, gradp_y,\\n u_MAC, v_MAC):\\n\\n # get the full u and v left and right states (including transverse\\n # terms) on both the x- and y-interfaces\\n u_xl, u_xr, u_yl, u_yr, v_xl, v_xr, v_yl, v_yr = get_interface_states(grid, dt,\\n u, v,\\n ldelta_ux, ldelta_vx,\\n ldelta_uy, ldelta_vy,\\n gradp_x, gradp_y)\\n\\n # upwind using the MAC velocity to determine which state exists on\\n # the interface\\n u_xint = burgers_interface.upwind(grid, u_xl, u_xr, u_MAC)\\n v_xint = burgers_interface.upwind(grid, v_xl, v_xr, u_MAC)\\n u_yint = burgers_interface.upwind(grid, u_yl, u_yr, v_MAC)\\n v_yint = burgers_interface.upwind(grid, v_yl, v_yr, v_MAC)\\n\\n return u_xint, v_xint, u_yint, v_yint\",\n \"def forward(self, state):\\n \\n x = F.relu(self.fc1(state)) \\n x = F.relu(self.fc2(x)) \\n x = F.tanh(self.fc3(x)) \\n \\n \\n ####x = F.relu(self.bn1(self.fc1(state)))\\n ####x = F.relu(self.bn2(self.fc2(x)))\\n ####x = torch.tanh(self.bn3(self.fc3(x)))\\n ##x = torch.tanh(self.fc3(x))\\n\\n return x\",\n \"def finnLaplace(u):\\n laplace=u[0:-2, 1:-1] + u[2:, 1:-1] + u[1:-1, 0:-2] + u[1:-1, 2:] - 4 * u[1:-1, 1:-1]\\n return laplace\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n x = F.relu(self.fc3(x))\\n x = F.relu(self.fc4(x))\\n\\n return F.tanh(self.fc5(x))\",\n \"def strain_rates(\\n u1, # velocity-1 component\\n u2, # velocity-2 component\\n u3, # velocity-3 component\\n h = False, # spatial step size\\n dim = False): # number of spatial steps\\n #---------------------------------------------------------------------#\\n # Default settings #\\n #---------------------------------------------------------------------#\\n if h is False:\\n pi = np.pi\\n N = 64\\n h = (2.0*pi)/N\\n if dim is False:\\n dim = 64\\n #---------------------------------------------------------------------#\\n # Strain rates #\\n #---------------------------------------------------------------------#\\n St = np.empty((6, dim, dim, dim))\\n St[0] = np.gradient(u1, h, edge_order=2)[2] # S11\\n St[1] = 0.5*(np.gradient(u1, h, edge_order=2)[1] +\\\\\\n np.gradient(u2, h, edge_order=2)[2]) # S12\\n St[2] = 0.5*(np.gradient(u1, h, edge_order=2)[0] +\\\\\\n np.gradient(u3, h, edge_order=2)[2]) # S13\\n St[3] = np.gradient(u2, h, edge_order=2)[1] # S22\\n St[4] = 0.5*(np.gradient(u2, h, edge_order=2)[0] +\\\\\\n np.gradient(u3, h, edge_order=2)[1]) # S23\\n St[5] = (np.gradient(u3, h, edge_order=2)[0]) # S33\\n\\n return St\",\n \"def __update_state(self, x0, u):\\n N = int(len(u) / 2)\\n lower_triangular_ones_matrix = np.tril(np.ones((N, N)))\\n kron = np.kron(lower_triangular_ones_matrix, np.eye(2))\\n\\n new_state = np.vstack([np.eye(2)] * int(N)) @ x0 + kron @ u * self.nmpc_timestep\\n\\n return new_state\",\n \"def forward(self, state):\\n x = self.fc(state)\\n return x\",\n \"def _build_gains(self):\\n flip_nibbles = True\\n\\n p = (100, 4, flip_nibbles)\\n d = (1000, 4, flip_nibbles)\\n i = (0, 4, flip_nibbles)\\n il = (0, 4, flip_nibbles)\\n ol = (255, 2)\\n cl = (0, 2)\\n el = (4000, 4, flip_nibbles)\\n sr = (1, 2)\\n db = (1, 2)\\n sm = (1, 2)\\n gains = self._build_hexstr(p, d, i, il, ol, cl, el, sr, db, sm)\\n return \\\"F6{}\\\".format(gains)\",\n \"def _condense_state(self, s):\\n def append_col(A, b):\\n expanded_b = np.expand_dims(b, 1)\\n return np.append(A, expanded_b, 1)\\n\\n A, b, c0, cuts_a, cuts_b = s\\n Ab = append_col(A, b)\\n cuts = append_col(cuts_a, cuts_b)\\n return (Ab, c0, cuts)\",\n \"def fL():\\n for n in b.allNodes():\\n n.autoplace()\",\n \"def forward(self, state):\\n x = state.unsqueeze(1)\\n x = F.relu(self.cnl1(x))\\n x = F.relu(self.cnl2(x))\\n x = F.relu(self.cnl3(x))\\n x = x.view(x.shape[0], -1) # flatten\\n x = F.relu(self.dense1(x))\\n x = self.out(x)\\n return x\",\n \"def preprocess_state(states):\\n states_pp = np.copy(states)\\n \\n # Paint black over the sum of rewards\\n states_pp[:, 85:, :15] = [0.0, 0.0, 0.0]\\n\\n # Replace the colors defined bellow\\n def replace_color(old_color, new_color):\\n mask = np.all(states_pp == old_color, axis=3)\\n states_pp[mask] = new_color\\n\\n # Black bar\\n replace_color([000., 000., 000.], [120.0, 120.0, 120.0])\\n\\n # Road\\n #new_road_color = [255.0, 255.0, 255.0]\\n new_road_color = [102.0, 102.0, 102.0]\\n replace_color([102., 102., 102.], new_road_color)\\n replace_color([105., 105., 105.], new_road_color)\\n replace_color([107., 107., 107.], new_road_color)\\n # Curbs\\n replace_color([255., 000., 000.], new_road_color)\\n replace_color([255., 255., 255.], new_road_color)\\n # Grass\\n #new_grass_color = [0.0, 0.0, 0.0]\\n new_grass_color = [102., 229., 102.]\\n replace_color([102., 229., 102.], new_grass_color)\\n replace_color([102., 204., 102.], new_grass_color)\\n\\n # Float RGB represenattion\\n states_pp /= 255.\\n\\n # Converting to gray scale\\n states_pp = rgb2gray(states_pp)\\n\\n return states_pp\",\n \"def stateToCode(self, state):\\n\\n multiplier = 1\\n code = \\\"\\\"\\n for i in range(self.num_joints-1, -1, -1):\\n num_angles = len(self.angles[i])\\n code += str(int((state / multiplier ) % num_angles))\\n multiplier *= len(self.angles[i])\\n\\n # Return the reversed code\\n return code [::-1]\",\n \"def _fuse_back(self):\\n with tf.variable_scope('fusion'):\\n #self.fuse_p_encodes, _ = rnn('lstm', self.match_p_encodes, self.p_length,\\n # self.hidden_size, layer_num=1)\\n self.fuse_p_encodes = tc.layers.fully_connected(self.match_p_encodes, self.hidden_size)\\n if self.use_dropout:\\n self.fuse_p_encodes = tf.nn.dropout(self.fuse_p_encodes, self.dropout_keep_prob)\",\n \"def _preprocess_state(self, state):\\r\\n if np.isinf(self.observation_space.low).any() or np.isinf(self.observation_space.high).any(): return state\\r\\n return (state - self.observation_space.low) /(self.observation_space.high)\",\n \"def forward(self, x):\\n x = self.arch(x)\\n x = self.swish(x)\\n x_out = self.arch._fcOut(x)\\n return x_out\",\n \"def down_optimized_block(x, out_channels, name, act=tf.nn.relu):\\n with tf.variable_scope(name):\\n x_0 = x\\n x = ops.snconv2d(x, out_channels, 3, 3, 1, 1, name='sn_conv1')\\n x = act(x)\\n x = ops.snconv2d(x, out_channels, 3, 3, 1, 1, name='sn_conv2')\\n x = dsample(x)\\n x_0 = dsample(x_0)\\n x_0 = ops.snconv2d(x_0, out_channels, 1, 1, 1, 1, name='sn_conv3')\\n return x + x_0\",\n \"def featurize_state(self,state):\\r\\n try:\\r\\n state=(state[0].item(),state[1].item())\\r\\n except:\\r\\n pass\\r\\n \\r\\n scaled_x = np.divide(np.add(state[0],-self.x_mean),np.add(self.x_max,-self.x_min))\\r\\n scaled_vx = np.divide(np.add(state[1],-self.vx_mean),np.add(self.vx_max,-self.vx_min))\\r\\n return [scaled_x,scaled_vx]\",\n \"def unfold_params(params, nstates=2):\\n init = params[:nstates]\\n # emiss = params[nstates:nstates * 5].reshape((nstates, 4))\\n trans = params[nstates:(nstates * (nstates + 1))].reshape((nstates, nstates))\\n scale = params[-1]\\n return init, trans, scale\",\n \"def rollout(self, us):\\n xs = [self.initialState]\\n for m, d, u in zip(self.runningModels, self.runningDatas, us):\\n xs.append(m.calc(d, xs[-1], u)[0].copy())\\n return xs\",\n \"def forward(self, state, action) -> float:\\n xs = F.relu(self.fcs1_layer(state))\\n x = torch.cat((xs, action), dim=1)\\n x = F.relu(self.fc2_layer(x))\\n x = self.dropout(x)\\n x = self.fc3_layer(x)\\n\\n return x\",\n \"def transition_down(self, x, training, filters, name):\\n with tf.name_scope(name):\\n x = self.batch_norm(x, training, name=name+'_bn')\\n x = tf.nn.relu(x, name=name+'relu')\\n x = tf.layers.conv2d(x,\\n filters=filters,\\n kernel_size=[1, 1],\\n strides=[1, 1],\\n padding='SAME',\\n dilation_rate=[1, 1],\\n activation=None,\\n kernel_initializer=tf.contrib.layers.xavier_initializer(),\\n name=name+'_conv1x1')\\n x = tf.layers.dropout(x, rate=0.2, training=training, name=name+'_dropout')\\n x = tf.nn.max_pool(x, [1, 4, 4, 1], [1, 2, 2, 1], padding='SAME', name=name+'_maxpool2x2')\\n\\n return x\",\n \"def state_eq(t, x, u, tu):\\n # u = u[0, :]\\n u_interp = np.interp(t, tu, u[0, :])\\n # print(f'u: {u}')\\n return np.vstack((x[1], -x[1] + u_interp))\",\n \"def forward(self, s):\\n \\n fc1_out = self.fc1(s)\\n fc1_act = F.dropout(F.relu(fc1_out), p=0.3)\\n fc2_out = self.fc2(fc1_act)\\n fc2_act = F.dropout(F.relu(fc2_out), p=0.3)\\n fc3_out = self.fc3(fc2_act)\\n output = F.sigmoid(fc3_out) # output size = batch_size x 28\\n\\n return output\",\n \"def sparsify(self, state):\\n print(\\\"running L0 projection-based (unstructured) sparsification. \\\\n \\\")\\n model = state.model\\n masks = self.get_masks(model)\\n self.apply_masks(model, masks)\",\n \"def state_transition(self):\\n self.x = np.dot(self.F, self.x)\\n self.x_noisy = noise_fun(np.dot(self.F, self.x_noisy), self.Q)\\n return self.x\",\n \"def _apply_cz(self, state, axes, **kwargs):\\n ndim = self._ndim(state)\\n sl_0 = _get_slice(0, axes[0], ndim)\\n sl_1 = _get_slice(1, axes[0], ndim)\\n\\n if axes[1] > axes[0]:\\n target_axes = [axes[1] - 1]\\n else:\\n target_axes = [axes[1]]\\n\\n state_z = self._apply_z(state[sl_1], axes=target_axes)\\n return self._stack([state[sl_0], state_z], axis=axes[0])\",\n \"def computePosition(self, state):\\n d = 0\\n if state[5] == \\\"East\\\":\\n d = 0\\n elif state[5] == \\\"West\\\":\\n d = 1\\n elif state[5] == \\\"North\\\":\\n d = 2\\n else:\\n d = 3\\n return state[0]*64+state[1]*32+state[2]*16+state[3]*8+state[4]*4+d\",\n \"def forward(self, state):\\n x = f.relu(self.fc1(state))\\n x = f.relu(self.fc2(x))\\n return torch.tanh(self.fc3(x))\",\n \"def forward(self, state, action):\\n xs = F.relu(self.fcs1(state))\\n x = torch.cat((xs, action), dim=1)\\n x = F.relu(self.fc2(x))\\n return self.fc3(x)\",\n \"def test_displace_xyz(self):\\n xyz = {'symbols': ('N', 'H', 'H', 'N', 'H', 'H', 'N', 'H'), 'isotopes': (14, 1, 1, 14, 1, 1, 14, 1),\\n 'coords': ((-0.447353, 0.680147, -0.090895), (-0.451171, 1.142121, 0.814701),\\n (0.674665, 0.380874, -0.232312), (-1.228559, -0.471121, -0.003769),\\n (-1.815912, -0.503291, 0.815499), (-1.782278, -0.570663, -0.841674),\\n (1.909708, -0.148579, -0.070033), (1.740013, -0.849123, 0.669738))}\\n displacement = np.array([[-0.03, -0.02, -0.0], [0.04, -0.08, 0.05], [0.92, -0.34, 0.08], [0.0, 0.04, 0.0],\\n [0.0, -0.05, 0.01], [0.09, -0.09, -0.04], [-0.05, 0.02, -0.01], [0.0, 0.03, -0.01]],\\n np.float64)\\n xyz_1, xyz_2 = converter.displace_xyz(xyz=xyz, displacement=displacement)\\n expected_xyz_1 = {'symbols': ('N', 'H', 'H', 'N', 'H', 'H', 'N', 'H'), 'isotopes': (14, 1, 1, 14, 1, 1, 14, 1),\\n 'coords': ((-0.4754185110901118, 0.6614366592732588, -0.090895),\\n (-0.44113195107970876, 1.1220429021594176, 0.827249811150364),\\n (0.9055631251666977, 0.29554208417752476, -0.2122339021594176),\\n (-1.228559, -0.43370031854651764, -0.003769),\\n (-1.815912, -0.515839811150364, 0.8180087622300728),\\n (-1.7596901399293448, -0.5932508600706552, -0.8517130489202912),\\n (1.862932148183147, -0.1298686592732588, -0.07938817036337059),\\n (1.740013, -0.8415937133097816, 0.6672282377699272))}\\n expected_xyz_2 = {'symbols': ('N', 'H', 'H', 'N', 'H', 'H', 'N', 'H'), 'isotopes': (14, 1, 1, 14, 1, 1, 14, 1),\\n 'coords': ((-0.4192874889098882, 0.6988573407267411, -0.090895),\\n (-0.4612100489202912, 1.1621990978405823, 0.802152188849636),\\n (0.44376687483330224, 0.4662059158224752, -0.2523900978405824),\\n (-1.228559, -0.5085416814534824, -0.003769),\\n (-1.815912, -0.49074218884963605, 0.8129892377699272),\\n (-1.8048658600706553, -0.5480751399293449, -0.8316349510797089),\\n (1.956483851816853, -0.16728934072674118, -0.060677829636629405),\\n (1.740013, -0.8566522866902183, 0.6722477622300729))}\\n self.assertEqual(xyz_1, expected_xyz_1)\\n self.assertEqual(xyz_2, expected_xyz_2)\\n\\n xyz_1, xyz_2 = converter.displace_xyz(xyz=xyz, displacement=displacement, amplitude=0.5)\\n expected_xyz_1 = {'symbols': ('N', 'H', 'H', 'N', 'H', 'H', 'N', 'H'), 'isotopes': (14, 1, 1, 14, 1, 1, 14, 1),\\n 'coords': ((-0.5034840221802236, 0.6427263185465175, -0.090895),\\n (-0.4310929021594176, 1.101964804318835, 0.839798622300728),\\n (1.1364612503333955, 0.2102101683550495, -0.19215580431883517),\\n (-1.228559, -0.39627963709303526, -0.003769),\\n (-1.815912, -0.528388622300728, 0.8205185244601456),\\n (-1.7371022798586897, -0.6158387201413105, -0.8617520978405825),\\n (1.816156296366294, -0.11115831854651761, -0.08874334072674119),\\n (1.740013, -0.8340644266195631, 0.6647184755398544))}\\n expected_xyz_2 = {'symbols': ('N', 'H', 'H', 'N', 'H', 'H', 'N', 'H'), 'isotopes': (14, 1, 1, 14, 1, 1, 14, 1),\\n 'coords': ((-0.3912219778197764, 0.7175676814534824, -0.090895),\\n (-0.4712490978405824, 1.1822771956811648, 0.789603377699272),\\n (0.21286874966660452, 0.5515378316449505, -0.2724681956811648),\\n (-1.228559, -0.5459623629069648, -0.003769),\\n (-1.815912, -0.47819337769927206, 0.8104794755398543),\\n (-1.8274537201413104, -0.5254872798586896, -0.8215959021594176),\\n (2.003259703633706, -0.18599968145348236, -0.05132265927325881),\\n (1.740013, -0.8641815733804368, 0.6747575244601457))}\\n self.assertEqual(xyz_1, expected_xyz_1)\\n self.assertEqual(xyz_2, expected_xyz_2)\",\n \"def displacement_from_surface_loads(self, loads: {dict, Loads, typing.Sequence[np.ndarray]},\\n grid_spacing: {typing.Sequence[float], float},\\n deflections: str = 'xyz',\\n current_state: dict = None,\\n span: typing.Optional[typing.Sequence[int]] = None,\\n simple: bool = False) -> Displacements:\\n if not isinstance(loads, Loads):\\n if isinstance(loads, dict):\\n try:\\n loads = {key: value for key, value in loads if value is not None}\\n loads = Loads(**{key: np.array(value, dtype=float) for key, value in loads.items()})\\n except TypeError:\\n raise ValueError(\\\"Unrecognised keys in loads dict, allowed keys are x,y,z found keys are: \\\"\\n f\\\"{', '.join(loads.keys())}\\\")\\n elif isinstance(loads, Sequence):\\n try:\\n loads = Loads(*[np.array(ld, dtype=float) if ld is not None else None for ld in loads])\\n except TypeError:\\n raise ValueError(f\\\"length of the loads sequence must be 3, length is {len(loads)}\\\")\\n\\n valid_directions = 'xyz'\\n load_directions = [vd for vd, el in zip(valid_directions, loads) if el is not None]\\n\\n shapes = [ld.shape for ld in loads if ld is not None]\\n\\n if len(set(shapes)) != 1:\\n raise ValueError(\\\"Load vectors are not all the same shape\\\")\\n\\n if span is None:\\n span = shapes[0]\\n\\n if not isinstance(grid_spacing, Sequence):\\n grid_spacing = (grid_spacing,) * 2\\n elif len(grid_spacing) == 1:\\n grid_spacing *= 2\\n elif len(grid_spacing) > 2:\\n raise ValueError(\\\"Too many elements in grid_spacing sequence, should be 1 or 2\\\")\\n\\n # u_a=ifft(fft(K_ab) * fft(sigma_b))\\n\\n if simple:\\n comp_names = [ld * 2 for ld in load_directions] # ['xx', 'yy'] etc.\\n else:\\n comp_names = list(product(deflections, load_directions))\\n comp_names = [a + b for a, b in comp_names] # 'xy'...\\n\\n # get the influence matrix components from the class methods\\n\\n components = self.influence_matrix(span=span, grid_spacing=grid_spacing, components=comp_names)\\n displacements = _solve_im_loading(loads, components)\\n return displacements\",\n \"def forward(self, state, action):\\n\\t\\tx = F.relu(self.fc1(state))\\n\\t\\tx = F.relu(self.fc2(torch.cat([x, action], dim=1))) # add action too for the mapping\\n\\t\\tx = F.relu(self.fc3(x))\\n\\n\\t\\treturn x\",\n \"def Lorenz(s):\\n x = s[0]\\n y = s[1]\\n z = s[2]\\n \\n # constants for the equations\\n sigma = 10.0\\n rho = 28.0\\n beta = 8.0/3.0\\n \\n # Return the state derivatives.\\n return [sigma * (y-x), (rho-z)*x -y, x*y - beta*z]\",\n \"def affine_backward(dout, cache):\\n #raise NotImplementedError\\n #######################################################################\\n # #\\n # #\\n # TODO: YOUR CODE HERE #\\n # #\\n # #\\n #######################################################################\\n x,w,b=cache\\n \\n dx=np.dot(dout,(w.transpose()))\\n D=w.shape[0]\\n N=x.shape[0]\\n dw=np.dot(x.transpose(),dout)\\n db=np.dot(dout.transpose(),np.ones(N))\\n return dx,dw,db\",\n \"def forward(self, state, action):\\n xs = f.relu(self.fcs1(state))\\n x = torch.cat((xs, action), dim=1)\\n x = f.relu(self.fc2(x))\\n return self.fc3(x)\",\n \"def transition(name, year, grids, control):\\n ## SETUP -------------------------------------------------\\n cc = control['cohorts'][name + '_Control']\\n from_cohort_a0 = grids.area[name + '--0', year]\\n from_cohort = grids.area[name, year]\\n transitions_to = cc['transitions_to']\\n to_cohort_a0 = grids.area[transitions_to + '--0', year]\\n to_cohort = grids.area[transitions_to + '--0', year]\\n ice_slope = \\\\\\n grids.ice.get_ice_slope_grid( name )\\\\\\n .reshape(grids.shape).astype(np.float32)\\n ALD, PL = grids.ald['ALD', year], grids.ald[name ,year] \\n AOI = grids.area.area_of_interest()\\n POIn = grids.poi[name, year]\\n POInm1 = grids.poi[name, year-1]\\n drainage = grids.drainage.grid.reshape(grids.shape)\\n above_idx = drainage == 'above'\\n porosity = grids.ald.porosity[name]\\n\\n max_rot = cc['max_terrain_transition']\\n\\n if cc['POI_Function'] == 'Sigmoid2':\\n params = np.array([\\n cc['Parameters']['above']['sigmoid2_K'],\\n cc['Parameters']['above']['sigmoid2_C'],\\n cc['Parameters']['above']['sigmoid2_A'],\\n cc['Parameters']['above']['sigmoid2_B'],\\n cc['Parameters']['below']['sigmoid2_K'],\\n cc['Parameters']['below']['sigmoid2_C'],\\n cc['Parameters']['below']['sigmoid2_A'],\\n cc['Parameters']['below']['sigmoid2_B'],\\n ]).astype(np.float32)\\n poi_func = calc_new_sig2_poi\\n elif cc['POI_Function'] == 'Sigmoid':\\n params = np.array([\\n cc['Parameters']['above']['sigmoid_A1'],\\n cc['Parameters']['above']['sigmoid_A2'],\\n cc['Parameters']['above']['sigmoid_x0'],\\n cc['Parameters']['above']['sigmoid_dx'],\\n cc['Parameters']['below']['sigmoid_A1'],\\n cc['Parameters']['below']['sigmoid_A2'],\\n cc['Parameters']['below']['sigmoid_x0'],\\n cc['Parameters']['below']['sigmoid_dx'],\\n ]).astype(np.float32)\\n poi_func = calc_new_sig_poi\\n elif cc['POI_Function'] == 'Hill':\\n params = np.array([\\n cc['Parameters']['above']['hill_B'],\\n cc['Parameters']['above']['hill_N'],\\n cc['Parameters']['below']['hill_B'],\\n cc['Parameters']['below']['hill_N'],\\n ]).astype(np.float32)\\n poi_func = calc_new_hill_poi\\n elif cc['POI_Function'] == 'Linear':\\n params = np.array([\\n cc['Parameters']['above']['linear_a'],\\n cc['Parameters']['above']['linear_b'],\\n cc['Parameters']['below']['linear_a'],\\n cc['Parameters']['below']['linear_b'],\\n ]).astype(np.float32)\\n poi_func = calc_linear_linear_poi\\n else:\\n raise KeyError(\\\"Not a valid function type\\\")\\n\\n present = from_cohort > 0\\n pl_breach = ALD >= PL\\n current_cell_mask = np.logical_and(np.logical_and(AOI, present), pl_breach)\\n\\n ## work ---------------\\n blocks = (32, 32)\\n threads = (\\n int(np.ceil(ALD.shape[0] / blocks[0])),\\n int(np.ceil(ALD.shape[1] / blocks[1]))\\n )\\n \\n X = np.zeros(ALD.shape)\\n calc_x[blocks, threads](X, ALD,PL)#.astype(np.float32)\\n\\n \\n new_poi = np.zeros(X.shape)\\n poi_func(new_poi, params, X, above_idx)\\n\\n\\n update_poi[blocks, threads](POIn, POInm1, new_poi, current_cell_mask)\\n \\n\\n # not cuda'd\\n ALD[current_cell_mask] = \\\\\\n ALD[current_cell_mask] + \\\\\\n (ALD[current_cell_mask] - PL[ current_cell_mask ] ) * porosity\\n\\n rate_of_transition = np.zeros(POIn.shape) \\n calc_rot[blocks, threads](rate_of_transition, POIn, ice_slope, max_rot)\\n\\n change = np.zeros(POIn.shape) \\n calc_change[blocks, threads](\\n change, rate_of_transition, from_cohort, present\\n )\\n \\n # not cuda'd\\n to_cohort_a0[present] = to_cohort[present] + change[present]\\n from_cohort_a0[present] = from_cohort[present] - change[present]\",\n \"def prepare_displaced_squeezed_state(self, alpha, r, phi, mode):\\n\\n self.circuit.squeeze(r, phi, mode)\\n self.circuit.displace(alpha, mode)\",\n \"def forward(self, state):\\n\\n # connect layers to each other and put relu activations between them\\n for layer in self.hidden_layers:\\n state = layer(state)\\n state = F.relu(state)\\n value = self.value_layer(state)\\n return value\",\n \"def _evolve_swap_element(self, state, element):\\n new_state = PhotonicState()\\n for in_modes, amp in state.items():\\n out_modes = []\\n for in_mode in in_modes:\\n offset_in_mode = in_mode - element.offset \\n if offset_in_mode in element.in_modes:\\n index = element.in_modes.index(offset_in_mode)\\n out_mode = element.out_modes[index] + element.offset\\n else:\\n out_mode = in_mode \\n out_modes.append(out_mode)\\n new_state[tuple(sorted(out_modes))] = amp \\n return new_state\",\n \"def res(self, t, y, yd, sw):\\n if sw[0]:\\n# print('state 1')\\n G = scipy.array([\\n [0, 1, 0],\\n [0, 0, 1]\\n ])\\n gvec = y[3:5]\\n elif sw[1]:\\n# print('state 2')\\n G = scipy.array([\\n [0, self.hS, 0],\\n [1, self.rS, 0]\\n ])\\n gvec = scipy.array([self.rS - self.r0 + self.hS * y[1],\\n y[5] + self.rS * y[6]])\\n elif sw[2]:\\n# print('state 3, phi_bp: ', y[7], 'res: ', self.hB * y[2] - self.lS - self.lG + self.lB + self.r0)\\n G = scipy.array([\\n [0, - self.hS, 0],\\n [1, self.rS, 0]\\n ])\\n gvec = scipy.array([self.rS - self.r0 - self.hS * y[1],\\n y[5] + self.rS * y[6]])\\n\\n ff = scipy.array([- (self.mS + self.mB) * self.g,\\n self.cp * (y[2] - y[1]) - self.mB * self.lS * self.g,\\n self.cp * (y[1] - y[2]) - self.mB * self.lG * self.g])\\n\\n res_1 = yd[0:5] - y[5:10]\\n res_2 = scipy.dot(self.M, yd[5:8]) - ff + scipy.dot(G.T, y[3:5])\\n res_3 = gvec\\n\\n return scipy.hstack((res_1, res_2, res_3)).flatten()\",\n \"def reconstructY(self, inputs):\\n if self.act_dec is None:\\n act_dec = lambda x: x\\n else:\\n act_dec = self.act_dec\\n return act_dec(self.decodeY(inputs))\",\n \"def _apply_state_vector(self, state, device_wires):\\n\\n # translate to wire labels used by device\\n device_wires = self.map_wires(device_wires)\\n dim = 2 ** len(device_wires)\\n\\n state = self._asarray(state, dtype=self.C_DTYPE)\\n batch_size = self._get_batch_size(state, (dim,), dim)\\n output_shape = [2] * self.num_wires\\n if batch_size is not None:\\n output_shape.insert(0, batch_size)\\n\\n if len(device_wires) == self.num_wires and sorted(device_wires) == device_wires:\\n # Initialize the entire device state with the input state\\n self._state = self._reshape(state, output_shape)\\n return\\n\\n # generate basis states on subset of qubits via the cartesian product\\n basis_states = np.array(list(itertools.product([0, 1], repeat=len(device_wires))))\\n\\n # get basis states to alter on full set of qubits\\n unravelled_indices = np.zeros((2 ** len(device_wires), self.num_wires), dtype=int)\\n unravelled_indices[:, device_wires] = basis_states\\n\\n # get indices for which the state is changed to input state vector elements\\n ravelled_indices = np.ravel_multi_index(unravelled_indices.T, [2] * self.num_wires)\\n\\n if batch_size is not None:\\n state = self._scatter(\\n (slice(None), ravelled_indices), state, [batch_size, 2**self.num_wires]\\n )\\n else:\\n state = self._scatter(ravelled_indices, state, [2**self.num_wires])\\n state = self._reshape(state, output_shape)\\n self._state = self._asarray(state, dtype=self.C_DTYPE)\",\n \"def transposition_string(self, state):\\n return state.__str__()\",\n \"def fromState(state):\",\n \"def transform_state(state):\\n # TODO: automate n_enemies calculation -> only valid fot n_enemies = n_friends\\n n_agents = len(state.agents)\\n n_enemies = n_agents // 2 # TODO: improve this\\n states_v = torch.zeros(n_agents, 5 + n_enemies) # 5 = x, y, alive, ammo, aim, enemy visible ? (x n_enemies)\\n for agent_idx, agent in enumerate(state.agents):\\n states_v[agent_idx, 0] = state.position[agent][0] # x\\n states_v[agent_idx, 1] = state.position[agent][1] # y\\n states_v[agent_idx, 2] = state.alive[agent]\\n states_v[agent_idx, 3] = state.ammo[agent] / 5 # args.ammo\\n states_v[agent_idx, 4] = -1 if state.aim[agent] is None else state.aim[agent].id\\n idx = 5\\n for other in state.agents:\\n if (agent, other) in state.visible:\\n states_v[agent_idx, idx] = int(state.visible[(agent, other)])\\n idx += 1\\n return states_v\",\n \"def forward(self, x):\\n out_conv1 = self.conv1(x)\\n out_conv2 = self.conv2(out_conv1)\\n out_conv3 = self.conv3(out_conv2)\\n out_conv4 = self.conv4(out_conv3)\\n out_conv5 = self.conv5(out_conv4)\\n out_conv6 = self.conv6(out_conv5)\\n out_conv7 = self.conv7(out_conv6)\\n\\n out_upconv7 = self.crop_top_left(self.upconv7(out_conv7), out_conv6)\\n concat7 = torch.cat((out_upconv7, out_conv6), 1)\\n out_iconv7 = self.iconv7(concat7)\\n\\n out_upconv6 = self.crop_top_left(self.upconv6(out_iconv7), out_conv5)\\n concat6 = torch.cat((out_upconv6, out_conv5), 1)\\n out_iconv6 = self.iconv6(concat6)\\n\\n out_upconv5 = self.crop_top_left(self.upconv5(out_iconv6), out_conv4)\\n concat5 = torch.cat((out_upconv5, out_conv4), 1)\\n out_iconv5 = self.iconv5(concat5)\\n\\n out_upconv4 = self.crop_top_left(self.upconv4(out_iconv5), out_conv3)\\n concat4 = torch.cat((out_upconv4, out_conv3), 1)\\n out_iconv4 = self.iconv4(concat4)\\n disp4 = self.alpha * self.predict_disp4(out_iconv4) + self.beta\\n\\n out_upconv3 = self.crop_top_left(self.upconv3(out_iconv4), out_conv2)\\n disp4_up = self.crop_top_left(torch.nn.functional.interpolate(disp4,\\n scale_factor=2,\\n mode='bilinear',\\n align_corners=False), out_conv2)\\n concat3 = torch.cat((out_upconv3, out_conv2, disp4_up), 1)\\n out_iconv3 = self.iconv3(concat3)\\n disp3 = self.alpha * self.predict_disp3(out_iconv3) + self.beta\\n\\n out_upconv2 = self.crop_top_left(self.upconv2(out_iconv3), out_conv1)\\n disp3_up = self.crop_top_left(torch.nn.functional.interpolate(disp3,\\n scale_factor=2,\\n mode='bilinear',\\n align_corners=False), out_conv1)\\n concat2 = torch.cat((out_upconv2, out_conv1, disp3_up), 1)\\n out_iconv2 = self.iconv2(concat2)\\n disp2 = self.alpha * self.predict_disp2(out_iconv2) + self.beta\\n\\n out_upconv1 = self.crop_top_left(self.upconv1(out_iconv2), x)\\n disp2_up = self.crop_top_left(torch.nn.functional.interpolate(disp2,\\n scale_factor=2,\\n mode='bilinear',\\n align_corners=False), x)\\n concat1 = torch.cat((out_upconv1, disp2_up), 1)\\n out_iconv1 = self.iconv1(concat1)\\n disp1 = self.alpha * self.predict_disp1(out_iconv1) + self.beta\\n\\n if self.training:\\n return disp1, disp2\\n else:\\n return disp1\",\n \"def obs2state(observation):\\n l1 = [val.tolist() for val in list(observation.values())]\\n l2 = []\\n for sublist in l1:\\n try:\\n l2.extend(sublist)\\n except:\\n l2.append(sublist)\\n return torch.FloatTensor(l2).view(1, -1)\",\n \"def backward(self, dY, dcn = None, cache=None):\\n if self.Reversed:\\n dY = dY[::-1,:,:]\\n\\n cache = self.Cache if cache is None else cache\\n y = cache['y']\\n C = cache['C']\\n S = cache['S']\\n Z = cache['Z']\\n c0 = cache['c0']\\n U = cache['U']\\n FN = cache['FN']\\n FNf = cache['FNf']\\n \\n n, b, _ = dY.shape\\n d = self.NC # hidden size\\n input_size = U.shape[2]-1-d # - C - bias\\n\\n # views\\n X = U[:,:,1:input_size+1]\\n Ff = FNf[:,:,:d]\\n F = FN[:,:,:d]\\n Nf = FNf[:,:,d:]\\n N = FN[:,:,d:]\\n \\n #Wxf = self.W[1:1+input_size,:d] # view\\n #Wxn = self.W[1:1+input_size,d:] # view\\n #Wsf = self.W[1+input_size:,:d] # view\\n #Wsn = self.W[1+input_size:,d:] # view\\n \\n Wx = self.W[1:1+input_size,:]\\n Ws = self.W[1+input_size:,:]\\n\\n gW = np.zeros(self.W.shape)\\n gV = np.zeros(self.V.shape)\\n gX = np.empty_like(X)\\n gS = np.empty_like(C)\\n \\n NmS = Nf - S\\n \\n #print \\\"S:\\\", S\\n #print \\\"N:\\\", N\\n\\n dZ = np.dot(dY, self.V.T) # [n, nb, nout] dot [nout, nin+1+nc] -> [n, nb, nin+1+nc]\\n dC = dcn if not dcn is None else np.zeros((b, d))\\n dFprime = Ff*(1.0-Ff)\\n dNprime = 1.0-Nf**2\\n\\n gFN = np.empty((n, b, d*2))\\n gFN[:,:,:d] = NmS*dFprime\\n gFN[:,:,d:] = Ff*dNprime\\n gF = gFN[:,:,:d]\\n gN = gFN[:,:,d:]\\n\\n gCgFNt = np.empty((b, d*2))\\n\\n #if dcn is not None: dC[n-1] += dcn.copy() # carry over gradients from later\\n for t in reversed(xrange(n)):\\n gC = dC + dZ[t,:,-d:]\\n\\n gCgFNt[:,:d] = gC*gF[t]\\n gCgFNt[:,d:] = gC*gN[t]\\n \\n gX[t] = np.dot(gCgFNt, Wx.T) + dZ[t,:,1:1+input_size]\\n gS[t] = np.dot(gCgFNt, Ws.T) + gC*(1-Ff[t])\\n\\n gV += np.dot(Z[t].T, dY[t]) # [mb, in+1+nc] [mb, out] -> \\n gW += np.dot(U[t].T, gCgFNt)\\n \\n dC = gS[t]\\n \\n return gX, gW, gV, gS[0]\",\n \"def state(self):\\n state = np.array(self.get_state_arr())\\n om = utils.build_occupancy_maps(utils.build_humans(state))\\n # We only have a batch of one so just get the first element of\\n # transform and rotate\\n state = utils.transform_and_rotate(state.reshape((1, -1)))[0]\\n return torch.cat((state, om), dim=1)\",\n \"def stoichiometry(self, fluid):\\n air = self.air_alias.val\\n fuel = self.fuel_alias.val\\n flue_gas = self.fuel_alias.val + '_fg'\\n\\n ###################################################################\\n # calculate fuel and air mass flow\\n m_fuel = 0\\n for i in self.inl:\\n m_fuel += i.m.val_SI * i.fluid.val[fuel]\\n\\n m_air = 0\\n for i in self.inl:\\n m_air += i.m.val_SI * i.fluid.val[air]\\n\\n m_air_min = self.air_min * m_fuel\\n\\n ###################################################################\\n # calculate lambda if not specified\\n if not self.lamb.is_set:\\n self.lamb.val = m_air / (self.air_min * m_fuel)\\n\\n ###################################################################\\n # calculate excess fuel if lambda is smaller than 1\\n m_fuel_exc = 0\\n if self.lamb.val < 1:\\n m_fuel_exc = m_fuel - m_air / (self.lamb.val * self.air_min)\\n\\n ###################################################################\\n # equation for air\\n if fluid == air:\\n if self.lamb.val >= 1:\\n dm = -m_air_min\\n else:\\n dm = -m_air\\n\\n ###################################################################\\n # equation for fuel\\n elif fluid == fuel:\\n dm = -(m_fuel - m_fuel_exc)\\n\\n ###################################################################\\n # equation for flue gas\\n elif fluid == flue_gas:\\n dm = m_air_min + m_fuel\\n\\n ###################################################################\\n # equation for other components\\n else:\\n dm = 0\\n\\n res = dm\\n for i in self.inl:\\n res += i.fluid.val[fluid] * i.m.val_SI\\n for o in self.outl:\\n res -= o.fluid.val[fluid] * o.m.val_SI\\n return res\",\n \"def _apply_swap(self, state, axes, **kwargs):\\n all_axes = list(range(len(state.shape)))\\n all_axes[axes[0]] = axes[1]\\n all_axes[axes[1]] = axes[0]\\n return self._transpose(state, all_axes)\",\n \"def _do_single_state(state, sign=True):\\n states = []\\n for p in ParallelHamiltonianBuilder.plaquettes:\\n # First apply the U term.\\n new_state, s = apply_u_dagger(state, p, sign=sign)\\n\\n # If U term was not successful, try the U^dagger term.\\n # (the order could have been switched - there's always only one\\n # possibility for overlap to be generated)\\n if not new_state:\\n new_state, s = apply_u(state, p, sign=sign)\\n\\n if new_state:\\n c = ParallelHamiltonianBuilder.inv_lookuptable.get(new_state)\\n if c is not None:\\n states.append([state, c, s])\\n\\n return states\",\n \"def forward(self, state, action): #concatenate the action -value\\n\\n xu = torch.cat([state, action], 1)\\n\\n x1 = F.relu(self.fc1(xu))\\n x1 = F.relu(self.fc2(x1))\\n x1 = self.fc3(x1)\\n\\n x2 = F.relu(self.fc4(xu))\\n x2 = F.relu(self.fc5(x2))\\n x2 = self.fc6(x2)\\n \\n return x1, x2\",\n \"def constraint_transition_update(mvi, impact_surfaces, release_surfaces, transfer_state):\\n mvi.set_single_state(2, transfer_state['t'], transfer_state['q'], transfer_state['p']) \\n\\n # Remove the constraints from the system.\\n remove_constraints(mvi, release_surfaces)\\n\\n # Apply the impact map to the end of the interval.\\n impact_update(mvi, impact_surfaces, transfer_state) \\n\\n mvi._state1_impacts = impact_surfaces\\n mvi._state1_releases = release_surfaces\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n x = self.fc3(x)\\n action = self.tanh(x)\\n\\n action = action.cpu().data.numpy() * self.action_lim\\n action = torch.FloatTensor(action)\\n\\n return action\",\n \"def forward(self, state):\\n x = F.relu(self.linear1(state))\\n x = F.relu(self.linear2(x))\\n x = torch.tanh(self.linear3(x))\\n\\n return x\",\n \"def forward(self, state):\\r\\n x = F.relu(self.linear1(state))\\r\\n x = F.relu(self.linear2(x))\\r\\n #x = torch.tanh(self.linear3(x))\\r\\n #x = F.relu(self.linear3(x))\\r\\n #x = nn.LeakyReLU(self.linear3(x), negative_slope=0.1)# .negativ_slope nur für leakyReLU relevant\\r\\n x = F.leaky_relu(self.linear3(x), 0.1)\\r\\n #x = F.softmax(self.linear3(x), dim=0)\\r\\n \\r\\n return x#.negativ_slope\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5913096","0.574097","0.5734477","0.5705467","0.5608403","0.55807066","0.5495976","0.5495976","0.5495976","0.5444154","0.53824127","0.53726685","0.53664255","0.5356983","0.53183407","0.5317279","0.53069645","0.52513015","0.5239924","0.5210715","0.51835614","0.5159202","0.51490027","0.5144359","0.5142788","0.5142711","0.51359886","0.5097755","0.5097673","0.50788033","0.50785106","0.507754","0.50544393","0.5042244","0.5040812","0.5039656","0.5037176","0.5025451","0.5018836","0.50119966","0.5010685","0.500375","0.4999276","0.49869204","0.49733093","0.49703756","0.49676877","0.4966886","0.49621502","0.4961449","0.4956471","0.49496806","0.49472338","0.4943093","0.4938996","0.49269164","0.4925799","0.49190977","0.4914534","0.4911026","0.49074063","0.49067897","0.490386","0.49028978","0.4898571","0.48865324","0.48713005","0.48648477","0.48608217","0.48560187","0.485506","0.48539543","0.48538893","0.4849292","0.48440397","0.4836587","0.4832845","0.4832012","0.48282894","0.48251876","0.48237967","0.48201668","0.48136654","0.48057777","0.4804377","0.48022628","0.47973052","0.47903624","0.4787445","0.4782371","0.47814798","0.47792268","0.47779045","0.4767831","0.47625676","0.4756899","0.47524104","0.4746853","0.47449636","0.47381833","0.47303063"],"string":"[\n \"0.5913096\",\n \"0.574097\",\n \"0.5734477\",\n \"0.5705467\",\n \"0.5608403\",\n \"0.55807066\",\n \"0.5495976\",\n \"0.5495976\",\n \"0.5495976\",\n \"0.5444154\",\n \"0.53824127\",\n \"0.53726685\",\n \"0.53664255\",\n \"0.5356983\",\n \"0.53183407\",\n \"0.5317279\",\n \"0.53069645\",\n \"0.52513015\",\n \"0.5239924\",\n \"0.5210715\",\n \"0.51835614\",\n \"0.5159202\",\n \"0.51490027\",\n \"0.5144359\",\n \"0.5142788\",\n \"0.5142711\",\n \"0.51359886\",\n \"0.5097755\",\n \"0.5097673\",\n \"0.50788033\",\n \"0.50785106\",\n \"0.507754\",\n \"0.50544393\",\n \"0.5042244\",\n \"0.5040812\",\n \"0.5039656\",\n \"0.5037176\",\n \"0.5025451\",\n \"0.5018836\",\n \"0.50119966\",\n \"0.5010685\",\n \"0.500375\",\n \"0.4999276\",\n \"0.49869204\",\n \"0.49733093\",\n \"0.49703756\",\n \"0.49676877\",\n \"0.4966886\",\n \"0.49621502\",\n \"0.4961449\",\n \"0.4956471\",\n \"0.49496806\",\n \"0.49472338\",\n \"0.4943093\",\n \"0.4938996\",\n \"0.49269164\",\n \"0.4925799\",\n \"0.49190977\",\n \"0.4914534\",\n \"0.4911026\",\n \"0.49074063\",\n \"0.49067897\",\n \"0.490386\",\n \"0.49028978\",\n \"0.4898571\",\n \"0.48865324\",\n \"0.48713005\",\n \"0.48648477\",\n \"0.48608217\",\n \"0.48560187\",\n \"0.485506\",\n \"0.48539543\",\n \"0.48538893\",\n \"0.4849292\",\n \"0.48440397\",\n \"0.4836587\",\n \"0.4832845\",\n \"0.4832012\",\n \"0.48282894\",\n \"0.48251876\",\n \"0.48237967\",\n \"0.48201668\",\n \"0.48136654\",\n \"0.48057777\",\n \"0.4804377\",\n \"0.48022628\",\n \"0.47973052\",\n \"0.47903624\",\n \"0.4787445\",\n \"0.4782371\",\n \"0.47814798\",\n \"0.47792268\",\n \"0.47779045\",\n \"0.4767831\",\n \"0.47625676\",\n \"0.4756899\",\n \"0.47524104\",\n \"0.4746853\",\n \"0.47449636\",\n \"0.47381833\",\n \"0.47303063\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94486,"cells":{"query":{"kind":"string","value":"Converts stress state to strain state"},"document":{"kind":"string","value":"def stress2strain(sigma, S):\n s6 = voigt(sigma)\n e6 = np.dot(S, s6)\n e6[3] = 0.5 * e6[3]\n e6[4] = 0.5 * e6[4]\n e6[5] = 0.5 * e6[5]\n e = unvoigt(e6)\n return e"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def normalize_state(self):\n self.state = 2 * (self.state - 0.5)","def get_state_s(self, lower = True):\r\n\r\n state_s = STATE_STRINGS[self._state - 1]\r\n state_s = state_s.lower() if lower else state_s\r\n return state_s","def _state_convert(self, raw_state):\n variables_dict = dict()\n variables_dict[\"s_t\"] = np.hstack((0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.0, 0.0, 1.0))\n variables_dict[\"v_t\"] = np.hstack((0.0, 0.0, 0.0, 0.0, 0.0, 0.0))\n variables_dict[\"add_s_t\"] = np.hstack((0.8, 0.8))\n variables_dict[\"add_v_t\"] = np.hstack((0.0, 0.0))\n variables_dict[\"flag_t\"] = 0.0\n variables_dict[\"add_dist_min\"] = np.hstack((1000.0, 1000.0, 1000.0, 1000.0))\n variables_dict[\"dist_min\"] = np.hstack((1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0))\n variables_dict[\"ego_lane\"] = raw_state[16]\n variables_dict[\"lane_ids\"] = raw_state[18]\n variables_dict[\"ego_lane\"] = variables_dict[\"lane_ids\"].index(variables_dict[\"ego_lane\"])\n if variables_dict[\"ego_lane\"] == 0 or variables_dict[\"ego_lane\"] == 2:\n variables_dict[\"s_t\"][variables_dict[\"ego_lane\"]] = 1.0\n variables_dict[\"s_t\"][variables_dict[\"ego_lane\"] + 3] = 1.0\n variables_dict[\"flag_t\"] = 1 if variables_dict[\"ego_lane\"] == 0 else -1\n\n variables_dict[\"ego_raw_speed\"] = raw_state[3]\n variables_dict[\"filter_speed\"] = (variables_dict[\"ego_raw_speed\"]\n if variables_dict[\"ego_raw_speed\"] >= 10.0 else 10.0)\n variables_dict[\"s_t\"][6] = variables_dict[\"ego_raw_speed\"] / SPEED_RANGE\n objects = raw_state[-1]\n # print(\"ego_speed\",ego_raw_speed,\"ego_lane\",ego_lane)\n if objects[0] is not None:\n # for i in range(len(objects)):\n for i, _object in enumerate(objects):\n lane_id = objects[i][0]\n dist = abs(objects[i][1]) * np.sign(objects[i][1])\n speed = objects[i][2]\n pre_post = np.sign(dist)\n flag = 0 if pre_post == 1.0 else 1\n\n if abs(dist) < VIEW_RANGE:\n for j in range(3):\n adjacent_lane = variables_dict[\"ego_lane\"] - 1 + j\n dist_index = j + flag * 3\n if (lane_id == adjacent_lane and abs(dist) < variables_dict[\"dist_min\"][dist_index]):\n self.min_dist(\n variables_dict[\"v_t\"],\n variables_dict[\"s_t\"],\n dist_index,\n speed,\n dist,\n variables_dict[\"filter_speed\"],\n )\n variables_dict[\"dist_min\"][dist_index] = abs(dist)\n\n if abs(dist) < variables_dict[\"add_dist_min\"][flag]:\n if (variables_dict[\"ego_lane\"] == 0 and lane_id == variables_dict[\"ego_lane\"] + 2\n or variables_dict[\"ego_lane\"] == len(variables_dict[\"lane_ids\"]) - 1\n and lane_id == variables_dict[\"ego_lane\"] - 2):\n self.min_dist(\n variables_dict[\"add_v_t\"],\n variables_dict[\"add_s_t\"],\n flag,\n speed,\n dist,\n variables_dict[\"filter_speed\"],\n )\n\n state = np.hstack((\n variables_dict[\"s_t\"],\n variables_dict[\"v_t\"],\n variables_dict[\"add_s_t\"],\n variables_dict[\"add_v_t\"],\n variables_dict[\"flag_t\"],\n ))\n return state","def _computeStress(self, strainTpdt, muV, lambdaV, shearRatioV, maxwellTimeV,\n dqV, strainT, viscousStrainT,\n initialStress, initialStrain, stateVars):\n \n bulkModulus = lambdaV + 2.0 * muV / 3.0\n diag = numpy.array([1.0, 1.0, 1.0, 0.0, 0.0, 0.0], dtype=numpy.float64)\n\n # Initial stresses and strains\n meanStrainInitial = numpy.dot(diag, initialStrain) / 3.0\n meanStressInitial = numpy.dot(diag, initialStress) / 3.0\n\n devStrainInitial = initialStrain - diag * meanStrainInitial\n devStressInitial = initialStress - diag * meanStressInitial\n\n # Strains from previous time step\n meanStrainT = numpy.dot(diag, strainT) / 3.0\n devStrainT = strainT - diag * meanStrainT - devStrainInitial\n\n # Strains and mean stress for current time step\n meanStrainTpdt = numpy.dot(diag, strainTpdt) / 3.0\n devStrainTpdt = strainTpdt - diag * meanStrainTpdt - devStrainInitial\n meanStressTpdt = 3.0 * bulkModulus * \\\n (meanStrainTpdt - meanStrainInitial) + meanStressInitial\n\n # Compute viscous factors\n visFrac = 0.0\n visFac = 0.0\n expFac = numpy.zeros((numMaxwellModels), dtype=numpy.float64)\n for model in range(numMaxwellModels):\n visFrac += shearRatioV[model]\n visFac += shearRatioV[model] * dqV[model]\n expFac[model] = math.exp(-self.dt/maxwellTimeV[model])\n \n elasFrac = 1.0 - visFrac\n stressTpdt = numpy.zeros( (tensorSize), dtype=numpy.float64)\n viscousStrainTpdt = numpy.zeros( (numMaxwellModels, tensorSize),\n dtype=numpy.float64)\n elasFac = 2.0 * muV\n\n # Compute viscous strain and stress\n for iComp in range(tensorSize):\n deltaStrain = devStrainTpdt[iComp] - devStrainT[iComp]\n devStressTpdt = elasFrac * devStrainTpdt[iComp]\n for model in range(numMaxwellModels):\n if shearRatioV[model] != 0.0:\n viscousStrainTpdt[model, iComp] = expFac[model] * \\\n viscousStrainT[model, iComp] + \\\n dqV[model] * deltaStrain\n devStressTpdt += shearRatioV[model] * viscousStrainTpdt[model, iComp]\n devStressTpdt = elasFac * devStressTpdt\n stressTpdt[iComp] = diag[iComp] * meanStressTpdt + devStressTpdt\n \n return stressTpdt, viscousStrainTpdt","def steel_stress(self,strain_dis, newFOS=None):\r\n\t\tstress = np.zeros(len(self.reinforcement))\r\n\t\tfor i,steel in enumerate(self.reinforcement):\r\n\t\t\tstrain = np.interp(steel[0], self.mesh_center,strain_dis)\r\n\t\t\tstress[i] = (self.steel(strain,newFOS)-self.concrete(strain,newFOS))\r\n\t\treturn stress","def gym_to_state(self, state) -> Dict[str, Any]:\n\n joint_speeds = self._env.unwrapped.robot.joint_speeds\n\n joints_at_limit = float(self._env.unwrapped.robot.joints_at_limit)\n\n potential = float(self._env.unwrapped.potential)\n if self.prev_potential is None:\n self.prev_potential = potential\n\n progress = potential - self.prev_potential\n\n self.bonsai_state = {\"obs\": state.tolist(),\n \"joint_speeds\": joint_speeds.tolist(),\n \"joints_at_limit\": joints_at_limit,\n \"progress\": progress}\n\n self.prev_potential = potential\n\n return self.bonsai_state","def get_state(self, s):\n return (torch.tensor(s, device=self.device).permute(2, 0, 1)).unsqueeze(0).float()","def _preprocess_state(self, state):\r\n if np.isinf(self.observation_space.low).any() or np.isinf(self.observation_space.high).any(): return state\r\n return (state - self.observation_space.low) /(self.observation_space.high)","def solve_steady_state(self):\n # optimization has to be done on the reduced system\n # TODO: implement different comp. sizes\n s0 = self.model.get_initial_conc()\n [L_inv, L, _] = self.model.N_partitioned\n si = numpy.dot(L_inv, s0)\n t = s0 - numpy.dot(L, si)\n f = lambda x: numpy.linalg.norm(\n self.dS_dt(numpy.dot(L, x) + t, 1))\n ss_i = scipy.optimize.fmin_bfgs(f, si)\n ss = numpy.dot(L, ss_i) + t\n return ss","def set_stress(self) -> None:\n\n c = self.cos()\n s = self.sin()\n transformation_matrix = np.array([-c, -s, c, s], dtype=np.float64)\n nodal_displacements = self.__get_arranged_nodal_displacements()\n self.__stress = (\n self.youngs_modulus # type: ignore\n / self.get_length()\n * (transformation_matrix @ nodal_displacements.T)\n )","def _transit_state(self) -> None:\n pass","def target_state(self, s):\n if s > self.total_length:\n s = self.total_length\n\n return np.array([self.sign*s, 0, 0])\n # return np.append(np.dot(self.g, np.array([s, 0, 1]))[:2], self.start_theta)","def to_se3(self, state: Vector) -> RigidTransform:\n return (state[:9],state[9:12])","def to_se3(self, state: Vector) -> RigidTransform:\n return (state[:9],state[9:])","def _calcStress(self, strainV, muV, lambdaV, shearRatioV, maxwellTimeV,\n totalStrainV, viscousStrainV, initialStressV, initialStrainV,\n stateVars):\n import scipy.misc\n \n # Define some numpy arrays\n strainTpdt = numpy.array(totalStrainV, dtype=numpy.float64)\n strainT = numpy.array(strainV, dtype=numpy.float64)\n viscousStrainT = numpy.array(viscousStrainV, dtype=numpy.float64)\n initialStress = numpy.array(initialStressV, dtype=numpy.float64)\n initialStrain = numpy.array(initialStrainV, dtype=numpy.float64)\n\n # Compute viscous factors for each Maxwell model\n dqV = numpy.zeros(numMaxwellModels, dtype=numpy.float64)\n for model in range(numMaxwellModels):\n dqV[model] = self._computeViscousFactor(maxwellTimeV[model])\n\n # Compute current stress and viscous strain\n stressTpdt, viscousStrainTpdt = self._computeStress(strainTpdt,\n muV,\n lambdaV,\n shearRatioV,\n maxwellTimeV,\n dqV,\n strainT,\n viscousStrainT,\n initialStress,\n initialStrain,\n stateVars)\n\n # Form updated state variables\n strainTpdtVec = numpy.ravel(strainTpdt)\n viscousStrainTpdtVec = numpy.ravel(viscousStrainTpdt)\n stateVarsUpdated = numpy.concatenate((strainTpdtVec, viscousStrainTpdtVec))\n\n # Compute components of tangent constitutive matrix using numerical\n # derivatives.\n derivDx = 1.0e-12\n derivOrder = 3\n elasticConstsList = []\n\n for stressComp in range(tensorSize):\n for strainComp in range(tensorSize):\n dStressDStrain = stressComp + strainComp\n dStressDStrain = scipy.misc.derivative(self._calcStressComponent,\n strainTpdt[strainComp],\n dx=derivDx,\n args=(strainComp,\n stressComp,\n strainTpdt,\n muV,\n lambdaV,\n shearRatioV,\n maxwellTimeV,\n dqV,\n strainT,\n viscousStrainT,\n initialStress,\n initialStrain,\n stateVars),\n order=derivOrder)\n elasticConstsList.append(dStressDStrain)\n\n elasticConsts = numpy.array(elasticConstsList, dtype=numpy.float64)\n\n return (elasticConsts, numpy.ravel(stressTpdt),\n numpy.ravel(stateVarsUpdated))","def _reduce_states(self, fw_st, bw_st):\n hidden_dim = self._hps.hidden_dim\n with tf.variable_scope('reduce_final_st'):\n\n # Define weights and biases to reduce the cell and reduce the state\n w_reduce_c = tf.get_variable('w_reduce_c', [hidden_dim * 2, hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\n w_reduce_h = tf.get_variable('w_reduce_h', [hidden_dim * 2, hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\n bias_reduce_c = tf.get_variable('bias_reduce_c', [hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\n bias_reduce_h = tf.get_variable('bias_reduce_h', [hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\n\n # Apply linear layer\n old_c = tf.concat(axis=1, values=[fw_st.c, bw_st.c]) # Concatenation of fw and bw cell\n old_h = tf.concat(axis=1, values=[fw_st.h, bw_st.h]) # Concatenation of fw and bw state\n new_c = tf.nn.relu(tf.matmul(old_c, w_reduce_c) + bias_reduce_c) # Get new cell from old cell\n new_h = tf.nn.relu(tf.matmul(old_h, w_reduce_h) + bias_reduce_h) # Get new state from old state\n return tf.contrib.rnn.LSTMStateTuple(new_c, new_h) # Return new cell and state","def set_stress(self, stress=None):\n self.status()\n if not stress:\n if self.__cod == 'vasp': \n #getData = VASP()\n getData = vasp.Stress()\n outfile = 'vasprun.xml'\n elif self.__cod == 'espresso':\n getData = espresso.Stress()\n outfile = 'espresso.out'\n for atoms in self.__structures.items():\n \n if not atoms[1].status:\n atoms[1].stress = np.zeros((3,3))\n continue\n #getData.set_outfile('%s/%s/'%atoms[0] + outfile)\n #getData.set_gsEnergy()\n getData.set_fname(self.__workdir + '%s/'%atoms[1].path.lstrip('.') + outfile)\n getData.set_stress()\n #atoms[1].gsenergy = getData.get_gsEnergy()\n atoms[1].stress = getData.get_stress()\n \n self.__stress = stress","def reflect_state(self, s):\n s[2:8] = reflect_control_vector(s[2:8])\n s[11:17] = reflect_control_vector(s[11:17])\n return s","def TXS(self, *_):\n self.reg.S = self.reg.X\n self.reg.N = self.reg.S << 7\n self.reg.Z = self.reg.S == 0","def _steadystate2initial(self):\n self.ss_result = []\n ss = self.steady_state\n sizeclasses = numpy.unique(ss[:,0])\n for sc in sizeclasses:\n criterium = (ss[:,0]==sc)\n target = numpy.where(criterium)[0]\n div = len(target)\n masses = [ss[t, 1:].sum() for t in target]\n mass_sum = sum(masses)\n m = mass_sum / div\n m_std = self._std(masses)\n acids = ss[target, 1] / masses\n a = acids.sum() / div\n a_std = self._std(acids)\n waters = ss[target, 2] / masses\n w = waters.sum() / div\n w_std = self._std(waters)\n ethanols = ss[target, 3] / masses\n e = ethanols.sum() / div\n e_std = self._std(ethanols)\n nonsolubles = ss[target, 4] / masses\n n = nonsolubles.sum() / div\n n_std = self._std(nonsolubles)\n humuses = ss[target, 5] / masses\n h = humuses.sum() / div\n h_std = self._std(humuses)\n self.ss_result.append([m, m_std, a, a_std, w, w_std,\n e, e_std, n, n_std, h, h_std, sc])","def switch_to_state(self, state):\n self.switch_state = state","def test_set_sT(self):\n s = State(substance=\"water\")\n s.sT = Q_(7496.2021523754065, \"J/(kg*K)\"), Q_(400.0, \"K\")\n # Pylance does not support NumPy ufuncs\n assert np.isclose(s.T, Q_(400.0, \"K\")) # type: ignore\n assert np.isclose(s.p, Q_(101325.0, \"Pa\")) # type: ignore\n assert np.isclose(s.sT[1], Q_(400.0, \"K\")) # type: ignore\n assert np.isclose(s.sT[0], Q_(7496.2021523754065, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.u, Q_(2547715.3635084038, \"J/kg\")) # type: ignore\n assert np.isclose(s.s, Q_(7496.2021523754065, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.cp, Q_(2009.2902478486988, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.cv, Q_(1509.1482452129906, \"J/(kg*K)\")) # type: ignore\n assert np.isclose(s.v, Q_(1.801983936953226, \"m**3/kg\")) # type: ignore\n assert np.isclose(s.h, Q_(2730301.3859201893, \"J/kg\")) # type: ignore\n assert s.x is None","def set_state(self,s):\n self.state = s","def state_transition(CS, CP, state, events, soft_disable_timer, v_cruise_kph, AM):\n enabled = isEnabled(state)\n\n v_cruise_kph_last = v_cruise_kph\n\n # if stock cruise is completely disabled, then we can use our own set speed logic\n if not CP.enableCruise:\n v_cruise_kph = update_v_cruise(v_cruise_kph, CS.buttonEvents, enabled)\n elif CP.enableCruise and CS.cruiseState.enabled:\n v_cruise_kph = CS.cruiseState.speed * CV.MS_TO_KPH\n\n # decrease the soft disable timer at every step, as it's reset on\n # entrance in SOFT_DISABLING state\n soft_disable_timer = max(0, soft_disable_timer - 1)\n\n # DISABLED\n if state == State.disabled:\n if get_events(events, [ET.ENABLE]):\n if get_events(events, [ET.NO_ENTRY]):\n for e in get_events(events, [ET.NO_ENTRY]):\n AM.add(str(e) + \"NoEntry\", enabled)\n\n else:\n if get_events(events, [ET.PRE_ENABLE]):\n state = State.preEnabled\n else:\n state = State.enabled\n AM.add(\"enable\", enabled)\n v_cruise_kph = initialize_v_cruise(CS.vEgo, CS.buttonEvents, v_cruise_kph_last)\n\n # ENABLED\n elif state == State.enabled:\n if get_events(events, [ET.USER_DISABLE]):\n state = State.disabled\n AM.add(\"disable\", enabled)\n\n elif get_events(events, [ET.IMMEDIATE_DISABLE]):\n state = State.disabled\n for e in get_events(events, [ET.IMMEDIATE_DISABLE]):\n AM.add(e, enabled)\n\n elif get_events(events, [ET.SOFT_DISABLE]):\n state = State.softDisabling\n soft_disable_timer = 300 # 3s\n for e in get_events(events, [ET.SOFT_DISABLE]):\n AM.add(e, enabled)\n\n # SOFT DISABLING\n elif state == State.softDisabling:\n if get_events(events, [ET.USER_DISABLE]):\n state = State.disabled\n AM.add(\"disable\", enabled)\n\n elif get_events(events, [ET.IMMEDIATE_DISABLE]):\n state = State.disabled\n for e in get_events(events, [ET.IMMEDIATE_DISABLE]):\n AM.add(e, enabled)\n\n elif not get_events(events, [ET.SOFT_DISABLE]):\n # no more soft disabling condition, so go back to ENABLED\n state = State.enabled\n\n elif get_events(events, [ET.SOFT_DISABLE]) and soft_disable_timer > 0:\n for e in get_events(events, [ET.SOFT_DISABLE]):\n AM.add(e, enabled)\n\n elif soft_disable_timer <= 0:\n state = State.disabled\n\n # PRE ENABLING\n elif state == State.preEnabled:\n if get_events(events, [ET.USER_DISABLE]):\n state = State.disabled\n AM.add(\"disable\", enabled)\n\n elif get_events(events, [ET.IMMEDIATE_DISABLE, ET.SOFT_DISABLE]):\n state = State.disabled\n for e in get_events(events, [ET.IMMEDIATE_DISABLE, ET.SOFT_DISABLE]):\n AM.add(e, enabled)\n\n elif not get_events(events, [ET.PRE_ENABLE]):\n state = State.enabled\n\n return state, soft_disable_timer, v_cruise_kph, v_cruise_kph_last","def toState(attrs=ALL):","def _calcStressComponent(self, strainVal, strainComp, stressComp, strainTpdt,\n muV, lambdaV, shearRatioV, maxwellTimeV, dqV,\n totalStrainT, viscousStrainT,\n initialStress, initialStrain,\n stateVars):\n strainTest = numpy.array(strainTpdt, dtype=numpy.float64)\n strainTest[strainComp] = strainVal\n stressTpdt, viscousStrainTpdt = self._computeStress(strainTest,\n muV,\n lambdaV,\n shearRatioV,\n maxwellTimeV,\n dqV,\n totalStrainT,\n viscousStrainT,\n initialStress,\n initialStrain,\n stateVars)\n return stressTpdt[stressComp]","def dormant_to_swd(self):\n\n # 8 SWDIOTMS cycles high + 128-bit selection alert sequence.\n self.selection_alert()\n\n # 4-bit SWDIOTMS cycles low + 8-bit SWD activation code.\n self.swd_activation_code()\n\n # SWD line reset (>50 SWDIOTMS cycles high).\n self.line_reset()\n\n # >=2 SWDIOTMS cycles low.\n self.idle_cycles(2)","def state_tensor_convert(self,state):\n return torch.Tensor(state)","def target_state(self, s):\n raise NotImplementedError()","def __getstate__(self):\n state = Object.__getstate__(self)\n state['_strain'] = set()\n return state","def simplify(self):\n state_copy = copy.deepcopy(self)\n state_copy.space.spacecrafts = [state_copy.spacecraft] + state_copy.space.close_spacecrafts_to(\n state_copy.spacecraft, self.PERCEPTION_DISTANCE)\n\n return state_copy","def effective_stress(self):\n tau = self.deviatoric_stress_tensor()\n tu_xx = tau[0,0]\n tu_yy = tau[1,1]\n tu_zz = tau[2,2]\n tu_xy = tau[0,1]\n tu_xz = tau[0,2]\n tu_yz = tau[1,2]\n \n # Second invariant of the strain rate tensor squared\n taudot = 0.5 * (+ tu_xx**2 + tu_yy**2 + tu_zz**2) \\\n + tu_xy**2 + tu_xz**2 + tu_yz**2\n return taudot","def success_state(self):\n state = np.array(self.get_success_state_arr())\n om = utils.build_occupancy_maps(utils.build_humans(state))\n #print(\"OM: \", om.size())\n # We only have a batch of one so just get the first element of\n # transform and rotate\n state = utils.transform_and_rotate(state.reshape((1, -1)))[0]\n #print(\"State: \", state.size())\n return torch.cat((state, om), dim=1).unsqueeze(0)","def state_transl(state):\n nonlocal state_cnt\n nonlocal state_transl_dict\n\n if state not in state_transl_dict.keys():\n state_transl_dict[state] = state_cnt\n state_cnt += 1\n\n return str(state_transl_dict[state])","def state_transl(state):\n nonlocal state_cnt\n nonlocal state_transl_dict\n\n if state not in state_transl_dict.keys():\n state_transl_dict[state] = state_cnt\n state_cnt += 1\n\n return str(state_transl_dict[state])","def concrete_stress(self,strain, newFOS=None):\r\n\t\tstress = np.zeros(len(strain))\r\n\t\tfor i,strn in enumerate(strain):\r\n\t\t\tstress[i] = self.concrete(strn,newFOS)\r\n\t\treturn stress","def transition_to_state(state):\n\n # Clear our \"time-in-state\" counter.\n m.d.ss += cycles_in_state.eq(0)\n\n # If we have any additional entry conditions for the given state, apply them.\n if state in tasks_on_entry:\n m.d.ss += tasks_on_entry[state]\n\n m.next = state","def _preprocess_state(self, state):\n\n def normalize_matrix(matrix, min_val, max_val):\n \"\"\"normalizes all elements in matrix to be between min val and max val\n \"\"\"\n return (max_val - min_val) * (matrix - np.min(matrix)) / (np.max(matrix) - np.min(matrix)) + min_val\n\n A, b, c0, cuts_a, cuts_b = state\n\n min_lhs = np.min([np.min(A), np.min(cuts_a)])\n max_lhs = np.max([np.max(A), np.max(cuts_a)])\n min_rhs = np.min([np.min(b), np.min(cuts_b)])\n max_rhs = np.max([np.max(b), np.max(cuts_b)])\n\n A = normalize_matrix(A, min_lhs, max_lhs)\n cuts_a = normalize_matrix(cuts_a, min_lhs, max_lhs)\n\n b = normalize_matrix(b, min_rhs, max_rhs)\n cuts_b = normalize_matrix(cuts_b, min_rhs, max_rhs)\n\n processed_state = (A, b, c0, cuts_a, cuts_b)\n condensed_state = self._condense_state(processed_state)\n return condensed_state","def _apply_basis_state(self, state, wires):\n # translate to wire labels used by device\n device_wires = self.map_wires(wires)\n\n # length of basis state parameter\n n_basis_state = len(state)\n\n if not set(state.tolist()).issubset({0, 1}):\n raise ValueError(\"BasisState parameter must consist of 0 or 1 integers.\")\n\n if n_basis_state != len(device_wires):\n raise ValueError(\"BasisState parameter and wires must be of equal length.\")\n\n # get computational basis state number\n basis_states = 2 ** (self.num_wires - 1 - np.array(device_wires))\n basis_states = qml.math.convert_like(basis_states, state)\n num = int(qml.math.dot(state, basis_states))\n\n self._state = self._create_basis_state(num)","def to_cwl_state_string(state: 'JobState') -> str:\n state_to_cwl_string = {\n JobState.SUBMITTED: 'Waiting',\n JobState.STAGING_IN: 'Waiting',\n JobState.WAITING: 'Running',\n JobState.RUNNING: 'Running',\n JobState.FINISHED: 'Running',\n JobState.STAGING_OUT: 'Running',\n JobState.SUCCESS: 'Success',\n JobState.STAGING_IN_CR: 'Waiting',\n JobState.WAITING_CR: 'Running',\n JobState.RUNNING_CR: 'Running',\n JobState.STAGING_OUT_CR: 'Running',\n JobState.CANCELLED: 'Cancelled',\n JobState.SYSTEM_ERROR: 'SystemError',\n JobState.TEMPORARY_FAILURE: 'TemporaryFailure',\n JobState.PERMANENT_FAILURE: 'PermanentFailure',\n }\n return state_to_cwl_string[state]","def target_state(self, s):\n\n if s < self.total_length and s - self.transition >= self.subpaths[self.current_path].total_length:\n self.transition += self.subpaths[self.current_path].total_length\n offset = self.subpaths[self.current_path].target_state(self.subpaths[self.current_path].total_length)\n self.g = np.dot(self.g, rigid(offset))\n self.start_theta += offset[2]\n self.start_theta = (self.start_theta+np.pi)%(np.pi*2) - np.pi\n self.current_path += 1\n \n if s > self.total_length:\n s = self.total_length\n\n state = self.subpaths[self.current_path].target_state(s-self.transition)\n state[:2] = np.dot(self.g, np.append(state[:2], 1))[:2]\n state[2] += self.start_theta\n\n return state","def _get_state(self):\n start = self.design.first_unassigned_site\n return self.target.padded_encoding[\n start : start + 2 * self._env_config.state_radius + 1\n ]","def shock2state(self, shock):\n\n stype, ssize = shock[:2]\n state = np.zeros(self.dimq)\n state[-self.dimeps:][list(self.shocks).index(stype)] = ssize\n\n return state","def generate_swapped_stress_strain_one_file():\n fname = 'resources/simple_swapped_data.json'\n\n stress = np.linspace(0, 100)\n stress_time = np.linspace(0, 100)\n strain = np.linspace(0, 100)\n strain_time = np.linspace(0, 100)\n expected = pif.System(\n subSystems=None,\n properties=[\n pif.Property(name='strain',\n scalars=list(strain),\n conditions=pif.Value(\n name='time',\n scalars=list(strain_time))),\n pif.Property(name='stress',\n scalars=list(stress),\n conditions=pif.Value(\n name='time',\n scalars=list(stress_time)))\n\n ])\n with open(fname, 'w') as data:\n pif.dump(expected, data)\n\n return {\n 'file_name': fname,\n 'expected': expected\n }","def cost_state_old(s,state_considered,L,Q,gamma):\n if s==s.goal:\n return 0\n model=Model(\"trajectory of polytopes\")\n p={}\n for row in range(s.n):\n p[row]=model.addVar(lb=-1,ub=1)\n model.update()\n GLG=np.dot(state_considered.G.T,np.dot(L,state_considered.G))\n theta=state_considered.successor[2]\n u=state_considered.successor[1]\n i=state_considered.mode\n theta_Q_theta=np.dot(theta.T,np.dot(Q,theta))\n J=QuadExpr()\n for row in range(s.n):\n for k in range(s.n):\n J.add(p[row]*p[k]*GLG[row,k]+p[row]*p[k]*theta_Q_theta[row,k])\n model.setParam('OutputFlag',False)\n model.setObjective(J)\n model.optimize()\n return model.ObjVal+np.asscalar(np.dot(state_considered.x.T,np.dot(L,state_considered.x))+np.dot(u.T,np.dot(Q,u))+gamma)","def state_action(self, s, a):\r\n s_x, s_y = s[0][0], s[0][1]\r\n s_vx, s_vy = s[1][0], s[1][1]\r\n a_x, a_y = a[0] + 1, a[1] + 1\r\n s_a = (s_x, s_y, s_vx, s_vy, a_x, a_y)\r\n\r\n return s_a","def define_state_transition_SecuritySettlement():\n\n state_chart_name = 'FSwiftSecuritySettlementIn'\n old_state_chart_name = 'SecuritySettlementConfMsg'\n state_chart = {\n 'Ready': {'Identified' : 'Paired',\n 'NotIdentified' : 'Unpaired',\n 'SecurityTransfer' : 'TradeGenerated'},\n 'Paired': {'PartialMatch' : 'PartialMatch',\n 'NoMatch' : 'Difference',\n 'Match' : 'Settled',\n 'AlreadyCancelled' : 'ManuallyCancelled' },\n 'Unpaired': {'Ignore' : 'Ignored',\n 'Identified' : 'Paired'},\n 'Difference': {'ManuallyCorrect' : 'ManuallyCorrected',\n 'Unpair' : 'Unpaired',\n 'Re-Match' : 'Paired',\n 'ManuallyMatch' : 'Settled'},\n 'PartialMatch': {'Identified' : 'Paired'},\n 'TradeGenerated': {'Identified' : 'Paired'},\n 'Settled': {'Unpair' : 'Unpaired'},\n }\n co_string = 'Ready,-500,0;Paired,-300,0;PartialMatch,-300,400;Settled,400,0;Unpaired,-300,-200;Ignored,400,-200;Difference,400,250;ManuallyCorrected,400,400;TradeGenerated,-500,400;ManuallyCancelled,100,400'\n #state_charts_list.append({state_chart_name:[state_chart]+[co_string]})\n\n return state_chart_name, state_chart, old_state_chart_name, co_string","def set_state(self, state):\n for v in self._variables:\n self._state[self._mapping[v]] = state[v]\n if any(v not in {1, -1} for v in self._state):\n raise ValueError(\"State must contain only 1's and -1's\")","def get_strand_state(w, c):\n if (w is None) or (c is None) or (w + c == 0):\n return (0, 0)\n r = w / (w + c)\n if r < 0.2:\n return (0, 2)\n elif r > 0.8:\n return (2, 0)\n else:\n return (1, 1)","def action(self, S, t):\n i, b = t\n mask = 1 << i\n if b:\n V = S | mask\n else:\n V = S & ~ mask\n if V in self._states:\n return V\n else:\n return S","def state_transition(self, curr_state, curr_action):\n curr_state[curr_action[0]] = curr_action[1]\n return curr_state","def propagate_state(s,t0,tf):\n\n return rk4(s,t0,tf)","def fromState(state):","def convert_input(self, inlist):\n\n # First map the ordered state list from the simulation into a\n # state dictionary for the brain.\n self.state = {\n 'heat_cost':\t\tinlist[0],\n 'set_temp':\t\t\tinlist[1],\n 'room_temp':\t\tinlist[2],\n 'room_temp_change':\t\tinlist[3],\n 'outside_temp':\t\tinlist[4],\n 'outside_temp_change':\tinlist[5],\n }\n\n # To compute the reward function value we start by taking the\n # difference between the set point temperature and the actual\n # room temperature.\n tdiff = math.fabs(self.state['set_temp'] - self.state['room_temp'])\n\n # Raise the difference to the 0.4 power. The non-linear\n # function enhances the reward distribution near the desired\n # temperature range. Please refer to the Bonsai training\n # video on reward functions for more details.\n nonlinear_diff = pow(tdiff, 0.4)\n\n # Scale the nonlinear difference so differences in the range\n # +/- 2 degrees (C) map between 0 and 1.0.\n # 2 degree ^ 0.4 = 1.32\n scaled_diff = nonlinear_diff / 1.32\n\n # Since we need a positive going reward function, subtract the\n # scaled difference from 1.0. This reward value will be 1.0\n # when we are precisely matching the set point and will fall\n # to less than 0.0 when we exceed 2 degrees (C) from the set\n # point.\n self.reward = 1.0 - scaled_diff\n \n self.terminal = self.nsteps >= 240 or self.reward < 0.0\n\n if self.nsteps > 0:\n self.total_reward += self.reward\n\n return self.state, self.reward, self.terminal","def state(self, state: str) -> None:","def featurize_state(self, state):\n s_scaled = self.scaler.transform([state])\n s_transformed = self.feature_transformer.transform(s_scaled)\n return s_transformed[0]","def state_transition(self, curr_state, curr_action):\n #The state transition happens from the current state to the next state based on agent's action\n curr_state[curr_action[0]]=curr_action[1]\n return curr_state","def get_state(self, state):\n status = [u'noState', u'poweredOn', u'blocked', u'suspended', \n u'poweredOff', u'poweredOff', u'crashed']\n return status[int(state)]","def state_transition(self):\n self.x = np.dot(self.F, self.x)\n self.x_noisy = noise_fun(np.dot(self.F, self.x_noisy), self.Q)\n return self.x","def stiffenerBuckle(dim):\n bst = dim[0]\n tst = dim[1]\n tsk = dim[2]\n\n epsilont = kt * ((tst / bst)) ** 2\n Et = (Esk * tsk) + (Est * ((bst * tst) / bsk))\n Nst = Et*epsilont # Critical Load\n rsf = Nst/Nx\n return rsf - 1 # Using a target Reserve Factor of 1","def get_state(self):\n return STAR_STATES[self.state][0]","def get_state(self):\n return STAR_STATES[self.state][0]","def S(self):\n return self._states","def define_state_transition_SettlementStatusProcessingAdvice():\n\n state_chart_name = 'FSwiftSettStatusProcessAdviceIn'\n old_state_chart_name = ''\n state_chart = {\n 'Ready': {'Identified': 'Paired',\n 'NotIdentified': 'Unpaired'},\n\n 'Unpaired': {'Identified': 'Paired'},\n\n 'Paired': {'Acknowledge': 'Acknowledged',\n 'NoMatch': 'NotMatched',\n 'Match': 'Matched',\n 'Pending': 'PendingSettlement',\n 'Failing': 'FailingSettlement',\n 'Reject': 'Rejected',\n 'Cancel': 'Cancelled',},\n\n 'Acknowledged': {'NoMatch': 'NotMatched',\n 'Match': 'Matched',\n 'Pending': 'PendingSettlement',\n 'Failing': 'FailingSettlement',\n 'Cancel': 'Cancelled',\n 'Reject': 'Rejected',\n 'AmndCancRequest':'AmendCancelRequested',\n 'AmndCancPending':'AmendCancelPending',\n 'Done':'Processed'},\n\n 'Matched': {'Pending': 'PendingSettlement',\n 'Cancel': 'Cancelled',\n 'Reject': 'Rejected',\n 'Failing': 'FailingSettlement',\n 'AmndCancRequest':'AmendCancelRequested',\n 'AmndCancPending':'AmendCancelPending',\n 'Done':'Processed'\n },\n\n 'FailingSettlement':{'AmndCancRequest':'AmendCancelRequested',\n 'AmndCancPending':'AmendCancelPending',\n 'Reject': 'Rejected',\n 'Cancel': 'Cancelled',\n 'Done':'Processed'},\n\n 'NotMatched': {'Match': 'Matched',\n 'Pending': 'PendingSettlement',\n 'Failing': 'FailingSettlement',\n 'Cancel': 'Cancelled',\n 'Reject': 'Rejected',\n 'AmndCancRequest':'AmendCancelRequested',\n 'AmndCancPending':'AmendCancelPending',\n 'Done':'Processed'},\n\n 'AmendCancelRequested': {'AmndCancComplete':'AmendCancelCompleted',\n 'Done':'Processed'},\n\n 'AmendCancelPending': {'AmndCancComplete':'AmendCancelCompleted',\n 'Done':'Processed'},\n\n 'PendingSettlement': {'Failing': 'FailingSettlement',\n 'Cancel': 'Cancelled',\n 'AmndCancRequest':'AmendCancelRequested',\n 'AmndCancPending':'AmendCancelPending',\n 'Reject': 'Rejected',\n 'Done':'Processed'},\n 'Cancelled' : { 'Done':'Processed'},\n 'AmendCancelCompleted' : { 'Done':'Processed'},\n\n 'Rejected': {'Cancel': 'Cancelled',\n 'Done': 'Processed'}\n\n }\n\n co_string = 'Paired,73,-105;Cancelled,676,329;Not Match,696,-223;Match,1271,173;AmendCancelPending,728,189;Matched,347,-133;Unpaired,-178,-351;Acknowledge,435,-110;Reject,229,538;AmendCancelCompleted,862,90;Rejected,177,338;NotMatched,432,-283;Acknowledged,549,-429;Processed,1072,-131;Pending Settlement,1193,495;PendingSettlement,304,22;FailingSettlement,255,179;Ready,-237,-98;AmendCancelRequested,737,0;'\n #state_charts_list.append({state_chart_name: [state_chart] + [co_string]})\n\n return state_chart_name, state_chart, old_state_chart_name, co_string","def compute_steady_state(self, capital):\n#TODO\n NotDefinedError=create_grids(s)\n NotDefinedError=compute_poly(s)\n else:\n NotImplementedError\n # Make an initial guess of market clearing capital levels from Young, 2010 method using histograms \n np.fsolve(lambda a, b, c: compute_MC_Residual_Histogram(),x0,args)","def ratestate_sl(t,y,o):\n State=y[:o['N']]\n Vel=y[o['N']:2*o['N']] \n Disp=y[2*o['N']:3*o['N']]\n # Slip law\n dStatedt = np.concatenate((np.zeros(o['Fstart']),\n -State[o['Fstart']:o['Fend']]*Vel[o['Fstart']:o['Fend']]*np.log(State[o['Fstart']:o['Fend']]*Vel[o['Fstart']:o['Fend']]),\n np.zeros(o['N']-o['Fend'])))\n stress=getstress(Vel,o);\n dVeldt = np.concatenate((np.zeros(o['Fstart']),\n ((o['aoverb'][o['Fstart']:o['Fend']])/Vel[o['Fstart']:o['Fend']] + o['eta'])**(-1)*\n (-dStatedt[o['Fstart']:o['Fend']]/State[o['Fstart']:o['Fend']] - stress[o['Fstart']:o['Fend']]/2),\n np.zeros(o['N']-o['Fend'])))\n dDispdt = Vel\n dy = np.concatenate((dStatedt,dVeldt,dDispdt))\n print(t)\n return dy","def CTMCtoStormpy(h):\n\tstate_labelling = _buildStateLabeling(h)\n\ttransition_matrix = deepcopy(h.matrix)\n\te = array([h.e(s) for s in range(h.nb_states)])\n\ttransition_matrix /= e[:,newaxis]\n\ttransition_matrix = st.build_sparse_matrix(transition_matrix)\n\tcomponents = st.SparseModelComponents(transition_matrix=transition_matrix,\n\t\t\t\t\t\t\t\t\t\t state_labeling=state_labelling,\n\t\t\t\t\t\t\t\t\t\t rate_transitions=True)\n\tcomponents.exit_rates = e\n\tctmc = st.storage.SparseCtmc(components)\n\treturn ctmc","def state(params1):\n variational_circuit(params1)\n return qml.state()","def jajapyModeltoStormpy(h):\n\tif type(h) == MDP:\n\t\treturn MDPtoStormpy(h)\n\telif type(h) == CTMC:\n\t\treturn CTMCtoStormpy(h)\n\telif type(h) == MC:\n\t\treturn MCtoStormpy(h)\n\telif type(h) == PCTMC:\n\t\ttry:\n\t\t\th = PCTMCtoCTMC(h)\n\t\texcept ValueError:\n\t\t\traise ValueError(\"Cannot convert non-instantiated PCTMC to Stormpy.\")\n\t\treturn CTMCtoStormpy(h)\n\telse:\n\t\traise TypeError(str(type(h))+' cannot be translated to a stormpy sparse model.')","def get_steady_state(self, s0=None, tol=1e-12, max_steps=100, max_computation_time=180, old_ss=None,\n d_params=None, old_conc_resp=None, string_output=False):\n if self._no_steady_state:\n raise NoncriticalError('No steady state could be found')\n if s0 is None:\n s0 = self.model.get_initial_conc(with_rate_rule_params=True)\n self._steady_state_s0 = s0\n if self._steady_state is not None and numpy.linalg.norm(self._steady_state_s0 - s0) < 0.0001:\n if string_output:\n return misc.matrix2string(numpy.array([self._steady_state]), self.model.species_ids)\n return self._steady_state\n # linear approximation of new ss\n if old_ss is not None and old_conc_resp is not None and d_params is not None:\n s0 = old_ss + numpy.dot(old_conc_resp, d_params)\n result = [s0]\n\n start_comp_time = time.time()\n sim_time = 0\n for i in range(max_steps):\n stepsize = 10 ** (i / 10 - 1)\n t = numpy.linspace(sim_time, sim_time + stepsize, 100)\n s0 = result[-1]\n try:\n result = self.odeint_wrapper(self.dS_dt, s0, t)\n except NoncriticalError, e:\n if i > 0:\n self._no_steady_state = True\n raise NoncriticalError(\n 'No steady state could be found. This could indicate and oszillating model.')\n else:\n raise e\n if (numpy.linalg.norm(result[0] - result[-1]) / s0.size) < tol:\n break\n sim_time += stepsize\n if i == (max_steps - 1) or (time.time() - start_comp_time > max_computation_time):\n self._no_steady_state = True\n raise NoncriticalError(\n 'No steady state could be found. This could indicate and oszillating model.')\n self._steady_state = result[-1]\n if string_output:\n return misc.matrix2string(numpy.array([result[1]]).T,\n ['Conc.'],\n self.model.species_ids,\n justify='left')\n return result[1]","def reset_reservoir(self):\n self.state = np.zeros((self.state_size,1),dtype=self.typefloat)","def flowStress(f_hard,eps,d,q,a):\n\n pass","def reset_states(self):\n self.mean_makespan_baseline.assign(0)\n self.mean_makespan_train.assign(0)\n self.step.assign(0)","def call(self, state):\n x = tf.cast(state, tf.float32)\n x = self.flatten(x)\n x -= self.min_vals\n x /= self.max_vals - self.min_vals\n x = 2.0 * x - 1.0 # Rescale in range [-1, 1].\n x = self.dense1(x)\n x = self.dense2(x)\n x = self.last_layer(x)\n return x","def test_state_units_SI(self):\n s = State(\"water\", T=Q_(100, \"degC\"), p=Q_(1.0, \"atm\"), units=\"SI\")\n assert s.units == \"SI\"\n assert s.cv.units == \"kilojoule / kelvin / kilogram\"\n assert s.cp.units == \"kilojoule / kelvin / kilogram\"\n assert s.s.units == \"kilojoule / kelvin / kilogram\"\n assert s.h.units == \"kilojoule / kilogram\"\n assert s.T.units == \"degree_Celsius\"\n assert s.u.units == \"kilojoule / kilogram\"\n assert s.v.units == \"meter ** 3 / kilogram\"\n assert s.p.units == \"bar\"","def test_state_preparation(self, tol, qubit_device_3_wires, basis_state, wires, target_state):\n\n @qml.qnode(qubit_device_3_wires)\n def circuit():\n BasisStatePreparation(basis_state, wires)\n\n # Pauli Z gates identify the basis state\n return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1)), qml.expval(qml.PauliZ(2))\n\n # Convert from Pauli Z eigenvalues to basis state\n output_state = [0 if x == 1.0 else 1 for x in circuit()]\n\n assert np.allclose(output_state, target_state, atol=tol, rtol=0)","def test_lowercase_input(self):\n State(substance=\"water\")\n State(substance=\"r22\")\n State(substance=\"r134a\")\n State(substance=\"ammonia\")\n State(substance=\"propane\")\n State(substance=\"air\")\n State(substance=\"isobutane\")\n State(substance=\"carbondioxide\")\n State(substance=\"oxygen\")\n State(substance=\"nitrogen\")","def str_state():\n\n asserts = get_solver().assertions()\n if len(asserts) == 0:\n return None\n return str(z3.simplify(z3.And(*asserts),\n expand_select_store=True))","def update_stimulus(self, stimulus):\r\n self.stri.update_stimulus(stimulus)","def update_stimulus(self, stimulus):\r\n self.stri.update_stimulus(stimulus)","def set_stress(dat):\n # stress parameters\n rho = 2700.\n xgrad = 0.61\n ygrad = (0.61 + 1) / 2\n dat.strs.on()\n dat.strs.bodyforce = False\n dat.add(fdata.fmacro('stressboun', zone='XMIN',\n param=(('direction', 1), ('value', 0))))\n dat.add(fdata.fmacro('stressboun', zone='YMIN',\n param=(('direction', 2), ('value', 0))))\n dat.add(fdata.fmacro('stressboun', zone='ZMIN',\n param=(('direction', 3), ('value', 0))))\n dat.add(fdata.fmacro('stressboun', zone='XMAX',\n param=(('direction', 1), ('value', 0))))\n dat.add(fdata.fmacro('stressboun', zone='YMAX',\n param=(('direction', 2), ('value', 0))))\n dat.zone[0].poissons_ratio = 0.2\n dat.zone[0].thermal_expansion = 3.5e-5\n dat.zone[0].pressure_coupling = 1.\n # Model starts at surface, so no overburden (specified as zgrad when\n # 'calculate_vertical' set to True)\n dat.incon.stressgrad(xgrad=xgrad, ygrad=ygrad, zgrad=0,\n calculate_vertical=True, vertical_fraction=True)\n return dat","def state(self):\n state = np.array(self.get_state_arr())\n om = utils.build_occupancy_maps(utils.build_humans(state))\n # We only have a batch of one so just get the first element of\n # transform and rotate\n state = utils.transform_and_rotate(state.reshape((1, -1)))[0]\n return torch.cat((state, om), dim=1)","def pka_switchstate(cls, amb, state_id_):\n titrationdict = TITRATION_DICT\n state_id = titrationdict[state_id_]\n state_id = state_id.split(\"+\")\n new_state_id = [int(i) for i in state_id]\n residue = getattr(amb, \"residue\")\n hdef = getattr(amb, \"hdef\")\n for conf in hdef.conformations:\n hname = conf.hname\n boundname = conf.boundatom\n if residue.get_atom(hname) is not None:\n residue.remove_atom(hname)\n residue.get_atom(boundname).hacceptor = 1\n residue.get_atom(boundname).hdonor = 0\n\n # Update the IntraBonds\n for state_id in new_state_id:\n if state_id == 0:\n continue\n conf = hdef.conformations[state_id - 1]\n refcoords = []\n defcoords = []\n defatomcoords = []\n if conf == ():\n continue\n hname = conf.hname\n for atom in conf.atoms:\n if (\n residue.is_n_term\n and residue.name == \"PRO\"\n and atom.name == \"H\"\n ):\n atom.name = \"CD\"\n atom.x = 1.874\n atom.y = 0.862\n atom.z = 1.306\n\n if not residue.rebuild_tetrahedral(hname):\n for atom in conf.atoms:\n atomname = atom.name\n resatom = residue.get_atom(atomname)\n if atomname == hname:\n defatomcoords = atom.coords\n elif resatom is not None:\n refcoords.append(resatom.coords)\n defcoords.append(atom.coords)\n else:\n raise KeyError(\"Could not find necessary atom!\")\n\n newcoords = quat.find_coordinates(\n 3, refcoords, defcoords, defatomcoords\n )\n residue.create_atom(hname, newcoords)\n\n boundname = conf.boundatom\n residue.get_atom(boundname).hacceptor = 0\n residue.get_atom(boundname).hdonor = 1\n\n # Setting the SybylType for the newly built H\n residue.get_atom(hname).sybyl_type = \"H\"\n\n # formal charge for PEOE_PB\n residue.get_atom(hname).formalcharge = 0.0\n\n # flag the added hydrogen\n residue.get_atom(hname).titratableH = True\n\n # Update intrabonds again\n if residue.is_n_term and residue.name == \"PRO\":\n for atom in residue.atoms:\n if atom.name == \"H\":\n residue.remove_atom(\"H\")\n residue.update_terminus_status()","def get_state(self, state):\n return state","def restore_after_spacer(state_min1, state_min2):\n logger.debug('t-2 : {0} t-1 : {1}'.\n format(state_min2, state_min1) \n )\n\n wave_state = '';\n # Bug Fix: Issue 1.\n # Search backwards. If t-1 was a spacer too, then use t-2 for continuation\n if (re.search('\\bS\\b|\\[dotted\\]', state_min1)):\n wave_state = state_min2 \n else:\n wave_state = state_min1 \n\n # Flag erraneous input\n if (re.search('\\bS\\b|\\[dotted\\]', wave_state)):\n logger.error('Not supported, Possible back to back breaks or break on first clock')\n\n wave_state = re.sub(r'(\\d+[UDXLHCudxlhc])(.*)',r'\\1', wave_state)\n\n return wave_state","def stateToCode(self, state):\n\n multiplier = 1\n code = \"\"\n for i in range(self.num_joints-1, -1, -1):\n num_angles = len(self.angles[i])\n code += str(int((state / multiplier ) % num_angles))\n multiplier *= len(self.angles[i])\n\n # Return the reversed code\n return code [::-1]","def strain_rate_tensor(self):\n U = self.U3\n return 0.5 * (grad(U) + grad(U).T)","def make_move(self, move: Any) -> \"StonehengeState\":\n new_state = StonehengeState(self.p1_turn, self.length,\n self.letters[:], self.claim[:])\n state = new_state\n if new_state.length == 1:\n state = self.move_length_1(move, new_state)\n if new_state.length == 2:\n state = self.move_length_2(move, new_state)\n if new_state.length == 3:\n state = self.move_length_3(move, new_state)\n if new_state.length == 4:\n if move in [\"A\", \"B\", \"J\", \"O\", \"N\", \"R\",\n \"C\", \"F\", \"E\", \"I\", \"P\", \"Q\"]:\n state = self.move_length_4(move, new_state)\n else:\n state = self.move_length_41(move, new_state)\n if new_state.length == 5:\n if move in [\"A\", \"B\", \"U\", \"O\", \"T\", \"Y\",\n \"C\", \"J\", \"E\", \"N\", \"V\", \"X\"]:\n state = self.move_length_5(move, new_state)\n elif move in [\"F\", \"I\", \"W\"]:\n state = self.move_length_51(move, new_state)\n else:\n state = self.move_length_52(move, new_state)\n return state","def assignState(self):\n\t\tblack = ['r', 'n', 'b','q','k','b','n','r']\n\t\twhite = ['R','N','B','Q','K','B','N','R']\n\n\t\tfor i in range(8):\n\t\t\tself.squares[8*i + 0].state = black[i]\n\t\t\tself.squares[8*i + 1].state = 'p'\n\t\t\tself.squares[8*i + 2].state = '.'\n\t\t\tself.squares[8*i + 3].state = '.'\n\t\t\tself.squares[8*i + 4].state = '.'\n\t\t\tself.squares[8*i + 5].state = '.'\n\t\t\tself.squares[8*i + 6].state = 'P'\n\t\t\tself.squares[8*i + 7].state = white[i]\n\n\t\tfor square in self.squares:\n\t\t\tself.boardMatrix.append(square.state)","def get_state_tostring(rapid_data):\n try:\n if rapid_data.RapidType == 'bool':\n res = 'State = %s' % rapid_data.Value\n return res\n else:\n err = 'DataType is ' + rapid_data.RapidType + ' and not bool.'\n return err\n except Exception, err:\n return err","def _stateDict(self):\n\n data = {}\n # if self.currentState[4]:\n # data['action'] = 'BRAK'\n # else:\n data['action'] = 'MCTL'\n data['speed'] = float(self.speed)\n data['steerAngle'] = float(self.steering_angle)\n\n return data","def sense_state(self):\n\n # 3. Return turkey's current state\n return self.maze.sense_turkey()","def _status_to_state(status):\n if status == 'failed':\n return Finding.State.ACTIVE\n elif status == 'passed' or status == 'skipped':\n return Finding.State.INACTIVE\n else:\n return Finding.State.STATE_UNSPECIFIED","def MCtoStormpy(h):\n\tstate_labelling = _buildStateLabeling(h)\n\ttransition_matrix = h.matrix\n\ttransition_matrix = st.build_sparse_matrix(transition_matrix)\n\tcomponents = st.SparseModelComponents(transition_matrix=transition_matrix,\n\t\t\t\t\t\t\t\t\t\t state_labeling=state_labelling)\n\tmc = st.storage.SparseDtmc(components)\n\treturn mc","def get_state(s):\n return np.array([math.atan2(s[1], s[0]), s[2]])","def change_state(self):\n transitions = self.transition_map[self.current_state]\n self.current_state = select_from_probability_dict(random(),transitions)","def final_state_cost(x_tape):\n return np.linalg.norm(deviation_from_upright_equilibrium(x_tape[:, -1]))","def obs_to_state(env, obs):\n env_low = env.observation_space.low\n env_high = env.observation_space.high\n env_dx = (env_high - env_low) / n_states\n a = int((obs[0] - env_low[0])/env_dx[0])\n b = int((obs[1] - env_low[1])/env_dx[1])\n return a, b","def get_stress(self) -> Union[np.float64, float]:\n\n return self.__stress","def get_state_as_string(state):\n string_state = \"\"\n for element in state:\n string_state += \" \" + element\n return string_state.lstrip()"],"string":"[\n \"def normalize_state(self):\\n self.state = 2 * (self.state - 0.5)\",\n \"def get_state_s(self, lower = True):\\r\\n\\r\\n state_s = STATE_STRINGS[self._state - 1]\\r\\n state_s = state_s.lower() if lower else state_s\\r\\n return state_s\",\n \"def _state_convert(self, raw_state):\\n variables_dict = dict()\\n variables_dict[\\\"s_t\\\"] = np.hstack((0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.0, 0.0, 1.0))\\n variables_dict[\\\"v_t\\\"] = np.hstack((0.0, 0.0, 0.0, 0.0, 0.0, 0.0))\\n variables_dict[\\\"add_s_t\\\"] = np.hstack((0.8, 0.8))\\n variables_dict[\\\"add_v_t\\\"] = np.hstack((0.0, 0.0))\\n variables_dict[\\\"flag_t\\\"] = 0.0\\n variables_dict[\\\"add_dist_min\\\"] = np.hstack((1000.0, 1000.0, 1000.0, 1000.0))\\n variables_dict[\\\"dist_min\\\"] = np.hstack((1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0))\\n variables_dict[\\\"ego_lane\\\"] = raw_state[16]\\n variables_dict[\\\"lane_ids\\\"] = raw_state[18]\\n variables_dict[\\\"ego_lane\\\"] = variables_dict[\\\"lane_ids\\\"].index(variables_dict[\\\"ego_lane\\\"])\\n if variables_dict[\\\"ego_lane\\\"] == 0 or variables_dict[\\\"ego_lane\\\"] == 2:\\n variables_dict[\\\"s_t\\\"][variables_dict[\\\"ego_lane\\\"]] = 1.0\\n variables_dict[\\\"s_t\\\"][variables_dict[\\\"ego_lane\\\"] + 3] = 1.0\\n variables_dict[\\\"flag_t\\\"] = 1 if variables_dict[\\\"ego_lane\\\"] == 0 else -1\\n\\n variables_dict[\\\"ego_raw_speed\\\"] = raw_state[3]\\n variables_dict[\\\"filter_speed\\\"] = (variables_dict[\\\"ego_raw_speed\\\"]\\n if variables_dict[\\\"ego_raw_speed\\\"] >= 10.0 else 10.0)\\n variables_dict[\\\"s_t\\\"][6] = variables_dict[\\\"ego_raw_speed\\\"] / SPEED_RANGE\\n objects = raw_state[-1]\\n # print(\\\"ego_speed\\\",ego_raw_speed,\\\"ego_lane\\\",ego_lane)\\n if objects[0] is not None:\\n # for i in range(len(objects)):\\n for i, _object in enumerate(objects):\\n lane_id = objects[i][0]\\n dist = abs(objects[i][1]) * np.sign(objects[i][1])\\n speed = objects[i][2]\\n pre_post = np.sign(dist)\\n flag = 0 if pre_post == 1.0 else 1\\n\\n if abs(dist) < VIEW_RANGE:\\n for j in range(3):\\n adjacent_lane = variables_dict[\\\"ego_lane\\\"] - 1 + j\\n dist_index = j + flag * 3\\n if (lane_id == adjacent_lane and abs(dist) < variables_dict[\\\"dist_min\\\"][dist_index]):\\n self.min_dist(\\n variables_dict[\\\"v_t\\\"],\\n variables_dict[\\\"s_t\\\"],\\n dist_index,\\n speed,\\n dist,\\n variables_dict[\\\"filter_speed\\\"],\\n )\\n variables_dict[\\\"dist_min\\\"][dist_index] = abs(dist)\\n\\n if abs(dist) < variables_dict[\\\"add_dist_min\\\"][flag]:\\n if (variables_dict[\\\"ego_lane\\\"] == 0 and lane_id == variables_dict[\\\"ego_lane\\\"] + 2\\n or variables_dict[\\\"ego_lane\\\"] == len(variables_dict[\\\"lane_ids\\\"]) - 1\\n and lane_id == variables_dict[\\\"ego_lane\\\"] - 2):\\n self.min_dist(\\n variables_dict[\\\"add_v_t\\\"],\\n variables_dict[\\\"add_s_t\\\"],\\n flag,\\n speed,\\n dist,\\n variables_dict[\\\"filter_speed\\\"],\\n )\\n\\n state = np.hstack((\\n variables_dict[\\\"s_t\\\"],\\n variables_dict[\\\"v_t\\\"],\\n variables_dict[\\\"add_s_t\\\"],\\n variables_dict[\\\"add_v_t\\\"],\\n variables_dict[\\\"flag_t\\\"],\\n ))\\n return state\",\n \"def _computeStress(self, strainTpdt, muV, lambdaV, shearRatioV, maxwellTimeV,\\n dqV, strainT, viscousStrainT,\\n initialStress, initialStrain, stateVars):\\n \\n bulkModulus = lambdaV + 2.0 * muV / 3.0\\n diag = numpy.array([1.0, 1.0, 1.0, 0.0, 0.0, 0.0], dtype=numpy.float64)\\n\\n # Initial stresses and strains\\n meanStrainInitial = numpy.dot(diag, initialStrain) / 3.0\\n meanStressInitial = numpy.dot(diag, initialStress) / 3.0\\n\\n devStrainInitial = initialStrain - diag * meanStrainInitial\\n devStressInitial = initialStress - diag * meanStressInitial\\n\\n # Strains from previous time step\\n meanStrainT = numpy.dot(diag, strainT) / 3.0\\n devStrainT = strainT - diag * meanStrainT - devStrainInitial\\n\\n # Strains and mean stress for current time step\\n meanStrainTpdt = numpy.dot(diag, strainTpdt) / 3.0\\n devStrainTpdt = strainTpdt - diag * meanStrainTpdt - devStrainInitial\\n meanStressTpdt = 3.0 * bulkModulus * \\\\\\n (meanStrainTpdt - meanStrainInitial) + meanStressInitial\\n\\n # Compute viscous factors\\n visFrac = 0.0\\n visFac = 0.0\\n expFac = numpy.zeros((numMaxwellModels), dtype=numpy.float64)\\n for model in range(numMaxwellModels):\\n visFrac += shearRatioV[model]\\n visFac += shearRatioV[model] * dqV[model]\\n expFac[model] = math.exp(-self.dt/maxwellTimeV[model])\\n \\n elasFrac = 1.0 - visFrac\\n stressTpdt = numpy.zeros( (tensorSize), dtype=numpy.float64)\\n viscousStrainTpdt = numpy.zeros( (numMaxwellModels, tensorSize),\\n dtype=numpy.float64)\\n elasFac = 2.0 * muV\\n\\n # Compute viscous strain and stress\\n for iComp in range(tensorSize):\\n deltaStrain = devStrainTpdt[iComp] - devStrainT[iComp]\\n devStressTpdt = elasFrac * devStrainTpdt[iComp]\\n for model in range(numMaxwellModels):\\n if shearRatioV[model] != 0.0:\\n viscousStrainTpdt[model, iComp] = expFac[model] * \\\\\\n viscousStrainT[model, iComp] + \\\\\\n dqV[model] * deltaStrain\\n devStressTpdt += shearRatioV[model] * viscousStrainTpdt[model, iComp]\\n devStressTpdt = elasFac * devStressTpdt\\n stressTpdt[iComp] = diag[iComp] * meanStressTpdt + devStressTpdt\\n \\n return stressTpdt, viscousStrainTpdt\",\n \"def steel_stress(self,strain_dis, newFOS=None):\\r\\n\\t\\tstress = np.zeros(len(self.reinforcement))\\r\\n\\t\\tfor i,steel in enumerate(self.reinforcement):\\r\\n\\t\\t\\tstrain = np.interp(steel[0], self.mesh_center,strain_dis)\\r\\n\\t\\t\\tstress[i] = (self.steel(strain,newFOS)-self.concrete(strain,newFOS))\\r\\n\\t\\treturn stress\",\n \"def gym_to_state(self, state) -> Dict[str, Any]:\\n\\n joint_speeds = self._env.unwrapped.robot.joint_speeds\\n\\n joints_at_limit = float(self._env.unwrapped.robot.joints_at_limit)\\n\\n potential = float(self._env.unwrapped.potential)\\n if self.prev_potential is None:\\n self.prev_potential = potential\\n\\n progress = potential - self.prev_potential\\n\\n self.bonsai_state = {\\\"obs\\\": state.tolist(),\\n \\\"joint_speeds\\\": joint_speeds.tolist(),\\n \\\"joints_at_limit\\\": joints_at_limit,\\n \\\"progress\\\": progress}\\n\\n self.prev_potential = potential\\n\\n return self.bonsai_state\",\n \"def get_state(self, s):\\n return (torch.tensor(s, device=self.device).permute(2, 0, 1)).unsqueeze(0).float()\",\n \"def _preprocess_state(self, state):\\r\\n if np.isinf(self.observation_space.low).any() or np.isinf(self.observation_space.high).any(): return state\\r\\n return (state - self.observation_space.low) /(self.observation_space.high)\",\n \"def solve_steady_state(self):\\n # optimization has to be done on the reduced system\\n # TODO: implement different comp. sizes\\n s0 = self.model.get_initial_conc()\\n [L_inv, L, _] = self.model.N_partitioned\\n si = numpy.dot(L_inv, s0)\\n t = s0 - numpy.dot(L, si)\\n f = lambda x: numpy.linalg.norm(\\n self.dS_dt(numpy.dot(L, x) + t, 1))\\n ss_i = scipy.optimize.fmin_bfgs(f, si)\\n ss = numpy.dot(L, ss_i) + t\\n return ss\",\n \"def set_stress(self) -> None:\\n\\n c = self.cos()\\n s = self.sin()\\n transformation_matrix = np.array([-c, -s, c, s], dtype=np.float64)\\n nodal_displacements = self.__get_arranged_nodal_displacements()\\n self.__stress = (\\n self.youngs_modulus # type: ignore\\n / self.get_length()\\n * (transformation_matrix @ nodal_displacements.T)\\n )\",\n \"def _transit_state(self) -> None:\\n pass\",\n \"def target_state(self, s):\\n if s > self.total_length:\\n s = self.total_length\\n\\n return np.array([self.sign*s, 0, 0])\\n # return np.append(np.dot(self.g, np.array([s, 0, 1]))[:2], self.start_theta)\",\n \"def to_se3(self, state: Vector) -> RigidTransform:\\n return (state[:9],state[9:12])\",\n \"def to_se3(self, state: Vector) -> RigidTransform:\\n return (state[:9],state[9:])\",\n \"def _calcStress(self, strainV, muV, lambdaV, shearRatioV, maxwellTimeV,\\n totalStrainV, viscousStrainV, initialStressV, initialStrainV,\\n stateVars):\\n import scipy.misc\\n \\n # Define some numpy arrays\\n strainTpdt = numpy.array(totalStrainV, dtype=numpy.float64)\\n strainT = numpy.array(strainV, dtype=numpy.float64)\\n viscousStrainT = numpy.array(viscousStrainV, dtype=numpy.float64)\\n initialStress = numpy.array(initialStressV, dtype=numpy.float64)\\n initialStrain = numpy.array(initialStrainV, dtype=numpy.float64)\\n\\n # Compute viscous factors for each Maxwell model\\n dqV = numpy.zeros(numMaxwellModels, dtype=numpy.float64)\\n for model in range(numMaxwellModels):\\n dqV[model] = self._computeViscousFactor(maxwellTimeV[model])\\n\\n # Compute current stress and viscous strain\\n stressTpdt, viscousStrainTpdt = self._computeStress(strainTpdt,\\n muV,\\n lambdaV,\\n shearRatioV,\\n maxwellTimeV,\\n dqV,\\n strainT,\\n viscousStrainT,\\n initialStress,\\n initialStrain,\\n stateVars)\\n\\n # Form updated state variables\\n strainTpdtVec = numpy.ravel(strainTpdt)\\n viscousStrainTpdtVec = numpy.ravel(viscousStrainTpdt)\\n stateVarsUpdated = numpy.concatenate((strainTpdtVec, viscousStrainTpdtVec))\\n\\n # Compute components of tangent constitutive matrix using numerical\\n # derivatives.\\n derivDx = 1.0e-12\\n derivOrder = 3\\n elasticConstsList = []\\n\\n for stressComp in range(tensorSize):\\n for strainComp in range(tensorSize):\\n dStressDStrain = stressComp + strainComp\\n dStressDStrain = scipy.misc.derivative(self._calcStressComponent,\\n strainTpdt[strainComp],\\n dx=derivDx,\\n args=(strainComp,\\n stressComp,\\n strainTpdt,\\n muV,\\n lambdaV,\\n shearRatioV,\\n maxwellTimeV,\\n dqV,\\n strainT,\\n viscousStrainT,\\n initialStress,\\n initialStrain,\\n stateVars),\\n order=derivOrder)\\n elasticConstsList.append(dStressDStrain)\\n\\n elasticConsts = numpy.array(elasticConstsList, dtype=numpy.float64)\\n\\n return (elasticConsts, numpy.ravel(stressTpdt),\\n numpy.ravel(stateVarsUpdated))\",\n \"def _reduce_states(self, fw_st, bw_st):\\n hidden_dim = self._hps.hidden_dim\\n with tf.variable_scope('reduce_final_st'):\\n\\n # Define weights and biases to reduce the cell and reduce the state\\n w_reduce_c = tf.get_variable('w_reduce_c', [hidden_dim * 2, hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\\n w_reduce_h = tf.get_variable('w_reduce_h', [hidden_dim * 2, hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\\n bias_reduce_c = tf.get_variable('bias_reduce_c', [hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\\n bias_reduce_h = tf.get_variable('bias_reduce_h', [hidden_dim], dtype=tf.float32, initializer=self.trunc_norm_init)\\n\\n # Apply linear layer\\n old_c = tf.concat(axis=1, values=[fw_st.c, bw_st.c]) # Concatenation of fw and bw cell\\n old_h = tf.concat(axis=1, values=[fw_st.h, bw_st.h]) # Concatenation of fw and bw state\\n new_c = tf.nn.relu(tf.matmul(old_c, w_reduce_c) + bias_reduce_c) # Get new cell from old cell\\n new_h = tf.nn.relu(tf.matmul(old_h, w_reduce_h) + bias_reduce_h) # Get new state from old state\\n return tf.contrib.rnn.LSTMStateTuple(new_c, new_h) # Return new cell and state\",\n \"def set_stress(self, stress=None):\\n self.status()\\n if not stress:\\n if self.__cod == 'vasp': \\n #getData = VASP()\\n getData = vasp.Stress()\\n outfile = 'vasprun.xml'\\n elif self.__cod == 'espresso':\\n getData = espresso.Stress()\\n outfile = 'espresso.out'\\n for atoms in self.__structures.items():\\n \\n if not atoms[1].status:\\n atoms[1].stress = np.zeros((3,3))\\n continue\\n #getData.set_outfile('%s/%s/'%atoms[0] + outfile)\\n #getData.set_gsEnergy()\\n getData.set_fname(self.__workdir + '%s/'%atoms[1].path.lstrip('.') + outfile)\\n getData.set_stress()\\n #atoms[1].gsenergy = getData.get_gsEnergy()\\n atoms[1].stress = getData.get_stress()\\n \\n self.__stress = stress\",\n \"def reflect_state(self, s):\\n s[2:8] = reflect_control_vector(s[2:8])\\n s[11:17] = reflect_control_vector(s[11:17])\\n return s\",\n \"def TXS(self, *_):\\n self.reg.S = self.reg.X\\n self.reg.N = self.reg.S << 7\\n self.reg.Z = self.reg.S == 0\",\n \"def _steadystate2initial(self):\\n self.ss_result = []\\n ss = self.steady_state\\n sizeclasses = numpy.unique(ss[:,0])\\n for sc in sizeclasses:\\n criterium = (ss[:,0]==sc)\\n target = numpy.where(criterium)[0]\\n div = len(target)\\n masses = [ss[t, 1:].sum() for t in target]\\n mass_sum = sum(masses)\\n m = mass_sum / div\\n m_std = self._std(masses)\\n acids = ss[target, 1] / masses\\n a = acids.sum() / div\\n a_std = self._std(acids)\\n waters = ss[target, 2] / masses\\n w = waters.sum() / div\\n w_std = self._std(waters)\\n ethanols = ss[target, 3] / masses\\n e = ethanols.sum() / div\\n e_std = self._std(ethanols)\\n nonsolubles = ss[target, 4] / masses\\n n = nonsolubles.sum() / div\\n n_std = self._std(nonsolubles)\\n humuses = ss[target, 5] / masses\\n h = humuses.sum() / div\\n h_std = self._std(humuses)\\n self.ss_result.append([m, m_std, a, a_std, w, w_std,\\n e, e_std, n, n_std, h, h_std, sc])\",\n \"def switch_to_state(self, state):\\n self.switch_state = state\",\n \"def test_set_sT(self):\\n s = State(substance=\\\"water\\\")\\n s.sT = Q_(7496.2021523754065, \\\"J/(kg*K)\\\"), Q_(400.0, \\\"K\\\")\\n # Pylance does not support NumPy ufuncs\\n assert np.isclose(s.T, Q_(400.0, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.p, Q_(101325.0, \\\"Pa\\\")) # type: ignore\\n assert np.isclose(s.sT[1], Q_(400.0, \\\"K\\\")) # type: ignore\\n assert np.isclose(s.sT[0], Q_(7496.2021523754065, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.u, Q_(2547715.3635084038, \\\"J/kg\\\")) # type: ignore\\n assert np.isclose(s.s, Q_(7496.2021523754065, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.cp, Q_(2009.2902478486988, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.cv, Q_(1509.1482452129906, \\\"J/(kg*K)\\\")) # type: ignore\\n assert np.isclose(s.v, Q_(1.801983936953226, \\\"m**3/kg\\\")) # type: ignore\\n assert np.isclose(s.h, Q_(2730301.3859201893, \\\"J/kg\\\")) # type: ignore\\n assert s.x is None\",\n \"def set_state(self,s):\\n self.state = s\",\n \"def state_transition(CS, CP, state, events, soft_disable_timer, v_cruise_kph, AM):\\n enabled = isEnabled(state)\\n\\n v_cruise_kph_last = v_cruise_kph\\n\\n # if stock cruise is completely disabled, then we can use our own set speed logic\\n if not CP.enableCruise:\\n v_cruise_kph = update_v_cruise(v_cruise_kph, CS.buttonEvents, enabled)\\n elif CP.enableCruise and CS.cruiseState.enabled:\\n v_cruise_kph = CS.cruiseState.speed * CV.MS_TO_KPH\\n\\n # decrease the soft disable timer at every step, as it's reset on\\n # entrance in SOFT_DISABLING state\\n soft_disable_timer = max(0, soft_disable_timer - 1)\\n\\n # DISABLED\\n if state == State.disabled:\\n if get_events(events, [ET.ENABLE]):\\n if get_events(events, [ET.NO_ENTRY]):\\n for e in get_events(events, [ET.NO_ENTRY]):\\n AM.add(str(e) + \\\"NoEntry\\\", enabled)\\n\\n else:\\n if get_events(events, [ET.PRE_ENABLE]):\\n state = State.preEnabled\\n else:\\n state = State.enabled\\n AM.add(\\\"enable\\\", enabled)\\n v_cruise_kph = initialize_v_cruise(CS.vEgo, CS.buttonEvents, v_cruise_kph_last)\\n\\n # ENABLED\\n elif state == State.enabled:\\n if get_events(events, [ET.USER_DISABLE]):\\n state = State.disabled\\n AM.add(\\\"disable\\\", enabled)\\n\\n elif get_events(events, [ET.IMMEDIATE_DISABLE]):\\n state = State.disabled\\n for e in get_events(events, [ET.IMMEDIATE_DISABLE]):\\n AM.add(e, enabled)\\n\\n elif get_events(events, [ET.SOFT_DISABLE]):\\n state = State.softDisabling\\n soft_disable_timer = 300 # 3s\\n for e in get_events(events, [ET.SOFT_DISABLE]):\\n AM.add(e, enabled)\\n\\n # SOFT DISABLING\\n elif state == State.softDisabling:\\n if get_events(events, [ET.USER_DISABLE]):\\n state = State.disabled\\n AM.add(\\\"disable\\\", enabled)\\n\\n elif get_events(events, [ET.IMMEDIATE_DISABLE]):\\n state = State.disabled\\n for e in get_events(events, [ET.IMMEDIATE_DISABLE]):\\n AM.add(e, enabled)\\n\\n elif not get_events(events, [ET.SOFT_DISABLE]):\\n # no more soft disabling condition, so go back to ENABLED\\n state = State.enabled\\n\\n elif get_events(events, [ET.SOFT_DISABLE]) and soft_disable_timer > 0:\\n for e in get_events(events, [ET.SOFT_DISABLE]):\\n AM.add(e, enabled)\\n\\n elif soft_disable_timer <= 0:\\n state = State.disabled\\n\\n # PRE ENABLING\\n elif state == State.preEnabled:\\n if get_events(events, [ET.USER_DISABLE]):\\n state = State.disabled\\n AM.add(\\\"disable\\\", enabled)\\n\\n elif get_events(events, [ET.IMMEDIATE_DISABLE, ET.SOFT_DISABLE]):\\n state = State.disabled\\n for e in get_events(events, [ET.IMMEDIATE_DISABLE, ET.SOFT_DISABLE]):\\n AM.add(e, enabled)\\n\\n elif not get_events(events, [ET.PRE_ENABLE]):\\n state = State.enabled\\n\\n return state, soft_disable_timer, v_cruise_kph, v_cruise_kph_last\",\n \"def toState(attrs=ALL):\",\n \"def _calcStressComponent(self, strainVal, strainComp, stressComp, strainTpdt,\\n muV, lambdaV, shearRatioV, maxwellTimeV, dqV,\\n totalStrainT, viscousStrainT,\\n initialStress, initialStrain,\\n stateVars):\\n strainTest = numpy.array(strainTpdt, dtype=numpy.float64)\\n strainTest[strainComp] = strainVal\\n stressTpdt, viscousStrainTpdt = self._computeStress(strainTest,\\n muV,\\n lambdaV,\\n shearRatioV,\\n maxwellTimeV,\\n dqV,\\n totalStrainT,\\n viscousStrainT,\\n initialStress,\\n initialStrain,\\n stateVars)\\n return stressTpdt[stressComp]\",\n \"def dormant_to_swd(self):\\n\\n # 8 SWDIOTMS cycles high + 128-bit selection alert sequence.\\n self.selection_alert()\\n\\n # 4-bit SWDIOTMS cycles low + 8-bit SWD activation code.\\n self.swd_activation_code()\\n\\n # SWD line reset (>50 SWDIOTMS cycles high).\\n self.line_reset()\\n\\n # >=2 SWDIOTMS cycles low.\\n self.idle_cycles(2)\",\n \"def state_tensor_convert(self,state):\\n return torch.Tensor(state)\",\n \"def target_state(self, s):\\n raise NotImplementedError()\",\n \"def __getstate__(self):\\n state = Object.__getstate__(self)\\n state['_strain'] = set()\\n return state\",\n \"def simplify(self):\\n state_copy = copy.deepcopy(self)\\n state_copy.space.spacecrafts = [state_copy.spacecraft] + state_copy.space.close_spacecrafts_to(\\n state_copy.spacecraft, self.PERCEPTION_DISTANCE)\\n\\n return state_copy\",\n \"def effective_stress(self):\\n tau = self.deviatoric_stress_tensor()\\n tu_xx = tau[0,0]\\n tu_yy = tau[1,1]\\n tu_zz = tau[2,2]\\n tu_xy = tau[0,1]\\n tu_xz = tau[0,2]\\n tu_yz = tau[1,2]\\n \\n # Second invariant of the strain rate tensor squared\\n taudot = 0.5 * (+ tu_xx**2 + tu_yy**2 + tu_zz**2) \\\\\\n + tu_xy**2 + tu_xz**2 + tu_yz**2\\n return taudot\",\n \"def success_state(self):\\n state = np.array(self.get_success_state_arr())\\n om = utils.build_occupancy_maps(utils.build_humans(state))\\n #print(\\\"OM: \\\", om.size())\\n # We only have a batch of one so just get the first element of\\n # transform and rotate\\n state = utils.transform_and_rotate(state.reshape((1, -1)))[0]\\n #print(\\\"State: \\\", state.size())\\n return torch.cat((state, om), dim=1).unsqueeze(0)\",\n \"def state_transl(state):\\n nonlocal state_cnt\\n nonlocal state_transl_dict\\n\\n if state not in state_transl_dict.keys():\\n state_transl_dict[state] = state_cnt\\n state_cnt += 1\\n\\n return str(state_transl_dict[state])\",\n \"def state_transl(state):\\n nonlocal state_cnt\\n nonlocal state_transl_dict\\n\\n if state not in state_transl_dict.keys():\\n state_transl_dict[state] = state_cnt\\n state_cnt += 1\\n\\n return str(state_transl_dict[state])\",\n \"def concrete_stress(self,strain, newFOS=None):\\r\\n\\t\\tstress = np.zeros(len(strain))\\r\\n\\t\\tfor i,strn in enumerate(strain):\\r\\n\\t\\t\\tstress[i] = self.concrete(strn,newFOS)\\r\\n\\t\\treturn stress\",\n \"def transition_to_state(state):\\n\\n # Clear our \\\"time-in-state\\\" counter.\\n m.d.ss += cycles_in_state.eq(0)\\n\\n # If we have any additional entry conditions for the given state, apply them.\\n if state in tasks_on_entry:\\n m.d.ss += tasks_on_entry[state]\\n\\n m.next = state\",\n \"def _preprocess_state(self, state):\\n\\n def normalize_matrix(matrix, min_val, max_val):\\n \\\"\\\"\\\"normalizes all elements in matrix to be between min val and max val\\n \\\"\\\"\\\"\\n return (max_val - min_val) * (matrix - np.min(matrix)) / (np.max(matrix) - np.min(matrix)) + min_val\\n\\n A, b, c0, cuts_a, cuts_b = state\\n\\n min_lhs = np.min([np.min(A), np.min(cuts_a)])\\n max_lhs = np.max([np.max(A), np.max(cuts_a)])\\n min_rhs = np.min([np.min(b), np.min(cuts_b)])\\n max_rhs = np.max([np.max(b), np.max(cuts_b)])\\n\\n A = normalize_matrix(A, min_lhs, max_lhs)\\n cuts_a = normalize_matrix(cuts_a, min_lhs, max_lhs)\\n\\n b = normalize_matrix(b, min_rhs, max_rhs)\\n cuts_b = normalize_matrix(cuts_b, min_rhs, max_rhs)\\n\\n processed_state = (A, b, c0, cuts_a, cuts_b)\\n condensed_state = self._condense_state(processed_state)\\n return condensed_state\",\n \"def _apply_basis_state(self, state, wires):\\n # translate to wire labels used by device\\n device_wires = self.map_wires(wires)\\n\\n # length of basis state parameter\\n n_basis_state = len(state)\\n\\n if not set(state.tolist()).issubset({0, 1}):\\n raise ValueError(\\\"BasisState parameter must consist of 0 or 1 integers.\\\")\\n\\n if n_basis_state != len(device_wires):\\n raise ValueError(\\\"BasisState parameter and wires must be of equal length.\\\")\\n\\n # get computational basis state number\\n basis_states = 2 ** (self.num_wires - 1 - np.array(device_wires))\\n basis_states = qml.math.convert_like(basis_states, state)\\n num = int(qml.math.dot(state, basis_states))\\n\\n self._state = self._create_basis_state(num)\",\n \"def to_cwl_state_string(state: 'JobState') -> str:\\n state_to_cwl_string = {\\n JobState.SUBMITTED: 'Waiting',\\n JobState.STAGING_IN: 'Waiting',\\n JobState.WAITING: 'Running',\\n JobState.RUNNING: 'Running',\\n JobState.FINISHED: 'Running',\\n JobState.STAGING_OUT: 'Running',\\n JobState.SUCCESS: 'Success',\\n JobState.STAGING_IN_CR: 'Waiting',\\n JobState.WAITING_CR: 'Running',\\n JobState.RUNNING_CR: 'Running',\\n JobState.STAGING_OUT_CR: 'Running',\\n JobState.CANCELLED: 'Cancelled',\\n JobState.SYSTEM_ERROR: 'SystemError',\\n JobState.TEMPORARY_FAILURE: 'TemporaryFailure',\\n JobState.PERMANENT_FAILURE: 'PermanentFailure',\\n }\\n return state_to_cwl_string[state]\",\n \"def target_state(self, s):\\n\\n if s < self.total_length and s - self.transition >= self.subpaths[self.current_path].total_length:\\n self.transition += self.subpaths[self.current_path].total_length\\n offset = self.subpaths[self.current_path].target_state(self.subpaths[self.current_path].total_length)\\n self.g = np.dot(self.g, rigid(offset))\\n self.start_theta += offset[2]\\n self.start_theta = (self.start_theta+np.pi)%(np.pi*2) - np.pi\\n self.current_path += 1\\n \\n if s > self.total_length:\\n s = self.total_length\\n\\n state = self.subpaths[self.current_path].target_state(s-self.transition)\\n state[:2] = np.dot(self.g, np.append(state[:2], 1))[:2]\\n state[2] += self.start_theta\\n\\n return state\",\n \"def _get_state(self):\\n start = self.design.first_unassigned_site\\n return self.target.padded_encoding[\\n start : start + 2 * self._env_config.state_radius + 1\\n ]\",\n \"def shock2state(self, shock):\\n\\n stype, ssize = shock[:2]\\n state = np.zeros(self.dimq)\\n state[-self.dimeps:][list(self.shocks).index(stype)] = ssize\\n\\n return state\",\n \"def generate_swapped_stress_strain_one_file():\\n fname = 'resources/simple_swapped_data.json'\\n\\n stress = np.linspace(0, 100)\\n stress_time = np.linspace(0, 100)\\n strain = np.linspace(0, 100)\\n strain_time = np.linspace(0, 100)\\n expected = pif.System(\\n subSystems=None,\\n properties=[\\n pif.Property(name='strain',\\n scalars=list(strain),\\n conditions=pif.Value(\\n name='time',\\n scalars=list(strain_time))),\\n pif.Property(name='stress',\\n scalars=list(stress),\\n conditions=pif.Value(\\n name='time',\\n scalars=list(stress_time)))\\n\\n ])\\n with open(fname, 'w') as data:\\n pif.dump(expected, data)\\n\\n return {\\n 'file_name': fname,\\n 'expected': expected\\n }\",\n \"def cost_state_old(s,state_considered,L,Q,gamma):\\n if s==s.goal:\\n return 0\\n model=Model(\\\"trajectory of polytopes\\\")\\n p={}\\n for row in range(s.n):\\n p[row]=model.addVar(lb=-1,ub=1)\\n model.update()\\n GLG=np.dot(state_considered.G.T,np.dot(L,state_considered.G))\\n theta=state_considered.successor[2]\\n u=state_considered.successor[1]\\n i=state_considered.mode\\n theta_Q_theta=np.dot(theta.T,np.dot(Q,theta))\\n J=QuadExpr()\\n for row in range(s.n):\\n for k in range(s.n):\\n J.add(p[row]*p[k]*GLG[row,k]+p[row]*p[k]*theta_Q_theta[row,k])\\n model.setParam('OutputFlag',False)\\n model.setObjective(J)\\n model.optimize()\\n return model.ObjVal+np.asscalar(np.dot(state_considered.x.T,np.dot(L,state_considered.x))+np.dot(u.T,np.dot(Q,u))+gamma)\",\n \"def state_action(self, s, a):\\r\\n s_x, s_y = s[0][0], s[0][1]\\r\\n s_vx, s_vy = s[1][0], s[1][1]\\r\\n a_x, a_y = a[0] + 1, a[1] + 1\\r\\n s_a = (s_x, s_y, s_vx, s_vy, a_x, a_y)\\r\\n\\r\\n return s_a\",\n \"def define_state_transition_SecuritySettlement():\\n\\n state_chart_name = 'FSwiftSecuritySettlementIn'\\n old_state_chart_name = 'SecuritySettlementConfMsg'\\n state_chart = {\\n 'Ready': {'Identified' : 'Paired',\\n 'NotIdentified' : 'Unpaired',\\n 'SecurityTransfer' : 'TradeGenerated'},\\n 'Paired': {'PartialMatch' : 'PartialMatch',\\n 'NoMatch' : 'Difference',\\n 'Match' : 'Settled',\\n 'AlreadyCancelled' : 'ManuallyCancelled' },\\n 'Unpaired': {'Ignore' : 'Ignored',\\n 'Identified' : 'Paired'},\\n 'Difference': {'ManuallyCorrect' : 'ManuallyCorrected',\\n 'Unpair' : 'Unpaired',\\n 'Re-Match' : 'Paired',\\n 'ManuallyMatch' : 'Settled'},\\n 'PartialMatch': {'Identified' : 'Paired'},\\n 'TradeGenerated': {'Identified' : 'Paired'},\\n 'Settled': {'Unpair' : 'Unpaired'},\\n }\\n co_string = 'Ready,-500,0;Paired,-300,0;PartialMatch,-300,400;Settled,400,0;Unpaired,-300,-200;Ignored,400,-200;Difference,400,250;ManuallyCorrected,400,400;TradeGenerated,-500,400;ManuallyCancelled,100,400'\\n #state_charts_list.append({state_chart_name:[state_chart]+[co_string]})\\n\\n return state_chart_name, state_chart, old_state_chart_name, co_string\",\n \"def set_state(self, state):\\n for v in self._variables:\\n self._state[self._mapping[v]] = state[v]\\n if any(v not in {1, -1} for v in self._state):\\n raise ValueError(\\\"State must contain only 1's and -1's\\\")\",\n \"def get_strand_state(w, c):\\n if (w is None) or (c is None) or (w + c == 0):\\n return (0, 0)\\n r = w / (w + c)\\n if r < 0.2:\\n return (0, 2)\\n elif r > 0.8:\\n return (2, 0)\\n else:\\n return (1, 1)\",\n \"def action(self, S, t):\\n i, b = t\\n mask = 1 << i\\n if b:\\n V = S | mask\\n else:\\n V = S & ~ mask\\n if V in self._states:\\n return V\\n else:\\n return S\",\n \"def state_transition(self, curr_state, curr_action):\\n curr_state[curr_action[0]] = curr_action[1]\\n return curr_state\",\n \"def propagate_state(s,t0,tf):\\n\\n return rk4(s,t0,tf)\",\n \"def fromState(state):\",\n \"def convert_input(self, inlist):\\n\\n # First map the ordered state list from the simulation into a\\n # state dictionary for the brain.\\n self.state = {\\n 'heat_cost':\\t\\tinlist[0],\\n 'set_temp':\\t\\t\\tinlist[1],\\n 'room_temp':\\t\\tinlist[2],\\n 'room_temp_change':\\t\\tinlist[3],\\n 'outside_temp':\\t\\tinlist[4],\\n 'outside_temp_change':\\tinlist[5],\\n }\\n\\n # To compute the reward function value we start by taking the\\n # difference between the set point temperature and the actual\\n # room temperature.\\n tdiff = math.fabs(self.state['set_temp'] - self.state['room_temp'])\\n\\n # Raise the difference to the 0.4 power. The non-linear\\n # function enhances the reward distribution near the desired\\n # temperature range. Please refer to the Bonsai training\\n # video on reward functions for more details.\\n nonlinear_diff = pow(tdiff, 0.4)\\n\\n # Scale the nonlinear difference so differences in the range\\n # +/- 2 degrees (C) map between 0 and 1.0.\\n # 2 degree ^ 0.4 = 1.32\\n scaled_diff = nonlinear_diff / 1.32\\n\\n # Since we need a positive going reward function, subtract the\\n # scaled difference from 1.0. This reward value will be 1.0\\n # when we are precisely matching the set point and will fall\\n # to less than 0.0 when we exceed 2 degrees (C) from the set\\n # point.\\n self.reward = 1.0 - scaled_diff\\n \\n self.terminal = self.nsteps >= 240 or self.reward < 0.0\\n\\n if self.nsteps > 0:\\n self.total_reward += self.reward\\n\\n return self.state, self.reward, self.terminal\",\n \"def state(self, state: str) -> None:\",\n \"def featurize_state(self, state):\\n s_scaled = self.scaler.transform([state])\\n s_transformed = self.feature_transformer.transform(s_scaled)\\n return s_transformed[0]\",\n \"def state_transition(self, curr_state, curr_action):\\n #The state transition happens from the current state to the next state based on agent's action\\n curr_state[curr_action[0]]=curr_action[1]\\n return curr_state\",\n \"def get_state(self, state):\\n status = [u'noState', u'poweredOn', u'blocked', u'suspended', \\n u'poweredOff', u'poweredOff', u'crashed']\\n return status[int(state)]\",\n \"def state_transition(self):\\n self.x = np.dot(self.F, self.x)\\n self.x_noisy = noise_fun(np.dot(self.F, self.x_noisy), self.Q)\\n return self.x\",\n \"def stiffenerBuckle(dim):\\n bst = dim[0]\\n tst = dim[1]\\n tsk = dim[2]\\n\\n epsilont = kt * ((tst / bst)) ** 2\\n Et = (Esk * tsk) + (Est * ((bst * tst) / bsk))\\n Nst = Et*epsilont # Critical Load\\n rsf = Nst/Nx\\n return rsf - 1 # Using a target Reserve Factor of 1\",\n \"def get_state(self):\\n return STAR_STATES[self.state][0]\",\n \"def get_state(self):\\n return STAR_STATES[self.state][0]\",\n \"def S(self):\\n return self._states\",\n \"def define_state_transition_SettlementStatusProcessingAdvice():\\n\\n state_chart_name = 'FSwiftSettStatusProcessAdviceIn'\\n old_state_chart_name = ''\\n state_chart = {\\n 'Ready': {'Identified': 'Paired',\\n 'NotIdentified': 'Unpaired'},\\n\\n 'Unpaired': {'Identified': 'Paired'},\\n\\n 'Paired': {'Acknowledge': 'Acknowledged',\\n 'NoMatch': 'NotMatched',\\n 'Match': 'Matched',\\n 'Pending': 'PendingSettlement',\\n 'Failing': 'FailingSettlement',\\n 'Reject': 'Rejected',\\n 'Cancel': 'Cancelled',},\\n\\n 'Acknowledged': {'NoMatch': 'NotMatched',\\n 'Match': 'Matched',\\n 'Pending': 'PendingSettlement',\\n 'Failing': 'FailingSettlement',\\n 'Cancel': 'Cancelled',\\n 'Reject': 'Rejected',\\n 'AmndCancRequest':'AmendCancelRequested',\\n 'AmndCancPending':'AmendCancelPending',\\n 'Done':'Processed'},\\n\\n 'Matched': {'Pending': 'PendingSettlement',\\n 'Cancel': 'Cancelled',\\n 'Reject': 'Rejected',\\n 'Failing': 'FailingSettlement',\\n 'AmndCancRequest':'AmendCancelRequested',\\n 'AmndCancPending':'AmendCancelPending',\\n 'Done':'Processed'\\n },\\n\\n 'FailingSettlement':{'AmndCancRequest':'AmendCancelRequested',\\n 'AmndCancPending':'AmendCancelPending',\\n 'Reject': 'Rejected',\\n 'Cancel': 'Cancelled',\\n 'Done':'Processed'},\\n\\n 'NotMatched': {'Match': 'Matched',\\n 'Pending': 'PendingSettlement',\\n 'Failing': 'FailingSettlement',\\n 'Cancel': 'Cancelled',\\n 'Reject': 'Rejected',\\n 'AmndCancRequest':'AmendCancelRequested',\\n 'AmndCancPending':'AmendCancelPending',\\n 'Done':'Processed'},\\n\\n 'AmendCancelRequested': {'AmndCancComplete':'AmendCancelCompleted',\\n 'Done':'Processed'},\\n\\n 'AmendCancelPending': {'AmndCancComplete':'AmendCancelCompleted',\\n 'Done':'Processed'},\\n\\n 'PendingSettlement': {'Failing': 'FailingSettlement',\\n 'Cancel': 'Cancelled',\\n 'AmndCancRequest':'AmendCancelRequested',\\n 'AmndCancPending':'AmendCancelPending',\\n 'Reject': 'Rejected',\\n 'Done':'Processed'},\\n 'Cancelled' : { 'Done':'Processed'},\\n 'AmendCancelCompleted' : { 'Done':'Processed'},\\n\\n 'Rejected': {'Cancel': 'Cancelled',\\n 'Done': 'Processed'}\\n\\n }\\n\\n co_string = 'Paired,73,-105;Cancelled,676,329;Not Match,696,-223;Match,1271,173;AmendCancelPending,728,189;Matched,347,-133;Unpaired,-178,-351;Acknowledge,435,-110;Reject,229,538;AmendCancelCompleted,862,90;Rejected,177,338;NotMatched,432,-283;Acknowledged,549,-429;Processed,1072,-131;Pending Settlement,1193,495;PendingSettlement,304,22;FailingSettlement,255,179;Ready,-237,-98;AmendCancelRequested,737,0;'\\n #state_charts_list.append({state_chart_name: [state_chart] + [co_string]})\\n\\n return state_chart_name, state_chart, old_state_chart_name, co_string\",\n \"def compute_steady_state(self, capital):\\n#TODO\\n NotDefinedError=create_grids(s)\\n NotDefinedError=compute_poly(s)\\n else:\\n NotImplementedError\\n # Make an initial guess of market clearing capital levels from Young, 2010 method using histograms \\n np.fsolve(lambda a, b, c: compute_MC_Residual_Histogram(),x0,args)\",\n \"def ratestate_sl(t,y,o):\\n State=y[:o['N']]\\n Vel=y[o['N']:2*o['N']] \\n Disp=y[2*o['N']:3*o['N']]\\n # Slip law\\n dStatedt = np.concatenate((np.zeros(o['Fstart']),\\n -State[o['Fstart']:o['Fend']]*Vel[o['Fstart']:o['Fend']]*np.log(State[o['Fstart']:o['Fend']]*Vel[o['Fstart']:o['Fend']]),\\n np.zeros(o['N']-o['Fend'])))\\n stress=getstress(Vel,o);\\n dVeldt = np.concatenate((np.zeros(o['Fstart']),\\n ((o['aoverb'][o['Fstart']:o['Fend']])/Vel[o['Fstart']:o['Fend']] + o['eta'])**(-1)*\\n (-dStatedt[o['Fstart']:o['Fend']]/State[o['Fstart']:o['Fend']] - stress[o['Fstart']:o['Fend']]/2),\\n np.zeros(o['N']-o['Fend'])))\\n dDispdt = Vel\\n dy = np.concatenate((dStatedt,dVeldt,dDispdt))\\n print(t)\\n return dy\",\n \"def CTMCtoStormpy(h):\\n\\tstate_labelling = _buildStateLabeling(h)\\n\\ttransition_matrix = deepcopy(h.matrix)\\n\\te = array([h.e(s) for s in range(h.nb_states)])\\n\\ttransition_matrix /= e[:,newaxis]\\n\\ttransition_matrix = st.build_sparse_matrix(transition_matrix)\\n\\tcomponents = st.SparseModelComponents(transition_matrix=transition_matrix,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t state_labeling=state_labelling,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t rate_transitions=True)\\n\\tcomponents.exit_rates = e\\n\\tctmc = st.storage.SparseCtmc(components)\\n\\treturn ctmc\",\n \"def state(params1):\\n variational_circuit(params1)\\n return qml.state()\",\n \"def jajapyModeltoStormpy(h):\\n\\tif type(h) == MDP:\\n\\t\\treturn MDPtoStormpy(h)\\n\\telif type(h) == CTMC:\\n\\t\\treturn CTMCtoStormpy(h)\\n\\telif type(h) == MC:\\n\\t\\treturn MCtoStormpy(h)\\n\\telif type(h) == PCTMC:\\n\\t\\ttry:\\n\\t\\t\\th = PCTMCtoCTMC(h)\\n\\t\\texcept ValueError:\\n\\t\\t\\traise ValueError(\\\"Cannot convert non-instantiated PCTMC to Stormpy.\\\")\\n\\t\\treturn CTMCtoStormpy(h)\\n\\telse:\\n\\t\\traise TypeError(str(type(h))+' cannot be translated to a stormpy sparse model.')\",\n \"def get_steady_state(self, s0=None, tol=1e-12, max_steps=100, max_computation_time=180, old_ss=None,\\n d_params=None, old_conc_resp=None, string_output=False):\\n if self._no_steady_state:\\n raise NoncriticalError('No steady state could be found')\\n if s0 is None:\\n s0 = self.model.get_initial_conc(with_rate_rule_params=True)\\n self._steady_state_s0 = s0\\n if self._steady_state is not None and numpy.linalg.norm(self._steady_state_s0 - s0) < 0.0001:\\n if string_output:\\n return misc.matrix2string(numpy.array([self._steady_state]), self.model.species_ids)\\n return self._steady_state\\n # linear approximation of new ss\\n if old_ss is not None and old_conc_resp is not None and d_params is not None:\\n s0 = old_ss + numpy.dot(old_conc_resp, d_params)\\n result = [s0]\\n\\n start_comp_time = time.time()\\n sim_time = 0\\n for i in range(max_steps):\\n stepsize = 10 ** (i / 10 - 1)\\n t = numpy.linspace(sim_time, sim_time + stepsize, 100)\\n s0 = result[-1]\\n try:\\n result = self.odeint_wrapper(self.dS_dt, s0, t)\\n except NoncriticalError, e:\\n if i > 0:\\n self._no_steady_state = True\\n raise NoncriticalError(\\n 'No steady state could be found. This could indicate and oszillating model.')\\n else:\\n raise e\\n if (numpy.linalg.norm(result[0] - result[-1]) / s0.size) < tol:\\n break\\n sim_time += stepsize\\n if i == (max_steps - 1) or (time.time() - start_comp_time > max_computation_time):\\n self._no_steady_state = True\\n raise NoncriticalError(\\n 'No steady state could be found. This could indicate and oszillating model.')\\n self._steady_state = result[-1]\\n if string_output:\\n return misc.matrix2string(numpy.array([result[1]]).T,\\n ['Conc.'],\\n self.model.species_ids,\\n justify='left')\\n return result[1]\",\n \"def reset_reservoir(self):\\n self.state = np.zeros((self.state_size,1),dtype=self.typefloat)\",\n \"def flowStress(f_hard,eps,d,q,a):\\n\\n pass\",\n \"def reset_states(self):\\n self.mean_makespan_baseline.assign(0)\\n self.mean_makespan_train.assign(0)\\n self.step.assign(0)\",\n \"def call(self, state):\\n x = tf.cast(state, tf.float32)\\n x = self.flatten(x)\\n x -= self.min_vals\\n x /= self.max_vals - self.min_vals\\n x = 2.0 * x - 1.0 # Rescale in range [-1, 1].\\n x = self.dense1(x)\\n x = self.dense2(x)\\n x = self.last_layer(x)\\n return x\",\n \"def test_state_units_SI(self):\\n s = State(\\\"water\\\", T=Q_(100, \\\"degC\\\"), p=Q_(1.0, \\\"atm\\\"), units=\\\"SI\\\")\\n assert s.units == \\\"SI\\\"\\n assert s.cv.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.cp.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.s.units == \\\"kilojoule / kelvin / kilogram\\\"\\n assert s.h.units == \\\"kilojoule / kilogram\\\"\\n assert s.T.units == \\\"degree_Celsius\\\"\\n assert s.u.units == \\\"kilojoule / kilogram\\\"\\n assert s.v.units == \\\"meter ** 3 / kilogram\\\"\\n assert s.p.units == \\\"bar\\\"\",\n \"def test_state_preparation(self, tol, qubit_device_3_wires, basis_state, wires, target_state):\\n\\n @qml.qnode(qubit_device_3_wires)\\n def circuit():\\n BasisStatePreparation(basis_state, wires)\\n\\n # Pauli Z gates identify the basis state\\n return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1)), qml.expval(qml.PauliZ(2))\\n\\n # Convert from Pauli Z eigenvalues to basis state\\n output_state = [0 if x == 1.0 else 1 for x in circuit()]\\n\\n assert np.allclose(output_state, target_state, atol=tol, rtol=0)\",\n \"def test_lowercase_input(self):\\n State(substance=\\\"water\\\")\\n State(substance=\\\"r22\\\")\\n State(substance=\\\"r134a\\\")\\n State(substance=\\\"ammonia\\\")\\n State(substance=\\\"propane\\\")\\n State(substance=\\\"air\\\")\\n State(substance=\\\"isobutane\\\")\\n State(substance=\\\"carbondioxide\\\")\\n State(substance=\\\"oxygen\\\")\\n State(substance=\\\"nitrogen\\\")\",\n \"def str_state():\\n\\n asserts = get_solver().assertions()\\n if len(asserts) == 0:\\n return None\\n return str(z3.simplify(z3.And(*asserts),\\n expand_select_store=True))\",\n \"def update_stimulus(self, stimulus):\\r\\n self.stri.update_stimulus(stimulus)\",\n \"def update_stimulus(self, stimulus):\\r\\n self.stri.update_stimulus(stimulus)\",\n \"def set_stress(dat):\\n # stress parameters\\n rho = 2700.\\n xgrad = 0.61\\n ygrad = (0.61 + 1) / 2\\n dat.strs.on()\\n dat.strs.bodyforce = False\\n dat.add(fdata.fmacro('stressboun', zone='XMIN',\\n param=(('direction', 1), ('value', 0))))\\n dat.add(fdata.fmacro('stressboun', zone='YMIN',\\n param=(('direction', 2), ('value', 0))))\\n dat.add(fdata.fmacro('stressboun', zone='ZMIN',\\n param=(('direction', 3), ('value', 0))))\\n dat.add(fdata.fmacro('stressboun', zone='XMAX',\\n param=(('direction', 1), ('value', 0))))\\n dat.add(fdata.fmacro('stressboun', zone='YMAX',\\n param=(('direction', 2), ('value', 0))))\\n dat.zone[0].poissons_ratio = 0.2\\n dat.zone[0].thermal_expansion = 3.5e-5\\n dat.zone[0].pressure_coupling = 1.\\n # Model starts at surface, so no overburden (specified as zgrad when\\n # 'calculate_vertical' set to True)\\n dat.incon.stressgrad(xgrad=xgrad, ygrad=ygrad, zgrad=0,\\n calculate_vertical=True, vertical_fraction=True)\\n return dat\",\n \"def state(self):\\n state = np.array(self.get_state_arr())\\n om = utils.build_occupancy_maps(utils.build_humans(state))\\n # We only have a batch of one so just get the first element of\\n # transform and rotate\\n state = utils.transform_and_rotate(state.reshape((1, -1)))[0]\\n return torch.cat((state, om), dim=1)\",\n \"def pka_switchstate(cls, amb, state_id_):\\n titrationdict = TITRATION_DICT\\n state_id = titrationdict[state_id_]\\n state_id = state_id.split(\\\"+\\\")\\n new_state_id = [int(i) for i in state_id]\\n residue = getattr(amb, \\\"residue\\\")\\n hdef = getattr(amb, \\\"hdef\\\")\\n for conf in hdef.conformations:\\n hname = conf.hname\\n boundname = conf.boundatom\\n if residue.get_atom(hname) is not None:\\n residue.remove_atom(hname)\\n residue.get_atom(boundname).hacceptor = 1\\n residue.get_atom(boundname).hdonor = 0\\n\\n # Update the IntraBonds\\n for state_id in new_state_id:\\n if state_id == 0:\\n continue\\n conf = hdef.conformations[state_id - 1]\\n refcoords = []\\n defcoords = []\\n defatomcoords = []\\n if conf == ():\\n continue\\n hname = conf.hname\\n for atom in conf.atoms:\\n if (\\n residue.is_n_term\\n and residue.name == \\\"PRO\\\"\\n and atom.name == \\\"H\\\"\\n ):\\n atom.name = \\\"CD\\\"\\n atom.x = 1.874\\n atom.y = 0.862\\n atom.z = 1.306\\n\\n if not residue.rebuild_tetrahedral(hname):\\n for atom in conf.atoms:\\n atomname = atom.name\\n resatom = residue.get_atom(atomname)\\n if atomname == hname:\\n defatomcoords = atom.coords\\n elif resatom is not None:\\n refcoords.append(resatom.coords)\\n defcoords.append(atom.coords)\\n else:\\n raise KeyError(\\\"Could not find necessary atom!\\\")\\n\\n newcoords = quat.find_coordinates(\\n 3, refcoords, defcoords, defatomcoords\\n )\\n residue.create_atom(hname, newcoords)\\n\\n boundname = conf.boundatom\\n residue.get_atom(boundname).hacceptor = 0\\n residue.get_atom(boundname).hdonor = 1\\n\\n # Setting the SybylType for the newly built H\\n residue.get_atom(hname).sybyl_type = \\\"H\\\"\\n\\n # formal charge for PEOE_PB\\n residue.get_atom(hname).formalcharge = 0.0\\n\\n # flag the added hydrogen\\n residue.get_atom(hname).titratableH = True\\n\\n # Update intrabonds again\\n if residue.is_n_term and residue.name == \\\"PRO\\\":\\n for atom in residue.atoms:\\n if atom.name == \\\"H\\\":\\n residue.remove_atom(\\\"H\\\")\\n residue.update_terminus_status()\",\n \"def get_state(self, state):\\n return state\",\n \"def restore_after_spacer(state_min1, state_min2):\\n logger.debug('t-2 : {0} t-1 : {1}'.\\n format(state_min2, state_min1) \\n )\\n\\n wave_state = '';\\n # Bug Fix: Issue 1.\\n # Search backwards. If t-1 was a spacer too, then use t-2 for continuation\\n if (re.search('\\\\bS\\\\b|\\\\[dotted\\\\]', state_min1)):\\n wave_state = state_min2 \\n else:\\n wave_state = state_min1 \\n\\n # Flag erraneous input\\n if (re.search('\\\\bS\\\\b|\\\\[dotted\\\\]', wave_state)):\\n logger.error('Not supported, Possible back to back breaks or break on first clock')\\n\\n wave_state = re.sub(r'(\\\\d+[UDXLHCudxlhc])(.*)',r'\\\\1', wave_state)\\n\\n return wave_state\",\n \"def stateToCode(self, state):\\n\\n multiplier = 1\\n code = \\\"\\\"\\n for i in range(self.num_joints-1, -1, -1):\\n num_angles = len(self.angles[i])\\n code += str(int((state / multiplier ) % num_angles))\\n multiplier *= len(self.angles[i])\\n\\n # Return the reversed code\\n return code [::-1]\",\n \"def strain_rate_tensor(self):\\n U = self.U3\\n return 0.5 * (grad(U) + grad(U).T)\",\n \"def make_move(self, move: Any) -> \\\"StonehengeState\\\":\\n new_state = StonehengeState(self.p1_turn, self.length,\\n self.letters[:], self.claim[:])\\n state = new_state\\n if new_state.length == 1:\\n state = self.move_length_1(move, new_state)\\n if new_state.length == 2:\\n state = self.move_length_2(move, new_state)\\n if new_state.length == 3:\\n state = self.move_length_3(move, new_state)\\n if new_state.length == 4:\\n if move in [\\\"A\\\", \\\"B\\\", \\\"J\\\", \\\"O\\\", \\\"N\\\", \\\"R\\\",\\n \\\"C\\\", \\\"F\\\", \\\"E\\\", \\\"I\\\", \\\"P\\\", \\\"Q\\\"]:\\n state = self.move_length_4(move, new_state)\\n else:\\n state = self.move_length_41(move, new_state)\\n if new_state.length == 5:\\n if move in [\\\"A\\\", \\\"B\\\", \\\"U\\\", \\\"O\\\", \\\"T\\\", \\\"Y\\\",\\n \\\"C\\\", \\\"J\\\", \\\"E\\\", \\\"N\\\", \\\"V\\\", \\\"X\\\"]:\\n state = self.move_length_5(move, new_state)\\n elif move in [\\\"F\\\", \\\"I\\\", \\\"W\\\"]:\\n state = self.move_length_51(move, new_state)\\n else:\\n state = self.move_length_52(move, new_state)\\n return state\",\n \"def assignState(self):\\n\\t\\tblack = ['r', 'n', 'b','q','k','b','n','r']\\n\\t\\twhite = ['R','N','B','Q','K','B','N','R']\\n\\n\\t\\tfor i in range(8):\\n\\t\\t\\tself.squares[8*i + 0].state = black[i]\\n\\t\\t\\tself.squares[8*i + 1].state = 'p'\\n\\t\\t\\tself.squares[8*i + 2].state = '.'\\n\\t\\t\\tself.squares[8*i + 3].state = '.'\\n\\t\\t\\tself.squares[8*i + 4].state = '.'\\n\\t\\t\\tself.squares[8*i + 5].state = '.'\\n\\t\\t\\tself.squares[8*i + 6].state = 'P'\\n\\t\\t\\tself.squares[8*i + 7].state = white[i]\\n\\n\\t\\tfor square in self.squares:\\n\\t\\t\\tself.boardMatrix.append(square.state)\",\n \"def get_state_tostring(rapid_data):\\n try:\\n if rapid_data.RapidType == 'bool':\\n res = 'State = %s' % rapid_data.Value\\n return res\\n else:\\n err = 'DataType is ' + rapid_data.RapidType + ' and not bool.'\\n return err\\n except Exception, err:\\n return err\",\n \"def _stateDict(self):\\n\\n data = {}\\n # if self.currentState[4]:\\n # data['action'] = 'BRAK'\\n # else:\\n data['action'] = 'MCTL'\\n data['speed'] = float(self.speed)\\n data['steerAngle'] = float(self.steering_angle)\\n\\n return data\",\n \"def sense_state(self):\\n\\n # 3. Return turkey's current state\\n return self.maze.sense_turkey()\",\n \"def _status_to_state(status):\\n if status == 'failed':\\n return Finding.State.ACTIVE\\n elif status == 'passed' or status == 'skipped':\\n return Finding.State.INACTIVE\\n else:\\n return Finding.State.STATE_UNSPECIFIED\",\n \"def MCtoStormpy(h):\\n\\tstate_labelling = _buildStateLabeling(h)\\n\\ttransition_matrix = h.matrix\\n\\ttransition_matrix = st.build_sparse_matrix(transition_matrix)\\n\\tcomponents = st.SparseModelComponents(transition_matrix=transition_matrix,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t state_labeling=state_labelling)\\n\\tmc = st.storage.SparseDtmc(components)\\n\\treturn mc\",\n \"def get_state(s):\\n return np.array([math.atan2(s[1], s[0]), s[2]])\",\n \"def change_state(self):\\n transitions = self.transition_map[self.current_state]\\n self.current_state = select_from_probability_dict(random(),transitions)\",\n \"def final_state_cost(x_tape):\\n return np.linalg.norm(deviation_from_upright_equilibrium(x_tape[:, -1]))\",\n \"def obs_to_state(env, obs):\\n env_low = env.observation_space.low\\n env_high = env.observation_space.high\\n env_dx = (env_high - env_low) / n_states\\n a = int((obs[0] - env_low[0])/env_dx[0])\\n b = int((obs[1] - env_low[1])/env_dx[1])\\n return a, b\",\n \"def get_stress(self) -> Union[np.float64, float]:\\n\\n return self.__stress\",\n \"def get_state_as_string(state):\\n string_state = \\\"\\\"\\n for element in state:\\n string_state += \\\" \\\" + element\\n return string_state.lstrip()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6264138","0.59735096","0.5917664","0.5915843","0.58080965","0.57078695","0.5452941","0.544726","0.5424653","0.53956044","0.5375939","0.53561866","0.5349646","0.5337765","0.5305472","0.52900547","0.5284307","0.52565426","0.52550626","0.5244411","0.52370965","0.52329093","0.5230009","0.5229991","0.5218566","0.5211845","0.5206896","0.52058446","0.5196998","0.51799583","0.5173072","0.5169339","0.5164172","0.5163721","0.5163721","0.5162005","0.51609737","0.5146197","0.5142883","0.5137716","0.5130893","0.5094617","0.509232","0.5085582","0.50795865","0.50777286","0.5077699","0.5076642","0.5074361","0.5070248","0.5056296","0.50490826","0.50246936","0.5020869","0.502068","0.5007658","0.5002007","0.50000316","0.49907833","0.49824405","0.49744043","0.49744043","0.49740332","0.49577114","0.4955975","0.4946231","0.49395564","0.4936948","0.49365553","0.49295324","0.49281904","0.49253914","0.49234703","0.4923111","0.49215457","0.49209246","0.49134007","0.491051","0.4907193","0.4907193","0.49069136","0.49068195","0.49065313","0.49049827","0.49026096","0.48882908","0.48731938","0.48707426","0.48690563","0.48639956","0.48635736","0.48629272","0.48612916","0.48564333","0.48533952","0.48523128","0.48517996","0.48507562","0.48485786","0.4847409"],"string":"[\n \"0.6264138\",\n \"0.59735096\",\n \"0.5917664\",\n \"0.5915843\",\n \"0.58080965\",\n \"0.57078695\",\n \"0.5452941\",\n \"0.544726\",\n \"0.5424653\",\n \"0.53956044\",\n \"0.5375939\",\n \"0.53561866\",\n \"0.5349646\",\n \"0.5337765\",\n \"0.5305472\",\n \"0.52900547\",\n \"0.5284307\",\n \"0.52565426\",\n \"0.52550626\",\n \"0.5244411\",\n \"0.52370965\",\n \"0.52329093\",\n \"0.5230009\",\n \"0.5229991\",\n \"0.5218566\",\n \"0.5211845\",\n \"0.5206896\",\n \"0.52058446\",\n \"0.5196998\",\n \"0.51799583\",\n \"0.5173072\",\n \"0.5169339\",\n \"0.5164172\",\n \"0.5163721\",\n \"0.5163721\",\n \"0.5162005\",\n \"0.51609737\",\n \"0.5146197\",\n \"0.5142883\",\n \"0.5137716\",\n \"0.5130893\",\n \"0.5094617\",\n \"0.509232\",\n \"0.5085582\",\n \"0.50795865\",\n \"0.50777286\",\n \"0.5077699\",\n \"0.5076642\",\n \"0.5074361\",\n \"0.5070248\",\n \"0.5056296\",\n \"0.50490826\",\n \"0.50246936\",\n \"0.5020869\",\n \"0.502068\",\n \"0.5007658\",\n \"0.5002007\",\n \"0.50000316\",\n \"0.49907833\",\n \"0.49824405\",\n \"0.49744043\",\n \"0.49744043\",\n \"0.49740332\",\n \"0.49577114\",\n \"0.4955975\",\n \"0.4946231\",\n \"0.49395564\",\n \"0.4936948\",\n \"0.49365553\",\n \"0.49295324\",\n \"0.49281904\",\n \"0.49253914\",\n \"0.49234703\",\n \"0.4923111\",\n \"0.49215457\",\n \"0.49209246\",\n \"0.49134007\",\n \"0.491051\",\n \"0.4907193\",\n \"0.4907193\",\n \"0.49069136\",\n \"0.49068195\",\n \"0.49065313\",\n \"0.49049827\",\n \"0.49026096\",\n \"0.48882908\",\n \"0.48731938\",\n \"0.48707426\",\n \"0.48690563\",\n \"0.48639956\",\n \"0.48635736\",\n \"0.48629272\",\n \"0.48612916\",\n \"0.48564333\",\n \"0.48533952\",\n \"0.48523128\",\n \"0.48517996\",\n \"0.48507562\",\n \"0.48485786\",\n \"0.4847409\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5284506"},"document_rank":{"kind":"string","value":"16"}}},{"rowIdx":94487,"cells":{"query":{"kind":"string","value":"Converts from 6x1 to 3x3"},"document":{"kind":"string","value":"def unvoigt(A):\n a = np.zeros(shape=(3, 3))\n a[0, 0] = A[0]\n a[0, 1] = A[5]\n a[0, 2] = A[4]\n a[1, 0] = A[5]\n a[1, 1] = A[1]\n a[1, 2] = A[3]\n a[2, 0] = A[4]\n a[2, 1] = A[3]\n a[2, 2] = A[2]\n return a"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def make8UC3(mat):\n mat_8UC = make8UC(mat)\n mat_8UC3 = np.stack((mat_8UC,)*3, axis = -1)\n \n return mat_8UC3","def dti6to33(dt6):\n dt33 = numpy.zeros(dt6.shape[:-1] + (3, 3), dtype=dt6.dtype)\n dt33[..., 0, 0] = dt6[..., 5] # dxx\n dt33[..., 0, 1] = dt33[..., 1, 0] = dt6[..., 4] / 2 # dxy\n dt33[..., 0, 2] = dt33[..., 2, 0] = dt6[..., 3] / 2 # dxz\n dt33[..., 1, 1] = dt6[..., 2] # dyy\n dt33[..., 1, 2] = dt33[..., 2, 1] = dt6[..., 1] / 2 # dyz\n dt33[..., 2, 2] = dt6[..., 0] # dzz\n\n return dt33","def one_to_three(one):\n return ((1,0,0),(0,1,0),(0,0,1))[one+1]","def _to_bc_L_h_w_3(x, x_shape):\r\n\r\n x = tf.reshape(x, (-1,\r\n int(x_shape[2]),\r\n int(x_shape[3]),\r\n int(x_shape[4]), 3))\r\n return x","def nine_to_3x3(listy):\n new_side = []\n k = int(len(listy) / 3)\n \n for i in range(k):\n intermediate = []\n for j in range(3):\n intermediate.append(listy.pop(0))\n \n new_side.append(intermediate)\n return new_side","def dti33to6(dt33):\n dt6 = numpy.zeros(dt33.shape[:-2] + (6, ), dtype=dt33.dtype)\n dt6[..., 5] = dt33[..., 0, 0]\n dt6[..., 4] = dt33[..., 0, 1] + dt33[..., 1, 0]\n dt6[..., 3] = dt33[..., 0, 2] + dt33[..., 2, 0]\n dt6[..., 2] = dt33[..., 1, 1]\n dt6[..., 1] = dt33[..., 1, 2] + dt33[..., 2, 1]\n dt6[..., 0] = dt33[..., 2, 2]\n\n return dt6","def tdim3(dim3):\n return TransformedDimension(Compose([], dim3.type), dim3)","def convert_game_action_to_3D_action(ga):\n tile_type, from_row, to_row, nbr_to_move = ga\n\n return (tile_type, min(nbr_to_move,5), to_row)","def three_d6() -> list:\n rolls: List[int] = []\n for i in range(1, 7):\n roll: int = multi_die(3, 6)\n rolls.append(roll)\n return rolls","def dim3():\n return Integer(\"yolo3\", \"uniform\", 3, 7, shape=(1,))","def third_mixup(seq):\n len_third = int(len(seq) / 3)\n third_mixup = seq[-len_third:] + seq[:-len_third]\n return third_mixup","def Cijkl(C):\n c = np.zeros(shape=(3, 3, 3, 3))\n CC = np.zeros(shape=(9, 9))\n CC[0:6, 0:6] = C[0:6, 0:6]\n CC[6:9, 6:9] = C[3:6, 3:6]\n CC[0:6, 6:9] = C[0:6, 3:6]\n CC[6:9, 0:6] = C[3:6, 0:6]\n\n c[0, 0, 0, 0] = CC[0, 0]\n c[0, 0, 1, 1] = CC[0, 1]\n c[0, 0, 2, 2] = CC[0, 2]\n c[0, 0, 1, 2] = CC[0, 3]\n c[0, 0, 2, 0] = CC[0, 4]\n c[0, 0, 0, 1] = CC[0, 5]\n c[0, 0, 2, 1] = CC[0, 6]\n c[0, 0, 0, 2] = CC[0, 7]\n c[0, 0, 1, 0] = CC[0, 8]\n\n c[1, 1, 0, 0] = CC[1, 0]\n c[1, 1, 1, 1] = CC[1, 1]\n c[1, 1, 2, 2] = CC[1, 2]\n c[1, 1, 1, 2] = CC[1, 3]\n c[1, 1, 2, 0] = CC[1, 4]\n c[1, 1, 0, 1] = CC[1, 5]\n c[1, 1, 2, 1] = CC[1, 6]\n c[1, 1, 0, 2] = CC[1, 7]\n c[1, 1, 1, 0] = CC[1, 8]\n\n c[2, 2, 0, 0] = CC[2, 0]\n c[2, 2, 1, 1] = CC[2, 1]\n c[2, 2, 2, 2] = CC[2, 2]\n c[2, 2, 1, 2] = CC[2, 3]\n c[2, 2, 2, 0] = CC[2, 4]\n c[2, 2, 0, 1] = CC[2, 5]\n c[2, 2, 2, 1] = CC[2, 6]\n c[2, 2, 0, 2] = CC[2, 7]\n c[2, 2, 1, 0] = CC[2, 8]\n\n c[1, 2, 0, 0] = CC[3, 0]\n c[1, 2, 1, 1] = CC[3, 1]\n c[1, 2, 2, 2] = CC[3, 2]\n c[1, 2, 1, 2] = CC[3, 3]\n c[1, 2, 2, 0] = CC[3, 4]\n c[1, 2, 0, 1] = CC[3, 5]\n c[1, 2, 2, 1] = CC[3, 6]\n c[1, 2, 0, 2] = CC[3, 7]\n c[1, 2, 1, 0] = CC[3, 8]\n\n c[2, 0, 0, 0] = CC[4, 0]\n c[2, 0, 1, 1] = CC[4, 1]\n c[2, 0, 2, 2] = CC[4, 2]\n c[2, 0, 1, 2] = CC[4, 3]\n c[2, 0, 2, 0] = CC[4, 4]\n c[2, 0, 0, 1] = CC[4, 5]\n c[2, 0, 2, 1] = CC[4, 6]\n c[2, 0, 0, 2] = CC[4, 7]\n c[2, 0, 1, 0] = CC[4, 8]\n\n c[0, 1, 0, 0] = CC[5, 0]\n c[0, 1, 1, 1] = CC[5, 1]\n c[0, 1, 2, 2] = CC[5, 2]\n c[0, 1, 1, 2] = CC[5, 3]\n c[0, 1, 2, 0] = CC[5, 4]\n c[0, 1, 0, 1] = CC[5, 5]\n c[0, 1, 2, 1] = CC[5, 6]\n c[0, 1, 0, 2] = CC[5, 7]\n c[0, 1, 1, 0] = CC[5, 8]\n\n c[2, 1, 0, 0] = CC[6, 0]\n c[2, 1, 1, 1] = CC[6, 1]\n c[2, 1, 2, 2] = CC[6, 2]\n c[2, 1, 1, 2] = CC[6, 3]\n c[2, 1, 2, 0] = CC[6, 4]\n c[2, 1, 0, 1] = CC[6, 5]\n c[2, 1, 2, 1] = CC[6, 6]\n c[2, 1, 0, 2] = CC[6, 7]\n c[2, 1, 1, 0] = CC[6, 8]\n\n c[0, 2, 0, 0] = CC[7, 0]\n c[0, 2, 1, 1] = CC[7, 1]\n c[0, 2, 2, 2] = CC[7, 2]\n c[0, 2, 1, 2] = CC[7, 3]\n c[0, 2, 2, 0] = CC[7, 4]\n c[0, 2, 0, 1] = CC[7, 5]\n c[0, 2, 2, 1] = CC[7, 6]\n c[0, 2, 0, 2] = CC[7, 7]\n c[0, 2, 1, 0] = CC[7, 8]\n\n c[1, 0, 0, 0] = CC[8, 0]\n c[1, 0, 1, 1] = CC[8, 1]\n c[1, 0, 2, 2] = CC[8, 2]\n c[1, 0, 1, 2] = CC[8, 3]\n c[1, 0, 2, 0] = CC[8, 4]\n c[1, 0, 0, 1] = CC[8, 5]\n c[1, 0, 2, 1] = CC[8, 6]\n c[1, 0, 0, 2] = CC[8, 7]\n c[1, 0, 1, 0] = CC[8, 8]\n return c","def _transpose_by_1_vnchwconv():\n\n pass","def six_hundred_cell(self):\n verts = []\n q12 = QQ(1)/2\n base = [q12,q12,q12,q12]\n for i in range(2):\n for j in range(2):\n for k in range(2):\n for l in range(2):\n verts.append([x for x in base])\n base[3] = base[3]*(-1)\n base[2] = base[2]*(-1)\n base[1] = base[1]*(-1)\n base[0] = base[0]*(-1)\n for x in permutations([0,0,0,1]):\n verts.append(x)\n for x in permutations([0,0,0,-1]):\n verts.append(x)\n g = QQ(1618033)/1000000 # Golden ratio approximation\n verts = verts + [i([q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n return Polyhedron(vertices = verts)","def generate_3d_board(n):\n layer = nxn_generate.generate_shuffled_2d_board(n)\n cube = []\n for i in range(len(layer)):\n new_layer = []\n for column in layer:\n new_column = []\n # this nested mess is to ensure that none of the sub 3x3 squares violates sudoku rules from any x y or z\n # perspective (also the Latin Square rules but the subsquares are trickier and the cause of more mess)\n for j in range(int(math.sqrt(len(layer)))):\n for k in range(int(math.sqrt(len(layer)))):\n # lot of 3 = (i+j) % 3\n # index within lot = (i + k + (i//3)) % 3\n new_column.append(column[int(math.sqrt(len(layer))) * ((i + j) % int(math.sqrt(len(layer)))) + (\n i + k + (i // int(math.sqrt(len(layer))))) % int(math.sqrt(len(layer)))])\n new_layer.append(new_column)\n cube.append(new_layer)\n\n return shuffle_cube(cube)","def axial_to_cube(axial):\n x = axial[0] # q\n z = axial[1] # r\n y = -x-z\n return tuple([x, y, z])","def cube(num):\n return num ** 3","def _mat3(self):\n if self.frame.orientation == HillFrame.DEFAULT_ORIENTATION:\n return np.identity(3)\n else:\n return self.QSW2TNW","def reformat(x):\n x = x.permute(0, 2, 3, 1)\n N, D1, D2, Feat = x.size()\n x = x.view(N, D1 * D2, Feat)\n return x","def reformat(x):\n x = x.permute(0, 2, 3, 1)\n N, D1, D2, Feat = x.size()\n x = x.view(N, D1 * D2, Feat)\n return x","def cube(n):\n return n**3","def c_matrix(x1,x2,x3):\n\tC = np.array([\t[\t2*(x2-x1), \t\t(x2-x1), \t\t\t0\t\t\t], \\\n\t\t\t\t\t[\t(x2-x1), \t\t2*(x3-x1), \t\t(x3-x2)\t\t], \\\n\t\t\t\t\t[\t0,\t\t\t\t(x3-x2),\t\t2*(x3-x2)\t] \t], \\\n\t\t\t\t\tfloat)\n\treturn(C)","def reduce_kcol_to_3col(G, k):\n\n G, H = prepare_grid(G)\n print(\"grid prepared\")\n N = len(G)\n H = create_kgrid(H, N, k)\n print(\"grid created\")\n H = add_pheripherals_per_edge(G.edges, H, k)\n print(\"peripherals added\")\n\n return H","def _pad_1x1_to_3x3_tensor(self, kernel1x1):\n if kernel1x1 is None:\n return 0\n else:\n return torch.nn.functional.pad(kernel1x1, [1, 1, 1, 1])","def six_cubed():\n print(math.pow(6,3))","def _aseg_to_three():\n import numpy as np\n\n # Base struct\n aseg_lut = np.zeros((256,), dtype=\"int\")\n # GM\n aseg_lut[3] = 1\n aseg_lut[8:14] = 1\n aseg_lut[17:21] = 1\n aseg_lut[26:40] = 1\n aseg_lut[42] = 1\n aseg_lut[47:73] = 1\n\n # CSF\n aseg_lut[4:6] = 3\n aseg_lut[14:16] = 3\n aseg_lut[24] = 3\n aseg_lut[43:45] = 3\n aseg_lut[72] = 3\n\n # WM\n aseg_lut[2] = 2\n aseg_lut[7] = 2\n aseg_lut[16] = 2\n aseg_lut[28] = 2\n aseg_lut[41] = 2\n aseg_lut[46] = 2\n aseg_lut[60] = 2\n aseg_lut[77:80] = 2\n aseg_lut[250:256] = 2\n return tuple(aseg_lut)","def nu3(self):\n n = self.level()\n if (n % 9 == 0):\n return ZZ(0)\n return prod([ 1 + kronecker_symbol(-3, p) for p, _ in n.factor()])","def cube_array(self):\n cube_sides = {}\n\n for side in SIDES:\n cube_sides[side] = []\n \n # Todo Break this loop into helper functions for clarity and simplicity\n for coord in COORDS_3:\n for cubie in self.cubies:\n # Making sure that the cubes cubies are processed in the correct order\n if np.array_equal(cubie.coordinates, coord): \n \n \n for side in SIDES:\n if cubie.in_side(side):\n for face in cubie.faces:\n \n # Checking that the face of the cubie has the same norm as the side we are processing\n if np.array_equal(face.norm, NORMS[side]):\n cube_sides[side].append(face.colour)\n\n new_list = [cube_sides[\"U\"], cube_sides[\"F\"], reversal(cube_sides[\"R\"]), reversal(cube_sides[\"B\"]),\n cube_sides[\"L\"], reversal(cube_sides[\"D\"])]\n \n final_list = [nine_to_3x3(side) for side in new_list]\n return final_list","def check3x3(self, board):\n\t\t\t# print \"This is check3x3\"\n\t\t\t# for i in xrange(0,9):\n\t\t\t# \tprint board[i],\n\t\t\t# \tif i%3 == 2:\n\t\t\t# \t\tprint\n\n\t\t\tvalue = self.finddraw(board)\n\t\t\tif(value[1] != -1):\n\t\t\t\treturn value[1]\n\t\t\t#Rows\n\t\t\tfor i in range(0,9):\n\t\t\t\tif(i%3 == 0):\n\t\t\t\t\tif (board[i] == 'x' and board[i+1] == 'x' and board[i+2] == 'x'):\n\t\t\t\t\t\tif(self.symbol == 'x'):\n\t\t\t\t\t\t\treturn 4\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\treturn 0\n\t\n\t\t\t\t\tif (board[i] == 'o' and board[i+1] == 'o' and board[i+2] == 'o'):\n\t\t\t\t\t\tif(self.symbol == 'o'):\n\t\t\t\t\t\t\treturn 4\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\treturn 0\n\n\t\t\t#Colomns\n\t\t\tfor i in range(0,3):\n\t\t\t\tif(i/3 == 0):\n\t\t\t\t\tif (board[i] == 'x' and board[i+3] == 'x' and board[i+6] == 'x'):\n\t\t\t\t\t\tif(self.symbol == 'x'):\n\t\t\t\t\t\t\treturn 4\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\treturn 0\n\t\n\t\t\t\t\tif (board[i] == 'o' and board[i+3] == 'o' and board[i+6] == 'o'):\n\t\t\t\t\t\tif(self.symbol == 'o'):\n\t\t\t\t\t\t\treturn 4\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\treturn 0\n\n\t\t\tcount = 0\n\t\t\tsavei = 0\n\t\t\tvalue = -1\n\t\t\tfor i in range(0,9):\n\t\t\t\t\tif(board[i] != '-'):\n\t\t\t\t\t\tcount += 1\n\t\t\t\t\telse:\n\t\t\t\t\t\tsavei = i\n\n\t\t\tif(count == 9):\n\t\t\t\treturn 1\n\t\t\tif(count == 8):\n\t\t\t\tif(self.symbol == 'x'):\n\t\t\t\t\tboard[savei] = 'o'\n\t\t\t\t\tvalue = self.finddraw(board)\n\t\t\t\tif(self.symbol == 'o'):\n\t\t\t\t\tboard[savei] = 'x'\n\t\t\t\t\tvalue = self.finddraw(board)\n\t\t\t\tif(value[1] > -1):\n\t\t\t\t\tif(value[1] == 1):\n\t\t\t\t\t\treturn 1\n\t\t\t\t\tif(value[1] == 4):\n\t\t\t\t\t\treturn 2\n\n\t\t\treturn -1","def get_A3():\n\n return array([[0.68557183+0.46550108j, 0.12934765-0.1622676j,\n 0.24409518+0.25335939j],\n [0.1531015 + 0.66678983j, 0.45112492+0.18206976j,\n -0.02633966+0.43477693j],\n [-0.10817164-1.16879196j, -0.18446849+0.03755672j,\n 0.06430325-0.44757084j]])","def scale3(a,c):\n return [a[0]*c,a[1]*c,a[2]*c,1.0]","def rot6d_to_rotmat(x):\n x = x.view(-1,3,2)\n a1 = x[:, :, 0]\n a2 = x[:, :, 1]\n b1 = F.normalize(a1)\n b2 = F.normalize(a2 - torch.einsum('bi,bi->b', b1, a2).unsqueeze(-1) * b1)\n b3 = torch.cross(b1, b2)\n return torch.stack((b1, b2, b3), dim=-1)","def subpel_conv3x3(in_ch, out_ch, r=1):\n # return nn.Sequential(\n # nn.Conv2d(in_ch, out_ch * r**2, kernel_size=3, padding=1),\n # nn.PixelShuffle(r))\n # change\n return nn.SequentialCell([nn.Conv2d(in_ch, out_ch * r**2, kernel_size=3, padding=1),\n # # TODO BY J : no pixel shuffle in mindspore\n # nn.PixelShuffle(r))\n ])","def cube(n):\n result = [num*num*num for num in range(n)]\n\n return result[1:]","def three_dimensional(self, z): # Maybe I misunderstood the task. My method looks weird\n return (self.x, self.y, z)","def six_cubed():\n print(math.pow(6, 3))","def rotmat_to_rot6d(rotmat):\n\n rot6d = rotmat[:, :, 0:2]\n rot6d = rot6d.reshape(-1, 6)\n\n return rot6d","def cube(x):\n return x ** 3","def cube(x):\n return x ** 3","def mat_2d_to_3d(x, agg_num, hop):\n # Pad to at least one block. \n len_x, n_in = x.shape\n if (len_x < agg_num):\n x = np.concatenate((x, np.zeros((agg_num - len_x, n_in))))\n \n # Segment 2d to 3d. \n len_x = len(x)\n i1 = 0\n x3d = []\n while (i1 + agg_num <= len_x):\n x3d.append(x[i1 : i1 + agg_num])\n i1 += hop\n return np.array(x3d)","def coupling_6j((J1,J2,J3),(J4,J5,J6)):\n cj6=pygsl.sf.coupling_6j(int(2*J1),int(2*J2), int(2*J3), int(2*J4),int(2*J5), int(2*J6))[0]\n cj6=(-1)**(J1+J2+J4+J5)*hat(J3)*hat(J6)*cj6 \n return cj6","def preprocess_3d(im_stack):\n im_stack /= 127.5\n im_stack -= 1.0\n return im_stack","def rot6d_to_rotmat(x):\n x = x.view(-1, 3, 2)\n a1 = x[:, :, 0]\n a2 = x[:, :, 1]\n b1 = F.normalize(a1)\n b2 = F.normalize(a2 - torch.einsum('bi,bi->b', b1, a2).unsqueeze(-1) * b1)\n b3 = torch.cross(b1, b2)\n return torch.stack((b1, b2, b3), dim=-1)","def rot6d_to_rotmat(x):\n x = x.view(-1, 3, 2)\n a1 = x[:, :, 0]\n a2 = x[:, :, 1]\n b1 = F.normalize(a1)\n b2 = F.normalize(a2 - torch.einsum('bi,bi->b', b1, a2).unsqueeze(-1) * b1)\n b3 = torch.cross(b1, b2)\n return torch.stack((b1, b2, b3), dim=-1)","def _build(self):\n ary = np.zeros( (3,3,3), float )\n ary[0,0,0] = ary[1,1,1] = ary[0,1,2] = ary[1,0,2] = 1.\n ary[0,2,0] = ary[0,2,2] = ary[2,0,0] = ary[2,0,2] = 0.5\n ary[1,2,1] = ary[1,2,2] = ary[2,1,1] = ary[2,1,2] = 0.5\n ary[2,2,0] = ary[2,2,1] = 0.25\n ary[2,2,2] = 0.5\n return ary","def test_Pad3D6():\n input_shape = (1, 1, 2, 3, 2)\n # pad = np.array([1, 0, 1, 2, 1, 0]).astype('int32')\n pad = [1, 0, 1, 2, 1, 0]\n mode = \"constant\"\n res = [\n [\n [\n [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]],\n [[0, 0, 0], [0, 1, 2], [0, 3, 4], [0, 5, 6], [0, 0, 0], [0, 0, 0]],\n [[0, 0, 0], [0, 7, 8], [0, 9, 10], [0, 11, 12], [0, 0, 0], [0, 0, 0]],\n ]\n ]\n ]\n data = np.arange(np.prod(input_shape)).reshape(input_shape) + 1\n obj.run(res=res, padding=pad, mode=mode, data_format=\"NCDHW\", data=data)","def get_B3():\n return array([[0.46870499+0.37541453j, 0.19115959-0.39233203j,\n 0.12830659+0.12102382j],\n [0.90249603-0.09446345j, 0.51584055+0.84326503j,\n -0.02582305+0.23259079j],\n [0.75419973-0.52470311j, -0.59173739+0.48075322j,\n 0.51545446-0.21867957j]])","def box_3d_to_3d_iou_format(boxes_3d):\n boxes_3d = np.asarray(boxes_3d)\n fc.check_box_3d_format(boxes_3d)\n\n iou_3d_boxes = np.zeros([len(boxes_3d), 7])\n iou_3d_boxes[:, 4:7] = boxes_3d[:, 0:3]\n iou_3d_boxes[:, 1] = boxes_3d[:, 3]\n iou_3d_boxes[:, 2] = boxes_3d[:, 4]\n iou_3d_boxes[:, 3] = boxes_3d[:, 5]\n iou_3d_boxes[:, 0] = boxes_3d[:, 6]\n\n return iou_3d_boxes","def get_3d_H(H1):\n H_fin = [H1[0,0], 0, H1[0,1], H1[0,2], 0, 1, 0, 0, H1[1,0], 0, H1[1,1], H1[1,2]]\n H_fin = np.array(H_fin).reshape(3,4)\n return H_fin","def test_2_2_3D_cube_splits(self):\n check = [(0, 0, 0), (1, 1, 1), (1, 0, 0), (1, 1, 0), (1, 0, 1),\n (0, 1, 0),\n (0, 1, 1), (0, 0, 1), (0.5, 0.5, 0.5), (0.0, 0.5, 0.5),\n (0.0, 0.0, 0.5), (0.0, 0.5, 0.0), (0.5, 0.0, 0.5),\n (0.5, 0.0, 0.0),\n (0.5, 0.5, 0.0), (0.25, 0.25, 0.25), (1.0, 0.5, 0.5),\n (1.0, 1.0, 0.5),\n (1.0, 0.5, 1.0), (0.5, 1.0, 0.5), (0.5, 1.0, 1.0),\n (0.5, 0.5, 1.0),\n (0.75, 0.75, 0.75), (1.0, 0.0, 0.5), (1.0, 0.5, 0.0),\n (0.75, 0.25, 0.25), (0.5, 1.0, 0.0), (0.75, 0.75, 0.25),\n (0.5, 0.0, 1.0), (0.75, 0.25, 0.75), (0.0, 1.0, 0.5),\n (0.25, 0.75, 0.25), (0.0, 0.5, 1.0), (0.25, 0.75, 0.75),\n (0.25, 0.25, 0.75), (0.5, 0.25, 0.25), (0.5, 0.5, 0.25),\n (0.5, 0.25, 0.5), (0.25, 0.5, 0.25), (0.25, 0.5, 0.5),\n (0.25, 0.25, 0.5), (0.375, 0.375, 0.375), (0.0, 0.25, 0.25),\n (0.0, 0.0, 0.25), (0.0, 0.25, 0.0), (0.25, 0.0, 0.25),\n (0.25, 0.0, 0.0), (0.25, 0.25, 0.0), (0.125, 0.125, 0.125),\n (0.0, 0.5, 0.25), (0.0, 0.25, 0.5), (0.125, 0.375, 0.375),\n (0.25, 0.0, 0.5), (0.125, 0.125, 0.375), (0.25, 0.5, 0.0),\n (0.125, 0.375, 0.125), (0.5, 0.0, 0.25), (0.375, 0.125, 0.375),\n (0.5, 0.25, 0.0), (0.375, 0.125, 0.125), (0.375, 0.375, 0.125),\n (0.5, 0.75, 0.75), (0.5, 0.5, 0.75), (0.5, 0.75, 0.5),\n (0.75, 0.5, 0.75), (0.75, 0.5, 0.5), (0.75, 0.75, 0.5),\n (0.625, 0.625, 0.625), (1.0, 0.75, 0.75), (1.0, 1.0, 0.75),\n (1.0, 0.75, 1.0), (0.75, 1.0, 0.75), (0.75, 1.0, 1.0),\n (0.75, 0.75, 1.0), (0.875, 0.875, 0.875), (1.0, 0.5, 0.75),\n (1.0, 0.75, 0.5), (0.875, 0.625, 0.625), (0.75, 1.0, 0.5),\n (0.875, 0.875, 0.625), (0.75, 0.5, 1.0), (0.875, 0.625, 0.875),\n (0.5, 1.0, 0.75), (0.625, 0.875, 0.625), (0.5, 0.75, 1.0),\n (0.625, 0.875, 0.875), (0.625, 0.625, 0.875),\n (0.75, 0.5, 0.25),\n (0.75, 0.25, 0.5), (0.625, 0.375, 0.375), (1.0, 0.25, 0.25),\n (1.0, 0.0, 0.25), (1.0, 0.25, 0.0), (0.75, 0.0, 0.25),\n (0.75, 0.0, 0.0), (0.75, 0.25, 0.0), (0.875, 0.125, 0.125),\n (1.0, 0.5, 0.25), (1.0, 0.25, 0.5), (0.875, 0.375, 0.375),\n (0.75, 0.0, 0.5), (0.875, 0.125, 0.375), (0.75, 0.5, 0.0),\n (0.875, 0.375, 0.125), (0.625, 0.125, 0.375),\n (0.625, 0.125, 0.125),\n (0.625, 0.375, 0.125), (0.5, 0.75, 0.25),\n (0.625, 0.625, 0.375),\n (1.0, 0.75, 0.25), (1.0, 1.0, 0.25), (1.0, 0.75, 0.0),\n (0.75, 1.0, 0.25), (0.75, 1.0, 0.0), (0.75, 0.75, 0.0),\n (0.875, 0.875, 0.125), (0.875, 0.625, 0.375),\n (0.875, 0.875, 0.375),\n (0.875, 0.625, 0.125), (0.5, 1.0, 0.25), (0.625, 0.875, 0.375),\n (0.5, 0.75, 0.0), (0.625, 0.875, 0.125), (0.625, 0.625, 0.125),\n (0.5, 0.25, 0.75), (0.625, 0.375, 0.625), (1.0, 0.25, 0.75),\n (1.0, 0.0, 0.75), (1.0, 0.25, 1.0), (0.75, 0.0, 0.75),\n (0.75, 0.0, 1.0), (0.75, 0.25, 1.0), (0.875, 0.125, 0.875),\n (0.875, 0.375, 0.625), (0.875, 0.125, 0.625),\n (0.875, 0.375, 0.875),\n (0.5, 0.0, 0.75), (0.625, 0.125, 0.625), (0.5, 0.25, 1.0),\n (0.625, 0.125, 0.875), (0.625, 0.375, 0.875),\n (0.25, 0.75, 0.5),\n (0.375, 0.625, 0.375), (0.0, 0.75, 0.25), (0.0, 1.0, 0.25),\n (0.0, 0.75, 0.0), (0.25, 1.0, 0.25), (0.25, 1.0, 0.0),\n (0.25, 0.75, 0.0), (0.125, 0.875, 0.125), (0.0, 0.75, 0.5),\n (0.125, 0.625, 0.375), (0.25, 1.0, 0.5), (0.125, 0.875, 0.375),\n (0.125, 0.625, 0.125), (0.375, 0.875, 0.375),\n (0.375, 0.875, 0.125),\n (0.375, 0.625, 0.125), (0.25, 0.5, 0.75),\n (0.375, 0.625, 0.625),\n (0.0, 0.75, 0.75), (0.0, 1.0, 0.75), (0.0, 0.75, 1.0),\n (0.25, 1.0, 0.75), (0.25, 1.0, 1.0), (0.25, 0.75, 1.0),\n (0.125, 0.875, 0.875), (0.0, 0.5, 0.75), (0.125, 0.625, 0.625),\n (0.125, 0.875, 0.625), (0.25, 0.5, 1.0), (0.125, 0.625, 0.875),\n (0.375, 0.875, 0.625), (0.375, 0.875, 0.875),\n (0.375, 0.625, 0.875),\n (0.375, 0.375, 0.625), (0.0, 0.25, 0.75), (0.0, 0.0, 0.75),\n (0.0, 0.25, 1.0), (0.25, 0.0, 0.75), (0.25, 0.0, 1.0),\n (0.25, 0.25, 1.0), (0.125, 0.125, 0.875),\n (0.125, 0.375, 0.625),\n (0.125, 0.125, 0.625), (0.125, 0.375, 0.875),\n (0.375, 0.125, 0.625),\n (0.375, 0.125, 0.875), (0.375, 0.375, 0.875)]\n\n nn_checks = {(0.5, 0.25, 0.25): [(0.375, 0.375, 0.125), (0.5, 0.5, 0.0),\n (0.75, 0.25, 0.25),\n (0.625, 0.375, 0.375),\n (0.625, 0.125, 0.375),\n (0.625, 0.125, 0.125),\n (0.5, 0.5, 0.25), (0.25, 0.25, 0.25),\n (0.375, 0.375, 0.375),\n (0.5, 0.25, 0.5), (0.5, 0.5, 0.5),\n (0.5, 0.0, 0.25),\n (0.375, 0.125, 0.375), (0.5, 0.0, 0.5),\n (0.5, 0.25, 0.0),\n (0.375, 0.125, 0.125), (0.5, 0.0, 0.0),\n (0.625, 0.375, 0.125)],\n (0.625, 0.625, 0.875): [(0.75, 0.5, 1.0),\n (0.75, 0.75, 1.0),\n (0.5, 0.75, 1.0), (0.5, 0.5, 1.0),\n (0.5, 0.5, 0.75),\n (0.5, 0.75, 0.75),\n (0.75, 0.5, 0.75),\n (0.75, 0.75, 0.75)],\n (0, 0, 0): [(0.0, 0.25, 0.0), (0.125, 0.125, 0.125),\n (0.0, 0.0, 0.25), (0.25, 0.0, 0.0),\n (0.0, 0.25, 0.25), (0.25, 0.25, 0.0),\n (0.25, 0.0, 0.25)]}\n\n init_triangulation(3, 2, check, nn_checks)","def transpose():","def I3_u32(self) -> complex:\n return (self.S3_u32() / self.U23()).conjugate()","def mixing_matrix_2nu(sth):\n cth = sqrt(1.0-sth*sth)\n\n U00 = cth\n U01 = sth\n U10 = -sth\n U11 = cth\n\n return [[U00,U01],[U10,U11]]","def conv3x3(self, in_planes, out_planes, stride=1):\n c = self.conv(3, in_planes, out_planes, stride=stride)\n return c","def transform_play_to_column(play):\n\n return [2 ** i for i in range(49)].index(play) // 7","def conv3x3(in_ch, out_ch, stride=1):\n return nn.Conv2d(in_ch, out_ch, kernel_size=3, stride=stride, padding=1)","def _to_b_c_L_h_w(x, x_shape):\r\n x = tf.reshape(x, (-1,\r\n int(x_shape[1]),\r\n int(x_shape[2]),\r\n int(x_shape[3]),\r\n int(x_shape[4])))\r\n return x","def ROW(x):\n return (x >> 3)","def ROW(x):\n return (x >> 3)","def _factorRepresentation(self, character, size):\n # Create the character matrix space\n rows = 2*size + 3\n cols = size + 2\n char_matrix = [[_SPACE]*cols for i in range(rows)] \n\n # Creates the constituent element\n horizontal_line = [_H_LINE]*size\n vertical_line = [_V_LINE]*size\n\n # Get the points to construct the number with the elements\n horizontal_points = self._getHLinesPoints(character, size)\n vertical_points = self._getVLinesPoints(character, size)\n\n for x, y in horizontal_points:\n char_matrix[x][y:y+size] = horizontal_line\n\n for x, y in vertical_points:\n for i in range(size):\n char_matrix[x+i][y] = vertical_line[i]\n\n return char_matrix","def resh(x):\r\n a = x.shape[0]\r\n b = x.shape[1]\r\n return x.reshape(a*b, 1), a, b","def 3Sat(B):","def __det3x3__(a):\r\n # val = +a[0,0] * ( a[1,1] * a[2,2] - a[2,1] * a[1,2] )\r\n # val += -a[0,1] * ( a[1,0] * a[2,2] - a[2,0] * a[1,2] )\r\n # val += +a[0,2] * ( a[1,0] * a[2,1] - a[2,0] * a[1,1] )\r\n val = +a[0] * (a[4] * a[8] - a[7] * a[5])\r\n val += -a[1] * (a[3] * a[8] - a[6] * a[5])\r\n val += +a[2] * (a[3] * a[7] - a[6] * a[4])\r\n return val","def get_palette(num_cls):\n '''\n n = num_cls\n palette = [0] * (n * 3)\n for j in range(0, n):\n lab = j\n palette[j * 3 + 0] = 0\n palette[j * 3 + 1] = 0\n palette[j * 3 + 2] = 0\n i = 0\n while lab:\n palette[j * 3 + 0] |= (((lab >> 0) & 1) << (7 - i))\n palette[j * 3 + 1] |= (((lab >> 1) & 1) << (7 - i))\n palette[j * 3 + 2] |= (((lab >> 2) & 1) << (7 - i))\n i += 1\n lab >>= 3\n '''\n n = num_cls\n palette = [0] * (n * 3)\n for j in range(0, n):\n lab = j\n palette[j * 3 + 2] = 0\n palette[j * 3 + 1] = 0\n palette[j * 3 + 0] = 0\n i = 0\n while lab:\n palette[j * 3 + 0] |= (((lab >> 0) & 1) << (7 - i))\n palette[j * 3 + 1] |= (((lab >> 1) & 1) << (7 - i))\n palette[j * 3 + 2] |= (((lab >> 2) & 1) << (7 - i))\n i += 1\n lab >>= 3\n\n return palette[3:]","def matrix_2d_to_3d(matrix: np.matrix) -> np.matrix:\n return np.matrix([\n [matrix.item(0, 0), matrix.item(0, 1), 0, matrix.item(0, 2)],\n [matrix.item(1, 0), matrix.item(1, 1), 0, matrix.item(1, 2)],\n [0, 0, 1, 0],\n [matrix.item(2, 0), matrix.item(2, 1), 0, matrix.item(2, 2)]])","def matrix4_to_3x4_array(mat):\r\n return tuple(f for v in mat[0:3] for f in v)","def linearTosRGB3(c):\n return [linearTosRGB(c[0]), linearTosRGB(c[1]), linearTosRGB(c[2])]","def convert_3to1(seq):\n term_list = []\n for i in __kmers(seq,k=3):\n res = __get_value(i,aa3_to1_dict)\n term_list.append(res)\n return ''.join(term_list)","def I3_u3(self) -> complex:\n return self.I3_u1() * cmath.rect(1, 120 / 180 * cmath.pi)","def jointsImgTo3D(sample):\n ret = np.zeros((sample.shape[0], 3), np.float32)\n for i in range(sample.shape[0]):\n ret[i] = jointImgTo3D(sample[i])\n return ret","def voigt(a):\n A = np.zeros(shape=(6, 1))\n A[0] = a[0, 0]\n A[1] = a[1, 1]\n A[2] = a[2, 2]\n A[3] = a[1, 2]\n A[4] = a[0, 2]\n A[5] = a[0, 1]\n return A","def Q2C(self, q):\n\n #q = q.squeeze();\n C = np.empty((3,3));\n\tC[0,0] = (q[0]**2.0) + (q[1]**2.0) - (q[2]**2.0) - (q[3]**2.0);\n\tC[0,1] = 2.0 * ((q[1]*q[2]) + (q[0]*q[3]));\n\tC[0,2] = 2.0 * ((q[1]*q[3]) - (q[0]*q[2]));\n\n\tC[1,0] = 2.0 * ((q[1]*q[2]) - (q[0]*q[3]));\n\tC[1,1] = (q[0]**2.0) - (q[1]**2.0) + (q[2]**2.0) - (q[3]**2.0);\n\tC[1,2] = 2.0 * ((q[2]*q[3]) + (q[0]*q[1]));\n\n\tC[2,0] = 2.0 * ((q[1]*q[3]) + (q[0]*q[2]));\n\tC[2,1] = 2.0 * ((q[2]*q[3]) - (q[0]*q[1]));\n\tC[2,2] = (q[0]**2.0) - (q[1]**2.0) - (q[2]**2.0) + (q[3]**2.0);\n\n return C","def getU3(state):\n\n # TODO : do the verifictions of the above constraints\n\n theta=2*math.acos(state[0])\n phi=0\n lam=0\n\n if state[1]<0: theta = -theta\n\n # U3=np.array([\n # [math.cos(theta/2) , np.exp(-1j*lam)*math.sin(theta/2)], \n # [np.exp(1j*phi)*math.sin(theta/2), np.exp(1j*(phi+lam))*math.cos(theta/2)]\n # ])\n # print (U3)\n # print (U3@np.array([[1],[0]]))\n\n return [theta, phi, lam]","def cube(num):\n cube = num ** 3\n return cube","def scale4(a,c):\n return [a[0]*c,a[1]*c,a[2]*c,a[3]*c]","def cubeCij(c11, c13, c44):\n C = np.zeros(shape=(6, 6))\n C[0, 0] = C[1, 1] = C[2, 2] = c11\n C[0, 1] = C[0, 2] = C[1, 0] = C[1, 2] = C[2, 0] = C[2, 1] = c13\n C[3, 3] = C[4, 4] = C[5, 5] = c44\n S = np.linalg.inv(C)\n return {\"C\": C, \"S\": S}","def return_box(self, num):\n result = []\n three = [0, 1, 2]\n for a in three: #row\n for b in three: #column\n result += [self.board[a+((num-1)//3)*3][b+(num%3-1)*3]]\n return result","def transpose_3d():\n tmp = np.random.random((10, 10, 10))\n\n a = tmp.T\n b = np.empty(tmp.shape)\n for j in range(tmp.shape[1]):\n b[:, j, :] = tmp[:, j, :].T\n\n print(np.all(a == b))","def reduce_3sat_to_3col(instance, G = None):\n G = Graph() if G is None else G\n\n # add common gadget\n G.add_named_vertex('T')\n G.add_named_vertex('F')\n G.add_named_vertex('X')\n G.add_edge('T', 'F')\n G.add_edge('F', 'X')\n G.add_edge('X', 'T')\n\n\n # add gadget for variables\n variables = sorted(set([abs(v) for clause in instance for v in clause]))\n\n for v in variables:\n G.add_named_vertex(v)\n G.add_named_vertex(-v)\n G.add_edge('X', v)\n G.add_edge('X', -v)\n G.add_edge(v, -v)\n\n G.set_vertex_index(max(variables) + 1)\n # add the clause gadgets\n for a, b, c in instance:\n g1, g2, g3, g4, g5 = [G.add_vertex() for _i in range(5)]\n\n # triangle 1,2,3\n G.add_edge(g1, g2) # 1\n G.add_edge(g2, g3) # 2\n G.add_edge(g3, g1) # 3\n\n # bridge betwen triangle 1,2,3T and 4,5,T\n G.add_edge(g3, g4) # 4\n\n # triangle 3,4,5\n G.add_edge(g4, g5) # 5\n G.add_edge(g5, 'T') # 6\n G.add_edge('T', g4) # 7\n\n # edges for clause a,b,c\n G.add_edge(a, g1) # 8\n G.add_edge(b, g2) # 9\n G.add_edge(c, g5) # 10\n\n return G","def computeCRCD3(self, u0, u1, u2, u3, u4, u5, u6, u7):\n tmp = u0\n bs = [u1, u2, u3, u4, u5, u6, u7]\n for val in bs:\n for j in range(16):\n if tmp & (1 << 15):\n tmp <<= 1\n if val & (1 << 15):\n tmp += 1\n tmp ^= 0x8005\n else:\n tmp <<= 1\n if val & (1 << 15):\n tmp += 1\n val <<= 1\n tmp &= 0xffff\n return tmp","def matrix_3d_to_4x4(matrix: np.matrix) -> np.matrix:\n return np.matrix([\n [matrix.item(0, 0), matrix.item(0, 1), matrix.item(0, 2), 0],\n [matrix.item(1, 0), matrix.item(1, 1), matrix.item(1, 2), 0],\n [matrix.item(2, 0), matrix.item(2, 1), matrix.item(2, 2), 0],\n [0, 0, 0, 1]])","def convert_coordinate_system_3d(x, y, z):\n\n return x, -z, y","def reconstructImage(self,arr):\n\t\tarr = arr * 256\n\t\tarr = np.array(np.round(arr),dtype=np.uint8)\n\t\t#arr = np.array(arr,dtype=np.uint8)\n\n\t\t# We need to transpose the array because we flatten X by columns\n\t\t#arr = arr.T\n\t\t#a = arr.reshape((self.width, self.height,3))\n\t\t\n\t\tif self.mode == 'L':\n\t\t\ta = arr.reshape((self.width, self.height))\n\t\telse:\n\t\t\ta = arr.reshape((self.width, self.height,3))\n\n\t\t#a = arr.reshape((3,self.width, self.height))\t\t\n\t\t#a = arr.transpose(0, 3, 1, 2)\n\n\t\tim = Image.fromarray(a,mode=self.mode)\n\n\t\treturn im","def Expand3D(x):\r\n\r\n if x < 0:\r\n raise Exception(\r\n \"\"\"ERROR: Morton code is valid only for positive numbers\"\"\")\r\n x &= 0x7fffffffL\r\n x = (x ^ x << 32) & 0x7fff00000000ffffL\r\n x = (x ^ x << 16) & 0x7f0000ff0000ff0000ffL\r\n x = (x ^ x << 8) & 0x700f00f00f00f00f00f00fL\r\n x = (x ^ x << 4) & 0x430c30c30c30c30c30c30c3L\r\n x = (x ^ x << 2) & 0x49249249249249249249249L\r\n return x","def test_3_2_4D_cube_splits(self):\n check = [(0, 0, 0, 0), (1, 1, 1, 1), (1, 0, 0, 0), (1, 1, 0, 0),\n (1, 1, 1, 0),\n (1, 1, 0, 1), (1, 0, 1, 0), (1, 0, 1, 1), (1, 0, 0, 1),\n (0, 1, 0, 0),\n (0, 1, 1, 0), (0, 1, 1, 1), (0, 1, 0, 1), (0, 0, 1, 0),\n (0, 0, 1, 1),\n (0, 0, 0, 1), (0.5, 0.5, 0.5, 0.5), (0.0, 0.5, 0.5, 0.5),\n (0.0, 0.0, 0.5, 0.5), (0.0, 0.0, 0.0, 0.5),\n (0.0, 0.0, 0.5, 0.0),\n (0.0, 0.5, 0.0, 0.5), (0.0, 0.5, 0.0, 0.0),\n (0.0, 0.5, 0.5, 0.0),\n (0.5, 0.0, 0.5, 0.5), (0.5, 0.0, 0.0, 0.5),\n (0.5, 0.0, 0.0, 0.0),\n (0.5, 0.0, 0.5, 0.0), (0.5, 0.5, 0.0, 0.5),\n (0.5, 0.5, 0.0, 0.0),\n (0.5, 0.5, 0.5, 0.0), (0.25, 0.25, 0.25, 0.25),\n (1.0, 0.5, 0.5, 0.5),\n (1.0, 1.0, 0.5, 0.5), (1.0, 1.0, 1.0, 0.5),\n (1.0, 1.0, 0.5, 1.0),\n (1.0, 0.5, 1.0, 0.5), (1.0, 0.5, 1.0, 1.0),\n (1.0, 0.5, 0.5, 1.0),\n (0.5, 1.0, 0.5, 0.5), (0.5, 1.0, 1.0, 0.5),\n (0.5, 1.0, 1.0, 1.0),\n (0.5, 1.0, 0.5, 1.0), (0.5, 0.5, 1.0, 0.5),\n (0.5, 0.5, 1.0, 1.0),\n (0.5, 0.5, 0.5, 1.0), (0.75, 0.75, 0.75, 0.75),\n (1.0, 0.0, 0.5, 0.5),\n (1.0, 0.0, 0.0, 0.5), (1.0, 0.0, 0.5, 0.0),\n (1.0, 0.5, 0.0, 0.5),\n (1.0, 0.5, 0.0, 0.0), (1.0, 0.5, 0.5, 0.0),\n (0.75, 0.25, 0.25, 0.25),\n (1.0, 1.0, 0.0, 0.5), (1.0, 1.0, 0.5, 0.0),\n (0.5, 1.0, 0.0, 0.5),\n (0.5, 1.0, 0.0, 0.0), (0.5, 1.0, 0.5, 0.0),\n (0.75, 0.75, 0.25, 0.25),\n (1.0, 0.5, 1.0, 0.0), (0.5, 1.0, 1.0, 0.0),\n (0.5, 0.5, 1.0, 0.0),\n (0.75, 0.75, 0.75, 0.25), (1.0, 0.5, 0.0, 1.0),\n (0.5, 1.0, 0.0, 1.0),\n (0.5, 0.5, 0.0, 1.0), (0.75, 0.75, 0.25, 0.75),\n (1.0, 0.0, 1.0, 0.5),\n (0.5, 0.0, 1.0, 0.5), (0.5, 0.0, 1.0, 0.0),\n (0.75, 0.25, 0.75, 0.25),\n (1.0, 0.0, 0.5, 1.0), (0.5, 0.0, 1.0, 1.0),\n (0.5, 0.0, 0.5, 1.0),\n (0.75, 0.25, 0.75, 0.75), (0.5, 0.0, 0.0, 1.0),\n (0.75, 0.25, 0.25, 0.75), (0.0, 1.0, 0.5, 0.5),\n (0.0, 1.0, 0.0, 0.5),\n (0.0, 1.0, 0.5, 0.0), (0.25, 0.75, 0.25, 0.25),\n (0.0, 1.0, 1.0, 0.5),\n (0.0, 0.5, 1.0, 0.5), (0.0, 0.5, 1.0, 0.0),\n (0.25, 0.75, 0.75, 0.25),\n (0.0, 1.0, 0.5, 1.0), (0.0, 0.5, 1.0, 1.0),\n (0.0, 0.5, 0.5, 1.0),\n (0.25, 0.75, 0.75, 0.75), (0.0, 0.5, 0.0, 1.0),\n (0.25, 0.75, 0.25, 0.75), (0.0, 0.0, 1.0, 0.5),\n (0.25, 0.25, 0.75, 0.25), (0.0, 0.0, 0.5, 1.0),\n (0.25, 0.25, 0.75, 0.75), (0.25, 0.25, 0.25, 0.75)]\n\n nn_checks = {(0, 0, 0, 0): [(0.0, 0.5, 0.5, 0.0), (0.5, 0.0, 0.5, 0.5),\n (0.5, 0.5, 0.0, 0.5),\n (0.25, 0.25, 0.25, 0.25),\n (0.5, 0.0, 0.0, 0.5), (0.5, 0.0, 0.5, 0.0),\n (0.5, 0.5, 0.0, 0.0), (0.0, 0.0, 0.5, 0.0),\n (0.0, 0.5, 0.0, 0.0), (0.0, 0.0, 0.0, 0.5),\n (0.0, 0.5, 0.5, 0.5), (0.0, 0.0, 0.5, 0.5),\n (0.0, 0.5, 0.0, 0.5), (0.5, 0.0, 0.0, 0.0),\n (0.5, 0.5, 0.5, 0.0)],\n (1.0, 1.0, 0.5, 0.5): [(1.0, 1.0, 0.5, 1.0), (1, 1, 0, 1),\n (1.0, 1.0, 1.0, 0.5),\n (1.0, 0.5, 0.5, 0.5), (1, 1, 1, 0),\n (1.0, 1.0, 0.5, 0.0),\n (1.0, 1.0, 0.0, 0.5), (1, 1, 0, 0),\n (1, 1, 1, 1), (0.5, 1.0, 0.5, 0.5),\n (0.5, 0.5, 0.5, 0.5),\n (0.75, 0.75, 0.75, 0.75),\n (0.75, 0.75, 0.25, 0.25),\n (0.75, 0.75, 0.75, 0.25),\n (0.75, 0.75, 0.25, 0.75)],\n (0.25, 0.25, 0.25, 0.75): [(0.0, 0.0, 0.5, 1.0),\n (0.0, 0.5, 0.0, 1.0),\n (0.5, 0.0, 0.0, 1.0),\n (0.5, 0.5, 0.5, 1.0),\n (0, 0, 0, 1),\n (0.0, 0.5, 0.5, 1.0),\n (0.5, 0.0, 0.5, 1.0),\n (0.5, 0.5, 0.0, 1.0),\n (0.0, 0.0, 0.0, 0.5),\n (0.0, 0.0, 0.5, 0.5),\n (0.0, 0.5, 0.5, 0.5),\n (0.0, 0.5, 0.0, 0.5),\n (0.5, 0.0, 0.5, 0.5),\n (0.5, 0.5, 0.0, 0.5),\n (0.5, 0.5, 0.5, 0.5),\n (0.5, 0.0, 0.0, 0.5)]}\n\n init_triangulation(4, 1, check, nn_checks)","def factor_tuple(input,factor):\n input_np = np.array(list(input))\n input_np = input_np*factor\n return tuple(list(input_np))","def _change_box_format(self, boxes):\n boxes[..., 0] = boxes[..., 0]\n boxes[..., 1] = boxes[..., 1]\n boxes[..., 2] = boxes[..., 2]\n boxes[..., 3] = boxes[..., 1] + boxes[..., 3]\n boxes[..., 4] = boxes[..., 2] + boxes[..., 4]\n return boxes","def to_se3(self, state: Vector) -> RigidTransform:\n return (state[:9],state[9:])","def mask_tile(self):\n if self.size == 1:\n m = np.array([[0]])\n elif self.size ==2:\n m = np.array([[1,2],[4,3]])\n else:\n m = 9 * np.ones((self.size, self.size))\n m[0,0] = 1\n m[0,-1] = 2\n m[-1,-1] = 3\n m[-1,0] = 4 \n m[0,1:-1] = 5 * np.ones(self.size-2)\n m[1:-1,-1] = 6 * np.ones(self.size-2)\n m[-1,1:-1] = 7 * np.ones(self.size-2)\n m[1:-1,0] = 8 * np.ones(self.size-2)\n return m.astype(np.int8)","def gm2code(arr, info):\n return (arr / info.pboxsize + 0.5)# * 0.999783599","def to_se3(self, state: Vector) -> RigidTransform:\n return (state[:9],state[9:12])","def _to_bc_L_h_w(x, x_shape):\r\n x = tf.reshape(x, (-1,\r\n int(x_shape[2]),\r\n int(x_shape[3]),\r\n int(x_shape[4])))\r\n return x","def checksumToBoard(self):\n\t\treal_board = [[ '.' for x in range(9)] for x in range(9)] \n\n\t\txstart = 0\n\t\txend = 3\n\t\tystart = 0\n\t\tyend = 3\n\n\t\tfor i in range(0,3):\n\t\t\tself.makeBoard(i,real_board,xstart,xend,ystart,yend)\n\t\t\tystart += 3\n\t\t\tyend += 3\n\n\t\n\t\txstart = 3\n\t\txend = 6\n\t\tystart = 0\n\t\tyend = 3\n\t\tfor i in range(3,6):\n\t\t\tself.makeBoard(i,real_board,xstart,xend,ystart,yend)\n\t\t\tystart += 3\n\t\t\tyend += 3\n\n\n\t\txstart = 6\n\t\txend = 9\n\t\tystart = 0\n\t\tyend = 3\n\t\tfor i in range(6,9):\n\t\t\tself.makeBoard(i,real_board,xstart,xend,ystart,yend)\n\t\t\tystart += 3\n\t\t\tyend += 3\n\n\t\t# print 'Board created from checksum values:'\n\t\t# for i in range(0,9):\n\t\t# \tfor j in range(0,9):\n\t\t# \t\tprint real_board[i][j],\n\t\t# \t\tif j%3 == 2:\n\t\t# \t\t\tprint \"|\",\n\t\t# \tprint\n\t\t# \tif i%3 == 2:\n\t\t# \t\tprint \" _ _ _ _ _ _ _ _ _\"\n\n\t\treturn real_board","def normalize((image)):\n new = np.zeros((7,7))\n index = 0\n for i in [0, 4, 7, 10, 14, 17, 21]:\n for j in [0, 4, 7, 10, 14, 17, 21]:\n new[index / 7][index % 7] += float(np.sum(image[i:(i+6),j:(j+6)]))/49\n index += 1\n return new","def construct(self, x):\n x = self.conv(x)\n h0 = self.up_conv1(x)\n l0 = self.up_conv2(h0)\n h1 = self.up_conv3(l0 - x)\n return h1 + h0","def testCube(self):\n cube = {i:(i^1,i^2,i^4) for i in range(8)}\n self.check(cube,6)","def test_Pad3D7():\n input_shape = (1, 2, 3)\n pad = [1, 2]\n mode = \"reflect\"\n res = [[[2, 1, 2, 3, 2, 1], [5, 4, 5, 6, 5, 4]]]\n data = np.arange(np.prod(input_shape)).reshape(input_shape) + 1\n obj.base(res=res, padding=pad, mode=mode, data_format=\"NCL\", data=data)","def jadeite():\n\n rho = 3330.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 274.; C[0,1] = 94.; C[0,2] = 71.; C[0,3] = 0.; C[0,4] = 4.; C[0,5] = 0.\n C[1,0] = C[0,1]; C[1,1] = 253.; C[1,2] = 82.; C[1,3] = 0.; C[1,4] = 14.; C[1,5] = 0.\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 282.; C[2,3] = 0.; C[2,4] = 28.; C[2,5] = 0.\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 88.; C[3,4] = 0.; C[3,5] = 13.\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 65.; C[4,5] = 0.\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 94.\n\n return C, rho","def cube(num1):\n cubed = num1*num1*num1\n return cubed","def f_to_c(temp):\n if type(temp) is list or type(temp) is tuple:\n return [(c - 32) / 1.8 for c in temp]\n else:\n return (temp - 32.0) / 1.8"],"string":"[\n \"def make8UC3(mat):\\n mat_8UC = make8UC(mat)\\n mat_8UC3 = np.stack((mat_8UC,)*3, axis = -1)\\n \\n return mat_8UC3\",\n \"def dti6to33(dt6):\\n dt33 = numpy.zeros(dt6.shape[:-1] + (3, 3), dtype=dt6.dtype)\\n dt33[..., 0, 0] = dt6[..., 5] # dxx\\n dt33[..., 0, 1] = dt33[..., 1, 0] = dt6[..., 4] / 2 # dxy\\n dt33[..., 0, 2] = dt33[..., 2, 0] = dt6[..., 3] / 2 # dxz\\n dt33[..., 1, 1] = dt6[..., 2] # dyy\\n dt33[..., 1, 2] = dt33[..., 2, 1] = dt6[..., 1] / 2 # dyz\\n dt33[..., 2, 2] = dt6[..., 0] # dzz\\n\\n return dt33\",\n \"def one_to_three(one):\\n return ((1,0,0),(0,1,0),(0,0,1))[one+1]\",\n \"def _to_bc_L_h_w_3(x, x_shape):\\r\\n\\r\\n x = tf.reshape(x, (-1,\\r\\n int(x_shape[2]),\\r\\n int(x_shape[3]),\\r\\n int(x_shape[4]), 3))\\r\\n return x\",\n \"def nine_to_3x3(listy):\\n new_side = []\\n k = int(len(listy) / 3)\\n \\n for i in range(k):\\n intermediate = []\\n for j in range(3):\\n intermediate.append(listy.pop(0))\\n \\n new_side.append(intermediate)\\n return new_side\",\n \"def dti33to6(dt33):\\n dt6 = numpy.zeros(dt33.shape[:-2] + (6, ), dtype=dt33.dtype)\\n dt6[..., 5] = dt33[..., 0, 0]\\n dt6[..., 4] = dt33[..., 0, 1] + dt33[..., 1, 0]\\n dt6[..., 3] = dt33[..., 0, 2] + dt33[..., 2, 0]\\n dt6[..., 2] = dt33[..., 1, 1]\\n dt6[..., 1] = dt33[..., 1, 2] + dt33[..., 2, 1]\\n dt6[..., 0] = dt33[..., 2, 2]\\n\\n return dt6\",\n \"def tdim3(dim3):\\n return TransformedDimension(Compose([], dim3.type), dim3)\",\n \"def convert_game_action_to_3D_action(ga):\\n tile_type, from_row, to_row, nbr_to_move = ga\\n\\n return (tile_type, min(nbr_to_move,5), to_row)\",\n \"def three_d6() -> list:\\n rolls: List[int] = []\\n for i in range(1, 7):\\n roll: int = multi_die(3, 6)\\n rolls.append(roll)\\n return rolls\",\n \"def dim3():\\n return Integer(\\\"yolo3\\\", \\\"uniform\\\", 3, 7, shape=(1,))\",\n \"def third_mixup(seq):\\n len_third = int(len(seq) / 3)\\n third_mixup = seq[-len_third:] + seq[:-len_third]\\n return third_mixup\",\n \"def Cijkl(C):\\n c = np.zeros(shape=(3, 3, 3, 3))\\n CC = np.zeros(shape=(9, 9))\\n CC[0:6, 0:6] = C[0:6, 0:6]\\n CC[6:9, 6:9] = C[3:6, 3:6]\\n CC[0:6, 6:9] = C[0:6, 3:6]\\n CC[6:9, 0:6] = C[3:6, 0:6]\\n\\n c[0, 0, 0, 0] = CC[0, 0]\\n c[0, 0, 1, 1] = CC[0, 1]\\n c[0, 0, 2, 2] = CC[0, 2]\\n c[0, 0, 1, 2] = CC[0, 3]\\n c[0, 0, 2, 0] = CC[0, 4]\\n c[0, 0, 0, 1] = CC[0, 5]\\n c[0, 0, 2, 1] = CC[0, 6]\\n c[0, 0, 0, 2] = CC[0, 7]\\n c[0, 0, 1, 0] = CC[0, 8]\\n\\n c[1, 1, 0, 0] = CC[1, 0]\\n c[1, 1, 1, 1] = CC[1, 1]\\n c[1, 1, 2, 2] = CC[1, 2]\\n c[1, 1, 1, 2] = CC[1, 3]\\n c[1, 1, 2, 0] = CC[1, 4]\\n c[1, 1, 0, 1] = CC[1, 5]\\n c[1, 1, 2, 1] = CC[1, 6]\\n c[1, 1, 0, 2] = CC[1, 7]\\n c[1, 1, 1, 0] = CC[1, 8]\\n\\n c[2, 2, 0, 0] = CC[2, 0]\\n c[2, 2, 1, 1] = CC[2, 1]\\n c[2, 2, 2, 2] = CC[2, 2]\\n c[2, 2, 1, 2] = CC[2, 3]\\n c[2, 2, 2, 0] = CC[2, 4]\\n c[2, 2, 0, 1] = CC[2, 5]\\n c[2, 2, 2, 1] = CC[2, 6]\\n c[2, 2, 0, 2] = CC[2, 7]\\n c[2, 2, 1, 0] = CC[2, 8]\\n\\n c[1, 2, 0, 0] = CC[3, 0]\\n c[1, 2, 1, 1] = CC[3, 1]\\n c[1, 2, 2, 2] = CC[3, 2]\\n c[1, 2, 1, 2] = CC[3, 3]\\n c[1, 2, 2, 0] = CC[3, 4]\\n c[1, 2, 0, 1] = CC[3, 5]\\n c[1, 2, 2, 1] = CC[3, 6]\\n c[1, 2, 0, 2] = CC[3, 7]\\n c[1, 2, 1, 0] = CC[3, 8]\\n\\n c[2, 0, 0, 0] = CC[4, 0]\\n c[2, 0, 1, 1] = CC[4, 1]\\n c[2, 0, 2, 2] = CC[4, 2]\\n c[2, 0, 1, 2] = CC[4, 3]\\n c[2, 0, 2, 0] = CC[4, 4]\\n c[2, 0, 0, 1] = CC[4, 5]\\n c[2, 0, 2, 1] = CC[4, 6]\\n c[2, 0, 0, 2] = CC[4, 7]\\n c[2, 0, 1, 0] = CC[4, 8]\\n\\n c[0, 1, 0, 0] = CC[5, 0]\\n c[0, 1, 1, 1] = CC[5, 1]\\n c[0, 1, 2, 2] = CC[5, 2]\\n c[0, 1, 1, 2] = CC[5, 3]\\n c[0, 1, 2, 0] = CC[5, 4]\\n c[0, 1, 0, 1] = CC[5, 5]\\n c[0, 1, 2, 1] = CC[5, 6]\\n c[0, 1, 0, 2] = CC[5, 7]\\n c[0, 1, 1, 0] = CC[5, 8]\\n\\n c[2, 1, 0, 0] = CC[6, 0]\\n c[2, 1, 1, 1] = CC[6, 1]\\n c[2, 1, 2, 2] = CC[6, 2]\\n c[2, 1, 1, 2] = CC[6, 3]\\n c[2, 1, 2, 0] = CC[6, 4]\\n c[2, 1, 0, 1] = CC[6, 5]\\n c[2, 1, 2, 1] = CC[6, 6]\\n c[2, 1, 0, 2] = CC[6, 7]\\n c[2, 1, 1, 0] = CC[6, 8]\\n\\n c[0, 2, 0, 0] = CC[7, 0]\\n c[0, 2, 1, 1] = CC[7, 1]\\n c[0, 2, 2, 2] = CC[7, 2]\\n c[0, 2, 1, 2] = CC[7, 3]\\n c[0, 2, 2, 0] = CC[7, 4]\\n c[0, 2, 0, 1] = CC[7, 5]\\n c[0, 2, 2, 1] = CC[7, 6]\\n c[0, 2, 0, 2] = CC[7, 7]\\n c[0, 2, 1, 0] = CC[7, 8]\\n\\n c[1, 0, 0, 0] = CC[8, 0]\\n c[1, 0, 1, 1] = CC[8, 1]\\n c[1, 0, 2, 2] = CC[8, 2]\\n c[1, 0, 1, 2] = CC[8, 3]\\n c[1, 0, 2, 0] = CC[8, 4]\\n c[1, 0, 0, 1] = CC[8, 5]\\n c[1, 0, 2, 1] = CC[8, 6]\\n c[1, 0, 0, 2] = CC[8, 7]\\n c[1, 0, 1, 0] = CC[8, 8]\\n return c\",\n \"def _transpose_by_1_vnchwconv():\\n\\n pass\",\n \"def six_hundred_cell(self):\\n verts = []\\n q12 = QQ(1)/2\\n base = [q12,q12,q12,q12]\\n for i in range(2):\\n for j in range(2):\\n for k in range(2):\\n for l in range(2):\\n verts.append([x for x in base])\\n base[3] = base[3]*(-1)\\n base[2] = base[2]*(-1)\\n base[1] = base[1]*(-1)\\n base[0] = base[0]*(-1)\\n for x in permutations([0,0,0,1]):\\n verts.append(x)\\n for x in permutations([0,0,0,-1]):\\n verts.append(x)\\n g = QQ(1618033)/1000000 # Golden ratio approximation\\n verts = verts + [i([q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n return Polyhedron(vertices = verts)\",\n \"def generate_3d_board(n):\\n layer = nxn_generate.generate_shuffled_2d_board(n)\\n cube = []\\n for i in range(len(layer)):\\n new_layer = []\\n for column in layer:\\n new_column = []\\n # this nested mess is to ensure that none of the sub 3x3 squares violates sudoku rules from any x y or z\\n # perspective (also the Latin Square rules but the subsquares are trickier and the cause of more mess)\\n for j in range(int(math.sqrt(len(layer)))):\\n for k in range(int(math.sqrt(len(layer)))):\\n # lot of 3 = (i+j) % 3\\n # index within lot = (i + k + (i//3)) % 3\\n new_column.append(column[int(math.sqrt(len(layer))) * ((i + j) % int(math.sqrt(len(layer)))) + (\\n i + k + (i // int(math.sqrt(len(layer))))) % int(math.sqrt(len(layer)))])\\n new_layer.append(new_column)\\n cube.append(new_layer)\\n\\n return shuffle_cube(cube)\",\n \"def axial_to_cube(axial):\\n x = axial[0] # q\\n z = axial[1] # r\\n y = -x-z\\n return tuple([x, y, z])\",\n \"def cube(num):\\n return num ** 3\",\n \"def _mat3(self):\\n if self.frame.orientation == HillFrame.DEFAULT_ORIENTATION:\\n return np.identity(3)\\n else:\\n return self.QSW2TNW\",\n \"def reformat(x):\\n x = x.permute(0, 2, 3, 1)\\n N, D1, D2, Feat = x.size()\\n x = x.view(N, D1 * D2, Feat)\\n return x\",\n \"def reformat(x):\\n x = x.permute(0, 2, 3, 1)\\n N, D1, D2, Feat = x.size()\\n x = x.view(N, D1 * D2, Feat)\\n return x\",\n \"def cube(n):\\n return n**3\",\n \"def c_matrix(x1,x2,x3):\\n\\tC = np.array([\\t[\\t2*(x2-x1), \\t\\t(x2-x1), \\t\\t\\t0\\t\\t\\t], \\\\\\n\\t\\t\\t\\t\\t[\\t(x2-x1), \\t\\t2*(x3-x1), \\t\\t(x3-x2)\\t\\t], \\\\\\n\\t\\t\\t\\t\\t[\\t0,\\t\\t\\t\\t(x3-x2),\\t\\t2*(x3-x2)\\t] \\t], \\\\\\n\\t\\t\\t\\t\\tfloat)\\n\\treturn(C)\",\n \"def reduce_kcol_to_3col(G, k):\\n\\n G, H = prepare_grid(G)\\n print(\\\"grid prepared\\\")\\n N = len(G)\\n H = create_kgrid(H, N, k)\\n print(\\\"grid created\\\")\\n H = add_pheripherals_per_edge(G.edges, H, k)\\n print(\\\"peripherals added\\\")\\n\\n return H\",\n \"def _pad_1x1_to_3x3_tensor(self, kernel1x1):\\n if kernel1x1 is None:\\n return 0\\n else:\\n return torch.nn.functional.pad(kernel1x1, [1, 1, 1, 1])\",\n \"def six_cubed():\\n print(math.pow(6,3))\",\n \"def _aseg_to_three():\\n import numpy as np\\n\\n # Base struct\\n aseg_lut = np.zeros((256,), dtype=\\\"int\\\")\\n # GM\\n aseg_lut[3] = 1\\n aseg_lut[8:14] = 1\\n aseg_lut[17:21] = 1\\n aseg_lut[26:40] = 1\\n aseg_lut[42] = 1\\n aseg_lut[47:73] = 1\\n\\n # CSF\\n aseg_lut[4:6] = 3\\n aseg_lut[14:16] = 3\\n aseg_lut[24] = 3\\n aseg_lut[43:45] = 3\\n aseg_lut[72] = 3\\n\\n # WM\\n aseg_lut[2] = 2\\n aseg_lut[7] = 2\\n aseg_lut[16] = 2\\n aseg_lut[28] = 2\\n aseg_lut[41] = 2\\n aseg_lut[46] = 2\\n aseg_lut[60] = 2\\n aseg_lut[77:80] = 2\\n aseg_lut[250:256] = 2\\n return tuple(aseg_lut)\",\n \"def nu3(self):\\n n = self.level()\\n if (n % 9 == 0):\\n return ZZ(0)\\n return prod([ 1 + kronecker_symbol(-3, p) for p, _ in n.factor()])\",\n \"def cube_array(self):\\n cube_sides = {}\\n\\n for side in SIDES:\\n cube_sides[side] = []\\n \\n # Todo Break this loop into helper functions for clarity and simplicity\\n for coord in COORDS_3:\\n for cubie in self.cubies:\\n # Making sure that the cubes cubies are processed in the correct order\\n if np.array_equal(cubie.coordinates, coord): \\n \\n \\n for side in SIDES:\\n if cubie.in_side(side):\\n for face in cubie.faces:\\n \\n # Checking that the face of the cubie has the same norm as the side we are processing\\n if np.array_equal(face.norm, NORMS[side]):\\n cube_sides[side].append(face.colour)\\n\\n new_list = [cube_sides[\\\"U\\\"], cube_sides[\\\"F\\\"], reversal(cube_sides[\\\"R\\\"]), reversal(cube_sides[\\\"B\\\"]),\\n cube_sides[\\\"L\\\"], reversal(cube_sides[\\\"D\\\"])]\\n \\n final_list = [nine_to_3x3(side) for side in new_list]\\n return final_list\",\n \"def check3x3(self, board):\\n\\t\\t\\t# print \\\"This is check3x3\\\"\\n\\t\\t\\t# for i in xrange(0,9):\\n\\t\\t\\t# \\tprint board[i],\\n\\t\\t\\t# \\tif i%3 == 2:\\n\\t\\t\\t# \\t\\tprint\\n\\n\\t\\t\\tvalue = self.finddraw(board)\\n\\t\\t\\tif(value[1] != -1):\\n\\t\\t\\t\\treturn value[1]\\n\\t\\t\\t#Rows\\n\\t\\t\\tfor i in range(0,9):\\n\\t\\t\\t\\tif(i%3 == 0):\\n\\t\\t\\t\\t\\tif (board[i] == 'x' and board[i+1] == 'x' and board[i+2] == 'x'):\\n\\t\\t\\t\\t\\t\\tif(self.symbol == 'x'):\\n\\t\\t\\t\\t\\t\\t\\treturn 4\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\treturn 0\\n\\t\\n\\t\\t\\t\\t\\tif (board[i] == 'o' and board[i+1] == 'o' and board[i+2] == 'o'):\\n\\t\\t\\t\\t\\t\\tif(self.symbol == 'o'):\\n\\t\\t\\t\\t\\t\\t\\treturn 4\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\treturn 0\\n\\n\\t\\t\\t#Colomns\\n\\t\\t\\tfor i in range(0,3):\\n\\t\\t\\t\\tif(i/3 == 0):\\n\\t\\t\\t\\t\\tif (board[i] == 'x' and board[i+3] == 'x' and board[i+6] == 'x'):\\n\\t\\t\\t\\t\\t\\tif(self.symbol == 'x'):\\n\\t\\t\\t\\t\\t\\t\\treturn 4\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\treturn 0\\n\\t\\n\\t\\t\\t\\t\\tif (board[i] == 'o' and board[i+3] == 'o' and board[i+6] == 'o'):\\n\\t\\t\\t\\t\\t\\tif(self.symbol == 'o'):\\n\\t\\t\\t\\t\\t\\t\\treturn 4\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\treturn 0\\n\\n\\t\\t\\tcount = 0\\n\\t\\t\\tsavei = 0\\n\\t\\t\\tvalue = -1\\n\\t\\t\\tfor i in range(0,9):\\n\\t\\t\\t\\t\\tif(board[i] != '-'):\\n\\t\\t\\t\\t\\t\\tcount += 1\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tsavei = i\\n\\n\\t\\t\\tif(count == 9):\\n\\t\\t\\t\\treturn 1\\n\\t\\t\\tif(count == 8):\\n\\t\\t\\t\\tif(self.symbol == 'x'):\\n\\t\\t\\t\\t\\tboard[savei] = 'o'\\n\\t\\t\\t\\t\\tvalue = self.finddraw(board)\\n\\t\\t\\t\\tif(self.symbol == 'o'):\\n\\t\\t\\t\\t\\tboard[savei] = 'x'\\n\\t\\t\\t\\t\\tvalue = self.finddraw(board)\\n\\t\\t\\t\\tif(value[1] > -1):\\n\\t\\t\\t\\t\\tif(value[1] == 1):\\n\\t\\t\\t\\t\\t\\treturn 1\\n\\t\\t\\t\\t\\tif(value[1] == 4):\\n\\t\\t\\t\\t\\t\\treturn 2\\n\\n\\t\\t\\treturn -1\",\n \"def get_A3():\\n\\n return array([[0.68557183+0.46550108j, 0.12934765-0.1622676j,\\n 0.24409518+0.25335939j],\\n [0.1531015 + 0.66678983j, 0.45112492+0.18206976j,\\n -0.02633966+0.43477693j],\\n [-0.10817164-1.16879196j, -0.18446849+0.03755672j,\\n 0.06430325-0.44757084j]])\",\n \"def scale3(a,c):\\n return [a[0]*c,a[1]*c,a[2]*c,1.0]\",\n \"def rot6d_to_rotmat(x):\\n x = x.view(-1,3,2)\\n a1 = x[:, :, 0]\\n a2 = x[:, :, 1]\\n b1 = F.normalize(a1)\\n b2 = F.normalize(a2 - torch.einsum('bi,bi->b', b1, a2).unsqueeze(-1) * b1)\\n b3 = torch.cross(b1, b2)\\n return torch.stack((b1, b2, b3), dim=-1)\",\n \"def subpel_conv3x3(in_ch, out_ch, r=1):\\n # return nn.Sequential(\\n # nn.Conv2d(in_ch, out_ch * r**2, kernel_size=3, padding=1),\\n # nn.PixelShuffle(r))\\n # change\\n return nn.SequentialCell([nn.Conv2d(in_ch, out_ch * r**2, kernel_size=3, padding=1),\\n # # TODO BY J : no pixel shuffle in mindspore\\n # nn.PixelShuffle(r))\\n ])\",\n \"def cube(n):\\n result = [num*num*num for num in range(n)]\\n\\n return result[1:]\",\n \"def three_dimensional(self, z): # Maybe I misunderstood the task. My method looks weird\\n return (self.x, self.y, z)\",\n \"def six_cubed():\\n print(math.pow(6, 3))\",\n \"def rotmat_to_rot6d(rotmat):\\n\\n rot6d = rotmat[:, :, 0:2]\\n rot6d = rot6d.reshape(-1, 6)\\n\\n return rot6d\",\n \"def cube(x):\\n return x ** 3\",\n \"def cube(x):\\n return x ** 3\",\n \"def mat_2d_to_3d(x, agg_num, hop):\\n # Pad to at least one block. \\n len_x, n_in = x.shape\\n if (len_x < agg_num):\\n x = np.concatenate((x, np.zeros((agg_num - len_x, n_in))))\\n \\n # Segment 2d to 3d. \\n len_x = len(x)\\n i1 = 0\\n x3d = []\\n while (i1 + agg_num <= len_x):\\n x3d.append(x[i1 : i1 + agg_num])\\n i1 += hop\\n return np.array(x3d)\",\n \"def coupling_6j((J1,J2,J3),(J4,J5,J6)):\\n cj6=pygsl.sf.coupling_6j(int(2*J1),int(2*J2), int(2*J3), int(2*J4),int(2*J5), int(2*J6))[0]\\n cj6=(-1)**(J1+J2+J4+J5)*hat(J3)*hat(J6)*cj6 \\n return cj6\",\n \"def preprocess_3d(im_stack):\\n im_stack /= 127.5\\n im_stack -= 1.0\\n return im_stack\",\n \"def rot6d_to_rotmat(x):\\n x = x.view(-1, 3, 2)\\n a1 = x[:, :, 0]\\n a2 = x[:, :, 1]\\n b1 = F.normalize(a1)\\n b2 = F.normalize(a2 - torch.einsum('bi,bi->b', b1, a2).unsqueeze(-1) * b1)\\n b3 = torch.cross(b1, b2)\\n return torch.stack((b1, b2, b3), dim=-1)\",\n \"def rot6d_to_rotmat(x):\\n x = x.view(-1, 3, 2)\\n a1 = x[:, :, 0]\\n a2 = x[:, :, 1]\\n b1 = F.normalize(a1)\\n b2 = F.normalize(a2 - torch.einsum('bi,bi->b', b1, a2).unsqueeze(-1) * b1)\\n b3 = torch.cross(b1, b2)\\n return torch.stack((b1, b2, b3), dim=-1)\",\n \"def _build(self):\\n ary = np.zeros( (3,3,3), float )\\n ary[0,0,0] = ary[1,1,1] = ary[0,1,2] = ary[1,0,2] = 1.\\n ary[0,2,0] = ary[0,2,2] = ary[2,0,0] = ary[2,0,2] = 0.5\\n ary[1,2,1] = ary[1,2,2] = ary[2,1,1] = ary[2,1,2] = 0.5\\n ary[2,2,0] = ary[2,2,1] = 0.25\\n ary[2,2,2] = 0.5\\n return ary\",\n \"def test_Pad3D6():\\n input_shape = (1, 1, 2, 3, 2)\\n # pad = np.array([1, 0, 1, 2, 1, 0]).astype('int32')\\n pad = [1, 0, 1, 2, 1, 0]\\n mode = \\\"constant\\\"\\n res = [\\n [\\n [\\n [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]],\\n [[0, 0, 0], [0, 1, 2], [0, 3, 4], [0, 5, 6], [0, 0, 0], [0, 0, 0]],\\n [[0, 0, 0], [0, 7, 8], [0, 9, 10], [0, 11, 12], [0, 0, 0], [0, 0, 0]],\\n ]\\n ]\\n ]\\n data = np.arange(np.prod(input_shape)).reshape(input_shape) + 1\\n obj.run(res=res, padding=pad, mode=mode, data_format=\\\"NCDHW\\\", data=data)\",\n \"def get_B3():\\n return array([[0.46870499+0.37541453j, 0.19115959-0.39233203j,\\n 0.12830659+0.12102382j],\\n [0.90249603-0.09446345j, 0.51584055+0.84326503j,\\n -0.02582305+0.23259079j],\\n [0.75419973-0.52470311j, -0.59173739+0.48075322j,\\n 0.51545446-0.21867957j]])\",\n \"def box_3d_to_3d_iou_format(boxes_3d):\\n boxes_3d = np.asarray(boxes_3d)\\n fc.check_box_3d_format(boxes_3d)\\n\\n iou_3d_boxes = np.zeros([len(boxes_3d), 7])\\n iou_3d_boxes[:, 4:7] = boxes_3d[:, 0:3]\\n iou_3d_boxes[:, 1] = boxes_3d[:, 3]\\n iou_3d_boxes[:, 2] = boxes_3d[:, 4]\\n iou_3d_boxes[:, 3] = boxes_3d[:, 5]\\n iou_3d_boxes[:, 0] = boxes_3d[:, 6]\\n\\n return iou_3d_boxes\",\n \"def get_3d_H(H1):\\n H_fin = [H1[0,0], 0, H1[0,1], H1[0,2], 0, 1, 0, 0, H1[1,0], 0, H1[1,1], H1[1,2]]\\n H_fin = np.array(H_fin).reshape(3,4)\\n return H_fin\",\n \"def test_2_2_3D_cube_splits(self):\\n check = [(0, 0, 0), (1, 1, 1), (1, 0, 0), (1, 1, 0), (1, 0, 1),\\n (0, 1, 0),\\n (0, 1, 1), (0, 0, 1), (0.5, 0.5, 0.5), (0.0, 0.5, 0.5),\\n (0.0, 0.0, 0.5), (0.0, 0.5, 0.0), (0.5, 0.0, 0.5),\\n (0.5, 0.0, 0.0),\\n (0.5, 0.5, 0.0), (0.25, 0.25, 0.25), (1.0, 0.5, 0.5),\\n (1.0, 1.0, 0.5),\\n (1.0, 0.5, 1.0), (0.5, 1.0, 0.5), (0.5, 1.0, 1.0),\\n (0.5, 0.5, 1.0),\\n (0.75, 0.75, 0.75), (1.0, 0.0, 0.5), (1.0, 0.5, 0.0),\\n (0.75, 0.25, 0.25), (0.5, 1.0, 0.0), (0.75, 0.75, 0.25),\\n (0.5, 0.0, 1.0), (0.75, 0.25, 0.75), (0.0, 1.0, 0.5),\\n (0.25, 0.75, 0.25), (0.0, 0.5, 1.0), (0.25, 0.75, 0.75),\\n (0.25, 0.25, 0.75), (0.5, 0.25, 0.25), (0.5, 0.5, 0.25),\\n (0.5, 0.25, 0.5), (0.25, 0.5, 0.25), (0.25, 0.5, 0.5),\\n (0.25, 0.25, 0.5), (0.375, 0.375, 0.375), (0.0, 0.25, 0.25),\\n (0.0, 0.0, 0.25), (0.0, 0.25, 0.0), (0.25, 0.0, 0.25),\\n (0.25, 0.0, 0.0), (0.25, 0.25, 0.0), (0.125, 0.125, 0.125),\\n (0.0, 0.5, 0.25), (0.0, 0.25, 0.5), (0.125, 0.375, 0.375),\\n (0.25, 0.0, 0.5), (0.125, 0.125, 0.375), (0.25, 0.5, 0.0),\\n (0.125, 0.375, 0.125), (0.5, 0.0, 0.25), (0.375, 0.125, 0.375),\\n (0.5, 0.25, 0.0), (0.375, 0.125, 0.125), (0.375, 0.375, 0.125),\\n (0.5, 0.75, 0.75), (0.5, 0.5, 0.75), (0.5, 0.75, 0.5),\\n (0.75, 0.5, 0.75), (0.75, 0.5, 0.5), (0.75, 0.75, 0.5),\\n (0.625, 0.625, 0.625), (1.0, 0.75, 0.75), (1.0, 1.0, 0.75),\\n (1.0, 0.75, 1.0), (0.75, 1.0, 0.75), (0.75, 1.0, 1.0),\\n (0.75, 0.75, 1.0), (0.875, 0.875, 0.875), (1.0, 0.5, 0.75),\\n (1.0, 0.75, 0.5), (0.875, 0.625, 0.625), (0.75, 1.0, 0.5),\\n (0.875, 0.875, 0.625), (0.75, 0.5, 1.0), (0.875, 0.625, 0.875),\\n (0.5, 1.0, 0.75), (0.625, 0.875, 0.625), (0.5, 0.75, 1.0),\\n (0.625, 0.875, 0.875), (0.625, 0.625, 0.875),\\n (0.75, 0.5, 0.25),\\n (0.75, 0.25, 0.5), (0.625, 0.375, 0.375), (1.0, 0.25, 0.25),\\n (1.0, 0.0, 0.25), (1.0, 0.25, 0.0), (0.75, 0.0, 0.25),\\n (0.75, 0.0, 0.0), (0.75, 0.25, 0.0), (0.875, 0.125, 0.125),\\n (1.0, 0.5, 0.25), (1.0, 0.25, 0.5), (0.875, 0.375, 0.375),\\n (0.75, 0.0, 0.5), (0.875, 0.125, 0.375), (0.75, 0.5, 0.0),\\n (0.875, 0.375, 0.125), (0.625, 0.125, 0.375),\\n (0.625, 0.125, 0.125),\\n (0.625, 0.375, 0.125), (0.5, 0.75, 0.25),\\n (0.625, 0.625, 0.375),\\n (1.0, 0.75, 0.25), (1.0, 1.0, 0.25), (1.0, 0.75, 0.0),\\n (0.75, 1.0, 0.25), (0.75, 1.0, 0.0), (0.75, 0.75, 0.0),\\n (0.875, 0.875, 0.125), (0.875, 0.625, 0.375),\\n (0.875, 0.875, 0.375),\\n (0.875, 0.625, 0.125), (0.5, 1.0, 0.25), (0.625, 0.875, 0.375),\\n (0.5, 0.75, 0.0), (0.625, 0.875, 0.125), (0.625, 0.625, 0.125),\\n (0.5, 0.25, 0.75), (0.625, 0.375, 0.625), (1.0, 0.25, 0.75),\\n (1.0, 0.0, 0.75), (1.0, 0.25, 1.0), (0.75, 0.0, 0.75),\\n (0.75, 0.0, 1.0), (0.75, 0.25, 1.0), (0.875, 0.125, 0.875),\\n (0.875, 0.375, 0.625), (0.875, 0.125, 0.625),\\n (0.875, 0.375, 0.875),\\n (0.5, 0.0, 0.75), (0.625, 0.125, 0.625), (0.5, 0.25, 1.0),\\n (0.625, 0.125, 0.875), (0.625, 0.375, 0.875),\\n (0.25, 0.75, 0.5),\\n (0.375, 0.625, 0.375), (0.0, 0.75, 0.25), (0.0, 1.0, 0.25),\\n (0.0, 0.75, 0.0), (0.25, 1.0, 0.25), (0.25, 1.0, 0.0),\\n (0.25, 0.75, 0.0), (0.125, 0.875, 0.125), (0.0, 0.75, 0.5),\\n (0.125, 0.625, 0.375), (0.25, 1.0, 0.5), (0.125, 0.875, 0.375),\\n (0.125, 0.625, 0.125), (0.375, 0.875, 0.375),\\n (0.375, 0.875, 0.125),\\n (0.375, 0.625, 0.125), (0.25, 0.5, 0.75),\\n (0.375, 0.625, 0.625),\\n (0.0, 0.75, 0.75), (0.0, 1.0, 0.75), (0.0, 0.75, 1.0),\\n (0.25, 1.0, 0.75), (0.25, 1.0, 1.0), (0.25, 0.75, 1.0),\\n (0.125, 0.875, 0.875), (0.0, 0.5, 0.75), (0.125, 0.625, 0.625),\\n (0.125, 0.875, 0.625), (0.25, 0.5, 1.0), (0.125, 0.625, 0.875),\\n (0.375, 0.875, 0.625), (0.375, 0.875, 0.875),\\n (0.375, 0.625, 0.875),\\n (0.375, 0.375, 0.625), (0.0, 0.25, 0.75), (0.0, 0.0, 0.75),\\n (0.0, 0.25, 1.0), (0.25, 0.0, 0.75), (0.25, 0.0, 1.0),\\n (0.25, 0.25, 1.0), (0.125, 0.125, 0.875),\\n (0.125, 0.375, 0.625),\\n (0.125, 0.125, 0.625), (0.125, 0.375, 0.875),\\n (0.375, 0.125, 0.625),\\n (0.375, 0.125, 0.875), (0.375, 0.375, 0.875)]\\n\\n nn_checks = {(0.5, 0.25, 0.25): [(0.375, 0.375, 0.125), (0.5, 0.5, 0.0),\\n (0.75, 0.25, 0.25),\\n (0.625, 0.375, 0.375),\\n (0.625, 0.125, 0.375),\\n (0.625, 0.125, 0.125),\\n (0.5, 0.5, 0.25), (0.25, 0.25, 0.25),\\n (0.375, 0.375, 0.375),\\n (0.5, 0.25, 0.5), (0.5, 0.5, 0.5),\\n (0.5, 0.0, 0.25),\\n (0.375, 0.125, 0.375), (0.5, 0.0, 0.5),\\n (0.5, 0.25, 0.0),\\n (0.375, 0.125, 0.125), (0.5, 0.0, 0.0),\\n (0.625, 0.375, 0.125)],\\n (0.625, 0.625, 0.875): [(0.75, 0.5, 1.0),\\n (0.75, 0.75, 1.0),\\n (0.5, 0.75, 1.0), (0.5, 0.5, 1.0),\\n (0.5, 0.5, 0.75),\\n (0.5, 0.75, 0.75),\\n (0.75, 0.5, 0.75),\\n (0.75, 0.75, 0.75)],\\n (0, 0, 0): [(0.0, 0.25, 0.0), (0.125, 0.125, 0.125),\\n (0.0, 0.0, 0.25), (0.25, 0.0, 0.0),\\n (0.0, 0.25, 0.25), (0.25, 0.25, 0.0),\\n (0.25, 0.0, 0.25)]}\\n\\n init_triangulation(3, 2, check, nn_checks)\",\n \"def transpose():\",\n \"def I3_u32(self) -> complex:\\n return (self.S3_u32() / self.U23()).conjugate()\",\n \"def mixing_matrix_2nu(sth):\\n cth = sqrt(1.0-sth*sth)\\n\\n U00 = cth\\n U01 = sth\\n U10 = -sth\\n U11 = cth\\n\\n return [[U00,U01],[U10,U11]]\",\n \"def conv3x3(self, in_planes, out_planes, stride=1):\\n c = self.conv(3, in_planes, out_planes, stride=stride)\\n return c\",\n \"def transform_play_to_column(play):\\n\\n return [2 ** i for i in range(49)].index(play) // 7\",\n \"def conv3x3(in_ch, out_ch, stride=1):\\n return nn.Conv2d(in_ch, out_ch, kernel_size=3, stride=stride, padding=1)\",\n \"def _to_b_c_L_h_w(x, x_shape):\\r\\n x = tf.reshape(x, (-1,\\r\\n int(x_shape[1]),\\r\\n int(x_shape[2]),\\r\\n int(x_shape[3]),\\r\\n int(x_shape[4])))\\r\\n return x\",\n \"def ROW(x):\\n return (x >> 3)\",\n \"def ROW(x):\\n return (x >> 3)\",\n \"def _factorRepresentation(self, character, size):\\n # Create the character matrix space\\n rows = 2*size + 3\\n cols = size + 2\\n char_matrix = [[_SPACE]*cols for i in range(rows)] \\n\\n # Creates the constituent element\\n horizontal_line = [_H_LINE]*size\\n vertical_line = [_V_LINE]*size\\n\\n # Get the points to construct the number with the elements\\n horizontal_points = self._getHLinesPoints(character, size)\\n vertical_points = self._getVLinesPoints(character, size)\\n\\n for x, y in horizontal_points:\\n char_matrix[x][y:y+size] = horizontal_line\\n\\n for x, y in vertical_points:\\n for i in range(size):\\n char_matrix[x+i][y] = vertical_line[i]\\n\\n return char_matrix\",\n \"def resh(x):\\r\\n a = x.shape[0]\\r\\n b = x.shape[1]\\r\\n return x.reshape(a*b, 1), a, b\",\n \"def 3Sat(B):\",\n \"def __det3x3__(a):\\r\\n # val = +a[0,0] * ( a[1,1] * a[2,2] - a[2,1] * a[1,2] )\\r\\n # val += -a[0,1] * ( a[1,0] * a[2,2] - a[2,0] * a[1,2] )\\r\\n # val += +a[0,2] * ( a[1,0] * a[2,1] - a[2,0] * a[1,1] )\\r\\n val = +a[0] * (a[4] * a[8] - a[7] * a[5])\\r\\n val += -a[1] * (a[3] * a[8] - a[6] * a[5])\\r\\n val += +a[2] * (a[3] * a[7] - a[6] * a[4])\\r\\n return val\",\n \"def get_palette(num_cls):\\n '''\\n n = num_cls\\n palette = [0] * (n * 3)\\n for j in range(0, n):\\n lab = j\\n palette[j * 3 + 0] = 0\\n palette[j * 3 + 1] = 0\\n palette[j * 3 + 2] = 0\\n i = 0\\n while lab:\\n palette[j * 3 + 0] |= (((lab >> 0) & 1) << (7 - i))\\n palette[j * 3 + 1] |= (((lab >> 1) & 1) << (7 - i))\\n palette[j * 3 + 2] |= (((lab >> 2) & 1) << (7 - i))\\n i += 1\\n lab >>= 3\\n '''\\n n = num_cls\\n palette = [0] * (n * 3)\\n for j in range(0, n):\\n lab = j\\n palette[j * 3 + 2] = 0\\n palette[j * 3 + 1] = 0\\n palette[j * 3 + 0] = 0\\n i = 0\\n while lab:\\n palette[j * 3 + 0] |= (((lab >> 0) & 1) << (7 - i))\\n palette[j * 3 + 1] |= (((lab >> 1) & 1) << (7 - i))\\n palette[j * 3 + 2] |= (((lab >> 2) & 1) << (7 - i))\\n i += 1\\n lab >>= 3\\n\\n return palette[3:]\",\n \"def matrix_2d_to_3d(matrix: np.matrix) -> np.matrix:\\n return np.matrix([\\n [matrix.item(0, 0), matrix.item(0, 1), 0, matrix.item(0, 2)],\\n [matrix.item(1, 0), matrix.item(1, 1), 0, matrix.item(1, 2)],\\n [0, 0, 1, 0],\\n [matrix.item(2, 0), matrix.item(2, 1), 0, matrix.item(2, 2)]])\",\n \"def matrix4_to_3x4_array(mat):\\r\\n return tuple(f for v in mat[0:3] for f in v)\",\n \"def linearTosRGB3(c):\\n return [linearTosRGB(c[0]), linearTosRGB(c[1]), linearTosRGB(c[2])]\",\n \"def convert_3to1(seq):\\n term_list = []\\n for i in __kmers(seq,k=3):\\n res = __get_value(i,aa3_to1_dict)\\n term_list.append(res)\\n return ''.join(term_list)\",\n \"def I3_u3(self) -> complex:\\n return self.I3_u1() * cmath.rect(1, 120 / 180 * cmath.pi)\",\n \"def jointsImgTo3D(sample):\\n ret = np.zeros((sample.shape[0], 3), np.float32)\\n for i in range(sample.shape[0]):\\n ret[i] = jointImgTo3D(sample[i])\\n return ret\",\n \"def voigt(a):\\n A = np.zeros(shape=(6, 1))\\n A[0] = a[0, 0]\\n A[1] = a[1, 1]\\n A[2] = a[2, 2]\\n A[3] = a[1, 2]\\n A[4] = a[0, 2]\\n A[5] = a[0, 1]\\n return A\",\n \"def Q2C(self, q):\\n\\n #q = q.squeeze();\\n C = np.empty((3,3));\\n\\tC[0,0] = (q[0]**2.0) + (q[1]**2.0) - (q[2]**2.0) - (q[3]**2.0);\\n\\tC[0,1] = 2.0 * ((q[1]*q[2]) + (q[0]*q[3]));\\n\\tC[0,2] = 2.0 * ((q[1]*q[3]) - (q[0]*q[2]));\\n\\n\\tC[1,0] = 2.0 * ((q[1]*q[2]) - (q[0]*q[3]));\\n\\tC[1,1] = (q[0]**2.0) - (q[1]**2.0) + (q[2]**2.0) - (q[3]**2.0);\\n\\tC[1,2] = 2.0 * ((q[2]*q[3]) + (q[0]*q[1]));\\n\\n\\tC[2,0] = 2.0 * ((q[1]*q[3]) + (q[0]*q[2]));\\n\\tC[2,1] = 2.0 * ((q[2]*q[3]) - (q[0]*q[1]));\\n\\tC[2,2] = (q[0]**2.0) - (q[1]**2.0) - (q[2]**2.0) + (q[3]**2.0);\\n\\n return C\",\n \"def getU3(state):\\n\\n # TODO : do the verifictions of the above constraints\\n\\n theta=2*math.acos(state[0])\\n phi=0\\n lam=0\\n\\n if state[1]<0: theta = -theta\\n\\n # U3=np.array([\\n # [math.cos(theta/2) , np.exp(-1j*lam)*math.sin(theta/2)], \\n # [np.exp(1j*phi)*math.sin(theta/2), np.exp(1j*(phi+lam))*math.cos(theta/2)]\\n # ])\\n # print (U3)\\n # print (U3@np.array([[1],[0]]))\\n\\n return [theta, phi, lam]\",\n \"def cube(num):\\n cube = num ** 3\\n return cube\",\n \"def scale4(a,c):\\n return [a[0]*c,a[1]*c,a[2]*c,a[3]*c]\",\n \"def cubeCij(c11, c13, c44):\\n C = np.zeros(shape=(6, 6))\\n C[0, 0] = C[1, 1] = C[2, 2] = c11\\n C[0, 1] = C[0, 2] = C[1, 0] = C[1, 2] = C[2, 0] = C[2, 1] = c13\\n C[3, 3] = C[4, 4] = C[5, 5] = c44\\n S = np.linalg.inv(C)\\n return {\\\"C\\\": C, \\\"S\\\": S}\",\n \"def return_box(self, num):\\n result = []\\n three = [0, 1, 2]\\n for a in three: #row\\n for b in three: #column\\n result += [self.board[a+((num-1)//3)*3][b+(num%3-1)*3]]\\n return result\",\n \"def transpose_3d():\\n tmp = np.random.random((10, 10, 10))\\n\\n a = tmp.T\\n b = np.empty(tmp.shape)\\n for j in range(tmp.shape[1]):\\n b[:, j, :] = tmp[:, j, :].T\\n\\n print(np.all(a == b))\",\n \"def reduce_3sat_to_3col(instance, G = None):\\n G = Graph() if G is None else G\\n\\n # add common gadget\\n G.add_named_vertex('T')\\n G.add_named_vertex('F')\\n G.add_named_vertex('X')\\n G.add_edge('T', 'F')\\n G.add_edge('F', 'X')\\n G.add_edge('X', 'T')\\n\\n\\n # add gadget for variables\\n variables = sorted(set([abs(v) for clause in instance for v in clause]))\\n\\n for v in variables:\\n G.add_named_vertex(v)\\n G.add_named_vertex(-v)\\n G.add_edge('X', v)\\n G.add_edge('X', -v)\\n G.add_edge(v, -v)\\n\\n G.set_vertex_index(max(variables) + 1)\\n # add the clause gadgets\\n for a, b, c in instance:\\n g1, g2, g3, g4, g5 = [G.add_vertex() for _i in range(5)]\\n\\n # triangle 1,2,3\\n G.add_edge(g1, g2) # 1\\n G.add_edge(g2, g3) # 2\\n G.add_edge(g3, g1) # 3\\n\\n # bridge betwen triangle 1,2,3T and 4,5,T\\n G.add_edge(g3, g4) # 4\\n\\n # triangle 3,4,5\\n G.add_edge(g4, g5) # 5\\n G.add_edge(g5, 'T') # 6\\n G.add_edge('T', g4) # 7\\n\\n # edges for clause a,b,c\\n G.add_edge(a, g1) # 8\\n G.add_edge(b, g2) # 9\\n G.add_edge(c, g5) # 10\\n\\n return G\",\n \"def computeCRCD3(self, u0, u1, u2, u3, u4, u5, u6, u7):\\n tmp = u0\\n bs = [u1, u2, u3, u4, u5, u6, u7]\\n for val in bs:\\n for j in range(16):\\n if tmp & (1 << 15):\\n tmp <<= 1\\n if val & (1 << 15):\\n tmp += 1\\n tmp ^= 0x8005\\n else:\\n tmp <<= 1\\n if val & (1 << 15):\\n tmp += 1\\n val <<= 1\\n tmp &= 0xffff\\n return tmp\",\n \"def matrix_3d_to_4x4(matrix: np.matrix) -> np.matrix:\\n return np.matrix([\\n [matrix.item(0, 0), matrix.item(0, 1), matrix.item(0, 2), 0],\\n [matrix.item(1, 0), matrix.item(1, 1), matrix.item(1, 2), 0],\\n [matrix.item(2, 0), matrix.item(2, 1), matrix.item(2, 2), 0],\\n [0, 0, 0, 1]])\",\n \"def convert_coordinate_system_3d(x, y, z):\\n\\n return x, -z, y\",\n \"def reconstructImage(self,arr):\\n\\t\\tarr = arr * 256\\n\\t\\tarr = np.array(np.round(arr),dtype=np.uint8)\\n\\t\\t#arr = np.array(arr,dtype=np.uint8)\\n\\n\\t\\t# We need to transpose the array because we flatten X by columns\\n\\t\\t#arr = arr.T\\n\\t\\t#a = arr.reshape((self.width, self.height,3))\\n\\t\\t\\n\\t\\tif self.mode == 'L':\\n\\t\\t\\ta = arr.reshape((self.width, self.height))\\n\\t\\telse:\\n\\t\\t\\ta = arr.reshape((self.width, self.height,3))\\n\\n\\t\\t#a = arr.reshape((3,self.width, self.height))\\t\\t\\n\\t\\t#a = arr.transpose(0, 3, 1, 2)\\n\\n\\t\\tim = Image.fromarray(a,mode=self.mode)\\n\\n\\t\\treturn im\",\n \"def Expand3D(x):\\r\\n\\r\\n if x < 0:\\r\\n raise Exception(\\r\\n \\\"\\\"\\\"ERROR: Morton code is valid only for positive numbers\\\"\\\"\\\")\\r\\n x &= 0x7fffffffL\\r\\n x = (x ^ x << 32) & 0x7fff00000000ffffL\\r\\n x = (x ^ x << 16) & 0x7f0000ff0000ff0000ffL\\r\\n x = (x ^ x << 8) & 0x700f00f00f00f00f00f00fL\\r\\n x = (x ^ x << 4) & 0x430c30c30c30c30c30c30c3L\\r\\n x = (x ^ x << 2) & 0x49249249249249249249249L\\r\\n return x\",\n \"def test_3_2_4D_cube_splits(self):\\n check = [(0, 0, 0, 0), (1, 1, 1, 1), (1, 0, 0, 0), (1, 1, 0, 0),\\n (1, 1, 1, 0),\\n (1, 1, 0, 1), (1, 0, 1, 0), (1, 0, 1, 1), (1, 0, 0, 1),\\n (0, 1, 0, 0),\\n (0, 1, 1, 0), (0, 1, 1, 1), (0, 1, 0, 1), (0, 0, 1, 0),\\n (0, 0, 1, 1),\\n (0, 0, 0, 1), (0.5, 0.5, 0.5, 0.5), (0.0, 0.5, 0.5, 0.5),\\n (0.0, 0.0, 0.5, 0.5), (0.0, 0.0, 0.0, 0.5),\\n (0.0, 0.0, 0.5, 0.0),\\n (0.0, 0.5, 0.0, 0.5), (0.0, 0.5, 0.0, 0.0),\\n (0.0, 0.5, 0.5, 0.0),\\n (0.5, 0.0, 0.5, 0.5), (0.5, 0.0, 0.0, 0.5),\\n (0.5, 0.0, 0.0, 0.0),\\n (0.5, 0.0, 0.5, 0.0), (0.5, 0.5, 0.0, 0.5),\\n (0.5, 0.5, 0.0, 0.0),\\n (0.5, 0.5, 0.5, 0.0), (0.25, 0.25, 0.25, 0.25),\\n (1.0, 0.5, 0.5, 0.5),\\n (1.0, 1.0, 0.5, 0.5), (1.0, 1.0, 1.0, 0.5),\\n (1.0, 1.0, 0.5, 1.0),\\n (1.0, 0.5, 1.0, 0.5), (1.0, 0.5, 1.0, 1.0),\\n (1.0, 0.5, 0.5, 1.0),\\n (0.5, 1.0, 0.5, 0.5), (0.5, 1.0, 1.0, 0.5),\\n (0.5, 1.0, 1.0, 1.0),\\n (0.5, 1.0, 0.5, 1.0), (0.5, 0.5, 1.0, 0.5),\\n (0.5, 0.5, 1.0, 1.0),\\n (0.5, 0.5, 0.5, 1.0), (0.75, 0.75, 0.75, 0.75),\\n (1.0, 0.0, 0.5, 0.5),\\n (1.0, 0.0, 0.0, 0.5), (1.0, 0.0, 0.5, 0.0),\\n (1.0, 0.5, 0.0, 0.5),\\n (1.0, 0.5, 0.0, 0.0), (1.0, 0.5, 0.5, 0.0),\\n (0.75, 0.25, 0.25, 0.25),\\n (1.0, 1.0, 0.0, 0.5), (1.0, 1.0, 0.5, 0.0),\\n (0.5, 1.0, 0.0, 0.5),\\n (0.5, 1.0, 0.0, 0.0), (0.5, 1.0, 0.5, 0.0),\\n (0.75, 0.75, 0.25, 0.25),\\n (1.0, 0.5, 1.0, 0.0), (0.5, 1.0, 1.0, 0.0),\\n (0.5, 0.5, 1.0, 0.0),\\n (0.75, 0.75, 0.75, 0.25), (1.0, 0.5, 0.0, 1.0),\\n (0.5, 1.0, 0.0, 1.0),\\n (0.5, 0.5, 0.0, 1.0), (0.75, 0.75, 0.25, 0.75),\\n (1.0, 0.0, 1.0, 0.5),\\n (0.5, 0.0, 1.0, 0.5), (0.5, 0.0, 1.0, 0.0),\\n (0.75, 0.25, 0.75, 0.25),\\n (1.0, 0.0, 0.5, 1.0), (0.5, 0.0, 1.0, 1.0),\\n (0.5, 0.0, 0.5, 1.0),\\n (0.75, 0.25, 0.75, 0.75), (0.5, 0.0, 0.0, 1.0),\\n (0.75, 0.25, 0.25, 0.75), (0.0, 1.0, 0.5, 0.5),\\n (0.0, 1.0, 0.0, 0.5),\\n (0.0, 1.0, 0.5, 0.0), (0.25, 0.75, 0.25, 0.25),\\n (0.0, 1.0, 1.0, 0.5),\\n (0.0, 0.5, 1.0, 0.5), (0.0, 0.5, 1.0, 0.0),\\n (0.25, 0.75, 0.75, 0.25),\\n (0.0, 1.0, 0.5, 1.0), (0.0, 0.5, 1.0, 1.0),\\n (0.0, 0.5, 0.5, 1.0),\\n (0.25, 0.75, 0.75, 0.75), (0.0, 0.5, 0.0, 1.0),\\n (0.25, 0.75, 0.25, 0.75), (0.0, 0.0, 1.0, 0.5),\\n (0.25, 0.25, 0.75, 0.25), (0.0, 0.0, 0.5, 1.0),\\n (0.25, 0.25, 0.75, 0.75), (0.25, 0.25, 0.25, 0.75)]\\n\\n nn_checks = {(0, 0, 0, 0): [(0.0, 0.5, 0.5, 0.0), (0.5, 0.0, 0.5, 0.5),\\n (0.5, 0.5, 0.0, 0.5),\\n (0.25, 0.25, 0.25, 0.25),\\n (0.5, 0.0, 0.0, 0.5), (0.5, 0.0, 0.5, 0.0),\\n (0.5, 0.5, 0.0, 0.0), (0.0, 0.0, 0.5, 0.0),\\n (0.0, 0.5, 0.0, 0.0), (0.0, 0.0, 0.0, 0.5),\\n (0.0, 0.5, 0.5, 0.5), (0.0, 0.0, 0.5, 0.5),\\n (0.0, 0.5, 0.0, 0.5), (0.5, 0.0, 0.0, 0.0),\\n (0.5, 0.5, 0.5, 0.0)],\\n (1.0, 1.0, 0.5, 0.5): [(1.0, 1.0, 0.5, 1.0), (1, 1, 0, 1),\\n (1.0, 1.0, 1.0, 0.5),\\n (1.0, 0.5, 0.5, 0.5), (1, 1, 1, 0),\\n (1.0, 1.0, 0.5, 0.0),\\n (1.0, 1.0, 0.0, 0.5), (1, 1, 0, 0),\\n (1, 1, 1, 1), (0.5, 1.0, 0.5, 0.5),\\n (0.5, 0.5, 0.5, 0.5),\\n (0.75, 0.75, 0.75, 0.75),\\n (0.75, 0.75, 0.25, 0.25),\\n (0.75, 0.75, 0.75, 0.25),\\n (0.75, 0.75, 0.25, 0.75)],\\n (0.25, 0.25, 0.25, 0.75): [(0.0, 0.0, 0.5, 1.0),\\n (0.0, 0.5, 0.0, 1.0),\\n (0.5, 0.0, 0.0, 1.0),\\n (0.5, 0.5, 0.5, 1.0),\\n (0, 0, 0, 1),\\n (0.0, 0.5, 0.5, 1.0),\\n (0.5, 0.0, 0.5, 1.0),\\n (0.5, 0.5, 0.0, 1.0),\\n (0.0, 0.0, 0.0, 0.5),\\n (0.0, 0.0, 0.5, 0.5),\\n (0.0, 0.5, 0.5, 0.5),\\n (0.0, 0.5, 0.0, 0.5),\\n (0.5, 0.0, 0.5, 0.5),\\n (0.5, 0.5, 0.0, 0.5),\\n (0.5, 0.5, 0.5, 0.5),\\n (0.5, 0.0, 0.0, 0.5)]}\\n\\n init_triangulation(4, 1, check, nn_checks)\",\n \"def factor_tuple(input,factor):\\n input_np = np.array(list(input))\\n input_np = input_np*factor\\n return tuple(list(input_np))\",\n \"def _change_box_format(self, boxes):\\n boxes[..., 0] = boxes[..., 0]\\n boxes[..., 1] = boxes[..., 1]\\n boxes[..., 2] = boxes[..., 2]\\n boxes[..., 3] = boxes[..., 1] + boxes[..., 3]\\n boxes[..., 4] = boxes[..., 2] + boxes[..., 4]\\n return boxes\",\n \"def to_se3(self, state: Vector) -> RigidTransform:\\n return (state[:9],state[9:])\",\n \"def mask_tile(self):\\n if self.size == 1:\\n m = np.array([[0]])\\n elif self.size ==2:\\n m = np.array([[1,2],[4,3]])\\n else:\\n m = 9 * np.ones((self.size, self.size))\\n m[0,0] = 1\\n m[0,-1] = 2\\n m[-1,-1] = 3\\n m[-1,0] = 4 \\n m[0,1:-1] = 5 * np.ones(self.size-2)\\n m[1:-1,-1] = 6 * np.ones(self.size-2)\\n m[-1,1:-1] = 7 * np.ones(self.size-2)\\n m[1:-1,0] = 8 * np.ones(self.size-2)\\n return m.astype(np.int8)\",\n \"def gm2code(arr, info):\\n return (arr / info.pboxsize + 0.5)# * 0.999783599\",\n \"def to_se3(self, state: Vector) -> RigidTransform:\\n return (state[:9],state[9:12])\",\n \"def _to_bc_L_h_w(x, x_shape):\\r\\n x = tf.reshape(x, (-1,\\r\\n int(x_shape[2]),\\r\\n int(x_shape[3]),\\r\\n int(x_shape[4])))\\r\\n return x\",\n \"def checksumToBoard(self):\\n\\t\\treal_board = [[ '.' for x in range(9)] for x in range(9)] \\n\\n\\t\\txstart = 0\\n\\t\\txend = 3\\n\\t\\tystart = 0\\n\\t\\tyend = 3\\n\\n\\t\\tfor i in range(0,3):\\n\\t\\t\\tself.makeBoard(i,real_board,xstart,xend,ystart,yend)\\n\\t\\t\\tystart += 3\\n\\t\\t\\tyend += 3\\n\\n\\t\\n\\t\\txstart = 3\\n\\t\\txend = 6\\n\\t\\tystart = 0\\n\\t\\tyend = 3\\n\\t\\tfor i in range(3,6):\\n\\t\\t\\tself.makeBoard(i,real_board,xstart,xend,ystart,yend)\\n\\t\\t\\tystart += 3\\n\\t\\t\\tyend += 3\\n\\n\\n\\t\\txstart = 6\\n\\t\\txend = 9\\n\\t\\tystart = 0\\n\\t\\tyend = 3\\n\\t\\tfor i in range(6,9):\\n\\t\\t\\tself.makeBoard(i,real_board,xstart,xend,ystart,yend)\\n\\t\\t\\tystart += 3\\n\\t\\t\\tyend += 3\\n\\n\\t\\t# print 'Board created from checksum values:'\\n\\t\\t# for i in range(0,9):\\n\\t\\t# \\tfor j in range(0,9):\\n\\t\\t# \\t\\tprint real_board[i][j],\\n\\t\\t# \\t\\tif j%3 == 2:\\n\\t\\t# \\t\\t\\tprint \\\"|\\\",\\n\\t\\t# \\tprint\\n\\t\\t# \\tif i%3 == 2:\\n\\t\\t# \\t\\tprint \\\" _ _ _ _ _ _ _ _ _\\\"\\n\\n\\t\\treturn real_board\",\n \"def normalize((image)):\\n new = np.zeros((7,7))\\n index = 0\\n for i in [0, 4, 7, 10, 14, 17, 21]:\\n for j in [0, 4, 7, 10, 14, 17, 21]:\\n new[index / 7][index % 7] += float(np.sum(image[i:(i+6),j:(j+6)]))/49\\n index += 1\\n return new\",\n \"def construct(self, x):\\n x = self.conv(x)\\n h0 = self.up_conv1(x)\\n l0 = self.up_conv2(h0)\\n h1 = self.up_conv3(l0 - x)\\n return h1 + h0\",\n \"def testCube(self):\\n cube = {i:(i^1,i^2,i^4) for i in range(8)}\\n self.check(cube,6)\",\n \"def test_Pad3D7():\\n input_shape = (1, 2, 3)\\n pad = [1, 2]\\n mode = \\\"reflect\\\"\\n res = [[[2, 1, 2, 3, 2, 1], [5, 4, 5, 6, 5, 4]]]\\n data = np.arange(np.prod(input_shape)).reshape(input_shape) + 1\\n obj.base(res=res, padding=pad, mode=mode, data_format=\\\"NCL\\\", data=data)\",\n \"def jadeite():\\n\\n rho = 3330.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 274.; C[0,1] = 94.; C[0,2] = 71.; C[0,3] = 0.; C[0,4] = 4.; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = 253.; C[1,2] = 82.; C[1,3] = 0.; C[1,4] = 14.; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 282.; C[2,3] = 0.; C[2,4] = 28.; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 88.; C[3,4] = 0.; C[3,5] = 13.\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 65.; C[4,5] = 0.\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 94.\\n\\n return C, rho\",\n \"def cube(num1):\\n cubed = num1*num1*num1\\n return cubed\",\n \"def f_to_c(temp):\\n if type(temp) is list or type(temp) is tuple:\\n return [(c - 32) / 1.8 for c in temp]\\n else:\\n return (temp - 32.0) / 1.8\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6342387","0.62157285","0.61090064","0.6037838","0.58831704","0.5652443","0.5637152","0.5616307","0.5598152","0.5570862","0.554038","0.552032","0.550749","0.5502176","0.5461463","0.5430975","0.542803","0.54076666","0.54068506","0.54068506","0.54051447","0.5388393","0.53866565","0.53850603","0.53789854","0.5373188","0.53676254","0.53672135","0.5366875","0.5365821","0.53552854","0.53441614","0.53420484","0.5338203","0.53275746","0.5325655","0.5322407","0.53208786","0.53208786","0.5316531","0.5301732","0.5300517","0.5294901","0.5294901","0.5282773","0.5275448","0.52709013","0.5267904","0.52675676","0.52581364","0.5253124","0.52516127","0.52429247","0.523838","0.5220202","0.52172667","0.5198338","0.5193287","0.5193287","0.51864386","0.51693887","0.5152342","0.5151651","0.51466686","0.51464486","0.5145981","0.5145471","0.51452994","0.5143895","0.51416355","0.51360595","0.51255655","0.5118476","0.51161766","0.51032007","0.5096128","0.5078508","0.50744337","0.5070984","0.50693434","0.5064862","0.5063594","0.5059263","0.5057983","0.505713","0.5050553","0.50434566","0.5038707","0.50309634","0.50137854","0.5009148","0.50036657","0.5000631","0.49930158","0.49925658","0.49819085","0.49807474","0.49801132","0.49777934","0.4972834"],"string":"[\n \"0.6342387\",\n \"0.62157285\",\n \"0.61090064\",\n \"0.6037838\",\n \"0.58831704\",\n \"0.5652443\",\n \"0.5637152\",\n \"0.5616307\",\n \"0.5598152\",\n \"0.5570862\",\n \"0.554038\",\n \"0.552032\",\n \"0.550749\",\n \"0.5502176\",\n \"0.5461463\",\n \"0.5430975\",\n \"0.542803\",\n \"0.54076666\",\n \"0.54068506\",\n \"0.54068506\",\n \"0.54051447\",\n \"0.5388393\",\n \"0.53866565\",\n \"0.53850603\",\n \"0.53789854\",\n \"0.5373188\",\n \"0.53676254\",\n \"0.53672135\",\n \"0.5366875\",\n \"0.5365821\",\n \"0.53552854\",\n \"0.53441614\",\n \"0.53420484\",\n \"0.5338203\",\n \"0.53275746\",\n \"0.5325655\",\n \"0.5322407\",\n \"0.53208786\",\n \"0.53208786\",\n \"0.5316531\",\n \"0.5301732\",\n \"0.5300517\",\n \"0.5294901\",\n \"0.5294901\",\n \"0.5282773\",\n \"0.5275448\",\n \"0.52709013\",\n \"0.5267904\",\n \"0.52675676\",\n \"0.52581364\",\n \"0.5253124\",\n \"0.52516127\",\n \"0.52429247\",\n \"0.523838\",\n \"0.5220202\",\n \"0.52172667\",\n \"0.5198338\",\n \"0.5193287\",\n \"0.5193287\",\n \"0.51864386\",\n \"0.51693887\",\n \"0.5152342\",\n \"0.5151651\",\n \"0.51466686\",\n \"0.51464486\",\n \"0.5145981\",\n \"0.5145471\",\n \"0.51452994\",\n \"0.5143895\",\n \"0.51416355\",\n \"0.51360595\",\n \"0.51255655\",\n \"0.5118476\",\n \"0.51161766\",\n \"0.51032007\",\n \"0.5096128\",\n \"0.5078508\",\n \"0.50744337\",\n \"0.5070984\",\n \"0.50693434\",\n \"0.5064862\",\n \"0.5063594\",\n \"0.5059263\",\n \"0.5057983\",\n \"0.505713\",\n \"0.5050553\",\n \"0.50434566\",\n \"0.5038707\",\n \"0.50309634\",\n \"0.50137854\",\n \"0.5009148\",\n \"0.50036657\",\n \"0.5000631\",\n \"0.49930158\",\n \"0.49925658\",\n \"0.49819085\",\n \"0.49807474\",\n \"0.49801132\",\n \"0.49777934\",\n \"0.4972834\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.49841478"},"document_rank":{"kind":"string","value":"95"}}},{"rowIdx":94488,"cells":{"query":{"kind":"string","value":"Performs vector contraction in the form of m C n"},"document":{"kind":"string","value":"def vect_contract(m, c, n):\n a = np.tensordot(m, c, (0, 0))\n mn = np.tensordot(a, n, (2, 0))\n return mn"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getVector(c1, c2):\n return [c1[0] - c2[0], c1[1] - c2[1], c1[2] - c2[2]]","def mvector(B, c):\n # for Sun Mg Potential: c=1.6281689374348\n A = np.zeros(shape=4)\n A[0] = (2 / 3) * B[0]\n A[1] = 0.5 * ((2 / sqrt(3)) * B[1] - A[0])\n A[2] = -A[0] - A[1]\n A[3] = B[2] / c\n return A","def algorithm_2_20_vector(p, t, c, x):\n\n mu = index(x, t)\n t = np.array(t, dtype=np.float64)\n c = np.array(c[mu - p:mu + 1], dtype=np.float64)\n\n for i in range(0, p):\n k = p - i\n t1 = t[mu - k + 1:mu + 1]\n t2 = t[mu + 1:mu + k + 1]\n omega = np.divide((x - t1), (t2 - t1))\n c = (1 - omega) * c[:-1] + omega * c[1:]\n return c","def subtract(vector01,vector02): \r\n result = [[0] for row in range(len(vector01))]\r\n # Creates list full of 0s with the same lenght as vector01\r\n for z in range(len(vector01)):\r\n # for loop which continues as long as there are more elements in vector01 \r\n result[z] = vector01[z]-vector02[z]\r\n # the subtraction of each element which replaces the corresponding element in the vector full of 0s \r\n return result","def alg(c):\n return c[0]*G[0] + c[1]*G[1] + c[2]*G[2]","def proVec(*args):\r\n resultado = []\r\n i,j,k = (args[0][1] * args[1][2]) - (args[0][2] * args[1][1]) , ((args[0][0] * args[1][2]) - (args[0][2] * args[1][0])) * (-1) , (args[0][0] * args[1][1]) - (args[0][1] * args[1][0])\r\n resultado.append(i)\r\n resultado.append(j)\r\n resultado.append(k)\r\n return resultado","def vector_substraction(a, b):\n return a[0] - b[0], a[1] - b[1]","def reduce_C(self, C_on_basis_vecs):\n self.C_reduced = np.mat(np.array(C_on_basis_vecs, ndmin=2))\n return self.C_reduced","def reduce_C(self, C_on_basis_vecs):\n self.C_reduced = np.mat(np.array(C_on_basis_vecs, ndmin=2).T)\n return self.C_reduced","def mbvector(A, c=sqrt(8 / 3)):\n la = len(A)\n sa = A.size\n if la == sa:\n B = np.array([0.0, 0.0, 0.0])\n a1 = A[0] * np.array([1.0, 0.0])\n a2 = A[1] * np.array([-0.5, 0.5 * sqrt(3)])\n a3 = A[2] * np.array([-0.5, -0.5 * sqrt(3)])\n B[0] = a1[0] + a2[0] + a3[0]\n B[1] = a1[1] + a2[1] + a3[1]\n B[2] = c * A[3]\n else:\n sa = A.shape\n B = np.zeros(shape=(sa[0], 3))\n for i in range(sa[0]):\n B[i, 0] = a1[0] + a2[0] + a3[0]\n B[i, 1] = a1[1] + a2[1] + a3[1]\n B[i, 2] = c * A[i, 3]\n return B","def _contraction_with_merge(self, x, merged_support):\n raise NotImplementedError\n n_vertex = x.shape[1]\n dim = self._calculate_dim_with_merge(merged_support, n_vertex)\n return torch.sum(merged_support.mm(x.view(dim * n_vertex, -1)).view(\n dim, n_vertex, -1), dim=0)","def vector_subtract(v, w):\n return [v_i - w_i for v_i, w_i in zip(v, w)]","def vector_subtract(v, w):\n return [v_i - w_i for v_i, w_i in zip(v,w)]","def vector_subtract(v, w):\n return [v_i - w_i for v_i, w_i in zip(v,w)]","def vector_subtract(v, w):\n return [v_i - w_i for v_i, w_i in zip(v,w)]","def vectordot(a, b):\n return np.sum(a * b, 1)","def _contraction_without_merge(self, x, supports):\n shape = x.shape\n tensor_rank = len(shape) - 2\n if tensor_rank == self.support_tensor_rank:\n if self.support_tensor_rank == 1:\n return torch.sum(torch.stack([\n supports[i_dim].mm(x[:, i_dim]) for i_dim\n in range(self.dim)]), dim=0)\n elif self.support_tensor_rank == 2:\n # ijkm, jnmf -> iknf\n return torch.stack([\n torch.stack([\n torch.sum(torch.stack([\n supports[self.dim*k+m].mm(x[:, n, m])\n for m in range(self.dim)]), dim=0)\n for n in range(self.dim)], dim=1)\n for k in range(self.dim)], dim=1)\n else:\n raise ValueError\n elif tensor_rank > 1:\n return torch.stack([\n self._contraction_without_merge(x[:, i_dim], supports)\n for i_dim in range(self.dim)], dim=1)\n else:\n raise ValueError(f\"Tensor rank is 0 (shape: {shape})\")","def subtract_vectors(vector_1, vector_2):\n new_coordinates = []\n index = 0\n while index < vector_1.dimension:\n new_value = vector_1.coordinates[index] - vector_2.coordinates[index]\n new_coordinates.append(new_value)\n index += 1\n new_vector = Vector(new_coordinates)\n return new_vector","def classical(m1,m2):\n \n n = m1.shape\n result = np.zeros(n, dtype = int)\n\n for i in range(n[0]):\n for j in range(n[0]):\n for k in range(n[0]):\n result[i][j] += m1[i][k] * m2[k][j]\n return result","def substract(self, vector):\n\n # return (self.from_list([vector.vector[self.vector.index(x)]-x for x in\n # self.vector]))\n return Vector(self.x - vector.x, self.y - vector.y, self.z - vector.z)","def calculate_vector_difference(self, point, cpoint):\n difference = []\n for m, s in zip(point, cpoint):\n difference.append(m - s)\n return difference","def gains_vector(m):\n\n n_ant, n_chan, n_dir, _ = m.shape\n row_shape = n_ant * n_chan * n_dir\n g = np.zeros((2*row_shape), dtype=np.complex128)\n\n for nu in range(n_chan):\n for s in range(n_dir):\n for a in range(n_ant):\n row = a + n_ant * s + n_ant * n_dir * nu \n g[row] = m[a, nu, s, 0]\n g[row + row_shape] = m[a, nu, s, 1]\n \n return g","def apply(self, v):\n u = np.zeros(self.Dimension, dtype=complex)\n for me in self.Elements:\n for index in range(v.Elements.size):\n if index == me.j:\n u[me.i] += me.val * v.Elements[index]\n u = Vector(u) \n return u","def conj(self, vecs):\n raise NotImplementedError","def get_C(n_c,CV_matrix):\n C = np.zeros((n_c, n_c), dtype=np.float32)\n for i in range(3):\n C += np.asfortranarray(CV_matrix[:, :, i]) @ np.asfortranarray(CV_matrix[:, :, np.mod(i + 2, 3)].T)\n C = (C != 0).astype(np.int32)\n return C","def compCGP_C(M):\n # we store the coedd as a lower triangular matrix\n # random polynomial coefficients\n c = 0.5 * np.random.uniform(-1.0, -0.45, size=(M + 1, M + 1)) +\\\n 0.5 * np.random.uniform(0.45, 1.0, size=(M + 1, M + 1))\n for i in np.arange(M + 1):\n c[i, :] /= 2**(np.arange(M + 1) + i)\n c /= 1.5\n c = np.tril(c)\n c[0, 0] = 0\n c[1, 0] = 0\n c[1, 1] = 1\n\n return c","def conv(A, B, c, i, tipus):\r\n if tipus == 1:\r\n suma = [np.conj(A[k, i]) * B[c - k, i] for k in range(1, c + 1)]\r\n return sum(suma)\r\n elif tipus == 2:\r\n suma = [A[k, i] * B[c - 1 - k, i] for k in range(1, c)]\r\n return sum(suma)\r\n elif tipus == 3:\r\n suma = [A[k, i] * np.conj(B[c - k, i]) for k in range(1, c)]\r\n return sum(suma)","def true_gains_vector(m):\n\n n_ant, n_chan, n_dir = m.shape\n row_shape = n_ant * n_chan * n_dir\n g = np.zeros((2*row_shape), dtype=np.complex128)\n\n for nu in range(n_chan):\n for s in range(n_dir):\n for a in range(n_ant):\n row = a + n_ant * s + n_ant * n_dir * nu \n g[row] = m[a, nu, s]\n g[row + row_shape] = m[a, nu, s].conj()\n\n return g","def _inv22_vectorized(M):\n assert (M.ndim == 3)\n assert (M.shape[-2:] == (2, 2))\n M_inv = np.empty_like(M)\n delta_inv = np.reciprocal(M[:, 0, 0]*M[:, 1, 1] - M[:, 0, 1]*M[:, 1, 0])\n M_inv[:, 0, 0] = M[:, 1, 1]*delta_inv\n M_inv[:, 0, 1] = -M[:, 0, 1]*delta_inv\n M_inv[:, 1, 0] = -M[:, 1, 0]*delta_inv\n M_inv[:, 1, 1] = M[:, 0, 0]*delta_inv\n return M_inv","def c(self) -> np.ndarray:\n return self._vector[10:12]","def _apply_cost_to_vec(\n self, vec: jnp.ndarray, axis: int = 0, fn=None\n ) -> jnp.ndarray:\n vec = jnp.reshape(vec, self.grid_size)\n accum_vec = jnp.zeros_like(vec)\n indices = list(range(1, self.grid_dimension))\n for dimension, geom in enumerate(self.geometries):\n cost = geom.cost_matrix\n ind = indices.copy()\n ind.insert(dimension, 0)\n if axis == 0:\n cost = cost.T\n accum_vec += jnp.sum(\n jnp.tensordot(cost, vec, axes=([0], [dimension])),\n axis=indices,\n keepdims=True\n ).transpose(ind)\n return accum_vec.ravel()","def matrixSubtraction(self, a, b):\n\t\n\t\tnumRows = len(a)\n\t\tnumCols = len(a[0])\n\t\n\t\treturn [[ a[j][i] - b[j][i] for i in range(numCols)] for j in range(numRows)]","def ec_matrix_vector(p0, T, n): \n if(n<=0):\n EC=np.zeros(T.shape)\n return EC\n else:\n \"\"\"Probability vector after (k=0) propagations\"\"\" \n p_k=1.0*p0\n \"\"\"Sum of vectors after (k=0) propagations\"\"\"\n p_sum=1.0*p_k \n for k in xrange(n-1):\n \"\"\"Propagate one step p_{k} -> p_{k+1}\"\"\"\n p_k=np.dot(p_k,T) \n \"\"\"Update sum\"\"\"\n p_sum+=p_k \n \"\"\"Expected counts\"\"\"\n EC=p_sum[:,np.newaxis]*T \n return EC","def vector_subtract(v1, v2):\n return v1[0] - v2[0], v1[1] - v2[1]","def subtract_vectors(u, v):\n return u[0] - v[0], u[1] - v[1], u[2] - v[2]","def contract(tensor):\n temp = np.einsum('ikma, jlan', tensor, tensor)\n M = np.zeros((tensor.shape[0]**2, tensor.shape[1]**2, tensor.shape[2], tensor.shape[3]))\n for i,j,k,l,m,n in it.product(*[range(x) for x in temp.shape]):\n M[i + tensor.shape[0]*j, k + tensor.shape[1]*l, m, n] = temp[i,j,k,l,m,n]\n return M","def retraction(self, v, x, c):\n c = self.truncate_c(c)\n new_v = self.expmap(v, x, c)\n return self.proj(new_v, c)","def vector_sum(a, b):\n return a[0] + b[0], a[1] + b[1]","def vector(p0, p1):\n a = p1[0] - p0[0]\n b = p1[1] - p0[1]\n return (a, b)","def sysrem_update_rij(rij, a, c):\n return rij - np.outer(a,c)","def spmv (n, A, x):\n y = dense_vector (n)\n for (i, A_i) in A.items ():\n s = 0\n for (j, a_ij) in A_i.items ():\n s += a_ij * x[j]\n y[i] = s\n return y","def transform(tvec1, rvec1, tvec2, rvec2):\n op = localToGlobal(np.squeeze(tvec2), np.squeeze(rvec2))\n tvec3 = []\n for tvec in tvec1:\n #tvec = tvec.squeeze()\n tvec3.append(np.matmul(op, tvec))\n tvec3 = np.array(tvec3)\n return tvec3","def vec_cross(a,b):\r\n return [a[1] * b[2] - a[2] * b[1],\r\n a[2] * b[0] - a[0] * b[2],\r\n a[0] * b[1] - a[1] * b[0]]","def op(M, N):\n\n return M ^ N","def c(self, i):\n value = self.b(i)\n if i == self.N:\n return value\n else:\n for j in range(i+1, self.N+1):\n value = value - self.a(i,j) * self.C[j]\n return value","def __sub__(self, m):\n nv=Matrice()\n if self.__mm_type(m):\n ls=len(self)\n nv.generate(ls,self.desc())\n for i in self.desc():\n for j in range(len(self)):\n nv.g_val(self.val(i,j)-m.val(i,j),i,j)\n return nv","def cross_vectors(u, v):\n return [u[1] * v[2] - u[2] * v[1],\n u[2] * v[0] - u[0] * v[2],\n u[0] * v[1] - u[1] * v[0]]","def apply(self,v):\n return np.tensordot(self._transform, v, axes=([1],[0])) \\\n + self._translation","def vector_sub(v1,v2):\n return Vector(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z)","def to_coulomb_vec(mol, max_size=23, addition=None):\n\n cm = to_coulomb_m(mol, max_size=max_size)\n cm_vec = cm[np.tril_indices(cm.shape[0])]\n \n if addition:\n cm_vec = np.hstack([cm_vec, addition])\n \n return cm_vec","def vector_sum(vectors):\n results = vectors[0]\n for vector in vectors[1:]:\n results = vector_add(results, vector)\n return results","def test_scalar_coeff_cc():\n hs_1 = LocalSpace('q1', basis=('g', 'e'))\n hs_2 = LocalSpace('q2', basis=('g', 'e'))\n kappa = Symbol('kappa', real=True)\n a1 = Destroy(hs=hs_1)\n a2 = Destroy(hs=hs_2)\n\n jc_expr = (\n I / 2 * (2 * kappa * (a1.dag() * a2) - 2 * kappa * (a1 * a2.dag()))\n )\n\n simplified = rewrite_with_operator_pm_cc(jc_expr)\n assert simplified == I * kappa * OperatorPlusMinusCC(\n a1.dag() * a2, sign=-1\n )\n expanded = simplified.doit()\n assert expanded == I * kappa * (a1.dag() * a2 - a1 * a2.dag())","def __sub__(self, other):\n return Vector([c1 - c2 for (c1, c2) in zip(self.components, other.components)])","def matTimesVec(M, x):\n return [dot(m, x) for m in M]","def associate_comp(x, y):\n return torch.cat([x[:1] * y[:1] - x[1:] * y[1:], x[:1] * y[1:] + x[1:] * y[:1]])","def __mul__(self, n):\n vectors = [n * Vector(*(p - self.center)) for p in self.points]\n return Form([vectors[i](self.points[i]) for i in range(len(self.points))])","def project_vectors(self, vectors):\n return np.dot(vectors, self.components.T)","def subtract_update_(X, c, Y):\n if X.size > 2048:\n _nb_subtract_update_par(X, c, Y, out=X)\n else:\n _nb_subtract_update_seq(X, c, Y, out=X)","def commutator(self, other) -> 'MultiVector':\n\n return ((self * other) - (other * self)) / 2","def marginal(self, target, out=None):\n return self.__opReduce2(self.v - target,np.sum, out=out)","def CoTang(M):\n x = [sy.Dummy() for _ in range(nargs(M))]\n fx = [sy.Dummy() for _ in range(len(x))]\n\n y = list(M(*x))\n J = Jac(M)(*x)\n J = sy.Matrix(J).reshape(len(y), len(x))\n\n fy = list(J.T.inv() @ sy.Matrix(fx))\n return sy.lambdify(\n x + fx,\n y + fy,\n 'sympy',\n )","def test__vector_subtraction__given_two_vectors__return_correct_vector():\n assert Vector((0, 1, 2)) - Vector((3, 4, 5)) == Vector((-3, -3, -3))","def apply_ccms(images, ccms):\n images.shape.assert_has_rank(4)\n images = images[:, :, :, tf.newaxis, :]\n ccms = ccms[:, tf.newaxis, tf.newaxis, :, :]\n return tf.reduce_sum(images * ccms, axis=-1)","def scalar_multiply(c: float, v: Vector) -> Vector:\n return [c * v_i for v_i in v]","def scalar_multiply(c: float, v: Vector) -> Vector:\n return [c * v_i for v_i in v]","def vector_sum(vectors):\n\tresult = vectors[0]\n\tfor vector in vectors:\n\t\tresult = vector_add(result, vector)\n\treturn result","def vectorAdd(a, b):\n return [a[i] + b[i] for i, j in enumerate(a)]","def __imul__(self, n):\n vectors = [n * Vector(*(p - self.center)) for p in self.points]\n self.points = [vectors[i](self.points[i]) for i in range(len(self.points))]\n return self","def crossproduct(first, other=FreeCAD.Vector(0,0,1)):\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\n return FreeCAD.Vector(first.y*other.z - first.z*other.y, first.z*other.x - first.x*other.z, first.x*other.y - first.y*other.x)","def tripiv(a, b, c, d):\n \n n = len(b)\n x = np.zeros(n)\n fail = 0\n \n # reordering\n \n a[0] = b[0]\n b[0] = c[0]\n c[0] = 0\n \n # elimination:\n \n l = 0\n \n for k in range(0,n):\n q = a[k]\n i = k\n \n if l < n-1:\n l = l + 1\n \n for j in range(k+1,l+1):\n q1 = a[j]\n if (np.abs(q1) > np.abs(q)):\n q = q1\n i = j\n if q == 0:\n fail = -1\n \n if i != k:\n q = d[k]\n d[k] = d[i]\n d[i] = q\n q = a[k]\n a[k] = a[i]\n a[i] = q\n q = b[k]\n b[k] = b[i]\n b[i] = q\n q = c[k]\n c[k] =c[i]\n c[i] = q\n for i in range(k+1,l+1):\n q = a[i]/a[k]\n d[i] = d[i]-q*d[k]\n a[i] = b[i]-q*b[k]\n b[i] = c[i]-q*c[k]\n c[i] = 0\n \n\n \n # backsubstitution\n \n x[n-1] = d[n-1]/a[n-1]\n x[n-2] = (d[n-2]-b[n-2]*x[n-1])/a[n-2]\n \n for i in range(n-3,-1,-1):\n \n q = d[i] - b[i]*x[i+1]\n x[i] = (q - c[i]*x[i+2])/a[i]\n \n return x","def subtract(self, m): \n f = m.negate()\n return self.add(f)","def apply(self, vec):\n return self._disp_over_m * vec - self._gp * ( # pylint: disable = E1130\n self._gp @ vec / self.L ** self.ndim\n )","def ccw(p1, p2, p3):\n return (p2[0] - p1[0])*(p3[1] - p1[1]) - (p2[1] - p1[1])*(p3[0] - p1[0])","def cg(A, b, x=None):\n n = len(b)\n if not x:\n x = np.ones([n,1])\n r = np.dot(A, x) - b\n p = - r\n # r_k_norm = np.dot(r, r)\n r_k_norm = np.linalg.norm ( r )*np.linalg.norm ( r )\n for i in range(2*n):\n Ap = np.dot(A, p)\n alpha = r_k_norm / p.T@Ap\n try:\n x += alpha * p\n except:\n pass\n r += alpha * Ap\n r_kplus1_norm = np.linalg.norm ( r )*np.linalg.norm ( r )\n beta = r_kplus1_norm / r_k_norm\n r_k_norm = r_kplus1_norm\n if r_kplus1_norm < 1e-5:\n break\n p = beta * p - r\n return x","def project_vectors(self, vectors):\n X = vectors - self._mean\n return np.dot(X, self.components.T)","def coproduct(self, element):\n from sage.categories.tensor import tensor\n base = element.lift().parent()\n return self.tensor_square().sum(coeff * tensor([self(base[x]), self(base[y])])\n for ((x,y), coeff) in element.lift().coproduct())","def multMatVect(v, A, m1, B, m2):\r\n if multMatVect.dot_modulo is None:\r\n A_sym = tensor.lmatrix('A')\r\n s_sym = tensor.ivector('s')\r\n m_sym = tensor.iscalar('m')\r\n A2_sym = tensor.lmatrix('A2')\r\n s2_sym = tensor.ivector('s2')\r\n m2_sym = tensor.iscalar('m2')\r\n o = DotModulo()(A_sym, s_sym, m_sym, A2_sym, s2_sym, m2_sym)\r\n multMatVect.dot_modulo = function(\r\n [A_sym, s_sym, m_sym, A2_sym, s2_sym, m2_sym], o)\r\n\r\n # This way of calling the Theano fct is done to bypass Theano overhead.\r\n f = multMatVect.dot_modulo\r\n f.input_storage[0].storage[0] = A\r\n f.input_storage[1].storage[0] = v[:3]\r\n f.input_storage[2].storage[0] = m1\r\n f.input_storage[3].storage[0] = B\r\n f.input_storage[4].storage[0] = v[3:]\r\n f.input_storage[5].storage[0] = m2\r\n f.fn()\r\n r = f.output_storage[0].storage[0]\r\n\r\n return r","def cforwardsolve(A, b, d):\n A = matrix(A)\n n = len(b)\n for k in range(n-1):\n b[k] /= A[k, k]\n uk = array([n, k + d + 1]).min()\n b[(k+1):uk] -= A[(k+1):uk, k]*b[k]\n b[n - 1] /= A[n - 1,n - 1]","def MulMatrixVector(InversedMat, b_vector):\r\n result = []\r\n # Initialize the x vector\r\n for i in range(len(b_vector)):\r\n result.append([])\r\n result[i].append(0)\r\n # Multiplication of inverse matrix in the result vector\r\n for i in range(len(InversedMat)):\r\n for k in range(len(b_vector)):\r\n result[i][0] += InversedMat[i][k] * b_vector[k][0]\r\n return result","def calculate(self) -> complex128:\n\n if not self.__can_calculation_be_performed():\n raise AttributeError\n\n v_vectors = self.__calculate_v_vectors()\n\n permanent = 0\n for v_vector in v_vectors:\n v_sum = sum(v_vector)\n addend = pow(-1, v_sum)\n # Binomials calculation\n for i in range(len(v_vector)):\n addend *= binom(self.__input_state[i], v_vector[i])\n\n # Product calculation\n product = 1\n for j in range(len(self.__input_state)):\n if self.__output_state[j] == 0: # There's no reason to calculate the sum if t_j = 0\n continue\n # Otherwise we calculate the sum\n product_part = 0\n for i in range(len(self.__input_state)):\n product_part += (self.__input_state[i] - 2 * v_vector[i]) * self.__matrix[j][i]\n product_part = pow(product_part, self.__output_state[j])\n product *= product_part\n addend *= product\n permanent += addend\n\n permanent /= pow(2, sum(self.__input_state))\n\n return permanent","def Cvec(self):\n return vec(self.xc, self.yc)","def covar(self):\n a, c, d, b = self.to_ccw()\n return a * d - b * c","def cotangent(a: list, b: list, c: list):\n ba = np.subtract(a, b)\n bc = np.subtract(c, b)\n return (np.dot(bc, ba) / abs(np.cross(bc, ba)))","def matrix_vector_prod(m,u):\n each_product = []\n for v in m:\n each_product.append(dot_prod(v, u))\n return each_product","def matrix_mult(M, vector1, vector2):\n out = None\n ### YOUR CODE HERE\n pass\n ### END YOUR CODE\n\n return out","def matrix_mult(M, vector1, vector2):\n out = None\n ### YOUR CODE HERE\n pass\n ### END YOUR CODE\n\n return out","def mtob(InputVec):\n InputVec = InputVec.copy()\n mf = InputVec.size\n natoms =round(math.log(mf,2))\n if math.pow(2, natoms) == mf:\n for i in range(natoms):\n i124 = int(math.pow(2, i))\n i842 = int(math.pow(2, natoms - i))\n i421 = int(math.pow(2, natoms - i - 1))\n InputVec = InputVec.reshape(i124, i842,order='F')\n #for j in range(1, i421 + 1): #to be replaced by i842\n for j in range(i421): #not a good way for add operation coz loop matrix for i842 times\n InputVec[:, j * 2 + 1 ] = InputVec[:, j * 2 + 1 ] + InputVec[:, j * 2]\n out = InputVec.reshape(1,mf,order='F')[0]\n return out\n else:\n exit(\"ACCIDENT in mtoq: length of input vector not OK: should be a power of 2\\n\")","def reduce(self,vecs):\n\t\tif self.base_vecs is None or self.inv_vecs is None:\n\t\t\traise KeyError('The fitter has not yet been prepped.')\n\n\t\tr_arr = []\n\t\tfor vec in vecs:\n\t\t\tcoeffs = self.Fit(vec)\n\t\t\tr_arr.append(np.subtract(vec,np.dot(coeffs,self.base_vecs)))\n\n\t\treturn r_arr","def conjugate(quats):\n res = np.zeros(quats.shape)\n res[:,0]=quats[:,0]\n res[:,1]=-quats[:,1]\n res[:,2]=-quats[:,2]\n res[:,3]=-quats[:,3]\n \n return res","def custom_np_function(vector):\n summation = 0\n for item in vector:\n summation += item ** 2\n return summation","def f(t, x, n, v):\n total = 0\n for i in range(n+1):\n for j in range(n+1):\n for k in range(v):\n total = t[i][j] * x[i][j][k]","def reflect(d,n):\n\t# coefficent c, because easier\n\tc = 2 * dot(d,n)\n\treturn [di - c * ni for (di, ni) in zip(d,n)]","def compCoeff_CGP(i, A, c, N):\n Ap = np.copy(A)\n out = c[i, 0] * np.eye(N)\n j = 1\n while j <= i:\n # compute A to the power p\n if j > 1:\n Ap = Ap.dot(A)\n\n # add to the polynome\n out += c[i, j] * Ap\n j += 1\n\n return out","def v3minus(a, b):\n return [a[i] - b[i] for i, j in enumerate(a)]","def _prod_vectorized(M1, M2):\n sh1 = M1.shape\n sh2 = M2.shape\n assert len(sh1) >= 2\n assert len(sh2) >= 2\n assert sh1[-1] == sh2[-2]\n\n ndim1 = len(sh1)\n t1_index = list(xrange(ndim1-2)) + [ndim1-1, ndim1-2]\n return np.sum(np.transpose(M1, t1_index)[..., np.newaxis] *\n M2[..., np.newaxis, :], -3)","def scalar_mult(n, m):\n\ttemp = []\n\tfor i in range(len(m)):\n\t\te = []\n\t\tfor j in range(len(m[0])):\n\t\t\te.append(m[i][j]*n)\n\t\ttemp.append(e)\n\treturn temp","def multiply_vector(self, dv, spm):\n product = []\n for a, b in zip(dv, spm):\n product.append(a * b)\n return product","def _diffmat_objective(a,X):\n \n (n,p) = X.shape\n return(X - np.tile(a,(n,1)))","def _z2matvecmul(self, mat, vec):\n prod = np.mod(np.dot(mat, vec), 2)\n return prod","def complex_inverse(c1,cr):"],"string":"[\n \"def getVector(c1, c2):\\n return [c1[0] - c2[0], c1[1] - c2[1], c1[2] - c2[2]]\",\n \"def mvector(B, c):\\n # for Sun Mg Potential: c=1.6281689374348\\n A = np.zeros(shape=4)\\n A[0] = (2 / 3) * B[0]\\n A[1] = 0.5 * ((2 / sqrt(3)) * B[1] - A[0])\\n A[2] = -A[0] - A[1]\\n A[3] = B[2] / c\\n return A\",\n \"def algorithm_2_20_vector(p, t, c, x):\\n\\n mu = index(x, t)\\n t = np.array(t, dtype=np.float64)\\n c = np.array(c[mu - p:mu + 1], dtype=np.float64)\\n\\n for i in range(0, p):\\n k = p - i\\n t1 = t[mu - k + 1:mu + 1]\\n t2 = t[mu + 1:mu + k + 1]\\n omega = np.divide((x - t1), (t2 - t1))\\n c = (1 - omega) * c[:-1] + omega * c[1:]\\n return c\",\n \"def subtract(vector01,vector02): \\r\\n result = [[0] for row in range(len(vector01))]\\r\\n # Creates list full of 0s with the same lenght as vector01\\r\\n for z in range(len(vector01)):\\r\\n # for loop which continues as long as there are more elements in vector01 \\r\\n result[z] = vector01[z]-vector02[z]\\r\\n # the subtraction of each element which replaces the corresponding element in the vector full of 0s \\r\\n return result\",\n \"def alg(c):\\n return c[0]*G[0] + c[1]*G[1] + c[2]*G[2]\",\n \"def proVec(*args):\\r\\n resultado = []\\r\\n i,j,k = (args[0][1] * args[1][2]) - (args[0][2] * args[1][1]) , ((args[0][0] * args[1][2]) - (args[0][2] * args[1][0])) * (-1) , (args[0][0] * args[1][1]) - (args[0][1] * args[1][0])\\r\\n resultado.append(i)\\r\\n resultado.append(j)\\r\\n resultado.append(k)\\r\\n return resultado\",\n \"def vector_substraction(a, b):\\n return a[0] - b[0], a[1] - b[1]\",\n \"def reduce_C(self, C_on_basis_vecs):\\n self.C_reduced = np.mat(np.array(C_on_basis_vecs, ndmin=2))\\n return self.C_reduced\",\n \"def reduce_C(self, C_on_basis_vecs):\\n self.C_reduced = np.mat(np.array(C_on_basis_vecs, ndmin=2).T)\\n return self.C_reduced\",\n \"def mbvector(A, c=sqrt(8 / 3)):\\n la = len(A)\\n sa = A.size\\n if la == sa:\\n B = np.array([0.0, 0.0, 0.0])\\n a1 = A[0] * np.array([1.0, 0.0])\\n a2 = A[1] * np.array([-0.5, 0.5 * sqrt(3)])\\n a3 = A[2] * np.array([-0.5, -0.5 * sqrt(3)])\\n B[0] = a1[0] + a2[0] + a3[0]\\n B[1] = a1[1] + a2[1] + a3[1]\\n B[2] = c * A[3]\\n else:\\n sa = A.shape\\n B = np.zeros(shape=(sa[0], 3))\\n for i in range(sa[0]):\\n B[i, 0] = a1[0] + a2[0] + a3[0]\\n B[i, 1] = a1[1] + a2[1] + a3[1]\\n B[i, 2] = c * A[i, 3]\\n return B\",\n \"def _contraction_with_merge(self, x, merged_support):\\n raise NotImplementedError\\n n_vertex = x.shape[1]\\n dim = self._calculate_dim_with_merge(merged_support, n_vertex)\\n return torch.sum(merged_support.mm(x.view(dim * n_vertex, -1)).view(\\n dim, n_vertex, -1), dim=0)\",\n \"def vector_subtract(v, w):\\n return [v_i - w_i for v_i, w_i in zip(v, w)]\",\n \"def vector_subtract(v, w):\\n return [v_i - w_i for v_i, w_i in zip(v,w)]\",\n \"def vector_subtract(v, w):\\n return [v_i - w_i for v_i, w_i in zip(v,w)]\",\n \"def vector_subtract(v, w):\\n return [v_i - w_i for v_i, w_i in zip(v,w)]\",\n \"def vectordot(a, b):\\n return np.sum(a * b, 1)\",\n \"def _contraction_without_merge(self, x, supports):\\n shape = x.shape\\n tensor_rank = len(shape) - 2\\n if tensor_rank == self.support_tensor_rank:\\n if self.support_tensor_rank == 1:\\n return torch.sum(torch.stack([\\n supports[i_dim].mm(x[:, i_dim]) for i_dim\\n in range(self.dim)]), dim=0)\\n elif self.support_tensor_rank == 2:\\n # ijkm, jnmf -> iknf\\n return torch.stack([\\n torch.stack([\\n torch.sum(torch.stack([\\n supports[self.dim*k+m].mm(x[:, n, m])\\n for m in range(self.dim)]), dim=0)\\n for n in range(self.dim)], dim=1)\\n for k in range(self.dim)], dim=1)\\n else:\\n raise ValueError\\n elif tensor_rank > 1:\\n return torch.stack([\\n self._contraction_without_merge(x[:, i_dim], supports)\\n for i_dim in range(self.dim)], dim=1)\\n else:\\n raise ValueError(f\\\"Tensor rank is 0 (shape: {shape})\\\")\",\n \"def subtract_vectors(vector_1, vector_2):\\n new_coordinates = []\\n index = 0\\n while index < vector_1.dimension:\\n new_value = vector_1.coordinates[index] - vector_2.coordinates[index]\\n new_coordinates.append(new_value)\\n index += 1\\n new_vector = Vector(new_coordinates)\\n return new_vector\",\n \"def classical(m1,m2):\\n \\n n = m1.shape\\n result = np.zeros(n, dtype = int)\\n\\n for i in range(n[0]):\\n for j in range(n[0]):\\n for k in range(n[0]):\\n result[i][j] += m1[i][k] * m2[k][j]\\n return result\",\n \"def substract(self, vector):\\n\\n # return (self.from_list([vector.vector[self.vector.index(x)]-x for x in\\n # self.vector]))\\n return Vector(self.x - vector.x, self.y - vector.y, self.z - vector.z)\",\n \"def calculate_vector_difference(self, point, cpoint):\\n difference = []\\n for m, s in zip(point, cpoint):\\n difference.append(m - s)\\n return difference\",\n \"def gains_vector(m):\\n\\n n_ant, n_chan, n_dir, _ = m.shape\\n row_shape = n_ant * n_chan * n_dir\\n g = np.zeros((2*row_shape), dtype=np.complex128)\\n\\n for nu in range(n_chan):\\n for s in range(n_dir):\\n for a in range(n_ant):\\n row = a + n_ant * s + n_ant * n_dir * nu \\n g[row] = m[a, nu, s, 0]\\n g[row + row_shape] = m[a, nu, s, 1]\\n \\n return g\",\n \"def apply(self, v):\\n u = np.zeros(self.Dimension, dtype=complex)\\n for me in self.Elements:\\n for index in range(v.Elements.size):\\n if index == me.j:\\n u[me.i] += me.val * v.Elements[index]\\n u = Vector(u) \\n return u\",\n \"def conj(self, vecs):\\n raise NotImplementedError\",\n \"def get_C(n_c,CV_matrix):\\n C = np.zeros((n_c, n_c), dtype=np.float32)\\n for i in range(3):\\n C += np.asfortranarray(CV_matrix[:, :, i]) @ np.asfortranarray(CV_matrix[:, :, np.mod(i + 2, 3)].T)\\n C = (C != 0).astype(np.int32)\\n return C\",\n \"def compCGP_C(M):\\n # we store the coedd as a lower triangular matrix\\n # random polynomial coefficients\\n c = 0.5 * np.random.uniform(-1.0, -0.45, size=(M + 1, M + 1)) +\\\\\\n 0.5 * np.random.uniform(0.45, 1.0, size=(M + 1, M + 1))\\n for i in np.arange(M + 1):\\n c[i, :] /= 2**(np.arange(M + 1) + i)\\n c /= 1.5\\n c = np.tril(c)\\n c[0, 0] = 0\\n c[1, 0] = 0\\n c[1, 1] = 1\\n\\n return c\",\n \"def conv(A, B, c, i, tipus):\\r\\n if tipus == 1:\\r\\n suma = [np.conj(A[k, i]) * B[c - k, i] for k in range(1, c + 1)]\\r\\n return sum(suma)\\r\\n elif tipus == 2:\\r\\n suma = [A[k, i] * B[c - 1 - k, i] for k in range(1, c)]\\r\\n return sum(suma)\\r\\n elif tipus == 3:\\r\\n suma = [A[k, i] * np.conj(B[c - k, i]) for k in range(1, c)]\\r\\n return sum(suma)\",\n \"def true_gains_vector(m):\\n\\n n_ant, n_chan, n_dir = m.shape\\n row_shape = n_ant * n_chan * n_dir\\n g = np.zeros((2*row_shape), dtype=np.complex128)\\n\\n for nu in range(n_chan):\\n for s in range(n_dir):\\n for a in range(n_ant):\\n row = a + n_ant * s + n_ant * n_dir * nu \\n g[row] = m[a, nu, s]\\n g[row + row_shape] = m[a, nu, s].conj()\\n\\n return g\",\n \"def _inv22_vectorized(M):\\n assert (M.ndim == 3)\\n assert (M.shape[-2:] == (2, 2))\\n M_inv = np.empty_like(M)\\n delta_inv = np.reciprocal(M[:, 0, 0]*M[:, 1, 1] - M[:, 0, 1]*M[:, 1, 0])\\n M_inv[:, 0, 0] = M[:, 1, 1]*delta_inv\\n M_inv[:, 0, 1] = -M[:, 0, 1]*delta_inv\\n M_inv[:, 1, 0] = -M[:, 1, 0]*delta_inv\\n M_inv[:, 1, 1] = M[:, 0, 0]*delta_inv\\n return M_inv\",\n \"def c(self) -> np.ndarray:\\n return self._vector[10:12]\",\n \"def _apply_cost_to_vec(\\n self, vec: jnp.ndarray, axis: int = 0, fn=None\\n ) -> jnp.ndarray:\\n vec = jnp.reshape(vec, self.grid_size)\\n accum_vec = jnp.zeros_like(vec)\\n indices = list(range(1, self.grid_dimension))\\n for dimension, geom in enumerate(self.geometries):\\n cost = geom.cost_matrix\\n ind = indices.copy()\\n ind.insert(dimension, 0)\\n if axis == 0:\\n cost = cost.T\\n accum_vec += jnp.sum(\\n jnp.tensordot(cost, vec, axes=([0], [dimension])),\\n axis=indices,\\n keepdims=True\\n ).transpose(ind)\\n return accum_vec.ravel()\",\n \"def matrixSubtraction(self, a, b):\\n\\t\\n\\t\\tnumRows = len(a)\\n\\t\\tnumCols = len(a[0])\\n\\t\\n\\t\\treturn [[ a[j][i] - b[j][i] for i in range(numCols)] for j in range(numRows)]\",\n \"def ec_matrix_vector(p0, T, n): \\n if(n<=0):\\n EC=np.zeros(T.shape)\\n return EC\\n else:\\n \\\"\\\"\\\"Probability vector after (k=0) propagations\\\"\\\"\\\" \\n p_k=1.0*p0\\n \\\"\\\"\\\"Sum of vectors after (k=0) propagations\\\"\\\"\\\"\\n p_sum=1.0*p_k \\n for k in xrange(n-1):\\n \\\"\\\"\\\"Propagate one step p_{k} -> p_{k+1}\\\"\\\"\\\"\\n p_k=np.dot(p_k,T) \\n \\\"\\\"\\\"Update sum\\\"\\\"\\\"\\n p_sum+=p_k \\n \\\"\\\"\\\"Expected counts\\\"\\\"\\\"\\n EC=p_sum[:,np.newaxis]*T \\n return EC\",\n \"def vector_subtract(v1, v2):\\n return v1[0] - v2[0], v1[1] - v2[1]\",\n \"def subtract_vectors(u, v):\\n return u[0] - v[0], u[1] - v[1], u[2] - v[2]\",\n \"def contract(tensor):\\n temp = np.einsum('ikma, jlan', tensor, tensor)\\n M = np.zeros((tensor.shape[0]**2, tensor.shape[1]**2, tensor.shape[2], tensor.shape[3]))\\n for i,j,k,l,m,n in it.product(*[range(x) for x in temp.shape]):\\n M[i + tensor.shape[0]*j, k + tensor.shape[1]*l, m, n] = temp[i,j,k,l,m,n]\\n return M\",\n \"def retraction(self, v, x, c):\\n c = self.truncate_c(c)\\n new_v = self.expmap(v, x, c)\\n return self.proj(new_v, c)\",\n \"def vector_sum(a, b):\\n return a[0] + b[0], a[1] + b[1]\",\n \"def vector(p0, p1):\\n a = p1[0] - p0[0]\\n b = p1[1] - p0[1]\\n return (a, b)\",\n \"def sysrem_update_rij(rij, a, c):\\n return rij - np.outer(a,c)\",\n \"def spmv (n, A, x):\\n y = dense_vector (n)\\n for (i, A_i) in A.items ():\\n s = 0\\n for (j, a_ij) in A_i.items ():\\n s += a_ij * x[j]\\n y[i] = s\\n return y\",\n \"def transform(tvec1, rvec1, tvec2, rvec2):\\n op = localToGlobal(np.squeeze(tvec2), np.squeeze(rvec2))\\n tvec3 = []\\n for tvec in tvec1:\\n #tvec = tvec.squeeze()\\n tvec3.append(np.matmul(op, tvec))\\n tvec3 = np.array(tvec3)\\n return tvec3\",\n \"def vec_cross(a,b):\\r\\n return [a[1] * b[2] - a[2] * b[1],\\r\\n a[2] * b[0] - a[0] * b[2],\\r\\n a[0] * b[1] - a[1] * b[0]]\",\n \"def op(M, N):\\n\\n return M ^ N\",\n \"def c(self, i):\\n value = self.b(i)\\n if i == self.N:\\n return value\\n else:\\n for j in range(i+1, self.N+1):\\n value = value - self.a(i,j) * self.C[j]\\n return value\",\n \"def __sub__(self, m):\\n nv=Matrice()\\n if self.__mm_type(m):\\n ls=len(self)\\n nv.generate(ls,self.desc())\\n for i in self.desc():\\n for j in range(len(self)):\\n nv.g_val(self.val(i,j)-m.val(i,j),i,j)\\n return nv\",\n \"def cross_vectors(u, v):\\n return [u[1] * v[2] - u[2] * v[1],\\n u[2] * v[0] - u[0] * v[2],\\n u[0] * v[1] - u[1] * v[0]]\",\n \"def apply(self,v):\\n return np.tensordot(self._transform, v, axes=([1],[0])) \\\\\\n + self._translation\",\n \"def vector_sub(v1,v2):\\n return Vector(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z)\",\n \"def to_coulomb_vec(mol, max_size=23, addition=None):\\n\\n cm = to_coulomb_m(mol, max_size=max_size)\\n cm_vec = cm[np.tril_indices(cm.shape[0])]\\n \\n if addition:\\n cm_vec = np.hstack([cm_vec, addition])\\n \\n return cm_vec\",\n \"def vector_sum(vectors):\\n results = vectors[0]\\n for vector in vectors[1:]:\\n results = vector_add(results, vector)\\n return results\",\n \"def test_scalar_coeff_cc():\\n hs_1 = LocalSpace('q1', basis=('g', 'e'))\\n hs_2 = LocalSpace('q2', basis=('g', 'e'))\\n kappa = Symbol('kappa', real=True)\\n a1 = Destroy(hs=hs_1)\\n a2 = Destroy(hs=hs_2)\\n\\n jc_expr = (\\n I / 2 * (2 * kappa * (a1.dag() * a2) - 2 * kappa * (a1 * a2.dag()))\\n )\\n\\n simplified = rewrite_with_operator_pm_cc(jc_expr)\\n assert simplified == I * kappa * OperatorPlusMinusCC(\\n a1.dag() * a2, sign=-1\\n )\\n expanded = simplified.doit()\\n assert expanded == I * kappa * (a1.dag() * a2 - a1 * a2.dag())\",\n \"def __sub__(self, other):\\n return Vector([c1 - c2 for (c1, c2) in zip(self.components, other.components)])\",\n \"def matTimesVec(M, x):\\n return [dot(m, x) for m in M]\",\n \"def associate_comp(x, y):\\n return torch.cat([x[:1] * y[:1] - x[1:] * y[1:], x[:1] * y[1:] + x[1:] * y[:1]])\",\n \"def __mul__(self, n):\\n vectors = [n * Vector(*(p - self.center)) for p in self.points]\\n return Form([vectors[i](self.points[i]) for i in range(len(self.points))])\",\n \"def project_vectors(self, vectors):\\n return np.dot(vectors, self.components.T)\",\n \"def subtract_update_(X, c, Y):\\n if X.size > 2048:\\n _nb_subtract_update_par(X, c, Y, out=X)\\n else:\\n _nb_subtract_update_seq(X, c, Y, out=X)\",\n \"def commutator(self, other) -> 'MultiVector':\\n\\n return ((self * other) - (other * self)) / 2\",\n \"def marginal(self, target, out=None):\\n return self.__opReduce2(self.v - target,np.sum, out=out)\",\n \"def CoTang(M):\\n x = [sy.Dummy() for _ in range(nargs(M))]\\n fx = [sy.Dummy() for _ in range(len(x))]\\n\\n y = list(M(*x))\\n J = Jac(M)(*x)\\n J = sy.Matrix(J).reshape(len(y), len(x))\\n\\n fy = list(J.T.inv() @ sy.Matrix(fx))\\n return sy.lambdify(\\n x + fx,\\n y + fy,\\n 'sympy',\\n )\",\n \"def test__vector_subtraction__given_two_vectors__return_correct_vector():\\n assert Vector((0, 1, 2)) - Vector((3, 4, 5)) == Vector((-3, -3, -3))\",\n \"def apply_ccms(images, ccms):\\n images.shape.assert_has_rank(4)\\n images = images[:, :, :, tf.newaxis, :]\\n ccms = ccms[:, tf.newaxis, tf.newaxis, :, :]\\n return tf.reduce_sum(images * ccms, axis=-1)\",\n \"def scalar_multiply(c: float, v: Vector) -> Vector:\\n return [c * v_i for v_i in v]\",\n \"def scalar_multiply(c: float, v: Vector) -> Vector:\\n return [c * v_i for v_i in v]\",\n \"def vector_sum(vectors):\\n\\tresult = vectors[0]\\n\\tfor vector in vectors:\\n\\t\\tresult = vector_add(result, vector)\\n\\treturn result\",\n \"def vectorAdd(a, b):\\n return [a[i] + b[i] for i, j in enumerate(a)]\",\n \"def __imul__(self, n):\\n vectors = [n * Vector(*(p - self.center)) for p in self.points]\\n self.points = [vectors[i](self.points[i]) for i in range(len(self.points))]\\n return self\",\n \"def crossproduct(first, other=FreeCAD.Vector(0,0,1)):\\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\\n return FreeCAD.Vector(first.y*other.z - first.z*other.y, first.z*other.x - first.x*other.z, first.x*other.y - first.y*other.x)\",\n \"def tripiv(a, b, c, d):\\n \\n n = len(b)\\n x = np.zeros(n)\\n fail = 0\\n \\n # reordering\\n \\n a[0] = b[0]\\n b[0] = c[0]\\n c[0] = 0\\n \\n # elimination:\\n \\n l = 0\\n \\n for k in range(0,n):\\n q = a[k]\\n i = k\\n \\n if l < n-1:\\n l = l + 1\\n \\n for j in range(k+1,l+1):\\n q1 = a[j]\\n if (np.abs(q1) > np.abs(q)):\\n q = q1\\n i = j\\n if q == 0:\\n fail = -1\\n \\n if i != k:\\n q = d[k]\\n d[k] = d[i]\\n d[i] = q\\n q = a[k]\\n a[k] = a[i]\\n a[i] = q\\n q = b[k]\\n b[k] = b[i]\\n b[i] = q\\n q = c[k]\\n c[k] =c[i]\\n c[i] = q\\n for i in range(k+1,l+1):\\n q = a[i]/a[k]\\n d[i] = d[i]-q*d[k]\\n a[i] = b[i]-q*b[k]\\n b[i] = c[i]-q*c[k]\\n c[i] = 0\\n \\n\\n \\n # backsubstitution\\n \\n x[n-1] = d[n-1]/a[n-1]\\n x[n-2] = (d[n-2]-b[n-2]*x[n-1])/a[n-2]\\n \\n for i in range(n-3,-1,-1):\\n \\n q = d[i] - b[i]*x[i+1]\\n x[i] = (q - c[i]*x[i+2])/a[i]\\n \\n return x\",\n \"def subtract(self, m): \\n f = m.negate()\\n return self.add(f)\",\n \"def apply(self, vec):\\n return self._disp_over_m * vec - self._gp * ( # pylint: disable = E1130\\n self._gp @ vec / self.L ** self.ndim\\n )\",\n \"def ccw(p1, p2, p3):\\n return (p2[0] - p1[0])*(p3[1] - p1[1]) - (p2[1] - p1[1])*(p3[0] - p1[0])\",\n \"def cg(A, b, x=None):\\n n = len(b)\\n if not x:\\n x = np.ones([n,1])\\n r = np.dot(A, x) - b\\n p = - r\\n # r_k_norm = np.dot(r, r)\\n r_k_norm = np.linalg.norm ( r )*np.linalg.norm ( r )\\n for i in range(2*n):\\n Ap = np.dot(A, p)\\n alpha = r_k_norm / p.T@Ap\\n try:\\n x += alpha * p\\n except:\\n pass\\n r += alpha * Ap\\n r_kplus1_norm = np.linalg.norm ( r )*np.linalg.norm ( r )\\n beta = r_kplus1_norm / r_k_norm\\n r_k_norm = r_kplus1_norm\\n if r_kplus1_norm < 1e-5:\\n break\\n p = beta * p - r\\n return x\",\n \"def project_vectors(self, vectors):\\n X = vectors - self._mean\\n return np.dot(X, self.components.T)\",\n \"def coproduct(self, element):\\n from sage.categories.tensor import tensor\\n base = element.lift().parent()\\n return self.tensor_square().sum(coeff * tensor([self(base[x]), self(base[y])])\\n for ((x,y), coeff) in element.lift().coproduct())\",\n \"def multMatVect(v, A, m1, B, m2):\\r\\n if multMatVect.dot_modulo is None:\\r\\n A_sym = tensor.lmatrix('A')\\r\\n s_sym = tensor.ivector('s')\\r\\n m_sym = tensor.iscalar('m')\\r\\n A2_sym = tensor.lmatrix('A2')\\r\\n s2_sym = tensor.ivector('s2')\\r\\n m2_sym = tensor.iscalar('m2')\\r\\n o = DotModulo()(A_sym, s_sym, m_sym, A2_sym, s2_sym, m2_sym)\\r\\n multMatVect.dot_modulo = function(\\r\\n [A_sym, s_sym, m_sym, A2_sym, s2_sym, m2_sym], o)\\r\\n\\r\\n # This way of calling the Theano fct is done to bypass Theano overhead.\\r\\n f = multMatVect.dot_modulo\\r\\n f.input_storage[0].storage[0] = A\\r\\n f.input_storage[1].storage[0] = v[:3]\\r\\n f.input_storage[2].storage[0] = m1\\r\\n f.input_storage[3].storage[0] = B\\r\\n f.input_storage[4].storage[0] = v[3:]\\r\\n f.input_storage[5].storage[0] = m2\\r\\n f.fn()\\r\\n r = f.output_storage[0].storage[0]\\r\\n\\r\\n return r\",\n \"def cforwardsolve(A, b, d):\\n A = matrix(A)\\n n = len(b)\\n for k in range(n-1):\\n b[k] /= A[k, k]\\n uk = array([n, k + d + 1]).min()\\n b[(k+1):uk] -= A[(k+1):uk, k]*b[k]\\n b[n - 1] /= A[n - 1,n - 1]\",\n \"def MulMatrixVector(InversedMat, b_vector):\\r\\n result = []\\r\\n # Initialize the x vector\\r\\n for i in range(len(b_vector)):\\r\\n result.append([])\\r\\n result[i].append(0)\\r\\n # Multiplication of inverse matrix in the result vector\\r\\n for i in range(len(InversedMat)):\\r\\n for k in range(len(b_vector)):\\r\\n result[i][0] += InversedMat[i][k] * b_vector[k][0]\\r\\n return result\",\n \"def calculate(self) -> complex128:\\n\\n if not self.__can_calculation_be_performed():\\n raise AttributeError\\n\\n v_vectors = self.__calculate_v_vectors()\\n\\n permanent = 0\\n for v_vector in v_vectors:\\n v_sum = sum(v_vector)\\n addend = pow(-1, v_sum)\\n # Binomials calculation\\n for i in range(len(v_vector)):\\n addend *= binom(self.__input_state[i], v_vector[i])\\n\\n # Product calculation\\n product = 1\\n for j in range(len(self.__input_state)):\\n if self.__output_state[j] == 0: # There's no reason to calculate the sum if t_j = 0\\n continue\\n # Otherwise we calculate the sum\\n product_part = 0\\n for i in range(len(self.__input_state)):\\n product_part += (self.__input_state[i] - 2 * v_vector[i]) * self.__matrix[j][i]\\n product_part = pow(product_part, self.__output_state[j])\\n product *= product_part\\n addend *= product\\n permanent += addend\\n\\n permanent /= pow(2, sum(self.__input_state))\\n\\n return permanent\",\n \"def Cvec(self):\\n return vec(self.xc, self.yc)\",\n \"def covar(self):\\n a, c, d, b = self.to_ccw()\\n return a * d - b * c\",\n \"def cotangent(a: list, b: list, c: list):\\n ba = np.subtract(a, b)\\n bc = np.subtract(c, b)\\n return (np.dot(bc, ba) / abs(np.cross(bc, ba)))\",\n \"def matrix_vector_prod(m,u):\\n each_product = []\\n for v in m:\\n each_product.append(dot_prod(v, u))\\n return each_product\",\n \"def matrix_mult(M, vector1, vector2):\\n out = None\\n ### YOUR CODE HERE\\n pass\\n ### END YOUR CODE\\n\\n return out\",\n \"def matrix_mult(M, vector1, vector2):\\n out = None\\n ### YOUR CODE HERE\\n pass\\n ### END YOUR CODE\\n\\n return out\",\n \"def mtob(InputVec):\\n InputVec = InputVec.copy()\\n mf = InputVec.size\\n natoms =round(math.log(mf,2))\\n if math.pow(2, natoms) == mf:\\n for i in range(natoms):\\n i124 = int(math.pow(2, i))\\n i842 = int(math.pow(2, natoms - i))\\n i421 = int(math.pow(2, natoms - i - 1))\\n InputVec = InputVec.reshape(i124, i842,order='F')\\n #for j in range(1, i421 + 1): #to be replaced by i842\\n for j in range(i421): #not a good way for add operation coz loop matrix for i842 times\\n InputVec[:, j * 2 + 1 ] = InputVec[:, j * 2 + 1 ] + InputVec[:, j * 2]\\n out = InputVec.reshape(1,mf,order='F')[0]\\n return out\\n else:\\n exit(\\\"ACCIDENT in mtoq: length of input vector not OK: should be a power of 2\\\\n\\\")\",\n \"def reduce(self,vecs):\\n\\t\\tif self.base_vecs is None or self.inv_vecs is None:\\n\\t\\t\\traise KeyError('The fitter has not yet been prepped.')\\n\\n\\t\\tr_arr = []\\n\\t\\tfor vec in vecs:\\n\\t\\t\\tcoeffs = self.Fit(vec)\\n\\t\\t\\tr_arr.append(np.subtract(vec,np.dot(coeffs,self.base_vecs)))\\n\\n\\t\\treturn r_arr\",\n \"def conjugate(quats):\\n res = np.zeros(quats.shape)\\n res[:,0]=quats[:,0]\\n res[:,1]=-quats[:,1]\\n res[:,2]=-quats[:,2]\\n res[:,3]=-quats[:,3]\\n \\n return res\",\n \"def custom_np_function(vector):\\n summation = 0\\n for item in vector:\\n summation += item ** 2\\n return summation\",\n \"def f(t, x, n, v):\\n total = 0\\n for i in range(n+1):\\n for j in range(n+1):\\n for k in range(v):\\n total = t[i][j] * x[i][j][k]\",\n \"def reflect(d,n):\\n\\t# coefficent c, because easier\\n\\tc = 2 * dot(d,n)\\n\\treturn [di - c * ni for (di, ni) in zip(d,n)]\",\n \"def compCoeff_CGP(i, A, c, N):\\n Ap = np.copy(A)\\n out = c[i, 0] * np.eye(N)\\n j = 1\\n while j <= i:\\n # compute A to the power p\\n if j > 1:\\n Ap = Ap.dot(A)\\n\\n # add to the polynome\\n out += c[i, j] * Ap\\n j += 1\\n\\n return out\",\n \"def v3minus(a, b):\\n return [a[i] - b[i] for i, j in enumerate(a)]\",\n \"def _prod_vectorized(M1, M2):\\n sh1 = M1.shape\\n sh2 = M2.shape\\n assert len(sh1) >= 2\\n assert len(sh2) >= 2\\n assert sh1[-1] == sh2[-2]\\n\\n ndim1 = len(sh1)\\n t1_index = list(xrange(ndim1-2)) + [ndim1-1, ndim1-2]\\n return np.sum(np.transpose(M1, t1_index)[..., np.newaxis] *\\n M2[..., np.newaxis, :], -3)\",\n \"def scalar_mult(n, m):\\n\\ttemp = []\\n\\tfor i in range(len(m)):\\n\\t\\te = []\\n\\t\\tfor j in range(len(m[0])):\\n\\t\\t\\te.append(m[i][j]*n)\\n\\t\\ttemp.append(e)\\n\\treturn temp\",\n \"def multiply_vector(self, dv, spm):\\n product = []\\n for a, b in zip(dv, spm):\\n product.append(a * b)\\n return product\",\n \"def _diffmat_objective(a,X):\\n \\n (n,p) = X.shape\\n return(X - np.tile(a,(n,1)))\",\n \"def _z2matvecmul(self, mat, vec):\\n prod = np.mod(np.dot(mat, vec), 2)\\n return prod\",\n \"def complex_inverse(c1,cr):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6204063","0.6118313","0.6027351","0.59437466","0.5920729","0.58891094","0.58567584","0.58476985","0.58374596","0.58282095","0.5810846","0.5797152","0.5795684","0.5795684","0.5795684","0.5773497","0.5768829","0.56864727","0.5681027","0.56669194","0.5644837","0.5623082","0.5610107","0.56075954","0.5603298","0.55920404","0.5581414","0.55782175","0.55740637","0.55659306","0.5565613","0.5564391","0.55618244","0.55551463","0.55537885","0.5543402","0.5540208","0.55392","0.55380297","0.55355424","0.5532949","0.5517914","0.55109835","0.5505548","0.5500484","0.5500238","0.5492022","0.5488059","0.5486611","0.5485856","0.54841626","0.5483831","0.54798853","0.54747397","0.5468401","0.54568344","0.544855","0.544829","0.5446761","0.54454345","0.5445297","0.54368985","0.543661","0.542401","0.542401","0.54117715","0.540698","0.53997546","0.5399241","0.539443","0.53803575","0.5376313","0.53749347","0.53711563","0.5366117","0.5363147","0.5344696","0.53365266","0.53125995","0.53066605","0.53021306","0.5302119","0.5294721","0.5293125","0.52875644","0.52875644","0.52867746","0.5285093","0.5283519","0.52827716","0.5280239","0.5280212","0.527718","0.5272628","0.5269244","0.5266445","0.5263664","0.5260295","0.52577233","0.52576834"],"string":"[\n \"0.6204063\",\n \"0.6118313\",\n \"0.6027351\",\n \"0.59437466\",\n \"0.5920729\",\n \"0.58891094\",\n \"0.58567584\",\n \"0.58476985\",\n \"0.58374596\",\n \"0.58282095\",\n \"0.5810846\",\n \"0.5797152\",\n \"0.5795684\",\n \"0.5795684\",\n \"0.5795684\",\n \"0.5773497\",\n \"0.5768829\",\n \"0.56864727\",\n \"0.5681027\",\n \"0.56669194\",\n \"0.5644837\",\n \"0.5623082\",\n \"0.5610107\",\n \"0.56075954\",\n \"0.5603298\",\n \"0.55920404\",\n \"0.5581414\",\n \"0.55782175\",\n \"0.55740637\",\n \"0.55659306\",\n \"0.5565613\",\n \"0.5564391\",\n \"0.55618244\",\n \"0.55551463\",\n \"0.55537885\",\n \"0.5543402\",\n \"0.5540208\",\n \"0.55392\",\n \"0.55380297\",\n \"0.55355424\",\n \"0.5532949\",\n \"0.5517914\",\n \"0.55109835\",\n \"0.5505548\",\n \"0.5500484\",\n \"0.5500238\",\n \"0.5492022\",\n \"0.5488059\",\n \"0.5486611\",\n \"0.5485856\",\n \"0.54841626\",\n \"0.5483831\",\n \"0.54798853\",\n \"0.54747397\",\n \"0.5468401\",\n \"0.54568344\",\n \"0.544855\",\n \"0.544829\",\n \"0.5446761\",\n \"0.54454345\",\n \"0.5445297\",\n \"0.54368985\",\n \"0.543661\",\n \"0.542401\",\n \"0.542401\",\n \"0.54117715\",\n \"0.540698\",\n \"0.53997546\",\n \"0.5399241\",\n \"0.539443\",\n \"0.53803575\",\n \"0.5376313\",\n \"0.53749347\",\n \"0.53711563\",\n \"0.5366117\",\n \"0.5363147\",\n \"0.5344696\",\n \"0.53365266\",\n \"0.53125995\",\n \"0.53066605\",\n \"0.53021306\",\n \"0.5302119\",\n \"0.5294721\",\n \"0.5293125\",\n \"0.52875644\",\n \"0.52875644\",\n \"0.52867746\",\n \"0.5285093\",\n \"0.5283519\",\n \"0.52827716\",\n \"0.5280239\",\n \"0.5280212\",\n \"0.527718\",\n \"0.5272628\",\n \"0.5269244\",\n \"0.5266445\",\n \"0.5263664\",\n \"0.5260295\",\n \"0.52577233\",\n \"0.52576834\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.709335"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94489,"cells":{"query":{"kind":"string","value":"Converts from 3x3 to 6x1"},"document":{"kind":"string","value":"def voigt(a):\n A = np.zeros(shape=(6, 1))\n A[0] = a[0, 0]\n A[1] = a[1, 1]\n A[2] = a[2, 2]\n A[3] = a[1, 2]\n A[4] = a[0, 2]\n A[5] = a[0, 1]\n return A"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def make8UC3(mat):\n mat_8UC = make8UC(mat)\n mat_8UC3 = np.stack((mat_8UC,)*3, axis = -1)\n \n return mat_8UC3","def dti6to33(dt6):\n dt33 = numpy.zeros(dt6.shape[:-1] + (3, 3), dtype=dt6.dtype)\n dt33[..., 0, 0] = dt6[..., 5] # dxx\n dt33[..., 0, 1] = dt33[..., 1, 0] = dt6[..., 4] / 2 # dxy\n dt33[..., 0, 2] = dt33[..., 2, 0] = dt6[..., 3] / 2 # dxz\n dt33[..., 1, 1] = dt6[..., 2] # dyy\n dt33[..., 1, 2] = dt33[..., 2, 1] = dt6[..., 1] / 2 # dyz\n dt33[..., 2, 2] = dt6[..., 0] # dzz\n\n return dt33","def _to_bc_L_h_w_3(x, x_shape):\r\n\r\n x = tf.reshape(x, (-1,\r\n int(x_shape[2]),\r\n int(x_shape[3]),\r\n int(x_shape[4]), 3))\r\n return x","def dti33to6(dt33):\n dt6 = numpy.zeros(dt33.shape[:-2] + (6, ), dtype=dt33.dtype)\n dt6[..., 5] = dt33[..., 0, 0]\n dt6[..., 4] = dt33[..., 0, 1] + dt33[..., 1, 0]\n dt6[..., 3] = dt33[..., 0, 2] + dt33[..., 2, 0]\n dt6[..., 2] = dt33[..., 1, 1]\n dt6[..., 1] = dt33[..., 1, 2] + dt33[..., 2, 1]\n dt6[..., 0] = dt33[..., 2, 2]\n\n return dt6","def _transpose_by_1_vnchwconv():\n\n pass","def Cijkl(C):\n c = np.zeros(shape=(3, 3, 3, 3))\n CC = np.zeros(shape=(9, 9))\n CC[0:6, 0:6] = C[0:6, 0:6]\n CC[6:9, 6:9] = C[3:6, 3:6]\n CC[0:6, 6:9] = C[0:6, 3:6]\n CC[6:9, 0:6] = C[3:6, 0:6]\n\n c[0, 0, 0, 0] = CC[0, 0]\n c[0, 0, 1, 1] = CC[0, 1]\n c[0, 0, 2, 2] = CC[0, 2]\n c[0, 0, 1, 2] = CC[0, 3]\n c[0, 0, 2, 0] = CC[0, 4]\n c[0, 0, 0, 1] = CC[0, 5]\n c[0, 0, 2, 1] = CC[0, 6]\n c[0, 0, 0, 2] = CC[0, 7]\n c[0, 0, 1, 0] = CC[0, 8]\n\n c[1, 1, 0, 0] = CC[1, 0]\n c[1, 1, 1, 1] = CC[1, 1]\n c[1, 1, 2, 2] = CC[1, 2]\n c[1, 1, 1, 2] = CC[1, 3]\n c[1, 1, 2, 0] = CC[1, 4]\n c[1, 1, 0, 1] = CC[1, 5]\n c[1, 1, 2, 1] = CC[1, 6]\n c[1, 1, 0, 2] = CC[1, 7]\n c[1, 1, 1, 0] = CC[1, 8]\n\n c[2, 2, 0, 0] = CC[2, 0]\n c[2, 2, 1, 1] = CC[2, 1]\n c[2, 2, 2, 2] = CC[2, 2]\n c[2, 2, 1, 2] = CC[2, 3]\n c[2, 2, 2, 0] = CC[2, 4]\n c[2, 2, 0, 1] = CC[2, 5]\n c[2, 2, 2, 1] = CC[2, 6]\n c[2, 2, 0, 2] = CC[2, 7]\n c[2, 2, 1, 0] = CC[2, 8]\n\n c[1, 2, 0, 0] = CC[3, 0]\n c[1, 2, 1, 1] = CC[3, 1]\n c[1, 2, 2, 2] = CC[3, 2]\n c[1, 2, 1, 2] = CC[3, 3]\n c[1, 2, 2, 0] = CC[3, 4]\n c[1, 2, 0, 1] = CC[3, 5]\n c[1, 2, 2, 1] = CC[3, 6]\n c[1, 2, 0, 2] = CC[3, 7]\n c[1, 2, 1, 0] = CC[3, 8]\n\n c[2, 0, 0, 0] = CC[4, 0]\n c[2, 0, 1, 1] = CC[4, 1]\n c[2, 0, 2, 2] = CC[4, 2]\n c[2, 0, 1, 2] = CC[4, 3]\n c[2, 0, 2, 0] = CC[4, 4]\n c[2, 0, 0, 1] = CC[4, 5]\n c[2, 0, 2, 1] = CC[4, 6]\n c[2, 0, 0, 2] = CC[4, 7]\n c[2, 0, 1, 0] = CC[4, 8]\n\n c[0, 1, 0, 0] = CC[5, 0]\n c[0, 1, 1, 1] = CC[5, 1]\n c[0, 1, 2, 2] = CC[5, 2]\n c[0, 1, 1, 2] = CC[5, 3]\n c[0, 1, 2, 0] = CC[5, 4]\n c[0, 1, 0, 1] = CC[5, 5]\n c[0, 1, 2, 1] = CC[5, 6]\n c[0, 1, 0, 2] = CC[5, 7]\n c[0, 1, 1, 0] = CC[5, 8]\n\n c[2, 1, 0, 0] = CC[6, 0]\n c[2, 1, 1, 1] = CC[6, 1]\n c[2, 1, 2, 2] = CC[6, 2]\n c[2, 1, 1, 2] = CC[6, 3]\n c[2, 1, 2, 0] = CC[6, 4]\n c[2, 1, 0, 1] = CC[6, 5]\n c[2, 1, 2, 1] = CC[6, 6]\n c[2, 1, 0, 2] = CC[6, 7]\n c[2, 1, 1, 0] = CC[6, 8]\n\n c[0, 2, 0, 0] = CC[7, 0]\n c[0, 2, 1, 1] = CC[7, 1]\n c[0, 2, 2, 2] = CC[7, 2]\n c[0, 2, 1, 2] = CC[7, 3]\n c[0, 2, 2, 0] = CC[7, 4]\n c[0, 2, 0, 1] = CC[7, 5]\n c[0, 2, 2, 1] = CC[7, 6]\n c[0, 2, 0, 2] = CC[7, 7]\n c[0, 2, 1, 0] = CC[7, 8]\n\n c[1, 0, 0, 0] = CC[8, 0]\n c[1, 0, 1, 1] = CC[8, 1]\n c[1, 0, 2, 2] = CC[8, 2]\n c[1, 0, 1, 2] = CC[8, 3]\n c[1, 0, 2, 0] = CC[8, 4]\n c[1, 0, 0, 1] = CC[8, 5]\n c[1, 0, 2, 1] = CC[8, 6]\n c[1, 0, 0, 2] = CC[8, 7]\n c[1, 0, 1, 0] = CC[8, 8]\n return c","def six_hundred_cell(self):\n verts = []\n q12 = QQ(1)/2\n base = [q12,q12,q12,q12]\n for i in range(2):\n for j in range(2):\n for k in range(2):\n for l in range(2):\n verts.append([x for x in base])\n base[3] = base[3]*(-1)\n base[2] = base[2]*(-1)\n base[1] = base[1]*(-1)\n base[0] = base[0]*(-1)\n for x in permutations([0,0,0,1]):\n verts.append(x)\n for x in permutations([0,0,0,-1]):\n verts.append(x)\n g = QQ(1618033)/1000000 # Golden ratio approximation\n verts = verts + [i([q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\n verts = verts + [i([-q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\n return Polyhedron(vertices = verts)","def one_to_three(one):\n return ((1,0,0),(0,1,0),(0,0,1))[one+1]","def nine_to_3x3(listy):\n new_side = []\n k = int(len(listy) / 3)\n \n for i in range(k):\n intermediate = []\n for j in range(3):\n intermediate.append(listy.pop(0))\n \n new_side.append(intermediate)\n return new_side","def reformat(x):\n x = x.permute(0, 2, 3, 1)\n N, D1, D2, Feat = x.size()\n x = x.view(N, D1 * D2, Feat)\n return x","def reformat(x):\n x = x.permute(0, 2, 3, 1)\n N, D1, D2, Feat = x.size()\n x = x.view(N, D1 * D2, Feat)\n return x","def gm2code(arr, info):\n return (arr / info.pboxsize + 0.5)# * 0.999783599","def mask_tile(self):\n if self.size == 1:\n m = np.array([[0]])\n elif self.size ==2:\n m = np.array([[1,2],[4,3]])\n else:\n m = 9 * np.ones((self.size, self.size))\n m[0,0] = 1\n m[0,-1] = 2\n m[-1,-1] = 3\n m[-1,0] = 4 \n m[0,1:-1] = 5 * np.ones(self.size-2)\n m[1:-1,-1] = 6 * np.ones(self.size-2)\n m[-1,1:-1] = 7 * np.ones(self.size-2)\n m[1:-1,0] = 8 * np.ones(self.size-2)\n return m.astype(np.int8)","def dim3():\n return Integer(\"yolo3\", \"uniform\", 3, 7, shape=(1,))","def rotmat_to_rot6d(rotmat):\n\n rot6d = rotmat[:, :, 0:2]\n rot6d = rot6d.reshape(-1, 6)\n\n return rot6d","def test_2_2_3D_cube_splits(self):\n check = [(0, 0, 0), (1, 1, 1), (1, 0, 0), (1, 1, 0), (1, 0, 1),\n (0, 1, 0),\n (0, 1, 1), (0, 0, 1), (0.5, 0.5, 0.5), (0.0, 0.5, 0.5),\n (0.0, 0.0, 0.5), (0.0, 0.5, 0.0), (0.5, 0.0, 0.5),\n (0.5, 0.0, 0.0),\n (0.5, 0.5, 0.0), (0.25, 0.25, 0.25), (1.0, 0.5, 0.5),\n (1.0, 1.0, 0.5),\n (1.0, 0.5, 1.0), (0.5, 1.0, 0.5), (0.5, 1.0, 1.0),\n (0.5, 0.5, 1.0),\n (0.75, 0.75, 0.75), (1.0, 0.0, 0.5), (1.0, 0.5, 0.0),\n (0.75, 0.25, 0.25), (0.5, 1.0, 0.0), (0.75, 0.75, 0.25),\n (0.5, 0.0, 1.0), (0.75, 0.25, 0.75), (0.0, 1.0, 0.5),\n (0.25, 0.75, 0.25), (0.0, 0.5, 1.0), (0.25, 0.75, 0.75),\n (0.25, 0.25, 0.75), (0.5, 0.25, 0.25), (0.5, 0.5, 0.25),\n (0.5, 0.25, 0.5), (0.25, 0.5, 0.25), (0.25, 0.5, 0.5),\n (0.25, 0.25, 0.5), (0.375, 0.375, 0.375), (0.0, 0.25, 0.25),\n (0.0, 0.0, 0.25), (0.0, 0.25, 0.0), (0.25, 0.0, 0.25),\n (0.25, 0.0, 0.0), (0.25, 0.25, 0.0), (0.125, 0.125, 0.125),\n (0.0, 0.5, 0.25), (0.0, 0.25, 0.5), (0.125, 0.375, 0.375),\n (0.25, 0.0, 0.5), (0.125, 0.125, 0.375), (0.25, 0.5, 0.0),\n (0.125, 0.375, 0.125), (0.5, 0.0, 0.25), (0.375, 0.125, 0.375),\n (0.5, 0.25, 0.0), (0.375, 0.125, 0.125), (0.375, 0.375, 0.125),\n (0.5, 0.75, 0.75), (0.5, 0.5, 0.75), (0.5, 0.75, 0.5),\n (0.75, 0.5, 0.75), (0.75, 0.5, 0.5), (0.75, 0.75, 0.5),\n (0.625, 0.625, 0.625), (1.0, 0.75, 0.75), (1.0, 1.0, 0.75),\n (1.0, 0.75, 1.0), (0.75, 1.0, 0.75), (0.75, 1.0, 1.0),\n (0.75, 0.75, 1.0), (0.875, 0.875, 0.875), (1.0, 0.5, 0.75),\n (1.0, 0.75, 0.5), (0.875, 0.625, 0.625), (0.75, 1.0, 0.5),\n (0.875, 0.875, 0.625), (0.75, 0.5, 1.0), (0.875, 0.625, 0.875),\n (0.5, 1.0, 0.75), (0.625, 0.875, 0.625), (0.5, 0.75, 1.0),\n (0.625, 0.875, 0.875), (0.625, 0.625, 0.875),\n (0.75, 0.5, 0.25),\n (0.75, 0.25, 0.5), (0.625, 0.375, 0.375), (1.0, 0.25, 0.25),\n (1.0, 0.0, 0.25), (1.0, 0.25, 0.0), (0.75, 0.0, 0.25),\n (0.75, 0.0, 0.0), (0.75, 0.25, 0.0), (0.875, 0.125, 0.125),\n (1.0, 0.5, 0.25), (1.0, 0.25, 0.5), (0.875, 0.375, 0.375),\n (0.75, 0.0, 0.5), (0.875, 0.125, 0.375), (0.75, 0.5, 0.0),\n (0.875, 0.375, 0.125), (0.625, 0.125, 0.375),\n (0.625, 0.125, 0.125),\n (0.625, 0.375, 0.125), (0.5, 0.75, 0.25),\n (0.625, 0.625, 0.375),\n (1.0, 0.75, 0.25), (1.0, 1.0, 0.25), (1.0, 0.75, 0.0),\n (0.75, 1.0, 0.25), (0.75, 1.0, 0.0), (0.75, 0.75, 0.0),\n (0.875, 0.875, 0.125), (0.875, 0.625, 0.375),\n (0.875, 0.875, 0.375),\n (0.875, 0.625, 0.125), (0.5, 1.0, 0.25), (0.625, 0.875, 0.375),\n (0.5, 0.75, 0.0), (0.625, 0.875, 0.125), (0.625, 0.625, 0.125),\n (0.5, 0.25, 0.75), (0.625, 0.375, 0.625), (1.0, 0.25, 0.75),\n (1.0, 0.0, 0.75), (1.0, 0.25, 1.0), (0.75, 0.0, 0.75),\n (0.75, 0.0, 1.0), (0.75, 0.25, 1.0), (0.875, 0.125, 0.875),\n (0.875, 0.375, 0.625), (0.875, 0.125, 0.625),\n (0.875, 0.375, 0.875),\n (0.5, 0.0, 0.75), (0.625, 0.125, 0.625), (0.5, 0.25, 1.0),\n (0.625, 0.125, 0.875), (0.625, 0.375, 0.875),\n (0.25, 0.75, 0.5),\n (0.375, 0.625, 0.375), (0.0, 0.75, 0.25), (0.0, 1.0, 0.25),\n (0.0, 0.75, 0.0), (0.25, 1.0, 0.25), (0.25, 1.0, 0.0),\n (0.25, 0.75, 0.0), (0.125, 0.875, 0.125), (0.0, 0.75, 0.5),\n (0.125, 0.625, 0.375), (0.25, 1.0, 0.5), (0.125, 0.875, 0.375),\n (0.125, 0.625, 0.125), (0.375, 0.875, 0.375),\n (0.375, 0.875, 0.125),\n (0.375, 0.625, 0.125), (0.25, 0.5, 0.75),\n (0.375, 0.625, 0.625),\n (0.0, 0.75, 0.75), (0.0, 1.0, 0.75), (0.0, 0.75, 1.0),\n (0.25, 1.0, 0.75), (0.25, 1.0, 1.0), (0.25, 0.75, 1.0),\n (0.125, 0.875, 0.875), (0.0, 0.5, 0.75), (0.125, 0.625, 0.625),\n (0.125, 0.875, 0.625), (0.25, 0.5, 1.0), (0.125, 0.625, 0.875),\n (0.375, 0.875, 0.625), (0.375, 0.875, 0.875),\n (0.375, 0.625, 0.875),\n (0.375, 0.375, 0.625), (0.0, 0.25, 0.75), (0.0, 0.0, 0.75),\n (0.0, 0.25, 1.0), (0.25, 0.0, 0.75), (0.25, 0.0, 1.0),\n (0.25, 0.25, 1.0), (0.125, 0.125, 0.875),\n (0.125, 0.375, 0.625),\n (0.125, 0.125, 0.625), (0.125, 0.375, 0.875),\n (0.375, 0.125, 0.625),\n (0.375, 0.125, 0.875), (0.375, 0.375, 0.875)]\n\n nn_checks = {(0.5, 0.25, 0.25): [(0.375, 0.375, 0.125), (0.5, 0.5, 0.0),\n (0.75, 0.25, 0.25),\n (0.625, 0.375, 0.375),\n (0.625, 0.125, 0.375),\n (0.625, 0.125, 0.125),\n (0.5, 0.5, 0.25), (0.25, 0.25, 0.25),\n (0.375, 0.375, 0.375),\n (0.5, 0.25, 0.5), (0.5, 0.5, 0.5),\n (0.5, 0.0, 0.25),\n (0.375, 0.125, 0.375), (0.5, 0.0, 0.5),\n (0.5, 0.25, 0.0),\n (0.375, 0.125, 0.125), (0.5, 0.0, 0.0),\n (0.625, 0.375, 0.125)],\n (0.625, 0.625, 0.875): [(0.75, 0.5, 1.0),\n (0.75, 0.75, 1.0),\n (0.5, 0.75, 1.0), (0.5, 0.5, 1.0),\n (0.5, 0.5, 0.75),\n (0.5, 0.75, 0.75),\n (0.75, 0.5, 0.75),\n (0.75, 0.75, 0.75)],\n (0, 0, 0): [(0.0, 0.25, 0.0), (0.125, 0.125, 0.125),\n (0.0, 0.0, 0.25), (0.25, 0.0, 0.0),\n (0.0, 0.25, 0.25), (0.25, 0.25, 0.0),\n (0.25, 0.0, 0.25)]}\n\n init_triangulation(3, 2, check, nn_checks)","def make8UC(mat):\n mat_256 = mat[:,:]# *255\n mat_256.round()\n mat_8UC = np.uint8(mat_256)\n \n return mat_8UC","def resh(x):\r\n a = x.shape[0]\r\n b = x.shape[1]\r\n return x.reshape(a*b, 1), a, b","def six_cubed():\n print(math.pow(6,3))","def normalize((image)):\n new = np.zeros((7,7))\n index = 0\n for i in [0, 4, 7, 10, 14, 17, 21]:\n for j in [0, 4, 7, 10, 14, 17, 21]:\n new[index / 7][index % 7] += float(np.sum(image[i:(i+6),j:(j+6)]))/49\n index += 1\n return new","def test_3_2_4D_cube_splits(self):\n check = [(0, 0, 0, 0), (1, 1, 1, 1), (1, 0, 0, 0), (1, 1, 0, 0),\n (1, 1, 1, 0),\n (1, 1, 0, 1), (1, 0, 1, 0), (1, 0, 1, 1), (1, 0, 0, 1),\n (0, 1, 0, 0),\n (0, 1, 1, 0), (0, 1, 1, 1), (0, 1, 0, 1), (0, 0, 1, 0),\n (0, 0, 1, 1),\n (0, 0, 0, 1), (0.5, 0.5, 0.5, 0.5), (0.0, 0.5, 0.5, 0.5),\n (0.0, 0.0, 0.5, 0.5), (0.0, 0.0, 0.0, 0.5),\n (0.0, 0.0, 0.5, 0.0),\n (0.0, 0.5, 0.0, 0.5), (0.0, 0.5, 0.0, 0.0),\n (0.0, 0.5, 0.5, 0.0),\n (0.5, 0.0, 0.5, 0.5), (0.5, 0.0, 0.0, 0.5),\n (0.5, 0.0, 0.0, 0.0),\n (0.5, 0.0, 0.5, 0.0), (0.5, 0.5, 0.0, 0.5),\n (0.5, 0.5, 0.0, 0.0),\n (0.5, 0.5, 0.5, 0.0), (0.25, 0.25, 0.25, 0.25),\n (1.0, 0.5, 0.5, 0.5),\n (1.0, 1.0, 0.5, 0.5), (1.0, 1.0, 1.0, 0.5),\n (1.0, 1.0, 0.5, 1.0),\n (1.0, 0.5, 1.0, 0.5), (1.0, 0.5, 1.0, 1.0),\n (1.0, 0.5, 0.5, 1.0),\n (0.5, 1.0, 0.5, 0.5), (0.5, 1.0, 1.0, 0.5),\n (0.5, 1.0, 1.0, 1.0),\n (0.5, 1.0, 0.5, 1.0), (0.5, 0.5, 1.0, 0.5),\n (0.5, 0.5, 1.0, 1.0),\n (0.5, 0.5, 0.5, 1.0), (0.75, 0.75, 0.75, 0.75),\n (1.0, 0.0, 0.5, 0.5),\n (1.0, 0.0, 0.0, 0.5), (1.0, 0.0, 0.5, 0.0),\n (1.0, 0.5, 0.0, 0.5),\n (1.0, 0.5, 0.0, 0.0), (1.0, 0.5, 0.5, 0.0),\n (0.75, 0.25, 0.25, 0.25),\n (1.0, 1.0, 0.0, 0.5), (1.0, 1.0, 0.5, 0.0),\n (0.5, 1.0, 0.0, 0.5),\n (0.5, 1.0, 0.0, 0.0), (0.5, 1.0, 0.5, 0.0),\n (0.75, 0.75, 0.25, 0.25),\n (1.0, 0.5, 1.0, 0.0), (0.5, 1.0, 1.0, 0.0),\n (0.5, 0.5, 1.0, 0.0),\n (0.75, 0.75, 0.75, 0.25), (1.0, 0.5, 0.0, 1.0),\n (0.5, 1.0, 0.0, 1.0),\n (0.5, 0.5, 0.0, 1.0), (0.75, 0.75, 0.25, 0.75),\n (1.0, 0.0, 1.0, 0.5),\n (0.5, 0.0, 1.0, 0.5), (0.5, 0.0, 1.0, 0.0),\n (0.75, 0.25, 0.75, 0.25),\n (1.0, 0.0, 0.5, 1.0), (0.5, 0.0, 1.0, 1.0),\n (0.5, 0.0, 0.5, 1.0),\n (0.75, 0.25, 0.75, 0.75), (0.5, 0.0, 0.0, 1.0),\n (0.75, 0.25, 0.25, 0.75), (0.0, 1.0, 0.5, 0.5),\n (0.0, 1.0, 0.0, 0.5),\n (0.0, 1.0, 0.5, 0.0), (0.25, 0.75, 0.25, 0.25),\n (0.0, 1.0, 1.0, 0.5),\n (0.0, 0.5, 1.0, 0.5), (0.0, 0.5, 1.0, 0.0),\n (0.25, 0.75, 0.75, 0.25),\n (0.0, 1.0, 0.5, 1.0), (0.0, 0.5, 1.0, 1.0),\n (0.0, 0.5, 0.5, 1.0),\n (0.25, 0.75, 0.75, 0.75), (0.0, 0.5, 0.0, 1.0),\n (0.25, 0.75, 0.25, 0.75), (0.0, 0.0, 1.0, 0.5),\n (0.25, 0.25, 0.75, 0.25), (0.0, 0.0, 0.5, 1.0),\n (0.25, 0.25, 0.75, 0.75), (0.25, 0.25, 0.25, 0.75)]\n\n nn_checks = {(0, 0, 0, 0): [(0.0, 0.5, 0.5, 0.0), (0.5, 0.0, 0.5, 0.5),\n (0.5, 0.5, 0.0, 0.5),\n (0.25, 0.25, 0.25, 0.25),\n (0.5, 0.0, 0.0, 0.5), (0.5, 0.0, 0.5, 0.0),\n (0.5, 0.5, 0.0, 0.0), (0.0, 0.0, 0.5, 0.0),\n (0.0, 0.5, 0.0, 0.0), (0.0, 0.0, 0.0, 0.5),\n (0.0, 0.5, 0.5, 0.5), (0.0, 0.0, 0.5, 0.5),\n (0.0, 0.5, 0.0, 0.5), (0.5, 0.0, 0.0, 0.0),\n (0.5, 0.5, 0.5, 0.0)],\n (1.0, 1.0, 0.5, 0.5): [(1.0, 1.0, 0.5, 1.0), (1, 1, 0, 1),\n (1.0, 1.0, 1.0, 0.5),\n (1.0, 0.5, 0.5, 0.5), (1, 1, 1, 0),\n (1.0, 1.0, 0.5, 0.0),\n (1.0, 1.0, 0.0, 0.5), (1, 1, 0, 0),\n (1, 1, 1, 1), (0.5, 1.0, 0.5, 0.5),\n (0.5, 0.5, 0.5, 0.5),\n (0.75, 0.75, 0.75, 0.75),\n (0.75, 0.75, 0.25, 0.25),\n (0.75, 0.75, 0.75, 0.25),\n (0.75, 0.75, 0.25, 0.75)],\n (0.25, 0.25, 0.25, 0.75): [(0.0, 0.0, 0.5, 1.0),\n (0.0, 0.5, 0.0, 1.0),\n (0.5, 0.0, 0.0, 1.0),\n (0.5, 0.5, 0.5, 1.0),\n (0, 0, 0, 1),\n (0.0, 0.5, 0.5, 1.0),\n (0.5, 0.0, 0.5, 1.0),\n (0.5, 0.5, 0.0, 1.0),\n (0.0, 0.0, 0.0, 0.5),\n (0.0, 0.0, 0.5, 0.5),\n (0.0, 0.5, 0.5, 0.5),\n (0.0, 0.5, 0.0, 0.5),\n (0.5, 0.0, 0.5, 0.5),\n (0.5, 0.5, 0.0, 0.5),\n (0.5, 0.5, 0.5, 0.5),\n (0.5, 0.0, 0.0, 0.5)]}\n\n init_triangulation(4, 1, check, nn_checks)","def _build(self):\n ary = np.zeros( (3,3,3), float )\n ary[0,0,0] = ary[1,1,1] = ary[0,1,2] = ary[1,0,2] = 1.\n ary[0,2,0] = ary[0,2,2] = ary[2,0,0] = ary[2,0,2] = 0.5\n ary[1,2,1] = ary[1,2,2] = ary[2,1,1] = ary[2,1,2] = 0.5\n ary[2,2,0] = ary[2,2,1] = 0.25\n ary[2,2,2] = 0.5\n return ary","def six_cubed():\n print(math.pow(6, 3))","def board_state_to_nn_input(self, state):\n # res = np.array([(state == self.side).astype(int),\n # (state == Board.other_side(self.side)).astype(int),\n # (state == EMPTY).astype(int)])\n # res = res.reshape(3, 3, 3)\n # res = np.transpose(res, [1, 2, 0])\n res = np.array(state)\n return res","def homothick():\n return se2hmt(binary([[1,1,1],\n [0,0,0],\n [0,0,0]]),\n binary([[0,0,0],\n [0,1,0],\n [1,1,1]]))","def test_4_2_5D_cube_splits(self):\n check = [(0, 0, 0, 0, 0), (1, 1, 1, 1, 1), (1, 0, 0, 0, 0),\n (1, 1, 0, 0, 0), (1, 1, 1, 0, 0), (1, 1, 1, 1, 0),\n (1, 1, 1, 0, 1), (1, 1, 0, 1, 0), (1, 1, 0, 1, 1),\n (1, 1, 0, 0, 1), (1, 0, 1, 0, 0), (1, 0, 1, 1, 0),\n (1, 0, 1, 1, 1), (1, 0, 1, 0, 1), (1, 0, 0, 1, 0),\n (1, 0, 0, 1, 1), (1, 0, 0, 0, 1), (0, 1, 0, 0, 0),\n (0, 1, 1, 0, 0), (0, 1, 1, 1, 0), (0, 1, 1, 1, 1),\n (0, 1, 1, 0, 1), (0, 1, 0, 1, 0), (0, 1, 0, 1, 1),\n (0, 1, 0, 0, 1), (0, 0, 1, 0, 0), (0, 0, 1, 1, 0),\n (0, 0, 1, 1, 1), (0, 0, 1, 0, 1), (0, 0, 0, 1, 0),\n (0, 0, 0, 1, 1), (0, 0, 0, 0, 1), (0.5, 0.5, 0.5, 0.5, 0.5),\n (0.0, 0.5, 0.5, 0.5, 0.5), (0.0, 0.0, 0.5, 0.5, 0.5),\n (0.0, 0.0, 0.0, 0.5, 0.5), (0.0, 0.0, 0.0, 0.0, 0.5),\n (0.0, 0.0, 0.0, 0.5, 0.0), (0.0, 0.0, 0.5, 0.0, 0.5),\n (0.0, 0.0, 0.5, 0.0, 0.0), (0.0, 0.0, 0.5, 0.5, 0.0),\n (0.0, 0.5, 0.0, 0.5, 0.5), (0.0, 0.5, 0.0, 0.0, 0.5),\n (0.0, 0.5, 0.0, 0.0, 0.0), (0.0, 0.5, 0.0, 0.5, 0.0),\n (0.0, 0.5, 0.5, 0.0, 0.5), (0.0, 0.5, 0.5, 0.0, 0.0),\n (0.0, 0.5, 0.5, 0.5, 0.0), (0.5, 0.0, 0.5, 0.5, 0.5),\n (0.5, 0.0, 0.0, 0.5, 0.5), (0.5, 0.0, 0.0, 0.0, 0.5),\n (0.5, 0.0, 0.0, 0.0, 0.0), (0.5, 0.0, 0.0, 0.5, 0.0),\n (0.5, 0.0, 0.5, 0.0, 0.5), (0.5, 0.0, 0.5, 0.0, 0.0),\n (0.5, 0.0, 0.5, 0.5, 0.0), (0.5, 0.5, 0.0, 0.5, 0.5),\n (0.5, 0.5, 0.0, 0.0, 0.5), (0.5, 0.5, 0.0, 0.0, 0.0),\n (0.5, 0.5, 0.0, 0.5, 0.0), (0.5, 0.5, 0.5, 0.0, 0.5),\n (0.5, 0.5, 0.5, 0.0, 0.0), (0.5, 0.5, 0.5, 0.5, 0.0),\n (0.25, 0.25, 0.25, 0.25, 0.25), (1.0, 0.5, 0.5, 0.5, 0.5),\n (1.0, 1.0, 0.5, 0.5, 0.5), (1.0, 1.0, 1.0, 0.5, 0.5),\n (1.0, 1.0, 1.0, 1.0, 0.5), (1.0, 1.0, 1.0, 0.5, 1.0),\n (1.0, 1.0, 0.5, 1.0, 0.5), (1.0, 1.0, 0.5, 1.0, 1.0),\n (1.0, 1.0, 0.5, 0.5, 1.0), (1.0, 0.5, 1.0, 0.5, 0.5),\n (1.0, 0.5, 1.0, 1.0, 0.5), (1.0, 0.5, 1.0, 1.0, 1.0),\n (1.0, 0.5, 1.0, 0.5, 1.0), (1.0, 0.5, 0.5, 1.0, 0.5),\n (1.0, 0.5, 0.5, 1.0, 1.0), (1.0, 0.5, 0.5, 0.5, 1.0),\n (0.5, 1.0, 0.5, 0.5, 0.5), (0.5, 1.0, 1.0, 0.5, 0.5),\n (0.5, 1.0, 1.0, 1.0, 0.5), (0.5, 1.0, 1.0, 1.0, 1.0),\n (0.5, 1.0, 1.0, 0.5, 1.0), (0.5, 1.0, 0.5, 1.0, 0.5),\n (0.5, 1.0, 0.5, 1.0, 1.0), (0.5, 1.0, 0.5, 0.5, 1.0),\n (0.5, 0.5, 1.0, 0.5, 0.5), (0.5, 0.5, 1.0, 1.0, 0.5),\n (0.5, 0.5, 1.0, 1.0, 1.0), (0.5, 0.5, 1.0, 0.5, 1.0),\n (0.5, 0.5, 0.5, 1.0, 0.5), (0.5, 0.5, 0.5, 1.0, 1.0),\n (0.5, 0.5, 0.5, 0.5, 1.0), (0.75, 0.75, 0.75, 0.75, 0.75),\n (1.0, 0.0, 0.5, 0.5, 0.5), (1.0, 0.0, 0.0, 0.5, 0.5),\n (1.0, 0.0, 0.0, 0.0, 0.5), (1.0, 0.0, 0.0, 0.5, 0.0),\n (1.0, 0.0, 0.5, 0.0, 0.5), (1.0, 0.0, 0.5, 0.0, 0.0),\n (1.0, 0.0, 0.5, 0.5, 0.0), (1.0, 0.5, 0.0, 0.5, 0.5),\n (1.0, 0.5, 0.0, 0.0, 0.5), (1.0, 0.5, 0.0, 0.0, 0.0),\n (1.0, 0.5, 0.0, 0.5, 0.0), (1.0, 0.5, 0.5, 0.0, 0.5),\n (1.0, 0.5, 0.5, 0.0, 0.0), (1.0, 0.5, 0.5, 0.5, 0.0),\n (0.75, 0.25, 0.25, 0.25, 0.25), (1.0, 1.0, 0.0, 0.5, 0.5),\n (1.0, 1.0, 0.0, 0.0, 0.5), (1.0, 1.0, 0.0, 0.5, 0.0),\n (1.0, 1.0, 0.5, 0.0, 0.5), (1.0, 1.0, 0.5, 0.0, 0.0),\n (1.0, 1.0, 0.5, 0.5, 0.0), (0.5, 1.0, 0.0, 0.5, 0.5),\n (0.5, 1.0, 0.0, 0.0, 0.5), (0.5, 1.0, 0.0, 0.0, 0.0),\n (0.5, 1.0, 0.0, 0.5, 0.0), (0.5, 1.0, 0.5, 0.0, 0.5),\n (0.5, 1.0, 0.5, 0.0, 0.0), (0.5, 1.0, 0.5, 0.5, 0.0),\n (0.75, 0.75, 0.25, 0.25, 0.25), (1.0, 1.0, 1.0, 0.0, 0.5),\n (1.0, 1.0, 1.0, 0.5, 0.0), (1.0, 0.5, 1.0, 0.0, 0.5),\n (1.0, 0.5, 1.0, 0.0, 0.0), (1.0, 0.5, 1.0, 0.5, 0.0),\n (0.5, 1.0, 1.0, 0.0, 0.5), (0.5, 1.0, 1.0, 0.0, 0.0),\n (0.5, 1.0, 1.0, 0.5, 0.0), (0.5, 0.5, 1.0, 0.0, 0.5),\n (0.5, 0.5, 1.0, 0.0, 0.0), (0.5, 0.5, 1.0, 0.5, 0.0),\n (0.75, 0.75, 0.75, 0.25, 0.25), (1.0, 1.0, 0.5, 1.0, 0.0),\n (1.0, 0.5, 1.0, 1.0, 0.0), (1.0, 0.5, 0.5, 1.0, 0.0),\n (0.5, 1.0, 1.0, 1.0, 0.0), (0.5, 1.0, 0.5, 1.0, 0.0),\n (0.5, 0.5, 1.0, 1.0, 0.0), (0.5, 0.5, 0.5, 1.0, 0.0),\n (0.75, 0.75, 0.75, 0.75, 0.25), (1.0, 1.0, 0.5, 0.0, 1.0),\n (1.0, 0.5, 1.0, 0.0, 1.0), (1.0, 0.5, 0.5, 0.0, 1.0),\n (0.5, 1.0, 1.0, 0.0, 1.0), (0.5, 1.0, 0.5, 0.0, 1.0),\n (0.5, 0.5, 1.0, 0.0, 1.0), (0.5, 0.5, 0.5, 0.0, 1.0),\n (0.75, 0.75, 0.75, 0.25, 0.75), (1.0, 1.0, 0.0, 1.0, 0.5),\n (1.0, 0.5, 0.0, 1.0, 0.5), (1.0, 0.5, 0.0, 1.0, 0.0),\n (0.5, 1.0, 0.0, 1.0, 0.5), (0.5, 1.0, 0.0, 1.0, 0.0),\n (0.5, 0.5, 0.0, 1.0, 0.5), (0.5, 0.5, 0.0, 1.0, 0.0),\n (0.75, 0.75, 0.25, 0.75, 0.25), (1.0, 1.0, 0.0, 0.5, 1.0),\n (1.0, 0.5, 0.0, 1.0, 1.0), (1.0, 0.5, 0.0, 0.5, 1.0),\n (0.5, 1.0, 0.0, 1.0, 1.0), (0.5, 1.0, 0.0, 0.5, 1.0),\n (0.5, 0.5, 0.0, 1.0, 1.0), (0.5, 0.5, 0.0, 0.5, 1.0),\n (0.75, 0.75, 0.25, 0.75, 0.75), (1.0, 0.5, 0.0, 0.0, 1.0),\n (0.5, 1.0, 0.0, 0.0, 1.0), (0.5, 0.5, 0.0, 0.0, 1.0),\n (0.75, 0.75, 0.25, 0.25, 0.75), (1.0, 0.0, 1.0, 0.5, 0.5),\n (1.0, 0.0, 1.0, 0.0, 0.5), (1.0, 0.0, 1.0, 0.5, 0.0),\n (0.5, 0.0, 1.0, 0.5, 0.5), (0.5, 0.0, 1.0, 0.0, 0.5),\n (0.5, 0.0, 1.0, 0.0, 0.0), (0.5, 0.0, 1.0, 0.5, 0.0),\n (0.75, 0.25, 0.75, 0.25, 0.25), (1.0, 0.0, 1.0, 1.0, 0.5),\n (1.0, 0.0, 0.5, 1.0, 0.5), (1.0, 0.0, 0.5, 1.0, 0.0),\n (0.5, 0.0, 1.0, 1.0, 0.5), (0.5, 0.0, 1.0, 1.0, 0.0),\n (0.5, 0.0, 0.5, 1.0, 0.5), (0.5, 0.0, 0.5, 1.0, 0.0),\n (0.75, 0.25, 0.75, 0.75, 0.25), (1.0, 0.0, 1.0, 0.5, 1.0),\n (1.0, 0.0, 0.5, 1.0, 1.0), (1.0, 0.0, 0.5, 0.5, 1.0),\n (0.5, 0.0, 1.0, 1.0, 1.0), (0.5, 0.0, 1.0, 0.5, 1.0),\n (0.5, 0.0, 0.5, 1.0, 1.0), (0.5, 0.0, 0.5, 0.5, 1.0),\n (0.75, 0.25, 0.75, 0.75, 0.75), (1.0, 0.0, 0.5, 0.0, 1.0),\n (0.5, 0.0, 1.0, 0.0, 1.0), (0.5, 0.0, 0.5, 0.0, 1.0),\n (0.75, 0.25, 0.75, 0.25, 0.75), (1.0, 0.0, 0.0, 1.0, 0.5),\n (0.5, 0.0, 0.0, 1.0, 0.5), (0.5, 0.0, 0.0, 1.0, 0.0),\n (0.75, 0.25, 0.25, 0.75, 0.25), (1.0, 0.0, 0.0, 0.5, 1.0),\n (0.5, 0.0, 0.0, 1.0, 1.0), (0.5, 0.0, 0.0, 0.5, 1.0),\n (0.75, 0.25, 0.25, 0.75, 0.75), (0.5, 0.0, 0.0, 0.0, 1.0),\n (0.75, 0.25, 0.25, 0.25, 0.75), (0.0, 1.0, 0.5, 0.5, 0.5),\n (0.0, 1.0, 0.0, 0.5, 0.5), (0.0, 1.0, 0.0, 0.0, 0.5),\n (0.0, 1.0, 0.0, 0.5, 0.0), (0.0, 1.0, 0.5, 0.0, 0.5),\n (0.0, 1.0, 0.5, 0.0, 0.0), (0.0, 1.0, 0.5, 0.5, 0.0),\n (0.25, 0.75, 0.25, 0.25, 0.25), (0.0, 1.0, 1.0, 0.5, 0.5),\n (0.0, 1.0, 1.0, 0.0, 0.5), (0.0, 1.0, 1.0, 0.5, 0.0),\n (0.0, 0.5, 1.0, 0.5, 0.5), (0.0, 0.5, 1.0, 0.0, 0.5),\n (0.0, 0.5, 1.0, 0.0, 0.0), (0.0, 0.5, 1.0, 0.5, 0.0),\n (0.25, 0.75, 0.75, 0.25, 0.25), (0.0, 1.0, 1.0, 1.0, 0.5),\n (0.0, 1.0, 0.5, 1.0, 0.5), (0.0, 1.0, 0.5, 1.0, 0.0),\n (0.0, 0.5, 1.0, 1.0, 0.5), (0.0, 0.5, 1.0, 1.0, 0.0),\n (0.0, 0.5, 0.5, 1.0, 0.5), (0.0, 0.5, 0.5, 1.0, 0.0),\n (0.25, 0.75, 0.75, 0.75, 0.25), (0.0, 1.0, 1.0, 0.5, 1.0),\n (0.0, 1.0, 0.5, 1.0, 1.0), (0.0, 1.0, 0.5, 0.5, 1.0),\n (0.0, 0.5, 1.0, 1.0, 1.0), (0.0, 0.5, 1.0, 0.5, 1.0),\n (0.0, 0.5, 0.5, 1.0, 1.0), (0.0, 0.5, 0.5, 0.5, 1.0),\n (0.25, 0.75, 0.75, 0.75, 0.75), (0.0, 1.0, 0.5, 0.0, 1.0),\n (0.0, 0.5, 1.0, 0.0, 1.0), (0.0, 0.5, 0.5, 0.0, 1.0),\n (0.25, 0.75, 0.75, 0.25, 0.75), (0.0, 1.0, 0.0, 1.0, 0.5),\n (0.0, 0.5, 0.0, 1.0, 0.5), (0.0, 0.5, 0.0, 1.0, 0.0),\n (0.25, 0.75, 0.25, 0.75, 0.25), (0.0, 1.0, 0.0, 0.5, 1.0),\n (0.0, 0.5, 0.0, 1.0, 1.0), (0.0, 0.5, 0.0, 0.5, 1.0),\n (0.25, 0.75, 0.25, 0.75, 0.75), (0.0, 0.5, 0.0, 0.0, 1.0),\n (0.25, 0.75, 0.25, 0.25, 0.75), (0.0, 0.0, 1.0, 0.5, 0.5),\n (0.0, 0.0, 1.0, 0.0, 0.5), (0.0, 0.0, 1.0, 0.5, 0.0),\n (0.25, 0.25, 0.75, 0.25, 0.25), (0.0, 0.0, 1.0, 1.0, 0.5),\n (0.0, 0.0, 0.5, 1.0, 0.5), (0.0, 0.0, 0.5, 1.0, 0.0),\n (0.25, 0.25, 0.75, 0.75, 0.25), (0.0, 0.0, 1.0, 0.5, 1.0),\n (0.0, 0.0, 0.5, 1.0, 1.0), (0.0, 0.0, 0.5, 0.5, 1.0),\n (0.25, 0.25, 0.75, 0.75, 0.75), (0.0, 0.0, 0.5, 0.0, 1.0),\n (0.25, 0.25, 0.75, 0.25, 0.75), (0.0, 0.0, 0.0, 1.0, 0.5),\n (0.25, 0.25, 0.25, 0.75, 0.25), (0.0, 0.0, 0.0, 0.5, 1.0),\n (0.25, 0.25, 0.25, 0.75, 0.75), (0.25, 0.25, 0.25, 0.25, 0.75)]\n\n nn_checks = {(1, 1, 1, 1, 1): [(1.0, 1.0, 1.0, 0.5, 1.0),\n (1.0, 1.0, 0.5, 1.0, 1.0),\n (1.0, 0.5, 0.5, 0.5, 0.5),\n (1.0, 0.5, 1.0, 1.0, 0.5),\n (0.5, 0.5, 1.0, 1.0, 1.0),\n (1.0, 0.5, 0.5, 1.0, 0.5),\n (1.0, 0.5, 1.0, 0.5, 0.5),\n (0.5, 0.5, 0.5, 0.5, 1.0),\n (0.5, 0.5, 1.0, 0.5, 1.0),\n (0.5, 0.5, 0.5, 1.0, 1.0),\n (0.5, 1.0, 0.5, 0.5, 0.5),\n (0.5, 1.0, 1.0, 1.0, 0.5),\n (0.5, 1.0, 1.0, 0.5, 0.5),\n (0.5, 1.0, 0.5, 1.0, 0.5),\n (1.0, 1.0, 1.0, 0.5, 0.5),\n (1.0, 1.0, 0.5, 1.0, 0.5),\n (1.0, 1.0, 0.5, 0.5, 0.5),\n (1.0, 1.0, 1.0, 1.0, 0.5),\n (1.0, 1.0, 0.5, 0.5, 1.0),\n (1.0, 0.5, 1.0, 0.5, 1.0),\n (1.0, 0.5, 0.5, 1.0, 1.0),\n (0.5, 1.0, 0.5, 0.5, 1.0),\n (0.5, 0.5, 1.0, 0.5, 0.5),\n (1.0, 0.5, 0.5, 0.5, 1.0),\n (1.0, 0.5, 1.0, 1.0, 1.0),\n (0.5, 0.5, 0.5, 1.0, 0.5),\n (0.75, 0.75, 0.75, 0.75, 0.75),\n (0.5, 0.5, 1.0, 1.0, 0.5),\n (0.5, 1.0, 1.0, 1.0, 1.0),\n (0.5, 1.0, 1.0, 0.5, 1.0),\n (0.5, 1.0, 0.5, 1.0, 1.0)],\n (0.25, 0.75, 0.75, 0.75, 0.25): [(0.5, 1.0, 1.0, 1.0, 0.0),\n (0.5, 0.5, 0.5, 1.0, 0.5),\n (0, 1, 1, 1, 0),\n (0.5, 1.0, 0.5, 0.5, 0.5),\n (0.5, 1.0, 1.0, 1.0, 0.5),\n (0.0, 1.0, 0.5, 0.5, 0.5),\n (0.0, 1.0, 1.0, 1.0, 0.5),\n (0.5, 1.0, 0.5, 1.0, 0.5),\n (0.0, 1.0, 0.5, 1.0, 0.5),\n (0.5, 1.0, 1.0, 0.5, 0.5),\n (0.0, 1.0, 1.0, 0.5, 0.5),\n (0.0, 1.0, 1.0, 0.5, 0.0),\n (0.0, 1.0, 0.5, 1.0, 0.0),\n (0.5, 1.0, 1.0, 0.5, 0.0),\n (0.5, 1.0, 0.5, 1.0, 0.0),\n (0.5, 1.0, 0.5, 0.5, 0.0),\n (0.0, 1.0, 0.5, 0.5, 0.0),\n (0.5, 0.5, 1.0, 0.5, 0.0),\n (0.5, 0.5, 0.5, 1.0, 0.0),\n (0.0, 0.5, 1.0, 0.5, 0.5),\n (0.0, 0.5, 0.5, 1.0, 0.5),\n (0.0, 0.5, 1.0, 0.5, 0.0),\n (0.0, 0.5, 1.0, 1.0, 0.5),\n (0.5, 0.5, 1.0, 1.0, 0.0),\n (0.0, 0.5, 0.5, 0.5, 0.5),\n (0.5, 0.5, 0.5, 0.5, 0.0),\n (0.0, 0.5, 0.5, 1.0, 0.0),\n (0.0, 0.5, 0.5, 0.5, 0.0),\n (0.0, 0.5, 1.0, 1.0, 0.0),\n (0.5, 0.5, 0.5, 0.5, 0.5),\n (0.5, 0.5, 1.0, 1.0, 0.5),\n (\n 0.5, 0.5, 1.0, 0.5, 0.5)],\n (0.0, 0.0, 1.0, 0.5, 1.0): [(0.5, 0.0, 0.5, 0.5, 1.0),\n (0.0, 0.5, 0.5, 0.5, 1.0),\n (0.5, 0.5, 0.5, 0.5, 1.0),\n (0.0, 0.0, 0.5, 0.5, 1.0),\n (0, 0, 1, 1, 1),\n (0.5, 0.5, 1.0, 0.5, 1.0),\n (0.5, 0.0, 1.0, 0.5, 1.0),\n (0.0, 0.5, 1.0, 0.5, 1.0),\n (0, 0, 1, 0, 1),\n (0.5, 0.0, 1.0, 0.5, 0.5),\n (0.0, 0.5, 1.0, 0.5, 0.5),\n (0.5, 0.5, 1.0, 0.5, 0.5),\n (0.0, 0.0, 1.0, 0.5, 0.5),\n (0.5, 0.5, 0.5, 0.5, 0.5),\n (0.0, 0.0, 0.5, 0.5, 0.5),\n (0.25, 0.25, 0.75, 0.75, 0.75),\n (0.5, 0.0, 0.5, 0.5, 0.5),\n (0.0, 0.5, 0.5, 0.5, 0.5), (\n 0.25, 0.25, 0.75, 0.25, 0.75)]}\n\n init_triangulation(5, 1, check, nn_checks)","def _factorRepresentation(self, character, size):\n # Create the character matrix space\n rows = 2*size + 3\n cols = size + 2\n char_matrix = [[_SPACE]*cols for i in range(rows)] \n\n # Creates the constituent element\n horizontal_line = [_H_LINE]*size\n vertical_line = [_V_LINE]*size\n\n # Get the points to construct the number with the elements\n horizontal_points = self._getHLinesPoints(character, size)\n vertical_points = self._getVLinesPoints(character, size)\n\n for x, y in horizontal_points:\n char_matrix[x][y:y+size] = horizontal_line\n\n for x, y in vertical_points:\n for i in range(size):\n char_matrix[x+i][y] = vertical_line[i]\n\n return char_matrix","def reconstructImage(self,arr):\n\t\tarr = arr * 256\n\t\tarr = np.array(np.round(arr),dtype=np.uint8)\n\t\t#arr = np.array(arr,dtype=np.uint8)\n\n\t\t# We need to transpose the array because we flatten X by columns\n\t\t#arr = arr.T\n\t\t#a = arr.reshape((self.width, self.height,3))\n\t\t\n\t\tif self.mode == 'L':\n\t\t\ta = arr.reshape((self.width, self.height))\n\t\telse:\n\t\t\ta = arr.reshape((self.width, self.height,3))\n\n\t\t#a = arr.reshape((3,self.width, self.height))\t\t\n\t\t#a = arr.transpose(0, 3, 1, 2)\n\n\t\tim = Image.fromarray(a,mode=self.mode)\n\n\t\treturn im","def transpose():","def test_Pad3D6():\n input_shape = (1, 1, 2, 3, 2)\n # pad = np.array([1, 0, 1, 2, 1, 0]).astype('int32')\n pad = [1, 0, 1, 2, 1, 0]\n mode = \"constant\"\n res = [\n [\n [\n [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]],\n [[0, 0, 0], [0, 1, 2], [0, 3, 4], [0, 5, 6], [0, 0, 0], [0, 0, 0]],\n [[0, 0, 0], [0, 7, 8], [0, 9, 10], [0, 11, 12], [0, 0, 0], [0, 0, 0]],\n ]\n ]\n ]\n data = np.arange(np.prod(input_shape)).reshape(input_shape) + 1\n obj.run(res=res, padding=pad, mode=mode, data_format=\"NCDHW\", data=data)","def cart2hom(arr):\n if arr.ndim == 1:\n return np.hstack([arr, 1])\n return np.asarray(np.vstack([arr, np.ones(arr.shape[1])]))","def auto_convert(boxes: Type[Union[Tensor, np.ndarray]], w: int, h: int):\n\n if boxes.max() < 2:\n # to pixel coordinates\n boxes[:, 0::2] *= w\n boxes[:, 1::2] *= h\n else:\n # to normalized 0-1\n boxes[:, 0::2] /= w\n boxes[:, 1::2] /= h\n return boxes","def fisher_factor_inner_shape(self) -> Sequence[int]:\n pass","def tdim3(dim3):\n return TransformedDimension(Compose([], dim3.type), dim3)","def Solution(self):\n self.solver.check()\n m = self.solver.model()\n answer = [[0] * self.width for i in range(self.height)]\n for y in range(self.height):\n for x in range(self.width):\n answer[y][x] = int(str(m[self.grid[(x, y)]]))\n return answer","def c_matrix(x1,x2,x3):\n\tC = np.array([\t[\t2*(x2-x1), \t\t(x2-x1), \t\t\t0\t\t\t], \\\n\t\t\t\t\t[\t(x2-x1), \t\t2*(x3-x1), \t\t(x3-x2)\t\t], \\\n\t\t\t\t\t[\t0,\t\t\t\t(x3-x2),\t\t2*(x3-x2)\t] \t], \\\n\t\t\t\t\tfloat)\n\treturn(C)","def rot6d_to_rotmat(x):\n x = x.view(-1,3,2)\n a1 = x[:, :, 0]\n a2 = x[:, :, 1]\n b1 = F.normalize(a1)\n b2 = F.normalize(a2 - torch.einsum('bi,bi->b', b1, a2).unsqueeze(-1) * b1)\n b3 = torch.cross(b1, b2)\n return torch.stack((b1, b2, b3), dim=-1)","def check3x3(self, board):\n\t\t\t# print \"This is check3x3\"\n\t\t\t# for i in xrange(0,9):\n\t\t\t# \tprint board[i],\n\t\t\t# \tif i%3 == 2:\n\t\t\t# \t\tprint\n\n\t\t\tvalue = self.finddraw(board)\n\t\t\tif(value[1] != -1):\n\t\t\t\treturn value[1]\n\t\t\t#Rows\n\t\t\tfor i in range(0,9):\n\t\t\t\tif(i%3 == 0):\n\t\t\t\t\tif (board[i] == 'x' and board[i+1] == 'x' and board[i+2] == 'x'):\n\t\t\t\t\t\tif(self.symbol == 'x'):\n\t\t\t\t\t\t\treturn 4\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\treturn 0\n\t\n\t\t\t\t\tif (board[i] == 'o' and board[i+1] == 'o' and board[i+2] == 'o'):\n\t\t\t\t\t\tif(self.symbol == 'o'):\n\t\t\t\t\t\t\treturn 4\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\treturn 0\n\n\t\t\t#Colomns\n\t\t\tfor i in range(0,3):\n\t\t\t\tif(i/3 == 0):\n\t\t\t\t\tif (board[i] == 'x' and board[i+3] == 'x' and board[i+6] == 'x'):\n\t\t\t\t\t\tif(self.symbol == 'x'):\n\t\t\t\t\t\t\treturn 4\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\treturn 0\n\t\n\t\t\t\t\tif (board[i] == 'o' and board[i+3] == 'o' and board[i+6] == 'o'):\n\t\t\t\t\t\tif(self.symbol == 'o'):\n\t\t\t\t\t\t\treturn 4\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\treturn 0\n\n\t\t\tcount = 0\n\t\t\tsavei = 0\n\t\t\tvalue = -1\n\t\t\tfor i in range(0,9):\n\t\t\t\t\tif(board[i] != '-'):\n\t\t\t\t\t\tcount += 1\n\t\t\t\t\telse:\n\t\t\t\t\t\tsavei = i\n\n\t\t\tif(count == 9):\n\t\t\t\treturn 1\n\t\t\tif(count == 8):\n\t\t\t\tif(self.symbol == 'x'):\n\t\t\t\t\tboard[savei] = 'o'\n\t\t\t\t\tvalue = self.finddraw(board)\n\t\t\t\tif(self.symbol == 'o'):\n\t\t\t\t\tboard[savei] = 'x'\n\t\t\t\t\tvalue = self.finddraw(board)\n\t\t\t\tif(value[1] > -1):\n\t\t\t\t\tif(value[1] == 1):\n\t\t\t\t\t\treturn 1\n\t\t\t\t\tif(value[1] == 4):\n\t\t\t\t\t\treturn 2\n\n\t\t\treturn -1","def test_round_trip_conversion(self):\n\n for num_qubits in range(1, 5):\n # Since we know the implementations don't depend on well-formed input data,\n # just generate a random d^2 x d^2 matrix as test data for all conversions.\n dim = 2**(2 * num_qubits)\n mat = np.random.rand(dim, dim)\n assert_allclose(mat, vec2mat(mat2vec(mat)))\n assert_allclose(liou2choi(choi2liou(mat)), mat)\n assert_allclose(choi2liou(liou2choi(mat)), mat)","def coupling_6j((J1,J2,J3),(J4,J5,J6)):\n cj6=pygsl.sf.coupling_6j(int(2*J1),int(2*J2), int(2*J3), int(2*J4),int(2*J5), int(2*J6))[0]\n cj6=(-1)**(J1+J2+J4+J5)*hat(J3)*hat(J6)*cj6 \n return cj6","def cube_array(self):\n cube_sides = {}\n\n for side in SIDES:\n cube_sides[side] = []\n \n # Todo Break this loop into helper functions for clarity and simplicity\n for coord in COORDS_3:\n for cubie in self.cubies:\n # Making sure that the cubes cubies are processed in the correct order\n if np.array_equal(cubie.coordinates, coord): \n \n \n for side in SIDES:\n if cubie.in_side(side):\n for face in cubie.faces:\n \n # Checking that the face of the cubie has the same norm as the side we are processing\n if np.array_equal(face.norm, NORMS[side]):\n cube_sides[side].append(face.colour)\n\n new_list = [cube_sides[\"U\"], cube_sides[\"F\"], reversal(cube_sides[\"R\"]), reversal(cube_sides[\"B\"]),\n cube_sides[\"L\"], reversal(cube_sides[\"D\"])]\n \n final_list = [nine_to_3x3(side) for side in new_list]\n return final_list","def ggn_factor_inner_shape(self) -> Sequence[int]:\n pass","def mixing_matrix_2nu(sth):\n cth = sqrt(1.0-sth*sth)\n\n U00 = cth\n U01 = sth\n U10 = -sth\n U11 = cth\n\n return [[U00,U01],[U10,U11]]","def _to_b_c_L_h_w(x, x_shape):\r\n x = tf.reshape(x, (-1,\r\n int(x_shape[1]),\r\n int(x_shape[2]),\r\n int(x_shape[3]),\r\n int(x_shape[4])))\r\n return x","def atlas6():\n\n Atlas = graph_atlas_g()[0:208] # 208\n # remove isolated nodes, only connected graphs are left\n U = nx.Graph() # graph for union of all graphs in atlas\n for G in Atlas:\n zerodegree = [n for n in G if G.degree(n) == 0]\n for n in zerodegree:\n G.remove_node(n)\n U = nx.disjoint_union(U, G)\n\n # iterator of graphs of all connected components\n C = (U.subgraph(c) for c in nx.connected_components(U))\n\n UU = nx.Graph()\n # do quick isomorphic-like check, not a true isomorphism checker\n nlist = [] # list of nonisomorphic graphs\n for G in C:\n # check against all nonisomorphic graphs so far\n if not iso(G, nlist):\n nlist.append(G)\n UU = nx.disjoint_union(UU, G) # union the nonisomorphic graphs\n return UU","def rot6d_to_rotmat(x):\n x = x.view(-1, 3, 2)\n a1 = x[:, :, 0]\n a2 = x[:, :, 1]\n b1 = F.normalize(a1)\n b2 = F.normalize(a2 - torch.einsum('bi,bi->b', b1, a2).unsqueeze(-1) * b1)\n b3 = torch.cross(b1, b2)\n return torch.stack((b1, b2, b3), dim=-1)","def rot6d_to_rotmat(x):\n x = x.view(-1, 3, 2)\n a1 = x[:, :, 0]\n a2 = x[:, :, 1]\n b1 = F.normalize(a1)\n b2 = F.normalize(a2 - torch.einsum('bi,bi->b', b1, a2).unsqueeze(-1) * b1)\n b3 = torch.cross(b1, b2)\n return torch.stack((b1, b2, b3), dim=-1)","def three_d6() -> list:\n rolls: List[int] = []\n for i in range(1, 7):\n roll: int = multi_die(3, 6)\n rolls.append(roll)\n return rolls","def checksumToBoard(self):\n\t\treal_board = [[ '.' for x in range(9)] for x in range(9)] \n\n\t\txstart = 0\n\t\txend = 3\n\t\tystart = 0\n\t\tyend = 3\n\n\t\tfor i in range(0,3):\n\t\t\tself.makeBoard(i,real_board,xstart,xend,ystart,yend)\n\t\t\tystart += 3\n\t\t\tyend += 3\n\n\t\n\t\txstart = 3\n\t\txend = 6\n\t\tystart = 0\n\t\tyend = 3\n\t\tfor i in range(3,6):\n\t\t\tself.makeBoard(i,real_board,xstart,xend,ystart,yend)\n\t\t\tystart += 3\n\t\t\tyend += 3\n\n\n\t\txstart = 6\n\t\txend = 9\n\t\tystart = 0\n\t\tyend = 3\n\t\tfor i in range(6,9):\n\t\t\tself.makeBoard(i,real_board,xstart,xend,ystart,yend)\n\t\t\tystart += 3\n\t\t\tyend += 3\n\n\t\t# print 'Board created from checksum values:'\n\t\t# for i in range(0,9):\n\t\t# \tfor j in range(0,9):\n\t\t# \t\tprint real_board[i][j],\n\t\t# \t\tif j%3 == 2:\n\t\t# \t\t\tprint \"|\",\n\t\t# \tprint\n\t\t# \tif i%3 == 2:\n\t\t# \t\tprint \" _ _ _ _ _ _ _ _ _\"\n\n\t\treturn real_board","def convgridone(a, pi, fi, gcf, v):\n \tsx, sy= gcf[0][0].shape[0]/2, gcf[0][0].shape[1]/2","def subpel_conv3x3(in_ch, out_ch, r=1):\n # return nn.Sequential(\n # nn.Conv2d(in_ch, out_ch * r**2, kernel_size=3, padding=1),\n # nn.PixelShuffle(r))\n # change\n return nn.SequentialCell([nn.Conv2d(in_ch, out_ch * r**2, kernel_size=3, padding=1),\n # # TODO BY J : no pixel shuffle in mindspore\n # nn.PixelShuffle(r))\n ])","def convertToRow(initialState):\n size = np.sqrt(len(initialState))\n rowform = ''\n for i in range(int(size)):\n j = i;\n while j < len(initialState):\n rowform += initialState[j]\n j += 3\n return rowform","def _change_box_format(self, boxes):\n boxes[..., 0] = boxes[..., 0]\n boxes[..., 1] = boxes[..., 1]\n boxes[..., 2] = boxes[..., 2]\n boxes[..., 3] = boxes[..., 1] + boxes[..., 3]\n boxes[..., 4] = boxes[..., 2] + boxes[..., 4]\n return boxes","def __set_TP(self):\t\n\t\tfor r in range(8,self.size - 8):\n\t\t\tself.matrix[r][6] = int(r % 2 == 0)\n\n\t\tfor c in range(8,self.size - 8):\n\t\t\tself.matrix[6][c] = int(c % 2 == 0)\n\n\t\tself.matrix[self.size-8][8] = 1","def _mat3(self):\n if self.frame.orientation == HillFrame.DEFAULT_ORIENTATION:\n return np.identity(3)\n else:\n return self.QSW2TNW","def conver1D(array):\n l = array.shape\n total = np.zeros((0, l[1] * l[2]), dtype=np.float32)\n i = 0\n for i in range(24):\n tempData = array[i]\n array1D = []\n for x in tempData:\n for s in x:\n array1D.append(s)\n total = np.insert(total, i, array1D, axis=0)\n return total","def convertBoard(self):\n \n board = \"\"\n \n for m in self.squares:\n board += str(convertMarker(m)) + \" \"\n \n return board","def transform_play_to_column(play):\n\n return [2 ** i for i in range(49)].index(play) // 7","def cube(n):\n return n**3","def box_3d_to_3d_iou_format(boxes_3d):\n boxes_3d = np.asarray(boxes_3d)\n fc.check_box_3d_format(boxes_3d)\n\n iou_3d_boxes = np.zeros([len(boxes_3d), 7])\n iou_3d_boxes[:, 4:7] = boxes_3d[:, 0:3]\n iou_3d_boxes[:, 1] = boxes_3d[:, 3]\n iou_3d_boxes[:, 2] = boxes_3d[:, 4]\n iou_3d_boxes[:, 3] = boxes_3d[:, 5]\n iou_3d_boxes[:, 0] = boxes_3d[:, 6]\n\n return iou_3d_boxes","def 3Sat(B):","def generate_3d_board(n):\n layer = nxn_generate.generate_shuffled_2d_board(n)\n cube = []\n for i in range(len(layer)):\n new_layer = []\n for column in layer:\n new_column = []\n # this nested mess is to ensure that none of the sub 3x3 squares violates sudoku rules from any x y or z\n # perspective (also the Latin Square rules but the subsquares are trickier and the cause of more mess)\n for j in range(int(math.sqrt(len(layer)))):\n for k in range(int(math.sqrt(len(layer)))):\n # lot of 3 = (i+j) % 3\n # index within lot = (i + k + (i//3)) % 3\n new_column.append(column[int(math.sqrt(len(layer))) * ((i + j) % int(math.sqrt(len(layer)))) + (\n i + k + (i // int(math.sqrt(len(layer))))) % int(math.sqrt(len(layer)))])\n new_layer.append(new_column)\n cube.append(new_layer)\n\n return shuffle_cube(cube)","def make_state_appliable_4ch(state):\n size = len(state)\n st_appl = np.zeros((size,)*4, dtype=complex)\n for p1 in range(size):\n for p2 in range(size):\n for p3 in range(size):\n for p4 in range(size):\n st_appl[p1, p2, p3, p4] = state[p1, p2, p3, p4] * sqrt(factorial(p1) * factorial(p2) * factorial(p3) * factorial(p4))\n return st_appl","def get5x5matrix(self): #modified from nxvasc get3x3matrix()\n try:\n i = na.identity(3)\n \n self.d124 = i.copy()\n self.ds124 = na.zeros(124,na.float64)\n \n for k in range(1,124):\n self.d124 = na.concatenate((self.d124,i))\n# print len(self.d124)\n count = 0\n a = []\n for k in range(-2,3):\n for j in range(-2,3):\n for i in range(-2,3):\n if( i != 0 or j != 0 or k != 0 ):\n self.ds124[count] = math.sqrt(i**2+j**2+k**2)\n count += 1\n a.append(i)\n a.append(j)\n a.append(k)\n# print len(a)\n a = na.reshape(na.array(a),(372,1))\n# print len(self.d124)\n self.d124 = na.concatenate((self.d124,a),axis=1)\n except Exception as error:\n print(\"failed in get5x5matrix(): \", error)","def _to_bc_L_h_w(x, x_shape):\r\n x = tf.reshape(x, (-1,\r\n int(x_shape[2]),\r\n int(x_shape[3]),\r\n int(x_shape[4])))\r\n return x","def convert_3to1(seq):\n term_list = []\n for i in __kmers(seq,k=3):\n res = __get_value(i,aa3_to1_dict)\n term_list.append(res)\n return ''.join(term_list)","def _pad_1x1_to_3x3_tensor(self, kernel1x1):\n if kernel1x1 is None:\n return 0\n else:\n return torch.nn.functional.pad(kernel1x1, [1, 1, 1, 1])","def push_up (grid):\r\n for i in range (3):\r\n for row in range(1,4):\r\n for col in range(4):\r\n if grid[row-1][col] == 0:\r\n grid[row-1][col] = grid[row][col]\r\n grid[row][col] = 0\r\n for row in range(1,4):\r\n for col in range(4):\r\n if grid[row-1][col] == grid[row][col]:\r\n grid[row-1][col] = grid[row-1][col]*2\r\n grid[row][col]=0\r\n for row in range(1,4):\r\n for col in range(4):\r\n if grid[row-1][col] == 0:\r\n grid[row-1][col] = grid[row][col]\r\n grid[row][col] = 0\r\n \r\n return grid","def test_3_1_4D_cube_init(self):\n check = [(0, 0, 0, 0), (1, 1, 1, 1), (1, 0, 0, 0), (1, 1, 0, 0),\n (1, 1, 1, 0), (1, 1, 0, 1), (1, 0, 1, 0), (1, 0, 1, 1),\n (1, 0, 0, 1), (0, 1, 0, 0), (0, 1, 1, 0), (0, 1, 1, 1),\n (0, 1, 0, 1), (0, 0, 1, 0), (0, 0, 1, 1), (0, 0, 0, 1),\n (0.5, 0.5, 0.5, 0.5)]\n nn_checks = {(0, 1, 1, 0): [(1, 1, 1, 0), (0, 1, 1, 1), (1, 1, 1, 1),\n (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 0),\n (0.5, 0.5, 0.5, 0.5)],\n (0.5, 0.5, 0.5, 0.5): [(1, 1, 0, 1), (1, 0, 1, 1),\n (1, 1, 1, 0), (1, 0, 0, 0),\n (1, 1, 0, 0), (1, 0, 1, 0),\n (0, 1, 1, 1), (0, 0, 0, 1),\n (1, 1, 1, 1), (1, 0, 0, 1),\n (0, 1, 0, 0), (0, 0, 1, 0),\n (0, 0, 0, 0), (0, 1, 1, 0),\n (0, 1, 0, 1), (0, 0, 1, 1)],\n (1, 0, 0, 0): [(1, 1, 0, 1), (1, 0, 1, 1), (1, 1, 1, 0),\n (1, 1, 0, 0), (1, 0, 1, 0), (1, 1, 1, 1),\n (1, 0, 0, 1), (0, 0, 0, 0),\n (0.5, 0.5, 0.5, 0.5)]}\n\n init_triangulation(4, 0, check, nn_checks)","def to_image_space(data):\n return np.swapaxes(np.flip(data, 1), 0, 1)","def axial_to_cube(axial):\n x = axial[0] # q\n z = axial[1] # r\n y = -x-z\n return tuple([x, y, z])","def testCube(self):\n cube = {i:(i^1,i^2,i^4) for i in range(8)}\n self.check(cube,6)","def preprocess_3d(im_stack):\n im_stack /= 127.5\n im_stack -= 1.0\n return im_stack","def bits_trippling_1(self):\n bits = np.array((self.image_bits))\n trippled_binary_image_bits = np.repeat(bits, 3)\n return trippled_binary_image_bits","def reduce_mini(minigrid):\n row = []\n for i in range(3):\n for j in range(3):\n row.append(minigrid[i][j])\n for i in range(9):\n if len(row[i]) == 1:\n for j in range(9):\n if i != j:\n if row[i] in row[j]:\n chunks = row[j].split(row[i])\n row[j] = chunks[0] + chunks[1]\n\n count_dict = {}\n for i in range(9):\n for char in row[i]:\n if char in count_dict:\n count_dict[char] = \"X\"\n else:\n count_dict[char] = i\n\n for key in count_dict:\n if count_dict[key] != \"X\":\n row[count_dict[key]] = key\n\n for i in range(3):\n for j in range(3):\n minigrid[i][j] = row[(i*3)+j]\n\n return minigrid","def conv7x7(self, in_planes, out_planes, stride=1):\n c = self.conv(7, in_planes, out_planes, stride=stride)\n return c","def unvoigt(A):\n a = np.zeros(shape=(3, 3))\n a[0, 0] = A[0]\n a[0, 1] = A[5]\n a[0, 2] = A[4]\n a[1, 0] = A[5]\n a[1, 1] = A[1]\n a[1, 2] = A[3]\n a[2, 0] = A[4]\n a[2, 1] = A[3]\n a[2, 2] = A[2]\n return a","def make_grid(self):\n\n\t\tinit_grid = (self.grid_width//2, self.grid_height//2)\n\t\tgrid_list = []\n\n\t\tfor i in range(self.canv_width//self.grid_width):\n\t\t\tfor j in range(self.canv_height//self.grid_height):\n\t\t\t\tif j == 0 or j%2 ==0:\n\t\t\t\t\tgrid_list.append((init_grid[0]+i*self.grid_width, init_grid[1]+j*self.grid_height))\n\t\t\t\t\t\n\t\t\t\telse:\n\t\t\t\t\tgrid_list.append((grid_list[-1][0]+(self.grid_width//2), init_grid[1]+j*self.grid_height))\n\n\t\treturn grid_list","def blockshaped(input_suduko_2d):\n h = input_suduko_2d.shape[0]\n return (input_suduko_2d.reshape(h // 3, 3, -1, 3)\n .swapaxes(1, 2)\n .reshape(-1, 3, 3))","def img_preprocess(img):\n squares = []\n x_size = img.shape[0]\n assert x_size >= FIX_IMG_SQR_SIZE\n y_size = img.shape[1]\n assert y_size >= FIX_IMG_SQR_SIZE\n for x in range(0, x_size, FIX_IMG_SQR_SIZE):\n xstart = x\n xend = xstart+FIX_IMG_SQR_SIZE\n if xend > x_size:\n xstart = x_size-FIX_IMG_SQR_SIZE\n xend = x_size\n for y in range(0, y_size, FIX_IMG_SQR_SIZE):\n ystart = y\n yend = ystart+FIX_IMG_SQR_SIZE\n if yend > y_size:\n ystart = y_size-FIX_IMG_SQR_SIZE\n yend = y_size\n square = img[xstart:xend, ystart:yend,:]\n squares.append(SQ_OUT(square, xstart, ystart, 3.0, 3))\n return squares","def convert_game_action_to_3D_action(ga):\n tile_type, from_row, to_row, nbr_to_move = ga\n\n return (tile_type, min(nbr_to_move,5), to_row)","def transpose_3d():\n tmp = np.random.random((10, 10, 10))\n\n a = tmp.T\n b = np.empty(tmp.shape)\n for j in range(tmp.shape[1]):\n b[:, j, :] = tmp[:, j, :].T\n\n print(np.all(a == b))","def mat24_perm_to_int(p):\n oct = sum(1 << x for x in p[:8])\n res = gc.vect_to_octad(oct) \n #print(\"p2i oct\", hex(oct))\n res -= STD_OCTAD\n res += (res >> 12) & 759 \n #print(\"p2i\", res)\n p1 = [24]*32\n oct, j = 8 * oct, 0x00 \n for i in range(24):\n o = oct & 8\n p1[i] = (j >> o) & 0x1f\n j += 1 << o\n oct >>= 1\n q, q_inv = [None]*8, [None]*8\n for i in range(8):\n j = p1[p[i] & 0x1f] & 7\n q[j] = i\n q_inv[i] = j\n for i in range(6):\n # exchange place i with place q_inv[i]\n j = q_inv[i]\n #q_inv[q[i]], q_inv[q[j]] = q_inv[q[j]], q_inv[q[i]]\n #q[i], q[j] = q[j], q[i]\n #assert q[:i] == q_inv[:i] == lrange(i)\n q_inv[q[i]] = q_inv[q[j]]\n q[j] = q[i]\n #print(\"p2i%d\" % i, j-i) \n res = res * (8 - i) + j - i\n #print(\"p2ifinal\", p1[p[8] & 0x1f]) \n return 16 * res + p1[p[8] & 0x1f]","def get_mnist(one_hot_enc, normalized, flatten):","def reduce_sub(sub,sudoku_grid):\n minigrid = []\n row = math.floor(sub/3)\n col = sub % 3\n start_row = row * 3\n start_col = col * 3\n for j in range(start_row,start_row+3):\n minirow = []\n for k in range(start_col,start_col+3):\n minirow.append(sudoku_grid[j][k])\n minigrid.append(minirow)\n minigrid = reduce_mini(minigrid)\n for j in range(start_row,start_row+3):\n for k in range(start_col,start_col+3):\n sudoku_grid[j][k] = minigrid[j%3][k%3]\n return sudoku_grid","def tile_size_2d(self):\n return 32.0, 32.0","def _aseg_to_three():\n import numpy as np\n\n # Base struct\n aseg_lut = np.zeros((256,), dtype=\"int\")\n # GM\n aseg_lut[3] = 1\n aseg_lut[8:14] = 1\n aseg_lut[17:21] = 1\n aseg_lut[26:40] = 1\n aseg_lut[42] = 1\n aseg_lut[47:73] = 1\n\n # CSF\n aseg_lut[4:6] = 3\n aseg_lut[14:16] = 3\n aseg_lut[24] = 3\n aseg_lut[43:45] = 3\n aseg_lut[72] = 3\n\n # WM\n aseg_lut[2] = 2\n aseg_lut[7] = 2\n aseg_lut[16] = 2\n aseg_lut[28] = 2\n aseg_lut[41] = 2\n aseg_lut[46] = 2\n aseg_lut[60] = 2\n aseg_lut[77:80] = 2\n aseg_lut[250:256] = 2\n return tuple(aseg_lut)","def get_unet1(patch_height, patch_width, channels, n_classes):\n axis = 3\n k = 3 # kernel size\n s = 2 # stride\n n_filters = 32 # number of filters 通道数\n\n #初始化keras张量\n inputs = Input((patch_height, patch_width, channels))\n\n # n_filters：输出的维度 （k，k）：卷积核尺寸 padding：边缘填充\n # 400,400,3 ==> 400,400,32\n conv1 = Conv2D(n_filters, (k, k), padding='same')(inputs)\n conv1 = BatchNormalization(scale=False, axis=axis)(conv1)\n conv1 = Activation('relu')(conv1)\n conv1 = Conv2D(n_filters, (k, k), padding='same')(conv1)\n conv1 = BatchNormalization(scale=False, axis=axis)(conv1)\n conv1 = Activation('relu')(conv1)\n # 400,400,32 ==> 200,200,32\n pool1 = MaxPooling2D(pool_size=(s, s))(conv1)\n\n # 200,200,32 ==> 200,200,32\n conv2 = Conv2D(n_filters, (k, k), padding='same')(pool1)\n conv2 = BatchNormalization(scale=False, axis=axis)(conv2)\n conv2 = Activation('relu')(conv2)\n conv2 = Conv2D(n_filters, (k, k), padding='same')(conv2)\n conv2 = BatchNormalization(scale=False, axis=axis)(conv2)\n conv2 = add([pool1, conv2])\n conv2 = Activation('relu')(conv2)\n x2 = Conv2D(2 * n_filters, (k, k), padding='same')(conv2)\n # 200,200,32 ==> 100,100,64\n output2 = Conv2D(n_filters * 2, (1,1),padding='same',strides=s)(conv2)\n\n # 200,200,32 ==> 100,100,64\n conv3 = Conv2D(2 * n_filters, (k, k), padding='same',strides=s)(conv2)\n conv3 = BatchNormalization(scale=False, axis=axis)(conv3)\n conv3 = Activation('relu')(conv3)\n # 100,100,64 ==> 100,100,64\n conv3 = Conv2D(2 * n_filters, (k, k), padding='same')(conv3)\n conv3 = BatchNormalization(scale=False, axis=axis)(conv3)\n conv3 = add([output2,conv3])\n conv3 = Activation('relu')(conv3)\n x3 = Conv2D(4 * n_filters, (k, k), padding='same')(conv3)\n # 100,100,64 ==> 50,50,128\n output3 = Conv2D(n_filters * 4,(1,1),padding='same',strides=s)(conv3)\n\n # 100,100,64 ==> 50,50,128\n conv4 = Conv2D(4 * n_filters, (k, k), padding='same',strides=s)(conv3)\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\n conv4 = Activation('relu')(conv4)\n conv4 = Conv2D(4 * n_filters, (k, k), padding='same')(conv4)\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\n conv4 = add([output3,conv4])\n conv4 = Activation('relu')(conv4)\n # x4 == 50,50,256\n x4 = Conv2D(8 * n_filters,(k,k),padding='same')(conv4)\n # 50,50,128 ==> 25,25,256\n output4 = Conv2D(8 * n_filters,(1,1),padding='same',strides=s)(conv4)\n\n # 50,50,128 ==> 25,25,256\n conv5 = Conv2D(8 * n_filters, (k, k), padding='same',strides=s)(conv4)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(8 * n_filters, (k, k), padding='same')(conv5)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = add([output4,conv5])\n conv5 = Activation('relu')(conv5)\n # 25,25,256 ==> 25,25,512\n output5 = Conv2D(16 * n_filters,(1,1),padding='same')(conv5)\n\n # 先上采样放大 在进行卷积操作 相当于转置卷积 并进行拼接\n # 25,25,512 ==> 50,50,768\n up1 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(output5), x4])\n conv6 = Conv2D(8 * n_filters, (k, k), padding='same')(up1)\n conv6 = BatchNormalization(scale=False, axis=axis)(conv6)\n conv6 = Activation('relu')(conv6)\n conv6 = Conv2D(8 * n_filters, (k, k), padding='same')(conv6)\n conv6 = BatchNormalization(scale=False, axis=axis)(conv6)\n conv6 = Activation('relu')(conv6)\n\n # 50,50,768 ==> 100,100,896\n up2 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(conv6), x3])\n conv7 = Conv2D(4 * n_filters, (k, k), padding='same')(up2)\n conv7 = BatchNormalization(scale=False, axis=axis)(conv7)\n conv7 = Activation('relu')(conv7)\n conv7 = Conv2D(4 * n_filters, (k, k), padding='same')(conv7)\n conv7 = BatchNormalization(scale=False, axis=axis)(conv7)\n conv7 = Activation('relu')(conv7)\n\n # 100,100,896 ==> 200,200,960\n up3 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(conv7), x2])\n conv8 = Conv2D(2 * n_filters, (k, k), padding='same')(up3)\n conv8 = BatchNormalization(scale=False, axis=axis)(conv8)\n conv8 = Activation('relu')(conv8)\n conv8 = Conv2D(2 * n_filters, (k, k), padding='same')(conv8)\n conv8 = BatchNormalization(scale=False, axis=axis)(conv8)\n conv8 = Activation('relu')(conv8)\n\n # 200,200,960 ==> 400,400,992\n up4 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(conv8), conv1])\n conv9 = Conv2D(n_filters, (k, k), padding='same')(up4)\n conv9 = BatchNormalization(scale=False, axis=axis)(conv9)\n conv9 = Activation('relu')(conv9)\n conv9 = Conv2D(n_filters, (k, k), padding='same')(conv9)\n conv9 = BatchNormalization(scale=False, axis=axis)(conv9)\n conv9 = Activation('relu')(conv9)\n\n # 全连接层 400,400,992 ==> 400,400,5\n outputs = Conv2D(n_classes, (1, 1), padding='same', activation='softmax')(conv9)\n\n unet = Model(inputs=inputs, outputs=outputs)\n return unet","def cube(n):\n result = [num*num*num for num in range(n)]\n\n return result[1:]","def _reshape_output(self, output):\n output = np.transpose(output, [0, 2, 3, 1])\n _, height, width, _ = output.shape\n dim1, dim2 = height, width\n dim3 = 3\n # There are CATEGORY_NUM=80 object categories:\n dim4 = (4 + 1 + CATEGORY_NUM)\n return np.reshape(output, (dim1, dim2, dim3, dim4))","def test_4_1_5D_cube_init(self):\n check = [(0, 0, 0, 0, 0), (1, 1, 1, 1, 1), (1, 0, 0, 0, 0),\n (1, 1, 0, 0, 0),\n (1, 1, 1, 0, 0), (1, 1, 1, 1, 0), (1, 1, 1, 0, 1),\n (1, 1, 0, 1, 0),\n (1, 1, 0, 1, 1), (1, 1, 0, 0, 1), (1, 0, 1, 0, 0),\n (1, 0, 1, 1, 0),\n (1, 0, 1, 1, 1), (1, 0, 1, 0, 1), (1, 0, 0, 1, 0),\n (1, 0, 0, 1, 1),\n (1, 0, 0, 0, 1), (0, 1, 0, 0, 0), (0, 1, 1, 0, 0),\n (0, 1, 1, 1, 0),\n (0, 1, 1, 1, 1), (0, 1, 1, 0, 1), (0, 1, 0, 1, 0),\n (0, 1, 0, 1, 1),\n (0, 1, 0, 0, 1), (0, 0, 1, 0, 0), (0, 0, 1, 1, 0),\n (0, 0, 1, 1, 1),\n (0, 0, 1, 0, 1), (0, 0, 0, 1, 0), (0, 0, 0, 1, 1),\n (0, 0, 0, 0, 1),\n (0.5, 0.5, 0.5, 0.5, 0.5)]\n\n nn_checks = {(0, 1, 0, 1, 1): [(0, 0, 0, 0, 0), (\n 0.5, 0.5, 0.5, 0.5, 0.5), (0, 0, 0, 1, 1), (1, 1, 0, 1, 1),\n (0, 1, 0, 0, 0),\n (0, 1, 0, 0, 1),\n (0, 1, 0, 1, 0),\n (0, 0, 0, 0, 1),\n (1, 1, 1, 1, 1),\n (0, 1, 1, 1, 1),\n (0, 0, 0, 1, 0)]}\n\n init_triangulation(5, 0, check, nn_checks)","def cube(num):\n return num ** 3","def scale4(a,c):\n return [a[0]*c,a[1]*c,a[2]*c,a[3]*c]","def _convert_to_square(self, bboxes):\n\n square_bboxes = torch.zeros_like(bboxes, device=self.device, dtype=torch.float32)\n x1, y1, x2, y2 = [bboxes[:, i].float() for i in range(4)]\n h = y2 - y1 + 1.0\n w = x2 - x1 + 1.0\n max_side = torch.max(h, w)\n square_bboxes[:, 0] = x1 + w*0.5 - max_side*0.5\n square_bboxes[:, 1] = y1 + h*0.5 - max_side*0.5\n square_bboxes[:, 2] = square_bboxes[:, 0] + max_side - 1.0\n square_bboxes[:, 3] = square_bboxes[:, 1] + max_side - 1.0\n\n square_bboxes = torch.ceil(square_bboxes + 1).int()\n return square_bboxes","def compute_output_shape(self, s):\n return s[0], s[1] + 2 * self.padding[0], s[2] + 2 * self.padding[1], s[3]","def dimensions():","def convertInchTOPixel(self,*args):\n return list(map(lambda x : int(x * 96),args))","def dim_calculatorP3():\r\n probe_set = np.arange(1, 101)\r\n X = 20 - 36 + ((probe_set - 1) // 10) * 4\r\n Y = 2 - ((probe_set - 1) % 10) * 4\r\n dim = np.vstack((X, Y)).T\r\n return dim","def _cal_meaningful_corners(self):\n corners = np.where(self._free_of_clash)\n corners = np.array(corners, dtype=int)\n corners = corners.transpose()\n return corners","def convert_shape_to_units(self, shape):\n unit_factor = [GDS[\"unit\"][0]] * 2\n ll=shape[0].scale(unit_factor)\n ur=shape[1].scale(unit_factor)\n return [ll,ur]"],"string":"[\n \"def make8UC3(mat):\\n mat_8UC = make8UC(mat)\\n mat_8UC3 = np.stack((mat_8UC,)*3, axis = -1)\\n \\n return mat_8UC3\",\n \"def dti6to33(dt6):\\n dt33 = numpy.zeros(dt6.shape[:-1] + (3, 3), dtype=dt6.dtype)\\n dt33[..., 0, 0] = dt6[..., 5] # dxx\\n dt33[..., 0, 1] = dt33[..., 1, 0] = dt6[..., 4] / 2 # dxy\\n dt33[..., 0, 2] = dt33[..., 2, 0] = dt6[..., 3] / 2 # dxz\\n dt33[..., 1, 1] = dt6[..., 2] # dyy\\n dt33[..., 1, 2] = dt33[..., 2, 1] = dt6[..., 1] / 2 # dyz\\n dt33[..., 2, 2] = dt6[..., 0] # dzz\\n\\n return dt33\",\n \"def _to_bc_L_h_w_3(x, x_shape):\\r\\n\\r\\n x = tf.reshape(x, (-1,\\r\\n int(x_shape[2]),\\r\\n int(x_shape[3]),\\r\\n int(x_shape[4]), 3))\\r\\n return x\",\n \"def dti33to6(dt33):\\n dt6 = numpy.zeros(dt33.shape[:-2] + (6, ), dtype=dt33.dtype)\\n dt6[..., 5] = dt33[..., 0, 0]\\n dt6[..., 4] = dt33[..., 0, 1] + dt33[..., 1, 0]\\n dt6[..., 3] = dt33[..., 0, 2] + dt33[..., 2, 0]\\n dt6[..., 2] = dt33[..., 1, 1]\\n dt6[..., 1] = dt33[..., 1, 2] + dt33[..., 2, 1]\\n dt6[..., 0] = dt33[..., 2, 2]\\n\\n return dt6\",\n \"def _transpose_by_1_vnchwconv():\\n\\n pass\",\n \"def Cijkl(C):\\n c = np.zeros(shape=(3, 3, 3, 3))\\n CC = np.zeros(shape=(9, 9))\\n CC[0:6, 0:6] = C[0:6, 0:6]\\n CC[6:9, 6:9] = C[3:6, 3:6]\\n CC[0:6, 6:9] = C[0:6, 3:6]\\n CC[6:9, 0:6] = C[3:6, 0:6]\\n\\n c[0, 0, 0, 0] = CC[0, 0]\\n c[0, 0, 1, 1] = CC[0, 1]\\n c[0, 0, 2, 2] = CC[0, 2]\\n c[0, 0, 1, 2] = CC[0, 3]\\n c[0, 0, 2, 0] = CC[0, 4]\\n c[0, 0, 0, 1] = CC[0, 5]\\n c[0, 0, 2, 1] = CC[0, 6]\\n c[0, 0, 0, 2] = CC[0, 7]\\n c[0, 0, 1, 0] = CC[0, 8]\\n\\n c[1, 1, 0, 0] = CC[1, 0]\\n c[1, 1, 1, 1] = CC[1, 1]\\n c[1, 1, 2, 2] = CC[1, 2]\\n c[1, 1, 1, 2] = CC[1, 3]\\n c[1, 1, 2, 0] = CC[1, 4]\\n c[1, 1, 0, 1] = CC[1, 5]\\n c[1, 1, 2, 1] = CC[1, 6]\\n c[1, 1, 0, 2] = CC[1, 7]\\n c[1, 1, 1, 0] = CC[1, 8]\\n\\n c[2, 2, 0, 0] = CC[2, 0]\\n c[2, 2, 1, 1] = CC[2, 1]\\n c[2, 2, 2, 2] = CC[2, 2]\\n c[2, 2, 1, 2] = CC[2, 3]\\n c[2, 2, 2, 0] = CC[2, 4]\\n c[2, 2, 0, 1] = CC[2, 5]\\n c[2, 2, 2, 1] = CC[2, 6]\\n c[2, 2, 0, 2] = CC[2, 7]\\n c[2, 2, 1, 0] = CC[2, 8]\\n\\n c[1, 2, 0, 0] = CC[3, 0]\\n c[1, 2, 1, 1] = CC[3, 1]\\n c[1, 2, 2, 2] = CC[3, 2]\\n c[1, 2, 1, 2] = CC[3, 3]\\n c[1, 2, 2, 0] = CC[3, 4]\\n c[1, 2, 0, 1] = CC[3, 5]\\n c[1, 2, 2, 1] = CC[3, 6]\\n c[1, 2, 0, 2] = CC[3, 7]\\n c[1, 2, 1, 0] = CC[3, 8]\\n\\n c[2, 0, 0, 0] = CC[4, 0]\\n c[2, 0, 1, 1] = CC[4, 1]\\n c[2, 0, 2, 2] = CC[4, 2]\\n c[2, 0, 1, 2] = CC[4, 3]\\n c[2, 0, 2, 0] = CC[4, 4]\\n c[2, 0, 0, 1] = CC[4, 5]\\n c[2, 0, 2, 1] = CC[4, 6]\\n c[2, 0, 0, 2] = CC[4, 7]\\n c[2, 0, 1, 0] = CC[4, 8]\\n\\n c[0, 1, 0, 0] = CC[5, 0]\\n c[0, 1, 1, 1] = CC[5, 1]\\n c[0, 1, 2, 2] = CC[5, 2]\\n c[0, 1, 1, 2] = CC[5, 3]\\n c[0, 1, 2, 0] = CC[5, 4]\\n c[0, 1, 0, 1] = CC[5, 5]\\n c[0, 1, 2, 1] = CC[5, 6]\\n c[0, 1, 0, 2] = CC[5, 7]\\n c[0, 1, 1, 0] = CC[5, 8]\\n\\n c[2, 1, 0, 0] = CC[6, 0]\\n c[2, 1, 1, 1] = CC[6, 1]\\n c[2, 1, 2, 2] = CC[6, 2]\\n c[2, 1, 1, 2] = CC[6, 3]\\n c[2, 1, 2, 0] = CC[6, 4]\\n c[2, 1, 0, 1] = CC[6, 5]\\n c[2, 1, 2, 1] = CC[6, 6]\\n c[2, 1, 0, 2] = CC[6, 7]\\n c[2, 1, 1, 0] = CC[6, 8]\\n\\n c[0, 2, 0, 0] = CC[7, 0]\\n c[0, 2, 1, 1] = CC[7, 1]\\n c[0, 2, 2, 2] = CC[7, 2]\\n c[0, 2, 1, 2] = CC[7, 3]\\n c[0, 2, 2, 0] = CC[7, 4]\\n c[0, 2, 0, 1] = CC[7, 5]\\n c[0, 2, 2, 1] = CC[7, 6]\\n c[0, 2, 0, 2] = CC[7, 7]\\n c[0, 2, 1, 0] = CC[7, 8]\\n\\n c[1, 0, 0, 0] = CC[8, 0]\\n c[1, 0, 1, 1] = CC[8, 1]\\n c[1, 0, 2, 2] = CC[8, 2]\\n c[1, 0, 1, 2] = CC[8, 3]\\n c[1, 0, 2, 0] = CC[8, 4]\\n c[1, 0, 0, 1] = CC[8, 5]\\n c[1, 0, 2, 1] = CC[8, 6]\\n c[1, 0, 0, 2] = CC[8, 7]\\n c[1, 0, 1, 0] = CC[8, 8]\\n return c\",\n \"def six_hundred_cell(self):\\n verts = []\\n q12 = QQ(1)/2\\n base = [q12,q12,q12,q12]\\n for i in range(2):\\n for j in range(2):\\n for k in range(2):\\n for l in range(2):\\n verts.append([x for x in base])\\n base[3] = base[3]*(-1)\\n base[2] = base[2]*(-1)\\n base[1] = base[1]*(-1)\\n base[0] = base[0]*(-1)\\n for x in permutations([0,0,0,1]):\\n verts.append(x)\\n for x in permutations([0,0,0,-1]):\\n verts.append(x)\\n g = QQ(1618033)/1000000 # Golden ratio approximation\\n verts = verts + [i([q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,-g/2,1/(g*2),0]) for i in AlternatingGroup(4)]\\n verts = verts + [i([-q12,-g/2,-1/(g*2),0]) for i in AlternatingGroup(4)]\\n return Polyhedron(vertices = verts)\",\n \"def one_to_three(one):\\n return ((1,0,0),(0,1,0),(0,0,1))[one+1]\",\n \"def nine_to_3x3(listy):\\n new_side = []\\n k = int(len(listy) / 3)\\n \\n for i in range(k):\\n intermediate = []\\n for j in range(3):\\n intermediate.append(listy.pop(0))\\n \\n new_side.append(intermediate)\\n return new_side\",\n \"def reformat(x):\\n x = x.permute(0, 2, 3, 1)\\n N, D1, D2, Feat = x.size()\\n x = x.view(N, D1 * D2, Feat)\\n return x\",\n \"def reformat(x):\\n x = x.permute(0, 2, 3, 1)\\n N, D1, D2, Feat = x.size()\\n x = x.view(N, D1 * D2, Feat)\\n return x\",\n \"def gm2code(arr, info):\\n return (arr / info.pboxsize + 0.5)# * 0.999783599\",\n \"def mask_tile(self):\\n if self.size == 1:\\n m = np.array([[0]])\\n elif self.size ==2:\\n m = np.array([[1,2],[4,3]])\\n else:\\n m = 9 * np.ones((self.size, self.size))\\n m[0,0] = 1\\n m[0,-1] = 2\\n m[-1,-1] = 3\\n m[-1,0] = 4 \\n m[0,1:-1] = 5 * np.ones(self.size-2)\\n m[1:-1,-1] = 6 * np.ones(self.size-2)\\n m[-1,1:-1] = 7 * np.ones(self.size-2)\\n m[1:-1,0] = 8 * np.ones(self.size-2)\\n return m.astype(np.int8)\",\n \"def dim3():\\n return Integer(\\\"yolo3\\\", \\\"uniform\\\", 3, 7, shape=(1,))\",\n \"def rotmat_to_rot6d(rotmat):\\n\\n rot6d = rotmat[:, :, 0:2]\\n rot6d = rot6d.reshape(-1, 6)\\n\\n return rot6d\",\n \"def test_2_2_3D_cube_splits(self):\\n check = [(0, 0, 0), (1, 1, 1), (1, 0, 0), (1, 1, 0), (1, 0, 1),\\n (0, 1, 0),\\n (0, 1, 1), (0, 0, 1), (0.5, 0.5, 0.5), (0.0, 0.5, 0.5),\\n (0.0, 0.0, 0.5), (0.0, 0.5, 0.0), (0.5, 0.0, 0.5),\\n (0.5, 0.0, 0.0),\\n (0.5, 0.5, 0.0), (0.25, 0.25, 0.25), (1.0, 0.5, 0.5),\\n (1.0, 1.0, 0.5),\\n (1.0, 0.5, 1.0), (0.5, 1.0, 0.5), (0.5, 1.0, 1.0),\\n (0.5, 0.5, 1.0),\\n (0.75, 0.75, 0.75), (1.0, 0.0, 0.5), (1.0, 0.5, 0.0),\\n (0.75, 0.25, 0.25), (0.5, 1.0, 0.0), (0.75, 0.75, 0.25),\\n (0.5, 0.0, 1.0), (0.75, 0.25, 0.75), (0.0, 1.0, 0.5),\\n (0.25, 0.75, 0.25), (0.0, 0.5, 1.0), (0.25, 0.75, 0.75),\\n (0.25, 0.25, 0.75), (0.5, 0.25, 0.25), (0.5, 0.5, 0.25),\\n (0.5, 0.25, 0.5), (0.25, 0.5, 0.25), (0.25, 0.5, 0.5),\\n (0.25, 0.25, 0.5), (0.375, 0.375, 0.375), (0.0, 0.25, 0.25),\\n (0.0, 0.0, 0.25), (0.0, 0.25, 0.0), (0.25, 0.0, 0.25),\\n (0.25, 0.0, 0.0), (0.25, 0.25, 0.0), (0.125, 0.125, 0.125),\\n (0.0, 0.5, 0.25), (0.0, 0.25, 0.5), (0.125, 0.375, 0.375),\\n (0.25, 0.0, 0.5), (0.125, 0.125, 0.375), (0.25, 0.5, 0.0),\\n (0.125, 0.375, 0.125), (0.5, 0.0, 0.25), (0.375, 0.125, 0.375),\\n (0.5, 0.25, 0.0), (0.375, 0.125, 0.125), (0.375, 0.375, 0.125),\\n (0.5, 0.75, 0.75), (0.5, 0.5, 0.75), (0.5, 0.75, 0.5),\\n (0.75, 0.5, 0.75), (0.75, 0.5, 0.5), (0.75, 0.75, 0.5),\\n (0.625, 0.625, 0.625), (1.0, 0.75, 0.75), (1.0, 1.0, 0.75),\\n (1.0, 0.75, 1.0), (0.75, 1.0, 0.75), (0.75, 1.0, 1.0),\\n (0.75, 0.75, 1.0), (0.875, 0.875, 0.875), (1.0, 0.5, 0.75),\\n (1.0, 0.75, 0.5), (0.875, 0.625, 0.625), (0.75, 1.0, 0.5),\\n (0.875, 0.875, 0.625), (0.75, 0.5, 1.0), (0.875, 0.625, 0.875),\\n (0.5, 1.0, 0.75), (0.625, 0.875, 0.625), (0.5, 0.75, 1.0),\\n (0.625, 0.875, 0.875), (0.625, 0.625, 0.875),\\n (0.75, 0.5, 0.25),\\n (0.75, 0.25, 0.5), (0.625, 0.375, 0.375), (1.0, 0.25, 0.25),\\n (1.0, 0.0, 0.25), (1.0, 0.25, 0.0), (0.75, 0.0, 0.25),\\n (0.75, 0.0, 0.0), (0.75, 0.25, 0.0), (0.875, 0.125, 0.125),\\n (1.0, 0.5, 0.25), (1.0, 0.25, 0.5), (0.875, 0.375, 0.375),\\n (0.75, 0.0, 0.5), (0.875, 0.125, 0.375), (0.75, 0.5, 0.0),\\n (0.875, 0.375, 0.125), (0.625, 0.125, 0.375),\\n (0.625, 0.125, 0.125),\\n (0.625, 0.375, 0.125), (0.5, 0.75, 0.25),\\n (0.625, 0.625, 0.375),\\n (1.0, 0.75, 0.25), (1.0, 1.0, 0.25), (1.0, 0.75, 0.0),\\n (0.75, 1.0, 0.25), (0.75, 1.0, 0.0), (0.75, 0.75, 0.0),\\n (0.875, 0.875, 0.125), (0.875, 0.625, 0.375),\\n (0.875, 0.875, 0.375),\\n (0.875, 0.625, 0.125), (0.5, 1.0, 0.25), (0.625, 0.875, 0.375),\\n (0.5, 0.75, 0.0), (0.625, 0.875, 0.125), (0.625, 0.625, 0.125),\\n (0.5, 0.25, 0.75), (0.625, 0.375, 0.625), (1.0, 0.25, 0.75),\\n (1.0, 0.0, 0.75), (1.0, 0.25, 1.0), (0.75, 0.0, 0.75),\\n (0.75, 0.0, 1.0), (0.75, 0.25, 1.0), (0.875, 0.125, 0.875),\\n (0.875, 0.375, 0.625), (0.875, 0.125, 0.625),\\n (0.875, 0.375, 0.875),\\n (0.5, 0.0, 0.75), (0.625, 0.125, 0.625), (0.5, 0.25, 1.0),\\n (0.625, 0.125, 0.875), (0.625, 0.375, 0.875),\\n (0.25, 0.75, 0.5),\\n (0.375, 0.625, 0.375), (0.0, 0.75, 0.25), (0.0, 1.0, 0.25),\\n (0.0, 0.75, 0.0), (0.25, 1.0, 0.25), (0.25, 1.0, 0.0),\\n (0.25, 0.75, 0.0), (0.125, 0.875, 0.125), (0.0, 0.75, 0.5),\\n (0.125, 0.625, 0.375), (0.25, 1.0, 0.5), (0.125, 0.875, 0.375),\\n (0.125, 0.625, 0.125), (0.375, 0.875, 0.375),\\n (0.375, 0.875, 0.125),\\n (0.375, 0.625, 0.125), (0.25, 0.5, 0.75),\\n (0.375, 0.625, 0.625),\\n (0.0, 0.75, 0.75), (0.0, 1.0, 0.75), (0.0, 0.75, 1.0),\\n (0.25, 1.0, 0.75), (0.25, 1.0, 1.0), (0.25, 0.75, 1.0),\\n (0.125, 0.875, 0.875), (0.0, 0.5, 0.75), (0.125, 0.625, 0.625),\\n (0.125, 0.875, 0.625), (0.25, 0.5, 1.0), (0.125, 0.625, 0.875),\\n (0.375, 0.875, 0.625), (0.375, 0.875, 0.875),\\n (0.375, 0.625, 0.875),\\n (0.375, 0.375, 0.625), (0.0, 0.25, 0.75), (0.0, 0.0, 0.75),\\n (0.0, 0.25, 1.0), (0.25, 0.0, 0.75), (0.25, 0.0, 1.0),\\n (0.25, 0.25, 1.0), (0.125, 0.125, 0.875),\\n (0.125, 0.375, 0.625),\\n (0.125, 0.125, 0.625), (0.125, 0.375, 0.875),\\n (0.375, 0.125, 0.625),\\n (0.375, 0.125, 0.875), (0.375, 0.375, 0.875)]\\n\\n nn_checks = {(0.5, 0.25, 0.25): [(0.375, 0.375, 0.125), (0.5, 0.5, 0.0),\\n (0.75, 0.25, 0.25),\\n (0.625, 0.375, 0.375),\\n (0.625, 0.125, 0.375),\\n (0.625, 0.125, 0.125),\\n (0.5, 0.5, 0.25), (0.25, 0.25, 0.25),\\n (0.375, 0.375, 0.375),\\n (0.5, 0.25, 0.5), (0.5, 0.5, 0.5),\\n (0.5, 0.0, 0.25),\\n (0.375, 0.125, 0.375), (0.5, 0.0, 0.5),\\n (0.5, 0.25, 0.0),\\n (0.375, 0.125, 0.125), (0.5, 0.0, 0.0),\\n (0.625, 0.375, 0.125)],\\n (0.625, 0.625, 0.875): [(0.75, 0.5, 1.0),\\n (0.75, 0.75, 1.0),\\n (0.5, 0.75, 1.0), (0.5, 0.5, 1.0),\\n (0.5, 0.5, 0.75),\\n (0.5, 0.75, 0.75),\\n (0.75, 0.5, 0.75),\\n (0.75, 0.75, 0.75)],\\n (0, 0, 0): [(0.0, 0.25, 0.0), (0.125, 0.125, 0.125),\\n (0.0, 0.0, 0.25), (0.25, 0.0, 0.0),\\n (0.0, 0.25, 0.25), (0.25, 0.25, 0.0),\\n (0.25, 0.0, 0.25)]}\\n\\n init_triangulation(3, 2, check, nn_checks)\",\n \"def make8UC(mat):\\n mat_256 = mat[:,:]# *255\\n mat_256.round()\\n mat_8UC = np.uint8(mat_256)\\n \\n return mat_8UC\",\n \"def resh(x):\\r\\n a = x.shape[0]\\r\\n b = x.shape[1]\\r\\n return x.reshape(a*b, 1), a, b\",\n \"def six_cubed():\\n print(math.pow(6,3))\",\n \"def normalize((image)):\\n new = np.zeros((7,7))\\n index = 0\\n for i in [0, 4, 7, 10, 14, 17, 21]:\\n for j in [0, 4, 7, 10, 14, 17, 21]:\\n new[index / 7][index % 7] += float(np.sum(image[i:(i+6),j:(j+6)]))/49\\n index += 1\\n return new\",\n \"def test_3_2_4D_cube_splits(self):\\n check = [(0, 0, 0, 0), (1, 1, 1, 1), (1, 0, 0, 0), (1, 1, 0, 0),\\n (1, 1, 1, 0),\\n (1, 1, 0, 1), (1, 0, 1, 0), (1, 0, 1, 1), (1, 0, 0, 1),\\n (0, 1, 0, 0),\\n (0, 1, 1, 0), (0, 1, 1, 1), (0, 1, 0, 1), (0, 0, 1, 0),\\n (0, 0, 1, 1),\\n (0, 0, 0, 1), (0.5, 0.5, 0.5, 0.5), (0.0, 0.5, 0.5, 0.5),\\n (0.0, 0.0, 0.5, 0.5), (0.0, 0.0, 0.0, 0.5),\\n (0.0, 0.0, 0.5, 0.0),\\n (0.0, 0.5, 0.0, 0.5), (0.0, 0.5, 0.0, 0.0),\\n (0.0, 0.5, 0.5, 0.0),\\n (0.5, 0.0, 0.5, 0.5), (0.5, 0.0, 0.0, 0.5),\\n (0.5, 0.0, 0.0, 0.0),\\n (0.5, 0.0, 0.5, 0.0), (0.5, 0.5, 0.0, 0.5),\\n (0.5, 0.5, 0.0, 0.0),\\n (0.5, 0.5, 0.5, 0.0), (0.25, 0.25, 0.25, 0.25),\\n (1.0, 0.5, 0.5, 0.5),\\n (1.0, 1.0, 0.5, 0.5), (1.0, 1.0, 1.0, 0.5),\\n (1.0, 1.0, 0.5, 1.0),\\n (1.0, 0.5, 1.0, 0.5), (1.0, 0.5, 1.0, 1.0),\\n (1.0, 0.5, 0.5, 1.0),\\n (0.5, 1.0, 0.5, 0.5), (0.5, 1.0, 1.0, 0.5),\\n (0.5, 1.0, 1.0, 1.0),\\n (0.5, 1.0, 0.5, 1.0), (0.5, 0.5, 1.0, 0.5),\\n (0.5, 0.5, 1.0, 1.0),\\n (0.5, 0.5, 0.5, 1.0), (0.75, 0.75, 0.75, 0.75),\\n (1.0, 0.0, 0.5, 0.5),\\n (1.0, 0.0, 0.0, 0.5), (1.0, 0.0, 0.5, 0.0),\\n (1.0, 0.5, 0.0, 0.5),\\n (1.0, 0.5, 0.0, 0.0), (1.0, 0.5, 0.5, 0.0),\\n (0.75, 0.25, 0.25, 0.25),\\n (1.0, 1.0, 0.0, 0.5), (1.0, 1.0, 0.5, 0.0),\\n (0.5, 1.0, 0.0, 0.5),\\n (0.5, 1.0, 0.0, 0.0), (0.5, 1.0, 0.5, 0.0),\\n (0.75, 0.75, 0.25, 0.25),\\n (1.0, 0.5, 1.0, 0.0), (0.5, 1.0, 1.0, 0.0),\\n (0.5, 0.5, 1.0, 0.0),\\n (0.75, 0.75, 0.75, 0.25), (1.0, 0.5, 0.0, 1.0),\\n (0.5, 1.0, 0.0, 1.0),\\n (0.5, 0.5, 0.0, 1.0), (0.75, 0.75, 0.25, 0.75),\\n (1.0, 0.0, 1.0, 0.5),\\n (0.5, 0.0, 1.0, 0.5), (0.5, 0.0, 1.0, 0.0),\\n (0.75, 0.25, 0.75, 0.25),\\n (1.0, 0.0, 0.5, 1.0), (0.5, 0.0, 1.0, 1.0),\\n (0.5, 0.0, 0.5, 1.0),\\n (0.75, 0.25, 0.75, 0.75), (0.5, 0.0, 0.0, 1.0),\\n (0.75, 0.25, 0.25, 0.75), (0.0, 1.0, 0.5, 0.5),\\n (0.0, 1.0, 0.0, 0.5),\\n (0.0, 1.0, 0.5, 0.0), (0.25, 0.75, 0.25, 0.25),\\n (0.0, 1.0, 1.0, 0.5),\\n (0.0, 0.5, 1.0, 0.5), (0.0, 0.5, 1.0, 0.0),\\n (0.25, 0.75, 0.75, 0.25),\\n (0.0, 1.0, 0.5, 1.0), (0.0, 0.5, 1.0, 1.0),\\n (0.0, 0.5, 0.5, 1.0),\\n (0.25, 0.75, 0.75, 0.75), (0.0, 0.5, 0.0, 1.0),\\n (0.25, 0.75, 0.25, 0.75), (0.0, 0.0, 1.0, 0.5),\\n (0.25, 0.25, 0.75, 0.25), (0.0, 0.0, 0.5, 1.0),\\n (0.25, 0.25, 0.75, 0.75), (0.25, 0.25, 0.25, 0.75)]\\n\\n nn_checks = {(0, 0, 0, 0): [(0.0, 0.5, 0.5, 0.0), (0.5, 0.0, 0.5, 0.5),\\n (0.5, 0.5, 0.0, 0.5),\\n (0.25, 0.25, 0.25, 0.25),\\n (0.5, 0.0, 0.0, 0.5), (0.5, 0.0, 0.5, 0.0),\\n (0.5, 0.5, 0.0, 0.0), (0.0, 0.0, 0.5, 0.0),\\n (0.0, 0.5, 0.0, 0.0), (0.0, 0.0, 0.0, 0.5),\\n (0.0, 0.5, 0.5, 0.5), (0.0, 0.0, 0.5, 0.5),\\n (0.0, 0.5, 0.0, 0.5), (0.5, 0.0, 0.0, 0.0),\\n (0.5, 0.5, 0.5, 0.0)],\\n (1.0, 1.0, 0.5, 0.5): [(1.0, 1.0, 0.5, 1.0), (1, 1, 0, 1),\\n (1.0, 1.0, 1.0, 0.5),\\n (1.0, 0.5, 0.5, 0.5), (1, 1, 1, 0),\\n (1.0, 1.0, 0.5, 0.0),\\n (1.0, 1.0, 0.0, 0.5), (1, 1, 0, 0),\\n (1, 1, 1, 1), (0.5, 1.0, 0.5, 0.5),\\n (0.5, 0.5, 0.5, 0.5),\\n (0.75, 0.75, 0.75, 0.75),\\n (0.75, 0.75, 0.25, 0.25),\\n (0.75, 0.75, 0.75, 0.25),\\n (0.75, 0.75, 0.25, 0.75)],\\n (0.25, 0.25, 0.25, 0.75): [(0.0, 0.0, 0.5, 1.0),\\n (0.0, 0.5, 0.0, 1.0),\\n (0.5, 0.0, 0.0, 1.0),\\n (0.5, 0.5, 0.5, 1.0),\\n (0, 0, 0, 1),\\n (0.0, 0.5, 0.5, 1.0),\\n (0.5, 0.0, 0.5, 1.0),\\n (0.5, 0.5, 0.0, 1.0),\\n (0.0, 0.0, 0.0, 0.5),\\n (0.0, 0.0, 0.5, 0.5),\\n (0.0, 0.5, 0.5, 0.5),\\n (0.0, 0.5, 0.0, 0.5),\\n (0.5, 0.0, 0.5, 0.5),\\n (0.5, 0.5, 0.0, 0.5),\\n (0.5, 0.5, 0.5, 0.5),\\n (0.5, 0.0, 0.0, 0.5)]}\\n\\n init_triangulation(4, 1, check, nn_checks)\",\n \"def _build(self):\\n ary = np.zeros( (3,3,3), float )\\n ary[0,0,0] = ary[1,1,1] = ary[0,1,2] = ary[1,0,2] = 1.\\n ary[0,2,0] = ary[0,2,2] = ary[2,0,0] = ary[2,0,2] = 0.5\\n ary[1,2,1] = ary[1,2,2] = ary[2,1,1] = ary[2,1,2] = 0.5\\n ary[2,2,0] = ary[2,2,1] = 0.25\\n ary[2,2,2] = 0.5\\n return ary\",\n \"def six_cubed():\\n print(math.pow(6, 3))\",\n \"def board_state_to_nn_input(self, state):\\n # res = np.array([(state == self.side).astype(int),\\n # (state == Board.other_side(self.side)).astype(int),\\n # (state == EMPTY).astype(int)])\\n # res = res.reshape(3, 3, 3)\\n # res = np.transpose(res, [1, 2, 0])\\n res = np.array(state)\\n return res\",\n \"def homothick():\\n return se2hmt(binary([[1,1,1],\\n [0,0,0],\\n [0,0,0]]),\\n binary([[0,0,0],\\n [0,1,0],\\n [1,1,1]]))\",\n \"def test_4_2_5D_cube_splits(self):\\n check = [(0, 0, 0, 0, 0), (1, 1, 1, 1, 1), (1, 0, 0, 0, 0),\\n (1, 1, 0, 0, 0), (1, 1, 1, 0, 0), (1, 1, 1, 1, 0),\\n (1, 1, 1, 0, 1), (1, 1, 0, 1, 0), (1, 1, 0, 1, 1),\\n (1, 1, 0, 0, 1), (1, 0, 1, 0, 0), (1, 0, 1, 1, 0),\\n (1, 0, 1, 1, 1), (1, 0, 1, 0, 1), (1, 0, 0, 1, 0),\\n (1, 0, 0, 1, 1), (1, 0, 0, 0, 1), (0, 1, 0, 0, 0),\\n (0, 1, 1, 0, 0), (0, 1, 1, 1, 0), (0, 1, 1, 1, 1),\\n (0, 1, 1, 0, 1), (0, 1, 0, 1, 0), (0, 1, 0, 1, 1),\\n (0, 1, 0, 0, 1), (0, 0, 1, 0, 0), (0, 0, 1, 1, 0),\\n (0, 0, 1, 1, 1), (0, 0, 1, 0, 1), (0, 0, 0, 1, 0),\\n (0, 0, 0, 1, 1), (0, 0, 0, 0, 1), (0.5, 0.5, 0.5, 0.5, 0.5),\\n (0.0, 0.5, 0.5, 0.5, 0.5), (0.0, 0.0, 0.5, 0.5, 0.5),\\n (0.0, 0.0, 0.0, 0.5, 0.5), (0.0, 0.0, 0.0, 0.0, 0.5),\\n (0.0, 0.0, 0.0, 0.5, 0.0), (0.0, 0.0, 0.5, 0.0, 0.5),\\n (0.0, 0.0, 0.5, 0.0, 0.0), (0.0, 0.0, 0.5, 0.5, 0.0),\\n (0.0, 0.5, 0.0, 0.5, 0.5), (0.0, 0.5, 0.0, 0.0, 0.5),\\n (0.0, 0.5, 0.0, 0.0, 0.0), (0.0, 0.5, 0.0, 0.5, 0.0),\\n (0.0, 0.5, 0.5, 0.0, 0.5), (0.0, 0.5, 0.5, 0.0, 0.0),\\n (0.0, 0.5, 0.5, 0.5, 0.0), (0.5, 0.0, 0.5, 0.5, 0.5),\\n (0.5, 0.0, 0.0, 0.5, 0.5), (0.5, 0.0, 0.0, 0.0, 0.5),\\n (0.5, 0.0, 0.0, 0.0, 0.0), (0.5, 0.0, 0.0, 0.5, 0.0),\\n (0.5, 0.0, 0.5, 0.0, 0.5), (0.5, 0.0, 0.5, 0.0, 0.0),\\n (0.5, 0.0, 0.5, 0.5, 0.0), (0.5, 0.5, 0.0, 0.5, 0.5),\\n (0.5, 0.5, 0.0, 0.0, 0.5), (0.5, 0.5, 0.0, 0.0, 0.0),\\n (0.5, 0.5, 0.0, 0.5, 0.0), (0.5, 0.5, 0.5, 0.0, 0.5),\\n (0.5, 0.5, 0.5, 0.0, 0.0), (0.5, 0.5, 0.5, 0.5, 0.0),\\n (0.25, 0.25, 0.25, 0.25, 0.25), (1.0, 0.5, 0.5, 0.5, 0.5),\\n (1.0, 1.0, 0.5, 0.5, 0.5), (1.0, 1.0, 1.0, 0.5, 0.5),\\n (1.0, 1.0, 1.0, 1.0, 0.5), (1.0, 1.0, 1.0, 0.5, 1.0),\\n (1.0, 1.0, 0.5, 1.0, 0.5), (1.0, 1.0, 0.5, 1.0, 1.0),\\n (1.0, 1.0, 0.5, 0.5, 1.0), (1.0, 0.5, 1.0, 0.5, 0.5),\\n (1.0, 0.5, 1.0, 1.0, 0.5), (1.0, 0.5, 1.0, 1.0, 1.0),\\n (1.0, 0.5, 1.0, 0.5, 1.0), (1.0, 0.5, 0.5, 1.0, 0.5),\\n (1.0, 0.5, 0.5, 1.0, 1.0), (1.0, 0.5, 0.5, 0.5, 1.0),\\n (0.5, 1.0, 0.5, 0.5, 0.5), (0.5, 1.0, 1.0, 0.5, 0.5),\\n (0.5, 1.0, 1.0, 1.0, 0.5), (0.5, 1.0, 1.0, 1.0, 1.0),\\n (0.5, 1.0, 1.0, 0.5, 1.0), (0.5, 1.0, 0.5, 1.0, 0.5),\\n (0.5, 1.0, 0.5, 1.0, 1.0), (0.5, 1.0, 0.5, 0.5, 1.0),\\n (0.5, 0.5, 1.0, 0.5, 0.5), (0.5, 0.5, 1.0, 1.0, 0.5),\\n (0.5, 0.5, 1.0, 1.0, 1.0), (0.5, 0.5, 1.0, 0.5, 1.0),\\n (0.5, 0.5, 0.5, 1.0, 0.5), (0.5, 0.5, 0.5, 1.0, 1.0),\\n (0.5, 0.5, 0.5, 0.5, 1.0), (0.75, 0.75, 0.75, 0.75, 0.75),\\n (1.0, 0.0, 0.5, 0.5, 0.5), (1.0, 0.0, 0.0, 0.5, 0.5),\\n (1.0, 0.0, 0.0, 0.0, 0.5), (1.0, 0.0, 0.0, 0.5, 0.0),\\n (1.0, 0.0, 0.5, 0.0, 0.5), (1.0, 0.0, 0.5, 0.0, 0.0),\\n (1.0, 0.0, 0.5, 0.5, 0.0), (1.0, 0.5, 0.0, 0.5, 0.5),\\n (1.0, 0.5, 0.0, 0.0, 0.5), (1.0, 0.5, 0.0, 0.0, 0.0),\\n (1.0, 0.5, 0.0, 0.5, 0.0), (1.0, 0.5, 0.5, 0.0, 0.5),\\n (1.0, 0.5, 0.5, 0.0, 0.0), (1.0, 0.5, 0.5, 0.5, 0.0),\\n (0.75, 0.25, 0.25, 0.25, 0.25), (1.0, 1.0, 0.0, 0.5, 0.5),\\n (1.0, 1.0, 0.0, 0.0, 0.5), (1.0, 1.0, 0.0, 0.5, 0.0),\\n (1.0, 1.0, 0.5, 0.0, 0.5), (1.0, 1.0, 0.5, 0.0, 0.0),\\n (1.0, 1.0, 0.5, 0.5, 0.0), (0.5, 1.0, 0.0, 0.5, 0.5),\\n (0.5, 1.0, 0.0, 0.0, 0.5), (0.5, 1.0, 0.0, 0.0, 0.0),\\n (0.5, 1.0, 0.0, 0.5, 0.0), (0.5, 1.0, 0.5, 0.0, 0.5),\\n (0.5, 1.0, 0.5, 0.0, 0.0), (0.5, 1.0, 0.5, 0.5, 0.0),\\n (0.75, 0.75, 0.25, 0.25, 0.25), (1.0, 1.0, 1.0, 0.0, 0.5),\\n (1.0, 1.0, 1.0, 0.5, 0.0), (1.0, 0.5, 1.0, 0.0, 0.5),\\n (1.0, 0.5, 1.0, 0.0, 0.0), (1.0, 0.5, 1.0, 0.5, 0.0),\\n (0.5, 1.0, 1.0, 0.0, 0.5), (0.5, 1.0, 1.0, 0.0, 0.0),\\n (0.5, 1.0, 1.0, 0.5, 0.0), (0.5, 0.5, 1.0, 0.0, 0.5),\\n (0.5, 0.5, 1.0, 0.0, 0.0), (0.5, 0.5, 1.0, 0.5, 0.0),\\n (0.75, 0.75, 0.75, 0.25, 0.25), (1.0, 1.0, 0.5, 1.0, 0.0),\\n (1.0, 0.5, 1.0, 1.0, 0.0), (1.0, 0.5, 0.5, 1.0, 0.0),\\n (0.5, 1.0, 1.0, 1.0, 0.0), (0.5, 1.0, 0.5, 1.0, 0.0),\\n (0.5, 0.5, 1.0, 1.0, 0.0), (0.5, 0.5, 0.5, 1.0, 0.0),\\n (0.75, 0.75, 0.75, 0.75, 0.25), (1.0, 1.0, 0.5, 0.0, 1.0),\\n (1.0, 0.5, 1.0, 0.0, 1.0), (1.0, 0.5, 0.5, 0.0, 1.0),\\n (0.5, 1.0, 1.0, 0.0, 1.0), (0.5, 1.0, 0.5, 0.0, 1.0),\\n (0.5, 0.5, 1.0, 0.0, 1.0), (0.5, 0.5, 0.5, 0.0, 1.0),\\n (0.75, 0.75, 0.75, 0.25, 0.75), (1.0, 1.0, 0.0, 1.0, 0.5),\\n (1.0, 0.5, 0.0, 1.0, 0.5), (1.0, 0.5, 0.0, 1.0, 0.0),\\n (0.5, 1.0, 0.0, 1.0, 0.5), (0.5, 1.0, 0.0, 1.0, 0.0),\\n (0.5, 0.5, 0.0, 1.0, 0.5), (0.5, 0.5, 0.0, 1.0, 0.0),\\n (0.75, 0.75, 0.25, 0.75, 0.25), (1.0, 1.0, 0.0, 0.5, 1.0),\\n (1.0, 0.5, 0.0, 1.0, 1.0), (1.0, 0.5, 0.0, 0.5, 1.0),\\n (0.5, 1.0, 0.0, 1.0, 1.0), (0.5, 1.0, 0.0, 0.5, 1.0),\\n (0.5, 0.5, 0.0, 1.0, 1.0), (0.5, 0.5, 0.0, 0.5, 1.0),\\n (0.75, 0.75, 0.25, 0.75, 0.75), (1.0, 0.5, 0.0, 0.0, 1.0),\\n (0.5, 1.0, 0.0, 0.0, 1.0), (0.5, 0.5, 0.0, 0.0, 1.0),\\n (0.75, 0.75, 0.25, 0.25, 0.75), (1.0, 0.0, 1.0, 0.5, 0.5),\\n (1.0, 0.0, 1.0, 0.0, 0.5), (1.0, 0.0, 1.0, 0.5, 0.0),\\n (0.5, 0.0, 1.0, 0.5, 0.5), (0.5, 0.0, 1.0, 0.0, 0.5),\\n (0.5, 0.0, 1.0, 0.0, 0.0), (0.5, 0.0, 1.0, 0.5, 0.0),\\n (0.75, 0.25, 0.75, 0.25, 0.25), (1.0, 0.0, 1.0, 1.0, 0.5),\\n (1.0, 0.0, 0.5, 1.0, 0.5), (1.0, 0.0, 0.5, 1.0, 0.0),\\n (0.5, 0.0, 1.0, 1.0, 0.5), (0.5, 0.0, 1.0, 1.0, 0.0),\\n (0.5, 0.0, 0.5, 1.0, 0.5), (0.5, 0.0, 0.5, 1.0, 0.0),\\n (0.75, 0.25, 0.75, 0.75, 0.25), (1.0, 0.0, 1.0, 0.5, 1.0),\\n (1.0, 0.0, 0.5, 1.0, 1.0), (1.0, 0.0, 0.5, 0.5, 1.0),\\n (0.5, 0.0, 1.0, 1.0, 1.0), (0.5, 0.0, 1.0, 0.5, 1.0),\\n (0.5, 0.0, 0.5, 1.0, 1.0), (0.5, 0.0, 0.5, 0.5, 1.0),\\n (0.75, 0.25, 0.75, 0.75, 0.75), (1.0, 0.0, 0.5, 0.0, 1.0),\\n (0.5, 0.0, 1.0, 0.0, 1.0), (0.5, 0.0, 0.5, 0.0, 1.0),\\n (0.75, 0.25, 0.75, 0.25, 0.75), (1.0, 0.0, 0.0, 1.0, 0.5),\\n (0.5, 0.0, 0.0, 1.0, 0.5), (0.5, 0.0, 0.0, 1.0, 0.0),\\n (0.75, 0.25, 0.25, 0.75, 0.25), (1.0, 0.0, 0.0, 0.5, 1.0),\\n (0.5, 0.0, 0.0, 1.0, 1.0), (0.5, 0.0, 0.0, 0.5, 1.0),\\n (0.75, 0.25, 0.25, 0.75, 0.75), (0.5, 0.0, 0.0, 0.0, 1.0),\\n (0.75, 0.25, 0.25, 0.25, 0.75), (0.0, 1.0, 0.5, 0.5, 0.5),\\n (0.0, 1.0, 0.0, 0.5, 0.5), (0.0, 1.0, 0.0, 0.0, 0.5),\\n (0.0, 1.0, 0.0, 0.5, 0.0), (0.0, 1.0, 0.5, 0.0, 0.5),\\n (0.0, 1.0, 0.5, 0.0, 0.0), (0.0, 1.0, 0.5, 0.5, 0.0),\\n (0.25, 0.75, 0.25, 0.25, 0.25), (0.0, 1.0, 1.0, 0.5, 0.5),\\n (0.0, 1.0, 1.0, 0.0, 0.5), (0.0, 1.0, 1.0, 0.5, 0.0),\\n (0.0, 0.5, 1.0, 0.5, 0.5), (0.0, 0.5, 1.0, 0.0, 0.5),\\n (0.0, 0.5, 1.0, 0.0, 0.0), (0.0, 0.5, 1.0, 0.5, 0.0),\\n (0.25, 0.75, 0.75, 0.25, 0.25), (0.0, 1.0, 1.0, 1.0, 0.5),\\n (0.0, 1.0, 0.5, 1.0, 0.5), (0.0, 1.0, 0.5, 1.0, 0.0),\\n (0.0, 0.5, 1.0, 1.0, 0.5), (0.0, 0.5, 1.0, 1.0, 0.0),\\n (0.0, 0.5, 0.5, 1.0, 0.5), (0.0, 0.5, 0.5, 1.0, 0.0),\\n (0.25, 0.75, 0.75, 0.75, 0.25), (0.0, 1.0, 1.0, 0.5, 1.0),\\n (0.0, 1.0, 0.5, 1.0, 1.0), (0.0, 1.0, 0.5, 0.5, 1.0),\\n (0.0, 0.5, 1.0, 1.0, 1.0), (0.0, 0.5, 1.0, 0.5, 1.0),\\n (0.0, 0.5, 0.5, 1.0, 1.0), (0.0, 0.5, 0.5, 0.5, 1.0),\\n (0.25, 0.75, 0.75, 0.75, 0.75), (0.0, 1.0, 0.5, 0.0, 1.0),\\n (0.0, 0.5, 1.0, 0.0, 1.0), (0.0, 0.5, 0.5, 0.0, 1.0),\\n (0.25, 0.75, 0.75, 0.25, 0.75), (0.0, 1.0, 0.0, 1.0, 0.5),\\n (0.0, 0.5, 0.0, 1.0, 0.5), (0.0, 0.5, 0.0, 1.0, 0.0),\\n (0.25, 0.75, 0.25, 0.75, 0.25), (0.0, 1.0, 0.0, 0.5, 1.0),\\n (0.0, 0.5, 0.0, 1.0, 1.0), (0.0, 0.5, 0.0, 0.5, 1.0),\\n (0.25, 0.75, 0.25, 0.75, 0.75), (0.0, 0.5, 0.0, 0.0, 1.0),\\n (0.25, 0.75, 0.25, 0.25, 0.75), (0.0, 0.0, 1.0, 0.5, 0.5),\\n (0.0, 0.0, 1.0, 0.0, 0.5), (0.0, 0.0, 1.0, 0.5, 0.0),\\n (0.25, 0.25, 0.75, 0.25, 0.25), (0.0, 0.0, 1.0, 1.0, 0.5),\\n (0.0, 0.0, 0.5, 1.0, 0.5), (0.0, 0.0, 0.5, 1.0, 0.0),\\n (0.25, 0.25, 0.75, 0.75, 0.25), (0.0, 0.0, 1.0, 0.5, 1.0),\\n (0.0, 0.0, 0.5, 1.0, 1.0), (0.0, 0.0, 0.5, 0.5, 1.0),\\n (0.25, 0.25, 0.75, 0.75, 0.75), (0.0, 0.0, 0.5, 0.0, 1.0),\\n (0.25, 0.25, 0.75, 0.25, 0.75), (0.0, 0.0, 0.0, 1.0, 0.5),\\n (0.25, 0.25, 0.25, 0.75, 0.25), (0.0, 0.0, 0.0, 0.5, 1.0),\\n (0.25, 0.25, 0.25, 0.75, 0.75), (0.25, 0.25, 0.25, 0.25, 0.75)]\\n\\n nn_checks = {(1, 1, 1, 1, 1): [(1.0, 1.0, 1.0, 0.5, 1.0),\\n (1.0, 1.0, 0.5, 1.0, 1.0),\\n (1.0, 0.5, 0.5, 0.5, 0.5),\\n (1.0, 0.5, 1.0, 1.0, 0.5),\\n (0.5, 0.5, 1.0, 1.0, 1.0),\\n (1.0, 0.5, 0.5, 1.0, 0.5),\\n (1.0, 0.5, 1.0, 0.5, 0.5),\\n (0.5, 0.5, 0.5, 0.5, 1.0),\\n (0.5, 0.5, 1.0, 0.5, 1.0),\\n (0.5, 0.5, 0.5, 1.0, 1.0),\\n (0.5, 1.0, 0.5, 0.5, 0.5),\\n (0.5, 1.0, 1.0, 1.0, 0.5),\\n (0.5, 1.0, 1.0, 0.5, 0.5),\\n (0.5, 1.0, 0.5, 1.0, 0.5),\\n (1.0, 1.0, 1.0, 0.5, 0.5),\\n (1.0, 1.0, 0.5, 1.0, 0.5),\\n (1.0, 1.0, 0.5, 0.5, 0.5),\\n (1.0, 1.0, 1.0, 1.0, 0.5),\\n (1.0, 1.0, 0.5, 0.5, 1.0),\\n (1.0, 0.5, 1.0, 0.5, 1.0),\\n (1.0, 0.5, 0.5, 1.0, 1.0),\\n (0.5, 1.0, 0.5, 0.5, 1.0),\\n (0.5, 0.5, 1.0, 0.5, 0.5),\\n (1.0, 0.5, 0.5, 0.5, 1.0),\\n (1.0, 0.5, 1.0, 1.0, 1.0),\\n (0.5, 0.5, 0.5, 1.0, 0.5),\\n (0.75, 0.75, 0.75, 0.75, 0.75),\\n (0.5, 0.5, 1.0, 1.0, 0.5),\\n (0.5, 1.0, 1.0, 1.0, 1.0),\\n (0.5, 1.0, 1.0, 0.5, 1.0),\\n (0.5, 1.0, 0.5, 1.0, 1.0)],\\n (0.25, 0.75, 0.75, 0.75, 0.25): [(0.5, 1.0, 1.0, 1.0, 0.0),\\n (0.5, 0.5, 0.5, 1.0, 0.5),\\n (0, 1, 1, 1, 0),\\n (0.5, 1.0, 0.5, 0.5, 0.5),\\n (0.5, 1.0, 1.0, 1.0, 0.5),\\n (0.0, 1.0, 0.5, 0.5, 0.5),\\n (0.0, 1.0, 1.0, 1.0, 0.5),\\n (0.5, 1.0, 0.5, 1.0, 0.5),\\n (0.0, 1.0, 0.5, 1.0, 0.5),\\n (0.5, 1.0, 1.0, 0.5, 0.5),\\n (0.0, 1.0, 1.0, 0.5, 0.5),\\n (0.0, 1.0, 1.0, 0.5, 0.0),\\n (0.0, 1.0, 0.5, 1.0, 0.0),\\n (0.5, 1.0, 1.0, 0.5, 0.0),\\n (0.5, 1.0, 0.5, 1.0, 0.0),\\n (0.5, 1.0, 0.5, 0.5, 0.0),\\n (0.0, 1.0, 0.5, 0.5, 0.0),\\n (0.5, 0.5, 1.0, 0.5, 0.0),\\n (0.5, 0.5, 0.5, 1.0, 0.0),\\n (0.0, 0.5, 1.0, 0.5, 0.5),\\n (0.0, 0.5, 0.5, 1.0, 0.5),\\n (0.0, 0.5, 1.0, 0.5, 0.0),\\n (0.0, 0.5, 1.0, 1.0, 0.5),\\n (0.5, 0.5, 1.0, 1.0, 0.0),\\n (0.0, 0.5, 0.5, 0.5, 0.5),\\n (0.5, 0.5, 0.5, 0.5, 0.0),\\n (0.0, 0.5, 0.5, 1.0, 0.0),\\n (0.0, 0.5, 0.5, 0.5, 0.0),\\n (0.0, 0.5, 1.0, 1.0, 0.0),\\n (0.5, 0.5, 0.5, 0.5, 0.5),\\n (0.5, 0.5, 1.0, 1.0, 0.5),\\n (\\n 0.5, 0.5, 1.0, 0.5, 0.5)],\\n (0.0, 0.0, 1.0, 0.5, 1.0): [(0.5, 0.0, 0.5, 0.5, 1.0),\\n (0.0, 0.5, 0.5, 0.5, 1.0),\\n (0.5, 0.5, 0.5, 0.5, 1.0),\\n (0.0, 0.0, 0.5, 0.5, 1.0),\\n (0, 0, 1, 1, 1),\\n (0.5, 0.5, 1.0, 0.5, 1.0),\\n (0.5, 0.0, 1.0, 0.5, 1.0),\\n (0.0, 0.5, 1.0, 0.5, 1.0),\\n (0, 0, 1, 0, 1),\\n (0.5, 0.0, 1.0, 0.5, 0.5),\\n (0.0, 0.5, 1.0, 0.5, 0.5),\\n (0.5, 0.5, 1.0, 0.5, 0.5),\\n (0.0, 0.0, 1.0, 0.5, 0.5),\\n (0.5, 0.5, 0.5, 0.5, 0.5),\\n (0.0, 0.0, 0.5, 0.5, 0.5),\\n (0.25, 0.25, 0.75, 0.75, 0.75),\\n (0.5, 0.0, 0.5, 0.5, 0.5),\\n (0.0, 0.5, 0.5, 0.5, 0.5), (\\n 0.25, 0.25, 0.75, 0.25, 0.75)]}\\n\\n init_triangulation(5, 1, check, nn_checks)\",\n \"def _factorRepresentation(self, character, size):\\n # Create the character matrix space\\n rows = 2*size + 3\\n cols = size + 2\\n char_matrix = [[_SPACE]*cols for i in range(rows)] \\n\\n # Creates the constituent element\\n horizontal_line = [_H_LINE]*size\\n vertical_line = [_V_LINE]*size\\n\\n # Get the points to construct the number with the elements\\n horizontal_points = self._getHLinesPoints(character, size)\\n vertical_points = self._getVLinesPoints(character, size)\\n\\n for x, y in horizontal_points:\\n char_matrix[x][y:y+size] = horizontal_line\\n\\n for x, y in vertical_points:\\n for i in range(size):\\n char_matrix[x+i][y] = vertical_line[i]\\n\\n return char_matrix\",\n \"def reconstructImage(self,arr):\\n\\t\\tarr = arr * 256\\n\\t\\tarr = np.array(np.round(arr),dtype=np.uint8)\\n\\t\\t#arr = np.array(arr,dtype=np.uint8)\\n\\n\\t\\t# We need to transpose the array because we flatten X by columns\\n\\t\\t#arr = arr.T\\n\\t\\t#a = arr.reshape((self.width, self.height,3))\\n\\t\\t\\n\\t\\tif self.mode == 'L':\\n\\t\\t\\ta = arr.reshape((self.width, self.height))\\n\\t\\telse:\\n\\t\\t\\ta = arr.reshape((self.width, self.height,3))\\n\\n\\t\\t#a = arr.reshape((3,self.width, self.height))\\t\\t\\n\\t\\t#a = arr.transpose(0, 3, 1, 2)\\n\\n\\t\\tim = Image.fromarray(a,mode=self.mode)\\n\\n\\t\\treturn im\",\n \"def transpose():\",\n \"def test_Pad3D6():\\n input_shape = (1, 1, 2, 3, 2)\\n # pad = np.array([1, 0, 1, 2, 1, 0]).astype('int32')\\n pad = [1, 0, 1, 2, 1, 0]\\n mode = \\\"constant\\\"\\n res = [\\n [\\n [\\n [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]],\\n [[0, 0, 0], [0, 1, 2], [0, 3, 4], [0, 5, 6], [0, 0, 0], [0, 0, 0]],\\n [[0, 0, 0], [0, 7, 8], [0, 9, 10], [0, 11, 12], [0, 0, 0], [0, 0, 0]],\\n ]\\n ]\\n ]\\n data = np.arange(np.prod(input_shape)).reshape(input_shape) + 1\\n obj.run(res=res, padding=pad, mode=mode, data_format=\\\"NCDHW\\\", data=data)\",\n \"def cart2hom(arr):\\n if arr.ndim == 1:\\n return np.hstack([arr, 1])\\n return np.asarray(np.vstack([arr, np.ones(arr.shape[1])]))\",\n \"def auto_convert(boxes: Type[Union[Tensor, np.ndarray]], w: int, h: int):\\n\\n if boxes.max() < 2:\\n # to pixel coordinates\\n boxes[:, 0::2] *= w\\n boxes[:, 1::2] *= h\\n else:\\n # to normalized 0-1\\n boxes[:, 0::2] /= w\\n boxes[:, 1::2] /= h\\n return boxes\",\n \"def fisher_factor_inner_shape(self) -> Sequence[int]:\\n pass\",\n \"def tdim3(dim3):\\n return TransformedDimension(Compose([], dim3.type), dim3)\",\n \"def Solution(self):\\n self.solver.check()\\n m = self.solver.model()\\n answer = [[0] * self.width for i in range(self.height)]\\n for y in range(self.height):\\n for x in range(self.width):\\n answer[y][x] = int(str(m[self.grid[(x, y)]]))\\n return answer\",\n \"def c_matrix(x1,x2,x3):\\n\\tC = np.array([\\t[\\t2*(x2-x1), \\t\\t(x2-x1), \\t\\t\\t0\\t\\t\\t], \\\\\\n\\t\\t\\t\\t\\t[\\t(x2-x1), \\t\\t2*(x3-x1), \\t\\t(x3-x2)\\t\\t], \\\\\\n\\t\\t\\t\\t\\t[\\t0,\\t\\t\\t\\t(x3-x2),\\t\\t2*(x3-x2)\\t] \\t], \\\\\\n\\t\\t\\t\\t\\tfloat)\\n\\treturn(C)\",\n \"def rot6d_to_rotmat(x):\\n x = x.view(-1,3,2)\\n a1 = x[:, :, 0]\\n a2 = x[:, :, 1]\\n b1 = F.normalize(a1)\\n b2 = F.normalize(a2 - torch.einsum('bi,bi->b', b1, a2).unsqueeze(-1) * b1)\\n b3 = torch.cross(b1, b2)\\n return torch.stack((b1, b2, b3), dim=-1)\",\n \"def check3x3(self, board):\\n\\t\\t\\t# print \\\"This is check3x3\\\"\\n\\t\\t\\t# for i in xrange(0,9):\\n\\t\\t\\t# \\tprint board[i],\\n\\t\\t\\t# \\tif i%3 == 2:\\n\\t\\t\\t# \\t\\tprint\\n\\n\\t\\t\\tvalue = self.finddraw(board)\\n\\t\\t\\tif(value[1] != -1):\\n\\t\\t\\t\\treturn value[1]\\n\\t\\t\\t#Rows\\n\\t\\t\\tfor i in range(0,9):\\n\\t\\t\\t\\tif(i%3 == 0):\\n\\t\\t\\t\\t\\tif (board[i] == 'x' and board[i+1] == 'x' and board[i+2] == 'x'):\\n\\t\\t\\t\\t\\t\\tif(self.symbol == 'x'):\\n\\t\\t\\t\\t\\t\\t\\treturn 4\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\treturn 0\\n\\t\\n\\t\\t\\t\\t\\tif (board[i] == 'o' and board[i+1] == 'o' and board[i+2] == 'o'):\\n\\t\\t\\t\\t\\t\\tif(self.symbol == 'o'):\\n\\t\\t\\t\\t\\t\\t\\treturn 4\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\treturn 0\\n\\n\\t\\t\\t#Colomns\\n\\t\\t\\tfor i in range(0,3):\\n\\t\\t\\t\\tif(i/3 == 0):\\n\\t\\t\\t\\t\\tif (board[i] == 'x' and board[i+3] == 'x' and board[i+6] == 'x'):\\n\\t\\t\\t\\t\\t\\tif(self.symbol == 'x'):\\n\\t\\t\\t\\t\\t\\t\\treturn 4\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\treturn 0\\n\\t\\n\\t\\t\\t\\t\\tif (board[i] == 'o' and board[i+3] == 'o' and board[i+6] == 'o'):\\n\\t\\t\\t\\t\\t\\tif(self.symbol == 'o'):\\n\\t\\t\\t\\t\\t\\t\\treturn 4\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\treturn 0\\n\\n\\t\\t\\tcount = 0\\n\\t\\t\\tsavei = 0\\n\\t\\t\\tvalue = -1\\n\\t\\t\\tfor i in range(0,9):\\n\\t\\t\\t\\t\\tif(board[i] != '-'):\\n\\t\\t\\t\\t\\t\\tcount += 1\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tsavei = i\\n\\n\\t\\t\\tif(count == 9):\\n\\t\\t\\t\\treturn 1\\n\\t\\t\\tif(count == 8):\\n\\t\\t\\t\\tif(self.symbol == 'x'):\\n\\t\\t\\t\\t\\tboard[savei] = 'o'\\n\\t\\t\\t\\t\\tvalue = self.finddraw(board)\\n\\t\\t\\t\\tif(self.symbol == 'o'):\\n\\t\\t\\t\\t\\tboard[savei] = 'x'\\n\\t\\t\\t\\t\\tvalue = self.finddraw(board)\\n\\t\\t\\t\\tif(value[1] > -1):\\n\\t\\t\\t\\t\\tif(value[1] == 1):\\n\\t\\t\\t\\t\\t\\treturn 1\\n\\t\\t\\t\\t\\tif(value[1] == 4):\\n\\t\\t\\t\\t\\t\\treturn 2\\n\\n\\t\\t\\treturn -1\",\n \"def test_round_trip_conversion(self):\\n\\n for num_qubits in range(1, 5):\\n # Since we know the implementations don't depend on well-formed input data,\\n # just generate a random d^2 x d^2 matrix as test data for all conversions.\\n dim = 2**(2 * num_qubits)\\n mat = np.random.rand(dim, dim)\\n assert_allclose(mat, vec2mat(mat2vec(mat)))\\n assert_allclose(liou2choi(choi2liou(mat)), mat)\\n assert_allclose(choi2liou(liou2choi(mat)), mat)\",\n \"def coupling_6j((J1,J2,J3),(J4,J5,J6)):\\n cj6=pygsl.sf.coupling_6j(int(2*J1),int(2*J2), int(2*J3), int(2*J4),int(2*J5), int(2*J6))[0]\\n cj6=(-1)**(J1+J2+J4+J5)*hat(J3)*hat(J6)*cj6 \\n return cj6\",\n \"def cube_array(self):\\n cube_sides = {}\\n\\n for side in SIDES:\\n cube_sides[side] = []\\n \\n # Todo Break this loop into helper functions for clarity and simplicity\\n for coord in COORDS_3:\\n for cubie in self.cubies:\\n # Making sure that the cubes cubies are processed in the correct order\\n if np.array_equal(cubie.coordinates, coord): \\n \\n \\n for side in SIDES:\\n if cubie.in_side(side):\\n for face in cubie.faces:\\n \\n # Checking that the face of the cubie has the same norm as the side we are processing\\n if np.array_equal(face.norm, NORMS[side]):\\n cube_sides[side].append(face.colour)\\n\\n new_list = [cube_sides[\\\"U\\\"], cube_sides[\\\"F\\\"], reversal(cube_sides[\\\"R\\\"]), reversal(cube_sides[\\\"B\\\"]),\\n cube_sides[\\\"L\\\"], reversal(cube_sides[\\\"D\\\"])]\\n \\n final_list = [nine_to_3x3(side) for side in new_list]\\n return final_list\",\n \"def ggn_factor_inner_shape(self) -> Sequence[int]:\\n pass\",\n \"def mixing_matrix_2nu(sth):\\n cth = sqrt(1.0-sth*sth)\\n\\n U00 = cth\\n U01 = sth\\n U10 = -sth\\n U11 = cth\\n\\n return [[U00,U01],[U10,U11]]\",\n \"def _to_b_c_L_h_w(x, x_shape):\\r\\n x = tf.reshape(x, (-1,\\r\\n int(x_shape[1]),\\r\\n int(x_shape[2]),\\r\\n int(x_shape[3]),\\r\\n int(x_shape[4])))\\r\\n return x\",\n \"def atlas6():\\n\\n Atlas = graph_atlas_g()[0:208] # 208\\n # remove isolated nodes, only connected graphs are left\\n U = nx.Graph() # graph for union of all graphs in atlas\\n for G in Atlas:\\n zerodegree = [n for n in G if G.degree(n) == 0]\\n for n in zerodegree:\\n G.remove_node(n)\\n U = nx.disjoint_union(U, G)\\n\\n # iterator of graphs of all connected components\\n C = (U.subgraph(c) for c in nx.connected_components(U))\\n\\n UU = nx.Graph()\\n # do quick isomorphic-like check, not a true isomorphism checker\\n nlist = [] # list of nonisomorphic graphs\\n for G in C:\\n # check against all nonisomorphic graphs so far\\n if not iso(G, nlist):\\n nlist.append(G)\\n UU = nx.disjoint_union(UU, G) # union the nonisomorphic graphs\\n return UU\",\n \"def rot6d_to_rotmat(x):\\n x = x.view(-1, 3, 2)\\n a1 = x[:, :, 0]\\n a2 = x[:, :, 1]\\n b1 = F.normalize(a1)\\n b2 = F.normalize(a2 - torch.einsum('bi,bi->b', b1, a2).unsqueeze(-1) * b1)\\n b3 = torch.cross(b1, b2)\\n return torch.stack((b1, b2, b3), dim=-1)\",\n \"def rot6d_to_rotmat(x):\\n x = x.view(-1, 3, 2)\\n a1 = x[:, :, 0]\\n a2 = x[:, :, 1]\\n b1 = F.normalize(a1)\\n b2 = F.normalize(a2 - torch.einsum('bi,bi->b', b1, a2).unsqueeze(-1) * b1)\\n b3 = torch.cross(b1, b2)\\n return torch.stack((b1, b2, b3), dim=-1)\",\n \"def three_d6() -> list:\\n rolls: List[int] = []\\n for i in range(1, 7):\\n roll: int = multi_die(3, 6)\\n rolls.append(roll)\\n return rolls\",\n \"def checksumToBoard(self):\\n\\t\\treal_board = [[ '.' for x in range(9)] for x in range(9)] \\n\\n\\t\\txstart = 0\\n\\t\\txend = 3\\n\\t\\tystart = 0\\n\\t\\tyend = 3\\n\\n\\t\\tfor i in range(0,3):\\n\\t\\t\\tself.makeBoard(i,real_board,xstart,xend,ystart,yend)\\n\\t\\t\\tystart += 3\\n\\t\\t\\tyend += 3\\n\\n\\t\\n\\t\\txstart = 3\\n\\t\\txend = 6\\n\\t\\tystart = 0\\n\\t\\tyend = 3\\n\\t\\tfor i in range(3,6):\\n\\t\\t\\tself.makeBoard(i,real_board,xstart,xend,ystart,yend)\\n\\t\\t\\tystart += 3\\n\\t\\t\\tyend += 3\\n\\n\\n\\t\\txstart = 6\\n\\t\\txend = 9\\n\\t\\tystart = 0\\n\\t\\tyend = 3\\n\\t\\tfor i in range(6,9):\\n\\t\\t\\tself.makeBoard(i,real_board,xstart,xend,ystart,yend)\\n\\t\\t\\tystart += 3\\n\\t\\t\\tyend += 3\\n\\n\\t\\t# print 'Board created from checksum values:'\\n\\t\\t# for i in range(0,9):\\n\\t\\t# \\tfor j in range(0,9):\\n\\t\\t# \\t\\tprint real_board[i][j],\\n\\t\\t# \\t\\tif j%3 == 2:\\n\\t\\t# \\t\\t\\tprint \\\"|\\\",\\n\\t\\t# \\tprint\\n\\t\\t# \\tif i%3 == 2:\\n\\t\\t# \\t\\tprint \\\" _ _ _ _ _ _ _ _ _\\\"\\n\\n\\t\\treturn real_board\",\n \"def convgridone(a, pi, fi, gcf, v):\\n \\tsx, sy= gcf[0][0].shape[0]/2, gcf[0][0].shape[1]/2\",\n \"def subpel_conv3x3(in_ch, out_ch, r=1):\\n # return nn.Sequential(\\n # nn.Conv2d(in_ch, out_ch * r**2, kernel_size=3, padding=1),\\n # nn.PixelShuffle(r))\\n # change\\n return nn.SequentialCell([nn.Conv2d(in_ch, out_ch * r**2, kernel_size=3, padding=1),\\n # # TODO BY J : no pixel shuffle in mindspore\\n # nn.PixelShuffle(r))\\n ])\",\n \"def convertToRow(initialState):\\n size = np.sqrt(len(initialState))\\n rowform = ''\\n for i in range(int(size)):\\n j = i;\\n while j < len(initialState):\\n rowform += initialState[j]\\n j += 3\\n return rowform\",\n \"def _change_box_format(self, boxes):\\n boxes[..., 0] = boxes[..., 0]\\n boxes[..., 1] = boxes[..., 1]\\n boxes[..., 2] = boxes[..., 2]\\n boxes[..., 3] = boxes[..., 1] + boxes[..., 3]\\n boxes[..., 4] = boxes[..., 2] + boxes[..., 4]\\n return boxes\",\n \"def __set_TP(self):\\t\\n\\t\\tfor r in range(8,self.size - 8):\\n\\t\\t\\tself.matrix[r][6] = int(r % 2 == 0)\\n\\n\\t\\tfor c in range(8,self.size - 8):\\n\\t\\t\\tself.matrix[6][c] = int(c % 2 == 0)\\n\\n\\t\\tself.matrix[self.size-8][8] = 1\",\n \"def _mat3(self):\\n if self.frame.orientation == HillFrame.DEFAULT_ORIENTATION:\\n return np.identity(3)\\n else:\\n return self.QSW2TNW\",\n \"def conver1D(array):\\n l = array.shape\\n total = np.zeros((0, l[1] * l[2]), dtype=np.float32)\\n i = 0\\n for i in range(24):\\n tempData = array[i]\\n array1D = []\\n for x in tempData:\\n for s in x:\\n array1D.append(s)\\n total = np.insert(total, i, array1D, axis=0)\\n return total\",\n \"def convertBoard(self):\\n \\n board = \\\"\\\"\\n \\n for m in self.squares:\\n board += str(convertMarker(m)) + \\\" \\\"\\n \\n return board\",\n \"def transform_play_to_column(play):\\n\\n return [2 ** i for i in range(49)].index(play) // 7\",\n \"def cube(n):\\n return n**3\",\n \"def box_3d_to_3d_iou_format(boxes_3d):\\n boxes_3d = np.asarray(boxes_3d)\\n fc.check_box_3d_format(boxes_3d)\\n\\n iou_3d_boxes = np.zeros([len(boxes_3d), 7])\\n iou_3d_boxes[:, 4:7] = boxes_3d[:, 0:3]\\n iou_3d_boxes[:, 1] = boxes_3d[:, 3]\\n iou_3d_boxes[:, 2] = boxes_3d[:, 4]\\n iou_3d_boxes[:, 3] = boxes_3d[:, 5]\\n iou_3d_boxes[:, 0] = boxes_3d[:, 6]\\n\\n return iou_3d_boxes\",\n \"def 3Sat(B):\",\n \"def generate_3d_board(n):\\n layer = nxn_generate.generate_shuffled_2d_board(n)\\n cube = []\\n for i in range(len(layer)):\\n new_layer = []\\n for column in layer:\\n new_column = []\\n # this nested mess is to ensure that none of the sub 3x3 squares violates sudoku rules from any x y or z\\n # perspective (also the Latin Square rules but the subsquares are trickier and the cause of more mess)\\n for j in range(int(math.sqrt(len(layer)))):\\n for k in range(int(math.sqrt(len(layer)))):\\n # lot of 3 = (i+j) % 3\\n # index within lot = (i + k + (i//3)) % 3\\n new_column.append(column[int(math.sqrt(len(layer))) * ((i + j) % int(math.sqrt(len(layer)))) + (\\n i + k + (i // int(math.sqrt(len(layer))))) % int(math.sqrt(len(layer)))])\\n new_layer.append(new_column)\\n cube.append(new_layer)\\n\\n return shuffle_cube(cube)\",\n \"def make_state_appliable_4ch(state):\\n size = len(state)\\n st_appl = np.zeros((size,)*4, dtype=complex)\\n for p1 in range(size):\\n for p2 in range(size):\\n for p3 in range(size):\\n for p4 in range(size):\\n st_appl[p1, p2, p3, p4] = state[p1, p2, p3, p4] * sqrt(factorial(p1) * factorial(p2) * factorial(p3) * factorial(p4))\\n return st_appl\",\n \"def get5x5matrix(self): #modified from nxvasc get3x3matrix()\\n try:\\n i = na.identity(3)\\n \\n self.d124 = i.copy()\\n self.ds124 = na.zeros(124,na.float64)\\n \\n for k in range(1,124):\\n self.d124 = na.concatenate((self.d124,i))\\n# print len(self.d124)\\n count = 0\\n a = []\\n for k in range(-2,3):\\n for j in range(-2,3):\\n for i in range(-2,3):\\n if( i != 0 or j != 0 or k != 0 ):\\n self.ds124[count] = math.sqrt(i**2+j**2+k**2)\\n count += 1\\n a.append(i)\\n a.append(j)\\n a.append(k)\\n# print len(a)\\n a = na.reshape(na.array(a),(372,1))\\n# print len(self.d124)\\n self.d124 = na.concatenate((self.d124,a),axis=1)\\n except Exception as error:\\n print(\\\"failed in get5x5matrix(): \\\", error)\",\n \"def _to_bc_L_h_w(x, x_shape):\\r\\n x = tf.reshape(x, (-1,\\r\\n int(x_shape[2]),\\r\\n int(x_shape[3]),\\r\\n int(x_shape[4])))\\r\\n return x\",\n \"def convert_3to1(seq):\\n term_list = []\\n for i in __kmers(seq,k=3):\\n res = __get_value(i,aa3_to1_dict)\\n term_list.append(res)\\n return ''.join(term_list)\",\n \"def _pad_1x1_to_3x3_tensor(self, kernel1x1):\\n if kernel1x1 is None:\\n return 0\\n else:\\n return torch.nn.functional.pad(kernel1x1, [1, 1, 1, 1])\",\n \"def push_up (grid):\\r\\n for i in range (3):\\r\\n for row in range(1,4):\\r\\n for col in range(4):\\r\\n if grid[row-1][col] == 0:\\r\\n grid[row-1][col] = grid[row][col]\\r\\n grid[row][col] = 0\\r\\n for row in range(1,4):\\r\\n for col in range(4):\\r\\n if grid[row-1][col] == grid[row][col]:\\r\\n grid[row-1][col] = grid[row-1][col]*2\\r\\n grid[row][col]=0\\r\\n for row in range(1,4):\\r\\n for col in range(4):\\r\\n if grid[row-1][col] == 0:\\r\\n grid[row-1][col] = grid[row][col]\\r\\n grid[row][col] = 0\\r\\n \\r\\n return grid\",\n \"def test_3_1_4D_cube_init(self):\\n check = [(0, 0, 0, 0), (1, 1, 1, 1), (1, 0, 0, 0), (1, 1, 0, 0),\\n (1, 1, 1, 0), (1, 1, 0, 1), (1, 0, 1, 0), (1, 0, 1, 1),\\n (1, 0, 0, 1), (0, 1, 0, 0), (0, 1, 1, 0), (0, 1, 1, 1),\\n (0, 1, 0, 1), (0, 0, 1, 0), (0, 0, 1, 1), (0, 0, 0, 1),\\n (0.5, 0.5, 0.5, 0.5)]\\n nn_checks = {(0, 1, 1, 0): [(1, 1, 1, 0), (0, 1, 1, 1), (1, 1, 1, 1),\\n (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 0),\\n (0.5, 0.5, 0.5, 0.5)],\\n (0.5, 0.5, 0.5, 0.5): [(1, 1, 0, 1), (1, 0, 1, 1),\\n (1, 1, 1, 0), (1, 0, 0, 0),\\n (1, 1, 0, 0), (1, 0, 1, 0),\\n (0, 1, 1, 1), (0, 0, 0, 1),\\n (1, 1, 1, 1), (1, 0, 0, 1),\\n (0, 1, 0, 0), (0, 0, 1, 0),\\n (0, 0, 0, 0), (0, 1, 1, 0),\\n (0, 1, 0, 1), (0, 0, 1, 1)],\\n (1, 0, 0, 0): [(1, 1, 0, 1), (1, 0, 1, 1), (1, 1, 1, 0),\\n (1, 1, 0, 0), (1, 0, 1, 0), (1, 1, 1, 1),\\n (1, 0, 0, 1), (0, 0, 0, 0),\\n (0.5, 0.5, 0.5, 0.5)]}\\n\\n init_triangulation(4, 0, check, nn_checks)\",\n \"def to_image_space(data):\\n return np.swapaxes(np.flip(data, 1), 0, 1)\",\n \"def axial_to_cube(axial):\\n x = axial[0] # q\\n z = axial[1] # r\\n y = -x-z\\n return tuple([x, y, z])\",\n \"def testCube(self):\\n cube = {i:(i^1,i^2,i^4) for i in range(8)}\\n self.check(cube,6)\",\n \"def preprocess_3d(im_stack):\\n im_stack /= 127.5\\n im_stack -= 1.0\\n return im_stack\",\n \"def bits_trippling_1(self):\\n bits = np.array((self.image_bits))\\n trippled_binary_image_bits = np.repeat(bits, 3)\\n return trippled_binary_image_bits\",\n \"def reduce_mini(minigrid):\\n row = []\\n for i in range(3):\\n for j in range(3):\\n row.append(minigrid[i][j])\\n for i in range(9):\\n if len(row[i]) == 1:\\n for j in range(9):\\n if i != j:\\n if row[i] in row[j]:\\n chunks = row[j].split(row[i])\\n row[j] = chunks[0] + chunks[1]\\n\\n count_dict = {}\\n for i in range(9):\\n for char in row[i]:\\n if char in count_dict:\\n count_dict[char] = \\\"X\\\"\\n else:\\n count_dict[char] = i\\n\\n for key in count_dict:\\n if count_dict[key] != \\\"X\\\":\\n row[count_dict[key]] = key\\n\\n for i in range(3):\\n for j in range(3):\\n minigrid[i][j] = row[(i*3)+j]\\n\\n return minigrid\",\n \"def conv7x7(self, in_planes, out_planes, stride=1):\\n c = self.conv(7, in_planes, out_planes, stride=stride)\\n return c\",\n \"def unvoigt(A):\\n a = np.zeros(shape=(3, 3))\\n a[0, 0] = A[0]\\n a[0, 1] = A[5]\\n a[0, 2] = A[4]\\n a[1, 0] = A[5]\\n a[1, 1] = A[1]\\n a[1, 2] = A[3]\\n a[2, 0] = A[4]\\n a[2, 1] = A[3]\\n a[2, 2] = A[2]\\n return a\",\n \"def make_grid(self):\\n\\n\\t\\tinit_grid = (self.grid_width//2, self.grid_height//2)\\n\\t\\tgrid_list = []\\n\\n\\t\\tfor i in range(self.canv_width//self.grid_width):\\n\\t\\t\\tfor j in range(self.canv_height//self.grid_height):\\n\\t\\t\\t\\tif j == 0 or j%2 ==0:\\n\\t\\t\\t\\t\\tgrid_list.append((init_grid[0]+i*self.grid_width, init_grid[1]+j*self.grid_height))\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tgrid_list.append((grid_list[-1][0]+(self.grid_width//2), init_grid[1]+j*self.grid_height))\\n\\n\\t\\treturn grid_list\",\n \"def blockshaped(input_suduko_2d):\\n h = input_suduko_2d.shape[0]\\n return (input_suduko_2d.reshape(h // 3, 3, -1, 3)\\n .swapaxes(1, 2)\\n .reshape(-1, 3, 3))\",\n \"def img_preprocess(img):\\n squares = []\\n x_size = img.shape[0]\\n assert x_size >= FIX_IMG_SQR_SIZE\\n y_size = img.shape[1]\\n assert y_size >= FIX_IMG_SQR_SIZE\\n for x in range(0, x_size, FIX_IMG_SQR_SIZE):\\n xstart = x\\n xend = xstart+FIX_IMG_SQR_SIZE\\n if xend > x_size:\\n xstart = x_size-FIX_IMG_SQR_SIZE\\n xend = x_size\\n for y in range(0, y_size, FIX_IMG_SQR_SIZE):\\n ystart = y\\n yend = ystart+FIX_IMG_SQR_SIZE\\n if yend > y_size:\\n ystart = y_size-FIX_IMG_SQR_SIZE\\n yend = y_size\\n square = img[xstart:xend, ystart:yend,:]\\n squares.append(SQ_OUT(square, xstart, ystart, 3.0, 3))\\n return squares\",\n \"def convert_game_action_to_3D_action(ga):\\n tile_type, from_row, to_row, nbr_to_move = ga\\n\\n return (tile_type, min(nbr_to_move,5), to_row)\",\n \"def transpose_3d():\\n tmp = np.random.random((10, 10, 10))\\n\\n a = tmp.T\\n b = np.empty(tmp.shape)\\n for j in range(tmp.shape[1]):\\n b[:, j, :] = tmp[:, j, :].T\\n\\n print(np.all(a == b))\",\n \"def mat24_perm_to_int(p):\\n oct = sum(1 << x for x in p[:8])\\n res = gc.vect_to_octad(oct) \\n #print(\\\"p2i oct\\\", hex(oct))\\n res -= STD_OCTAD\\n res += (res >> 12) & 759 \\n #print(\\\"p2i\\\", res)\\n p1 = [24]*32\\n oct, j = 8 * oct, 0x00 \\n for i in range(24):\\n o = oct & 8\\n p1[i] = (j >> o) & 0x1f\\n j += 1 << o\\n oct >>= 1\\n q, q_inv = [None]*8, [None]*8\\n for i in range(8):\\n j = p1[p[i] & 0x1f] & 7\\n q[j] = i\\n q_inv[i] = j\\n for i in range(6):\\n # exchange place i with place q_inv[i]\\n j = q_inv[i]\\n #q_inv[q[i]], q_inv[q[j]] = q_inv[q[j]], q_inv[q[i]]\\n #q[i], q[j] = q[j], q[i]\\n #assert q[:i] == q_inv[:i] == lrange(i)\\n q_inv[q[i]] = q_inv[q[j]]\\n q[j] = q[i]\\n #print(\\\"p2i%d\\\" % i, j-i) \\n res = res * (8 - i) + j - i\\n #print(\\\"p2ifinal\\\", p1[p[8] & 0x1f]) \\n return 16 * res + p1[p[8] & 0x1f]\",\n \"def get_mnist(one_hot_enc, normalized, flatten):\",\n \"def reduce_sub(sub,sudoku_grid):\\n minigrid = []\\n row = math.floor(sub/3)\\n col = sub % 3\\n start_row = row * 3\\n start_col = col * 3\\n for j in range(start_row,start_row+3):\\n minirow = []\\n for k in range(start_col,start_col+3):\\n minirow.append(sudoku_grid[j][k])\\n minigrid.append(minirow)\\n minigrid = reduce_mini(minigrid)\\n for j in range(start_row,start_row+3):\\n for k in range(start_col,start_col+3):\\n sudoku_grid[j][k] = minigrid[j%3][k%3]\\n return sudoku_grid\",\n \"def tile_size_2d(self):\\n return 32.0, 32.0\",\n \"def _aseg_to_three():\\n import numpy as np\\n\\n # Base struct\\n aseg_lut = np.zeros((256,), dtype=\\\"int\\\")\\n # GM\\n aseg_lut[3] = 1\\n aseg_lut[8:14] = 1\\n aseg_lut[17:21] = 1\\n aseg_lut[26:40] = 1\\n aseg_lut[42] = 1\\n aseg_lut[47:73] = 1\\n\\n # CSF\\n aseg_lut[4:6] = 3\\n aseg_lut[14:16] = 3\\n aseg_lut[24] = 3\\n aseg_lut[43:45] = 3\\n aseg_lut[72] = 3\\n\\n # WM\\n aseg_lut[2] = 2\\n aseg_lut[7] = 2\\n aseg_lut[16] = 2\\n aseg_lut[28] = 2\\n aseg_lut[41] = 2\\n aseg_lut[46] = 2\\n aseg_lut[60] = 2\\n aseg_lut[77:80] = 2\\n aseg_lut[250:256] = 2\\n return tuple(aseg_lut)\",\n \"def get_unet1(patch_height, patch_width, channels, n_classes):\\n axis = 3\\n k = 3 # kernel size\\n s = 2 # stride\\n n_filters = 32 # number of filters 通道数\\n\\n #初始化keras张量\\n inputs = Input((patch_height, patch_width, channels))\\n\\n # n_filters：输出的维度 （k，k）：卷积核尺寸 padding：边缘填充\\n # 400,400,3 ==> 400,400,32\\n conv1 = Conv2D(n_filters, (k, k), padding='same')(inputs)\\n conv1 = BatchNormalization(scale=False, axis=axis)(conv1)\\n conv1 = Activation('relu')(conv1)\\n conv1 = Conv2D(n_filters, (k, k), padding='same')(conv1)\\n conv1 = BatchNormalization(scale=False, axis=axis)(conv1)\\n conv1 = Activation('relu')(conv1)\\n # 400,400,32 ==> 200,200,32\\n pool1 = MaxPooling2D(pool_size=(s, s))(conv1)\\n\\n # 200,200,32 ==> 200,200,32\\n conv2 = Conv2D(n_filters, (k, k), padding='same')(pool1)\\n conv2 = BatchNormalization(scale=False, axis=axis)(conv2)\\n conv2 = Activation('relu')(conv2)\\n conv2 = Conv2D(n_filters, (k, k), padding='same')(conv2)\\n conv2 = BatchNormalization(scale=False, axis=axis)(conv2)\\n conv2 = add([pool1, conv2])\\n conv2 = Activation('relu')(conv2)\\n x2 = Conv2D(2 * n_filters, (k, k), padding='same')(conv2)\\n # 200,200,32 ==> 100,100,64\\n output2 = Conv2D(n_filters * 2, (1,1),padding='same',strides=s)(conv2)\\n\\n # 200,200,32 ==> 100,100,64\\n conv3 = Conv2D(2 * n_filters, (k, k), padding='same',strides=s)(conv2)\\n conv3 = BatchNormalization(scale=False, axis=axis)(conv3)\\n conv3 = Activation('relu')(conv3)\\n # 100,100,64 ==> 100,100,64\\n conv3 = Conv2D(2 * n_filters, (k, k), padding='same')(conv3)\\n conv3 = BatchNormalization(scale=False, axis=axis)(conv3)\\n conv3 = add([output2,conv3])\\n conv3 = Activation('relu')(conv3)\\n x3 = Conv2D(4 * n_filters, (k, k), padding='same')(conv3)\\n # 100,100,64 ==> 50,50,128\\n output3 = Conv2D(n_filters * 4,(1,1),padding='same',strides=s)(conv3)\\n\\n # 100,100,64 ==> 50,50,128\\n conv4 = Conv2D(4 * n_filters, (k, k), padding='same',strides=s)(conv3)\\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\\n conv4 = Activation('relu')(conv4)\\n conv4 = Conv2D(4 * n_filters, (k, k), padding='same')(conv4)\\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\\n conv4 = add([output3,conv4])\\n conv4 = Activation('relu')(conv4)\\n # x4 == 50,50,256\\n x4 = Conv2D(8 * n_filters,(k,k),padding='same')(conv4)\\n # 50,50,128 ==> 25,25,256\\n output4 = Conv2D(8 * n_filters,(1,1),padding='same',strides=s)(conv4)\\n\\n # 50,50,128 ==> 25,25,256\\n conv5 = Conv2D(8 * n_filters, (k, k), padding='same',strides=s)(conv4)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(8 * n_filters, (k, k), padding='same')(conv5)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = add([output4,conv5])\\n conv5 = Activation('relu')(conv5)\\n # 25,25,256 ==> 25,25,512\\n output5 = Conv2D(16 * n_filters,(1,1),padding='same')(conv5)\\n\\n # 先上采样放大 在进行卷积操作 相当于转置卷积 并进行拼接\\n # 25,25,512 ==> 50,50,768\\n up1 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(output5), x4])\\n conv6 = Conv2D(8 * n_filters, (k, k), padding='same')(up1)\\n conv6 = BatchNormalization(scale=False, axis=axis)(conv6)\\n conv6 = Activation('relu')(conv6)\\n conv6 = Conv2D(8 * n_filters, (k, k), padding='same')(conv6)\\n conv6 = BatchNormalization(scale=False, axis=axis)(conv6)\\n conv6 = Activation('relu')(conv6)\\n\\n # 50,50,768 ==> 100,100,896\\n up2 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(conv6), x3])\\n conv7 = Conv2D(4 * n_filters, (k, k), padding='same')(up2)\\n conv7 = BatchNormalization(scale=False, axis=axis)(conv7)\\n conv7 = Activation('relu')(conv7)\\n conv7 = Conv2D(4 * n_filters, (k, k), padding='same')(conv7)\\n conv7 = BatchNormalization(scale=False, axis=axis)(conv7)\\n conv7 = Activation('relu')(conv7)\\n\\n # 100,100,896 ==> 200,200,960\\n up3 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(conv7), x2])\\n conv8 = Conv2D(2 * n_filters, (k, k), padding='same')(up3)\\n conv8 = BatchNormalization(scale=False, axis=axis)(conv8)\\n conv8 = Activation('relu')(conv8)\\n conv8 = Conv2D(2 * n_filters, (k, k), padding='same')(conv8)\\n conv8 = BatchNormalization(scale=False, axis=axis)(conv8)\\n conv8 = Activation('relu')(conv8)\\n\\n # 200,200,960 ==> 400,400,992\\n up4 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(conv8), conv1])\\n conv9 = Conv2D(n_filters, (k, k), padding='same')(up4)\\n conv9 = BatchNormalization(scale=False, axis=axis)(conv9)\\n conv9 = Activation('relu')(conv9)\\n conv9 = Conv2D(n_filters, (k, k), padding='same')(conv9)\\n conv9 = BatchNormalization(scale=False, axis=axis)(conv9)\\n conv9 = Activation('relu')(conv9)\\n\\n # 全连接层 400,400,992 ==> 400,400,5\\n outputs = Conv2D(n_classes, (1, 1), padding='same', activation='softmax')(conv9)\\n\\n unet = Model(inputs=inputs, outputs=outputs)\\n return unet\",\n \"def cube(n):\\n result = [num*num*num for num in range(n)]\\n\\n return result[1:]\",\n \"def _reshape_output(self, output):\\n output = np.transpose(output, [0, 2, 3, 1])\\n _, height, width, _ = output.shape\\n dim1, dim2 = height, width\\n dim3 = 3\\n # There are CATEGORY_NUM=80 object categories:\\n dim4 = (4 + 1 + CATEGORY_NUM)\\n return np.reshape(output, (dim1, dim2, dim3, dim4))\",\n \"def test_4_1_5D_cube_init(self):\\n check = [(0, 0, 0, 0, 0), (1, 1, 1, 1, 1), (1, 0, 0, 0, 0),\\n (1, 1, 0, 0, 0),\\n (1, 1, 1, 0, 0), (1, 1, 1, 1, 0), (1, 1, 1, 0, 1),\\n (1, 1, 0, 1, 0),\\n (1, 1, 0, 1, 1), (1, 1, 0, 0, 1), (1, 0, 1, 0, 0),\\n (1, 0, 1, 1, 0),\\n (1, 0, 1, 1, 1), (1, 0, 1, 0, 1), (1, 0, 0, 1, 0),\\n (1, 0, 0, 1, 1),\\n (1, 0, 0, 0, 1), (0, 1, 0, 0, 0), (0, 1, 1, 0, 0),\\n (0, 1, 1, 1, 0),\\n (0, 1, 1, 1, 1), (0, 1, 1, 0, 1), (0, 1, 0, 1, 0),\\n (0, 1, 0, 1, 1),\\n (0, 1, 0, 0, 1), (0, 0, 1, 0, 0), (0, 0, 1, 1, 0),\\n (0, 0, 1, 1, 1),\\n (0, 0, 1, 0, 1), (0, 0, 0, 1, 0), (0, 0, 0, 1, 1),\\n (0, 0, 0, 0, 1),\\n (0.5, 0.5, 0.5, 0.5, 0.5)]\\n\\n nn_checks = {(0, 1, 0, 1, 1): [(0, 0, 0, 0, 0), (\\n 0.5, 0.5, 0.5, 0.5, 0.5), (0, 0, 0, 1, 1), (1, 1, 0, 1, 1),\\n (0, 1, 0, 0, 0),\\n (0, 1, 0, 0, 1),\\n (0, 1, 0, 1, 0),\\n (0, 0, 0, 0, 1),\\n (1, 1, 1, 1, 1),\\n (0, 1, 1, 1, 1),\\n (0, 0, 0, 1, 0)]}\\n\\n init_triangulation(5, 0, check, nn_checks)\",\n \"def cube(num):\\n return num ** 3\",\n \"def scale4(a,c):\\n return [a[0]*c,a[1]*c,a[2]*c,a[3]*c]\",\n \"def _convert_to_square(self, bboxes):\\n\\n square_bboxes = torch.zeros_like(bboxes, device=self.device, dtype=torch.float32)\\n x1, y1, x2, y2 = [bboxes[:, i].float() for i in range(4)]\\n h = y2 - y1 + 1.0\\n w = x2 - x1 + 1.0\\n max_side = torch.max(h, w)\\n square_bboxes[:, 0] = x1 + w*0.5 - max_side*0.5\\n square_bboxes[:, 1] = y1 + h*0.5 - max_side*0.5\\n square_bboxes[:, 2] = square_bboxes[:, 0] + max_side - 1.0\\n square_bboxes[:, 3] = square_bboxes[:, 1] + max_side - 1.0\\n\\n square_bboxes = torch.ceil(square_bboxes + 1).int()\\n return square_bboxes\",\n \"def compute_output_shape(self, s):\\n return s[0], s[1] + 2 * self.padding[0], s[2] + 2 * self.padding[1], s[3]\",\n \"def dimensions():\",\n \"def convertInchTOPixel(self,*args):\\n return list(map(lambda x : int(x * 96),args))\",\n \"def dim_calculatorP3():\\r\\n probe_set = np.arange(1, 101)\\r\\n X = 20 - 36 + ((probe_set - 1) // 10) * 4\\r\\n Y = 2 - ((probe_set - 1) % 10) * 4\\r\\n dim = np.vstack((X, Y)).T\\r\\n return dim\",\n \"def _cal_meaningful_corners(self):\\n corners = np.where(self._free_of_clash)\\n corners = np.array(corners, dtype=int)\\n corners = corners.transpose()\\n return corners\",\n \"def convert_shape_to_units(self, shape):\\n unit_factor = [GDS[\\\"unit\\\"][0]] * 2\\n ll=shape[0].scale(unit_factor)\\n ur=shape[1].scale(unit_factor)\\n return [ll,ur]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61705595","0.59333605","0.56910497","0.56123316","0.5608155","0.55314213","0.5478484","0.5430528","0.54113424","0.5405368","0.5405368","0.5388583","0.5362073","0.5334513","0.53329366","0.53061944","0.5296388","0.5294149","0.52797616","0.5278745","0.52707386","0.5245799","0.5243086","0.5229329","0.52229434","0.52224565","0.5215046","0.5213403","0.51965284","0.51844686","0.5179628","0.51772475","0.51765305","0.51737416","0.51613057","0.51569927","0.51564014","0.5151788","0.5150488","0.5146132","0.513683","0.51363826","0.51266026","0.51244104","0.5123273","0.51157004","0.51157004","0.511409","0.51086825","0.5081101","0.50783604","0.5070497","0.5069503","0.5057875","0.50555533","0.50461686","0.5035263","0.5023621","0.5023232","0.50214565","0.5015822","0.50124955","0.50106204","0.50077146","0.50066817","0.5005906","0.5004704","0.499302","0.49895585","0.49855137","0.49846157","0.49795854","0.49729815","0.49659166","0.49650937","0.49581608","0.49543822","0.49450833","0.49424198","0.4937432","0.49317327","0.4926856","0.4923282","0.49189806","0.4916774","0.49155322","0.49138677","0.49062183","0.48973808","0.48957866","0.48947152","0.4881456","0.48811752","0.48754746","0.4875109","0.4874506","0.4873808","0.48726997","0.48710406","0.48703215"],"string":"[\n \"0.61705595\",\n \"0.59333605\",\n \"0.56910497\",\n \"0.56123316\",\n \"0.5608155\",\n \"0.55314213\",\n \"0.5478484\",\n \"0.5430528\",\n \"0.54113424\",\n \"0.5405368\",\n \"0.5405368\",\n \"0.5388583\",\n \"0.5362073\",\n \"0.5334513\",\n \"0.53329366\",\n \"0.53061944\",\n \"0.5296388\",\n \"0.5294149\",\n \"0.52797616\",\n \"0.5278745\",\n \"0.52707386\",\n \"0.5245799\",\n \"0.5243086\",\n \"0.5229329\",\n \"0.52229434\",\n \"0.52224565\",\n \"0.5215046\",\n \"0.5213403\",\n \"0.51965284\",\n \"0.51844686\",\n \"0.5179628\",\n \"0.51772475\",\n \"0.51765305\",\n \"0.51737416\",\n \"0.51613057\",\n \"0.51569927\",\n \"0.51564014\",\n \"0.5151788\",\n \"0.5150488\",\n \"0.5146132\",\n \"0.513683\",\n \"0.51363826\",\n \"0.51266026\",\n \"0.51244104\",\n \"0.5123273\",\n \"0.51157004\",\n \"0.51157004\",\n \"0.511409\",\n \"0.51086825\",\n \"0.5081101\",\n \"0.50783604\",\n \"0.5070497\",\n \"0.5069503\",\n \"0.5057875\",\n \"0.50555533\",\n \"0.50461686\",\n \"0.5035263\",\n \"0.5023621\",\n \"0.5023232\",\n \"0.50214565\",\n \"0.5015822\",\n \"0.50124955\",\n \"0.50106204\",\n \"0.50077146\",\n \"0.50066817\",\n \"0.5005906\",\n \"0.5004704\",\n \"0.499302\",\n \"0.49895585\",\n \"0.49855137\",\n \"0.49846157\",\n \"0.49795854\",\n \"0.49729815\",\n \"0.49659166\",\n \"0.49650937\",\n \"0.49581608\",\n \"0.49543822\",\n \"0.49450833\",\n \"0.49424198\",\n \"0.4937432\",\n \"0.49317327\",\n \"0.4926856\",\n \"0.4923282\",\n \"0.49189806\",\n \"0.4916774\",\n \"0.49155322\",\n \"0.49138677\",\n \"0.49062183\",\n \"0.48973808\",\n \"0.48957866\",\n \"0.48947152\",\n \"0.4881456\",\n \"0.48811752\",\n \"0.48754746\",\n \"0.4875109\",\n \"0.4874506\",\n \"0.4873808\",\n \"0.48726997\",\n \"0.48710406\",\n \"0.48703215\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.54071677"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":94490,"cells":{"query":{"kind":"string","value":"Query memory given an input embedding"},"document":{"kind":"string","value":"def query(self, query, n_neighbours):\n if self.added_memories == 0:\n return None\n # TODO: possibly L2-normalize query vector?\n # allow single queries as well, not only batches\n if query.dim() == 1:\n query.unsqueeze_(0)\n idx, distances = self.get_nearest_entries_ixs(query, n_neighbours)\n return {\n \"embedding\": self.memory_embeddings[idx],\n \"label\": self.memory_labels[idx],\n \"age\": self.memory_age[idx],\n \"relevance\": self.memory_relevance[idx],\n \"ix\": idx\n }"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_embed(input_data, vocab_size, embed_dim):\n embedding = tf.Variable(tf.random_uniform((vocab_size,embed_dim), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, input_data)\n #print (\"embed_dim: \",embed_dim) # 向量表达维度为 256\n #print (\"input_data.shape: \",input_data.shape) # (50, 5)\n #print (\"embed.shap: \", embed.shape) # word 的向量表达 ==特征 (50, 5, 256) ==(batch_size, num_step, embed_dim)\n return embed # 返回input的向量表达","def get_embed(input_data, vocab_size, embed_dim):\n # todo 需要编程：\n # 1、构建嵌入矩阵的查找表\n lookup_w = tf.Variable(\n initial_value=tf.random_uniform([vocab_size, embed_dim], -1.0, 1.0)\n )\n # 2、获得嵌入输出\n embed = tf.nn.embedding_lookup(params=lookup_w, ids=input_data)\n # [N, n_steps, embed_size]\n return embed","def embedded(self, word_ids, embedding_tensor, scope=\"embedding\"):\n with tf.variable_scope(scope):\n with tf.device(\"/cpu:0\"):\n inputs = tf.nn.embedding_lookup(embedding_tensor, word_ids)\n return inputs","def embed(query: str) -> dict:\n embedding = model.embed(query)\n return {\"embedding\": embedding, \"model\": model_name}","def get_embed(input_data, vocab_size, embed_dim):\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_dim), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, input_data)\n\n return embed","def get_embedding(self, resp):\n\n feed_dict = {self.anchor: resp}\n embedding = self.sess.run(self.embed_anchor, feed_dict=feed_dict)\n return embedding","def _read_adv_embeddings(identity, target):\n embeddings_file = os.path.join(\n FLAGS.output_directory,\n identity,\n FLAGS.attack_type,\n target\n )\n embeddings_file = os.path.join(FLAGS.image_directory,\n identity,\n 'embeddings.h5')\n with h5py.File(embeddings_file, 'r') as f:\n return f['embeddings'][:].astype(np.float32)","def _get_query_vec(self, inputs):\n if self._flags.model_type == \"bilstm_net\":\n network = self.bilstm_net\n elif self._flags.model_type == \"bow_net\":\n network = self.bow_net\n elif self._flags.model_type == \"cnn_net\":\n network = self.cnn_net\n elif self._flags.model_type == \"lstm_net\":\n network = self.lstm_net\n elif self._flags.model_type == \"gru_net\":\n network = self.gru_net\n else:\n raise ValueError(\"Unknown network type!\")\n\n prefix_letter_pool = network(inputs[\"prefix_letter_id\"],\n \"wordid_embedding\",\n self._flags.vocab_size,\n self._flags.emb_dim,\n hid_dim=self.hid_dim,\n fc_dim=0,\n emb_lr=self._flags.emb_lr)\n if isinstance(prefix_letter_pool, list):\n #max-pooling\n prefix_pool = _parse_raw_att(prefix_letter_pool, self, 'prefix')\n else:\n prefix_pool = [prefix_letter_pool]\n\n if self._flags.prefix_word_id:\n prefix_word_pool = network(inputs[\"prefix_word_id\"],\n \"wordid_embedding\",\n self._flags.vocab_size,\n self._flags.emb_dim,\n hid_dim=self.hid_dim,\n fc_dim=0,\n emb_lr=self._flags.emb_lr)\n if isinstance(prefix_word_pool, list):\n #max-pooling\n prefix_word_raw, prefix_word_att = _parse_raw_att(prefix_word_pool, self, 'prefix')\n prefix_pool[0] = fluid.layers.concat([prefix_pool[0], prefix_word_raw], axis=1)\n prefix_pool[1] = fluid.layers.concat([prefix_pool[1], prefix_word_att], axis=1)\n else:\n prefix_pool[0] = fluid.layers.concat([prefix_pool[0], prefix_word_pool], axis=1)\n\n prefix_vec = mlp_pool(prefix_pool, self._flags.prefix_mlp.split(','), self.hid_dim)\n #vector layer\n #fluid.layers.Print(inputs[\"prefix_letter_id\"])\n #fluid.layers.Print(inputs[\"prefix_word_id\"])\n #fluid.layers.Print(prefix_vec)\n loc_vec = None\n if self._flags.use_geohash:\n loc_vec = fluid.layers.reshape(fluid.layers.cast(x=inputs['prefix_loc_geoid'],\n dtype=\"float32\"), [-1, 40])\n loc_vec = fluid.layers.fc(input=loc_vec, size=self.hid_dim, act=\"leaky_relu\", \n param_attr=fluid.ParamAttr(name='loc_fc_weight'),\n bias_attr=fluid.ParamAttr(name='loc_fc_bias'))\n\n # day_vec = fluid.layers.reshape(fluid.layers.cast(x=inputs['day_id'],\n # dtype=\"float32\"), [-1, 14])\n # day_vec = fluid.layers.fc(input=loc_vec, size=self.hid_dim, act=\"leaky_relu\", \n # param_attr=fluid.ParamAttr(name='day_weight'),\n # bias_attr=fluid.ParamAttr(name='day_bias'))\n \n context_pool = fluid.layers.concat([prefix_vec, loc_vec], axis=1) if loc_vec is not None else prefix_vec\n context_vec = fluid.layers.fc(input=context_pool, size=self._flags.fc_dim, act=self._flags.activate,\n param_attr=fluid.ParamAttr(name='context_fc_weight'),\n bias_attr=fluid.ParamAttr(name='context_fc_bias'))\n return context_vec, context_pool","def call(self,\n inputs: tf.Tensor,\n **kwargs):\n # one dim case\n # out = self.embeddings[inputs[0]]\n\n # this feels like cheating, read docs for explanation\n out = embedding_ops.embedding_lookup(self.embeddings, inputs)\n return out","def test_extract_embeddings():\n with pytest.raises(OSError):\n model = BERTopic(bert_model='not_a_model')\n model._extract_embeddings([\"Some document\"])\n\n # model = BERTopic(bert_model='distilbert-base-nli-mean-tokens')\n # embeddings = model._extract_embeddings([\"Some document\"])\n #\n # assert isinstance(embeddings, np.ndarray)\n # assert embeddings.shape == (1, 768)","def test_extract_embeddings():\n docs = [\"some document\"]\n model = BERTopic(embedding_model=\"distilbert-base-nli-stsb-mean-tokens\")\n bertopic_embeddings = model._extract_embeddings(docs)\n\n assert isinstance(bertopic_embeddings, np.ndarray)\n assert bertopic_embeddings.shape == (1, 768)\n\n sentence_embeddings = embedding_model.encode(docs, show_progress_bar=False)\n assert np.array_equal(bertopic_embeddings, sentence_embeddings)","def embed(self, sequence):\n words = sequence.split(' ')\n vecs = [self._E[self._w2i[i]] if i in self._w2i else self._E[self._w2i[\"UNK\"]]\n for i in words]\n return vecs","def forward(self, input):\n if isinstance(input, tuple):\n check_input = input[0]\n else:\n check_input = input\n in_length, in_batch, nfeat = check_input.size()\n aeq(nfeat, len(self.emb_luts))\n\n emb = self.make_embedding(input)\n\n out_length, out_batch, emb_size = emb.size()\n aeq(in_length, out_length)\n aeq(in_batch, out_batch)\n aeq(emb_size, self.embedding_size)\n\n return emb","def search(self, column: str, query: Any, top_k: int) -> gp.DataFrame:\n assert self._dataframe._db is not None\n embdedding_info = self._dataframe._db._execute(\n f\"\"\"\n WITH indexed_col_info AS (\n SELECT attrelid, attnum\n FROM pg_attribute\n WHERE \n attrelid = '{self._dataframe._qualified_table_name}'::regclass::oid AND\n attname = '{column}'\n ), reloptions AS (\n SELECT unnest(reloptions) AS option\n FROM pg_class, indexed_col_info\n WHERE pg_class.oid = attrelid\n ), embedding_info_json AS (\n SELECT split_part(option, '=', 2)::json AS val\n FROM reloptions, indexed_col_info\n WHERE option LIKE format('_pygp_emb_%s=%%', attnum)\n ), embedding_info AS (\n SELECT * \n FROM embedding_info_json, json_to_record(val) AS (attnum int4, embedding_relid oid, model text)\n )\n SELECT nspname, relname, attname, model\n FROM embedding_info, pg_class, pg_namespace, pg_attribute\n WHERE \n pg_class.oid = embedding_relid AND\n relnamespace = pg_namespace.oid AND\n embedding_relid = attrelid AND\n pg_attribute.attnum = 2;\n \"\"\"\n )\n row: Row = embdedding_info[0]\n schema: str = row[\"nspname\"]\n embedding_table_name: str = row[\"relname\"]\n model = row[\"model\"]\n embedding_col_name = row[\"attname\"]\n embedding_df = self._dataframe._db.create_dataframe(\n table_name=embedding_table_name, schema=schema\n )\n assert self._dataframe.unique_key is not None\n distance = gp.operator(\"<->\") # L2 distance is the default operator class in pgvector\n return self._dataframe.join(\n embedding_df.assign(\n distance=lambda t: distance(\n embedding_df[embedding_col_name], _generate_embedding(query, model)\n )\n ).order_by(\"distance\")[:top_k],\n how=\"inner\",\n on=self._dataframe.unique_key,\n self_columns={\"*\"},\n other_columns={},\n )","def forward(self, x, mask, query_embed, pos_embed):\n _, bs, _ = x.shape\n query_embed = query_embed.unsqueeze(1).repeat(\n 1, bs, 1) # [num_query, embed_dims] -> [num_query, bs, embed_dims]\n\n enc_mem = self.encoder(\n query=x,\n key=None,\n value=None,\n query_pos=pos_embed,\n query_key_padding_mask=mask)\n target = torch.zeros_like(query_embed)\n # out_dec: [num_dec_layers, num_query, bs, embed_dims]\n out_dec = self.decoder(\n query=target,\n key=enc_mem,\n value=enc_mem,\n key_pos=pos_embed,\n query_pos=query_embed,\n key_padding_mask=mask)\n out_dec = out_dec.transpose(1, 2)\n return out_dec, enc_mem","def question_to_vec(question, embeddings):\n\n dim = embeddings['dog'].size\n result = np.zeros((dim,))\n\n words = question.split(' ')\n\n count = 0\n for word in words:\n if word not in embeddings or not len(embeddings[word]):\n continue\n result += embeddings[word][:dim]\n count += 1\n\n return result / max(count, 1)","def search_es(es, query_embeddings, k):\n es_query ={\n \"query\": {\n \"knn\": {\n \"embeddings\": {\n \"vector\": query_embeddings,\n \"k\": k\n }\n }\n }\n }\n \n res = es.search(index=ES_INDEX, body=es_query, size=k)\n uris = [hit['_source']['uri'] for hit in res['hits']['hits']]\n return uris","def QL_embeddings():\n ql = QatarLivingCorpus(dev_file)\n sent = []\n for th in ql:\n for s in ThreadParser(th).get_sentences():\n sent.append(s)\n # CBOW, size=100, window=5\n w2v = Word2Vec(sent)\n\n # useful after training to trim unneeded model memory = use (much) less RAM\n w2v.init_sims(replace=True)\n w2v.save_word2vec_format('../models/ql_w2v_cbow_s100_w5', binary=True)\n\n # test for embeddings\n test_embeddings(w2v)","def _embed(self):\n with tf.variable_scope('word_embedding'):\n self.pretrained_word_mat = tf.get_variable(\"word_emb_mat\",\n [self.vocab.word_size() - 2, self.vocab.word_embed_dim],\n dtype=tf.float32,\n initializer=tf.constant_initializer(\n self.vocab.word_embeddings[2:],\n dtype=tf.float32),\n trainable=False)\n self.word_pad_unk_mat = tf.get_variable(\"word_unk_pad\",\n [2, self.pretrained_word_mat.get_shape()[1]],\n dtype=tf.float32,\n initializer=tf.constant_initializer(\n self.vocab.word_embeddings[:2],\n dtype=tf.float32),\n trainable=True)\n\n self.word_mat = tf.concat([self.word_pad_unk_mat, self.pretrained_word_mat], axis=0)\n self.p_emb = tf.nn.embedding_lookup(self.word_mat, self.p)\n self.q_emb = tf.nn.embedding_lookup(self.word_mat, self.q)","def create_embedding_matrix(self):\n self.id2word = dict([(self.vocab[word]['id'], word) for word in self.vocab])\n vocab_size = len(self.vocab)\n result = np.zeros((vocab_size, self.embed_dim))\n unknown_token_set = set()\n\n found_words = 0\n avg = np.zeros(self.embed_dim)\n for _ in range(1, vocab_size): # skip PAD embedding (initialize as zero embedding)\n try:\n result[_] = self.pretrained_embedding[self.id2word[_]]\n avg += result[_]\n found_words += 1\n except:\n unknown_token_set.add(_)\n\n avg /= found_words\n for _ in unknown_token_set:\n result[_] = avg\n self.embedding = result\n return found_words, len(self.id2word)","def embedding(inputs,\n vocab_dim,\n embedding_dim,\n reuse,\n validate_indices=False,\n w_init=tf.random_uniform_initializer(-1., 1.),\n trainable=True,\n normalize=False,\n vocab_freqs=None,\n name=\"Embedding\"):\n\n input_shape = util.get_input_shape(inputs)\n assert len(input_shape) == 2, \"Input Tensor shape must be 2-D\"\n\n with tf.variable_scope(name, reuse=reuse):\n with tf.device('/cpu:0'):\n W = tf.get_variable(\n \"W\", shape=[vocab_dim, embedding_dim], initializer=w_init, trainable=trainable)\n if normalize:\n assert vocab_freqs is not None\n vocab_freqs = tf.constant(vocab_freqs, dtype=tf.float32, shape=(vocab_dim, 1))\n W = _normalize(W, vocab_freqs)\n\n output = tf.cast(inputs, tf.int32)\n output = tf.nn.embedding_lookup(W, output, validate_indices=validate_indices)\n\n shape = [-1] + output.get_shape().as_list()[1:3] + [1]\n # seq_length = util.retrieve_seq_length(tf.reshape(inputs, shape))\n\n return output","def embed(self, word: str) -> list:\n return self.emb_matrix[self.wordmapper[word]]","def load_embeddings(db):\n size = db['size'].values\n emb = db['embedding'].values\n emb = [np.load(i).flatten() for i in emb]\n return emb, size","def embed(self, features, feature_name, params):\n with tf.variable_scope(\"%s_embed\" % feature_name):\n embed_matrix = tf.get_variable(\"embedding_matrix\",\n [getattr(params, \"%s_vocab_size\" % feature_name), \n getattr(params, \"%s_embed_size\" % feature_name)])\n return tf.nn.embedding_lookup(embed_matrix, features[feature_name])","def embed(documents, ctx_encoder, ctx_tokenizer, device):\n input_ids = ctx_tokenizer(\n documents[\"title\"],\n documents[\"text\"],\n truncation=True,\n padding=\"longest\",\n return_tensors=\"pt\",\n )[\"input_ids\"]\n embeddings = ctx_encoder(\n input_ids.to(device=device), return_dict=True\n ).pooler_output\n return {\"embeddings\": embeddings.detach().cpu().numpy()}","def word_embedding_forward(x, W):\n out, cache = None, None\n ##############################################################################\n # TODO: Implement the forward pass for word embeddings. #\n # #\n # HINT: This should be very simple. #\n ##############################################################################\n out = W[x,:]\n cache = x, W\n\n ##############################################################################\n # END OF YOUR CODE #\n ##############################################################################\n return out, cache","def get_word_embeddings(t, folder, lang=\"en\"):\n vecs_url = f\"https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.{lang}.300.vec.gz\"\n vecs_gz_filename = vecs_url.rpartition(\"/\")[2]\n os.makedirs(folder, exist_ok=True)\n vecs_gz_filepath = os.path.join(folder, vecs_gz_filename)\n\n tokenizer_vocab_size = len(t.vocab)\n\n if wait_for_file_stable(vecs_gz_filepath):\n print(\"Using existing embeddings file\")\n else:\n print(\"Downloading word vectors...\")\n subprocess.run([\" \".join([\"wget\", \"-NP\", folder, vecs_url])], check=True, shell=True)\n\n print(\"Loading into memory...\")\n embeddings_index = dict()\n with gzip.open(vecs_gz_filepath, \"rt\") as zipf:\n firstline = zipf.readline()\n emb_vocab_size, emb_d = firstline.split(\" \")\n emb_vocab_size = int(emb_vocab_size)\n emb_d = int(emb_d)\n for line in zipf:\n values = line.split()\n word = values[0]\n # Only load subset of the embeddings recognised by the tokenizer:\n if word in t.vocab.stoi:\n coefs = np.asarray(values[1:], dtype=\"float32\")\n embeddings_index[word] = coefs\n print(\"Loaded {} of {} word vectors for tokenizer vocabulary length {}\".format(\n len(embeddings_index),\n emb_vocab_size,\n tokenizer_vocab_size,\n ))\n\n # create a weight matrix for words in training docs\n embedding_matrix = np.zeros((tokenizer_vocab_size, emb_d))\n for word, i in t.vocab.stoi.items():\n embedding_vector = embeddings_index.get(word)\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector\n\n return embedding_matrix","def link(self, input):\n self.input = input\n self.output = self.embeddings[self.input]\n return self.output","def embed_query(self, text: str) -> List[float]:\n embedding = self._embedding_func(text, engine=self.query_model_name)\n return embedding","def decode_beamsearch(self, enc_inputs, memory_key_padding_mask, decode_dict):\n k = decode_dict['k']\n batch_size = decode_dict['batch_size']\n time_step = decode_dict['time_step']\n vocab_size = decode_dict['vocab_size']\n device = decode_dict['device']\n start_token_id = decode_dict['start_token_id']\n stop_token_id = decode_dict['stop_token_id']\n alpha = decode_dict['alpha']\n length_offset = decode_dict['length_offset']\n keypadmask_dtype = decode_dict['keypadmask_dtype']\n\n # create beam array & scores\n beams = [None for _ in range(k)]\n beam_scores = np.zeros((batch_size, k))\n\n # we should only feed through the encoder just once!!\n enc_output = self.encoder(enc_inputs) # memory\n\n # we run the decoder time_step times (auto-regressive)\n tgt_ids = torch.zeros((batch_size, time_step), dtype=torch.int64).to(device)\n tgt_ids[:,0] = start_token_id\n for i in range(k):\n beams[i] = tgt_ids\n\n for t in range(time_step-1):\n # tgt_key_padding_mask\n row_padding_mask = [False]*(t+1) + [True]*(time_step-t-1)\n padding_mask = [row_padding_mask for _ in range(batch_size)]\n tgt_key_padding_mask = torch.tensor(padding_mask, dtype=keypadmask_dtype).to(device)\n\n decoder_output_t_array = torch.zeros((batch_size, k*vocab_size))\n\n for i, beam in enumerate(beams):\n decoder_output = self.decoder(beam, enc_output,\n tgt_mask=self.tgt_mask,\n tgt_key_padding_mask=tgt_key_padding_mask,\n memory_key_padding_mask=memory_key_padding_mask,\n logsoftmax=False)\n\n # check if there is STOP_TOKEN emitted in the previous time step already\n # i.e. if the input at this time step is STOP_TOKEN\n for n_idx in range(batch_size):\n if beam[n_idx][t] == stop_token_id: # already stop\n decoder_output[n_idx, t, :] = float('-inf')\n decoder_output[n_idx, t, stop_token_id] = 0.0 # to ensure STOP_TOKEN will be picked again!\n\n else: # need to update scores --- length norm\n beam_scores[n_idx,i] *= (t-1+length_offset)**alpha\n beam_scores[n_idx,i] /= (t+length_offset)**alpha\n\n # length_norm = 1/(length)^alpha ... alpha = 0.7\n decoder_output_t_array[:,i*vocab_size:(i+1)*vocab_size] = decoder_output[:,t,:]/(t+length_offset)**alpha\n\n # add previous beam score bias\n for n_idx in range(batch_size):\n decoder_output_t_array[n_idx,i*vocab_size:(i+1)*vocab_size] += beam_scores[n_idx,i]\n\n if t == 0: break # only fill once for the first time step\n\n # scores, indice => (batch_size, k)\n scores, indices = torch.topk(decoder_output_t_array, k=k, dim=-1)\n new_beams = [torch.zeros((batch_size, time_step), dtype=torch.int64).to(device) for _ in range(k)]\n for r_idx, row in enumerate(indices):\n for c_idx, node in enumerate(row):\n vocab_idx = node % vocab_size\n beam_idx = int(node / vocab_size)\n\n new_beams[c_idx][r_idx,:t+1] = beams[beam_idx][r_idx,:t+1]\n new_beams[c_idx][r_idx,t+1] = vocab_idx\n\n beam_scores = scores.cpu().numpy()\n beams = new_beams\n\n # if (t % 10) == 0:\n # print(\"{}=\".format(t), end=\"\")\n # sys.stdout.flush()\n # print(\"{}=#\".format(t))\n\n summaries_id = [None for _ in range(batch_size)]\n for j in range(batch_size): summaries_id[j] = beams[0][j].cpu().numpy()\n\n return summaries_id","def _get_embedding(self, data):\n # Tensor(n, c)\n cat = data['cat']\n return self.one_hot_embed(cat)","def _embed(self):\n with tf.variable_scope('word_embedding'):\n self.word_embeddings = tf.get_variable(\n 'word_embeddings',\n shape=(self.term_vocab.size(), self.term_vocab.embed_dim),\n initializer=tf.constant_initializer(self.term_vocab.embeddings),\n trainable=True\n )\n self.p_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.p)\n self.q_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.q)\n\n with tf.variable_scope('char_embedding'):\n self.char_embeddings = tf.get_variable(\n 'char_embeddings',\n shape=(self.char_vocab.size(), self.char_vocab.embed_dim),\n initializer=tf.constant_initializer(self.char_vocab.embeddings),\n trainable=True\n )\n self.p_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.p_char) # [batch, seqlen, max_char_num, embedding_size]\n self.q_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.q_char)\n\n self.p_char_emb = self.cnn_emb(self.p_char_emb, \"p_emb\")\n self.q_char_emb = self.cnn_emb(self.q_char_emb, \"q_emb\")\n '''\n self.p_char_emb = tf.reshape(self.p_char_emb, [-1, self.max_char_num, self.emb_size])\n self.q_char_emb = tf.reshape(self.q_char_emb, [-1, self.max_char_num, self.emb_size])\n\n self.p_char_emb = cnn_layer.conv(self.p_char_emb, self.emb_size,\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\"char_conv\", reuse=None)\n self.q_char_emb = cnn_layer.conv(self.q_char_emb, self.emb_size,\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\"char_conv\", reuse=True)\n\n self.p_char_emb = tf.reduce_max(self.p_char_emb, axis=1) # [batch*seqlen, 1, emb_size]\n self.q_char_emb = tf.reduce_max(self.q_char_emb, axis=1)\n\n batch_size = tf.shape(self.p_word_emb)[0]\n self.p_char_emb = tf.reshape(self.p_char_emb, [batch_size, -1, self.emb_size])\n self.q_char_emb = tf.reshape(self.q_char_emb, [batch_size, -1, self.emb_size])\n\n self.p_char_emb = tf.nn.dropout(self.p_char_emb, 0.95)\n self.q_char_emb = tf.nn.dropout(self.q_char_emb, 0.95)\n '''\n self.p_emb = tf.concat([self.p_word_emb, self.p_char_emb], -1)\n self.q_emb = tf.concat([self.q_word_emb, self.q_char_emb], -1)","def compute_embeddings(model, opts, data):\n node_embeddings = []\n node_scores = []\n # batch size is 1 for computing embeddings\n dataloader = DataLoader(dataset=data, batch_size=1, shuffle=True, num_workers=16)\n model.eval()\n print(\"computing embeddings...\")\n with torch.no_grad():\n for batch in tqdm(dataloader):\n batch.to(opts.device)\n batch_scores, batch_embeddings = model(batch, compute_embeddings=False)\n node_embeddings.append(batch_embeddings)\n node_scores.append(batch_scores)\n # input('enter for embeddings')\n # print(node_embeddings)\n\n return torch.stack(node_scores), torch.stack(node_embeddings)","def _lookup_embeddings(self, x):\n e_s = tf.nn.embedding_lookup(self.ent_emb, x[:, 0], name='embedding_lookup_subject')\n e_p = tf.nn.embedding_lookup(self.rel_emb, x[:, 1], name='embedding_lookup_predicate')\n e_o = tf.nn.embedding_lookup(self.ent_emb, x[:, 2], name='embedding_lookup_object')\n return e_s, e_p, e_o","def getWordEmbeddingsMatrix(script_directory, embedding_file):\n translator = str.maketrans('', '', string.punctuation)\n all_words = []\n print(\"Loading vocab from text files in:\")\n for d in os.listdir(script_directory):\n print(d)\n for fname in os.listdir(\"%s/%s\" % (script_directory, d)):\n with open(\"%s/%s/%s\" % (script_directory, d, fname), 'r') as f:\n words = [w.translate(translator) for w in f.read().split() if w.translate(translator) != \"\"]\n all_words.extend(words)\n\n model = KeyedVectors.load_word2vec_format(embedding_file, binary=True)\n vocab = {\"PAD\" : 0, \"EOS\" : 1}\n vocab.update({w : i + 2 for i,w in enumerate([w1 for w1 in set(all_words) if w1 in model]) })\n inv_dict = vocab.keys()\n ## Take a minute to load...\n\n vocab_size = len(inv_dict)\n emb_size = 300 # or whatever the size of your embeddings\n embeddings = np.zeros((vocab_size + 1, emb_size))\n for k,v in vocab.items():\n embeddings[v] = model[k]\n vocab[\"UNK\"] = len(vocab.keys())\n embeddings[vocab[\"UNK\"]] = np.ones(emb_size)\n del model\n ## Now we have a numpy matrix of embeddings...\n # x_model = tf.placeholder(tf.int32, shape=[None, input_size])\n # with tf.device(\"/cpu:0\"):\n # embedded_x = tf.nn.embedding_lookup(embeddings, x_model)\n return embeddings, vocab","def calculate_embeddings_from_buffer(_img, _network, verbose=False):\n \n img_buff = Image.open(BytesIO(_img))\n img = _reshape_image(np.array(img_buff))\n descs = calculate_embedding(img, _network, verbose=verbose)\n img_buff.close()\n \n return descs","def __glove_embed__(sequence, model):\n embedded = []\n for word in sequence:\n embedded.append(model[word])\n return embedded","def for_extract_embedding(maxChunk=10000, isMatrix=True):\n def wrapper(function):\n def _wrapper(self, input):\n \"\"\"\n @input: a 3-dimensional tensor with batch-dim=1 or [frames, feature-dim] matrix for \n acoustic features only\n @return: an 1-dimensional vector \n \"\"\"\n train_status = self.training\n self.eval()\n\n with torch.no_grad():\n if isMatrix:\n input = torch.tensor(input)\n input = torch.unsqueeze(input, dim = 0)\n input = input.transpose(1,2)\n\n input = utils.to_device(self, input)\n num_frames = input.shape[2]\n num_split = (num_frames + maxChunk - 1) // maxChunk\n split_size = num_frames // num_split\n \n offset = 0\n embedding_stats = 0.\n for i in range(0, num_split-1):\n this_embedding = function(self, input[:, :, offset:offset+split_size])\n offset += split_size\n embedding_stats += split_size*this_embedding\n\n last_embedding = function(self, input[:, :, offset:])\n\n embedding = (embedding_stats + (num_frames-offset) * last_embedding) / num_frames\n\n if train_status:\n self.train()\n\n return torch.squeeze(embedding.transpose(1,2)).cpu()\n\n return _wrapper\n return wrapper","def question_to_vec(question, embeddings, dim):\r\n\r\n words = question.split()\r\n\r\n counter = 0\r\n res = np.zeros(dim)\r\n for word in words:\r\n if word in embeddings:\r\n res += np.array(embeddings[word])\r\n counter += 1\r\n if counter!=0:\r\n return res/counter # mean of all word embeddings\r\n else:\r\n return res # vector of zeros\r","def extract_embeddings():\n session, _ = session_bundle.load_session_bundle_from_path(FLAGS.model_path)\n all_paths = FLAGS.input_path.split(',')\n with tf.gfile.Open(FLAGS.output_path, 'w') as out:\n for dataset, pattern in enumerate(all_paths, start=FLAGS.offset):\n paths = tf.gfile.Glob(pattern)\n for path in paths:\n make_request(dataset, path, out, session)","def get_pretrained_embeddings(source_vocab,embed_df):\r\n \r\n num_tokens = len(source_vocab)\r\n embedding_dim = embed_df.shape[1]\r\n weights = np.zeros((num_tokens,embedding_dim),dtype=np.float32)\r\n \r\n for idx in range(num_tokens):\r\n token = source_vocab.lookup_index(idx)\r\n if token in embed_df.index:\r\n weights[idx,:] = embed_df.loc[token]\r\n else:\r\n weights[idx,:] = np.random.randn(1,embedding_dim)\r\n \r\n embed_tensor = torch.FloatTensor(weights)\r\n return embed_tensor","def _get_embedding_layer(self, input_data, doc_input_data):\n opts = self._options\n word_embedding = tf.Variable(tf.random_uniform((self.vocab_size, opts.embed_dim), -1.0, 1.0))\n embed = []\n\n temp = tf.zeros([opts.batch_size, opts.embed_dim])\n embed_d = []\n for n in range(opts.sentence_sample):\n temp = tf.add(temp, tf.nn.embedding_lookup(word_embedding, doc_input_data[:, n]))\n embed_d.append(temp)\n\n if opts.concat == 'True':\n combined_embed_vector_length = opts.embed_dim * opts.window_size + opts.embed_dim\n for j in range(opts.window_size):\n embed_w = tf.nn.embedding_lookup(word_embedding, input_data[:, j])\n embed.append(embed_w)\n embed.append(embed_d)\n else:\n combined_embed_vector_length = opts.embed_dim\n embed_w = tf.zeros([opts.batch_size, opts.embed_dim])\n for j in range(opts.window_size):\n embed_w += tf.nn.embedding_lookup(word_embedding, input_data[:, j])\n embed_w += embed_d\n embed.append(embed_w)\n\n return tf.concat(embed, 1), word_embedding, combined_embed_vector_length","def extract_embedding(self, from_model):\n return from_model","def get_embeddings(self, data):\n raise NotImplementedError()","def text2vec(doc_tok, model, dim=300):\n doc_embedding = np.zeros(dim)\n valid_words = 0\n for word in doc_tok:\n if word in model:\n valid_words += 1\n doc_embedding += model.query(word)\n else:\n continue\n if valid_words > 0:\n return doc_embedding / valid_words\n else:\n return doc_embedding","def embed(self, smi_or_mol):\n if not isinstance(smi_or_mol, Chem.Mol):\n mol = Chem.MolFromSmiles(smi_or_mol)\n else:\n mol = smi_or_mol\n wv = self.model.wv\n sentence = self.substructure(mol)\n vec = np.zeros(self.model.vector_size)\n for fp in sentence:\n if fp in wv.vocab:\n vec += wv[fp]\n return vec","def evaluate_embedding(ids, sess, model, dataset, batch_size, normalize=True, rescale=None):\n\n nrof_images = len(ids)\n embedding_size = model.embeddings.get_shape()[1]\n #embedding_size should be 128\n emb_array = np.zeros((nrof_images, embedding_size))\n labels_array = np.zeros((nrof_images,))\n\n nrof_batches = int(math.ceil(1.0*nrof_images / batch_size))\n for i in range(nrof_batches):\n start_index = i*batch_size\n end_index = min((i+1)*batch_size, nrof_images)\n ids_batch = ids[start_index:end_index]\n images, labels = dataset.load_images(ids_batch, normalize=normalize, rescale=rescale)\n feed_dict = {model.images:images}\n emb_array[start_index:end_index,:] = sess.run(model.embeddings, feed_dict=feed_dict)\n labels_array[start_index:end_index] = labels\n return emb_array, labels_array","def get_embedding(A,B):\n st = minion_hom_algebras(A,B,inj=True)\n writefile('tmp.minion',st)\n os.system('minion -noprintsols -solsout tmp.txt tmp.minion >tmpout.txt')\n st = readfile('tmp.txt')\n os.system('rm tmp.txt')\n emb = st.split(\"\\n\")[:-1]\n if len(emb)>1: return emb[0]","def glove_embedding(self, word_index, padded, embedding_matrix, part='q'):\n print(\"*\" * 50, \"Start Glove embedding process\", \"*\" * 50)\n start_time = time()\n\n\n MAX_SEQ_LEN = None\n if part == 'q':\n MAX_SEQ_LEN = self.MAX_Q_SEQ_LEN\n elif part == 'a':\n MAX_SEQ_LEN = self.MAX_A_SEQ_LEN\n else:\n print(f\"Please indicate you want embedding question part or answer part\")\n\n\n input_layer = Input(shape=(MAX_SEQ_LEN,), dtype='int32')\n embedding_layer = Embedding(input_dim = len(word_index) + 1,\n output_dim = self.EMBEDDING_DIM,\n weights=[embedding_matrix],\n input_length=MAX_SEQ_LEN,\n trainable=False)(input_layer)\n # (number of sample, MAX_SEQ_LEN, EMBEDING_DIM)\n model = Model(inputs=input_layer, outputs=embedding_layer)\n model.compile('rmsprop', 'mse')\n output_array = model.predict(padded)\n\n cost_time = round((time() - start_time), 4)\n print(\"*\" * 40, \"End Glove embedding() with {} seconds\".format(cost_time), \"*\" * 40, end='\\n\\n')\n\n return output_array, embedding_layer","def embedding(x, vocab_size, dense_size, name=None, reuse=None, multiplier=1.0):\n with tf.variable_scope(\n name, default_name=\"embedding\", values=[x], reuse=reuse):\n embedding_var = tf.get_variable(\"kernel\", [vocab_size, dense_size])\n emb_x = tf.gather(embedding_var, x)\n if multiplier != 1.0:\n emb_x *= multiplier\n return emb_x","def forward(self, input_variable):\r\n return self.embedding(input_variable)","def _read_embeddings(identity):\n embeddings_file = os.path.join(FLAGS.image_directory,\n identity,\n 'embeddings.h5')\n with h5py.File(embeddings_file, 'r') as f:\n return f['embeddings'][:].astype(np.float32)","def get_glove_embedding():\n embedding = {}\n N = 400_000\n print(\"Reading glove embedding...\")\n with open(GLOVE_EMBD_PATH, \"rb\") as f:\n for line in tqdm(f, total=N):\n line = line.decode().split()\n word = line[0].lower()\n vector = np.array(line[1:]).astype(np.float32)\n embedding[word] = vector\n\n return embedding","def embed_with_info(self, word_batch: List[List[str]]) -> Tuple[Tuple[FloatTensor, LongTensor], Dict[str, int]]:\n # Add words to cache\n words = {word for sequence in word_batch for word in sequence}\n cache_info = self._cache_words(words)\n\n # Convert to indices\n index_batch = [[self.word_to_index[word] for word in sequence] for sequence in word_batch]\n\n return self._embed(index_batch), cache_info","def form_cand_queries_amongvocab(self, batch_input, gram):\n N = batch_input['pair_objects'].size(0)\n tensor_type = batch_input['pair_objects'].long().data.type()\n\n M = len(self.vocab[gram])\n cats = self.idx_to_vocab[gram].type(tensor_type)\n queries = cats.unsqueeze(0) \n labels = batch_input['labels_'+gram].type(queries.data.type()) #(N,M)\n\n return (queries, labels)","def _use_embeddings(self, word):\n if word == \"@PAD@\":\n return torch.zeros(self.embeddings_dim)\n else:\n return self.embeddings[word]","def embed(text: str) -> np.ndarray:\n n = nlp(text)\n return n.vector","def filter_embeddings(embeddings, vocab, dim):\n _embeddings = np.zeros([len(vocab), dim])\n for word in vocab:\n if word in embeddings:\n word_idx = vocab[word]\n _embeddings[word_idx] = embeddings[word]\n\n return _embeddings","def _query_it(records_query: List[str],\n batch_size: int,\n metadata: Training\n ) -> Iterator[Dict[str, np.ndarray]]:\n dataset = predict_data(records_query, metadata, batch_size)()\n X_tensor = dataset.make_one_shot_iterator().get_next()\n with tf.Session() as sess:\n while True:\n try:\n X = sess.run(X_tensor)\n if \"con\" in X:\n X[\"con\"] = _make_mask(X[\"con\"], X[\"con_mask\"])\n if \"cat\" in X:\n X[\"cat\"] = _make_mask(X[\"cat\"], X[\"cat_mask\"])\n yield X\n except tf.errors.OutOfRangeError:\n break\n return","def call(self, x, *args, **kwargs):\n with tf.name_scope(\"embedding\"):\n # fills out of bound values with padding symbol\n out_bound_mask = tf.cast(x > (self.vocab_size - 1), dtype=tf.int32)\n x *= 1 - out_bound_mask\n x += out_bound_mask * tf.cast(self.pad_sym, dtype=tf.int32)\n\n embeddings = tf.gather(self.shared_weights, x)\n if self.embed_scale:\n # Scale embedding by the sqrt of the hidden size\n embeddings *= self.hidden_size ** 0.5\n\n if self.mask_paddings:\n # Create binary array of size [batch_size, length]\n # where 1 = padding, 0 = not padding\n padding = get_padding(x, padding_value=self.pad_sym)\n\n # Set all padding embedding values to 0\n # embeddings *= tf.expand_dims(1 - padding, -1)\n embeddings *= tf.cast(tf.expand_dims(1.0 - padding, -1), dtype=embeddings.dtype)\n return embeddings","def embedding(org_input):\n # Create the embedding list\n for f in range(Config.num_feature):\n num_cat_value = Config.schema[f]\n\n if num_cat_value == 1:\n pass\n elif num_cat_value > 1:\n embed_dict[f] = tf.get_variable(\n name=\"embed_\" + str(f),\n shape=[num_cat_value, Config.embed_size[f]],\n trainable=True)\n else:\n raise ValueError(\"Schema values should be positive integers!\")\n\n # Create embedded inputs\n f_size = np.sum(Config.embed_size)\n embedded_input = embed_events(org_input, f_size)\n\n return embedded_input","def test_embedding_matrix_shape(self):\n num_embeddings = 10\n features = 5\n embed = layers.Embed(num_embeddings=num_embeddings, features=features)\n inputs = np.expand_dims(np.arange(features, dtype=np.int64), 1)\n variables = embed.init(jax.random.PRNGKey(0), inputs)\n embedding_matrix = variables['params']['embedding']\n self.assertEqual((num_embeddings, features), embedding_matrix.shape)","def get_batch(corpus, ind, vocab_size, device, emsize=300):\r\n batch_size = len(ind)\r\n data_batch = np.zeros((batch_size, vocab_size))\r\n\r\n for i, doc_id in enumerate(ind):\r\n doc = corpus[doc_id.data]\r\n L = len(doc)\r\n if doc_id != -1:\r\n for word_id in doc:\r\n counts = doc.count(word_id)\r\n data_batch[i, word_id] = counts\r\n data_batch = torch.from_numpy(data_batch).float().to(device)\r\n return data_batch","def run_demo():\n while True:\n embeddings = beer_emb.embed_doc(input(\"Test if words are beer-related: \"),\n word_filter=False)\n for word_vec in embeddings:\n print(is_beer_related(word_vec))","def query(self, annotation: Annotation):\n\n x = [annotation.fee_raw] + annotation.sentence\n\n x = [[self.input_field.vocab.stoi[t]] for t in x]\n\n network_output = self.network.query(x)\n _, frame = torch.max(network_output[0], 0)\n frame = self.output_field.vocab.itos[frame.item()]\n\n return frame","def add_entry(self, embeddings, labels, query_result=None):\n n_added = embeddings.shape[0]\n\n if self.added_memories + n_added <= self.memory_size:\n start = self.write_pointer + 1\n end = start + n_added\n self.update_ixs(range(start, end), embeddings, labels, query_result)\n self.write_pointer += n_added\n else:\n capacity_remaining = max(self.memory_size - self.added_memories, 0)\n if capacity_remaining > 0:\n start = self.write_pointer + 1\n self.update_ixs(range(start, self.memory_size), embeddings[:capacity_remaining], labels[:capacity_remaining],\n query_result, global_update=False)\n\n n_overflow = n_added - capacity_remaining\n # get least relevant indices\n if self.delete_method == \"relevance\":\n write_ixs = torch.topk(self.memory_relevance, n_overflow, largest=False).indices\n elif self.delete_method == \"age\":\n write_ixs = torch.topk(self.memory_age, n_overflow, largest=True).indices\n self.update_ixs(write_ixs, embeddings[capacity_remaining:], labels[capacity_remaining:], query_result)\n self.added_memories += n_added","def add_embedding(self):\n ### YOUR CODE HERE (~4-6 lines)\n embeddingTensor = tf.Variable(self.pretrained_embeddings)\n embeddings = tf.nn.embedding_lookup(embeddingTensor, self.input_placeholder)\n embeddings = tf.reshape(embeddings, [-1, self.max_length, Config.n_features * Config.embed_size])\n ### END YOUR CODE\n return embeddings","def get_embeddings(model, loader, device=torch.device('cpu')):\n embeddings = []\n labels = []\n for item in loader:\n data, label = item\n data = data.view(-1, 1, data.shape[-1])\n data = data.to(device)\n label = label.to(device)\n output = model(data).squeeze(1)\n\n embedding = output.cpu().data.numpy()\n label = label.cpu().data.numpy()\n embeddings.append(embedding)\n labels.append(label)\n\n embeddings = np.array(embeddings)\n labels = np.array(labels)\n\n return embeddings, labels","def build_embedding_layer(inputs_, vocab_size, embed_size):\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_size), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, inputs_)\n \n return embed","def read_embeddings(embedding_file):\r\n print(\"Reading embeddings...\", end=\"\")\r\n\r\n embeddings = dict()\r\n with h5py.File(embedding_file, 'r') as f:\r\n for key in f.keys():\r\n embeddings[key] = np.array(f[key], dtype=np.float32)\r\n\r\n print(f\"done! Found {len(embeddings.keys())} proteins.\")\r\n\r\n return embeddings","def embedd_data(training_data_text, e_arr, e_dict):\n num_samples = len(training_data_text)\n embedded = np.zeros([num_samples, MAX_WORDS_IN_REVIEW, EMBEDDING_SIZE])\n for i in range(num_samples):\n review_mat = np.zeros([MAX_WORDS_IN_REVIEW, EMBEDDING_SIZE])\n # Iterate to either the end of the sentence of the max num of words, whichever is less\n for w in range(min(len(training_data_text[i]), MAX_WORDS_IN_REVIEW)):\n # assign embedding of that word or to the UNK token if that word isn't in the dict\n review_mat[w] = e_arr[e_dict.get(training_data_text[i][w], 0)]\n embedded[i] = review_mat\n return embedded","def load_embeddings(path, vocab, source_domain, target_domain, emb_name):\n\n pkl = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\n if os.path.exists(pkl):\n print(\"Load embeddings from existing pkl file %s...\" % pkl)\n # word embeddings weights have been loaded\n embeddings = pickle.load(open(pkl, 'rb'))\n else:\n print(\"Load embedding from %s...\" % path)\n raw_embeddings = {}\n if emb_name == 'yelp_electronics':\n with open(path) as fp:\n for line in fp:\n word_vector = line.split(\",\")[:-1]\n vector_list = []\n for element in word_vector[len(word_vector) - 100:]:\n vector_list.append(float(element))\n word = ','.join(word_vector[:len(word_vector) - 100])\n vector = np.asarray(vector_list)\n if word in vocab:\n raw_embeddings[word] = vector\n else:\n with open(path) as fp:\n for line in fp:\n eles = line.strip().split(' ')\n word = eles[0]\n if word in vocab:\n raw_embeddings[word] = eles[1:]\n\n dim_w = len(raw_embeddings['the'])\n n_words = len(vocab)\n embeddings = np.zeros(shape=(n_words, dim_w))\n for w in vocab:\n wid = vocab[w]\n if w in raw_embeddings:\n embeddings[wid] = np.array([float(ele) for ele in raw_embeddings[w]])\n else:\n # for OOV words, add random initialization\n embeddings[wid] = np.random.uniform(-0.25, 0.25, dim_w)\n print(\"Find %s word embeddings...\" % len(embeddings))\n if not os.path.exists('./work/embeddings'):\n os.mkdir('./work/embeddings')\n emb_path = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\n # write the embedding weights back to the disk\n pickle.dump(embeddings, open(emb_path, 'wb'))\n embeddings = np.array(embeddings, dtype='float32')\n return embeddings","def batch_inference(question,context): \n inputs = tokenizer(question, context, \n return_tensors='pt', \n truncation=True, \n padding=True)\n \n # Move data to GPU\n inputs = inputs.to(device)\n \n # Feed data through the model\n with torch.no_grad():\n outputs = model(**inputs)\n\n # Q&A model outputs the two logit scores for each word.\n # One for its chance of being the start of the answer\n # and one for its chance of being the end\n start_logits = outputs.start_logits\n end_logits = outputs.end_logits\n \n # Find the words with the highest score\n # argmax(dim=1) means argmax with each sample\n start = start_logits.argmax(dim=1)\n end = end_logits.argmax(dim=1)\n \n # Return the answers\n # This is the point where we move the prediction back to main memory with .cpu()\n tokens = [tokenizer.convert_ids_to_tokens(x) for x in inputs[\"input_ids\"].cpu().numpy()]\n return [tokenizer.convert_tokens_to_string(x[start[i]:end[i]+1]) for i,x in enumerate(tokens)]","def main():\n logging.basicConfig(level=logging.DEBUG)\n custom_embedding = True\n\n # Download embeddings'\n if custom_embedding:\n embedding_path = '../data/custom_embedding.pkl'\n embedding_index_path = '../data/custom_vocab_index.pkl'\n logging.info('Pulling custom embedding from: {}, and custom vocab from: {}'.format(embedding_path, embedding_index_path))\n embedding_matrix = pickle.load(open(embedding_path, 'rb'))\n embedding_index_lookup = pickle.load(open(embedding_index_path, 'rb'))\n\n else:\n logging.warning('Downloading embedding. If downloading for the first time, this make take 5-10 minutes.')\n embedding_url = 'https://s3.amazonaws.com/dl4j-distribution/GoogleNews-vectors-negative300.bin.gz'\n embedding_path = '~/nlp_example/'\n embedding_filename = 'GoogleNews-vectors-negative300.bin.gz'\n lib.download_file(embedding_url, embedding_path, embedding_filename)\n\n # Unpack embedding\n model = gensim.models.KeyedVectors.load_word2vec_format(embedding_path + '/' + embedding_filename, binary=True)\n embedding_matrix = model.syn0\n embedding_index_lookup = dict([(k, v.index) for k, v in model.vocab.items()])\n\n # Create thesaurus\n thesaurus = Thesaurus(embedding_matrix, embedding_index_lookup)\n\n # Find nearest neighbors for examples\n print(thesaurus.synonyms('day'))\n print(thesaurus.synonyms('top'))\n print(thesaurus.synonyms('bottom'))\n print(thesaurus.synonyms('cat'))\n print(thesaurus.synonyms('grown'))\n\n\n pass","def get_embeddings(emb_path, emb_length, vocab_size, embedding_type):\n print(\"Loading {} embeddings from file: {}...\".format(embedding_type, emb_path))\n\n emb_matrix = []\n str2id = {}\n idx = 0\n with open(emb_path, 'r') as fh:\n for line in tqdm(fh, total=vocab_size):\n line = line.lstrip().rstrip().split(\" \")\n word = line[0]\n vector = list(map(float, line[1:]))\n if emb_length != len(vector):\n raise Exception(\n \"{}: Expected vector of size {}, but got vector of size {}.\".format(idx, emb_length, len(vector)))\n emb_matrix.append(vector)\n str2id[word] = idx\n idx += 1\n\n emb_matrix = np.array(emb_matrix, dtype=np.float32)\n print(\"Loaded {} embedding matrix with shape {}.\".format(embedding_type, emb_matrix.shape))\n\n return emb_matrix, str2id","def _manifold_to_dataspace(self, X_embedded):\n\n if self.A.shape[1] != X_embedded.shape[0]:\n X_embedded = X_embedded.T\n\n X_query_kd = self.A @ X_embedded[self.n_keep_dims:]\n X_query_kd = X_query_kd.T # make X_query_kd of shape (q x d)\n\n # concatenate column-wise\n if self.n_keep_dims > 0:\n X_query = np.hstack((X_embedded[:self.n_keep_dims], X_query_kd))\n else:\n X_query = X_query_kd\n\n X_query = self._unscale(X_query)\n return X_query","def generate_embeddings_memory(dataset_path, classes):\n # get embeddings not in generators\n model = embeddings(INPUT_DIM)\n X_train, X_test, y_train, y_test = get_train_test_lists(dataset_path, classes)\n X_train_em = []\n X_test_em = []\n\n for im in X_train:\n img = preprocess_image(im)\n embeds = model.predict(img)\n embeds = np.squeeze(embeds)\n X_train_em.append(embeds)\n for im in X_test:\n img = preprocess_image(im)\n embeds = model.predict(img)\n embeds = np.squeeze(embeds)\n X_test_em.append(embeds)\n return np.array(X_train_em), np.array(X_test_em), np.array(y_train), np.array(y_test)","def embed_sent(self, x: Any) -> expression_seqs.ExpressionSequence:\n # single mode\n if not batchers.is_batched(x):\n expr = expression_seqs.ExpressionSequence(expr_list=[self.embed(word) for word in x])\n # minibatch mode\n elif type(self) == LookupEmbedder:\n embeddings = []\n for word_i in range(x.sent_len()):\n batch = batchers.mark_as_batch([single_sent[word_i] for single_sent in x])\n embeddings.append(self.embed(batch))\n expr = expression_seqs.ExpressionSequence(expr_list=embeddings, mask=x.mask)\n else:\n assert type(x[0]) == sent.SegmentedSentence, \"Need to use CharFromWordTextReader for non standard embeddings.\"\n embeddings = []\n all_embeddings = []\n for sentence in x:\n embedding = []\n for i in range(sentence.len_unpadded()):\n embed_word = self.embed(sentence.words[i])\n embedding.append(embed_word)\n all_embeddings.append(embed_word)\n embeddings.append(embedding)\n # Useful when using dy.autobatch\n dy.forward(all_embeddings)\n all_embeddings.clear()\n # Pad the results\n expr = batchers.pad_embedding(embeddings)\n\n return expr","def predict(self, content):\n input_x = list(content)\n while len(input_x) < self.args.maxlen1: input_x.append('<pad>')\n input_x = input_x[:self.args.maxlen1]\n\n input_x = [self.token2idx.get(s, self.token2idx['<unk>']) for s in input_x]\n\n memory = self.sess.run(self.memory, feed_dict={self.input_x: [input_x]})\n\n return self.bs.search(self.sess, input_x, memory[0])","def learn_from_memory():\n\n # Get a random minibatch from the replay memory and learns from it.\n if agent.memory.size > args.batch_size:\n s1, a, s2, isterminal, r = agent.memory.get_sample(args.batch_size)\n\n q = agent.get_q_values(s2).cpu().data.numpy()\n q2 = np.max(q, axis=1)\n\n target_q = agent.get_q_values(s1).cpu().data.numpy()\n # target differs from q only for the selected action. The following means:\n # target_Q(s,a) = r + gamma * max Q(s2,_) if isterminal else r\n\n target_q[np.arange(target_q.shape[0]), a] = r + args.discount_factor * (1 - isterminal) * q2\n learn(s1, target_q)","def in_storage(query,k,m):\n bools = []\n for i in range(1,k+1):\n bools.append(bfilter[mmh3.hash(query,i)%m])\n return np.prod(bools)","def embed(x, phase):\r\n\r\n is_train = True if phase == 'train' else False\r\n\r\n # Input embedding: convert input vector to dimension of hp.hidden_units.\r\n embs = input_embedding(x, num_units=hp.hidden_units, embed_type=hp.embed_type)\r\n print('Size after input embedding: ', embs.get_shape())\r\n\r\n # Positional Encoding.\r\n embs += embedding(tf.tile(tf.expand_dims(tf.range(tf.shape(x)[1]), 0), [tf.shape(x)[0], 1]),\r\n vocab_size=hp.win_len, num_units=hp.hidden_units,\r\n zero_pad=False, scale=False, scope=\"enc_pe\")\r\n print(\"Size after positional encoding: \", embs.get_shape())\r\n\r\n # Attention blocks.\r\n for i in range(hp.num_blocks):\r\n with tf.variable_scope(\"num_blocks_{}\".format(i)):\r\n # Multi-head Attention\r\n embs = multihead_attention(queries=embs, keys=embs, num_units=hp.hidden_units,\r\n num_heads=hp.num_heads, dropout_rate=hp.dropout_rate,\r\n is_training=is_train, causality=False)\r\n\r\n # Feed Forward\r\n embs = feedforward(embs, num_units=[2 * hp.hidden_units, hp.hidden_units])\r\n print(\"Size after multi-head_attention: \", embs.get_shape())\r\n\r\n # Temporal pooling by averaging on the time dimension.\r\n embs = tf.reduce_mean(embs, axis=1)\r\n\r\n return embs","def pass_word(word, model, input_embedding, char2idx, device, use_head=True):\n inp = torch.LongTensor([char2idx['START']] + [char2idx[c] for c in word]).to(device)\n inp = pack([inp])\n out, hidden = model(input_embedding.unsqueeze(0), inp, use_head=use_head)\n return out, hidden","def extract_argmax_and_embed(embedding, output_projection=None):\n def loop_function(prev, _):\n if output_projection is not None:\n prev = tf.matmul(prev, output_projection[0]) + output_projection[1]\n prev_symbol = tf.argmax(prev, 1) #得到对应的INDEX\n emb_prev = tf.gather(embedding, prev_symbol) #得到这个INDEX对应的embedding\n return emb_prev\n return loop_function","def retrieve(self, query, posting_encodings=util.CompressedPostings):\n if len(self.term_id_map) == 0 or len(self.doc_id_map) == 0:\n self.load()\n\n ### Begin your code\n words = query.split()\n iim = ii.InvertedIndexMapper('data', directory=self.output_dir, postings_encoding=posting_encodings)\n tid = self.term_id_map.__getitem__(words[0])\n ans = iim.__getitem__(tid)\n for i in range(1, len(words)):\n tid = self.term_id_map.__getitem__(words[i])\n ans = self.sorted_intersect(ans, iim.__getitem__(tid))\n for i in range(0, len(ans)):\n ans[i] = self.doc_id_map.__getitem__(ans[i])\n return ans\n ### End your code","def test_embedding_attend(self):\n features = 5\n embed = layers.Embed(num_embeddings=10, features=features)\n inputs = np.array([[1]], dtype=np.int64)\n variables = embed.init(jax.random.PRNGKey(0), inputs)\n query = np.ones(features, dtype=np.float32)\n result = embed.apply(variables, query, method=embed.attend)\n expected = np.sum(variables['params']['embedding'], -1)\n np.testing.assert_array_almost_equal(result, expected)","def embed(self,ipa_seg):\n pre_embedded = self.to_phoible_fts(ipa_seg)\n return np.matmul(PhonologicalEmbedding.__embedding_matrix,pre_embedded)","def _get_embedding(self, data):\n embedding_list = [super()._get_embedding(data)]\n context = data['context']\n for i in range(context.shape[1]):\n embedding_list.append(getattr(self, f'context{i}')(context[:, i:i+1]))\n return torch.cat(embedding_list, dim=1)","def qlist_to_vec(self, max_length, q_list):\n qvec = np.zeros(max_length)\n embed_matrix = None\n if self.use_embed:\n embed_matrix = np.zeros((max_length, EMBEDDING_SIZE))\n \"\"\" pad on the left \"\"\"\n # for i in range(max_length):\n # if i < max_length - len(q_list):\n # cvec[i] = 0\n # else:\n # w = q_list[i-(max_length-len(q_list))]\n # # is the word in the vocabulary?\n # if self.qdict.has_key(w) is False:\n # w = ''\n # qvec[i] = self.qdict[w]\n # cvec[i] = 0 if i == max_length - len(q_list) else 1\n \"\"\" pad on the right \"\"\"\n for i in range(len(q_list)):\n w = q_list[i]\n if self.use_embed:\n if w not in self.embed_dict:\n self.embed_dict[w] = self.nlp(u'%s' % w).vector\n embed_matrix[i] = self.embed_dict[w]\n\n if w not in self.qdict:\n w = ''\n qvec[i] = self.qdict[w]\n return qvec, embed_matrix","def _embed(self):\n batch_size = tf.shape(self.p)[0]\n with tf.variable_scope(\"emb\"):\n with tf.variable_scope(\"char\"):\n pc_emb = tf.reshape(tf.nn.embedding_lookup(\n self.char_embed, self.pc), \n [batch_size * self.max_p_len, self.max_w_len, self.vocab.char_embed_dim])\n qc_emb = tf.reshape(tf.nn.embedding_lookup(\n self.char_embed, self.qc), \n [batch_size * self.max_q_len, self.max_w_len, self.vocab.char_embed_dim])\n cell_fw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\n cell_bw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, pc_emb, self.pc_length, dtype=tf.float32)\n pc_emb = tf.concat([state_fw, state_bw], axis=1)\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, qc_emb, self.qc_length, dtype=tf.float32)\n qc_emb = tf.concat([state_fw, state_bw], axis=1)\n pc_emb = tf.reshape(pc_emb, [batch_size, self.max_p_len, 2 * self.char_hidden_size])\n qc_emb = tf.reshape(qc_emb, [batch_size, self.max_q_len, 2 * self.char_hidden_size])\n\n with tf.name_scope(\"word\"):\n p_emb = tf.nn.embedding_lookup(self.word_embed, self.p)\n q_emb = tf.nn.embedding_lookup(self.word_embed, self.q)\n\n with tf.name_scope(\"pos\"):\n p_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.p_pos)\n q_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.q_pos)\n \n with tf.name_scope(\"em\"):\n sh = tf.shape(self.p_em)\n resh = [sh[0], sh[1], 1]\n p_em_feat = tf.reshape(tf.cast(self.p_em, dtype=tf.float32), shape=resh)\n\n self.p_emb = tf.concat([p_emb, pc_emb, p_pos_emb, p_em_feat], axis=2)\n self.q_emb = tf.concat([q_emb, qc_emb, q_pos_emb], axis=2)","def _find_embeddings(snlp):\n embs = None\n for proc in snlp.processors.values():\n if hasattr(proc, \"pretrain\") and isinstance(proc.pretrain, Pretrain):\n embs = proc.pretrain\n break\n return embs","def forward(self, input_sentence):\n sentence = self.word_embedding(input_sentence)\n embedding = self.encoder(sentence)\n return embedding","def get_embedding():\n\n HOST = app.config.get('EMBEDDING_HOST')\n PORT = app.config.get('EMBEDDING_PORT')\n query_params = {\n 'text' : request.args.get('text', \"\"),\n \"language\" : request.args.get('language', None)\n }\n r = requests.get(f\"http://{HOST}:{PORT}/api/v1/embeddings/create\", params=query_params)\n return jsonify(r.json())","def embed(self, x):\n if self.embedding is None:\n return x\n else:\n return self.embedding(x)","def compute_user_input_embedding(txt, model):\r\n embeddings = []\r\n tokens = txt.split(\" \")\r\n for word in tokens:\r\n embeddings.append(model.wv[word])\r\n sentence_embedding = compute_average(embeddings)\r\n return sentence_embedding","def _embed_result(self, embedding):\n # project original embedding\n project_weight = self.project.weight # (o, c)\n project_embedding = embedding.permute(0, 2, 1).unsqueeze(-1) \\\n * project_weight.permute(1, 0) # (n, e, c, 1) * (c, o) -> (n, e, c, o)\n project_embedding = project_embedding.permute(0, 3, 2, 1) # (n, o, c, e)\n # interaction\n square_of_sum = torch.sum(project_embedding, dim=2) ** 2\n sum_of_square = torch.sum(project_embedding ** 2, dim=2)\n embed_result = 0.5 * (square_of_sum - sum_of_square).sum(dim=2)\n return embed_result","def pretrained_embedding_layer(model,model2,model3, word_to_index,emb_dim_max):\n words_ignored = []\n vocab_len = len(word_to_index) + 1 \n emb_matrix = np.zeros([vocab_len,emb_dim_max])\n \n print(' Total words would be processed : '+str(vocab_len))\n for word, idx in word_to_index.items():\n if word in model:\n emb_matrix[idx,:200] = model[word]\n emb_matrix[idx,200:] = 0\n if word in model2:\n emb_matrix[idx, :100] = model2[word]\n emb_matrix[idx, 100:] = 0\n if word in model3.keys():\n emb_matrix[idx,:] = model3[word]\n else:\n words_ignored.append(word)\n print(str(len(words_ignored))+\" words ignored\")\n print(emb_matrix.shape) \n \n \n embedding_layer = Embedding(vocab_len,emb_dim_max,trainable = True)\n \n # Build the embedding layer, it is required before setting the weights of the embedding layer. \n embedding_layer.build((None,)) # Do not modify the \"None\". This line of code is complete as-is.\n # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\n embedding_layer.set_weights([emb_matrix])\n \n return embedding_layer,words_ignored","def key_value_rte(placeholders, nvocab, **options):\n\n # [batch_size, max_seq1_length]\n premise = placeholders['question']\n # [batch_size]\n premise_lengths = placeholders[\"question_lengths\"]\n # [batch_size, max_seq2_length]\n hypothesis = placeholders[\"support\"]\n # [batch_size]\n hypothesis_lengths = placeholders[\"support_lengths\"]\n # [batch_size]\n targets = placeholders[\"answers\"]\n\n output_size = options[\"repr_dim_output\"]\n\n with tf.variable_scope(\"embedders\") as varscope:\n premise_embedded = nvocab(premise)\n varscope.reuse_variables()\n hypothesis_embedded = nvocab(hypothesis)\n\n # todo: add option for attentive reader\n\n print('TRAINABLE VARIABLES (only embeddings): %d' % get_total_trainable_variables())\n\n with tf.variable_scope(\"key_value_readers\") as varscope:\n premise_outputs, _ = \\\n key_value_reader(premise_embedded, premise_lengths, output_size,\n contexts=(None, None), scope=None,\n drop_keep_prob=options[\"drop_keep_prob\"],\n project_fw_bw=True)\n varscope.reuse_variables()\n hypothesis_outputs, _ = \\\n key_value_reader(hypothesis_embedded, hypothesis_lengths, output_size,\n contexts=(None, None), scope=None,\n drop_keep_prob=options[\"drop_keep_prob\"],\n project_fw_bw=True)\n\n # Reading premise with memory of hypothesis\n #premise_outputs_processed, premise_state = mutable_attention(\n # hypothesis_outputs, premise_outputs[0], premise_lengths, output_size, scope=varscope)\n #varscope.reuse_variables()\n\n # Reading hypothesis with memory of premise and altered memory of hypothesis\n hypothesis_outputs_processed, hypothesis_state = mutable_attention(\n premise_outputs, hypothesis_outputs[0], hypothesis_lengths, output_size)\n\n # todo: read premise and hypothesis memory for inferring entailment class\n\n # fixme: last can be zero because of dynamic_rnn!\n #output = hypothesis_outputs[0][:, -1, :]\n\n output = hypothesis_state.h\n\n #targets = tf.Print(targets, [tf.shape(targets)], \"targets \")\n #output = tf.Print(output, [tf.shape(output)], \"outputs \")\n\n logits, loss, predict = predictor(output, targets, options[\"answer_size\"])\n\n print('TRAINABLE VARIABLES (embeddings + model): %d' % get_total_trainable_variables())\n print('ALL VARIABLES (embeddings + model): %d' % get_total_variables())\n\n return logits, loss, predict","def prepare_word_emb_matrices(experiment):\r\n\r\n with open(\"public_data/stats/stats_train.pkl\", 'rb') as stats:\r\n stats = pickle.load(stats)\r\n vocab = stats[\"VOCAB\"]\r\n stops = [word.lower() for word in set(stopwords.words('english'))]\r\n vocab = vocab + stops\r\n\r\n if experiment == \"RANDOM\":\r\n word_embs = np.random.uniform(low=-1.0, high=1.0, size=(len(vocab), PARAMS[\"SIZE\"])).astype(\"float32\")\r\n\r\n else:\r\n word_embs = []\r\n count_unk = 0\r\n count_kn = 0\r\n\r\n if experiment == \"5\":\r\n emb_model = KeyedVectors.load_word2vec_format(\"public_data/models/experiment_5/embeddings_5.bin\",\r\n binary=True)\r\n elif experiment == \"6\":\r\n emb_model = Word2Vec.load(\"public_data/models/experiment_6/embeddings_6\")\r\n\r\n elif experiment in [\"7\", \"8\"]:\r\n emb_model = FastText.load_fasttext_format(\"public_data/models/experiment_%s/embeddings_%s.bin\"\r\n %(experiment, experiment))\r\n for word in vocab:\r\n if word in emb_model:\r\n word_embs.append(emb_model[word])\r\n count_kn += 1\r\n else:\r\n word_embs.append(np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\"SIZE\"]))\r\n count_unk += 1\r\n\r\n word_embs = np.array(word_embs).astype(\"float32\")\r\n print(count_unk / (count_kn + count_unk))\r\n\r\n pad = np.zeros(shape=PARAMS[\"SIZE\"]).astype(\"float32\")\r\n unk = np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\"SIZE\"]).astype(\"float32\")\r\n word_embs = np.insert(word_embs, 0, unk, axis=0) #id 1\r\n word_embs = np.insert(word_embs, 0, pad, axis=0) #id 0\r\n\r\n with open(\"public_data/embeddings/word_embeddings_%s.pkl\" %experiment, 'wb') as out:\r\n pickle.dump(word_embs, out, protocol=4)\r\n\r\n return word_embs"],"string":"[\n \"def get_embed(input_data, vocab_size, embed_dim):\\n embedding = tf.Variable(tf.random_uniform((vocab_size,embed_dim), -1, 1))\\n embed = tf.nn.embedding_lookup(embedding, input_data)\\n #print (\\\"embed_dim: \\\",embed_dim) # 向量表达维度为 256\\n #print (\\\"input_data.shape: \\\",input_data.shape) # (50, 5)\\n #print (\\\"embed.shap: \\\", embed.shape) # word 的向量表达 ==特征 (50, 5, 256) ==(batch_size, num_step, embed_dim)\\n return embed # 返回input的向量表达\",\n \"def get_embed(input_data, vocab_size, embed_dim):\\n # todo 需要编程：\\n # 1、构建嵌入矩阵的查找表\\n lookup_w = tf.Variable(\\n initial_value=tf.random_uniform([vocab_size, embed_dim], -1.0, 1.0)\\n )\\n # 2、获得嵌入输出\\n embed = tf.nn.embedding_lookup(params=lookup_w, ids=input_data)\\n # [N, n_steps, embed_size]\\n return embed\",\n \"def embedded(self, word_ids, embedding_tensor, scope=\\\"embedding\\\"):\\n with tf.variable_scope(scope):\\n with tf.device(\\\"/cpu:0\\\"):\\n inputs = tf.nn.embedding_lookup(embedding_tensor, word_ids)\\n return inputs\",\n \"def embed(query: str) -> dict:\\n embedding = model.embed(query)\\n return {\\\"embedding\\\": embedding, \\\"model\\\": model_name}\",\n \"def get_embed(input_data, vocab_size, embed_dim):\\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_dim), -1, 1))\\n embed = tf.nn.embedding_lookup(embedding, input_data)\\n\\n return embed\",\n \"def get_embedding(self, resp):\\n\\n feed_dict = {self.anchor: resp}\\n embedding = self.sess.run(self.embed_anchor, feed_dict=feed_dict)\\n return embedding\",\n \"def _read_adv_embeddings(identity, target):\\n embeddings_file = os.path.join(\\n FLAGS.output_directory,\\n identity,\\n FLAGS.attack_type,\\n target\\n )\\n embeddings_file = os.path.join(FLAGS.image_directory,\\n identity,\\n 'embeddings.h5')\\n with h5py.File(embeddings_file, 'r') as f:\\n return f['embeddings'][:].astype(np.float32)\",\n \"def _get_query_vec(self, inputs):\\n if self._flags.model_type == \\\"bilstm_net\\\":\\n network = self.bilstm_net\\n elif self._flags.model_type == \\\"bow_net\\\":\\n network = self.bow_net\\n elif self._flags.model_type == \\\"cnn_net\\\":\\n network = self.cnn_net\\n elif self._flags.model_type == \\\"lstm_net\\\":\\n network = self.lstm_net\\n elif self._flags.model_type == \\\"gru_net\\\":\\n network = self.gru_net\\n else:\\n raise ValueError(\\\"Unknown network type!\\\")\\n\\n prefix_letter_pool = network(inputs[\\\"prefix_letter_id\\\"],\\n \\\"wordid_embedding\\\",\\n self._flags.vocab_size,\\n self._flags.emb_dim,\\n hid_dim=self.hid_dim,\\n fc_dim=0,\\n emb_lr=self._flags.emb_lr)\\n if isinstance(prefix_letter_pool, list):\\n #max-pooling\\n prefix_pool = _parse_raw_att(prefix_letter_pool, self, 'prefix')\\n else:\\n prefix_pool = [prefix_letter_pool]\\n\\n if self._flags.prefix_word_id:\\n prefix_word_pool = network(inputs[\\\"prefix_word_id\\\"],\\n \\\"wordid_embedding\\\",\\n self._flags.vocab_size,\\n self._flags.emb_dim,\\n hid_dim=self.hid_dim,\\n fc_dim=0,\\n emb_lr=self._flags.emb_lr)\\n if isinstance(prefix_word_pool, list):\\n #max-pooling\\n prefix_word_raw, prefix_word_att = _parse_raw_att(prefix_word_pool, self, 'prefix')\\n prefix_pool[0] = fluid.layers.concat([prefix_pool[0], prefix_word_raw], axis=1)\\n prefix_pool[1] = fluid.layers.concat([prefix_pool[1], prefix_word_att], axis=1)\\n else:\\n prefix_pool[0] = fluid.layers.concat([prefix_pool[0], prefix_word_pool], axis=1)\\n\\n prefix_vec = mlp_pool(prefix_pool, self._flags.prefix_mlp.split(','), self.hid_dim)\\n #vector layer\\n #fluid.layers.Print(inputs[\\\"prefix_letter_id\\\"])\\n #fluid.layers.Print(inputs[\\\"prefix_word_id\\\"])\\n #fluid.layers.Print(prefix_vec)\\n loc_vec = None\\n if self._flags.use_geohash:\\n loc_vec = fluid.layers.reshape(fluid.layers.cast(x=inputs['prefix_loc_geoid'],\\n dtype=\\\"float32\\\"), [-1, 40])\\n loc_vec = fluid.layers.fc(input=loc_vec, size=self.hid_dim, act=\\\"leaky_relu\\\", \\n param_attr=fluid.ParamAttr(name='loc_fc_weight'),\\n bias_attr=fluid.ParamAttr(name='loc_fc_bias'))\\n\\n # day_vec = fluid.layers.reshape(fluid.layers.cast(x=inputs['day_id'],\\n # dtype=\\\"float32\\\"), [-1, 14])\\n # day_vec = fluid.layers.fc(input=loc_vec, size=self.hid_dim, act=\\\"leaky_relu\\\", \\n # param_attr=fluid.ParamAttr(name='day_weight'),\\n # bias_attr=fluid.ParamAttr(name='day_bias'))\\n \\n context_pool = fluid.layers.concat([prefix_vec, loc_vec], axis=1) if loc_vec is not None else prefix_vec\\n context_vec = fluid.layers.fc(input=context_pool, size=self._flags.fc_dim, act=self._flags.activate,\\n param_attr=fluid.ParamAttr(name='context_fc_weight'),\\n bias_attr=fluid.ParamAttr(name='context_fc_bias'))\\n return context_vec, context_pool\",\n \"def call(self,\\n inputs: tf.Tensor,\\n **kwargs):\\n # one dim case\\n # out = self.embeddings[inputs[0]]\\n\\n # this feels like cheating, read docs for explanation\\n out = embedding_ops.embedding_lookup(self.embeddings, inputs)\\n return out\",\n \"def test_extract_embeddings():\\n with pytest.raises(OSError):\\n model = BERTopic(bert_model='not_a_model')\\n model._extract_embeddings([\\\"Some document\\\"])\\n\\n # model = BERTopic(bert_model='distilbert-base-nli-mean-tokens')\\n # embeddings = model._extract_embeddings([\\\"Some document\\\"])\\n #\\n # assert isinstance(embeddings, np.ndarray)\\n # assert embeddings.shape == (1, 768)\",\n \"def test_extract_embeddings():\\n docs = [\\\"some document\\\"]\\n model = BERTopic(embedding_model=\\\"distilbert-base-nli-stsb-mean-tokens\\\")\\n bertopic_embeddings = model._extract_embeddings(docs)\\n\\n assert isinstance(bertopic_embeddings, np.ndarray)\\n assert bertopic_embeddings.shape == (1, 768)\\n\\n sentence_embeddings = embedding_model.encode(docs, show_progress_bar=False)\\n assert np.array_equal(bertopic_embeddings, sentence_embeddings)\",\n \"def embed(self, sequence):\\n words = sequence.split(' ')\\n vecs = [self._E[self._w2i[i]] if i in self._w2i else self._E[self._w2i[\\\"UNK\\\"]]\\n for i in words]\\n return vecs\",\n \"def forward(self, input):\\n if isinstance(input, tuple):\\n check_input = input[0]\\n else:\\n check_input = input\\n in_length, in_batch, nfeat = check_input.size()\\n aeq(nfeat, len(self.emb_luts))\\n\\n emb = self.make_embedding(input)\\n\\n out_length, out_batch, emb_size = emb.size()\\n aeq(in_length, out_length)\\n aeq(in_batch, out_batch)\\n aeq(emb_size, self.embedding_size)\\n\\n return emb\",\n \"def search(self, column: str, query: Any, top_k: int) -> gp.DataFrame:\\n assert self._dataframe._db is not None\\n embdedding_info = self._dataframe._db._execute(\\n f\\\"\\\"\\\"\\n WITH indexed_col_info AS (\\n SELECT attrelid, attnum\\n FROM pg_attribute\\n WHERE \\n attrelid = '{self._dataframe._qualified_table_name}'::regclass::oid AND\\n attname = '{column}'\\n ), reloptions AS (\\n SELECT unnest(reloptions) AS option\\n FROM pg_class, indexed_col_info\\n WHERE pg_class.oid = attrelid\\n ), embedding_info_json AS (\\n SELECT split_part(option, '=', 2)::json AS val\\n FROM reloptions, indexed_col_info\\n WHERE option LIKE format('_pygp_emb_%s=%%', attnum)\\n ), embedding_info AS (\\n SELECT * \\n FROM embedding_info_json, json_to_record(val) AS (attnum int4, embedding_relid oid, model text)\\n )\\n SELECT nspname, relname, attname, model\\n FROM embedding_info, pg_class, pg_namespace, pg_attribute\\n WHERE \\n pg_class.oid = embedding_relid AND\\n relnamespace = pg_namespace.oid AND\\n embedding_relid = attrelid AND\\n pg_attribute.attnum = 2;\\n \\\"\\\"\\\"\\n )\\n row: Row = embdedding_info[0]\\n schema: str = row[\\\"nspname\\\"]\\n embedding_table_name: str = row[\\\"relname\\\"]\\n model = row[\\\"model\\\"]\\n embedding_col_name = row[\\\"attname\\\"]\\n embedding_df = self._dataframe._db.create_dataframe(\\n table_name=embedding_table_name, schema=schema\\n )\\n assert self._dataframe.unique_key is not None\\n distance = gp.operator(\\\"<->\\\") # L2 distance is the default operator class in pgvector\\n return self._dataframe.join(\\n embedding_df.assign(\\n distance=lambda t: distance(\\n embedding_df[embedding_col_name], _generate_embedding(query, model)\\n )\\n ).order_by(\\\"distance\\\")[:top_k],\\n how=\\\"inner\\\",\\n on=self._dataframe.unique_key,\\n self_columns={\\\"*\\\"},\\n other_columns={},\\n )\",\n \"def forward(self, x, mask, query_embed, pos_embed):\\n _, bs, _ = x.shape\\n query_embed = query_embed.unsqueeze(1).repeat(\\n 1, bs, 1) # [num_query, embed_dims] -> [num_query, bs, embed_dims]\\n\\n enc_mem = self.encoder(\\n query=x,\\n key=None,\\n value=None,\\n query_pos=pos_embed,\\n query_key_padding_mask=mask)\\n target = torch.zeros_like(query_embed)\\n # out_dec: [num_dec_layers, num_query, bs, embed_dims]\\n out_dec = self.decoder(\\n query=target,\\n key=enc_mem,\\n value=enc_mem,\\n key_pos=pos_embed,\\n query_pos=query_embed,\\n key_padding_mask=mask)\\n out_dec = out_dec.transpose(1, 2)\\n return out_dec, enc_mem\",\n \"def question_to_vec(question, embeddings):\\n\\n dim = embeddings['dog'].size\\n result = np.zeros((dim,))\\n\\n words = question.split(' ')\\n\\n count = 0\\n for word in words:\\n if word not in embeddings or not len(embeddings[word]):\\n continue\\n result += embeddings[word][:dim]\\n count += 1\\n\\n return result / max(count, 1)\",\n \"def search_es(es, query_embeddings, k):\\n es_query ={\\n \\\"query\\\": {\\n \\\"knn\\\": {\\n \\\"embeddings\\\": {\\n \\\"vector\\\": query_embeddings,\\n \\\"k\\\": k\\n }\\n }\\n }\\n }\\n \\n res = es.search(index=ES_INDEX, body=es_query, size=k)\\n uris = [hit['_source']['uri'] for hit in res['hits']['hits']]\\n return uris\",\n \"def QL_embeddings():\\n ql = QatarLivingCorpus(dev_file)\\n sent = []\\n for th in ql:\\n for s in ThreadParser(th).get_sentences():\\n sent.append(s)\\n # CBOW, size=100, window=5\\n w2v = Word2Vec(sent)\\n\\n # useful after training to trim unneeded model memory = use (much) less RAM\\n w2v.init_sims(replace=True)\\n w2v.save_word2vec_format('../models/ql_w2v_cbow_s100_w5', binary=True)\\n\\n # test for embeddings\\n test_embeddings(w2v)\",\n \"def _embed(self):\\n with tf.variable_scope('word_embedding'):\\n self.pretrained_word_mat = tf.get_variable(\\\"word_emb_mat\\\",\\n [self.vocab.word_size() - 2, self.vocab.word_embed_dim],\\n dtype=tf.float32,\\n initializer=tf.constant_initializer(\\n self.vocab.word_embeddings[2:],\\n dtype=tf.float32),\\n trainable=False)\\n self.word_pad_unk_mat = tf.get_variable(\\\"word_unk_pad\\\",\\n [2, self.pretrained_word_mat.get_shape()[1]],\\n dtype=tf.float32,\\n initializer=tf.constant_initializer(\\n self.vocab.word_embeddings[:2],\\n dtype=tf.float32),\\n trainable=True)\\n\\n self.word_mat = tf.concat([self.word_pad_unk_mat, self.pretrained_word_mat], axis=0)\\n self.p_emb = tf.nn.embedding_lookup(self.word_mat, self.p)\\n self.q_emb = tf.nn.embedding_lookup(self.word_mat, self.q)\",\n \"def create_embedding_matrix(self):\\n self.id2word = dict([(self.vocab[word]['id'], word) for word in self.vocab])\\n vocab_size = len(self.vocab)\\n result = np.zeros((vocab_size, self.embed_dim))\\n unknown_token_set = set()\\n\\n found_words = 0\\n avg = np.zeros(self.embed_dim)\\n for _ in range(1, vocab_size): # skip PAD embedding (initialize as zero embedding)\\n try:\\n result[_] = self.pretrained_embedding[self.id2word[_]]\\n avg += result[_]\\n found_words += 1\\n except:\\n unknown_token_set.add(_)\\n\\n avg /= found_words\\n for _ in unknown_token_set:\\n result[_] = avg\\n self.embedding = result\\n return found_words, len(self.id2word)\",\n \"def embedding(inputs,\\n vocab_dim,\\n embedding_dim,\\n reuse,\\n validate_indices=False,\\n w_init=tf.random_uniform_initializer(-1., 1.),\\n trainable=True,\\n normalize=False,\\n vocab_freqs=None,\\n name=\\\"Embedding\\\"):\\n\\n input_shape = util.get_input_shape(inputs)\\n assert len(input_shape) == 2, \\\"Input Tensor shape must be 2-D\\\"\\n\\n with tf.variable_scope(name, reuse=reuse):\\n with tf.device('/cpu:0'):\\n W = tf.get_variable(\\n \\\"W\\\", shape=[vocab_dim, embedding_dim], initializer=w_init, trainable=trainable)\\n if normalize:\\n assert vocab_freqs is not None\\n vocab_freqs = tf.constant(vocab_freqs, dtype=tf.float32, shape=(vocab_dim, 1))\\n W = _normalize(W, vocab_freqs)\\n\\n output = tf.cast(inputs, tf.int32)\\n output = tf.nn.embedding_lookup(W, output, validate_indices=validate_indices)\\n\\n shape = [-1] + output.get_shape().as_list()[1:3] + [1]\\n # seq_length = util.retrieve_seq_length(tf.reshape(inputs, shape))\\n\\n return output\",\n \"def embed(self, word: str) -> list:\\n return self.emb_matrix[self.wordmapper[word]]\",\n \"def load_embeddings(db):\\n size = db['size'].values\\n emb = db['embedding'].values\\n emb = [np.load(i).flatten() for i in emb]\\n return emb, size\",\n \"def embed(self, features, feature_name, params):\\n with tf.variable_scope(\\\"%s_embed\\\" % feature_name):\\n embed_matrix = tf.get_variable(\\\"embedding_matrix\\\",\\n [getattr(params, \\\"%s_vocab_size\\\" % feature_name), \\n getattr(params, \\\"%s_embed_size\\\" % feature_name)])\\n return tf.nn.embedding_lookup(embed_matrix, features[feature_name])\",\n \"def embed(documents, ctx_encoder, ctx_tokenizer, device):\\n input_ids = ctx_tokenizer(\\n documents[\\\"title\\\"],\\n documents[\\\"text\\\"],\\n truncation=True,\\n padding=\\\"longest\\\",\\n return_tensors=\\\"pt\\\",\\n )[\\\"input_ids\\\"]\\n embeddings = ctx_encoder(\\n input_ids.to(device=device), return_dict=True\\n ).pooler_output\\n return {\\\"embeddings\\\": embeddings.detach().cpu().numpy()}\",\n \"def word_embedding_forward(x, W):\\n out, cache = None, None\\n ##############################################################################\\n # TODO: Implement the forward pass for word embeddings. #\\n # #\\n # HINT: This should be very simple. #\\n ##############################################################################\\n out = W[x,:]\\n cache = x, W\\n\\n ##############################################################################\\n # END OF YOUR CODE #\\n ##############################################################################\\n return out, cache\",\n \"def get_word_embeddings(t, folder, lang=\\\"en\\\"):\\n vecs_url = f\\\"https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.{lang}.300.vec.gz\\\"\\n vecs_gz_filename = vecs_url.rpartition(\\\"/\\\")[2]\\n os.makedirs(folder, exist_ok=True)\\n vecs_gz_filepath = os.path.join(folder, vecs_gz_filename)\\n\\n tokenizer_vocab_size = len(t.vocab)\\n\\n if wait_for_file_stable(vecs_gz_filepath):\\n print(\\\"Using existing embeddings file\\\")\\n else:\\n print(\\\"Downloading word vectors...\\\")\\n subprocess.run([\\\" \\\".join([\\\"wget\\\", \\\"-NP\\\", folder, vecs_url])], check=True, shell=True)\\n\\n print(\\\"Loading into memory...\\\")\\n embeddings_index = dict()\\n with gzip.open(vecs_gz_filepath, \\\"rt\\\") as zipf:\\n firstline = zipf.readline()\\n emb_vocab_size, emb_d = firstline.split(\\\" \\\")\\n emb_vocab_size = int(emb_vocab_size)\\n emb_d = int(emb_d)\\n for line in zipf:\\n values = line.split()\\n word = values[0]\\n # Only load subset of the embeddings recognised by the tokenizer:\\n if word in t.vocab.stoi:\\n coefs = np.asarray(values[1:], dtype=\\\"float32\\\")\\n embeddings_index[word] = coefs\\n print(\\\"Loaded {} of {} word vectors for tokenizer vocabulary length {}\\\".format(\\n len(embeddings_index),\\n emb_vocab_size,\\n tokenizer_vocab_size,\\n ))\\n\\n # create a weight matrix for words in training docs\\n embedding_matrix = np.zeros((tokenizer_vocab_size, emb_d))\\n for word, i in t.vocab.stoi.items():\\n embedding_vector = embeddings_index.get(word)\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector\\n\\n return embedding_matrix\",\n \"def link(self, input):\\n self.input = input\\n self.output = self.embeddings[self.input]\\n return self.output\",\n \"def embed_query(self, text: str) -> List[float]:\\n embedding = self._embedding_func(text, engine=self.query_model_name)\\n return embedding\",\n \"def decode_beamsearch(self, enc_inputs, memory_key_padding_mask, decode_dict):\\n k = decode_dict['k']\\n batch_size = decode_dict['batch_size']\\n time_step = decode_dict['time_step']\\n vocab_size = decode_dict['vocab_size']\\n device = decode_dict['device']\\n start_token_id = decode_dict['start_token_id']\\n stop_token_id = decode_dict['stop_token_id']\\n alpha = decode_dict['alpha']\\n length_offset = decode_dict['length_offset']\\n keypadmask_dtype = decode_dict['keypadmask_dtype']\\n\\n # create beam array & scores\\n beams = [None for _ in range(k)]\\n beam_scores = np.zeros((batch_size, k))\\n\\n # we should only feed through the encoder just once!!\\n enc_output = self.encoder(enc_inputs) # memory\\n\\n # we run the decoder time_step times (auto-regressive)\\n tgt_ids = torch.zeros((batch_size, time_step), dtype=torch.int64).to(device)\\n tgt_ids[:,0] = start_token_id\\n for i in range(k):\\n beams[i] = tgt_ids\\n\\n for t in range(time_step-1):\\n # tgt_key_padding_mask\\n row_padding_mask = [False]*(t+1) + [True]*(time_step-t-1)\\n padding_mask = [row_padding_mask for _ in range(batch_size)]\\n tgt_key_padding_mask = torch.tensor(padding_mask, dtype=keypadmask_dtype).to(device)\\n\\n decoder_output_t_array = torch.zeros((batch_size, k*vocab_size))\\n\\n for i, beam in enumerate(beams):\\n decoder_output = self.decoder(beam, enc_output,\\n tgt_mask=self.tgt_mask,\\n tgt_key_padding_mask=tgt_key_padding_mask,\\n memory_key_padding_mask=memory_key_padding_mask,\\n logsoftmax=False)\\n\\n # check if there is STOP_TOKEN emitted in the previous time step already\\n # i.e. if the input at this time step is STOP_TOKEN\\n for n_idx in range(batch_size):\\n if beam[n_idx][t] == stop_token_id: # already stop\\n decoder_output[n_idx, t, :] = float('-inf')\\n decoder_output[n_idx, t, stop_token_id] = 0.0 # to ensure STOP_TOKEN will be picked again!\\n\\n else: # need to update scores --- length norm\\n beam_scores[n_idx,i] *= (t-1+length_offset)**alpha\\n beam_scores[n_idx,i] /= (t+length_offset)**alpha\\n\\n # length_norm = 1/(length)^alpha ... alpha = 0.7\\n decoder_output_t_array[:,i*vocab_size:(i+1)*vocab_size] = decoder_output[:,t,:]/(t+length_offset)**alpha\\n\\n # add previous beam score bias\\n for n_idx in range(batch_size):\\n decoder_output_t_array[n_idx,i*vocab_size:(i+1)*vocab_size] += beam_scores[n_idx,i]\\n\\n if t == 0: break # only fill once for the first time step\\n\\n # scores, indice => (batch_size, k)\\n scores, indices = torch.topk(decoder_output_t_array, k=k, dim=-1)\\n new_beams = [torch.zeros((batch_size, time_step), dtype=torch.int64).to(device) for _ in range(k)]\\n for r_idx, row in enumerate(indices):\\n for c_idx, node in enumerate(row):\\n vocab_idx = node % vocab_size\\n beam_idx = int(node / vocab_size)\\n\\n new_beams[c_idx][r_idx,:t+1] = beams[beam_idx][r_idx,:t+1]\\n new_beams[c_idx][r_idx,t+1] = vocab_idx\\n\\n beam_scores = scores.cpu().numpy()\\n beams = new_beams\\n\\n # if (t % 10) == 0:\\n # print(\\\"{}=\\\".format(t), end=\\\"\\\")\\n # sys.stdout.flush()\\n # print(\\\"{}=#\\\".format(t))\\n\\n summaries_id = [None for _ in range(batch_size)]\\n for j in range(batch_size): summaries_id[j] = beams[0][j].cpu().numpy()\\n\\n return summaries_id\",\n \"def _get_embedding(self, data):\\n # Tensor(n, c)\\n cat = data['cat']\\n return self.one_hot_embed(cat)\",\n \"def _embed(self):\\n with tf.variable_scope('word_embedding'):\\n self.word_embeddings = tf.get_variable(\\n 'word_embeddings',\\n shape=(self.term_vocab.size(), self.term_vocab.embed_dim),\\n initializer=tf.constant_initializer(self.term_vocab.embeddings),\\n trainable=True\\n )\\n self.p_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.p)\\n self.q_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.q)\\n\\n with tf.variable_scope('char_embedding'):\\n self.char_embeddings = tf.get_variable(\\n 'char_embeddings',\\n shape=(self.char_vocab.size(), self.char_vocab.embed_dim),\\n initializer=tf.constant_initializer(self.char_vocab.embeddings),\\n trainable=True\\n )\\n self.p_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.p_char) # [batch, seqlen, max_char_num, embedding_size]\\n self.q_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.q_char)\\n\\n self.p_char_emb = self.cnn_emb(self.p_char_emb, \\\"p_emb\\\")\\n self.q_char_emb = self.cnn_emb(self.q_char_emb, \\\"q_emb\\\")\\n '''\\n self.p_char_emb = tf.reshape(self.p_char_emb, [-1, self.max_char_num, self.emb_size])\\n self.q_char_emb = tf.reshape(self.q_char_emb, [-1, self.max_char_num, self.emb_size])\\n\\n self.p_char_emb = cnn_layer.conv(self.p_char_emb, self.emb_size,\\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\\\"char_conv\\\", reuse=None)\\n self.q_char_emb = cnn_layer.conv(self.q_char_emb, self.emb_size,\\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\\\"char_conv\\\", reuse=True)\\n\\n self.p_char_emb = tf.reduce_max(self.p_char_emb, axis=1) # [batch*seqlen, 1, emb_size]\\n self.q_char_emb = tf.reduce_max(self.q_char_emb, axis=1)\\n\\n batch_size = tf.shape(self.p_word_emb)[0]\\n self.p_char_emb = tf.reshape(self.p_char_emb, [batch_size, -1, self.emb_size])\\n self.q_char_emb = tf.reshape(self.q_char_emb, [batch_size, -1, self.emb_size])\\n\\n self.p_char_emb = tf.nn.dropout(self.p_char_emb, 0.95)\\n self.q_char_emb = tf.nn.dropout(self.q_char_emb, 0.95)\\n '''\\n self.p_emb = tf.concat([self.p_word_emb, self.p_char_emb], -1)\\n self.q_emb = tf.concat([self.q_word_emb, self.q_char_emb], -1)\",\n \"def compute_embeddings(model, opts, data):\\n node_embeddings = []\\n node_scores = []\\n # batch size is 1 for computing embeddings\\n dataloader = DataLoader(dataset=data, batch_size=1, shuffle=True, num_workers=16)\\n model.eval()\\n print(\\\"computing embeddings...\\\")\\n with torch.no_grad():\\n for batch in tqdm(dataloader):\\n batch.to(opts.device)\\n batch_scores, batch_embeddings = model(batch, compute_embeddings=False)\\n node_embeddings.append(batch_embeddings)\\n node_scores.append(batch_scores)\\n # input('enter for embeddings')\\n # print(node_embeddings)\\n\\n return torch.stack(node_scores), torch.stack(node_embeddings)\",\n \"def _lookup_embeddings(self, x):\\n e_s = tf.nn.embedding_lookup(self.ent_emb, x[:, 0], name='embedding_lookup_subject')\\n e_p = tf.nn.embedding_lookup(self.rel_emb, x[:, 1], name='embedding_lookup_predicate')\\n e_o = tf.nn.embedding_lookup(self.ent_emb, x[:, 2], name='embedding_lookup_object')\\n return e_s, e_p, e_o\",\n \"def getWordEmbeddingsMatrix(script_directory, embedding_file):\\n translator = str.maketrans('', '', string.punctuation)\\n all_words = []\\n print(\\\"Loading vocab from text files in:\\\")\\n for d in os.listdir(script_directory):\\n print(d)\\n for fname in os.listdir(\\\"%s/%s\\\" % (script_directory, d)):\\n with open(\\\"%s/%s/%s\\\" % (script_directory, d, fname), 'r') as f:\\n words = [w.translate(translator) for w in f.read().split() if w.translate(translator) != \\\"\\\"]\\n all_words.extend(words)\\n\\n model = KeyedVectors.load_word2vec_format(embedding_file, binary=True)\\n vocab = {\\\"PAD\\\" : 0, \\\"EOS\\\" : 1}\\n vocab.update({w : i + 2 for i,w in enumerate([w1 for w1 in set(all_words) if w1 in model]) })\\n inv_dict = vocab.keys()\\n ## Take a minute to load...\\n\\n vocab_size = len(inv_dict)\\n emb_size = 300 # or whatever the size of your embeddings\\n embeddings = np.zeros((vocab_size + 1, emb_size))\\n for k,v in vocab.items():\\n embeddings[v] = model[k]\\n vocab[\\\"UNK\\\"] = len(vocab.keys())\\n embeddings[vocab[\\\"UNK\\\"]] = np.ones(emb_size)\\n del model\\n ## Now we have a numpy matrix of embeddings...\\n # x_model = tf.placeholder(tf.int32, shape=[None, input_size])\\n # with tf.device(\\\"/cpu:0\\\"):\\n # embedded_x = tf.nn.embedding_lookup(embeddings, x_model)\\n return embeddings, vocab\",\n \"def calculate_embeddings_from_buffer(_img, _network, verbose=False):\\n \\n img_buff = Image.open(BytesIO(_img))\\n img = _reshape_image(np.array(img_buff))\\n descs = calculate_embedding(img, _network, verbose=verbose)\\n img_buff.close()\\n \\n return descs\",\n \"def __glove_embed__(sequence, model):\\n embedded = []\\n for word in sequence:\\n embedded.append(model[word])\\n return embedded\",\n \"def for_extract_embedding(maxChunk=10000, isMatrix=True):\\n def wrapper(function):\\n def _wrapper(self, input):\\n \\\"\\\"\\\"\\n @input: a 3-dimensional tensor with batch-dim=1 or [frames, feature-dim] matrix for \\n acoustic features only\\n @return: an 1-dimensional vector \\n \\\"\\\"\\\"\\n train_status = self.training\\n self.eval()\\n\\n with torch.no_grad():\\n if isMatrix:\\n input = torch.tensor(input)\\n input = torch.unsqueeze(input, dim = 0)\\n input = input.transpose(1,2)\\n\\n input = utils.to_device(self, input)\\n num_frames = input.shape[2]\\n num_split = (num_frames + maxChunk - 1) // maxChunk\\n split_size = num_frames // num_split\\n \\n offset = 0\\n embedding_stats = 0.\\n for i in range(0, num_split-1):\\n this_embedding = function(self, input[:, :, offset:offset+split_size])\\n offset += split_size\\n embedding_stats += split_size*this_embedding\\n\\n last_embedding = function(self, input[:, :, offset:])\\n\\n embedding = (embedding_stats + (num_frames-offset) * last_embedding) / num_frames\\n\\n if train_status:\\n self.train()\\n\\n return torch.squeeze(embedding.transpose(1,2)).cpu()\\n\\n return _wrapper\\n return wrapper\",\n \"def question_to_vec(question, embeddings, dim):\\r\\n\\r\\n words = question.split()\\r\\n\\r\\n counter = 0\\r\\n res = np.zeros(dim)\\r\\n for word in words:\\r\\n if word in embeddings:\\r\\n res += np.array(embeddings[word])\\r\\n counter += 1\\r\\n if counter!=0:\\r\\n return res/counter # mean of all word embeddings\\r\\n else:\\r\\n return res # vector of zeros\\r\",\n \"def extract_embeddings():\\n session, _ = session_bundle.load_session_bundle_from_path(FLAGS.model_path)\\n all_paths = FLAGS.input_path.split(',')\\n with tf.gfile.Open(FLAGS.output_path, 'w') as out:\\n for dataset, pattern in enumerate(all_paths, start=FLAGS.offset):\\n paths = tf.gfile.Glob(pattern)\\n for path in paths:\\n make_request(dataset, path, out, session)\",\n \"def get_pretrained_embeddings(source_vocab,embed_df):\\r\\n \\r\\n num_tokens = len(source_vocab)\\r\\n embedding_dim = embed_df.shape[1]\\r\\n weights = np.zeros((num_tokens,embedding_dim),dtype=np.float32)\\r\\n \\r\\n for idx in range(num_tokens):\\r\\n token = source_vocab.lookup_index(idx)\\r\\n if token in embed_df.index:\\r\\n weights[idx,:] = embed_df.loc[token]\\r\\n else:\\r\\n weights[idx,:] = np.random.randn(1,embedding_dim)\\r\\n \\r\\n embed_tensor = torch.FloatTensor(weights)\\r\\n return embed_tensor\",\n \"def _get_embedding_layer(self, input_data, doc_input_data):\\n opts = self._options\\n word_embedding = tf.Variable(tf.random_uniform((self.vocab_size, opts.embed_dim), -1.0, 1.0))\\n embed = []\\n\\n temp = tf.zeros([opts.batch_size, opts.embed_dim])\\n embed_d = []\\n for n in range(opts.sentence_sample):\\n temp = tf.add(temp, tf.nn.embedding_lookup(word_embedding, doc_input_data[:, n]))\\n embed_d.append(temp)\\n\\n if opts.concat == 'True':\\n combined_embed_vector_length = opts.embed_dim * opts.window_size + opts.embed_dim\\n for j in range(opts.window_size):\\n embed_w = tf.nn.embedding_lookup(word_embedding, input_data[:, j])\\n embed.append(embed_w)\\n embed.append(embed_d)\\n else:\\n combined_embed_vector_length = opts.embed_dim\\n embed_w = tf.zeros([opts.batch_size, opts.embed_dim])\\n for j in range(opts.window_size):\\n embed_w += tf.nn.embedding_lookup(word_embedding, input_data[:, j])\\n embed_w += embed_d\\n embed.append(embed_w)\\n\\n return tf.concat(embed, 1), word_embedding, combined_embed_vector_length\",\n \"def extract_embedding(self, from_model):\\n return from_model\",\n \"def get_embeddings(self, data):\\n raise NotImplementedError()\",\n \"def text2vec(doc_tok, model, dim=300):\\n doc_embedding = np.zeros(dim)\\n valid_words = 0\\n for word in doc_tok:\\n if word in model:\\n valid_words += 1\\n doc_embedding += model.query(word)\\n else:\\n continue\\n if valid_words > 0:\\n return doc_embedding / valid_words\\n else:\\n return doc_embedding\",\n \"def embed(self, smi_or_mol):\\n if not isinstance(smi_or_mol, Chem.Mol):\\n mol = Chem.MolFromSmiles(smi_or_mol)\\n else:\\n mol = smi_or_mol\\n wv = self.model.wv\\n sentence = self.substructure(mol)\\n vec = np.zeros(self.model.vector_size)\\n for fp in sentence:\\n if fp in wv.vocab:\\n vec += wv[fp]\\n return vec\",\n \"def evaluate_embedding(ids, sess, model, dataset, batch_size, normalize=True, rescale=None):\\n\\n nrof_images = len(ids)\\n embedding_size = model.embeddings.get_shape()[1]\\n #embedding_size should be 128\\n emb_array = np.zeros((nrof_images, embedding_size))\\n labels_array = np.zeros((nrof_images,))\\n\\n nrof_batches = int(math.ceil(1.0*nrof_images / batch_size))\\n for i in range(nrof_batches):\\n start_index = i*batch_size\\n end_index = min((i+1)*batch_size, nrof_images)\\n ids_batch = ids[start_index:end_index]\\n images, labels = dataset.load_images(ids_batch, normalize=normalize, rescale=rescale)\\n feed_dict = {model.images:images}\\n emb_array[start_index:end_index,:] = sess.run(model.embeddings, feed_dict=feed_dict)\\n labels_array[start_index:end_index] = labels\\n return emb_array, labels_array\",\n \"def get_embedding(A,B):\\n st = minion_hom_algebras(A,B,inj=True)\\n writefile('tmp.minion',st)\\n os.system('minion -noprintsols -solsout tmp.txt tmp.minion >tmpout.txt')\\n st = readfile('tmp.txt')\\n os.system('rm tmp.txt')\\n emb = st.split(\\\"\\\\n\\\")[:-1]\\n if len(emb)>1: return emb[0]\",\n \"def glove_embedding(self, word_index, padded, embedding_matrix, part='q'):\\n print(\\\"*\\\" * 50, \\\"Start Glove embedding process\\\", \\\"*\\\" * 50)\\n start_time = time()\\n\\n\\n MAX_SEQ_LEN = None\\n if part == 'q':\\n MAX_SEQ_LEN = self.MAX_Q_SEQ_LEN\\n elif part == 'a':\\n MAX_SEQ_LEN = self.MAX_A_SEQ_LEN\\n else:\\n print(f\\\"Please indicate you want embedding question part or answer part\\\")\\n\\n\\n input_layer = Input(shape=(MAX_SEQ_LEN,), dtype='int32')\\n embedding_layer = Embedding(input_dim = len(word_index) + 1,\\n output_dim = self.EMBEDDING_DIM,\\n weights=[embedding_matrix],\\n input_length=MAX_SEQ_LEN,\\n trainable=False)(input_layer)\\n # (number of sample, MAX_SEQ_LEN, EMBEDING_DIM)\\n model = Model(inputs=input_layer, outputs=embedding_layer)\\n model.compile('rmsprop', 'mse')\\n output_array = model.predict(padded)\\n\\n cost_time = round((time() - start_time), 4)\\n print(\\\"*\\\" * 40, \\\"End Glove embedding() with {} seconds\\\".format(cost_time), \\\"*\\\" * 40, end='\\\\n\\\\n')\\n\\n return output_array, embedding_layer\",\n \"def embedding(x, vocab_size, dense_size, name=None, reuse=None, multiplier=1.0):\\n with tf.variable_scope(\\n name, default_name=\\\"embedding\\\", values=[x], reuse=reuse):\\n embedding_var = tf.get_variable(\\\"kernel\\\", [vocab_size, dense_size])\\n emb_x = tf.gather(embedding_var, x)\\n if multiplier != 1.0:\\n emb_x *= multiplier\\n return emb_x\",\n \"def forward(self, input_variable):\\r\\n return self.embedding(input_variable)\",\n \"def _read_embeddings(identity):\\n embeddings_file = os.path.join(FLAGS.image_directory,\\n identity,\\n 'embeddings.h5')\\n with h5py.File(embeddings_file, 'r') as f:\\n return f['embeddings'][:].astype(np.float32)\",\n \"def get_glove_embedding():\\n embedding = {}\\n N = 400_000\\n print(\\\"Reading glove embedding...\\\")\\n with open(GLOVE_EMBD_PATH, \\\"rb\\\") as f:\\n for line in tqdm(f, total=N):\\n line = line.decode().split()\\n word = line[0].lower()\\n vector = np.array(line[1:]).astype(np.float32)\\n embedding[word] = vector\\n\\n return embedding\",\n \"def embed_with_info(self, word_batch: List[List[str]]) -> Tuple[Tuple[FloatTensor, LongTensor], Dict[str, int]]:\\n # Add words to cache\\n words = {word for sequence in word_batch for word in sequence}\\n cache_info = self._cache_words(words)\\n\\n # Convert to indices\\n index_batch = [[self.word_to_index[word] for word in sequence] for sequence in word_batch]\\n\\n return self._embed(index_batch), cache_info\",\n \"def form_cand_queries_amongvocab(self, batch_input, gram):\\n N = batch_input['pair_objects'].size(0)\\n tensor_type = batch_input['pair_objects'].long().data.type()\\n\\n M = len(self.vocab[gram])\\n cats = self.idx_to_vocab[gram].type(tensor_type)\\n queries = cats.unsqueeze(0) \\n labels = batch_input['labels_'+gram].type(queries.data.type()) #(N,M)\\n\\n return (queries, labels)\",\n \"def _use_embeddings(self, word):\\n if word == \\\"@PAD@\\\":\\n return torch.zeros(self.embeddings_dim)\\n else:\\n return self.embeddings[word]\",\n \"def embed(text: str) -> np.ndarray:\\n n = nlp(text)\\n return n.vector\",\n \"def filter_embeddings(embeddings, vocab, dim):\\n _embeddings = np.zeros([len(vocab), dim])\\n for word in vocab:\\n if word in embeddings:\\n word_idx = vocab[word]\\n _embeddings[word_idx] = embeddings[word]\\n\\n return _embeddings\",\n \"def _query_it(records_query: List[str],\\n batch_size: int,\\n metadata: Training\\n ) -> Iterator[Dict[str, np.ndarray]]:\\n dataset = predict_data(records_query, metadata, batch_size)()\\n X_tensor = dataset.make_one_shot_iterator().get_next()\\n with tf.Session() as sess:\\n while True:\\n try:\\n X = sess.run(X_tensor)\\n if \\\"con\\\" in X:\\n X[\\\"con\\\"] = _make_mask(X[\\\"con\\\"], X[\\\"con_mask\\\"])\\n if \\\"cat\\\" in X:\\n X[\\\"cat\\\"] = _make_mask(X[\\\"cat\\\"], X[\\\"cat_mask\\\"])\\n yield X\\n except tf.errors.OutOfRangeError:\\n break\\n return\",\n \"def call(self, x, *args, **kwargs):\\n with tf.name_scope(\\\"embedding\\\"):\\n # fills out of bound values with padding symbol\\n out_bound_mask = tf.cast(x > (self.vocab_size - 1), dtype=tf.int32)\\n x *= 1 - out_bound_mask\\n x += out_bound_mask * tf.cast(self.pad_sym, dtype=tf.int32)\\n\\n embeddings = tf.gather(self.shared_weights, x)\\n if self.embed_scale:\\n # Scale embedding by the sqrt of the hidden size\\n embeddings *= self.hidden_size ** 0.5\\n\\n if self.mask_paddings:\\n # Create binary array of size [batch_size, length]\\n # where 1 = padding, 0 = not padding\\n padding = get_padding(x, padding_value=self.pad_sym)\\n\\n # Set all padding embedding values to 0\\n # embeddings *= tf.expand_dims(1 - padding, -1)\\n embeddings *= tf.cast(tf.expand_dims(1.0 - padding, -1), dtype=embeddings.dtype)\\n return embeddings\",\n \"def embedding(org_input):\\n # Create the embedding list\\n for f in range(Config.num_feature):\\n num_cat_value = Config.schema[f]\\n\\n if num_cat_value == 1:\\n pass\\n elif num_cat_value > 1:\\n embed_dict[f] = tf.get_variable(\\n name=\\\"embed_\\\" + str(f),\\n shape=[num_cat_value, Config.embed_size[f]],\\n trainable=True)\\n else:\\n raise ValueError(\\\"Schema values should be positive integers!\\\")\\n\\n # Create embedded inputs\\n f_size = np.sum(Config.embed_size)\\n embedded_input = embed_events(org_input, f_size)\\n\\n return embedded_input\",\n \"def test_embedding_matrix_shape(self):\\n num_embeddings = 10\\n features = 5\\n embed = layers.Embed(num_embeddings=num_embeddings, features=features)\\n inputs = np.expand_dims(np.arange(features, dtype=np.int64), 1)\\n variables = embed.init(jax.random.PRNGKey(0), inputs)\\n embedding_matrix = variables['params']['embedding']\\n self.assertEqual((num_embeddings, features), embedding_matrix.shape)\",\n \"def get_batch(corpus, ind, vocab_size, device, emsize=300):\\r\\n batch_size = len(ind)\\r\\n data_batch = np.zeros((batch_size, vocab_size))\\r\\n\\r\\n for i, doc_id in enumerate(ind):\\r\\n doc = corpus[doc_id.data]\\r\\n L = len(doc)\\r\\n if doc_id != -1:\\r\\n for word_id in doc:\\r\\n counts = doc.count(word_id)\\r\\n data_batch[i, word_id] = counts\\r\\n data_batch = torch.from_numpy(data_batch).float().to(device)\\r\\n return data_batch\",\n \"def run_demo():\\n while True:\\n embeddings = beer_emb.embed_doc(input(\\\"Test if words are beer-related: \\\"),\\n word_filter=False)\\n for word_vec in embeddings:\\n print(is_beer_related(word_vec))\",\n \"def query(self, annotation: Annotation):\\n\\n x = [annotation.fee_raw] + annotation.sentence\\n\\n x = [[self.input_field.vocab.stoi[t]] for t in x]\\n\\n network_output = self.network.query(x)\\n _, frame = torch.max(network_output[0], 0)\\n frame = self.output_field.vocab.itos[frame.item()]\\n\\n return frame\",\n \"def add_entry(self, embeddings, labels, query_result=None):\\n n_added = embeddings.shape[0]\\n\\n if self.added_memories + n_added <= self.memory_size:\\n start = self.write_pointer + 1\\n end = start + n_added\\n self.update_ixs(range(start, end), embeddings, labels, query_result)\\n self.write_pointer += n_added\\n else:\\n capacity_remaining = max(self.memory_size - self.added_memories, 0)\\n if capacity_remaining > 0:\\n start = self.write_pointer + 1\\n self.update_ixs(range(start, self.memory_size), embeddings[:capacity_remaining], labels[:capacity_remaining],\\n query_result, global_update=False)\\n\\n n_overflow = n_added - capacity_remaining\\n # get least relevant indices\\n if self.delete_method == \\\"relevance\\\":\\n write_ixs = torch.topk(self.memory_relevance, n_overflow, largest=False).indices\\n elif self.delete_method == \\\"age\\\":\\n write_ixs = torch.topk(self.memory_age, n_overflow, largest=True).indices\\n self.update_ixs(write_ixs, embeddings[capacity_remaining:], labels[capacity_remaining:], query_result)\\n self.added_memories += n_added\",\n \"def add_embedding(self):\\n ### YOUR CODE HERE (~4-6 lines)\\n embeddingTensor = tf.Variable(self.pretrained_embeddings)\\n embeddings = tf.nn.embedding_lookup(embeddingTensor, self.input_placeholder)\\n embeddings = tf.reshape(embeddings, [-1, self.max_length, Config.n_features * Config.embed_size])\\n ### END YOUR CODE\\n return embeddings\",\n \"def get_embeddings(model, loader, device=torch.device('cpu')):\\n embeddings = []\\n labels = []\\n for item in loader:\\n data, label = item\\n data = data.view(-1, 1, data.shape[-1])\\n data = data.to(device)\\n label = label.to(device)\\n output = model(data).squeeze(1)\\n\\n embedding = output.cpu().data.numpy()\\n label = label.cpu().data.numpy()\\n embeddings.append(embedding)\\n labels.append(label)\\n\\n embeddings = np.array(embeddings)\\n labels = np.array(labels)\\n\\n return embeddings, labels\",\n \"def build_embedding_layer(inputs_, vocab_size, embed_size):\\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_size), -1, 1))\\n embed = tf.nn.embedding_lookup(embedding, inputs_)\\n \\n return embed\",\n \"def read_embeddings(embedding_file):\\r\\n print(\\\"Reading embeddings...\\\", end=\\\"\\\")\\r\\n\\r\\n embeddings = dict()\\r\\n with h5py.File(embedding_file, 'r') as f:\\r\\n for key in f.keys():\\r\\n embeddings[key] = np.array(f[key], dtype=np.float32)\\r\\n\\r\\n print(f\\\"done! Found {len(embeddings.keys())} proteins.\\\")\\r\\n\\r\\n return embeddings\",\n \"def embedd_data(training_data_text, e_arr, e_dict):\\n num_samples = len(training_data_text)\\n embedded = np.zeros([num_samples, MAX_WORDS_IN_REVIEW, EMBEDDING_SIZE])\\n for i in range(num_samples):\\n review_mat = np.zeros([MAX_WORDS_IN_REVIEW, EMBEDDING_SIZE])\\n # Iterate to either the end of the sentence of the max num of words, whichever is less\\n for w in range(min(len(training_data_text[i]), MAX_WORDS_IN_REVIEW)):\\n # assign embedding of that word or to the UNK token if that word isn't in the dict\\n review_mat[w] = e_arr[e_dict.get(training_data_text[i][w], 0)]\\n embedded[i] = review_mat\\n return embedded\",\n \"def load_embeddings(path, vocab, source_domain, target_domain, emb_name):\\n\\n pkl = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\\n if os.path.exists(pkl):\\n print(\\\"Load embeddings from existing pkl file %s...\\\" % pkl)\\n # word embeddings weights have been loaded\\n embeddings = pickle.load(open(pkl, 'rb'))\\n else:\\n print(\\\"Load embedding from %s...\\\" % path)\\n raw_embeddings = {}\\n if emb_name == 'yelp_electronics':\\n with open(path) as fp:\\n for line in fp:\\n word_vector = line.split(\\\",\\\")[:-1]\\n vector_list = []\\n for element in word_vector[len(word_vector) - 100:]:\\n vector_list.append(float(element))\\n word = ','.join(word_vector[:len(word_vector) - 100])\\n vector = np.asarray(vector_list)\\n if word in vocab:\\n raw_embeddings[word] = vector\\n else:\\n with open(path) as fp:\\n for line in fp:\\n eles = line.strip().split(' ')\\n word = eles[0]\\n if word in vocab:\\n raw_embeddings[word] = eles[1:]\\n\\n dim_w = len(raw_embeddings['the'])\\n n_words = len(vocab)\\n embeddings = np.zeros(shape=(n_words, dim_w))\\n for w in vocab:\\n wid = vocab[w]\\n if w in raw_embeddings:\\n embeddings[wid] = np.array([float(ele) for ele in raw_embeddings[w]])\\n else:\\n # for OOV words, add random initialization\\n embeddings[wid] = np.random.uniform(-0.25, 0.25, dim_w)\\n print(\\\"Find %s word embeddings...\\\" % len(embeddings))\\n if not os.path.exists('./work/embeddings'):\\n os.mkdir('./work/embeddings')\\n emb_path = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\\n # write the embedding weights back to the disk\\n pickle.dump(embeddings, open(emb_path, 'wb'))\\n embeddings = np.array(embeddings, dtype='float32')\\n return embeddings\",\n \"def batch_inference(question,context): \\n inputs = tokenizer(question, context, \\n return_tensors='pt', \\n truncation=True, \\n padding=True)\\n \\n # Move data to GPU\\n inputs = inputs.to(device)\\n \\n # Feed data through the model\\n with torch.no_grad():\\n outputs = model(**inputs)\\n\\n # Q&A model outputs the two logit scores for each word.\\n # One for its chance of being the start of the answer\\n # and one for its chance of being the end\\n start_logits = outputs.start_logits\\n end_logits = outputs.end_logits\\n \\n # Find the words with the highest score\\n # argmax(dim=1) means argmax with each sample\\n start = start_logits.argmax(dim=1)\\n end = end_logits.argmax(dim=1)\\n \\n # Return the answers\\n # This is the point where we move the prediction back to main memory with .cpu()\\n tokens = [tokenizer.convert_ids_to_tokens(x) for x in inputs[\\\"input_ids\\\"].cpu().numpy()]\\n return [tokenizer.convert_tokens_to_string(x[start[i]:end[i]+1]) for i,x in enumerate(tokens)]\",\n \"def main():\\n logging.basicConfig(level=logging.DEBUG)\\n custom_embedding = True\\n\\n # Download embeddings'\\n if custom_embedding:\\n embedding_path = '../data/custom_embedding.pkl'\\n embedding_index_path = '../data/custom_vocab_index.pkl'\\n logging.info('Pulling custom embedding from: {}, and custom vocab from: {}'.format(embedding_path, embedding_index_path))\\n embedding_matrix = pickle.load(open(embedding_path, 'rb'))\\n embedding_index_lookup = pickle.load(open(embedding_index_path, 'rb'))\\n\\n else:\\n logging.warning('Downloading embedding. If downloading for the first time, this make take 5-10 minutes.')\\n embedding_url = 'https://s3.amazonaws.com/dl4j-distribution/GoogleNews-vectors-negative300.bin.gz'\\n embedding_path = '~/nlp_example/'\\n embedding_filename = 'GoogleNews-vectors-negative300.bin.gz'\\n lib.download_file(embedding_url, embedding_path, embedding_filename)\\n\\n # Unpack embedding\\n model = gensim.models.KeyedVectors.load_word2vec_format(embedding_path + '/' + embedding_filename, binary=True)\\n embedding_matrix = model.syn0\\n embedding_index_lookup = dict([(k, v.index) for k, v in model.vocab.items()])\\n\\n # Create thesaurus\\n thesaurus = Thesaurus(embedding_matrix, embedding_index_lookup)\\n\\n # Find nearest neighbors for examples\\n print(thesaurus.synonyms('day'))\\n print(thesaurus.synonyms('top'))\\n print(thesaurus.synonyms('bottom'))\\n print(thesaurus.synonyms('cat'))\\n print(thesaurus.synonyms('grown'))\\n\\n\\n pass\",\n \"def get_embeddings(emb_path, emb_length, vocab_size, embedding_type):\\n print(\\\"Loading {} embeddings from file: {}...\\\".format(embedding_type, emb_path))\\n\\n emb_matrix = []\\n str2id = {}\\n idx = 0\\n with open(emb_path, 'r') as fh:\\n for line in tqdm(fh, total=vocab_size):\\n line = line.lstrip().rstrip().split(\\\" \\\")\\n word = line[0]\\n vector = list(map(float, line[1:]))\\n if emb_length != len(vector):\\n raise Exception(\\n \\\"{}: Expected vector of size {}, but got vector of size {}.\\\".format(idx, emb_length, len(vector)))\\n emb_matrix.append(vector)\\n str2id[word] = idx\\n idx += 1\\n\\n emb_matrix = np.array(emb_matrix, dtype=np.float32)\\n print(\\\"Loaded {} embedding matrix with shape {}.\\\".format(embedding_type, emb_matrix.shape))\\n\\n return emb_matrix, str2id\",\n \"def _manifold_to_dataspace(self, X_embedded):\\n\\n if self.A.shape[1] != X_embedded.shape[0]:\\n X_embedded = X_embedded.T\\n\\n X_query_kd = self.A @ X_embedded[self.n_keep_dims:]\\n X_query_kd = X_query_kd.T # make X_query_kd of shape (q x d)\\n\\n # concatenate column-wise\\n if self.n_keep_dims > 0:\\n X_query = np.hstack((X_embedded[:self.n_keep_dims], X_query_kd))\\n else:\\n X_query = X_query_kd\\n\\n X_query = self._unscale(X_query)\\n return X_query\",\n \"def generate_embeddings_memory(dataset_path, classes):\\n # get embeddings not in generators\\n model = embeddings(INPUT_DIM)\\n X_train, X_test, y_train, y_test = get_train_test_lists(dataset_path, classes)\\n X_train_em = []\\n X_test_em = []\\n\\n for im in X_train:\\n img = preprocess_image(im)\\n embeds = model.predict(img)\\n embeds = np.squeeze(embeds)\\n X_train_em.append(embeds)\\n for im in X_test:\\n img = preprocess_image(im)\\n embeds = model.predict(img)\\n embeds = np.squeeze(embeds)\\n X_test_em.append(embeds)\\n return np.array(X_train_em), np.array(X_test_em), np.array(y_train), np.array(y_test)\",\n \"def embed_sent(self, x: Any) -> expression_seqs.ExpressionSequence:\\n # single mode\\n if not batchers.is_batched(x):\\n expr = expression_seqs.ExpressionSequence(expr_list=[self.embed(word) for word in x])\\n # minibatch mode\\n elif type(self) == LookupEmbedder:\\n embeddings = []\\n for word_i in range(x.sent_len()):\\n batch = batchers.mark_as_batch([single_sent[word_i] for single_sent in x])\\n embeddings.append(self.embed(batch))\\n expr = expression_seqs.ExpressionSequence(expr_list=embeddings, mask=x.mask)\\n else:\\n assert type(x[0]) == sent.SegmentedSentence, \\\"Need to use CharFromWordTextReader for non standard embeddings.\\\"\\n embeddings = []\\n all_embeddings = []\\n for sentence in x:\\n embedding = []\\n for i in range(sentence.len_unpadded()):\\n embed_word = self.embed(sentence.words[i])\\n embedding.append(embed_word)\\n all_embeddings.append(embed_word)\\n embeddings.append(embedding)\\n # Useful when using dy.autobatch\\n dy.forward(all_embeddings)\\n all_embeddings.clear()\\n # Pad the results\\n expr = batchers.pad_embedding(embeddings)\\n\\n return expr\",\n \"def predict(self, content):\\n input_x = list(content)\\n while len(input_x) < self.args.maxlen1: input_x.append('<pad>')\\n input_x = input_x[:self.args.maxlen1]\\n\\n input_x = [self.token2idx.get(s, self.token2idx['<unk>']) for s in input_x]\\n\\n memory = self.sess.run(self.memory, feed_dict={self.input_x: [input_x]})\\n\\n return self.bs.search(self.sess, input_x, memory[0])\",\n \"def learn_from_memory():\\n\\n # Get a random minibatch from the replay memory and learns from it.\\n if agent.memory.size > args.batch_size:\\n s1, a, s2, isterminal, r = agent.memory.get_sample(args.batch_size)\\n\\n q = agent.get_q_values(s2).cpu().data.numpy()\\n q2 = np.max(q, axis=1)\\n\\n target_q = agent.get_q_values(s1).cpu().data.numpy()\\n # target differs from q only for the selected action. The following means:\\n # target_Q(s,a) = r + gamma * max Q(s2,_) if isterminal else r\\n\\n target_q[np.arange(target_q.shape[0]), a] = r + args.discount_factor * (1 - isterminal) * q2\\n learn(s1, target_q)\",\n \"def in_storage(query,k,m):\\n bools = []\\n for i in range(1,k+1):\\n bools.append(bfilter[mmh3.hash(query,i)%m])\\n return np.prod(bools)\",\n \"def embed(x, phase):\\r\\n\\r\\n is_train = True if phase == 'train' else False\\r\\n\\r\\n # Input embedding: convert input vector to dimension of hp.hidden_units.\\r\\n embs = input_embedding(x, num_units=hp.hidden_units, embed_type=hp.embed_type)\\r\\n print('Size after input embedding: ', embs.get_shape())\\r\\n\\r\\n # Positional Encoding.\\r\\n embs += embedding(tf.tile(tf.expand_dims(tf.range(tf.shape(x)[1]), 0), [tf.shape(x)[0], 1]),\\r\\n vocab_size=hp.win_len, num_units=hp.hidden_units,\\r\\n zero_pad=False, scale=False, scope=\\\"enc_pe\\\")\\r\\n print(\\\"Size after positional encoding: \\\", embs.get_shape())\\r\\n\\r\\n # Attention blocks.\\r\\n for i in range(hp.num_blocks):\\r\\n with tf.variable_scope(\\\"num_blocks_{}\\\".format(i)):\\r\\n # Multi-head Attention\\r\\n embs = multihead_attention(queries=embs, keys=embs, num_units=hp.hidden_units,\\r\\n num_heads=hp.num_heads, dropout_rate=hp.dropout_rate,\\r\\n is_training=is_train, causality=False)\\r\\n\\r\\n # Feed Forward\\r\\n embs = feedforward(embs, num_units=[2 * hp.hidden_units, hp.hidden_units])\\r\\n print(\\\"Size after multi-head_attention: \\\", embs.get_shape())\\r\\n\\r\\n # Temporal pooling by averaging on the time dimension.\\r\\n embs = tf.reduce_mean(embs, axis=1)\\r\\n\\r\\n return embs\",\n \"def pass_word(word, model, input_embedding, char2idx, device, use_head=True):\\n inp = torch.LongTensor([char2idx['START']] + [char2idx[c] for c in word]).to(device)\\n inp = pack([inp])\\n out, hidden = model(input_embedding.unsqueeze(0), inp, use_head=use_head)\\n return out, hidden\",\n \"def extract_argmax_and_embed(embedding, output_projection=None):\\n def loop_function(prev, _):\\n if output_projection is not None:\\n prev = tf.matmul(prev, output_projection[0]) + output_projection[1]\\n prev_symbol = tf.argmax(prev, 1) #得到对应的INDEX\\n emb_prev = tf.gather(embedding, prev_symbol) #得到这个INDEX对应的embedding\\n return emb_prev\\n return loop_function\",\n \"def retrieve(self, query, posting_encodings=util.CompressedPostings):\\n if len(self.term_id_map) == 0 or len(self.doc_id_map) == 0:\\n self.load()\\n\\n ### Begin your code\\n words = query.split()\\n iim = ii.InvertedIndexMapper('data', directory=self.output_dir, postings_encoding=posting_encodings)\\n tid = self.term_id_map.__getitem__(words[0])\\n ans = iim.__getitem__(tid)\\n for i in range(1, len(words)):\\n tid = self.term_id_map.__getitem__(words[i])\\n ans = self.sorted_intersect(ans, iim.__getitem__(tid))\\n for i in range(0, len(ans)):\\n ans[i] = self.doc_id_map.__getitem__(ans[i])\\n return ans\\n ### End your code\",\n \"def test_embedding_attend(self):\\n features = 5\\n embed = layers.Embed(num_embeddings=10, features=features)\\n inputs = np.array([[1]], dtype=np.int64)\\n variables = embed.init(jax.random.PRNGKey(0), inputs)\\n query = np.ones(features, dtype=np.float32)\\n result = embed.apply(variables, query, method=embed.attend)\\n expected = np.sum(variables['params']['embedding'], -1)\\n np.testing.assert_array_almost_equal(result, expected)\",\n \"def embed(self,ipa_seg):\\n pre_embedded = self.to_phoible_fts(ipa_seg)\\n return np.matmul(PhonologicalEmbedding.__embedding_matrix,pre_embedded)\",\n \"def _get_embedding(self, data):\\n embedding_list = [super()._get_embedding(data)]\\n context = data['context']\\n for i in range(context.shape[1]):\\n embedding_list.append(getattr(self, f'context{i}')(context[:, i:i+1]))\\n return torch.cat(embedding_list, dim=1)\",\n \"def qlist_to_vec(self, max_length, q_list):\\n qvec = np.zeros(max_length)\\n embed_matrix = None\\n if self.use_embed:\\n embed_matrix = np.zeros((max_length, EMBEDDING_SIZE))\\n \\\"\\\"\\\" pad on the left \\\"\\\"\\\"\\n # for i in range(max_length):\\n # if i < max_length - len(q_list):\\n # cvec[i] = 0\\n # else:\\n # w = q_list[i-(max_length-len(q_list))]\\n # # is the word in the vocabulary?\\n # if self.qdict.has_key(w) is False:\\n # w = ''\\n # qvec[i] = self.qdict[w]\\n # cvec[i] = 0 if i == max_length - len(q_list) else 1\\n \\\"\\\"\\\" pad on the right \\\"\\\"\\\"\\n for i in range(len(q_list)):\\n w = q_list[i]\\n if self.use_embed:\\n if w not in self.embed_dict:\\n self.embed_dict[w] = self.nlp(u'%s' % w).vector\\n embed_matrix[i] = self.embed_dict[w]\\n\\n if w not in self.qdict:\\n w = ''\\n qvec[i] = self.qdict[w]\\n return qvec, embed_matrix\",\n \"def _embed(self):\\n batch_size = tf.shape(self.p)[0]\\n with tf.variable_scope(\\\"emb\\\"):\\n with tf.variable_scope(\\\"char\\\"):\\n pc_emb = tf.reshape(tf.nn.embedding_lookup(\\n self.char_embed, self.pc), \\n [batch_size * self.max_p_len, self.max_w_len, self.vocab.char_embed_dim])\\n qc_emb = tf.reshape(tf.nn.embedding_lookup(\\n self.char_embed, self.qc), \\n [batch_size * self.max_q_len, self.max_w_len, self.vocab.char_embed_dim])\\n cell_fw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\\n cell_bw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, pc_emb, self.pc_length, dtype=tf.float32)\\n pc_emb = tf.concat([state_fw, state_bw], axis=1)\\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, qc_emb, self.qc_length, dtype=tf.float32)\\n qc_emb = tf.concat([state_fw, state_bw], axis=1)\\n pc_emb = tf.reshape(pc_emb, [batch_size, self.max_p_len, 2 * self.char_hidden_size])\\n qc_emb = tf.reshape(qc_emb, [batch_size, self.max_q_len, 2 * self.char_hidden_size])\\n\\n with tf.name_scope(\\\"word\\\"):\\n p_emb = tf.nn.embedding_lookup(self.word_embed, self.p)\\n q_emb = tf.nn.embedding_lookup(self.word_embed, self.q)\\n\\n with tf.name_scope(\\\"pos\\\"):\\n p_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.p_pos)\\n q_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.q_pos)\\n \\n with tf.name_scope(\\\"em\\\"):\\n sh = tf.shape(self.p_em)\\n resh = [sh[0], sh[1], 1]\\n p_em_feat = tf.reshape(tf.cast(self.p_em, dtype=tf.float32), shape=resh)\\n\\n self.p_emb = tf.concat([p_emb, pc_emb, p_pos_emb, p_em_feat], axis=2)\\n self.q_emb = tf.concat([q_emb, qc_emb, q_pos_emb], axis=2)\",\n \"def _find_embeddings(snlp):\\n embs = None\\n for proc in snlp.processors.values():\\n if hasattr(proc, \\\"pretrain\\\") and isinstance(proc.pretrain, Pretrain):\\n embs = proc.pretrain\\n break\\n return embs\",\n \"def forward(self, input_sentence):\\n sentence = self.word_embedding(input_sentence)\\n embedding = self.encoder(sentence)\\n return embedding\",\n \"def get_embedding():\\n\\n HOST = app.config.get('EMBEDDING_HOST')\\n PORT = app.config.get('EMBEDDING_PORT')\\n query_params = {\\n 'text' : request.args.get('text', \\\"\\\"),\\n \\\"language\\\" : request.args.get('language', None)\\n }\\n r = requests.get(f\\\"http://{HOST}:{PORT}/api/v1/embeddings/create\\\", params=query_params)\\n return jsonify(r.json())\",\n \"def embed(self, x):\\n if self.embedding is None:\\n return x\\n else:\\n return self.embedding(x)\",\n \"def compute_user_input_embedding(txt, model):\\r\\n embeddings = []\\r\\n tokens = txt.split(\\\" \\\")\\r\\n for word in tokens:\\r\\n embeddings.append(model.wv[word])\\r\\n sentence_embedding = compute_average(embeddings)\\r\\n return sentence_embedding\",\n \"def _embed_result(self, embedding):\\n # project original embedding\\n project_weight = self.project.weight # (o, c)\\n project_embedding = embedding.permute(0, 2, 1).unsqueeze(-1) \\\\\\n * project_weight.permute(1, 0) # (n, e, c, 1) * (c, o) -> (n, e, c, o)\\n project_embedding = project_embedding.permute(0, 3, 2, 1) # (n, o, c, e)\\n # interaction\\n square_of_sum = torch.sum(project_embedding, dim=2) ** 2\\n sum_of_square = torch.sum(project_embedding ** 2, dim=2)\\n embed_result = 0.5 * (square_of_sum - sum_of_square).sum(dim=2)\\n return embed_result\",\n \"def pretrained_embedding_layer(model,model2,model3, word_to_index,emb_dim_max):\\n words_ignored = []\\n vocab_len = len(word_to_index) + 1 \\n emb_matrix = np.zeros([vocab_len,emb_dim_max])\\n \\n print(' Total words would be processed : '+str(vocab_len))\\n for word, idx in word_to_index.items():\\n if word in model:\\n emb_matrix[idx,:200] = model[word]\\n emb_matrix[idx,200:] = 0\\n if word in model2:\\n emb_matrix[idx, :100] = model2[word]\\n emb_matrix[idx, 100:] = 0\\n if word in model3.keys():\\n emb_matrix[idx,:] = model3[word]\\n else:\\n words_ignored.append(word)\\n print(str(len(words_ignored))+\\\" words ignored\\\")\\n print(emb_matrix.shape) \\n \\n \\n embedding_layer = Embedding(vocab_len,emb_dim_max,trainable = True)\\n \\n # Build the embedding layer, it is required before setting the weights of the embedding layer. \\n embedding_layer.build((None,)) # Do not modify the \\\"None\\\". This line of code is complete as-is.\\n # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\\n embedding_layer.set_weights([emb_matrix])\\n \\n return embedding_layer,words_ignored\",\n \"def key_value_rte(placeholders, nvocab, **options):\\n\\n # [batch_size, max_seq1_length]\\n premise = placeholders['question']\\n # [batch_size]\\n premise_lengths = placeholders[\\\"question_lengths\\\"]\\n # [batch_size, max_seq2_length]\\n hypothesis = placeholders[\\\"support\\\"]\\n # [batch_size]\\n hypothesis_lengths = placeholders[\\\"support_lengths\\\"]\\n # [batch_size]\\n targets = placeholders[\\\"answers\\\"]\\n\\n output_size = options[\\\"repr_dim_output\\\"]\\n\\n with tf.variable_scope(\\\"embedders\\\") as varscope:\\n premise_embedded = nvocab(premise)\\n varscope.reuse_variables()\\n hypothesis_embedded = nvocab(hypothesis)\\n\\n # todo: add option for attentive reader\\n\\n print('TRAINABLE VARIABLES (only embeddings): %d' % get_total_trainable_variables())\\n\\n with tf.variable_scope(\\\"key_value_readers\\\") as varscope:\\n premise_outputs, _ = \\\\\\n key_value_reader(premise_embedded, premise_lengths, output_size,\\n contexts=(None, None), scope=None,\\n drop_keep_prob=options[\\\"drop_keep_prob\\\"],\\n project_fw_bw=True)\\n varscope.reuse_variables()\\n hypothesis_outputs, _ = \\\\\\n key_value_reader(hypothesis_embedded, hypothesis_lengths, output_size,\\n contexts=(None, None), scope=None,\\n drop_keep_prob=options[\\\"drop_keep_prob\\\"],\\n project_fw_bw=True)\\n\\n # Reading premise with memory of hypothesis\\n #premise_outputs_processed, premise_state = mutable_attention(\\n # hypothesis_outputs, premise_outputs[0], premise_lengths, output_size, scope=varscope)\\n #varscope.reuse_variables()\\n\\n # Reading hypothesis with memory of premise and altered memory of hypothesis\\n hypothesis_outputs_processed, hypothesis_state = mutable_attention(\\n premise_outputs, hypothesis_outputs[0], hypothesis_lengths, output_size)\\n\\n # todo: read premise and hypothesis memory for inferring entailment class\\n\\n # fixme: last can be zero because of dynamic_rnn!\\n #output = hypothesis_outputs[0][:, -1, :]\\n\\n output = hypothesis_state.h\\n\\n #targets = tf.Print(targets, [tf.shape(targets)], \\\"targets \\\")\\n #output = tf.Print(output, [tf.shape(output)], \\\"outputs \\\")\\n\\n logits, loss, predict = predictor(output, targets, options[\\\"answer_size\\\"])\\n\\n print('TRAINABLE VARIABLES (embeddings + model): %d' % get_total_trainable_variables())\\n print('ALL VARIABLES (embeddings + model): %d' % get_total_variables())\\n\\n return logits, loss, predict\",\n \"def prepare_word_emb_matrices(experiment):\\r\\n\\r\\n with open(\\\"public_data/stats/stats_train.pkl\\\", 'rb') as stats:\\r\\n stats = pickle.load(stats)\\r\\n vocab = stats[\\\"VOCAB\\\"]\\r\\n stops = [word.lower() for word in set(stopwords.words('english'))]\\r\\n vocab = vocab + stops\\r\\n\\r\\n if experiment == \\\"RANDOM\\\":\\r\\n word_embs = np.random.uniform(low=-1.0, high=1.0, size=(len(vocab), PARAMS[\\\"SIZE\\\"])).astype(\\\"float32\\\")\\r\\n\\r\\n else:\\r\\n word_embs = []\\r\\n count_unk = 0\\r\\n count_kn = 0\\r\\n\\r\\n if experiment == \\\"5\\\":\\r\\n emb_model = KeyedVectors.load_word2vec_format(\\\"public_data/models/experiment_5/embeddings_5.bin\\\",\\r\\n binary=True)\\r\\n elif experiment == \\\"6\\\":\\r\\n emb_model = Word2Vec.load(\\\"public_data/models/experiment_6/embeddings_6\\\")\\r\\n\\r\\n elif experiment in [\\\"7\\\", \\\"8\\\"]:\\r\\n emb_model = FastText.load_fasttext_format(\\\"public_data/models/experiment_%s/embeddings_%s.bin\\\"\\r\\n %(experiment, experiment))\\r\\n for word in vocab:\\r\\n if word in emb_model:\\r\\n word_embs.append(emb_model[word])\\r\\n count_kn += 1\\r\\n else:\\r\\n word_embs.append(np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\\\"SIZE\\\"]))\\r\\n count_unk += 1\\r\\n\\r\\n word_embs = np.array(word_embs).astype(\\\"float32\\\")\\r\\n print(count_unk / (count_kn + count_unk))\\r\\n\\r\\n pad = np.zeros(shape=PARAMS[\\\"SIZE\\\"]).astype(\\\"float32\\\")\\r\\n unk = np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\\\"SIZE\\\"]).astype(\\\"float32\\\")\\r\\n word_embs = np.insert(word_embs, 0, unk, axis=0) #id 1\\r\\n word_embs = np.insert(word_embs, 0, pad, axis=0) #id 0\\r\\n\\r\\n with open(\\\"public_data/embeddings/word_embeddings_%s.pkl\\\" %experiment, 'wb') as out:\\r\\n pickle.dump(word_embs, out, protocol=4)\\r\\n\\r\\n return word_embs\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63078344","0.63063365","0.5960762","0.5928939","0.58945125","0.58742183","0.58714825","0.5823085","0.5794332","0.5751944","0.56750214","0.5587403","0.55768526","0.557125","0.5565566","0.5550268","0.5541789","0.5470685","0.5447556","0.54236406","0.5408294","0.5406469","0.5401259","0.5401143","0.5399215","0.5390409","0.538824","0.5385703","0.53731626","0.5358136","0.53569955","0.5349093","0.53242904","0.5321162","0.53182375","0.53176296","0.53133196","0.53075445","0.5294047","0.5291328","0.5291302","0.5283683","0.5278032","0.526622","0.52629006","0.5260308","0.5257134","0.5254715","0.5242012","0.52412045","0.52362627","0.5235791","0.5233309","0.52268565","0.52212095","0.5219294","0.5215402","0.521461","0.5208321","0.5206381","0.5205729","0.52030784","0.5191762","0.5187983","0.5183975","0.51789355","0.51756006","0.51707953","0.51659125","0.51650363","0.5142958","0.5140779","0.51387936","0.51237893","0.51199746","0.5111408","0.5110101","0.5108419","0.5107285","0.5102167","0.509658","0.5095546","0.50929123","0.50882405","0.5083063","0.507573","0.5073719","0.5069717","0.5066229","0.50653565","0.5055454","0.50553954","0.5054193","0.50496876","0.5049383","0.50487447","0.5040577","0.5038215","0.5033358"],"string":"[\n \"0.63078344\",\n \"0.63063365\",\n \"0.5960762\",\n \"0.5928939\",\n \"0.58945125\",\n \"0.58742183\",\n \"0.58714825\",\n \"0.5823085\",\n \"0.5794332\",\n \"0.5751944\",\n \"0.56750214\",\n \"0.5587403\",\n \"0.55768526\",\n \"0.557125\",\n \"0.5565566\",\n \"0.5550268\",\n \"0.5541789\",\n \"0.5470685\",\n \"0.5447556\",\n \"0.54236406\",\n \"0.5408294\",\n \"0.5406469\",\n \"0.5401259\",\n \"0.5401143\",\n \"0.5399215\",\n \"0.5390409\",\n \"0.538824\",\n \"0.5385703\",\n \"0.53731626\",\n \"0.5358136\",\n \"0.53569955\",\n \"0.5349093\",\n \"0.53242904\",\n \"0.5321162\",\n \"0.53182375\",\n \"0.53176296\",\n \"0.53133196\",\n \"0.53075445\",\n \"0.5294047\",\n \"0.5291328\",\n \"0.5291302\",\n \"0.5283683\",\n \"0.5278032\",\n \"0.526622\",\n \"0.52629006\",\n \"0.5260308\",\n \"0.5257134\",\n \"0.5254715\",\n \"0.5242012\",\n \"0.52412045\",\n \"0.52362627\",\n \"0.5235791\",\n \"0.5233309\",\n \"0.52268565\",\n \"0.52212095\",\n \"0.5219294\",\n \"0.5215402\",\n \"0.521461\",\n \"0.5208321\",\n \"0.5206381\",\n \"0.5205729\",\n \"0.52030784\",\n \"0.5191762\",\n \"0.5187983\",\n \"0.5183975\",\n \"0.51789355\",\n \"0.51756006\",\n \"0.51707953\",\n \"0.51659125\",\n \"0.51650363\",\n \"0.5142958\",\n \"0.5140779\",\n \"0.51387936\",\n \"0.51237893\",\n \"0.51199746\",\n \"0.5111408\",\n \"0.5110101\",\n \"0.5108419\",\n \"0.5107285\",\n \"0.5102167\",\n \"0.509658\",\n \"0.5095546\",\n \"0.50929123\",\n \"0.50882405\",\n \"0.5083063\",\n \"0.507573\",\n \"0.5073719\",\n \"0.5069717\",\n \"0.5066229\",\n \"0.50653565\",\n \"0.5055454\",\n \"0.50553954\",\n \"0.5054193\",\n \"0.50496876\",\n \"0.5049383\",\n \"0.50487447\",\n \"0.5040577\",\n \"0.5038215\",\n \"0.5033358\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6070764"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":94491,"cells":{"query":{"kind":"string","value":"Add entries to the memory module."},"document":{"kind":"string","value":"def add_entry(self, embeddings, labels, query_result=None):\n n_added = embeddings.shape[0]\n\n if self.added_memories + n_added <= self.memory_size:\n start = self.write_pointer + 1\n end = start + n_added\n self.update_ixs(range(start, end), embeddings, labels, query_result)\n self.write_pointer += n_added\n else:\n capacity_remaining = max(self.memory_size - self.added_memories, 0)\n if capacity_remaining > 0:\n start = self.write_pointer + 1\n self.update_ixs(range(start, self.memory_size), embeddings[:capacity_remaining], labels[:capacity_remaining],\n query_result, global_update=False)\n\n n_overflow = n_added - capacity_remaining\n # get least relevant indices\n if self.delete_method == \"relevance\":\n write_ixs = torch.topk(self.memory_relevance, n_overflow, largest=False).indices\n elif self.delete_method == \"age\":\n write_ixs = torch.topk(self.memory_age, n_overflow, largest=True).indices\n self.update_ixs(write_ixs, embeddings[capacity_remaining:], labels[capacity_remaining:], query_result)\n self.added_memories += n_added"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def add_memory(self, **kwarg):\n for name, obs in kwarg.items():\n self.buffers[name] = np.concatenate((self.buffers[name], obs), axis=0)\n # get recent memory\n return self","def record_memory_map(self):\n memory_map = self.get_memory_map()\n self._memory_map_records.append(memory_map)","def init_memory(self, address, values):\n for value in values: # writing 1 byte at a time\n self.set_memory(address, value)\n address = address + 1","def store_memory(memory, history, action, reward, next_history, dead):\n memory.append((history, action, reward, next_history, dead))","def appendProcess(self, pid: int, numberOfVariables: int, processTable, diagnostics) -> int:\n self.memory[pid] = []\n\n for _i in range(numberOfVariables):\n self.memory[pid].append(MemoryItem())\n\n return 0","def append(self, metaball):\n\n self.mbs.append(metaball)","def add_entries(self, entries):\n write_p = self._pointer\n for entry in entries:\n write_header(write_p, entry._entry_p)\n for block in entry.get_blocks():\n write_data(write_p, block, len(block))\n write_finish_entry(write_p)","def allocatememory(self):\n\n for key, value in self._dentsvertsdata.items():\n value.allocatememory()","def store_replay_memory(self, history, action, reward, next_history, dead):\n self.memory.append((history, action, reward, next_history, dead))","def __init__(self):\r\n self.__memory = []","def set_memory_map(self):\n sorted_list_tuple = sorted([(key, value) for key, value in \n self._page_map.iteritems() if value >= 0], \n key=lambda pair: pair[1])\n self._memory_map = [pair[0] for pair in sorted_list_tuple]","def set_memory_map(self):\n sorted_list_tuple = sorted([(key, value) for key, value in \n self._page_map.iteritems() if value[0] >= 0], \n key=lambda pair: pair[1])\n self._memory_map = [pair[0] for pair in sorted_list_tuple]","def add_entries(self, *entries: Entry):\n for entry in entries:\n self.add_entry(entry)","def allocatememory(self, key):\n self._dentsvertsdata[key].allocatememory()","def __init__(self):\n self.memory = {}\n self.sum_ = {}","def addEntries(self, rewardPoolId, data):\n resource = '/rewardPool/%s' % str(rewardPoolId)\n for d in [data[i:i + DEFAULT_CHUNK]\n for i in range(0, len(data), DEFAULT_CHUNK)]:\n param = [('entry', x,) for x in d]\n self.post(resource, param)","def _memory(self):\n memory = {}\n memory_used = cpmCPUMemoryUsed\n varbinds = self._snmp_connection.bulk_walk(memory_used)\n for varbind in varbinds:\n # grab the last element of the index to use as the memory_id\n if self._cisco_model in self._n3k_models:\n memory_id = self._process_mib_indices_table[int(varbind.index.split('.')[-1])]\n else:\n memory_id = int(varbind.index.split('.')[-1])\n memory[memory_id] = {u'memory_used': int(varbind.value)}\n\n memory_free = cpmCPUMemoryFree\n varbinds = self._snmp_connection.bulk_walk(memory_free)\n for varbind in varbinds:\n # grab the last element of the index to use as the memory_id\n if self._cisco_model in self._n3k_models:\n memory_id = self._process_mib_indices_table[int(varbind.index.split('.')[-1])]\n else:\n memory_id = int(varbind.index.split('.')[-1])\n memory[memory_id][u'memory_free'] = int(varbind.value)\n memory[memory_id][u'memory_total'] = memory[memory_id][u'memory_used'] + int(varbind.value)\n\n for memory_id in list(memory.keys()):\n if memory_id in self._module_numbers:\n if int(self._module_numbers[memory_id]) in self._entity_physical_names:\n memory[memory_id][u'memory_type'] = u\"Module {} ({})\".format(self._module_numbers[memory_id],\n self._entity_physical_names[\n int(self._module_numbers[memory_id])])\n else:\n memory[memory_id][u'memory_type'] = u\"Module {}\".format(self._module_numbers[memory_id])\n\n if not len(memory):\n self._logger.warn(\n u'Failed to get memory enrichments on device \"%s\" with model \"%s\"' %\n (self._device_fqdn, self._cisco_model))\n\n return memory","def initiate_memory(self):\n rows = constants.WINDOW_HEIGHT / constants.GRID_TILE_LENGTH\n cols = constants.WINDOW_WIDTH / constants.GRID_TILE_LENGTH\n self.memory = [[None for x in xrange(cols)] for x in xrange(rows)]","def add_memory(self, state, action, reward, next_state, is_done):\r\n for state_i, action_i, reward_i, next_state_i, is_done_i, ER_i in zip(state, action, reward, next_state,\r\n is_done, self.ER_array):\r\n ER_i.add_memory(state_i, action_i, reward_i, next_state_i, is_done_i)","def add_to_memory(count):\n\t\tSimulation.past_attendance.append(count)\n\t\tPerson.add_to_memory(count)\n\t\tSimulation.simulation_progression.write(str(Person.recent_memory))\n\t\tSimulation.simulation_progression.write(\"\\n\")","def remember(self, memory):\n assert isinstance(memory, dict)\n\n for name in self.names:\n assert name in memory\n self.meomries[name].append(memory[name])","def allocatememory(self):\n self._numvertstotal = self._numents * self._nvet\n self._cords = VertDataSingleChannel(GLDataType.FLOAT, 3, self._numvertstotal)\n self._colors = VertDataSingleChannel(GLDataType.UBYTE, 4, self._numvertstotal)","async def cadd(self, ctx, *args: Input):\n await self.add(\n MemoryInputSet(MemoryInputSetConfig(ctx=ctx, inputs=list(args)))\n )\n return ctx","def load_mem_to_registers(self):\n register = (self.opcode & 0xFFF) >> 8\n for x in range(register+1):\n self.registers[x] = self.memory[self.I + x]\n logger.info(\n \"Loaded memory from {} to {} in registers till V{}\".format(\n hex(self.I),\n hex((self.I + register)),\n register))","async def register_system_shared_memory(\n self,\n name: str,\n key: str,\n byte_size: int,\n offset: int = ...,\n headers: dict[str, t.Any] = ...,\n ) -> None:","def pin_memory(self):\r\n\r\n self.points = [in_tensor.pin_memory() for in_tensor in self.points]\r\n self.neighbors = [in_tensor.pin_memory() for in_tensor in self.neighbors]\r\n self.pools = [in_tensor.pin_memory() for in_tensor in self.pools]\r\n self.upsamples = [in_tensor.pin_memory() for in_tensor in self.upsamples]\r\n self.lengths = [in_tensor.pin_memory() for in_tensor in self.lengths]\r\n self.features = self.features.pin_memory()\r\n\r\n return self","def memory_write(self, offset: int, data: List[int]) -> None:\n self.mem_extend(offset, len(data))\n self.memory[offset : offset + len(data)] = data","def allocatememory(self):\n pass","def add(a: int, b: int, c: int, memory: List) -> NoReturn:\n memory[c] = memory[a] + memory[b]","def add_to_buffer(self, values):\n self._buffer.extend(values)","def _add_to_memory(self, state, action, next_state, reward, done):\n if len(self.memory) >= self.size_max_memory:\n self.memory.pop(0)\n self.memory += [Transition(state, action, next_state, reward, done)]","def load_registers_in_memory(self):\n register = (self.opcode & 0xF00) >> 8\n for x in range(register+1):\n self.memory[self.I + x] = self.registers[x]\n logger.info(\"Loaded registers from V0 to V{} into {}\".format(\n register,\n hex(self.I)))","def ADD():\n global pointer, memory, registers\n registers[memory[pointer + 0x02]] += memory[pointer + 0x01]\n pointer += 0x03","def write_mem(self):\n request = 'commands/writemem'\n return self._post(request)","def _build_memorymap(self):\n\t\tmemorymap = {}\n\t\ttotalsize = 0\n\t\tbaserva = self.liststream64.DirectoryData.BaseRva\n\t\tmmdscrptr64 = self.liststream64.DirectoryData.MINIDUMP_MEMORY_DESCRIPTOR64\n\t\tnumberofmemoryranges = self.liststream64.DirectoryData.NumberOfMemoryRanges\n\t\tfor i in range(numberofmemoryranges):\n\t\t\tmemorymap[mmdscrptr64[i].StartOfMemoryRange] = ((baserva + totalsize),mmdscrptr64[i].DataSize)\n\t\t\ttotalsize += mmdscrptr64[i].DataSize\n\t\treturn memorymap","def appendedEntries(self):\n self.contact_list.append({\"name\": self.first_name.title() + \" \" + self.last_name.title(), \"phone number\": self.phone_number, \"phone number type\": self.phone_number_type})","def add(self, states, all_state, action, all_actions, reward, next_state, all_next_state, done):\n e = self.experience(states, all_state, action, all_actions, reward, next_state, all_next_state, done)\n self.memory.append(e)","def add_entry(self, entry): # Hashmap.add_entry\n\n if entry.hexdigest in self.contentHash:\n self.contentHash[entry.hexdigest].append(entry)\n else:\n self.contentHash[entry.hexdigest] = [ entry ]\n\n if entry.depth < self.minDepth:\n self.minDepth = entry.depth","def reset_memory(self):\n self.memory = []","def allocate(self, memo):\r\n raise NotImplementedError","def addChunk(self, direction):\n pass\n\n ## get size of actual map\n ## create array of fitting size\n ## stack created array to map","def restore_program(memory_updates: Dict[int, int], memory: List[int]) -> List[int]:\n for (index, new_value) in memory_updates.items():\n memory[index] = new_value\n return memory","def add(self, key, value):\n self._data.append(self._Item(key, value))\n self._upheap(len(self._data) - 1) # upheap newly added position","def addEntry(self, symbol, address):\n self.table[symbol] = address","def add(self, key, value):\n self._data.append(self._Item(key, value))\n self._upheap(len(self._data) - 1) # upheap newly added position","def append(self, data):\n if self._expand_mode:\n new_keys = set(data.keys()) - self.keys & self._keys\n self._expand(new_keys)\n self._cubas = None\n self._append(data)\n self._number_of_items += 1","def memory_plan(self, feed_shapes):\n assert (self.ctx is not None)\n self.node_to_arr_map = {}\n for node, shape in self.node_to_shape_map.items():\n self.node_to_arr_map[node] = ndarray.empty(shape, ctx=self.ctx)","def add(self, key, value):\n self._data.append(self._Item(key, value))\n self._up_heap(len(self) - 1)","def add_datamap(self, ctx, datamap):\n zing_state = self._get_zing_tx_state()\n zing_state.datamaps.append((ctx.device(), datamap))","def post(self):\n try:\n memory = parse_memory_from_request()\n self.logger.info(\"Adding memory for %s on %s\", memory.user_id, memory.memory_date)\n ds.add_memory(memory)\n\n # re-fetch the memory and return it in the response body\n added_memory = ds.get_memory(memory.user_id, memory.memory_date)\n return added_memory.to_dict(), 201\n except MyDeticMemoryAlreadyExists, mdmae:\n self.logger.info(\"Memory already exists on add (%s : %s)\", memory.user_id, memory.memory_date)\n return generate_error_json(mdmae)\n except MyDeticInvalidMemoryString, mdims:\n self.logger.info(\"Invalid memory string on add (%s)\" % mdims.msg)\n return generate_error_json(mdims)\n except MyDeticException, mde:\n return generate_error_json(mde)","def memory(self, memory):\n\n self._memory = memory","def populate_mem():\n global MemListing\n for item in memList:\n mem = \"%s\" % item[0]\n price = \"%s\" % item[1]\n \n try:\n MemListing.objects.get(memList = mem, memPrice = price)\n \n except MemListing.DoesNotExist:\n print mem\n mydb = MemListing.objects.create(memList = mem, memPrice = price)\n print mydb\n mydb.save()","def memory(kdump_memory):\n config_db = ConfigDBConnector()\n if config_db is not None:\n config_db.connect()\n config_db.mod_entry(\"KDUMP\", \"config\", {\"memory\": kdump_memory})","def add(self, record):\n self._hist_records[record.uid] = record","def store(self, state, action, reward, next_state, done):\n self.replay_memory.append((state, action, reward, next_state, done))","def _initialize_mem_buffs():\r\n args = get_args()\r\n\r\n # Initialize memory for checkpointed activations.\r\n if args.distribute_checkpointed_activations:\r\n mpu.init_checkpointed_activations_memory_buffer()\r\n mpu.init_workspace_memory_buffer()\r\n # mpu.init_forward_buffer()\r\n mpu.init_QKV_forward_buffer()\r\n mpu.init_QKV_dense_buffer()\r\n mpu.init_h4h_forward_buffer()\r\n mpu.init_fhh_forward_buffer()\r\n mpu.init_backward_buffer()\r\n mpu.init_parameter_gradient_buffer()\r\n mpu.init_conjunction_gradient_buffer()\r\n # if not args.ParallelTransformer_only:\r\n # mpu.init_lmhead_dense_buffer()","def update_memory(self, target, clues, guesses, winlose):\n immediate_rewards = self.get_trajectory_immediate_rewards(target, \n clues,\n guesses)\n \n self.memory.append((target, \n clues, \n guesses, \n winlose, \n immediate_rewards))","def build_and_add(self,*args):\n lattice = lattice_class.lattice(*args)\n self.lattices.append()\n self.meshfns.append(['in_memory'])","def appenddictitemsize(self, key, numents):\n self._dentsvertsdata[key].appendsize(numents * self._multFactor)","def remember(self, item):\n self.memory.append(item)","def load_mem_to_registers_quirk(self):\n register = (self.opcode & 0xFFF) >> 8\n for x in range(register+1):\n self.registers[x] = self.memory[self.I + x]\n self.I += register + 1\n logger.info(\n \"Loaded memory from {} to {} in registers till V{}\".format(\n hex(self.I),\n hex((self.I + register)),\n register))","def allocate(self, memo):\r\n for input in self.kit.sinputs:\r\n r = input.variable\r\n if r not in memo:\r\n input = copy(input)\r\n input.value = Container(r, storage = [None])\r\n memo[r] = input","def update_replay_memory(self, transition: Tuple[np.array, int, int,\r\n np.array, bool]) -> None:\r\n self.replay_memory.append(transition)","def add(self, datasetName, rows):\r\n\r\n rows = np.vstack(rows)\r\n\r\n\t\t# Add the sample into the buffer\r\n try:\r\n self.datasetBuffer[datasetName].extend(rows)\r\n except:\r\n # Initialize the buffer\r\n self.datasetBuffer[datasetName] = []\r\n self.datasetBuffer[datasetName].extend(rows)\r\n\r\n # Create the dataset\r\n self._createDatasets(datasetName)\r\n\r\n # Initiliaze dataset index count\r\n self.idxs[datasetName] = 0\r\n\r\n # Update the number of samples in the buffer\r\n self.totalFeatures += len(rows)\r\n\r\n\t\t# Check to see if we have reached the maximum buffer size\r\n if self.totalFeatures >= self.maxBufferSize:\r\n\r\n\t\t\t# write the buffers to file\r\n self._writeBuffers()","def handle_memory_reads(self, instr):\n reading_export_address = 0\n number_of_exports_read = 0\n dyn_import_pair = set()\n stat_import_pair = set()\n if self.use_trace_file == True:\n dynamic_values_read = self.get_dynamic_memory_reads(instr)\n for value in dynamic_values_read:\n if self.exported_modules.contains_address(value) == True:\n dll_name, function_name = self.exported_modules.get_dll_and_function(value)\n dyn_import_pair.add((dll_name, function_name, value))\n\n static_values_read = list(self.get_static_memory_read(instr))\n for value in static_values_read:\n if self.exported_modules.contains_address(value) == True:\n dll_name, function_name = self.exported_modules.get_dll_and_function(value)\n stat_import_pair.add((dll_name, function_name, value))\n\n combined_pairs = dyn_import_pair.union(stat_import_pair)\n if len(combined_pairs) == 1:\n if len(dyn_import_pair) == 1:\n for dll_name, function_name, value in dyn_import_pair:\n self.import_table.add_function(dll_name, function_name, 1, instr)\n instr.add_values_read(value)\n reading_export_address = 1\n\n if len(stat_import_pair) == 1:\n for dll_name, function_name, value in stat_import_pair:\n self.import_table.add_function(dll_name, function_name, 0, instr)\n instr.add_values_read(value)\n reading_export_address = 1\n\n if reading_export_address == 1:\n self.instructions_to_relocate.append(instr.address)","def feed(self, entry):\r\n if entry.name not in self.names:\r\n self.names[entry.name] = list()\r\n self.names[entry.name].append(entry)","def add(self, batch_size=10000):\n if self.N <= batch_size:\n self.index.add(self.database)\n else:\n [self.index.add(self.database[i:i + batch_size])\n for i in tqdm(range(0, len(self.database), batch_size),\n desc='[index] add')]","def __init__(self):\n super(MemoryPersistence, self).__init__(descriptor)","def MEM (self,n):","def update_memory(self, result):\r\n if (len(self.memory) >= self.memory_capacity):\r\n self.memory.pop(0)\r\n self.memory.append(result)\r\n else:\r\n self.memory.append(result)","def add_file_from_memory(\n self, entry_path, entry_size, entry_data,\n filetype=REGULAR_FILE,\n permission=DEFAULT_UNIX_PERMISSION\n ):\n archive_pointer = self._pointer\n\n with new_archive_entry() as archive_entry_pointer:\n archive_entry = ArchiveEntry(None, archive_entry_pointer)\n\n archive_entry.pathname = entry_path\n entry_set_size(archive_entry_pointer, entry_size)\n entry_set_filetype(archive_entry_pointer, filetype)\n entry_set_perm(archive_entry_pointer, permission)\n write_header(archive_pointer, archive_entry_pointer)\n\n for chunk in entry_data:\n if not chunk:\n break\n write_data(archive_pointer, chunk, len(chunk))\n\n write_finish_entry(archive_pointer)\n entry_clear(archive_entry_pointer)","def load_history_entries(self, *entries):\n # Simplified version:\n for entry in entries:\n try:\n self[entry.url.host] += [entry]\n except KeyError:\n self[entry.url.host] = [entry]\n \n \n temp_dict = {entry.url.host: [] for entry in entries} \n for entry in entries:\n temp_dict[entry.url.host] += [entry]\n\n # Update the dictionary\n # self.update(temp_dict) # Will override any lists with the same host name\n for host, entry in temp_dict.items():\n #try:\n self[host] += [entry]\n #except IndexError:\n #self[host] = [entry]","def buffer(self, entry):\n # TODO\n print(\"Storing {} in Redis.\".format(entry))\n\n # Redis list to store all ids of entities\n self._pipeline.rpush(\n self._list_name,\n '{}'.format(entry.id)\n )\n\n # Redis hash to store all attributes of entities\n hash_name = '{}:{}'.format(self._list_name, entry.id)\n hash_dict = {}\n field_names = list(entry.__all__)\n field_names.remove('id')\n for field_name in field_names:\n hash_dict[field_name] = getattr(entry, field_name)\n\n self._pipeline.hmset(hash_name, hash_dict)","def append(self, *items: BOSminer) -> None:\n for item in items:\n self.miners[item.ip] = item","def devClearAdd(self):\n #l = [0, 1, 2, 3, 4, 5, 6, 15, 47]\n l = [0, 1, 2, 3, 4, 5, 47]\n tTree, tHeap, tHash = 0, 0, 0\n self.devClearStores()\n for i in l:\n movie = Movie()\n movie.importFromString(self._data[i])\n print \"Adding movie '%s'...\" % ( movie.title )\n start = time.clock() * 1000000\n self.storeTree.insert(movie)\n end = time.clock() * 1000000\n tTree += end - start\n start = time.clock() * 1000000\n self.storeHeap.insert(movie)\n end = time.clock() * 1000000\n tHeap += end - start\n start = time.clock() * 1000000\n self.storeHash.insert(movie)\n end = time.clock() * 1000000\n tHash += end - start\n self.benchmarkDisplay.binarySearchTree.set(tTree)\n self.benchmarkDisplay.binaryHeap.set(tHeap)\n self.benchmarkDisplay.hashTable.set(tHash)\n self.benchmarkDisplay.binarySearchTreeDepth.set(self.storeTree.getDepth())\n self.benchmarkDisplay.binaryHeapDepth.set(self.storeHeap.getDepth())","def bookkeeping(episode_memory, reward_per_episode):\n\n states, actions, new_states, rewards, done = zip(*episode_memory)\n reward_per_episode.append(np.sum(rewards))","def offset_list(self):\n self.nodes.append(None)\n self.formulas.append(None)\n self.node_memory.append(None)\n self.formulas_memory.append(None)","def add_array(self, attr_name, data, dtype=None):\n if attr_name in self._shm_attr_names:\n raise ValueError(f'A Shared Memory array with the name {attr_name}\\\n is already in this ShmManager')\n _shm = SharedMemArrayManager(\n data=data, dtype=dtype)\n self._shm_attr_names.append(attr_name)\n setattr(self, attr_name, _shm)","def add(self,key,value):\r\n try:\r\n self._data.append(self.Item(key,value)) # insert as Item class object with key value.\r\n self._heapify_after_add(len(self._data) - 1 )\r\n return self._data\r\n except Exception, e:\r\n print \"Error occurred in HeapDistance: add method\", e","def allocate_tensors(self):\n self.tensors = {}","def add_metadata(self, metdatadata_list):\n self._metadata.append((metdatadata_list, ))","def add_metadata(self, metdatadata_list):\n self._metadata.append((metdatadata_list, ))","def add_records(self, data: dict, execution_context: dict):","def to_memory(self, key):\n if key in self.keys('dict'):\n logger.debug(f'{key} already exist in dict (memory)')\n\n elif key in self.keys('shelve'):\n value = copy.copy(self[key])\n del self[key]\n self.add(key, value, 'dict')\n\n else:\n raise ValueError(f'{key} does not exist in shelve')","def insert(self, key, value):\n\n # Map key to an index in main_array\n item_index = self._key_hash(key)\n\n # Turn input key, value pair into a HashEntry object\n data = HashEntry(key, value)\n\n # Append key, value pair to end of appropriate linked list\n self.main_array[item_index].append(data)","def _extend(self, other):\n for key, value in list(other.entries.items()):\n self._add_entry(key, value)","def add(self, value):\n self.heap.append(value)\n self.heapify_up()","def addChildren(self, values):\r\n for i, value in enumerate(values):\r\n newScope = copy(self.scope)\r\n newScope.index = i\r\n setattr(newScope, self.entryName, value)\r\n self.componentsLoader.loadAll(self.tokens, scope=newScope, onto=self.widget)","def load_program(self, program):\n for idx, val in enumerate(program):\n self.memory[idx] = val","def initialize_memory(self, pretrain_length, env):\n\n if self.memlen >= pretrain_length:\n print(\"Memory already filled, length: {}\".format(len(self.memory)))\n return\n interval = max(10, int(pretrain_length/25))\n print(\"Initializing memory buffer.\")\n obs = env.states\n while self.memlen < pretrain_length:\n actions = np.random.uniform(-1, 1, (self.agent_count,\n self.action_size))\n next_obs, rewards, dones = env.step(actions)\n self.store((obs, next_obs, actions, rewards, dones))\n obs = next_obs\n if np.any(dones):\n env.reset()\n obs = env.states\n self.memory.init_n_step()\n if self.memlen % interval == 1 or self.memlen >= pretrain_length:\n print(\"...memory filled: {}/{}\".format(self.memlen,\n pretrain_length))\n print(\"Done!\")","def add_descriptors(self, mapping):\n for key, desc in mapping.iteritems():\n self.descriptors[int(key, 16)] = desc","def add_descriptors(self, mapping):\n for key, desc in mapping.iteritems():\n self.descriptors[int(key, 16)] = desc","def load_registers_in_memory_quirk(self):\n register = (self.opcode & 0xF00) >> 8\n for x in range(register+1):\n self.memory[self.I + x] = self.registers[x]\n self.I += register + 1\n logger.info(\"Loaded registers from V0 to V{} into {}\".format(\n register,\n hex(self.I)))","def _allocate_buffer_memory(self):\n for channel in self._channels_dict.values():\n if channel.enabled:\n channel.allocate(self._num_captures, self._num_samples)","def allocate(self, memo):\r\n deprecation_warning()\r\n for member in self.components():\r\n member.allocate(memo)","def mem_extend(self, start: int, size: int) -> None:\n if self.memory_size > start + size:\n return\n m_extend = start + size - self.memory_size\n self.memory.extend(bytearray(m_extend))","def add(self, state, action, reward, next_state, done):\r\n e = self.experience(state, action, reward, next_state, done)\r\n self.memory.append(e)","def add(self,**kwargs):\n if self._extract:\n raise RuntimeError('This archive is write-only!')\n\n items = kwargs.iteritems() if PY2 else kwargs.items()\n for key,value in items:\n self._setitem(key,value)","def __init__(self, contents=()):\n self._data = [self._Item(k, v) for k,v in contents] # empty by default\n if len(self._data) > 1:\n self._heapify()","def __init__(self,entries=None,memoized=False):\n if entries is not None:\n self.entries = entries[:]\n else:\n self.entries = []\n self.memoized = memoized"],"string":"[\n \"def add_memory(self, **kwarg):\\n for name, obs in kwarg.items():\\n self.buffers[name] = np.concatenate((self.buffers[name], obs), axis=0)\\n # get recent memory\\n return self\",\n \"def record_memory_map(self):\\n memory_map = self.get_memory_map()\\n self._memory_map_records.append(memory_map)\",\n \"def init_memory(self, address, values):\\n for value in values: # writing 1 byte at a time\\n self.set_memory(address, value)\\n address = address + 1\",\n \"def store_memory(memory, history, action, reward, next_history, dead):\\n memory.append((history, action, reward, next_history, dead))\",\n \"def appendProcess(self, pid: int, numberOfVariables: int, processTable, diagnostics) -> int:\\n self.memory[pid] = []\\n\\n for _i in range(numberOfVariables):\\n self.memory[pid].append(MemoryItem())\\n\\n return 0\",\n \"def append(self, metaball):\\n\\n self.mbs.append(metaball)\",\n \"def add_entries(self, entries):\\n write_p = self._pointer\\n for entry in entries:\\n write_header(write_p, entry._entry_p)\\n for block in entry.get_blocks():\\n write_data(write_p, block, len(block))\\n write_finish_entry(write_p)\",\n \"def allocatememory(self):\\n\\n for key, value in self._dentsvertsdata.items():\\n value.allocatememory()\",\n \"def store_replay_memory(self, history, action, reward, next_history, dead):\\n self.memory.append((history, action, reward, next_history, dead))\",\n \"def __init__(self):\\r\\n self.__memory = []\",\n \"def set_memory_map(self):\\n sorted_list_tuple = sorted([(key, value) for key, value in \\n self._page_map.iteritems() if value >= 0], \\n key=lambda pair: pair[1])\\n self._memory_map = [pair[0] for pair in sorted_list_tuple]\",\n \"def set_memory_map(self):\\n sorted_list_tuple = sorted([(key, value) for key, value in \\n self._page_map.iteritems() if value[0] >= 0], \\n key=lambda pair: pair[1])\\n self._memory_map = [pair[0] for pair in sorted_list_tuple]\",\n \"def add_entries(self, *entries: Entry):\\n for entry in entries:\\n self.add_entry(entry)\",\n \"def allocatememory(self, key):\\n self._dentsvertsdata[key].allocatememory()\",\n \"def __init__(self):\\n self.memory = {}\\n self.sum_ = {}\",\n \"def addEntries(self, rewardPoolId, data):\\n resource = '/rewardPool/%s' % str(rewardPoolId)\\n for d in [data[i:i + DEFAULT_CHUNK]\\n for i in range(0, len(data), DEFAULT_CHUNK)]:\\n param = [('entry', x,) for x in d]\\n self.post(resource, param)\",\n \"def _memory(self):\\n memory = {}\\n memory_used = cpmCPUMemoryUsed\\n varbinds = self._snmp_connection.bulk_walk(memory_used)\\n for varbind in varbinds:\\n # grab the last element of the index to use as the memory_id\\n if self._cisco_model in self._n3k_models:\\n memory_id = self._process_mib_indices_table[int(varbind.index.split('.')[-1])]\\n else:\\n memory_id = int(varbind.index.split('.')[-1])\\n memory[memory_id] = {u'memory_used': int(varbind.value)}\\n\\n memory_free = cpmCPUMemoryFree\\n varbinds = self._snmp_connection.bulk_walk(memory_free)\\n for varbind in varbinds:\\n # grab the last element of the index to use as the memory_id\\n if self._cisco_model in self._n3k_models:\\n memory_id = self._process_mib_indices_table[int(varbind.index.split('.')[-1])]\\n else:\\n memory_id = int(varbind.index.split('.')[-1])\\n memory[memory_id][u'memory_free'] = int(varbind.value)\\n memory[memory_id][u'memory_total'] = memory[memory_id][u'memory_used'] + int(varbind.value)\\n\\n for memory_id in list(memory.keys()):\\n if memory_id in self._module_numbers:\\n if int(self._module_numbers[memory_id]) in self._entity_physical_names:\\n memory[memory_id][u'memory_type'] = u\\\"Module {} ({})\\\".format(self._module_numbers[memory_id],\\n self._entity_physical_names[\\n int(self._module_numbers[memory_id])])\\n else:\\n memory[memory_id][u'memory_type'] = u\\\"Module {}\\\".format(self._module_numbers[memory_id])\\n\\n if not len(memory):\\n self._logger.warn(\\n u'Failed to get memory enrichments on device \\\"%s\\\" with model \\\"%s\\\"' %\\n (self._device_fqdn, self._cisco_model))\\n\\n return memory\",\n \"def initiate_memory(self):\\n rows = constants.WINDOW_HEIGHT / constants.GRID_TILE_LENGTH\\n cols = constants.WINDOW_WIDTH / constants.GRID_TILE_LENGTH\\n self.memory = [[None for x in xrange(cols)] for x in xrange(rows)]\",\n \"def add_memory(self, state, action, reward, next_state, is_done):\\r\\n for state_i, action_i, reward_i, next_state_i, is_done_i, ER_i in zip(state, action, reward, next_state,\\r\\n is_done, self.ER_array):\\r\\n ER_i.add_memory(state_i, action_i, reward_i, next_state_i, is_done_i)\",\n \"def add_to_memory(count):\\n\\t\\tSimulation.past_attendance.append(count)\\n\\t\\tPerson.add_to_memory(count)\\n\\t\\tSimulation.simulation_progression.write(str(Person.recent_memory))\\n\\t\\tSimulation.simulation_progression.write(\\\"\\\\n\\\")\",\n \"def remember(self, memory):\\n assert isinstance(memory, dict)\\n\\n for name in self.names:\\n assert name in memory\\n self.meomries[name].append(memory[name])\",\n \"def allocatememory(self):\\n self._numvertstotal = self._numents * self._nvet\\n self._cords = VertDataSingleChannel(GLDataType.FLOAT, 3, self._numvertstotal)\\n self._colors = VertDataSingleChannel(GLDataType.UBYTE, 4, self._numvertstotal)\",\n \"async def cadd(self, ctx, *args: Input):\\n await self.add(\\n MemoryInputSet(MemoryInputSetConfig(ctx=ctx, inputs=list(args)))\\n )\\n return ctx\",\n \"def load_mem_to_registers(self):\\n register = (self.opcode & 0xFFF) >> 8\\n for x in range(register+1):\\n self.registers[x] = self.memory[self.I + x]\\n logger.info(\\n \\\"Loaded memory from {} to {} in registers till V{}\\\".format(\\n hex(self.I),\\n hex((self.I + register)),\\n register))\",\n \"async def register_system_shared_memory(\\n self,\\n name: str,\\n key: str,\\n byte_size: int,\\n offset: int = ...,\\n headers: dict[str, t.Any] = ...,\\n ) -> None:\",\n \"def pin_memory(self):\\r\\n\\r\\n self.points = [in_tensor.pin_memory() for in_tensor in self.points]\\r\\n self.neighbors = [in_tensor.pin_memory() for in_tensor in self.neighbors]\\r\\n self.pools = [in_tensor.pin_memory() for in_tensor in self.pools]\\r\\n self.upsamples = [in_tensor.pin_memory() for in_tensor in self.upsamples]\\r\\n self.lengths = [in_tensor.pin_memory() for in_tensor in self.lengths]\\r\\n self.features = self.features.pin_memory()\\r\\n\\r\\n return self\",\n \"def memory_write(self, offset: int, data: List[int]) -> None:\\n self.mem_extend(offset, len(data))\\n self.memory[offset : offset + len(data)] = data\",\n \"def allocatememory(self):\\n pass\",\n \"def add(a: int, b: int, c: int, memory: List) -> NoReturn:\\n memory[c] = memory[a] + memory[b]\",\n \"def add_to_buffer(self, values):\\n self._buffer.extend(values)\",\n \"def _add_to_memory(self, state, action, next_state, reward, done):\\n if len(self.memory) >= self.size_max_memory:\\n self.memory.pop(0)\\n self.memory += [Transition(state, action, next_state, reward, done)]\",\n \"def load_registers_in_memory(self):\\n register = (self.opcode & 0xF00) >> 8\\n for x in range(register+1):\\n self.memory[self.I + x] = self.registers[x]\\n logger.info(\\\"Loaded registers from V0 to V{} into {}\\\".format(\\n register,\\n hex(self.I)))\",\n \"def ADD():\\n global pointer, memory, registers\\n registers[memory[pointer + 0x02]] += memory[pointer + 0x01]\\n pointer += 0x03\",\n \"def write_mem(self):\\n request = 'commands/writemem'\\n return self._post(request)\",\n \"def _build_memorymap(self):\\n\\t\\tmemorymap = {}\\n\\t\\ttotalsize = 0\\n\\t\\tbaserva = self.liststream64.DirectoryData.BaseRva\\n\\t\\tmmdscrptr64 = self.liststream64.DirectoryData.MINIDUMP_MEMORY_DESCRIPTOR64\\n\\t\\tnumberofmemoryranges = self.liststream64.DirectoryData.NumberOfMemoryRanges\\n\\t\\tfor i in range(numberofmemoryranges):\\n\\t\\t\\tmemorymap[mmdscrptr64[i].StartOfMemoryRange] = ((baserva + totalsize),mmdscrptr64[i].DataSize)\\n\\t\\t\\ttotalsize += mmdscrptr64[i].DataSize\\n\\t\\treturn memorymap\",\n \"def appendedEntries(self):\\n self.contact_list.append({\\\"name\\\": self.first_name.title() + \\\" \\\" + self.last_name.title(), \\\"phone number\\\": self.phone_number, \\\"phone number type\\\": self.phone_number_type})\",\n \"def add(self, states, all_state, action, all_actions, reward, next_state, all_next_state, done):\\n e = self.experience(states, all_state, action, all_actions, reward, next_state, all_next_state, done)\\n self.memory.append(e)\",\n \"def add_entry(self, entry): # Hashmap.add_entry\\n\\n if entry.hexdigest in self.contentHash:\\n self.contentHash[entry.hexdigest].append(entry)\\n else:\\n self.contentHash[entry.hexdigest] = [ entry ]\\n\\n if entry.depth < self.minDepth:\\n self.minDepth = entry.depth\",\n \"def reset_memory(self):\\n self.memory = []\",\n \"def allocate(self, memo):\\r\\n raise NotImplementedError\",\n \"def addChunk(self, direction):\\n pass\\n\\n ## get size of actual map\\n ## create array of fitting size\\n ## stack created array to map\",\n \"def restore_program(memory_updates: Dict[int, int], memory: List[int]) -> List[int]:\\n for (index, new_value) in memory_updates.items():\\n memory[index] = new_value\\n return memory\",\n \"def add(self, key, value):\\n self._data.append(self._Item(key, value))\\n self._upheap(len(self._data) - 1) # upheap newly added position\",\n \"def addEntry(self, symbol, address):\\n self.table[symbol] = address\",\n \"def add(self, key, value):\\n self._data.append(self._Item(key, value))\\n self._upheap(len(self._data) - 1) # upheap newly added position\",\n \"def append(self, data):\\n if self._expand_mode:\\n new_keys = set(data.keys()) - self.keys & self._keys\\n self._expand(new_keys)\\n self._cubas = None\\n self._append(data)\\n self._number_of_items += 1\",\n \"def memory_plan(self, feed_shapes):\\n assert (self.ctx is not None)\\n self.node_to_arr_map = {}\\n for node, shape in self.node_to_shape_map.items():\\n self.node_to_arr_map[node] = ndarray.empty(shape, ctx=self.ctx)\",\n \"def add(self, key, value):\\n self._data.append(self._Item(key, value))\\n self._up_heap(len(self) - 1)\",\n \"def add_datamap(self, ctx, datamap):\\n zing_state = self._get_zing_tx_state()\\n zing_state.datamaps.append((ctx.device(), datamap))\",\n \"def post(self):\\n try:\\n memory = parse_memory_from_request()\\n self.logger.info(\\\"Adding memory for %s on %s\\\", memory.user_id, memory.memory_date)\\n ds.add_memory(memory)\\n\\n # re-fetch the memory and return it in the response body\\n added_memory = ds.get_memory(memory.user_id, memory.memory_date)\\n return added_memory.to_dict(), 201\\n except MyDeticMemoryAlreadyExists, mdmae:\\n self.logger.info(\\\"Memory already exists on add (%s : %s)\\\", memory.user_id, memory.memory_date)\\n return generate_error_json(mdmae)\\n except MyDeticInvalidMemoryString, mdims:\\n self.logger.info(\\\"Invalid memory string on add (%s)\\\" % mdims.msg)\\n return generate_error_json(mdims)\\n except MyDeticException, mde:\\n return generate_error_json(mde)\",\n \"def memory(self, memory):\\n\\n self._memory = memory\",\n \"def populate_mem():\\n global MemListing\\n for item in memList:\\n mem = \\\"%s\\\" % item[0]\\n price = \\\"%s\\\" % item[1]\\n \\n try:\\n MemListing.objects.get(memList = mem, memPrice = price)\\n \\n except MemListing.DoesNotExist:\\n print mem\\n mydb = MemListing.objects.create(memList = mem, memPrice = price)\\n print mydb\\n mydb.save()\",\n \"def memory(kdump_memory):\\n config_db = ConfigDBConnector()\\n if config_db is not None:\\n config_db.connect()\\n config_db.mod_entry(\\\"KDUMP\\\", \\\"config\\\", {\\\"memory\\\": kdump_memory})\",\n \"def add(self, record):\\n self._hist_records[record.uid] = record\",\n \"def store(self, state, action, reward, next_state, done):\\n self.replay_memory.append((state, action, reward, next_state, done))\",\n \"def _initialize_mem_buffs():\\r\\n args = get_args()\\r\\n\\r\\n # Initialize memory for checkpointed activations.\\r\\n if args.distribute_checkpointed_activations:\\r\\n mpu.init_checkpointed_activations_memory_buffer()\\r\\n mpu.init_workspace_memory_buffer()\\r\\n # mpu.init_forward_buffer()\\r\\n mpu.init_QKV_forward_buffer()\\r\\n mpu.init_QKV_dense_buffer()\\r\\n mpu.init_h4h_forward_buffer()\\r\\n mpu.init_fhh_forward_buffer()\\r\\n mpu.init_backward_buffer()\\r\\n mpu.init_parameter_gradient_buffer()\\r\\n mpu.init_conjunction_gradient_buffer()\\r\\n # if not args.ParallelTransformer_only:\\r\\n # mpu.init_lmhead_dense_buffer()\",\n \"def update_memory(self, target, clues, guesses, winlose):\\n immediate_rewards = self.get_trajectory_immediate_rewards(target, \\n clues,\\n guesses)\\n \\n self.memory.append((target, \\n clues, \\n guesses, \\n winlose, \\n immediate_rewards))\",\n \"def build_and_add(self,*args):\\n lattice = lattice_class.lattice(*args)\\n self.lattices.append()\\n self.meshfns.append(['in_memory'])\",\n \"def appenddictitemsize(self, key, numents):\\n self._dentsvertsdata[key].appendsize(numents * self._multFactor)\",\n \"def remember(self, item):\\n self.memory.append(item)\",\n \"def load_mem_to_registers_quirk(self):\\n register = (self.opcode & 0xFFF) >> 8\\n for x in range(register+1):\\n self.registers[x] = self.memory[self.I + x]\\n self.I += register + 1\\n logger.info(\\n \\\"Loaded memory from {} to {} in registers till V{}\\\".format(\\n hex(self.I),\\n hex((self.I + register)),\\n register))\",\n \"def allocate(self, memo):\\r\\n for input in self.kit.sinputs:\\r\\n r = input.variable\\r\\n if r not in memo:\\r\\n input = copy(input)\\r\\n input.value = Container(r, storage = [None])\\r\\n memo[r] = input\",\n \"def update_replay_memory(self, transition: Tuple[np.array, int, int,\\r\\n np.array, bool]) -> None:\\r\\n self.replay_memory.append(transition)\",\n \"def add(self, datasetName, rows):\\r\\n\\r\\n rows = np.vstack(rows)\\r\\n\\r\\n\\t\\t# Add the sample into the buffer\\r\\n try:\\r\\n self.datasetBuffer[datasetName].extend(rows)\\r\\n except:\\r\\n # Initialize the buffer\\r\\n self.datasetBuffer[datasetName] = []\\r\\n self.datasetBuffer[datasetName].extend(rows)\\r\\n\\r\\n # Create the dataset\\r\\n self._createDatasets(datasetName)\\r\\n\\r\\n # Initiliaze dataset index count\\r\\n self.idxs[datasetName] = 0\\r\\n\\r\\n # Update the number of samples in the buffer\\r\\n self.totalFeatures += len(rows)\\r\\n\\r\\n\\t\\t# Check to see if we have reached the maximum buffer size\\r\\n if self.totalFeatures >= self.maxBufferSize:\\r\\n\\r\\n\\t\\t\\t# write the buffers to file\\r\\n self._writeBuffers()\",\n \"def handle_memory_reads(self, instr):\\n reading_export_address = 0\\n number_of_exports_read = 0\\n dyn_import_pair = set()\\n stat_import_pair = set()\\n if self.use_trace_file == True:\\n dynamic_values_read = self.get_dynamic_memory_reads(instr)\\n for value in dynamic_values_read:\\n if self.exported_modules.contains_address(value) == True:\\n dll_name, function_name = self.exported_modules.get_dll_and_function(value)\\n dyn_import_pair.add((dll_name, function_name, value))\\n\\n static_values_read = list(self.get_static_memory_read(instr))\\n for value in static_values_read:\\n if self.exported_modules.contains_address(value) == True:\\n dll_name, function_name = self.exported_modules.get_dll_and_function(value)\\n stat_import_pair.add((dll_name, function_name, value))\\n\\n combined_pairs = dyn_import_pair.union(stat_import_pair)\\n if len(combined_pairs) == 1:\\n if len(dyn_import_pair) == 1:\\n for dll_name, function_name, value in dyn_import_pair:\\n self.import_table.add_function(dll_name, function_name, 1, instr)\\n instr.add_values_read(value)\\n reading_export_address = 1\\n\\n if len(stat_import_pair) == 1:\\n for dll_name, function_name, value in stat_import_pair:\\n self.import_table.add_function(dll_name, function_name, 0, instr)\\n instr.add_values_read(value)\\n reading_export_address = 1\\n\\n if reading_export_address == 1:\\n self.instructions_to_relocate.append(instr.address)\",\n \"def feed(self, entry):\\r\\n if entry.name not in self.names:\\r\\n self.names[entry.name] = list()\\r\\n self.names[entry.name].append(entry)\",\n \"def add(self, batch_size=10000):\\n if self.N <= batch_size:\\n self.index.add(self.database)\\n else:\\n [self.index.add(self.database[i:i + batch_size])\\n for i in tqdm(range(0, len(self.database), batch_size),\\n desc='[index] add')]\",\n \"def __init__(self):\\n super(MemoryPersistence, self).__init__(descriptor)\",\n \"def MEM (self,n):\",\n \"def update_memory(self, result):\\r\\n if (len(self.memory) >= self.memory_capacity):\\r\\n self.memory.pop(0)\\r\\n self.memory.append(result)\\r\\n else:\\r\\n self.memory.append(result)\",\n \"def add_file_from_memory(\\n self, entry_path, entry_size, entry_data,\\n filetype=REGULAR_FILE,\\n permission=DEFAULT_UNIX_PERMISSION\\n ):\\n archive_pointer = self._pointer\\n\\n with new_archive_entry() as archive_entry_pointer:\\n archive_entry = ArchiveEntry(None, archive_entry_pointer)\\n\\n archive_entry.pathname = entry_path\\n entry_set_size(archive_entry_pointer, entry_size)\\n entry_set_filetype(archive_entry_pointer, filetype)\\n entry_set_perm(archive_entry_pointer, permission)\\n write_header(archive_pointer, archive_entry_pointer)\\n\\n for chunk in entry_data:\\n if not chunk:\\n break\\n write_data(archive_pointer, chunk, len(chunk))\\n\\n write_finish_entry(archive_pointer)\\n entry_clear(archive_entry_pointer)\",\n \"def load_history_entries(self, *entries):\\n # Simplified version:\\n for entry in entries:\\n try:\\n self[entry.url.host] += [entry]\\n except KeyError:\\n self[entry.url.host] = [entry]\\n \\n \\n temp_dict = {entry.url.host: [] for entry in entries} \\n for entry in entries:\\n temp_dict[entry.url.host] += [entry]\\n\\n # Update the dictionary\\n # self.update(temp_dict) # Will override any lists with the same host name\\n for host, entry in temp_dict.items():\\n #try:\\n self[host] += [entry]\\n #except IndexError:\\n #self[host] = [entry]\",\n \"def buffer(self, entry):\\n # TODO\\n print(\\\"Storing {} in Redis.\\\".format(entry))\\n\\n # Redis list to store all ids of entities\\n self._pipeline.rpush(\\n self._list_name,\\n '{}'.format(entry.id)\\n )\\n\\n # Redis hash to store all attributes of entities\\n hash_name = '{}:{}'.format(self._list_name, entry.id)\\n hash_dict = {}\\n field_names = list(entry.__all__)\\n field_names.remove('id')\\n for field_name in field_names:\\n hash_dict[field_name] = getattr(entry, field_name)\\n\\n self._pipeline.hmset(hash_name, hash_dict)\",\n \"def append(self, *items: BOSminer) -> None:\\n for item in items:\\n self.miners[item.ip] = item\",\n \"def devClearAdd(self):\\n #l = [0, 1, 2, 3, 4, 5, 6, 15, 47]\\n l = [0, 1, 2, 3, 4, 5, 47]\\n tTree, tHeap, tHash = 0, 0, 0\\n self.devClearStores()\\n for i in l:\\n movie = Movie()\\n movie.importFromString(self._data[i])\\n print \\\"Adding movie '%s'...\\\" % ( movie.title )\\n start = time.clock() * 1000000\\n self.storeTree.insert(movie)\\n end = time.clock() * 1000000\\n tTree += end - start\\n start = time.clock() * 1000000\\n self.storeHeap.insert(movie)\\n end = time.clock() * 1000000\\n tHeap += end - start\\n start = time.clock() * 1000000\\n self.storeHash.insert(movie)\\n end = time.clock() * 1000000\\n tHash += end - start\\n self.benchmarkDisplay.binarySearchTree.set(tTree)\\n self.benchmarkDisplay.binaryHeap.set(tHeap)\\n self.benchmarkDisplay.hashTable.set(tHash)\\n self.benchmarkDisplay.binarySearchTreeDepth.set(self.storeTree.getDepth())\\n self.benchmarkDisplay.binaryHeapDepth.set(self.storeHeap.getDepth())\",\n \"def bookkeeping(episode_memory, reward_per_episode):\\n\\n states, actions, new_states, rewards, done = zip(*episode_memory)\\n reward_per_episode.append(np.sum(rewards))\",\n \"def offset_list(self):\\n self.nodes.append(None)\\n self.formulas.append(None)\\n self.node_memory.append(None)\\n self.formulas_memory.append(None)\",\n \"def add_array(self, attr_name, data, dtype=None):\\n if attr_name in self._shm_attr_names:\\n raise ValueError(f'A Shared Memory array with the name {attr_name}\\\\\\n is already in this ShmManager')\\n _shm = SharedMemArrayManager(\\n data=data, dtype=dtype)\\n self._shm_attr_names.append(attr_name)\\n setattr(self, attr_name, _shm)\",\n \"def add(self,key,value):\\r\\n try:\\r\\n self._data.append(self.Item(key,value)) # insert as Item class object with key value.\\r\\n self._heapify_after_add(len(self._data) - 1 )\\r\\n return self._data\\r\\n except Exception, e:\\r\\n print \\\"Error occurred in HeapDistance: add method\\\", e\",\n \"def allocate_tensors(self):\\n self.tensors = {}\",\n \"def add_metadata(self, metdatadata_list):\\n self._metadata.append((metdatadata_list, ))\",\n \"def add_metadata(self, metdatadata_list):\\n self._metadata.append((metdatadata_list, ))\",\n \"def add_records(self, data: dict, execution_context: dict):\",\n \"def to_memory(self, key):\\n if key in self.keys('dict'):\\n logger.debug(f'{key} already exist in dict (memory)')\\n\\n elif key in self.keys('shelve'):\\n value = copy.copy(self[key])\\n del self[key]\\n self.add(key, value, 'dict')\\n\\n else:\\n raise ValueError(f'{key} does not exist in shelve')\",\n \"def insert(self, key, value):\\n\\n # Map key to an index in main_array\\n item_index = self._key_hash(key)\\n\\n # Turn input key, value pair into a HashEntry object\\n data = HashEntry(key, value)\\n\\n # Append key, value pair to end of appropriate linked list\\n self.main_array[item_index].append(data)\",\n \"def _extend(self, other):\\n for key, value in list(other.entries.items()):\\n self._add_entry(key, value)\",\n \"def add(self, value):\\n self.heap.append(value)\\n self.heapify_up()\",\n \"def addChildren(self, values):\\r\\n for i, value in enumerate(values):\\r\\n newScope = copy(self.scope)\\r\\n newScope.index = i\\r\\n setattr(newScope, self.entryName, value)\\r\\n self.componentsLoader.loadAll(self.tokens, scope=newScope, onto=self.widget)\",\n \"def load_program(self, program):\\n for idx, val in enumerate(program):\\n self.memory[idx] = val\",\n \"def initialize_memory(self, pretrain_length, env):\\n\\n if self.memlen >= pretrain_length:\\n print(\\\"Memory already filled, length: {}\\\".format(len(self.memory)))\\n return\\n interval = max(10, int(pretrain_length/25))\\n print(\\\"Initializing memory buffer.\\\")\\n obs = env.states\\n while self.memlen < pretrain_length:\\n actions = np.random.uniform(-1, 1, (self.agent_count,\\n self.action_size))\\n next_obs, rewards, dones = env.step(actions)\\n self.store((obs, next_obs, actions, rewards, dones))\\n obs = next_obs\\n if np.any(dones):\\n env.reset()\\n obs = env.states\\n self.memory.init_n_step()\\n if self.memlen % interval == 1 or self.memlen >= pretrain_length:\\n print(\\\"...memory filled: {}/{}\\\".format(self.memlen,\\n pretrain_length))\\n print(\\\"Done!\\\")\",\n \"def add_descriptors(self, mapping):\\n for key, desc in mapping.iteritems():\\n self.descriptors[int(key, 16)] = desc\",\n \"def add_descriptors(self, mapping):\\n for key, desc in mapping.iteritems():\\n self.descriptors[int(key, 16)] = desc\",\n \"def load_registers_in_memory_quirk(self):\\n register = (self.opcode & 0xF00) >> 8\\n for x in range(register+1):\\n self.memory[self.I + x] = self.registers[x]\\n self.I += register + 1\\n logger.info(\\\"Loaded registers from V0 to V{} into {}\\\".format(\\n register,\\n hex(self.I)))\",\n \"def _allocate_buffer_memory(self):\\n for channel in self._channels_dict.values():\\n if channel.enabled:\\n channel.allocate(self._num_captures, self._num_samples)\",\n \"def allocate(self, memo):\\r\\n deprecation_warning()\\r\\n for member in self.components():\\r\\n member.allocate(memo)\",\n \"def mem_extend(self, start: int, size: int) -> None:\\n if self.memory_size > start + size:\\n return\\n m_extend = start + size - self.memory_size\\n self.memory.extend(bytearray(m_extend))\",\n \"def add(self, state, action, reward, next_state, done):\\r\\n e = self.experience(state, action, reward, next_state, done)\\r\\n self.memory.append(e)\",\n \"def add(self,**kwargs):\\n if self._extract:\\n raise RuntimeError('This archive is write-only!')\\n\\n items = kwargs.iteritems() if PY2 else kwargs.items()\\n for key,value in items:\\n self._setitem(key,value)\",\n \"def __init__(self, contents=()):\\n self._data = [self._Item(k, v) for k,v in contents] # empty by default\\n if len(self._data) > 1:\\n self._heapify()\",\n \"def __init__(self,entries=None,memoized=False):\\n if entries is not None:\\n self.entries = entries[:]\\n else:\\n self.entries = []\\n self.memoized = memoized\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65852726","0.6368498","0.62108815","0.62035614","0.6151291","0.6102449","0.60953045","0.6070591","0.58292973","0.580414","0.5742335","0.57391006","0.5659953","0.56543183","0.5636044","0.56220376","0.56029516","0.55805933","0.55668706","0.5543858","0.55356157","0.55350626","0.550956","0.5500705","0.5461388","0.54523534","0.5445837","0.54378724","0.5406094","0.54034364","0.53894305","0.5380181","0.5364969","0.53581005","0.53496724","0.53301305","0.53261703","0.5321016","0.5320756","0.53005695","0.5294957","0.5280996","0.5279753","0.5274282","0.5222746","0.52127326","0.5201223","0.51926273","0.51832914","0.517924","0.5177621","0.5161435","0.5155637","0.5153967","0.515199","0.51518655","0.51490885","0.51427233","0.5141583","0.5139402","0.513647","0.51350635","0.5134913","0.51331407","0.5101498","0.5098753","0.5090971","0.5089082","0.5088649","0.5087578","0.50838906","0.5073908","0.50727385","0.5067062","0.50662047","0.50589335","0.5053074","0.5050259","0.5043738","0.5039912","0.503614","0.503614","0.50289327","0.50277525","0.50246704","0.5012701","0.5011998","0.5010643","0.500378","0.5001688","0.5000886","0.5000886","0.49942732","0.49917966","0.49888888","0.49876076","0.4981407","0.49799514","0.49733937","0.49731153"],"string":"[\n \"0.65852726\",\n \"0.6368498\",\n \"0.62108815\",\n \"0.62035614\",\n \"0.6151291\",\n \"0.6102449\",\n \"0.60953045\",\n \"0.6070591\",\n \"0.58292973\",\n \"0.580414\",\n \"0.5742335\",\n \"0.57391006\",\n \"0.5659953\",\n \"0.56543183\",\n \"0.5636044\",\n \"0.56220376\",\n \"0.56029516\",\n \"0.55805933\",\n \"0.55668706\",\n \"0.5543858\",\n \"0.55356157\",\n \"0.55350626\",\n \"0.550956\",\n \"0.5500705\",\n \"0.5461388\",\n \"0.54523534\",\n \"0.5445837\",\n \"0.54378724\",\n \"0.5406094\",\n \"0.54034364\",\n \"0.53894305\",\n \"0.5380181\",\n \"0.5364969\",\n \"0.53581005\",\n \"0.53496724\",\n \"0.53301305\",\n \"0.53261703\",\n \"0.5321016\",\n \"0.5320756\",\n \"0.53005695\",\n \"0.5294957\",\n \"0.5280996\",\n \"0.5279753\",\n \"0.5274282\",\n \"0.5222746\",\n \"0.52127326\",\n \"0.5201223\",\n \"0.51926273\",\n \"0.51832914\",\n \"0.517924\",\n \"0.5177621\",\n \"0.5161435\",\n \"0.5155637\",\n \"0.5153967\",\n \"0.515199\",\n \"0.51518655\",\n \"0.51490885\",\n \"0.51427233\",\n \"0.5141583\",\n \"0.5139402\",\n \"0.513647\",\n \"0.51350635\",\n \"0.5134913\",\n \"0.51331407\",\n \"0.5101498\",\n \"0.5098753\",\n \"0.5090971\",\n \"0.5089082\",\n \"0.5088649\",\n \"0.5087578\",\n \"0.50838906\",\n \"0.5073908\",\n \"0.50727385\",\n \"0.5067062\",\n \"0.50662047\",\n \"0.50589335\",\n \"0.5053074\",\n \"0.5050259\",\n \"0.5043738\",\n \"0.5039912\",\n \"0.503614\",\n \"0.503614\",\n \"0.50289327\",\n \"0.50277525\",\n \"0.50246704\",\n \"0.5012701\",\n \"0.5011998\",\n \"0.5010643\",\n \"0.500378\",\n \"0.5001688\",\n \"0.5000886\",\n \"0.5000886\",\n \"0.49942732\",\n \"0.49917966\",\n \"0.49888888\",\n \"0.49876076\",\n \"0.4981407\",\n \"0.49799514\",\n \"0.49733937\",\n \"0.49731153\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5632198"},"document_rank":{"kind":"string","value":"15"}}},{"rowIdx":94492,"cells":{"query":{"kind":"string","value":"Update specific memory slots If query_result is not supplied, relevance scores are not updated."},"document":{"kind":"string","value":"def update_ixs(self, ixs, embeddings, labels, query_result=None, global_update=True):\n self.memory_embeddings[ixs] = embeddings\n self.memory_labels[ixs] = labels\n self.memory_age[ixs] = 0\n self.memory_relevance[ixs] = 0\n if global_update:\n self.memory_age[self.memory_age != -1] += 1\n if query_result is not None:\n # relevance mask indicates which samples are deemed relevant based on the query results\n # here this is simply which queries were closest to the query embedding, as well as the query itself\n relevance_mask = torch.zeros_like(self.memory_relevance)\n ix_counts = Counter(query_result[\"ix\"].flatten().tolist())\n for ix, count in ix_counts.items():\n relevance_mask[ix] = count\n relevance_mask[ixs] = 1 # assign a relevance of 1 to newly added entries as well\n # keep exponential moving average\n self.memory_relevance = self.relevance_discount * self.memory_relevance + relevance_mask"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _update(self, nbrs, nbrs_y, query, query_y):\n\n # Set up the graph for our shared memory variables\n new_K, new_A, new_V = self.K, self.A, self.V\n\n # Condition (1): First returned neighbour shares the same query label\n correct_query = T.eq(nbrs_y[:, 0], query_y).nonzero()[0]\n correct_mem = nbrs[correct_query, 0] # Idx to memory keys\n\n normed_keys = tensor_norm(query[correct_query] + new_K[correct_mem])\n new_K = T.set_subtensor(new_K[correct_mem], normed_keys)\n new_A = T.set_subtensor(new_A[correct_mem], 0.)\n\n # Condition (2): First returned neighbour does not share query label.\n # Add the key and label from query to memory\n incorrect_mask = T.neq(nbrs_y[:, 0], query_y)\n incorrect_query = incorrect_mask.nonzero()[0]\n\n # We need to find len(incorrect_query) locations in memory to write to.\n # Noise is added to randomize selection.\n age_mask = T.ge(new_A, T.max(new_A) - self.C) #1d\n oldest_idx = tensor_choose_k(age_mask, self.rng,\n k=T.sum(incorrect_mask),\n random=True).flatten()\n\n new_K = T.set_subtensor(new_K[oldest_idx], query[incorrect_query])\n new_V = T.set_subtensor(new_V[oldest_idx], query_y[incorrect_query])\n new_A = T.set_subtensor(new_A[oldest_idx], 0.)\n\n # Increment the age of all non-updated indices by 1\n new_A = new_A + 1.\n new_A = T.inc_subtensor(new_A[correct_mem], -1.)\n new_A = T.inc_subtensor(new_A[oldest_idx], -1.)\n\n return OrderedDict({(self.K, new_K), (self.V, new_V), (self.A, new_A)})","def update_memory(self, result):\r\n if (len(self.memory) >= self.memory_capacity):\r\n self.memory.pop(0)\r\n self.memory.append(result)\r\n else:\r\n self.memory.append(result)","def update_search_space(self, search_space):\n raise NotImplementedError('Tuner: update_search_space not implemented')","def update_results(self, results):\n pass","def update_vm_result(self, context, msg):\n args = jsonutils.loads(msg)\n agent = context.get('agent')\n port_id = args.get('port_uuid')\n result = args.get('result')\n LOG.debug('update_vm_result received from %(agent)s: '\n '%(port_id)s %(result)s', {'agent': agent,\n 'port_id': port_id,\n 'result': result})\n\n # Add the request into queue for processing.\n event_type = 'agent.vm_result.update'\n payload = {'port_id': port_id, 'result': result}\n timestamp = time.ctime()\n data = (event_type, payload)\n # TODO(nlahouti) use value defined in constants\n pri = self.obj.PRI_LOW_START + 10\n self.obj.pqueue.put((pri, timestamp, data))\n LOG.debug('Added request vm result update into queue.')\n\n return 0","def update_score(self, concept: _Concept, result: _Result) -> None:\n\n score = self.make_score(concept, result)\n if score is None:\n pass\n else:\n self._vector.append(score)","def UpdateNode(self, result, actions):\n self.visits += 1\n self.wins += (result > 0)\n self.losses += (result < 0)\n self.draws += (result == 0)\n self.Q = self.Q + (result - self.Q)/self.visits\n \n # update rave values\n for a in actions:\n self.N_AMAF[a] += 1\n if not a in self.Q_AMAF:\n self.Q_AMAF[a] = 0.5\n self.Q_AMAF[a] = self.Q_AMAF[a] + (result - self.Q_AMAF[a])/self.N_AMAF[a]\n else:\n self.Q_AMAF[a] = self.Q_AMAF[a] + (result - self.Q_AMAF[a])/self.N_AMAF[a]","def update_qvals(self, state, action, reward):\n self.qvals[(state, action)] = 0","def updateQTable( self, reward, current_state ):","def _update_memory(key, cur, target, common_mem):\n mod_swap = {\"G\": \"M\", \"g\": \"m\"}\n cur_mem, orig_mod = _get_cur_mem(key, cur)\n if cur_mem >= common_mem * 1.5:\n return cur\n else:\n new_val = \"%s%s\" % (target, mod_swap.get(orig_mod, orig_mod))\n if key == \"jvm_opts\":\n out = cur\n out[-1] = \"-Xmx%s\" % new_val\n else:\n out = new_val\n return out","def update_Qfunction(self, result):\n if result == \"won\":\n final_value = WIN_VALUE\n elif result == \"draw\":\n final_value = DRAW_VALUE\n elif result == \"lost\":\n final_value = LOSS_VALUE\n \n self.move_history.reverse()\n next_max = -1.0\n \n for h in self.move_history:\n qvals = self.get_q(h[0])\n m = h[1]\n \n if next_max < 0:\n qvals[m] = final_value\n else:\n qvals[m] = qvals[m] * (1.0 - self.learning_rate) + self.learning_rate * self.value_discount * next_max\n \n self.q[h[0]] = qvals \n next_max = max(qvals)","def update_q_value(q_table: np.ndarray, state: int, action: int,\n learning_rate: float, current_reward: float,\n new_state: int, discount_rate: float) -> None:\n q_table[state, action] = new_q_value(q_table, state, action, learning_rate,\n current_reward, new_state,\n discount_rate)","def set_result(self, params, result, id=0):\n for i in range(len(self.result), id + 1):\n self.result.append(None)\n print \"List index %d does not exist, should not happen\" % i\n self.result[id] = result\n if self.best_score is None or result < self.best_score:\n self.best_score = result\n self.best_params = params\n return params, result","def update(self, result):\n\n runs_scored = 0\n outs_recorded = 0\n\n if result == 'single':\n # Runners from 2b or 3b score first\n if self.occupied_2b and self.occupied_3b:\n self.occupied_2b = False\n self.occupied_3b = False\n runs_scored += 2\n elif self.occupied_2b or self.occupied_3b:\n self.occupied_2b = False\n self.occupied_3b = False\n runs_scored += 1\n # Runners from first advance\n if self.occupied_1b:\n self.occupied_2b = True\n # First base now occupied\n self.occupied_1b = True\n\n if result == 'double':\n # Runners from 2b or 3b score\n if self.occupied_2b and self.occupied_3b:\n self.occupied_2b = False\n self.occupied_3b = False\n runs_scored += 2\n elif self.occupied_2b or self.occupied_3b:\n self.occupied_2b = False\n self.occupied_3b = False\n runs_scored += 1\n # Runner on 1st (see notes)\n if self.occupied_1b:\n rand = random.uniform(0,1)\n if rand < 0.4:\n runs_scored +=1\n else:\n self.occupied_3b = True\n self.occupied_1b = False\n \n if result == 'triple':\n # Everyone on base scores\n number_bases_occupied = self.occupied_1b + self.occupied_2b + self.occupied_3b\n runs_scored += number_bases_occupied\n # New runner on 3b\n self.occupied_3b = True\n\n if result == 'home run':\n number_bases_occupied = self.occupied_1b + self.occupied_2b + self.occupied_3b\n runs_scored += number_bases_occupied + 1\n\n if result == 'foul out' or result == 'fly out' or result == 'out at 1st' or result == 'strike out':\n outs_recorded += 1\n\n if result == 'double play':\n # This is weird, since dps aren't always possible. See notes.\n \n if self.occupied_1b + self.occupied_2b + self.occupied_3b == 0:\n # If nobody on base, just a normal out\n outs_recorded +=1\n \n ## 1 existing Baserunner scenario\n elif self.occupied_1b and not self.occupied_2b and not self.occupied_3b:\n # If on first, outs at 1b and 2b\n self.occupied_1b = False\n outs_recorded += 2\n elif (not self.occupied_1b and self.occupied_2b and not self.occupied_3b):\n # If baserunner on second, no force outs, just add an out\n outs_recorded += 1\n elif (not self.occupied_1b and not self.occupied_2b and self.occupied_3b):\n # If baserunner on third, same\n outs_recorded += 1\n\n ## 2 existing Baserunner scenario\n elif self.occupied_1b and self.occupied_2b and not self.occupied_3b:\n # If on 1st and 2nd, outs at 3rd and 2nd\n self.occupied_1b = True\n self.occupied_2b = False\n outs_recorded += 2\n elif self.occupied_1b and not self.occupied_2b and self.occupied_3b:\n # If on 1st and 3nd, outs at 2rd and 1st\n self.occupied_1b = False\n outs_recorded += 2\n elif not self.occupied_1b and self.occupied_2b and self.occupied_3b: \n # If 2b and 3b occupied, only force out at 1b, so base/out doesn't change\n outs_recorded += 1\n\n ## 3 existing Baserunner scneario\n elif self.occupied_1b and self.occupied_2b and self.occupied_3b: \n # If bases loaded, outs at home and 3b. 2b and 1b stay occupied\n self.occupied_3b = False\n outs_recorded += 2\n\n\n if result == 'base on error':\n # Everyone advances\n if self.occupied_3b:\n runs_scored += 1\n self.occupied_3b = False\n if self.occupied_2b:\n self.occupied_3b = True\n self.occupied_2b = False\n if self.occupied_1b:\n self.occupied_2b = True\n self.occupied_1b = False\n self.occupied_1b = True\n\n\n if result == 'base on balls':\n if self.occupied_3b and self.occupied_2b and self.occupied_1b:\n runs_scored += 1\n if self.occupied_2b and self.occupied_1b:\n self.occupied_3b = True\n if self.occupied_1b:\n self.occupied_2b = True\n self.occupied_1b = True \n\n return runs_scored, outs_recorded","def update(self, rank):\n # calculate MR and MRR\n self.mr += rank\n self.mrr += 1 / rank\n # calculate Hits@k\n if rank <= 1:\n self.hits1 += 1\n self.hits3 += 1\n self.hits5 += 1\n self.hits10 += 1\n elif rank <= 3:\n self.hits3 += 1\n self.hits5 += 1\n self.hits10 += 1\n elif rank <= 5:\n self.hits5 += 1\n self.hits10 += 1\n elif rank <= 10:\n self.hits10 += 1","def update_used_query_range(\n self,\n write_cursor: 'DBCursor',\n location_string: str,\n queried_ranges: list[tuple[Timestamp, Timestamp]],\n ) -> None:\n if len(queried_ranges) == 0:\n return\n\n starts = [x[0] for x in queried_ranges]\n ends = [x[1] for x in queried_ranges]\n saved_range = self.db.get_used_query_range(write_cursor, location_string)\n if saved_range is not None:\n starts.append(saved_range[0])\n ends.append(saved_range[1])\n\n self.db.update_used_query_range(\n write_cursor=write_cursor,\n name=location_string,\n start_ts=min(starts),\n end_ts=max(ends),\n )","def update(self, result):\n #print(\"updating node result = \" + str(result))\n self.visits += 1\n self.wins += result","def _adjust_memory(self, neighbour, neighbour_choice):\n if neighbour in self._memory:\n self.get_memory_of(neighbour).add_choice_to_memory(\n neighbour_choice, self.get_gene().get_mem_size())\n else:\n print (\"err: getMemory: no memory of subjectID \"\n + str(neighbour.get_id()))","def update_cache(self, query, results, expire):\n self.logger.info(\"DASMemcache::result(%s) store to cache\" % query)\n if not results:\n return\n key = genkey(query)\n rowdict = {}\n rowid = 0\n for row in results:\n if type(row) is dict:\n row['id'] = rowid\n rowdict[rowid] = row\n rowid += 1\n if len(rowdict.keys()) == self.chunk_size:\n self.memcache.set_multi(rowdict, time=expire, key_prefix=key)\n rowdict = {}\n yield row\n self.memcache.set_multi(rowdict, time=expire, key_prefix=key)\n self.memcache.set(key, rowid, expire)","def update_q(self,action,reward):\n #print('')\n #print('Action index is: ' + str(action))\n #print('Provided reward is: ' + str(reward))\n \n # Read from disk before updating\n try:\n pickle_in = open(\"static/data/values.pickle\",\"rb\")\n values = pickle.load(pickle_in)\n #print(values)\n self.values = values\n pickle_in = open(\"static/data/counts.pickle\",\"rb\")\n self.counts = pickle.load(pickle_in)\n pickle_in = open(\"static/data/actions_taken.pickle\",\"rb\")\n actions_taken = pickle.load(pickle_in)\n pickle_in = open(\"static/data/reward_list.pickle\",\"rb\")\n reward_list = pickle.load(pickle_in)\n except:\n actions_taken = []\n reward_list = []\n pass\n \n self.counts[action] += 1\n n = self.counts[action]\n value = self.values[action]\n actions_taken.append(action)\n reward_list.append(reward)\n \n # Running product\n new_value = value + (1/n) * (reward - value)\n self.values[action] = new_value\n \n \n # Save to disk before exiting\n pickle_out = open('static/data/values.pickle','wb')\n pickle.dump(self.values, pickle_out)\n pickle_out.close()\n pickle_out = open('static/data/counts.pickle','wb')\n pickle.dump(self.counts, pickle_out)\n pickle_out.close()\n pickle_out = open('static/data/actions_taken.pickle','wb')\n pickle.dump(actions_taken, pickle_out)\n pickle_out.close()\n pickle_out = open('static/data/reward_list.pickle','wb')\n pickle.dump(reward_list, pickle_out)\n pickle_out.close()","def _fill_query_slots(self, queries: List[Query]) -> None:\n while queries and self.query_slots > 0:\n logger.debug(\n f\"{self.query_slots} available query slots, creating query task\"\n )\n query = queries.pop(0)\n query_task_id = self.client.create_query_task(query.query_id)\n self.query_slots -= 1\n query.query_task_id = query_task_id\n self._query_by_task_id[query_task_id] = query\n self._running_queries.append(query)","def update_memory(self, target, clues, guesses, winlose):\n immediate_rewards = self.get_trajectory_immediate_rewards(target, \n clues,\n guesses)\n \n self.memory.append((target, \n clues, \n guesses, \n winlose, \n immediate_rewards))","def update(self, FlowStatistics=None, MatchIpAddressInArpPackets=None, PortStatistics=None, QueueStatistics=None, ReassambleIpFragments=None, Reserved=None, SpanningTree=None, TableStatistics=None):\n self._update(locals())","def update(self, state, action, nextState, reward):\n \"\"\"Description:\n Use Q-Learning algoritm in slide 58 of MDP\n \"\"\"\n \"\"\" YOUR CODE HERE \"\"\"\n maxQns = self.getValue(nextState) # get max q-value of next state\n if maxQns == None:\n maxQns = 0\n Qsa = self.getQValue(state, action) #self.qValues[(state, action)]\n difference = reward + self.discountRate * maxQns - Qsa\n self.qValues[(state, action)] += self.alpha * difference\n \n self.vitCount[(state, action)] += 1\n \"\"\" END CODE \"\"\"","def update(self, arm, reward):\n raise NotImplementedError","def _update_q_value(self, start_state, to_state, reward, iteration):\n if start_state.as_tuple() not in self.qstore.q:\n self.enum.enumerate_state(start_state, self.qstore.q)\n if to_state.as_tuple() not in self.qstore.q:\n self.enum.enumerate_state(to_state, self.qstore.q)\n\n actions = self.qstore.q[start_state.as_tuple()]['actions']\n values = self.qstore.q[start_state.as_tuple()]['utilities']\n\n max_over_next_states = max(self.qstore.q[to_state.as_tuple()]['utilities']) if to_state.terminate != 1 else 0\n\n action_between_states = to_state.as_tuple()\n\n action_index = actions.index(action_between_states)\n learning_rate_alpha = 1 / (iteration ** self.state_space_parameters.learning_rate_omega)\n\n # Q_Learning update rule\n values[action_index] = ( # Q_t+1(s_i,𝑢) =\n values[action_index] + # Q_t(s_i,𝑢)\n learning_rate_alpha * ( # α\n reward # r_t\n + self.state_space_parameters.discount_factor # γ\n * max_over_next_states # max_{𝑢'∈ 𝒰(s_j)} Q_t(s_j,𝑢')\n - values[action_index] # -Q_t(s_i,𝑢)\n )\n )\n\n self.qstore.q[start_state.as_tuple()] = {'actions': actions, 'utilities': values}","def update(self, reward):\n raise NotImplementedError","def update_results_score(self, edge, regions):\r\n if self.results_file is None:\r\n return # No update\r\n \r\n pln = self.get_player_num()\r\n self.results_file.results_update(player_num=pln, nsquare=len(regions))","def vm_result_update(self, payload):\n\n port_id = payload.get('port_id')\n result = payload.get('result')\n\n if port_id and result:\n # Update the VM's result field.\n params = dict(columns=dict(result=result))\n self.update_vm_db(port_id, **params)","def update_q_table(self, state, action, reward):\n\n q_key = self.q_key(state, action)\n inputs = self.env.sense(self)\n self.next_waypoint = self.planner.next_waypoint()\n new_state = self.set_current_state(inputs)\n\n #update q_value in q_table according to learning formula\n x = self.q_value(state, action)\n V = reward + (self.gamma * self.max_q_value(new_state))\n new_q_value = x + (self.alpha * (V - x))\n self.q_table[q_key] = new_q_value","def update_Qtable(self, r, action, next_state):\n if self.learning:\n # 8. When learning, update the q table according\n # to the given rules\n\n # The reward the turkey get after doing the action\n reward_t1 = r\n\n # Code Review1: Replace the following code\n '''\n # Get the key & value which enables the max Q value in State(t+1)\n max_Q_St1_info = max(self.Qtable[next_state].items(), key=operator.itemgetter(1))\n\n # The action which enables the max Q value in State(t+1)\n max_Q_St1_action = max_Q_St1_info[0]\n\n # The max Q value in State(t+1)\n max_Q_St1 = max_Q_St1_info[1]\n '''\n max_Q_St1 = max(self.Qtable[next_state].values())\n\n Q_old = self.Qtable[self.state][action]\n Q_new = reward_t1 + self.gamma * max_Q_St1\n\n self.Qtable[self.state][action] = (\n 1 - self.alpha) * Q_old + self.alpha * Q_new","def updateQValue(self, state, action, old_q, reward, future_rewards):\n self.q[(tuple(state), action)] = old_q + self.alpha * (reward + future_rewards - old_q)","def update(self, arm, reward, context):","def update(self, result: int):\n self.wins += result\n self.visits += 1","def process_query(self, query):\n query._cache_region = self","def restore_program(memory_updates: Dict[int, int], memory: List[int]) -> List[int]:\n for (index, new_value) in memory_updates.items():\n memory[index] = new_value\n return memory","def add_result(self, result):\n if len(self.results) == self.max_size:\n del self.results[0]\n self.results.append(result)","def update_Q(self, reward):\n old_estimate = self.q_estimates[self.prev_action]\n self.q_estimates[self.prev_action] = old_estimate + 1/self.N[self.prev_action] * (reward - old_estimate)","def update(self, state, action, nextState, reward):\n \"*** YOUR CODE HERE ***\"\n self.qValues[(state, action)] = ((1 - self.alpha) * self.getQValue(state, action)) + self.alpha \\\n * (reward + self.discount * self.computeValueFromQValues(nextState))","def update_quality():\n global items, converted_items\n if not converted_items:\n items = convert_items(items)\n converted_items = True\n for item in items:\n item.update_q()","def update(self, state, action, nextState, reward):\n self.qvals[(state, action)] = self.qvals[(state, action)] + self.alpha * (\n reward + self.discount * self.computevaluefromqvalues(nextState) - self.qvals[(state, action)])","def update(self, state, action, nextState, reward):\n \"*** YOUR CODE HERE ***\"\n best_action = self.computeActionFromQValues(nextState)\n self.QValueCounter[(state, action)] = ((1 - self.alpha) * self.getQValue(state, action) +\n self.alpha * (reward + self.discount * self.getQValue(nextState,\n best_action)))","def update_Q(self, state, action, new_state, reward):\n \n self.Q[(state, action)] = self.Q[(state, action)] + self.alpha*(reward + self.gamma * self.max_value(new_state) - self.Q[(state, action)])","def update_q_values(self, s_current, action, r_next, s_next, action_next):\n action = actions_indexes[action]\n action_next = actions_indexes[action_next]\n self.q_values[s_current, action] += self.alpha * (\n r_next + self.gamma * self.q_values[s_next, action_next] - self.q_values[s_current, action])","def update_query(self):\n text = self.lineedit.text()\n self.results = self.lookup(text)\n self.update_ui()\n self.copy_entry(self.table.currentRow(), self.table.currentColumn())","def update(self, arm, context, reward):\n raise NotImplementedError","def update(self, arm, context, reward):\n raise NotImplementedError","def update_Q(self, state, action, new_state, new_action, reward):\n \n self.Q[(state, action)] = float(self.Q[(state, action)] + self.alpha*(reward + self.gamma * self.Q[new_state, new_action] - self.Q[(state, action)]))","def update_scores(read_scores, result):\n\n\t# check that there are some results for this read\n\tassert len(result) > 0\n\t# write this read to output\n\tfor sim_match in result.keys():\n\n\t\t# get type (discordant or chimeric)\n\t\tjunc_type = sim_match.split('_')[2]\n\n\t\tfor analysis_match in result[sim_match]:\n\t\t\t\n\t\t\t# get each score type\n\t\t\tfor score_type in read_scores:\n\t\t\t\tscore = analysis_match[score_type]\n\t\t\t\tread_scores[score_type][junc_type][score] += 1","def update_scores(self, score):\n self.result_list.append(score)\n\n if self.best_score == 0 and self.worst_score == 0:\n self.best_score = score\n self.worst_score = score\n\n if score < self.best_score:\n self.best_score = score\n\n if score > self.worst_score:\n self.worst_score = score","def _update_scoreboard(self, result):\n if result == Moveresult.KEY:\n self.current_turn.keys_collected += 1\n elif result == Moveresult.EXIT:\n self.current_turn.successful_exits += 1","def update(self, state, action, nextState, reward):\n \"*** YOUR CODE HERE ***\"\n Q_Value = self.Q #calling constructor\n\n learning_rate = self.alpha #gives us the learning rate\n\n temporary_QValue = self.getQValue(state,action) #to get the Q value of the state\n\n nextState_QValue = self.getValue(nextState) #to get the Q value of the landing state when taken action a and state s\n\n discount_factor = self.discount #to get the gamma/ discount factor\n\n\n Q_Value[(state,action)] = ((1-learning_rate) * temporary_QValue) + (learning_rate * (reward + discount_factor * nextState_QValue)) #for formula go to README_Reinforcement.txt at line 8\n\n #util.raiseNotDefined()","def update_reward(self, observation, action, reward):\n self.q_table[observation,action] = (1 - self.count(observation,action)) * self.q_table[observation,action] + self.count(observation,action) * reward # Canonical Q-update\n self.increment_count(observation,action)","def Update(self, result):\n self.visits += 1\n self.wins += result","def Update(self, result):\n self.visits += 1\n self.wins += result","def update(self, old_state, action, new_state, reward):\r\n \r\n old = self.get_q_value(old_state, action)\r\n best_future = self.best_future_reward(new_state)\r\n self.update_q_value(old_state,action, old, reward, best_future)","def update_Q(self):","def update(self, result):\n self.visits += 1\n self.wins += result","def update_unsampled_queries(self, remaining_indices):\n remaining_queries_ids = [\n self.unsampled_queries.elements[i] for i in remaining_indices\n ]\n self.unsampled_queries = ProcessedQueryList(\n cache=self.resource_loader.query_cache, elements=remaining_queries_ids\n )","def update(self):\r\n self.data = [self.make_item_tuple(i) for i in self.query]\r\n self._fetched = True\r\n query_cache.set(self.iden, self.data)","def update(self, x_dict, y_dict, weight):\n assert len(x_dict) == len(y_dict), \"invalid # of qids\"\n \n qids = self.__get_shuffled_qids(x_dict, y_dict, weight.epoch)\n w = weight.get_dense_weight()\n for qid in tqdm(qids):\n w = approx_ap(x_dict[qid].toarray(), y_dict[qid], w, self.eta, self.alpha, self.beta)\n weight.set_weight(sp.csr_matrix(w.reshape((1, weight.dims))))\n weight.epoch += 1","def update_score(self):\n self.score = TurboMQ.calculate_fitness(self.result, self.graph)","def update_individuals(individuals, eval_results):\n for ind, res in zip(individuals, eval_results):\n ind.fitness.values = res[0]\n ind.matching_node_pairs = res[1]\n ind.gtp_precisions = res[2]","def update(self, state, action, nextState, reward):\n \"*** YOUR CODE HERE ***\"\n # print \"update\"\n oldValue = self.getQValue(state, action)\n sample = reward + self.discount*self.computeValueFromQValues(nextState)\n self.qValues[(state, action)] = (1-self.alpha)*oldValue + self.alpha*(sample)","def put(self, search_query, page_number, search_results):\n timestamp = int(time.time())\n with self.get_conn() as conn:\n c = conn.cursor()\n insert = \"\"\"INSERT OR REPLACE INTO movies\n (search_query, page_number, timestamp, search_results)\n VALUES (?, ?, ?, ?)\"\"\"\n\n c.execute(insert, (search_query, page_number, timestamp, search_results,))\n conn.commit()","def update_q_values(self, state, action, next_state, reward, done):\n # Following the Q-Learning update rule\n if done:\n self.Q_values[state,action] = (1 - self.alpha) * self.Q_values[state,action] + self.alpha * (reward)\n else:\n self.Q_values[state,action] = (1 - self.alpha) * self.Q_values[state,action] + self.alpha * (reward + self.gamma * np.amax(self.Q_values[next_state]))","def update_result(result):\n invader = result['invader'] \n countryOfInvader = result['countryOfInvader'] \n defender = result['defender'] \n countryOfdefender = result['countryOfdefender'] \n invasionHistory = InvasionHistory(\n invader ,\n countryOfInvader,\n defender,\n countryOfdefender,\n datetime.datetime.now() )\n\n #update territory info\n t_record = Territory.get_by_key_name(countryOfdefender)\n t_record.occupier = invader\n t_record.put() \n\n db.put([invasionHistory])","def mult_operation(self):\n arg1 = self.memory[self.memory[self._cursor + 1]]\n arg2 = self.memory[self.memory[self._cursor + 2]]\n arg3 = self.memory[self._cursor + 3]\n self.memory[arg3] = arg1 * arg2\n print(f'Cursor: {self._cursor}\\tAssigning position {arg3} with value {arg1 * arg2}')\n self._cursor += 4\n return","def update_a_result(self, idblock, sib):\n self.resultPanel.update_item(idblock, sib)","def __on_query_edited(self):\n self.__refresh_search_results()","def update(self, target, query):\n node = self._data[target]\n name = \"%s node %.8s\" % (node['type'], target)\n\n query.update({\n 'type': node['type'],\n 'model': node['model']\n })\n\n logger.info(\"Validating query\")\n NodeValidator.validate(query)\n\n self._data[target] = dict_update(node, query, name)\n logger.info(\"Updated parameters above of %s\" % name)\n\n return {target: self._data[target]}","def update_state(self, result):\n for i,k in enumerate(self._current_state.keys()):\n self._current_state[k] = result[i]","def _update_result(self, results, clf_numbers):\n # ToDo make results of scoring values dynamic\n names_results = ['Accuracy']\n for number in clf_numbers:\n for name in names_results:\n if name not in self.results:\n self.results[name] = [results[number][name + \"_test_score_\" + str(number)]]\n else:\n self.results[name].append(results[number][name + \"_test_score_\" + str(number)])","def increment_rank(self, rank, result):\n if result not in VALID_RESULTS:\n raise ValueError('Invalid result: %s' % result)\n self.counts[rank][result] += 1\n self.total_items += 1","def update(self, timestep, action, reward, is_optimal):\r\n\t\t# Increments the Player's selected action index by 1.\r\n\t\tself.player_selected_actions[action] += 1\r\n\r\n\t\t# Sets the Player reward for the particular timestep to the reward\r\n\t\t# obtained.\r\n\t\tself.player_reward[timestep] = reward\r\n\r\n\t\t# Sets the Player optimum for the particular timestep to the is_optimal\r\n\t\t# obtained.\r\n\t\tself.player_optimum[timestep] = is_optimal","def update(self, state, action, nextState, reward):\n oldComponent = (1-self.alpha) * self.getQValue(state, action)\n nextValue = self.computeValueFromQValues(nextState)\n sample = reward + self.discount * nextValue\n newComponent = self.alpha * sample\n self.qValues[(state, action)] = oldComponent + newComponent","def _run(self): # pylint: disable=too-many-locals.too-many-branches,too-many-statements\n num_of_stored_commands_before = len(self._stored_commands)\n if not self.current_mapping:\n self.current_mapping = {}\n else:\n self._send_possible_commands()\n if len(self._stored_commands) == 0:\n return\n new_row_major_mapping = self._return_new_mapping()\n # Find permutation of matchings with lowest cost\n swaps = None\n lowest_cost = None\n matchings_numbers = list(range(self.num_rows))\n if self.num_optimization_steps <= math.factorial(self.num_rows):\n permutations = itertools.permutations(matchings_numbers, self.num_rows)\n else:\n permutations = []\n for _ in range(self.num_optimization_steps):\n permutations.append(self._rng.sample(matchings_numbers, self.num_rows))\n for permutation in permutations:\n trial_swaps = self.return_swaps(\n old_mapping=self._current_row_major_mapping,\n new_mapping=new_row_major_mapping,\n permutation=permutation,\n )\n if swaps is None:\n swaps = trial_swaps\n lowest_cost = self.optimization_function(trial_swaps)\n elif lowest_cost > self.optimization_function(trial_swaps):\n swaps = trial_swaps\n lowest_cost = self.optimization_function(trial_swaps)\n if swaps: # first mapping requires no swaps\n # Allocate all mapped qubit ids (which are not already allocated,\n # i.e., contained in self._currently_allocated_ids)\n mapped_ids_used = set()\n for logical_id in self._currently_allocated_ids:\n mapped_ids_used.add(self._current_row_major_mapping[logical_id])\n not_allocated_ids = set(range(self.num_qubits)).difference(mapped_ids_used)\n for mapped_id in not_allocated_ids:\n qb = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[mapped_id])\n cmd = Command(engine=self, gate=AllocateQubitGate(), qubits=([qb],))\n self.send([cmd])\n # Send swap operations to arrive at new_mapping:\n for qubit_id0, qubit_id1 in swaps:\n qb0 = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[qubit_id0])\n qb1 = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[qubit_id1])\n cmd = Command(engine=self, gate=Swap, qubits=([qb0], [qb1]))\n self.send([cmd])\n # Register statistics:\n self.num_mappings += 1\n depth = return_swap_depth(swaps)\n if depth not in self.depth_of_swaps:\n self.depth_of_swaps[depth] = 1\n else:\n self.depth_of_swaps[depth] += 1\n if len(swaps) not in self.num_of_swaps_per_mapping:\n self.num_of_swaps_per_mapping[len(swaps)] = 1\n else:\n self.num_of_swaps_per_mapping[len(swaps)] += 1\n # Deallocate all previously mapped ids which we only needed for the\n # swaps:\n mapped_ids_used = set()\n for logical_id in self._currently_allocated_ids:\n mapped_ids_used.add(new_row_major_mapping[logical_id])\n not_needed_anymore = set(range(self.num_qubits)).difference(mapped_ids_used)\n for mapped_id in not_needed_anymore:\n qb = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[mapped_id])\n cmd = Command(engine=self, gate=DeallocateQubitGate(), qubits=([qb],))\n self.send([cmd])\n # Change to new map:\n self._current_row_major_mapping = new_row_major_mapping\n new_mapping = {}\n for logical_id, mapped_id in new_row_major_mapping.items():\n new_mapping[logical_id] = self._mapped_ids_to_backend_ids[mapped_id]\n self.current_mapping = new_mapping\n # Send possible gates:\n self._send_possible_commands()\n # Check that mapper actually made progress\n if len(self._stored_commands) == num_of_stored_commands_before:\n raise RuntimeError(\n \"Mapper is potentially in an infinite loop. It is likely that the algorithm requires too\"\n \"many qubits. Increase the number of qubits for this mapper.\"\n )","def update_optimization_results(output, model, result, runtime):\n\n data_path = output['Input_Data']\n\n result['Optimized_Model'] = [model]\n result['Optimized_Likelihood'] = [float(\n result['Optimized_Likelihood'])]\n\n if isinstance(data_path, list):\n result['Dataset'] = []\n for data in data_path:\n result['Dataset'].append(os.path.basename(data))\n else:\n result['Dataset'] = [os.path.basename(data_path)]\n\n result['Runtime'] = runtime\n\n if output['Kernel_Transform'] is not False:\n result['Kernel_Transform'] = str(output['Kernel_Transform'][0]) + \\\n '_' + str(output['Kernel_Transform'][1])\n else:\n result['Kernel_Transform'] = output['Kernel_Transform']\n\n for key, value in result.iteritems():\n output[key] = value\n\n return output","def update(self, result, action_taken):\n self.visits += 1\n self.wins += result\n\n if self.parent is None:\n return\n\n for key in self.parent.children:\n p = self.parent.children[key].player\n for a in action_taken[p]:\n if a == key:\n self.parent.children[key].visits_amaf += 1\n self.parent.children[key].wins_amaf += result","def mem_update(ops, x, mem, spike):\n #print(ops(x).size())\n #print(spike.size())\n mem = mem * decay * (1. - spike) + ops(x)\n spike = act_fun(mem) # act_fun : approximation firing function\n return mem, spike","def update(self, state, action, nextState, reward):\n candidateQ = reward + self.discount * \\\n self.computeValueFromQValues(nextState)\n candidateQ_vec = np.array([[candidateQ]])\n features = self.featExtractor.getFeatures(state, action)\n features_as_list = [features[feat] for feat in self.allFeats]\n features_vec = np.array([features_as_list])\n self.train_step.run(feed_dict={self.x: features_vec,\n self.y_: candidateQ_vec}, session=self.sess)","def updateNode(self, result):\n self.visits += 1\n self.wins += result","def update(self, attribute: str, result: ProcessorResult) -> None:\n pass","def tweak_q(self, q):\n self._q = q\n self.reset()","def update_score():\n pass","def update1(self, state, action, nextState, reward):\n #print \"update1 in ApproximateQAgent\"\n \"*** YOUR CODE HERE ***\"\n ##################################################################################################################################Eric Did Stuff\n actionList = nextState.getLegalActions(self.index)\n\n\n #print \"Action List\", actionList\n\n\n\n\n weights = self.getWeights()\n\n features = self.featExtractor.getFeatures(state, action, self)\n #self.myFeats = features\n if self.index == 0:\n print \"FEATURES: \",features\n value = self.computeValueFromQValues(nextState)\n qValue = self.getQValue(state,action)\n #print \"value\", value, \"qValue\", qValue\n for feature in features:\n if len(actionList) != 0:\n weights[feature] = weights[feature] + self.alpha * (reward + self.discount * value - qValue) * features[feature]\n else:\n weights[feature] = weights[feature] + self.alpha * (reward - qValue) * features[feature]\n #print \"feature\", feature, \"weights\", weights[feature]\n #print \"weights\", weights\n\n #util.raiseNotDefined()","def update_dev_scores(self, results):\n for metric in results:\n print(\"Validation {} -> {} | lr: {}\".format(self.vctr, metric, self.optimizer.param_groups[0]['lr']), flush=True)\n self.val_scores[metric.name].append(metric)\n self.cur_bests[metric.name] = self.best_score(self.val_scores[metric.name])\n\n self.tensorboard_writter.add_scalar(\n f\"/dev/{metric.name}\", metric.score, self.vctr\n )\n\n # Decrease learning rate according to the scheduler policy\n if self.opti_scheduler and metric.name == self.early_metric:\n mode = \"max\" if metric.higher_better else \"min\"\n self.opti_scheduler._init_is_better(mode,\n self.opti_scheduler.threshold,\n self.opti_scheduler.threshold_mode)\n\n self.opti_scheduler.step(metric.score)","def update_Q(self, state, action, reward, new_state = None):\n Q_val = self.Q[state][action]\n \n # Look at the best action from the next state.\n Qp_val = 0\n if new_state is not None:\n Qp_val = max(self.Q[new_state].values())\n \n # The famous formula:\n Q_val = Q_val + self.alpha * (reward + self.gamma * Qp_val - Q_val)\n #print self.alpha\n #print state, 'action: ', action\n #print 'Q[%s]: %s' % (state, self.Q[state])\n #print 'Q val: ', Q_val\n \n self.Q[state][action] = Q_val\n \n return None","def update_usage(user_size):\n\n cnx = create_connection()\n cursor = cnx.cursor()\n\n update_query = (\n \"UPDATE \" + USAGE_TABLE['name'] + \" \"\n \" SET \" + USAGE_TABLE['size_column'] + \"=\" + str(user_size[1]) + \" \"\n \" WHERE \" + USAGE_TABLE['relational_column'] + \"='\" + user_size[0] + \"'\"\n )\n\n try:\n cursor.execute(update_query)\n except mysql.connector.Error as e:\n cursor.close()\n cnx.close()\n print(e)\n return\n\n cursor.close()\n cnx.close()","def update(self):\n result = [], 0, False\n\n if self.t % self.t_train_freq == 0:\n result = self.q_learning_minibatch()\n\n if self.t % self.t_target_q_update_freq == self.t_target_q_update_freq - 1:\n # Copy \n self.update_target_q_network()\n\n return result","def update_memory(self, vm):\n try:\n memory_spec = self.client.get_memory(vm.backend_id)\n if memory_spec['size_MiB'] != vm.ram:\n self.client.update_memory(vm.backend_id, {'size_MiB': vm.ram})\n except VMwareError as e:\n raise VMwareBackendError(e)","def run_query(**kwargs):\n logging.info(\n \"Running query: \"\n + kwargs[\"query\"][\"name\"]\n + \" iterations: \"\n + str(kwargs[\"iterations\"])\n )\n query_id = kwargs[\"query\"][\"name\"].rsplit(\".\")[\n 0\n ] # Query ID = filename without extention\n query_results = {\n \"query_name\": kwargs[\"query\"][\"name\"],\n \"query_mapdql\": kwargs[\"query\"][\"mapdql\"],\n \"query_id\": query_id,\n \"query_succeeded\": True,\n \"query_error_info\": \"\",\n \"initial_iteration_results\": {},\n \"noninitial_iteration_results\": [],\n \"query_total_elapsed_time\": 0,\n }\n query_total_start_time = timeit.default_timer()\n # Run iterations of query\n for iteration in range(kwargs[\"iterations\"]):\n # Gather memory before running query iteration\n logging.debug(\"Getting pre-query memory usage on CPU\")\n pre_query_cpu_mem_usage = get_mem_usage(\n con=kwargs[\"con\"], mem_type=\"cpu\"\n )\n logging.debug(\"Getting pre-query memory usage on GPU\")\n pre_query_gpu_mem_usage = get_mem_usage(\n con=kwargs[\"con\"], mem_type=\"gpu\"\n )\n # Run query iteration\n logging.debug(\n \"Running iteration \"\n + str(iteration)\n + \" of query \"\n + kwargs[\"query\"][\"name\"]\n )\n query_result = execute_query(\n query_name=kwargs[\"query\"][\"name\"],\n query_mapdql=kwargs[\"query\"][\"mapdql\"],\n iteration=iteration,\n con=kwargs[\"con\"],\n arrow_cpu_output=kwargs[\"arrow_cpu_output\"],\n \n )\n # Gather memory after running query iteration\n logging.debug(\"Getting post-query memory usage on CPU\")\n post_query_cpu_mem_usage = get_mem_usage(\n con=kwargs[\"con\"], mem_type=\"cpu\"\n )\n logging.debug(\"Getting post-query memory usage on GPU\")\n post_query_gpu_mem_usage = get_mem_usage(\n con=kwargs[\"con\"], mem_type=\"gpu\"\n )\n # Calculate total (post minus pre) memory usage after query iteration\n query_cpu_mem_usage = round(\n post_query_cpu_mem_usage[\"usedram\"]\n - pre_query_cpu_mem_usage[\"usedram\"],\n 1,\n )\n query_gpu_mem_usage = round(\n post_query_gpu_mem_usage[\"usedram\"]\n - pre_query_gpu_mem_usage[\"usedram\"],\n 1,\n )\n if query_result:\n query_results.update(\n query_error_info=\"\" # TODO - interpret query error info\n )\n # Assign first query iteration times\n if iteration == 0:\n first_execution_time = round(query_result[\"execution_time\"], 1)\n first_connect_time = round(query_result[\"connect_time\"], 1)\n first_total_time = (\n first_execution_time\n + first_connect_time\n )\n query_results.update(\n initial_iteration_results={\n \"first_execution_time\": first_execution_time,\n \"first_connect_time\": first_connect_time,\n \"first_total_time\": first_total_time,\n \"first_cpu_mem_usage\": query_cpu_mem_usage,\n \"first_gpu_mem_usage\": query_gpu_mem_usage,\n }\n )\n else:\n # Put noninitial iterations into query_result list\n query_results[\"noninitial_iteration_results\"].append(\n query_result\n )\n # Verify no change in memory for noninitial iterations\n if query_cpu_mem_usage != 0.0:\n logging.error(\n (\n \"Noninitial iteration ({0}) of query ({1}) \"\n + \"shows non-zero CPU memory usage: {2}\"\n ).format(\n iteration,\n kwargs[\"query\"][\"name\"],\n query_cpu_mem_usage,\n )\n )\n if query_gpu_mem_usage != 0.0:\n logging.error(\n (\n \"Noninitial iteration ({0}) of query ({1}) \"\n + \"shows non-zero GPU memory usage: {2}\"\n ).format(\n iteration,\n kwargs[\"query\"][\"name\"],\n query_gpu_mem_usage,\n )\n )\n else:\n logging.warning(\n \"Error detected during execution of query: \"\n + kwargs[\"query\"][\"name\"]\n + \". This query will be skipped and \"\n + \"times will not reported\"\n )\n query_results.update(query_succeeded=False)\n break\n # Calculate time for all iterations to run\n query_total_elapsed_time = round(\n ((timeit.default_timer() - query_total_start_time) * 1000), 1\n )\n query_results.update(query_total_elapsed_time=query_total_elapsed_time)\n logging.info(\n \"Completed all iterations of query \" + kwargs[\"query\"][\"name\"]\n )\n return query_results","def update_resources_for_this_host(cache, db):\n free_cpu, free_mem = get_resources()\n my_ip = cache[\"ip\"]\n\n logger.info(\"UPDATING\", extra = {\"cpu\": free_cpu, \"mem\": free_mem, \"ip\": my_ip})\n try:\n db.hset(my_ip, mapping={\"cpu\": free_cpu, \"mem\": free_mem})\n except Exception as e:\n logger.error(e)\n raise e","def _problem_update_history(self, _):\n self._update_reward_values()\n self.history.curr_reward.append(self.curr_reward)\n self.history.curr_best_reward.append(self.curr_best_reward)","def update(self, arm, reward):\n\n # Increate pulls by one\n self.pulls[arm] += 1\n\n # New number of pull\n n = self.pulls[arm]\n\n # Old value\n old_val = self.values[arm]\n\n # New value (online weighted average)\n new_val = ((n - 1) / n) * old_val + (1 / n) * reward\n\n # Update value\n self.values[arm] = new_val\n\n # Update epsilon\n self.t += 1\n self.epsilon = self.calc_dynamic_epsilon()","def update(self):\n\n self._pre_calc_mb()","def add(self, result, next_item):\n self.test += self.length\n self.hit += len(set(next_item) & set(result[:self.length].index))","def update_q_table(self, cur_state, action, reward, next_state):\n new_max_q = max(self.q_val_table[next_state])\n new_value = reward + self.gamma * new_max_q\n\n old_value = self.q_val_table[cur_state][action]\n self.q_val_table[cur_state][action] = old_value + self.alpha * (new_value - old_value)\n\n # Decay epsilon_greedy\n self.e_greedy_prob = self.exp_decay(self.e_greedy_prob)","def update(self, action, reward):\n # like puseudo count\n a, b = self.ActionValue[action]\n #print(f\"UPDATE {action}: ({a}, {b})\")\n a = a + self.huber(reward) # The larger the reward, the easier it is to select\n b = b + 1 - self.huber(reward) # It becomes easy to be selected as the reward becomes larger, and it becomes difficult to be selected as the reward becomes smaller\n a = 0.001 if a <= 0 else a\n b = 0.001 if b <= 0 else b\n \n self.ActionValue[action] = (a, b)\n\n #print(f\"=> ({a}, {b})\")\n\n # Update nearby action candidates\n around_update_rate = 0.3 # Parameter to adjust the degree of change according to the distance; [0, 1]\n radius = np.sqrt(self.action_resolution**2 + self.action_resolution**2 + 1e-9) # 1e-9 is for safety to caluculate the small number \n for action_around in self.actions:\n if action_around == action:\n continue\n x = action_around[0] - action[0]\n y = action_around[1] - action[1]\n distance = np.sqrt(x**2 + y**2)\n if distance <= radius:\n a, b = self.ActionValue[action_around]\n #print(f\"UPDATE {action_around}: ({a}, {b})\")\n a = a + self.huber(reward) * around_update_rate * (1 - distance)\n b = b + (1 - self.huber(reward)) * around_update_rate * (1 - distance) # To adjust the update, weight 1-r. If normal update is 1, it will be the update of around_update_rate * (1-distance) for adjacent actions.\n a = 0.001 if a <= 0 else a\n b = 0.001 if b <= 0 else b\n\n #print(f\"=> ({a}, {b})\")\n\n self.ActionValue[action_around] = (a, b)"],"string":"[\n \"def _update(self, nbrs, nbrs_y, query, query_y):\\n\\n # Set up the graph for our shared memory variables\\n new_K, new_A, new_V = self.K, self.A, self.V\\n\\n # Condition (1): First returned neighbour shares the same query label\\n correct_query = T.eq(nbrs_y[:, 0], query_y).nonzero()[0]\\n correct_mem = nbrs[correct_query, 0] # Idx to memory keys\\n\\n normed_keys = tensor_norm(query[correct_query] + new_K[correct_mem])\\n new_K = T.set_subtensor(new_K[correct_mem], normed_keys)\\n new_A = T.set_subtensor(new_A[correct_mem], 0.)\\n\\n # Condition (2): First returned neighbour does not share query label.\\n # Add the key and label from query to memory\\n incorrect_mask = T.neq(nbrs_y[:, 0], query_y)\\n incorrect_query = incorrect_mask.nonzero()[0]\\n\\n # We need to find len(incorrect_query) locations in memory to write to.\\n # Noise is added to randomize selection.\\n age_mask = T.ge(new_A, T.max(new_A) - self.C) #1d\\n oldest_idx = tensor_choose_k(age_mask, self.rng,\\n k=T.sum(incorrect_mask),\\n random=True).flatten()\\n\\n new_K = T.set_subtensor(new_K[oldest_idx], query[incorrect_query])\\n new_V = T.set_subtensor(new_V[oldest_idx], query_y[incorrect_query])\\n new_A = T.set_subtensor(new_A[oldest_idx], 0.)\\n\\n # Increment the age of all non-updated indices by 1\\n new_A = new_A + 1.\\n new_A = T.inc_subtensor(new_A[correct_mem], -1.)\\n new_A = T.inc_subtensor(new_A[oldest_idx], -1.)\\n\\n return OrderedDict({(self.K, new_K), (self.V, new_V), (self.A, new_A)})\",\n \"def update_memory(self, result):\\r\\n if (len(self.memory) >= self.memory_capacity):\\r\\n self.memory.pop(0)\\r\\n self.memory.append(result)\\r\\n else:\\r\\n self.memory.append(result)\",\n \"def update_search_space(self, search_space):\\n raise NotImplementedError('Tuner: update_search_space not implemented')\",\n \"def update_results(self, results):\\n pass\",\n \"def update_vm_result(self, context, msg):\\n args = jsonutils.loads(msg)\\n agent = context.get('agent')\\n port_id = args.get('port_uuid')\\n result = args.get('result')\\n LOG.debug('update_vm_result received from %(agent)s: '\\n '%(port_id)s %(result)s', {'agent': agent,\\n 'port_id': port_id,\\n 'result': result})\\n\\n # Add the request into queue for processing.\\n event_type = 'agent.vm_result.update'\\n payload = {'port_id': port_id, 'result': result}\\n timestamp = time.ctime()\\n data = (event_type, payload)\\n # TODO(nlahouti) use value defined in constants\\n pri = self.obj.PRI_LOW_START + 10\\n self.obj.pqueue.put((pri, timestamp, data))\\n LOG.debug('Added request vm result update into queue.')\\n\\n return 0\",\n \"def update_score(self, concept: _Concept, result: _Result) -> None:\\n\\n score = self.make_score(concept, result)\\n if score is None:\\n pass\\n else:\\n self._vector.append(score)\",\n \"def UpdateNode(self, result, actions):\\n self.visits += 1\\n self.wins += (result > 0)\\n self.losses += (result < 0)\\n self.draws += (result == 0)\\n self.Q = self.Q + (result - self.Q)/self.visits\\n \\n # update rave values\\n for a in actions:\\n self.N_AMAF[a] += 1\\n if not a in self.Q_AMAF:\\n self.Q_AMAF[a] = 0.5\\n self.Q_AMAF[a] = self.Q_AMAF[a] + (result - self.Q_AMAF[a])/self.N_AMAF[a]\\n else:\\n self.Q_AMAF[a] = self.Q_AMAF[a] + (result - self.Q_AMAF[a])/self.N_AMAF[a]\",\n \"def update_qvals(self, state, action, reward):\\n self.qvals[(state, action)] = 0\",\n \"def updateQTable( self, reward, current_state ):\",\n \"def _update_memory(key, cur, target, common_mem):\\n mod_swap = {\\\"G\\\": \\\"M\\\", \\\"g\\\": \\\"m\\\"}\\n cur_mem, orig_mod = _get_cur_mem(key, cur)\\n if cur_mem >= common_mem * 1.5:\\n return cur\\n else:\\n new_val = \\\"%s%s\\\" % (target, mod_swap.get(orig_mod, orig_mod))\\n if key == \\\"jvm_opts\\\":\\n out = cur\\n out[-1] = \\\"-Xmx%s\\\" % new_val\\n else:\\n out = new_val\\n return out\",\n \"def update_Qfunction(self, result):\\n if result == \\\"won\\\":\\n final_value = WIN_VALUE\\n elif result == \\\"draw\\\":\\n final_value = DRAW_VALUE\\n elif result == \\\"lost\\\":\\n final_value = LOSS_VALUE\\n \\n self.move_history.reverse()\\n next_max = -1.0\\n \\n for h in self.move_history:\\n qvals = self.get_q(h[0])\\n m = h[1]\\n \\n if next_max < 0:\\n qvals[m] = final_value\\n else:\\n qvals[m] = qvals[m] * (1.0 - self.learning_rate) + self.learning_rate * self.value_discount * next_max\\n \\n self.q[h[0]] = qvals \\n next_max = max(qvals)\",\n \"def update_q_value(q_table: np.ndarray, state: int, action: int,\\n learning_rate: float, current_reward: float,\\n new_state: int, discount_rate: float) -> None:\\n q_table[state, action] = new_q_value(q_table, state, action, learning_rate,\\n current_reward, new_state,\\n discount_rate)\",\n \"def set_result(self, params, result, id=0):\\n for i in range(len(self.result), id + 1):\\n self.result.append(None)\\n print \\\"List index %d does not exist, should not happen\\\" % i\\n self.result[id] = result\\n if self.best_score is None or result < self.best_score:\\n self.best_score = result\\n self.best_params = params\\n return params, result\",\n \"def update(self, result):\\n\\n runs_scored = 0\\n outs_recorded = 0\\n\\n if result == 'single':\\n # Runners from 2b or 3b score first\\n if self.occupied_2b and self.occupied_3b:\\n self.occupied_2b = False\\n self.occupied_3b = False\\n runs_scored += 2\\n elif self.occupied_2b or self.occupied_3b:\\n self.occupied_2b = False\\n self.occupied_3b = False\\n runs_scored += 1\\n # Runners from first advance\\n if self.occupied_1b:\\n self.occupied_2b = True\\n # First base now occupied\\n self.occupied_1b = True\\n\\n if result == 'double':\\n # Runners from 2b or 3b score\\n if self.occupied_2b and self.occupied_3b:\\n self.occupied_2b = False\\n self.occupied_3b = False\\n runs_scored += 2\\n elif self.occupied_2b or self.occupied_3b:\\n self.occupied_2b = False\\n self.occupied_3b = False\\n runs_scored += 1\\n # Runner on 1st (see notes)\\n if self.occupied_1b:\\n rand = random.uniform(0,1)\\n if rand < 0.4:\\n runs_scored +=1\\n else:\\n self.occupied_3b = True\\n self.occupied_1b = False\\n \\n if result == 'triple':\\n # Everyone on base scores\\n number_bases_occupied = self.occupied_1b + self.occupied_2b + self.occupied_3b\\n runs_scored += number_bases_occupied\\n # New runner on 3b\\n self.occupied_3b = True\\n\\n if result == 'home run':\\n number_bases_occupied = self.occupied_1b + self.occupied_2b + self.occupied_3b\\n runs_scored += number_bases_occupied + 1\\n\\n if result == 'foul out' or result == 'fly out' or result == 'out at 1st' or result == 'strike out':\\n outs_recorded += 1\\n\\n if result == 'double play':\\n # This is weird, since dps aren't always possible. See notes.\\n \\n if self.occupied_1b + self.occupied_2b + self.occupied_3b == 0:\\n # If nobody on base, just a normal out\\n outs_recorded +=1\\n \\n ## 1 existing Baserunner scenario\\n elif self.occupied_1b and not self.occupied_2b and not self.occupied_3b:\\n # If on first, outs at 1b and 2b\\n self.occupied_1b = False\\n outs_recorded += 2\\n elif (not self.occupied_1b and self.occupied_2b and not self.occupied_3b):\\n # If baserunner on second, no force outs, just add an out\\n outs_recorded += 1\\n elif (not self.occupied_1b and not self.occupied_2b and self.occupied_3b):\\n # If baserunner on third, same\\n outs_recorded += 1\\n\\n ## 2 existing Baserunner scenario\\n elif self.occupied_1b and self.occupied_2b and not self.occupied_3b:\\n # If on 1st and 2nd, outs at 3rd and 2nd\\n self.occupied_1b = True\\n self.occupied_2b = False\\n outs_recorded += 2\\n elif self.occupied_1b and not self.occupied_2b and self.occupied_3b:\\n # If on 1st and 3nd, outs at 2rd and 1st\\n self.occupied_1b = False\\n outs_recorded += 2\\n elif not self.occupied_1b and self.occupied_2b and self.occupied_3b: \\n # If 2b and 3b occupied, only force out at 1b, so base/out doesn't change\\n outs_recorded += 1\\n\\n ## 3 existing Baserunner scneario\\n elif self.occupied_1b and self.occupied_2b and self.occupied_3b: \\n # If bases loaded, outs at home and 3b. 2b and 1b stay occupied\\n self.occupied_3b = False\\n outs_recorded += 2\\n\\n\\n if result == 'base on error':\\n # Everyone advances\\n if self.occupied_3b:\\n runs_scored += 1\\n self.occupied_3b = False\\n if self.occupied_2b:\\n self.occupied_3b = True\\n self.occupied_2b = False\\n if self.occupied_1b:\\n self.occupied_2b = True\\n self.occupied_1b = False\\n self.occupied_1b = True\\n\\n\\n if result == 'base on balls':\\n if self.occupied_3b and self.occupied_2b and self.occupied_1b:\\n runs_scored += 1\\n if self.occupied_2b and self.occupied_1b:\\n self.occupied_3b = True\\n if self.occupied_1b:\\n self.occupied_2b = True\\n self.occupied_1b = True \\n\\n return runs_scored, outs_recorded\",\n \"def update(self, rank):\\n # calculate MR and MRR\\n self.mr += rank\\n self.mrr += 1 / rank\\n # calculate Hits@k\\n if rank <= 1:\\n self.hits1 += 1\\n self.hits3 += 1\\n self.hits5 += 1\\n self.hits10 += 1\\n elif rank <= 3:\\n self.hits3 += 1\\n self.hits5 += 1\\n self.hits10 += 1\\n elif rank <= 5:\\n self.hits5 += 1\\n self.hits10 += 1\\n elif rank <= 10:\\n self.hits10 += 1\",\n \"def update_used_query_range(\\n self,\\n write_cursor: 'DBCursor',\\n location_string: str,\\n queried_ranges: list[tuple[Timestamp, Timestamp]],\\n ) -> None:\\n if len(queried_ranges) == 0:\\n return\\n\\n starts = [x[0] for x in queried_ranges]\\n ends = [x[1] for x in queried_ranges]\\n saved_range = self.db.get_used_query_range(write_cursor, location_string)\\n if saved_range is not None:\\n starts.append(saved_range[0])\\n ends.append(saved_range[1])\\n\\n self.db.update_used_query_range(\\n write_cursor=write_cursor,\\n name=location_string,\\n start_ts=min(starts),\\n end_ts=max(ends),\\n )\",\n \"def update(self, result):\\n #print(\\\"updating node result = \\\" + str(result))\\n self.visits += 1\\n self.wins += result\",\n \"def _adjust_memory(self, neighbour, neighbour_choice):\\n if neighbour in self._memory:\\n self.get_memory_of(neighbour).add_choice_to_memory(\\n neighbour_choice, self.get_gene().get_mem_size())\\n else:\\n print (\\\"err: getMemory: no memory of subjectID \\\"\\n + str(neighbour.get_id()))\",\n \"def update_cache(self, query, results, expire):\\n self.logger.info(\\\"DASMemcache::result(%s) store to cache\\\" % query)\\n if not results:\\n return\\n key = genkey(query)\\n rowdict = {}\\n rowid = 0\\n for row in results:\\n if type(row) is dict:\\n row['id'] = rowid\\n rowdict[rowid] = row\\n rowid += 1\\n if len(rowdict.keys()) == self.chunk_size:\\n self.memcache.set_multi(rowdict, time=expire, key_prefix=key)\\n rowdict = {}\\n yield row\\n self.memcache.set_multi(rowdict, time=expire, key_prefix=key)\\n self.memcache.set(key, rowid, expire)\",\n \"def update_q(self,action,reward):\\n #print('')\\n #print('Action index is: ' + str(action))\\n #print('Provided reward is: ' + str(reward))\\n \\n # Read from disk before updating\\n try:\\n pickle_in = open(\\\"static/data/values.pickle\\\",\\\"rb\\\")\\n values = pickle.load(pickle_in)\\n #print(values)\\n self.values = values\\n pickle_in = open(\\\"static/data/counts.pickle\\\",\\\"rb\\\")\\n self.counts = pickle.load(pickle_in)\\n pickle_in = open(\\\"static/data/actions_taken.pickle\\\",\\\"rb\\\")\\n actions_taken = pickle.load(pickle_in)\\n pickle_in = open(\\\"static/data/reward_list.pickle\\\",\\\"rb\\\")\\n reward_list = pickle.load(pickle_in)\\n except:\\n actions_taken = []\\n reward_list = []\\n pass\\n \\n self.counts[action] += 1\\n n = self.counts[action]\\n value = self.values[action]\\n actions_taken.append(action)\\n reward_list.append(reward)\\n \\n # Running product\\n new_value = value + (1/n) * (reward - value)\\n self.values[action] = new_value\\n \\n \\n # Save to disk before exiting\\n pickle_out = open('static/data/values.pickle','wb')\\n pickle.dump(self.values, pickle_out)\\n pickle_out.close()\\n pickle_out = open('static/data/counts.pickle','wb')\\n pickle.dump(self.counts, pickle_out)\\n pickle_out.close()\\n pickle_out = open('static/data/actions_taken.pickle','wb')\\n pickle.dump(actions_taken, pickle_out)\\n pickle_out.close()\\n pickle_out = open('static/data/reward_list.pickle','wb')\\n pickle.dump(reward_list, pickle_out)\\n pickle_out.close()\",\n \"def _fill_query_slots(self, queries: List[Query]) -> None:\\n while queries and self.query_slots > 0:\\n logger.debug(\\n f\\\"{self.query_slots} available query slots, creating query task\\\"\\n )\\n query = queries.pop(0)\\n query_task_id = self.client.create_query_task(query.query_id)\\n self.query_slots -= 1\\n query.query_task_id = query_task_id\\n self._query_by_task_id[query_task_id] = query\\n self._running_queries.append(query)\",\n \"def update_memory(self, target, clues, guesses, winlose):\\n immediate_rewards = self.get_trajectory_immediate_rewards(target, \\n clues,\\n guesses)\\n \\n self.memory.append((target, \\n clues, \\n guesses, \\n winlose, \\n immediate_rewards))\",\n \"def update(self, FlowStatistics=None, MatchIpAddressInArpPackets=None, PortStatistics=None, QueueStatistics=None, ReassambleIpFragments=None, Reserved=None, SpanningTree=None, TableStatistics=None):\\n self._update(locals())\",\n \"def update(self, state, action, nextState, reward):\\n \\\"\\\"\\\"Description:\\n Use Q-Learning algoritm in slide 58 of MDP\\n \\\"\\\"\\\"\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n maxQns = self.getValue(nextState) # get max q-value of next state\\n if maxQns == None:\\n maxQns = 0\\n Qsa = self.getQValue(state, action) #self.qValues[(state, action)]\\n difference = reward + self.discountRate * maxQns - Qsa\\n self.qValues[(state, action)] += self.alpha * difference\\n \\n self.vitCount[(state, action)] += 1\\n \\\"\\\"\\\" END CODE \\\"\\\"\\\"\",\n \"def update(self, arm, reward):\\n raise NotImplementedError\",\n \"def _update_q_value(self, start_state, to_state, reward, iteration):\\n if start_state.as_tuple() not in self.qstore.q:\\n self.enum.enumerate_state(start_state, self.qstore.q)\\n if to_state.as_tuple() not in self.qstore.q:\\n self.enum.enumerate_state(to_state, self.qstore.q)\\n\\n actions = self.qstore.q[start_state.as_tuple()]['actions']\\n values = self.qstore.q[start_state.as_tuple()]['utilities']\\n\\n max_over_next_states = max(self.qstore.q[to_state.as_tuple()]['utilities']) if to_state.terminate != 1 else 0\\n\\n action_between_states = to_state.as_tuple()\\n\\n action_index = actions.index(action_between_states)\\n learning_rate_alpha = 1 / (iteration ** self.state_space_parameters.learning_rate_omega)\\n\\n # Q_Learning update rule\\n values[action_index] = ( # Q_t+1(s_i,𝑢) =\\n values[action_index] + # Q_t(s_i,𝑢)\\n learning_rate_alpha * ( # α\\n reward # r_t\\n + self.state_space_parameters.discount_factor # γ\\n * max_over_next_states # max_{𝑢'∈ 𝒰(s_j)} Q_t(s_j,𝑢')\\n - values[action_index] # -Q_t(s_i,𝑢)\\n )\\n )\\n\\n self.qstore.q[start_state.as_tuple()] = {'actions': actions, 'utilities': values}\",\n \"def update(self, reward):\\n raise NotImplementedError\",\n \"def update_results_score(self, edge, regions):\\r\\n if self.results_file is None:\\r\\n return # No update\\r\\n \\r\\n pln = self.get_player_num()\\r\\n self.results_file.results_update(player_num=pln, nsquare=len(regions))\",\n \"def vm_result_update(self, payload):\\n\\n port_id = payload.get('port_id')\\n result = payload.get('result')\\n\\n if port_id and result:\\n # Update the VM's result field.\\n params = dict(columns=dict(result=result))\\n self.update_vm_db(port_id, **params)\",\n \"def update_q_table(self, state, action, reward):\\n\\n q_key = self.q_key(state, action)\\n inputs = self.env.sense(self)\\n self.next_waypoint = self.planner.next_waypoint()\\n new_state = self.set_current_state(inputs)\\n\\n #update q_value in q_table according to learning formula\\n x = self.q_value(state, action)\\n V = reward + (self.gamma * self.max_q_value(new_state))\\n new_q_value = x + (self.alpha * (V - x))\\n self.q_table[q_key] = new_q_value\",\n \"def update_Qtable(self, r, action, next_state):\\n if self.learning:\\n # 8. When learning, update the q table according\\n # to the given rules\\n\\n # The reward the turkey get after doing the action\\n reward_t1 = r\\n\\n # Code Review1: Replace the following code\\n '''\\n # Get the key & value which enables the max Q value in State(t+1)\\n max_Q_St1_info = max(self.Qtable[next_state].items(), key=operator.itemgetter(1))\\n\\n # The action which enables the max Q value in State(t+1)\\n max_Q_St1_action = max_Q_St1_info[0]\\n\\n # The max Q value in State(t+1)\\n max_Q_St1 = max_Q_St1_info[1]\\n '''\\n max_Q_St1 = max(self.Qtable[next_state].values())\\n\\n Q_old = self.Qtable[self.state][action]\\n Q_new = reward_t1 + self.gamma * max_Q_St1\\n\\n self.Qtable[self.state][action] = (\\n 1 - self.alpha) * Q_old + self.alpha * Q_new\",\n \"def updateQValue(self, state, action, old_q, reward, future_rewards):\\n self.q[(tuple(state), action)] = old_q + self.alpha * (reward + future_rewards - old_q)\",\n \"def update(self, arm, reward, context):\",\n \"def update(self, result: int):\\n self.wins += result\\n self.visits += 1\",\n \"def process_query(self, query):\\n query._cache_region = self\",\n \"def restore_program(memory_updates: Dict[int, int], memory: List[int]) -> List[int]:\\n for (index, new_value) in memory_updates.items():\\n memory[index] = new_value\\n return memory\",\n \"def add_result(self, result):\\n if len(self.results) == self.max_size:\\n del self.results[0]\\n self.results.append(result)\",\n \"def update_Q(self, reward):\\n old_estimate = self.q_estimates[self.prev_action]\\n self.q_estimates[self.prev_action] = old_estimate + 1/self.N[self.prev_action] * (reward - old_estimate)\",\n \"def update(self, state, action, nextState, reward):\\n \\\"*** YOUR CODE HERE ***\\\"\\n self.qValues[(state, action)] = ((1 - self.alpha) * self.getQValue(state, action)) + self.alpha \\\\\\n * (reward + self.discount * self.computeValueFromQValues(nextState))\",\n \"def update_quality():\\n global items, converted_items\\n if not converted_items:\\n items = convert_items(items)\\n converted_items = True\\n for item in items:\\n item.update_q()\",\n \"def update(self, state, action, nextState, reward):\\n self.qvals[(state, action)] = self.qvals[(state, action)] + self.alpha * (\\n reward + self.discount * self.computevaluefromqvalues(nextState) - self.qvals[(state, action)])\",\n \"def update(self, state, action, nextState, reward):\\n \\\"*** YOUR CODE HERE ***\\\"\\n best_action = self.computeActionFromQValues(nextState)\\n self.QValueCounter[(state, action)] = ((1 - self.alpha) * self.getQValue(state, action) +\\n self.alpha * (reward + self.discount * self.getQValue(nextState,\\n best_action)))\",\n \"def update_Q(self, state, action, new_state, reward):\\n \\n self.Q[(state, action)] = self.Q[(state, action)] + self.alpha*(reward + self.gamma * self.max_value(new_state) - self.Q[(state, action)])\",\n \"def update_q_values(self, s_current, action, r_next, s_next, action_next):\\n action = actions_indexes[action]\\n action_next = actions_indexes[action_next]\\n self.q_values[s_current, action] += self.alpha * (\\n r_next + self.gamma * self.q_values[s_next, action_next] - self.q_values[s_current, action])\",\n \"def update_query(self):\\n text = self.lineedit.text()\\n self.results = self.lookup(text)\\n self.update_ui()\\n self.copy_entry(self.table.currentRow(), self.table.currentColumn())\",\n \"def update(self, arm, context, reward):\\n raise NotImplementedError\",\n \"def update(self, arm, context, reward):\\n raise NotImplementedError\",\n \"def update_Q(self, state, action, new_state, new_action, reward):\\n \\n self.Q[(state, action)] = float(self.Q[(state, action)] + self.alpha*(reward + self.gamma * self.Q[new_state, new_action] - self.Q[(state, action)]))\",\n \"def update_scores(read_scores, result):\\n\\n\\t# check that there are some results for this read\\n\\tassert len(result) > 0\\n\\t# write this read to output\\n\\tfor sim_match in result.keys():\\n\\n\\t\\t# get type (discordant or chimeric)\\n\\t\\tjunc_type = sim_match.split('_')[2]\\n\\n\\t\\tfor analysis_match in result[sim_match]:\\n\\t\\t\\t\\n\\t\\t\\t# get each score type\\n\\t\\t\\tfor score_type in read_scores:\\n\\t\\t\\t\\tscore = analysis_match[score_type]\\n\\t\\t\\t\\tread_scores[score_type][junc_type][score] += 1\",\n \"def update_scores(self, score):\\n self.result_list.append(score)\\n\\n if self.best_score == 0 and self.worst_score == 0:\\n self.best_score = score\\n self.worst_score = score\\n\\n if score < self.best_score:\\n self.best_score = score\\n\\n if score > self.worst_score:\\n self.worst_score = score\",\n \"def _update_scoreboard(self, result):\\n if result == Moveresult.KEY:\\n self.current_turn.keys_collected += 1\\n elif result == Moveresult.EXIT:\\n self.current_turn.successful_exits += 1\",\n \"def update(self, state, action, nextState, reward):\\n \\\"*** YOUR CODE HERE ***\\\"\\n Q_Value = self.Q #calling constructor\\n\\n learning_rate = self.alpha #gives us the learning rate\\n\\n temporary_QValue = self.getQValue(state,action) #to get the Q value of the state\\n\\n nextState_QValue = self.getValue(nextState) #to get the Q value of the landing state when taken action a and state s\\n\\n discount_factor = self.discount #to get the gamma/ discount factor\\n\\n\\n Q_Value[(state,action)] = ((1-learning_rate) * temporary_QValue) + (learning_rate * (reward + discount_factor * nextState_QValue)) #for formula go to README_Reinforcement.txt at line 8\\n\\n #util.raiseNotDefined()\",\n \"def update_reward(self, observation, action, reward):\\n self.q_table[observation,action] = (1 - self.count(observation,action)) * self.q_table[observation,action] + self.count(observation,action) * reward # Canonical Q-update\\n self.increment_count(observation,action)\",\n \"def Update(self, result):\\n self.visits += 1\\n self.wins += result\",\n \"def Update(self, result):\\n self.visits += 1\\n self.wins += result\",\n \"def update(self, old_state, action, new_state, reward):\\r\\n \\r\\n old = self.get_q_value(old_state, action)\\r\\n best_future = self.best_future_reward(new_state)\\r\\n self.update_q_value(old_state,action, old, reward, best_future)\",\n \"def update_Q(self):\",\n \"def update(self, result):\\n self.visits += 1\\n self.wins += result\",\n \"def update_unsampled_queries(self, remaining_indices):\\n remaining_queries_ids = [\\n self.unsampled_queries.elements[i] for i in remaining_indices\\n ]\\n self.unsampled_queries = ProcessedQueryList(\\n cache=self.resource_loader.query_cache, elements=remaining_queries_ids\\n )\",\n \"def update(self):\\r\\n self.data = [self.make_item_tuple(i) for i in self.query]\\r\\n self._fetched = True\\r\\n query_cache.set(self.iden, self.data)\",\n \"def update(self, x_dict, y_dict, weight):\\n assert len(x_dict) == len(y_dict), \\\"invalid # of qids\\\"\\n \\n qids = self.__get_shuffled_qids(x_dict, y_dict, weight.epoch)\\n w = weight.get_dense_weight()\\n for qid in tqdm(qids):\\n w = approx_ap(x_dict[qid].toarray(), y_dict[qid], w, self.eta, self.alpha, self.beta)\\n weight.set_weight(sp.csr_matrix(w.reshape((1, weight.dims))))\\n weight.epoch += 1\",\n \"def update_score(self):\\n self.score = TurboMQ.calculate_fitness(self.result, self.graph)\",\n \"def update_individuals(individuals, eval_results):\\n for ind, res in zip(individuals, eval_results):\\n ind.fitness.values = res[0]\\n ind.matching_node_pairs = res[1]\\n ind.gtp_precisions = res[2]\",\n \"def update(self, state, action, nextState, reward):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # print \\\"update\\\"\\n oldValue = self.getQValue(state, action)\\n sample = reward + self.discount*self.computeValueFromQValues(nextState)\\n self.qValues[(state, action)] = (1-self.alpha)*oldValue + self.alpha*(sample)\",\n \"def put(self, search_query, page_number, search_results):\\n timestamp = int(time.time())\\n with self.get_conn() as conn:\\n c = conn.cursor()\\n insert = \\\"\\\"\\\"INSERT OR REPLACE INTO movies\\n (search_query, page_number, timestamp, search_results)\\n VALUES (?, ?, ?, ?)\\\"\\\"\\\"\\n\\n c.execute(insert, (search_query, page_number, timestamp, search_results,))\\n conn.commit()\",\n \"def update_q_values(self, state, action, next_state, reward, done):\\n # Following the Q-Learning update rule\\n if done:\\n self.Q_values[state,action] = (1 - self.alpha) * self.Q_values[state,action] + self.alpha * (reward)\\n else:\\n self.Q_values[state,action] = (1 - self.alpha) * self.Q_values[state,action] + self.alpha * (reward + self.gamma * np.amax(self.Q_values[next_state]))\",\n \"def update_result(result):\\n invader = result['invader'] \\n countryOfInvader = result['countryOfInvader'] \\n defender = result['defender'] \\n countryOfdefender = result['countryOfdefender'] \\n invasionHistory = InvasionHistory(\\n invader ,\\n countryOfInvader,\\n defender,\\n countryOfdefender,\\n datetime.datetime.now() )\\n\\n #update territory info\\n t_record = Territory.get_by_key_name(countryOfdefender)\\n t_record.occupier = invader\\n t_record.put() \\n\\n db.put([invasionHistory])\",\n \"def mult_operation(self):\\n arg1 = self.memory[self.memory[self._cursor + 1]]\\n arg2 = self.memory[self.memory[self._cursor + 2]]\\n arg3 = self.memory[self._cursor + 3]\\n self.memory[arg3] = arg1 * arg2\\n print(f'Cursor: {self._cursor}\\\\tAssigning position {arg3} with value {arg1 * arg2}')\\n self._cursor += 4\\n return\",\n \"def update_a_result(self, idblock, sib):\\n self.resultPanel.update_item(idblock, sib)\",\n \"def __on_query_edited(self):\\n self.__refresh_search_results()\",\n \"def update(self, target, query):\\n node = self._data[target]\\n name = \\\"%s node %.8s\\\" % (node['type'], target)\\n\\n query.update({\\n 'type': node['type'],\\n 'model': node['model']\\n })\\n\\n logger.info(\\\"Validating query\\\")\\n NodeValidator.validate(query)\\n\\n self._data[target] = dict_update(node, query, name)\\n logger.info(\\\"Updated parameters above of %s\\\" % name)\\n\\n return {target: self._data[target]}\",\n \"def update_state(self, result):\\n for i,k in enumerate(self._current_state.keys()):\\n self._current_state[k] = result[i]\",\n \"def _update_result(self, results, clf_numbers):\\n # ToDo make results of scoring values dynamic\\n names_results = ['Accuracy']\\n for number in clf_numbers:\\n for name in names_results:\\n if name not in self.results:\\n self.results[name] = [results[number][name + \\\"_test_score_\\\" + str(number)]]\\n else:\\n self.results[name].append(results[number][name + \\\"_test_score_\\\" + str(number)])\",\n \"def increment_rank(self, rank, result):\\n if result not in VALID_RESULTS:\\n raise ValueError('Invalid result: %s' % result)\\n self.counts[rank][result] += 1\\n self.total_items += 1\",\n \"def update(self, timestep, action, reward, is_optimal):\\r\\n\\t\\t# Increments the Player's selected action index by 1.\\r\\n\\t\\tself.player_selected_actions[action] += 1\\r\\n\\r\\n\\t\\t# Sets the Player reward for the particular timestep to the reward\\r\\n\\t\\t# obtained.\\r\\n\\t\\tself.player_reward[timestep] = reward\\r\\n\\r\\n\\t\\t# Sets the Player optimum for the particular timestep to the is_optimal\\r\\n\\t\\t# obtained.\\r\\n\\t\\tself.player_optimum[timestep] = is_optimal\",\n \"def update(self, state, action, nextState, reward):\\n oldComponent = (1-self.alpha) * self.getQValue(state, action)\\n nextValue = self.computeValueFromQValues(nextState)\\n sample = reward + self.discount * nextValue\\n newComponent = self.alpha * sample\\n self.qValues[(state, action)] = oldComponent + newComponent\",\n \"def _run(self): # pylint: disable=too-many-locals.too-many-branches,too-many-statements\\n num_of_stored_commands_before = len(self._stored_commands)\\n if not self.current_mapping:\\n self.current_mapping = {}\\n else:\\n self._send_possible_commands()\\n if len(self._stored_commands) == 0:\\n return\\n new_row_major_mapping = self._return_new_mapping()\\n # Find permutation of matchings with lowest cost\\n swaps = None\\n lowest_cost = None\\n matchings_numbers = list(range(self.num_rows))\\n if self.num_optimization_steps <= math.factorial(self.num_rows):\\n permutations = itertools.permutations(matchings_numbers, self.num_rows)\\n else:\\n permutations = []\\n for _ in range(self.num_optimization_steps):\\n permutations.append(self._rng.sample(matchings_numbers, self.num_rows))\\n for permutation in permutations:\\n trial_swaps = self.return_swaps(\\n old_mapping=self._current_row_major_mapping,\\n new_mapping=new_row_major_mapping,\\n permutation=permutation,\\n )\\n if swaps is None:\\n swaps = trial_swaps\\n lowest_cost = self.optimization_function(trial_swaps)\\n elif lowest_cost > self.optimization_function(trial_swaps):\\n swaps = trial_swaps\\n lowest_cost = self.optimization_function(trial_swaps)\\n if swaps: # first mapping requires no swaps\\n # Allocate all mapped qubit ids (which are not already allocated,\\n # i.e., contained in self._currently_allocated_ids)\\n mapped_ids_used = set()\\n for logical_id in self._currently_allocated_ids:\\n mapped_ids_used.add(self._current_row_major_mapping[logical_id])\\n not_allocated_ids = set(range(self.num_qubits)).difference(mapped_ids_used)\\n for mapped_id in not_allocated_ids:\\n qb = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[mapped_id])\\n cmd = Command(engine=self, gate=AllocateQubitGate(), qubits=([qb],))\\n self.send([cmd])\\n # Send swap operations to arrive at new_mapping:\\n for qubit_id0, qubit_id1 in swaps:\\n qb0 = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[qubit_id0])\\n qb1 = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[qubit_id1])\\n cmd = Command(engine=self, gate=Swap, qubits=([qb0], [qb1]))\\n self.send([cmd])\\n # Register statistics:\\n self.num_mappings += 1\\n depth = return_swap_depth(swaps)\\n if depth not in self.depth_of_swaps:\\n self.depth_of_swaps[depth] = 1\\n else:\\n self.depth_of_swaps[depth] += 1\\n if len(swaps) not in self.num_of_swaps_per_mapping:\\n self.num_of_swaps_per_mapping[len(swaps)] = 1\\n else:\\n self.num_of_swaps_per_mapping[len(swaps)] += 1\\n # Deallocate all previously mapped ids which we only needed for the\\n # swaps:\\n mapped_ids_used = set()\\n for logical_id in self._currently_allocated_ids:\\n mapped_ids_used.add(new_row_major_mapping[logical_id])\\n not_needed_anymore = set(range(self.num_qubits)).difference(mapped_ids_used)\\n for mapped_id in not_needed_anymore:\\n qb = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[mapped_id])\\n cmd = Command(engine=self, gate=DeallocateQubitGate(), qubits=([qb],))\\n self.send([cmd])\\n # Change to new map:\\n self._current_row_major_mapping = new_row_major_mapping\\n new_mapping = {}\\n for logical_id, mapped_id in new_row_major_mapping.items():\\n new_mapping[logical_id] = self._mapped_ids_to_backend_ids[mapped_id]\\n self.current_mapping = new_mapping\\n # Send possible gates:\\n self._send_possible_commands()\\n # Check that mapper actually made progress\\n if len(self._stored_commands) == num_of_stored_commands_before:\\n raise RuntimeError(\\n \\\"Mapper is potentially in an infinite loop. It is likely that the algorithm requires too\\\"\\n \\\"many qubits. Increase the number of qubits for this mapper.\\\"\\n )\",\n \"def update_optimization_results(output, model, result, runtime):\\n\\n data_path = output['Input_Data']\\n\\n result['Optimized_Model'] = [model]\\n result['Optimized_Likelihood'] = [float(\\n result['Optimized_Likelihood'])]\\n\\n if isinstance(data_path, list):\\n result['Dataset'] = []\\n for data in data_path:\\n result['Dataset'].append(os.path.basename(data))\\n else:\\n result['Dataset'] = [os.path.basename(data_path)]\\n\\n result['Runtime'] = runtime\\n\\n if output['Kernel_Transform'] is not False:\\n result['Kernel_Transform'] = str(output['Kernel_Transform'][0]) + \\\\\\n '_' + str(output['Kernel_Transform'][1])\\n else:\\n result['Kernel_Transform'] = output['Kernel_Transform']\\n\\n for key, value in result.iteritems():\\n output[key] = value\\n\\n return output\",\n \"def update(self, result, action_taken):\\n self.visits += 1\\n self.wins += result\\n\\n if self.parent is None:\\n return\\n\\n for key in self.parent.children:\\n p = self.parent.children[key].player\\n for a in action_taken[p]:\\n if a == key:\\n self.parent.children[key].visits_amaf += 1\\n self.parent.children[key].wins_amaf += result\",\n \"def mem_update(ops, x, mem, spike):\\n #print(ops(x).size())\\n #print(spike.size())\\n mem = mem * decay * (1. - spike) + ops(x)\\n spike = act_fun(mem) # act_fun : approximation firing function\\n return mem, spike\",\n \"def update(self, state, action, nextState, reward):\\n candidateQ = reward + self.discount * \\\\\\n self.computeValueFromQValues(nextState)\\n candidateQ_vec = np.array([[candidateQ]])\\n features = self.featExtractor.getFeatures(state, action)\\n features_as_list = [features[feat] for feat in self.allFeats]\\n features_vec = np.array([features_as_list])\\n self.train_step.run(feed_dict={self.x: features_vec,\\n self.y_: candidateQ_vec}, session=self.sess)\",\n \"def updateNode(self, result):\\n self.visits += 1\\n self.wins += result\",\n \"def update(self, attribute: str, result: ProcessorResult) -> None:\\n pass\",\n \"def tweak_q(self, q):\\n self._q = q\\n self.reset()\",\n \"def update_score():\\n pass\",\n \"def update1(self, state, action, nextState, reward):\\n #print \\\"update1 in ApproximateQAgent\\\"\\n \\\"*** YOUR CODE HERE ***\\\"\\n ##################################################################################################################################Eric Did Stuff\\n actionList = nextState.getLegalActions(self.index)\\n\\n\\n #print \\\"Action List\\\", actionList\\n\\n\\n\\n\\n weights = self.getWeights()\\n\\n features = self.featExtractor.getFeatures(state, action, self)\\n #self.myFeats = features\\n if self.index == 0:\\n print \\\"FEATURES: \\\",features\\n value = self.computeValueFromQValues(nextState)\\n qValue = self.getQValue(state,action)\\n #print \\\"value\\\", value, \\\"qValue\\\", qValue\\n for feature in features:\\n if len(actionList) != 0:\\n weights[feature] = weights[feature] + self.alpha * (reward + self.discount * value - qValue) * features[feature]\\n else:\\n weights[feature] = weights[feature] + self.alpha * (reward - qValue) * features[feature]\\n #print \\\"feature\\\", feature, \\\"weights\\\", weights[feature]\\n #print \\\"weights\\\", weights\\n\\n #util.raiseNotDefined()\",\n \"def update_dev_scores(self, results):\\n for metric in results:\\n print(\\\"Validation {} -> {} | lr: {}\\\".format(self.vctr, metric, self.optimizer.param_groups[0]['lr']), flush=True)\\n self.val_scores[metric.name].append(metric)\\n self.cur_bests[metric.name] = self.best_score(self.val_scores[metric.name])\\n\\n self.tensorboard_writter.add_scalar(\\n f\\\"/dev/{metric.name}\\\", metric.score, self.vctr\\n )\\n\\n # Decrease learning rate according to the scheduler policy\\n if self.opti_scheduler and metric.name == self.early_metric:\\n mode = \\\"max\\\" if metric.higher_better else \\\"min\\\"\\n self.opti_scheduler._init_is_better(mode,\\n self.opti_scheduler.threshold,\\n self.opti_scheduler.threshold_mode)\\n\\n self.opti_scheduler.step(metric.score)\",\n \"def update_Q(self, state, action, reward, new_state = None):\\n Q_val = self.Q[state][action]\\n \\n # Look at the best action from the next state.\\n Qp_val = 0\\n if new_state is not None:\\n Qp_val = max(self.Q[new_state].values())\\n \\n # The famous formula:\\n Q_val = Q_val + self.alpha * (reward + self.gamma * Qp_val - Q_val)\\n #print self.alpha\\n #print state, 'action: ', action\\n #print 'Q[%s]: %s' % (state, self.Q[state])\\n #print 'Q val: ', Q_val\\n \\n self.Q[state][action] = Q_val\\n \\n return None\",\n \"def update_usage(user_size):\\n\\n cnx = create_connection()\\n cursor = cnx.cursor()\\n\\n update_query = (\\n \\\"UPDATE \\\" + USAGE_TABLE['name'] + \\\" \\\"\\n \\\" SET \\\" + USAGE_TABLE['size_column'] + \\\"=\\\" + str(user_size[1]) + \\\" \\\"\\n \\\" WHERE \\\" + USAGE_TABLE['relational_column'] + \\\"='\\\" + user_size[0] + \\\"'\\\"\\n )\\n\\n try:\\n cursor.execute(update_query)\\n except mysql.connector.Error as e:\\n cursor.close()\\n cnx.close()\\n print(e)\\n return\\n\\n cursor.close()\\n cnx.close()\",\n \"def update(self):\\n result = [], 0, False\\n\\n if self.t % self.t_train_freq == 0:\\n result = self.q_learning_minibatch()\\n\\n if self.t % self.t_target_q_update_freq == self.t_target_q_update_freq - 1:\\n # Copy \\n self.update_target_q_network()\\n\\n return result\",\n \"def update_memory(self, vm):\\n try:\\n memory_spec = self.client.get_memory(vm.backend_id)\\n if memory_spec['size_MiB'] != vm.ram:\\n self.client.update_memory(vm.backend_id, {'size_MiB': vm.ram})\\n except VMwareError as e:\\n raise VMwareBackendError(e)\",\n \"def run_query(**kwargs):\\n logging.info(\\n \\\"Running query: \\\"\\n + kwargs[\\\"query\\\"][\\\"name\\\"]\\n + \\\" iterations: \\\"\\n + str(kwargs[\\\"iterations\\\"])\\n )\\n query_id = kwargs[\\\"query\\\"][\\\"name\\\"].rsplit(\\\".\\\")[\\n 0\\n ] # Query ID = filename without extention\\n query_results = {\\n \\\"query_name\\\": kwargs[\\\"query\\\"][\\\"name\\\"],\\n \\\"query_mapdql\\\": kwargs[\\\"query\\\"][\\\"mapdql\\\"],\\n \\\"query_id\\\": query_id,\\n \\\"query_succeeded\\\": True,\\n \\\"query_error_info\\\": \\\"\\\",\\n \\\"initial_iteration_results\\\": {},\\n \\\"noninitial_iteration_results\\\": [],\\n \\\"query_total_elapsed_time\\\": 0,\\n }\\n query_total_start_time = timeit.default_timer()\\n # Run iterations of query\\n for iteration in range(kwargs[\\\"iterations\\\"]):\\n # Gather memory before running query iteration\\n logging.debug(\\\"Getting pre-query memory usage on CPU\\\")\\n pre_query_cpu_mem_usage = get_mem_usage(\\n con=kwargs[\\\"con\\\"], mem_type=\\\"cpu\\\"\\n )\\n logging.debug(\\\"Getting pre-query memory usage on GPU\\\")\\n pre_query_gpu_mem_usage = get_mem_usage(\\n con=kwargs[\\\"con\\\"], mem_type=\\\"gpu\\\"\\n )\\n # Run query iteration\\n logging.debug(\\n \\\"Running iteration \\\"\\n + str(iteration)\\n + \\\" of query \\\"\\n + kwargs[\\\"query\\\"][\\\"name\\\"]\\n )\\n query_result = execute_query(\\n query_name=kwargs[\\\"query\\\"][\\\"name\\\"],\\n query_mapdql=kwargs[\\\"query\\\"][\\\"mapdql\\\"],\\n iteration=iteration,\\n con=kwargs[\\\"con\\\"],\\n arrow_cpu_output=kwargs[\\\"arrow_cpu_output\\\"],\\n \\n )\\n # Gather memory after running query iteration\\n logging.debug(\\\"Getting post-query memory usage on CPU\\\")\\n post_query_cpu_mem_usage = get_mem_usage(\\n con=kwargs[\\\"con\\\"], mem_type=\\\"cpu\\\"\\n )\\n logging.debug(\\\"Getting post-query memory usage on GPU\\\")\\n post_query_gpu_mem_usage = get_mem_usage(\\n con=kwargs[\\\"con\\\"], mem_type=\\\"gpu\\\"\\n )\\n # Calculate total (post minus pre) memory usage after query iteration\\n query_cpu_mem_usage = round(\\n post_query_cpu_mem_usage[\\\"usedram\\\"]\\n - pre_query_cpu_mem_usage[\\\"usedram\\\"],\\n 1,\\n )\\n query_gpu_mem_usage = round(\\n post_query_gpu_mem_usage[\\\"usedram\\\"]\\n - pre_query_gpu_mem_usage[\\\"usedram\\\"],\\n 1,\\n )\\n if query_result:\\n query_results.update(\\n query_error_info=\\\"\\\" # TODO - interpret query error info\\n )\\n # Assign first query iteration times\\n if iteration == 0:\\n first_execution_time = round(query_result[\\\"execution_time\\\"], 1)\\n first_connect_time = round(query_result[\\\"connect_time\\\"], 1)\\n first_total_time = (\\n first_execution_time\\n + first_connect_time\\n )\\n query_results.update(\\n initial_iteration_results={\\n \\\"first_execution_time\\\": first_execution_time,\\n \\\"first_connect_time\\\": first_connect_time,\\n \\\"first_total_time\\\": first_total_time,\\n \\\"first_cpu_mem_usage\\\": query_cpu_mem_usage,\\n \\\"first_gpu_mem_usage\\\": query_gpu_mem_usage,\\n }\\n )\\n else:\\n # Put noninitial iterations into query_result list\\n query_results[\\\"noninitial_iteration_results\\\"].append(\\n query_result\\n )\\n # Verify no change in memory for noninitial iterations\\n if query_cpu_mem_usage != 0.0:\\n logging.error(\\n (\\n \\\"Noninitial iteration ({0}) of query ({1}) \\\"\\n + \\\"shows non-zero CPU memory usage: {2}\\\"\\n ).format(\\n iteration,\\n kwargs[\\\"query\\\"][\\\"name\\\"],\\n query_cpu_mem_usage,\\n )\\n )\\n if query_gpu_mem_usage != 0.0:\\n logging.error(\\n (\\n \\\"Noninitial iteration ({0}) of query ({1}) \\\"\\n + \\\"shows non-zero GPU memory usage: {2}\\\"\\n ).format(\\n iteration,\\n kwargs[\\\"query\\\"][\\\"name\\\"],\\n query_gpu_mem_usage,\\n )\\n )\\n else:\\n logging.warning(\\n \\\"Error detected during execution of query: \\\"\\n + kwargs[\\\"query\\\"][\\\"name\\\"]\\n + \\\". This query will be skipped and \\\"\\n + \\\"times will not reported\\\"\\n )\\n query_results.update(query_succeeded=False)\\n break\\n # Calculate time for all iterations to run\\n query_total_elapsed_time = round(\\n ((timeit.default_timer() - query_total_start_time) * 1000), 1\\n )\\n query_results.update(query_total_elapsed_time=query_total_elapsed_time)\\n logging.info(\\n \\\"Completed all iterations of query \\\" + kwargs[\\\"query\\\"][\\\"name\\\"]\\n )\\n return query_results\",\n \"def update_resources_for_this_host(cache, db):\\n free_cpu, free_mem = get_resources()\\n my_ip = cache[\\\"ip\\\"]\\n\\n logger.info(\\\"UPDATING\\\", extra = {\\\"cpu\\\": free_cpu, \\\"mem\\\": free_mem, \\\"ip\\\": my_ip})\\n try:\\n db.hset(my_ip, mapping={\\\"cpu\\\": free_cpu, \\\"mem\\\": free_mem})\\n except Exception as e:\\n logger.error(e)\\n raise e\",\n \"def _problem_update_history(self, _):\\n self._update_reward_values()\\n self.history.curr_reward.append(self.curr_reward)\\n self.history.curr_best_reward.append(self.curr_best_reward)\",\n \"def update(self, arm, reward):\\n\\n # Increate pulls by one\\n self.pulls[arm] += 1\\n\\n # New number of pull\\n n = self.pulls[arm]\\n\\n # Old value\\n old_val = self.values[arm]\\n\\n # New value (online weighted average)\\n new_val = ((n - 1) / n) * old_val + (1 / n) * reward\\n\\n # Update value\\n self.values[arm] = new_val\\n\\n # Update epsilon\\n self.t += 1\\n self.epsilon = self.calc_dynamic_epsilon()\",\n \"def update(self):\\n\\n self._pre_calc_mb()\",\n \"def add(self, result, next_item):\\n self.test += self.length\\n self.hit += len(set(next_item) & set(result[:self.length].index))\",\n \"def update_q_table(self, cur_state, action, reward, next_state):\\n new_max_q = max(self.q_val_table[next_state])\\n new_value = reward + self.gamma * new_max_q\\n\\n old_value = self.q_val_table[cur_state][action]\\n self.q_val_table[cur_state][action] = old_value + self.alpha * (new_value - old_value)\\n\\n # Decay epsilon_greedy\\n self.e_greedy_prob = self.exp_decay(self.e_greedy_prob)\",\n \"def update(self, action, reward):\\n # like puseudo count\\n a, b = self.ActionValue[action]\\n #print(f\\\"UPDATE {action}: ({a}, {b})\\\")\\n a = a + self.huber(reward) # The larger the reward, the easier it is to select\\n b = b + 1 - self.huber(reward) # It becomes easy to be selected as the reward becomes larger, and it becomes difficult to be selected as the reward becomes smaller\\n a = 0.001 if a <= 0 else a\\n b = 0.001 if b <= 0 else b\\n \\n self.ActionValue[action] = (a, b)\\n\\n #print(f\\\"=> ({a}, {b})\\\")\\n\\n # Update nearby action candidates\\n around_update_rate = 0.3 # Parameter to adjust the degree of change according to the distance; [0, 1]\\n radius = np.sqrt(self.action_resolution**2 + self.action_resolution**2 + 1e-9) # 1e-9 is for safety to caluculate the small number \\n for action_around in self.actions:\\n if action_around == action:\\n continue\\n x = action_around[0] - action[0]\\n y = action_around[1] - action[1]\\n distance = np.sqrt(x**2 + y**2)\\n if distance <= radius:\\n a, b = self.ActionValue[action_around]\\n #print(f\\\"UPDATE {action_around}: ({a}, {b})\\\")\\n a = a + self.huber(reward) * around_update_rate * (1 - distance)\\n b = b + (1 - self.huber(reward)) * around_update_rate * (1 - distance) # To adjust the update, weight 1-r. If normal update is 1, it will be the update of around_update_rate * (1-distance) for adjacent actions.\\n a = 0.001 if a <= 0 else a\\n b = 0.001 if b <= 0 else b\\n\\n #print(f\\\"=> ({a}, {b})\\\")\\n\\n self.ActionValue[action_around] = (a, b)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61297095","0.5953453","0.5922591","0.5553142","0.544283","0.5403002","0.5356434","0.5338803","0.5331692","0.5323351","0.5294844","0.5292601","0.5231745","0.52154356","0.51240927","0.50593865","0.5058139","0.5054779","0.50533724","0.5042255","0.50057137","0.49620408","0.49591643","0.49553424","0.49470666","0.4946317","0.4943538","0.49367395","0.49194118","0.49133572","0.48974988","0.48968318","0.48944542","0.48638144","0.48472401","0.48407757","0.4835095","0.48257715","0.48234743","0.48208898","0.48208302","0.4819813","0.48165497","0.47992852","0.47939855","0.47786528","0.47786528","0.47485945","0.47453958","0.4742625","0.47289956","0.47288293","0.47279444","0.47227702","0.47227702","0.4721271","0.47174302","0.471647","0.471424","0.47086188","0.46990263","0.46983698","0.46962738","0.46902838","0.46872067","0.46766284","0.46690276","0.46614206","0.4655487","0.46478528","0.46410438","0.46364823","0.46358693","0.46345556","0.46338007","0.46319574","0.4627141","0.46199504","0.46159473","0.4611362","0.46082613","0.46059117","0.46049142","0.46006358","0.45947817","0.45909673","0.4587312","0.45859835","0.4576236","0.45750403","0.457269","0.45670936","0.45531917","0.45436624","0.4540992","0.4540538","0.4538863","0.4537903","0.45348418"],"string":"[\n \"0.61297095\",\n \"0.5953453\",\n \"0.5922591\",\n \"0.5553142\",\n \"0.544283\",\n \"0.5403002\",\n \"0.5356434\",\n \"0.5338803\",\n \"0.5331692\",\n \"0.5323351\",\n \"0.5294844\",\n \"0.5292601\",\n \"0.5231745\",\n \"0.52154356\",\n \"0.51240927\",\n \"0.50593865\",\n \"0.5058139\",\n \"0.5054779\",\n \"0.50533724\",\n \"0.5042255\",\n \"0.50057137\",\n \"0.49620408\",\n \"0.49591643\",\n \"0.49553424\",\n \"0.49470666\",\n \"0.4946317\",\n \"0.4943538\",\n \"0.49367395\",\n \"0.49194118\",\n \"0.49133572\",\n \"0.48974988\",\n \"0.48968318\",\n \"0.48944542\",\n \"0.48638144\",\n \"0.48472401\",\n \"0.48407757\",\n \"0.4835095\",\n \"0.48257715\",\n \"0.48234743\",\n \"0.48208898\",\n \"0.48208302\",\n \"0.4819813\",\n \"0.48165497\",\n \"0.47992852\",\n \"0.47939855\",\n \"0.47786528\",\n \"0.47786528\",\n \"0.47485945\",\n \"0.47453958\",\n \"0.4742625\",\n \"0.47289956\",\n \"0.47288293\",\n \"0.47279444\",\n \"0.47227702\",\n \"0.47227702\",\n \"0.4721271\",\n \"0.47174302\",\n \"0.471647\",\n \"0.471424\",\n \"0.47086188\",\n \"0.46990263\",\n \"0.46983698\",\n \"0.46962738\",\n \"0.46902838\",\n \"0.46872067\",\n \"0.46766284\",\n \"0.46690276\",\n \"0.46614206\",\n \"0.4655487\",\n \"0.46478528\",\n \"0.46410438\",\n \"0.46364823\",\n \"0.46358693\",\n \"0.46345556\",\n \"0.46338007\",\n \"0.46319574\",\n \"0.4627141\",\n \"0.46199504\",\n \"0.46159473\",\n \"0.4611362\",\n \"0.46082613\",\n \"0.46059117\",\n \"0.46049142\",\n \"0.46006358\",\n \"0.45947817\",\n \"0.45909673\",\n \"0.4587312\",\n \"0.45859835\",\n \"0.4576236\",\n \"0.45750403\",\n \"0.457269\",\n \"0.45670936\",\n \"0.45531917\",\n \"0.45436624\",\n \"0.4540992\",\n \"0.4540538\",\n \"0.4538863\",\n \"0.4537903\",\n \"0.45348418\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.620225"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94493,"cells":{"query":{"kind":"string","value":"Query memory given an input embedding"},"document":{"kind":"string","value":"def query(self, query, n_neighbours):\n if self.added_memories == 0:\n return None\n # TODO: possibly L2-normalize query vector?\n # allow single queries as well, not only batches\n if query.dim() == 1:\n query.unsqueeze_(0)\n idx, distances = self.get_nearest_entries_ixs(query, n_neighbours)\n return {\n \"embedding\": self.memory_embeddings[idx],\n \"label\": self.memory_labels[idx],\n \"age\": self.memory_age[idx],\n \"relevance\": self.memory_relevance[idx],\n \"ix\": idx\n }"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_embed(input_data, vocab_size, embed_dim):\n embedding = tf.Variable(tf.random_uniform((vocab_size,embed_dim), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, input_data)\n #print (\"embed_dim: \",embed_dim) # 向量表达维度为 256\n #print (\"input_data.shape: \",input_data.shape) # (50, 5)\n #print (\"embed.shap: \", embed.shape) # word 的向量表达 ==特征 (50, 5, 256) ==(batch_size, num_step, embed_dim)\n return embed # 返回input的向量表达","def get_embed(input_data, vocab_size, embed_dim):\n # todo 需要编程：\n # 1、构建嵌入矩阵的查找表\n lookup_w = tf.Variable(\n initial_value=tf.random_uniform([vocab_size, embed_dim], -1.0, 1.0)\n )\n # 2、获得嵌入输出\n embed = tf.nn.embedding_lookup(params=lookup_w, ids=input_data)\n # [N, n_steps, embed_size]\n return embed","def embedded(self, word_ids, embedding_tensor, scope=\"embedding\"):\n with tf.variable_scope(scope):\n with tf.device(\"/cpu:0\"):\n inputs = tf.nn.embedding_lookup(embedding_tensor, word_ids)\n return inputs","def embed(query: str) -> dict:\n embedding = model.embed(query)\n return {\"embedding\": embedding, \"model\": model_name}","def get_embed(input_data, vocab_size, embed_dim):\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_dim), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, input_data)\n\n return embed","def get_embedding(self, resp):\n\n feed_dict = {self.anchor: resp}\n embedding = self.sess.run(self.embed_anchor, feed_dict=feed_dict)\n return embedding","def _read_adv_embeddings(identity, target):\n embeddings_file = os.path.join(\n FLAGS.output_directory,\n identity,\n FLAGS.attack_type,\n target\n )\n embeddings_file = os.path.join(FLAGS.image_directory,\n identity,\n 'embeddings.h5')\n with h5py.File(embeddings_file, 'r') as f:\n return f['embeddings'][:].astype(np.float32)","def _get_query_vec(self, inputs):\n if self._flags.model_type == \"bilstm_net\":\n network = self.bilstm_net\n elif self._flags.model_type == \"bow_net\":\n network = self.bow_net\n elif self._flags.model_type == \"cnn_net\":\n network = self.cnn_net\n elif self._flags.model_type == \"lstm_net\":\n network = self.lstm_net\n elif self._flags.model_type == \"gru_net\":\n network = self.gru_net\n else:\n raise ValueError(\"Unknown network type!\")\n\n prefix_letter_pool = network(inputs[\"prefix_letter_id\"],\n \"wordid_embedding\",\n self._flags.vocab_size,\n self._flags.emb_dim,\n hid_dim=self.hid_dim,\n fc_dim=0,\n emb_lr=self._flags.emb_lr)\n if isinstance(prefix_letter_pool, list):\n #max-pooling\n prefix_pool = _parse_raw_att(prefix_letter_pool, self, 'prefix')\n else:\n prefix_pool = [prefix_letter_pool]\n\n if self._flags.prefix_word_id:\n prefix_word_pool = network(inputs[\"prefix_word_id\"],\n \"wordid_embedding\",\n self._flags.vocab_size,\n self._flags.emb_dim,\n hid_dim=self.hid_dim,\n fc_dim=0,\n emb_lr=self._flags.emb_lr)\n if isinstance(prefix_word_pool, list):\n #max-pooling\n prefix_word_raw, prefix_word_att = _parse_raw_att(prefix_word_pool, self, 'prefix')\n prefix_pool[0] = fluid.layers.concat([prefix_pool[0], prefix_word_raw], axis=1)\n prefix_pool[1] = fluid.layers.concat([prefix_pool[1], prefix_word_att], axis=1)\n else:\n prefix_pool[0] = fluid.layers.concat([prefix_pool[0], prefix_word_pool], axis=1)\n\n prefix_vec = mlp_pool(prefix_pool, self._flags.prefix_mlp.split(','), self.hid_dim)\n #vector layer\n #fluid.layers.Print(inputs[\"prefix_letter_id\"])\n #fluid.layers.Print(inputs[\"prefix_word_id\"])\n #fluid.layers.Print(prefix_vec)\n loc_vec = None\n if self._flags.use_geohash:\n loc_vec = fluid.layers.reshape(fluid.layers.cast(x=inputs['prefix_loc_geoid'],\n dtype=\"float32\"), [-1, 40])\n loc_vec = fluid.layers.fc(input=loc_vec, size=self.hid_dim, act=\"leaky_relu\", \n param_attr=fluid.ParamAttr(name='loc_fc_weight'),\n bias_attr=fluid.ParamAttr(name='loc_fc_bias'))\n\n # day_vec = fluid.layers.reshape(fluid.layers.cast(x=inputs['day_id'],\n # dtype=\"float32\"), [-1, 14])\n # day_vec = fluid.layers.fc(input=loc_vec, size=self.hid_dim, act=\"leaky_relu\", \n # param_attr=fluid.ParamAttr(name='day_weight'),\n # bias_attr=fluid.ParamAttr(name='day_bias'))\n \n context_pool = fluid.layers.concat([prefix_vec, loc_vec], axis=1) if loc_vec is not None else prefix_vec\n context_vec = fluid.layers.fc(input=context_pool, size=self._flags.fc_dim, act=self._flags.activate,\n param_attr=fluid.ParamAttr(name='context_fc_weight'),\n bias_attr=fluid.ParamAttr(name='context_fc_bias'))\n return context_vec, context_pool","def call(self,\n inputs: tf.Tensor,\n **kwargs):\n # one dim case\n # out = self.embeddings[inputs[0]]\n\n # this feels like cheating, read docs for explanation\n out = embedding_ops.embedding_lookup(self.embeddings, inputs)\n return out","def test_extract_embeddings():\n with pytest.raises(OSError):\n model = BERTopic(bert_model='not_a_model')\n model._extract_embeddings([\"Some document\"])\n\n # model = BERTopic(bert_model='distilbert-base-nli-mean-tokens')\n # embeddings = model._extract_embeddings([\"Some document\"])\n #\n # assert isinstance(embeddings, np.ndarray)\n # assert embeddings.shape == (1, 768)","def test_extract_embeddings():\n docs = [\"some document\"]\n model = BERTopic(embedding_model=\"distilbert-base-nli-stsb-mean-tokens\")\n bertopic_embeddings = model._extract_embeddings(docs)\n\n assert isinstance(bertopic_embeddings, np.ndarray)\n assert bertopic_embeddings.shape == (1, 768)\n\n sentence_embeddings = embedding_model.encode(docs, show_progress_bar=False)\n assert np.array_equal(bertopic_embeddings, sentence_embeddings)","def embed(self, sequence):\n words = sequence.split(' ')\n vecs = [self._E[self._w2i[i]] if i in self._w2i else self._E[self._w2i[\"UNK\"]]\n for i in words]\n return vecs","def forward(self, input):\n if isinstance(input, tuple):\n check_input = input[0]\n else:\n check_input = input\n in_length, in_batch, nfeat = check_input.size()\n aeq(nfeat, len(self.emb_luts))\n\n emb = self.make_embedding(input)\n\n out_length, out_batch, emb_size = emb.size()\n aeq(in_length, out_length)\n aeq(in_batch, out_batch)\n aeq(emb_size, self.embedding_size)\n\n return emb","def search(self, column: str, query: Any, top_k: int) -> gp.DataFrame:\n assert self._dataframe._db is not None\n embdedding_info = self._dataframe._db._execute(\n f\"\"\"\n WITH indexed_col_info AS (\n SELECT attrelid, attnum\n FROM pg_attribute\n WHERE \n attrelid = '{self._dataframe._qualified_table_name}'::regclass::oid AND\n attname = '{column}'\n ), reloptions AS (\n SELECT unnest(reloptions) AS option\n FROM pg_class, indexed_col_info\n WHERE pg_class.oid = attrelid\n ), embedding_info_json AS (\n SELECT split_part(option, '=', 2)::json AS val\n FROM reloptions, indexed_col_info\n WHERE option LIKE format('_pygp_emb_%s=%%', attnum)\n ), embedding_info AS (\n SELECT * \n FROM embedding_info_json, json_to_record(val) AS (attnum int4, embedding_relid oid, model text)\n )\n SELECT nspname, relname, attname, model\n FROM embedding_info, pg_class, pg_namespace, pg_attribute\n WHERE \n pg_class.oid = embedding_relid AND\n relnamespace = pg_namespace.oid AND\n embedding_relid = attrelid AND\n pg_attribute.attnum = 2;\n \"\"\"\n )\n row: Row = embdedding_info[0]\n schema: str = row[\"nspname\"]\n embedding_table_name: str = row[\"relname\"]\n model = row[\"model\"]\n embedding_col_name = row[\"attname\"]\n embedding_df = self._dataframe._db.create_dataframe(\n table_name=embedding_table_name, schema=schema\n )\n assert self._dataframe.unique_key is not None\n distance = gp.operator(\"<->\") # L2 distance is the default operator class in pgvector\n return self._dataframe.join(\n embedding_df.assign(\n distance=lambda t: distance(\n embedding_df[embedding_col_name], _generate_embedding(query, model)\n )\n ).order_by(\"distance\")[:top_k],\n how=\"inner\",\n on=self._dataframe.unique_key,\n self_columns={\"*\"},\n other_columns={},\n )","def forward(self, x, mask, query_embed, pos_embed):\n _, bs, _ = x.shape\n query_embed = query_embed.unsqueeze(1).repeat(\n 1, bs, 1) # [num_query, embed_dims] -> [num_query, bs, embed_dims]\n\n enc_mem = self.encoder(\n query=x,\n key=None,\n value=None,\n query_pos=pos_embed,\n query_key_padding_mask=mask)\n target = torch.zeros_like(query_embed)\n # out_dec: [num_dec_layers, num_query, bs, embed_dims]\n out_dec = self.decoder(\n query=target,\n key=enc_mem,\n value=enc_mem,\n key_pos=pos_embed,\n query_pos=query_embed,\n key_padding_mask=mask)\n out_dec = out_dec.transpose(1, 2)\n return out_dec, enc_mem","def question_to_vec(question, embeddings):\n\n dim = embeddings['dog'].size\n result = np.zeros((dim,))\n\n words = question.split(' ')\n\n count = 0\n for word in words:\n if word not in embeddings or not len(embeddings[word]):\n continue\n result += embeddings[word][:dim]\n count += 1\n\n return result / max(count, 1)","def search_es(es, query_embeddings, k):\n es_query ={\n \"query\": {\n \"knn\": {\n \"embeddings\": {\n \"vector\": query_embeddings,\n \"k\": k\n }\n }\n }\n }\n \n res = es.search(index=ES_INDEX, body=es_query, size=k)\n uris = [hit['_source']['uri'] for hit in res['hits']['hits']]\n return uris","def QL_embeddings():\n ql = QatarLivingCorpus(dev_file)\n sent = []\n for th in ql:\n for s in ThreadParser(th).get_sentences():\n sent.append(s)\n # CBOW, size=100, window=5\n w2v = Word2Vec(sent)\n\n # useful after training to trim unneeded model memory = use (much) less RAM\n w2v.init_sims(replace=True)\n w2v.save_word2vec_format('../models/ql_w2v_cbow_s100_w5', binary=True)\n\n # test for embeddings\n test_embeddings(w2v)","def _embed(self):\n with tf.variable_scope('word_embedding'):\n self.pretrained_word_mat = tf.get_variable(\"word_emb_mat\",\n [self.vocab.word_size() - 2, self.vocab.word_embed_dim],\n dtype=tf.float32,\n initializer=tf.constant_initializer(\n self.vocab.word_embeddings[2:],\n dtype=tf.float32),\n trainable=False)\n self.word_pad_unk_mat = tf.get_variable(\"word_unk_pad\",\n [2, self.pretrained_word_mat.get_shape()[1]],\n dtype=tf.float32,\n initializer=tf.constant_initializer(\n self.vocab.word_embeddings[:2],\n dtype=tf.float32),\n trainable=True)\n\n self.word_mat = tf.concat([self.word_pad_unk_mat, self.pretrained_word_mat], axis=0)\n self.p_emb = tf.nn.embedding_lookup(self.word_mat, self.p)\n self.q_emb = tf.nn.embedding_lookup(self.word_mat, self.q)","def create_embedding_matrix(self):\n self.id2word = dict([(self.vocab[word]['id'], word) for word in self.vocab])\n vocab_size = len(self.vocab)\n result = np.zeros((vocab_size, self.embed_dim))\n unknown_token_set = set()\n\n found_words = 0\n avg = np.zeros(self.embed_dim)\n for _ in range(1, vocab_size): # skip PAD embedding (initialize as zero embedding)\n try:\n result[_] = self.pretrained_embedding[self.id2word[_]]\n avg += result[_]\n found_words += 1\n except:\n unknown_token_set.add(_)\n\n avg /= found_words\n for _ in unknown_token_set:\n result[_] = avg\n self.embedding = result\n return found_words, len(self.id2word)","def embedding(inputs,\n vocab_dim,\n embedding_dim,\n reuse,\n validate_indices=False,\n w_init=tf.random_uniform_initializer(-1., 1.),\n trainable=True,\n normalize=False,\n vocab_freqs=None,\n name=\"Embedding\"):\n\n input_shape = util.get_input_shape(inputs)\n assert len(input_shape) == 2, \"Input Tensor shape must be 2-D\"\n\n with tf.variable_scope(name, reuse=reuse):\n with tf.device('/cpu:0'):\n W = tf.get_variable(\n \"W\", shape=[vocab_dim, embedding_dim], initializer=w_init, trainable=trainable)\n if normalize:\n assert vocab_freqs is not None\n vocab_freqs = tf.constant(vocab_freqs, dtype=tf.float32, shape=(vocab_dim, 1))\n W = _normalize(W, vocab_freqs)\n\n output = tf.cast(inputs, tf.int32)\n output = tf.nn.embedding_lookup(W, output, validate_indices=validate_indices)\n\n shape = [-1] + output.get_shape().as_list()[1:3] + [1]\n # seq_length = util.retrieve_seq_length(tf.reshape(inputs, shape))\n\n return output","def embed(self, word: str) -> list:\n return self.emb_matrix[self.wordmapper[word]]","def load_embeddings(db):\n size = db['size'].values\n emb = db['embedding'].values\n emb = [np.load(i).flatten() for i in emb]\n return emb, size","def embed(self, features, feature_name, params):\n with tf.variable_scope(\"%s_embed\" % feature_name):\n embed_matrix = tf.get_variable(\"embedding_matrix\",\n [getattr(params, \"%s_vocab_size\" % feature_name), \n getattr(params, \"%s_embed_size\" % feature_name)])\n return tf.nn.embedding_lookup(embed_matrix, features[feature_name])","def embed(documents, ctx_encoder, ctx_tokenizer, device):\n input_ids = ctx_tokenizer(\n documents[\"title\"],\n documents[\"text\"],\n truncation=True,\n padding=\"longest\",\n return_tensors=\"pt\",\n )[\"input_ids\"]\n embeddings = ctx_encoder(\n input_ids.to(device=device), return_dict=True\n ).pooler_output\n return {\"embeddings\": embeddings.detach().cpu().numpy()}","def word_embedding_forward(x, W):\n out, cache = None, None\n ##############################################################################\n # TODO: Implement the forward pass for word embeddings. #\n # #\n # HINT: This should be very simple. #\n ##############################################################################\n out = W[x,:]\n cache = x, W\n\n ##############################################################################\n # END OF YOUR CODE #\n ##############################################################################\n return out, cache","def get_word_embeddings(t, folder, lang=\"en\"):\n vecs_url = f\"https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.{lang}.300.vec.gz\"\n vecs_gz_filename = vecs_url.rpartition(\"/\")[2]\n os.makedirs(folder, exist_ok=True)\n vecs_gz_filepath = os.path.join(folder, vecs_gz_filename)\n\n tokenizer_vocab_size = len(t.vocab)\n\n if wait_for_file_stable(vecs_gz_filepath):\n print(\"Using existing embeddings file\")\n else:\n print(\"Downloading word vectors...\")\n subprocess.run([\" \".join([\"wget\", \"-NP\", folder, vecs_url])], check=True, shell=True)\n\n print(\"Loading into memory...\")\n embeddings_index = dict()\n with gzip.open(vecs_gz_filepath, \"rt\") as zipf:\n firstline = zipf.readline()\n emb_vocab_size, emb_d = firstline.split(\" \")\n emb_vocab_size = int(emb_vocab_size)\n emb_d = int(emb_d)\n for line in zipf:\n values = line.split()\n word = values[0]\n # Only load subset of the embeddings recognised by the tokenizer:\n if word in t.vocab.stoi:\n coefs = np.asarray(values[1:], dtype=\"float32\")\n embeddings_index[word] = coefs\n print(\"Loaded {} of {} word vectors for tokenizer vocabulary length {}\".format(\n len(embeddings_index),\n emb_vocab_size,\n tokenizer_vocab_size,\n ))\n\n # create a weight matrix for words in training docs\n embedding_matrix = np.zeros((tokenizer_vocab_size, emb_d))\n for word, i in t.vocab.stoi.items():\n embedding_vector = embeddings_index.get(word)\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector\n\n return embedding_matrix","def link(self, input):\n self.input = input\n self.output = self.embeddings[self.input]\n return self.output","def embed_query(self, text: str) -> List[float]:\n embedding = self._embedding_func(text, engine=self.query_model_name)\n return embedding","def decode_beamsearch(self, enc_inputs, memory_key_padding_mask, decode_dict):\n k = decode_dict['k']\n batch_size = decode_dict['batch_size']\n time_step = decode_dict['time_step']\n vocab_size = decode_dict['vocab_size']\n device = decode_dict['device']\n start_token_id = decode_dict['start_token_id']\n stop_token_id = decode_dict['stop_token_id']\n alpha = decode_dict['alpha']\n length_offset = decode_dict['length_offset']\n keypadmask_dtype = decode_dict['keypadmask_dtype']\n\n # create beam array & scores\n beams = [None for _ in range(k)]\n beam_scores = np.zeros((batch_size, k))\n\n # we should only feed through the encoder just once!!\n enc_output = self.encoder(enc_inputs) # memory\n\n # we run the decoder time_step times (auto-regressive)\n tgt_ids = torch.zeros((batch_size, time_step), dtype=torch.int64).to(device)\n tgt_ids[:,0] = start_token_id\n for i in range(k):\n beams[i] = tgt_ids\n\n for t in range(time_step-1):\n # tgt_key_padding_mask\n row_padding_mask = [False]*(t+1) + [True]*(time_step-t-1)\n padding_mask = [row_padding_mask for _ in range(batch_size)]\n tgt_key_padding_mask = torch.tensor(padding_mask, dtype=keypadmask_dtype).to(device)\n\n decoder_output_t_array = torch.zeros((batch_size, k*vocab_size))\n\n for i, beam in enumerate(beams):\n decoder_output = self.decoder(beam, enc_output,\n tgt_mask=self.tgt_mask,\n tgt_key_padding_mask=tgt_key_padding_mask,\n memory_key_padding_mask=memory_key_padding_mask,\n logsoftmax=False)\n\n # check if there is STOP_TOKEN emitted in the previous time step already\n # i.e. if the input at this time step is STOP_TOKEN\n for n_idx in range(batch_size):\n if beam[n_idx][t] == stop_token_id: # already stop\n decoder_output[n_idx, t, :] = float('-inf')\n decoder_output[n_idx, t, stop_token_id] = 0.0 # to ensure STOP_TOKEN will be picked again!\n\n else: # need to update scores --- length norm\n beam_scores[n_idx,i] *= (t-1+length_offset)**alpha\n beam_scores[n_idx,i] /= (t+length_offset)**alpha\n\n # length_norm = 1/(length)^alpha ... alpha = 0.7\n decoder_output_t_array[:,i*vocab_size:(i+1)*vocab_size] = decoder_output[:,t,:]/(t+length_offset)**alpha\n\n # add previous beam score bias\n for n_idx in range(batch_size):\n decoder_output_t_array[n_idx,i*vocab_size:(i+1)*vocab_size] += beam_scores[n_idx,i]\n\n if t == 0: break # only fill once for the first time step\n\n # scores, indice => (batch_size, k)\n scores, indices = torch.topk(decoder_output_t_array, k=k, dim=-1)\n new_beams = [torch.zeros((batch_size, time_step), dtype=torch.int64).to(device) for _ in range(k)]\n for r_idx, row in enumerate(indices):\n for c_idx, node in enumerate(row):\n vocab_idx = node % vocab_size\n beam_idx = int(node / vocab_size)\n\n new_beams[c_idx][r_idx,:t+1] = beams[beam_idx][r_idx,:t+1]\n new_beams[c_idx][r_idx,t+1] = vocab_idx\n\n beam_scores = scores.cpu().numpy()\n beams = new_beams\n\n # if (t % 10) == 0:\n # print(\"{}=\".format(t), end=\"\")\n # sys.stdout.flush()\n # print(\"{}=#\".format(t))\n\n summaries_id = [None for _ in range(batch_size)]\n for j in range(batch_size): summaries_id[j] = beams[0][j].cpu().numpy()\n\n return summaries_id","def _get_embedding(self, data):\n # Tensor(n, c)\n cat = data['cat']\n return self.one_hot_embed(cat)","def _embed(self):\n with tf.variable_scope('word_embedding'):\n self.word_embeddings = tf.get_variable(\n 'word_embeddings',\n shape=(self.term_vocab.size(), self.term_vocab.embed_dim),\n initializer=tf.constant_initializer(self.term_vocab.embeddings),\n trainable=True\n )\n self.p_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.p)\n self.q_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.q)\n\n with tf.variable_scope('char_embedding'):\n self.char_embeddings = tf.get_variable(\n 'char_embeddings',\n shape=(self.char_vocab.size(), self.char_vocab.embed_dim),\n initializer=tf.constant_initializer(self.char_vocab.embeddings),\n trainable=True\n )\n self.p_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.p_char) # [batch, seqlen, max_char_num, embedding_size]\n self.q_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.q_char)\n\n self.p_char_emb = self.cnn_emb(self.p_char_emb, \"p_emb\")\n self.q_char_emb = self.cnn_emb(self.q_char_emb, \"q_emb\")\n '''\n self.p_char_emb = tf.reshape(self.p_char_emb, [-1, self.max_char_num, self.emb_size])\n self.q_char_emb = tf.reshape(self.q_char_emb, [-1, self.max_char_num, self.emb_size])\n\n self.p_char_emb = cnn_layer.conv(self.p_char_emb, self.emb_size,\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\"char_conv\", reuse=None)\n self.q_char_emb = cnn_layer.conv(self.q_char_emb, self.emb_size,\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\"char_conv\", reuse=True)\n\n self.p_char_emb = tf.reduce_max(self.p_char_emb, axis=1) # [batch*seqlen, 1, emb_size]\n self.q_char_emb = tf.reduce_max(self.q_char_emb, axis=1)\n\n batch_size = tf.shape(self.p_word_emb)[0]\n self.p_char_emb = tf.reshape(self.p_char_emb, [batch_size, -1, self.emb_size])\n self.q_char_emb = tf.reshape(self.q_char_emb, [batch_size, -1, self.emb_size])\n\n self.p_char_emb = tf.nn.dropout(self.p_char_emb, 0.95)\n self.q_char_emb = tf.nn.dropout(self.q_char_emb, 0.95)\n '''\n self.p_emb = tf.concat([self.p_word_emb, self.p_char_emb], -1)\n self.q_emb = tf.concat([self.q_word_emb, self.q_char_emb], -1)","def compute_embeddings(model, opts, data):\n node_embeddings = []\n node_scores = []\n # batch size is 1 for computing embeddings\n dataloader = DataLoader(dataset=data, batch_size=1, shuffle=True, num_workers=16)\n model.eval()\n print(\"computing embeddings...\")\n with torch.no_grad():\n for batch in tqdm(dataloader):\n batch.to(opts.device)\n batch_scores, batch_embeddings = model(batch, compute_embeddings=False)\n node_embeddings.append(batch_embeddings)\n node_scores.append(batch_scores)\n # input('enter for embeddings')\n # print(node_embeddings)\n\n return torch.stack(node_scores), torch.stack(node_embeddings)","def _lookup_embeddings(self, x):\n e_s = tf.nn.embedding_lookup(self.ent_emb, x[:, 0], name='embedding_lookup_subject')\n e_p = tf.nn.embedding_lookup(self.rel_emb, x[:, 1], name='embedding_lookup_predicate')\n e_o = tf.nn.embedding_lookup(self.ent_emb, x[:, 2], name='embedding_lookup_object')\n return e_s, e_p, e_o","def getWordEmbeddingsMatrix(script_directory, embedding_file):\n translator = str.maketrans('', '', string.punctuation)\n all_words = []\n print(\"Loading vocab from text files in:\")\n for d in os.listdir(script_directory):\n print(d)\n for fname in os.listdir(\"%s/%s\" % (script_directory, d)):\n with open(\"%s/%s/%s\" % (script_directory, d, fname), 'r') as f:\n words = [w.translate(translator) for w in f.read().split() if w.translate(translator) != \"\"]\n all_words.extend(words)\n\n model = KeyedVectors.load_word2vec_format(embedding_file, binary=True)\n vocab = {\"PAD\" : 0, \"EOS\" : 1}\n vocab.update({w : i + 2 for i,w in enumerate([w1 for w1 in set(all_words) if w1 in model]) })\n inv_dict = vocab.keys()\n ## Take a minute to load...\n\n vocab_size = len(inv_dict)\n emb_size = 300 # or whatever the size of your embeddings\n embeddings = np.zeros((vocab_size + 1, emb_size))\n for k,v in vocab.items():\n embeddings[v] = model[k]\n vocab[\"UNK\"] = len(vocab.keys())\n embeddings[vocab[\"UNK\"]] = np.ones(emb_size)\n del model\n ## Now we have a numpy matrix of embeddings...\n # x_model = tf.placeholder(tf.int32, shape=[None, input_size])\n # with tf.device(\"/cpu:0\"):\n # embedded_x = tf.nn.embedding_lookup(embeddings, x_model)\n return embeddings, vocab","def calculate_embeddings_from_buffer(_img, _network, verbose=False):\n \n img_buff = Image.open(BytesIO(_img))\n img = _reshape_image(np.array(img_buff))\n descs = calculate_embedding(img, _network, verbose=verbose)\n img_buff.close()\n \n return descs","def __glove_embed__(sequence, model):\n embedded = []\n for word in sequence:\n embedded.append(model[word])\n return embedded","def for_extract_embedding(maxChunk=10000, isMatrix=True):\n def wrapper(function):\n def _wrapper(self, input):\n \"\"\"\n @input: a 3-dimensional tensor with batch-dim=1 or [frames, feature-dim] matrix for \n acoustic features only\n @return: an 1-dimensional vector \n \"\"\"\n train_status = self.training\n self.eval()\n\n with torch.no_grad():\n if isMatrix:\n input = torch.tensor(input)\n input = torch.unsqueeze(input, dim = 0)\n input = input.transpose(1,2)\n\n input = utils.to_device(self, input)\n num_frames = input.shape[2]\n num_split = (num_frames + maxChunk - 1) // maxChunk\n split_size = num_frames // num_split\n \n offset = 0\n embedding_stats = 0.\n for i in range(0, num_split-1):\n this_embedding = function(self, input[:, :, offset:offset+split_size])\n offset += split_size\n embedding_stats += split_size*this_embedding\n\n last_embedding = function(self, input[:, :, offset:])\n\n embedding = (embedding_stats + (num_frames-offset) * last_embedding) / num_frames\n\n if train_status:\n self.train()\n\n return torch.squeeze(embedding.transpose(1,2)).cpu()\n\n return _wrapper\n return wrapper","def question_to_vec(question, embeddings, dim):\r\n\r\n words = question.split()\r\n\r\n counter = 0\r\n res = np.zeros(dim)\r\n for word in words:\r\n if word in embeddings:\r\n res += np.array(embeddings[word])\r\n counter += 1\r\n if counter!=0:\r\n return res/counter # mean of all word embeddings\r\n else:\r\n return res # vector of zeros\r","def extract_embeddings():\n session, _ = session_bundle.load_session_bundle_from_path(FLAGS.model_path)\n all_paths = FLAGS.input_path.split(',')\n with tf.gfile.Open(FLAGS.output_path, 'w') as out:\n for dataset, pattern in enumerate(all_paths, start=FLAGS.offset):\n paths = tf.gfile.Glob(pattern)\n for path in paths:\n make_request(dataset, path, out, session)","def get_pretrained_embeddings(source_vocab,embed_df):\r\n \r\n num_tokens = len(source_vocab)\r\n embedding_dim = embed_df.shape[1]\r\n weights = np.zeros((num_tokens,embedding_dim),dtype=np.float32)\r\n \r\n for idx in range(num_tokens):\r\n token = source_vocab.lookup_index(idx)\r\n if token in embed_df.index:\r\n weights[idx,:] = embed_df.loc[token]\r\n else:\r\n weights[idx,:] = np.random.randn(1,embedding_dim)\r\n \r\n embed_tensor = torch.FloatTensor(weights)\r\n return embed_tensor","def _get_embedding_layer(self, input_data, doc_input_data):\n opts = self._options\n word_embedding = tf.Variable(tf.random_uniform((self.vocab_size, opts.embed_dim), -1.0, 1.0))\n embed = []\n\n temp = tf.zeros([opts.batch_size, opts.embed_dim])\n embed_d = []\n for n in range(opts.sentence_sample):\n temp = tf.add(temp, tf.nn.embedding_lookup(word_embedding, doc_input_data[:, n]))\n embed_d.append(temp)\n\n if opts.concat == 'True':\n combined_embed_vector_length = opts.embed_dim * opts.window_size + opts.embed_dim\n for j in range(opts.window_size):\n embed_w = tf.nn.embedding_lookup(word_embedding, input_data[:, j])\n embed.append(embed_w)\n embed.append(embed_d)\n else:\n combined_embed_vector_length = opts.embed_dim\n embed_w = tf.zeros([opts.batch_size, opts.embed_dim])\n for j in range(opts.window_size):\n embed_w += tf.nn.embedding_lookup(word_embedding, input_data[:, j])\n embed_w += embed_d\n embed.append(embed_w)\n\n return tf.concat(embed, 1), word_embedding, combined_embed_vector_length","def extract_embedding(self, from_model):\n return from_model","def get_embeddings(self, data):\n raise NotImplementedError()","def text2vec(doc_tok, model, dim=300):\n doc_embedding = np.zeros(dim)\n valid_words = 0\n for word in doc_tok:\n if word in model:\n valid_words += 1\n doc_embedding += model.query(word)\n else:\n continue\n if valid_words > 0:\n return doc_embedding / valid_words\n else:\n return doc_embedding","def embed(self, smi_or_mol):\n if not isinstance(smi_or_mol, Chem.Mol):\n mol = Chem.MolFromSmiles(smi_or_mol)\n else:\n mol = smi_or_mol\n wv = self.model.wv\n sentence = self.substructure(mol)\n vec = np.zeros(self.model.vector_size)\n for fp in sentence:\n if fp in wv.vocab:\n vec += wv[fp]\n return vec","def evaluate_embedding(ids, sess, model, dataset, batch_size, normalize=True, rescale=None):\n\n nrof_images = len(ids)\n embedding_size = model.embeddings.get_shape()[1]\n #embedding_size should be 128\n emb_array = np.zeros((nrof_images, embedding_size))\n labels_array = np.zeros((nrof_images,))\n\n nrof_batches = int(math.ceil(1.0*nrof_images / batch_size))\n for i in range(nrof_batches):\n start_index = i*batch_size\n end_index = min((i+1)*batch_size, nrof_images)\n ids_batch = ids[start_index:end_index]\n images, labels = dataset.load_images(ids_batch, normalize=normalize, rescale=rescale)\n feed_dict = {model.images:images}\n emb_array[start_index:end_index,:] = sess.run(model.embeddings, feed_dict=feed_dict)\n labels_array[start_index:end_index] = labels\n return emb_array, labels_array","def get_embedding(A,B):\n st = minion_hom_algebras(A,B,inj=True)\n writefile('tmp.minion',st)\n os.system('minion -noprintsols -solsout tmp.txt tmp.minion >tmpout.txt')\n st = readfile('tmp.txt')\n os.system('rm tmp.txt')\n emb = st.split(\"\\n\")[:-1]\n if len(emb)>1: return emb[0]","def glove_embedding(self, word_index, padded, embedding_matrix, part='q'):\n print(\"*\" * 50, \"Start Glove embedding process\", \"*\" * 50)\n start_time = time()\n\n\n MAX_SEQ_LEN = None\n if part == 'q':\n MAX_SEQ_LEN = self.MAX_Q_SEQ_LEN\n elif part == 'a':\n MAX_SEQ_LEN = self.MAX_A_SEQ_LEN\n else:\n print(f\"Please indicate you want embedding question part or answer part\")\n\n\n input_layer = Input(shape=(MAX_SEQ_LEN,), dtype='int32')\n embedding_layer = Embedding(input_dim = len(word_index) + 1,\n output_dim = self.EMBEDDING_DIM,\n weights=[embedding_matrix],\n input_length=MAX_SEQ_LEN,\n trainable=False)(input_layer)\n # (number of sample, MAX_SEQ_LEN, EMBEDING_DIM)\n model = Model(inputs=input_layer, outputs=embedding_layer)\n model.compile('rmsprop', 'mse')\n output_array = model.predict(padded)\n\n cost_time = round((time() - start_time), 4)\n print(\"*\" * 40, \"End Glove embedding() with {} seconds\".format(cost_time), \"*\" * 40, end='\\n\\n')\n\n return output_array, embedding_layer","def embedding(x, vocab_size, dense_size, name=None, reuse=None, multiplier=1.0):\n with tf.variable_scope(\n name, default_name=\"embedding\", values=[x], reuse=reuse):\n embedding_var = tf.get_variable(\"kernel\", [vocab_size, dense_size])\n emb_x = tf.gather(embedding_var, x)\n if multiplier != 1.0:\n emb_x *= multiplier\n return emb_x","def forward(self, input_variable):\r\n return self.embedding(input_variable)","def _read_embeddings(identity):\n embeddings_file = os.path.join(FLAGS.image_directory,\n identity,\n 'embeddings.h5')\n with h5py.File(embeddings_file, 'r') as f:\n return f['embeddings'][:].astype(np.float32)","def get_glove_embedding():\n embedding = {}\n N = 400_000\n print(\"Reading glove embedding...\")\n with open(GLOVE_EMBD_PATH, \"rb\") as f:\n for line in tqdm(f, total=N):\n line = line.decode().split()\n word = line[0].lower()\n vector = np.array(line[1:]).astype(np.float32)\n embedding[word] = vector\n\n return embedding","def embed_with_info(self, word_batch: List[List[str]]) -> Tuple[Tuple[FloatTensor, LongTensor], Dict[str, int]]:\n # Add words to cache\n words = {word for sequence in word_batch for word in sequence}\n cache_info = self._cache_words(words)\n\n # Convert to indices\n index_batch = [[self.word_to_index[word] for word in sequence] for sequence in word_batch]\n\n return self._embed(index_batch), cache_info","def form_cand_queries_amongvocab(self, batch_input, gram):\n N = batch_input['pair_objects'].size(0)\n tensor_type = batch_input['pair_objects'].long().data.type()\n\n M = len(self.vocab[gram])\n cats = self.idx_to_vocab[gram].type(tensor_type)\n queries = cats.unsqueeze(0) \n labels = batch_input['labels_'+gram].type(queries.data.type()) #(N,M)\n\n return (queries, labels)","def _use_embeddings(self, word):\n if word == \"@PAD@\":\n return torch.zeros(self.embeddings_dim)\n else:\n return self.embeddings[word]","def embed(text: str) -> np.ndarray:\n n = nlp(text)\n return n.vector","def filter_embeddings(embeddings, vocab, dim):\n _embeddings = np.zeros([len(vocab), dim])\n for word in vocab:\n if word in embeddings:\n word_idx = vocab[word]\n _embeddings[word_idx] = embeddings[word]\n\n return _embeddings","def _query_it(records_query: List[str],\n batch_size: int,\n metadata: Training\n ) -> Iterator[Dict[str, np.ndarray]]:\n dataset = predict_data(records_query, metadata, batch_size)()\n X_tensor = dataset.make_one_shot_iterator().get_next()\n with tf.Session() as sess:\n while True:\n try:\n X = sess.run(X_tensor)\n if \"con\" in X:\n X[\"con\"] = _make_mask(X[\"con\"], X[\"con_mask\"])\n if \"cat\" in X:\n X[\"cat\"] = _make_mask(X[\"cat\"], X[\"cat_mask\"])\n yield X\n except tf.errors.OutOfRangeError:\n break\n return","def call(self, x, *args, **kwargs):\n with tf.name_scope(\"embedding\"):\n # fills out of bound values with padding symbol\n out_bound_mask = tf.cast(x > (self.vocab_size - 1), dtype=tf.int32)\n x *= 1 - out_bound_mask\n x += out_bound_mask * tf.cast(self.pad_sym, dtype=tf.int32)\n\n embeddings = tf.gather(self.shared_weights, x)\n if self.embed_scale:\n # Scale embedding by the sqrt of the hidden size\n embeddings *= self.hidden_size ** 0.5\n\n if self.mask_paddings:\n # Create binary array of size [batch_size, length]\n # where 1 = padding, 0 = not padding\n padding = get_padding(x, padding_value=self.pad_sym)\n\n # Set all padding embedding values to 0\n # embeddings *= tf.expand_dims(1 - padding, -1)\n embeddings *= tf.cast(tf.expand_dims(1.0 - padding, -1), dtype=embeddings.dtype)\n return embeddings","def embedding(org_input):\n # Create the embedding list\n for f in range(Config.num_feature):\n num_cat_value = Config.schema[f]\n\n if num_cat_value == 1:\n pass\n elif num_cat_value > 1:\n embed_dict[f] = tf.get_variable(\n name=\"embed_\" + str(f),\n shape=[num_cat_value, Config.embed_size[f]],\n trainable=True)\n else:\n raise ValueError(\"Schema values should be positive integers!\")\n\n # Create embedded inputs\n f_size = np.sum(Config.embed_size)\n embedded_input = embed_events(org_input, f_size)\n\n return embedded_input","def test_embedding_matrix_shape(self):\n num_embeddings = 10\n features = 5\n embed = layers.Embed(num_embeddings=num_embeddings, features=features)\n inputs = np.expand_dims(np.arange(features, dtype=np.int64), 1)\n variables = embed.init(jax.random.PRNGKey(0), inputs)\n embedding_matrix = variables['params']['embedding']\n self.assertEqual((num_embeddings, features), embedding_matrix.shape)","def get_batch(corpus, ind, vocab_size, device, emsize=300):\r\n batch_size = len(ind)\r\n data_batch = np.zeros((batch_size, vocab_size))\r\n\r\n for i, doc_id in enumerate(ind):\r\n doc = corpus[doc_id.data]\r\n L = len(doc)\r\n if doc_id != -1:\r\n for word_id in doc:\r\n counts = doc.count(word_id)\r\n data_batch[i, word_id] = counts\r\n data_batch = torch.from_numpy(data_batch).float().to(device)\r\n return data_batch","def run_demo():\n while True:\n embeddings = beer_emb.embed_doc(input(\"Test if words are beer-related: \"),\n word_filter=False)\n for word_vec in embeddings:\n print(is_beer_related(word_vec))","def query(self, annotation: Annotation):\n\n x = [annotation.fee_raw] + annotation.sentence\n\n x = [[self.input_field.vocab.stoi[t]] for t in x]\n\n network_output = self.network.query(x)\n _, frame = torch.max(network_output[0], 0)\n frame = self.output_field.vocab.itos[frame.item()]\n\n return frame","def add_entry(self, embeddings, labels, query_result=None):\n n_added = embeddings.shape[0]\n\n if self.added_memories + n_added <= self.memory_size:\n start = self.write_pointer + 1\n end = start + n_added\n self.update_ixs(range(start, end), embeddings, labels, query_result)\n self.write_pointer += n_added\n else:\n capacity_remaining = max(self.memory_size - self.added_memories, 0)\n if capacity_remaining > 0:\n start = self.write_pointer + 1\n self.update_ixs(range(start, self.memory_size), embeddings[:capacity_remaining], labels[:capacity_remaining],\n query_result, global_update=False)\n\n n_overflow = n_added - capacity_remaining\n # get least relevant indices\n if self.delete_method == \"relevance\":\n write_ixs = torch.topk(self.memory_relevance, n_overflow, largest=False).indices\n elif self.delete_method == \"age\":\n write_ixs = torch.topk(self.memory_age, n_overflow, largest=True).indices\n self.update_ixs(write_ixs, embeddings[capacity_remaining:], labels[capacity_remaining:], query_result)\n self.added_memories += n_added","def add_embedding(self):\n ### YOUR CODE HERE (~4-6 lines)\n embeddingTensor = tf.Variable(self.pretrained_embeddings)\n embeddings = tf.nn.embedding_lookup(embeddingTensor, self.input_placeholder)\n embeddings = tf.reshape(embeddings, [-1, self.max_length, Config.n_features * Config.embed_size])\n ### END YOUR CODE\n return embeddings","def get_embeddings(model, loader, device=torch.device('cpu')):\n embeddings = []\n labels = []\n for item in loader:\n data, label = item\n data = data.view(-1, 1, data.shape[-1])\n data = data.to(device)\n label = label.to(device)\n output = model(data).squeeze(1)\n\n embedding = output.cpu().data.numpy()\n label = label.cpu().data.numpy()\n embeddings.append(embedding)\n labels.append(label)\n\n embeddings = np.array(embeddings)\n labels = np.array(labels)\n\n return embeddings, labels","def build_embedding_layer(inputs_, vocab_size, embed_size):\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_size), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, inputs_)\n \n return embed","def read_embeddings(embedding_file):\r\n print(\"Reading embeddings...\", end=\"\")\r\n\r\n embeddings = dict()\r\n with h5py.File(embedding_file, 'r') as f:\r\n for key in f.keys():\r\n embeddings[key] = np.array(f[key], dtype=np.float32)\r\n\r\n print(f\"done! Found {len(embeddings.keys())} proteins.\")\r\n\r\n return embeddings","def embedd_data(training_data_text, e_arr, e_dict):\n num_samples = len(training_data_text)\n embedded = np.zeros([num_samples, MAX_WORDS_IN_REVIEW, EMBEDDING_SIZE])\n for i in range(num_samples):\n review_mat = np.zeros([MAX_WORDS_IN_REVIEW, EMBEDDING_SIZE])\n # Iterate to either the end of the sentence of the max num of words, whichever is less\n for w in range(min(len(training_data_text[i]), MAX_WORDS_IN_REVIEW)):\n # assign embedding of that word or to the UNK token if that word isn't in the dict\n review_mat[w] = e_arr[e_dict.get(training_data_text[i][w], 0)]\n embedded[i] = review_mat\n return embedded","def load_embeddings(path, vocab, source_domain, target_domain, emb_name):\n\n pkl = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\n if os.path.exists(pkl):\n print(\"Load embeddings from existing pkl file %s...\" % pkl)\n # word embeddings weights have been loaded\n embeddings = pickle.load(open(pkl, 'rb'))\n else:\n print(\"Load embedding from %s...\" % path)\n raw_embeddings = {}\n if emb_name == 'yelp_electronics':\n with open(path) as fp:\n for line in fp:\n word_vector = line.split(\",\")[:-1]\n vector_list = []\n for element in word_vector[len(word_vector) - 100:]:\n vector_list.append(float(element))\n word = ','.join(word_vector[:len(word_vector) - 100])\n vector = np.asarray(vector_list)\n if word in vocab:\n raw_embeddings[word] = vector\n else:\n with open(path) as fp:\n for line in fp:\n eles = line.strip().split(' ')\n word = eles[0]\n if word in vocab:\n raw_embeddings[word] = eles[1:]\n\n dim_w = len(raw_embeddings['the'])\n n_words = len(vocab)\n embeddings = np.zeros(shape=(n_words, dim_w))\n for w in vocab:\n wid = vocab[w]\n if w in raw_embeddings:\n embeddings[wid] = np.array([float(ele) for ele in raw_embeddings[w]])\n else:\n # for OOV words, add random initialization\n embeddings[wid] = np.random.uniform(-0.25, 0.25, dim_w)\n print(\"Find %s word embeddings...\" % len(embeddings))\n if not os.path.exists('./work/embeddings'):\n os.mkdir('./work/embeddings')\n emb_path = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\n # write the embedding weights back to the disk\n pickle.dump(embeddings, open(emb_path, 'wb'))\n embeddings = np.array(embeddings, dtype='float32')\n return embeddings","def batch_inference(question,context): \n inputs = tokenizer(question, context, \n return_tensors='pt', \n truncation=True, \n padding=True)\n \n # Move data to GPU\n inputs = inputs.to(device)\n \n # Feed data through the model\n with torch.no_grad():\n outputs = model(**inputs)\n\n # Q&A model outputs the two logit scores for each word.\n # One for its chance of being the start of the answer\n # and one for its chance of being the end\n start_logits = outputs.start_logits\n end_logits = outputs.end_logits\n \n # Find the words with the highest score\n # argmax(dim=1) means argmax with each sample\n start = start_logits.argmax(dim=1)\n end = end_logits.argmax(dim=1)\n \n # Return the answers\n # This is the point where we move the prediction back to main memory with .cpu()\n tokens = [tokenizer.convert_ids_to_tokens(x) for x in inputs[\"input_ids\"].cpu().numpy()]\n return [tokenizer.convert_tokens_to_string(x[start[i]:end[i]+1]) for i,x in enumerate(tokens)]","def main():\n logging.basicConfig(level=logging.DEBUG)\n custom_embedding = True\n\n # Download embeddings'\n if custom_embedding:\n embedding_path = '../data/custom_embedding.pkl'\n embedding_index_path = '../data/custom_vocab_index.pkl'\n logging.info('Pulling custom embedding from: {}, and custom vocab from: {}'.format(embedding_path, embedding_index_path))\n embedding_matrix = pickle.load(open(embedding_path, 'rb'))\n embedding_index_lookup = pickle.load(open(embedding_index_path, 'rb'))\n\n else:\n logging.warning('Downloading embedding. If downloading for the first time, this make take 5-10 minutes.')\n embedding_url = 'https://s3.amazonaws.com/dl4j-distribution/GoogleNews-vectors-negative300.bin.gz'\n embedding_path = '~/nlp_example/'\n embedding_filename = 'GoogleNews-vectors-negative300.bin.gz'\n lib.download_file(embedding_url, embedding_path, embedding_filename)\n\n # Unpack embedding\n model = gensim.models.KeyedVectors.load_word2vec_format(embedding_path + '/' + embedding_filename, binary=True)\n embedding_matrix = model.syn0\n embedding_index_lookup = dict([(k, v.index) for k, v in model.vocab.items()])\n\n # Create thesaurus\n thesaurus = Thesaurus(embedding_matrix, embedding_index_lookup)\n\n # Find nearest neighbors for examples\n print(thesaurus.synonyms('day'))\n print(thesaurus.synonyms('top'))\n print(thesaurus.synonyms('bottom'))\n print(thesaurus.synonyms('cat'))\n print(thesaurus.synonyms('grown'))\n\n\n pass","def get_embeddings(emb_path, emb_length, vocab_size, embedding_type):\n print(\"Loading {} embeddings from file: {}...\".format(embedding_type, emb_path))\n\n emb_matrix = []\n str2id = {}\n idx = 0\n with open(emb_path, 'r') as fh:\n for line in tqdm(fh, total=vocab_size):\n line = line.lstrip().rstrip().split(\" \")\n word = line[0]\n vector = list(map(float, line[1:]))\n if emb_length != len(vector):\n raise Exception(\n \"{}: Expected vector of size {}, but got vector of size {}.\".format(idx, emb_length, len(vector)))\n emb_matrix.append(vector)\n str2id[word] = idx\n idx += 1\n\n emb_matrix = np.array(emb_matrix, dtype=np.float32)\n print(\"Loaded {} embedding matrix with shape {}.\".format(embedding_type, emb_matrix.shape))\n\n return emb_matrix, str2id","def _manifold_to_dataspace(self, X_embedded):\n\n if self.A.shape[1] != X_embedded.shape[0]:\n X_embedded = X_embedded.T\n\n X_query_kd = self.A @ X_embedded[self.n_keep_dims:]\n X_query_kd = X_query_kd.T # make X_query_kd of shape (q x d)\n\n # concatenate column-wise\n if self.n_keep_dims > 0:\n X_query = np.hstack((X_embedded[:self.n_keep_dims], X_query_kd))\n else:\n X_query = X_query_kd\n\n X_query = self._unscale(X_query)\n return X_query","def generate_embeddings_memory(dataset_path, classes):\n # get embeddings not in generators\n model = embeddings(INPUT_DIM)\n X_train, X_test, y_train, y_test = get_train_test_lists(dataset_path, classes)\n X_train_em = []\n X_test_em = []\n\n for im in X_train:\n img = preprocess_image(im)\n embeds = model.predict(img)\n embeds = np.squeeze(embeds)\n X_train_em.append(embeds)\n for im in X_test:\n img = preprocess_image(im)\n embeds = model.predict(img)\n embeds = np.squeeze(embeds)\n X_test_em.append(embeds)\n return np.array(X_train_em), np.array(X_test_em), np.array(y_train), np.array(y_test)","def embed_sent(self, x: Any) -> expression_seqs.ExpressionSequence:\n # single mode\n if not batchers.is_batched(x):\n expr = expression_seqs.ExpressionSequence(expr_list=[self.embed(word) for word in x])\n # minibatch mode\n elif type(self) == LookupEmbedder:\n embeddings = []\n for word_i in range(x.sent_len()):\n batch = batchers.mark_as_batch([single_sent[word_i] for single_sent in x])\n embeddings.append(self.embed(batch))\n expr = expression_seqs.ExpressionSequence(expr_list=embeddings, mask=x.mask)\n else:\n assert type(x[0]) == sent.SegmentedSentence, \"Need to use CharFromWordTextReader for non standard embeddings.\"\n embeddings = []\n all_embeddings = []\n for sentence in x:\n embedding = []\n for i in range(sentence.len_unpadded()):\n embed_word = self.embed(sentence.words[i])\n embedding.append(embed_word)\n all_embeddings.append(embed_word)\n embeddings.append(embedding)\n # Useful when using dy.autobatch\n dy.forward(all_embeddings)\n all_embeddings.clear()\n # Pad the results\n expr = batchers.pad_embedding(embeddings)\n\n return expr","def predict(self, content):\n input_x = list(content)\n while len(input_x) < self.args.maxlen1: input_x.append('<pad>')\n input_x = input_x[:self.args.maxlen1]\n\n input_x = [self.token2idx.get(s, self.token2idx['<unk>']) for s in input_x]\n\n memory = self.sess.run(self.memory, feed_dict={self.input_x: [input_x]})\n\n return self.bs.search(self.sess, input_x, memory[0])","def learn_from_memory():\n\n # Get a random minibatch from the replay memory and learns from it.\n if agent.memory.size > args.batch_size:\n s1, a, s2, isterminal, r = agent.memory.get_sample(args.batch_size)\n\n q = agent.get_q_values(s2).cpu().data.numpy()\n q2 = np.max(q, axis=1)\n\n target_q = agent.get_q_values(s1).cpu().data.numpy()\n # target differs from q only for the selected action. The following means:\n # target_Q(s,a) = r + gamma * max Q(s2,_) if isterminal else r\n\n target_q[np.arange(target_q.shape[0]), a] = r + args.discount_factor * (1 - isterminal) * q2\n learn(s1, target_q)","def in_storage(query,k,m):\n bools = []\n for i in range(1,k+1):\n bools.append(bfilter[mmh3.hash(query,i)%m])\n return np.prod(bools)","def embed(x, phase):\r\n\r\n is_train = True if phase == 'train' else False\r\n\r\n # Input embedding: convert input vector to dimension of hp.hidden_units.\r\n embs = input_embedding(x, num_units=hp.hidden_units, embed_type=hp.embed_type)\r\n print('Size after input embedding: ', embs.get_shape())\r\n\r\n # Positional Encoding.\r\n embs += embedding(tf.tile(tf.expand_dims(tf.range(tf.shape(x)[1]), 0), [tf.shape(x)[0], 1]),\r\n vocab_size=hp.win_len, num_units=hp.hidden_units,\r\n zero_pad=False, scale=False, scope=\"enc_pe\")\r\n print(\"Size after positional encoding: \", embs.get_shape())\r\n\r\n # Attention blocks.\r\n for i in range(hp.num_blocks):\r\n with tf.variable_scope(\"num_blocks_{}\".format(i)):\r\n # Multi-head Attention\r\n embs = multihead_attention(queries=embs, keys=embs, num_units=hp.hidden_units,\r\n num_heads=hp.num_heads, dropout_rate=hp.dropout_rate,\r\n is_training=is_train, causality=False)\r\n\r\n # Feed Forward\r\n embs = feedforward(embs, num_units=[2 * hp.hidden_units, hp.hidden_units])\r\n print(\"Size after multi-head_attention: \", embs.get_shape())\r\n\r\n # Temporal pooling by averaging on the time dimension.\r\n embs = tf.reduce_mean(embs, axis=1)\r\n\r\n return embs","def pass_word(word, model, input_embedding, char2idx, device, use_head=True):\n inp = torch.LongTensor([char2idx['START']] + [char2idx[c] for c in word]).to(device)\n inp = pack([inp])\n out, hidden = model(input_embedding.unsqueeze(0), inp, use_head=use_head)\n return out, hidden","def extract_argmax_and_embed(embedding, output_projection=None):\n def loop_function(prev, _):\n if output_projection is not None:\n prev = tf.matmul(prev, output_projection[0]) + output_projection[1]\n prev_symbol = tf.argmax(prev, 1) #得到对应的INDEX\n emb_prev = tf.gather(embedding, prev_symbol) #得到这个INDEX对应的embedding\n return emb_prev\n return loop_function","def retrieve(self, query, posting_encodings=util.CompressedPostings):\n if len(self.term_id_map) == 0 or len(self.doc_id_map) == 0:\n self.load()\n\n ### Begin your code\n words = query.split()\n iim = ii.InvertedIndexMapper('data', directory=self.output_dir, postings_encoding=posting_encodings)\n tid = self.term_id_map.__getitem__(words[0])\n ans = iim.__getitem__(tid)\n for i in range(1, len(words)):\n tid = self.term_id_map.__getitem__(words[i])\n ans = self.sorted_intersect(ans, iim.__getitem__(tid))\n for i in range(0, len(ans)):\n ans[i] = self.doc_id_map.__getitem__(ans[i])\n return ans\n ### End your code","def test_embedding_attend(self):\n features = 5\n embed = layers.Embed(num_embeddings=10, features=features)\n inputs = np.array([[1]], dtype=np.int64)\n variables = embed.init(jax.random.PRNGKey(0), inputs)\n query = np.ones(features, dtype=np.float32)\n result = embed.apply(variables, query, method=embed.attend)\n expected = np.sum(variables['params']['embedding'], -1)\n np.testing.assert_array_almost_equal(result, expected)","def embed(self,ipa_seg):\n pre_embedded = self.to_phoible_fts(ipa_seg)\n return np.matmul(PhonologicalEmbedding.__embedding_matrix,pre_embedded)","def _get_embedding(self, data):\n embedding_list = [super()._get_embedding(data)]\n context = data['context']\n for i in range(context.shape[1]):\n embedding_list.append(getattr(self, f'context{i}')(context[:, i:i+1]))\n return torch.cat(embedding_list, dim=1)","def qlist_to_vec(self, max_length, q_list):\n qvec = np.zeros(max_length)\n embed_matrix = None\n if self.use_embed:\n embed_matrix = np.zeros((max_length, EMBEDDING_SIZE))\n \"\"\" pad on the left \"\"\"\n # for i in range(max_length):\n # if i < max_length - len(q_list):\n # cvec[i] = 0\n # else:\n # w = q_list[i-(max_length-len(q_list))]\n # # is the word in the vocabulary?\n # if self.qdict.has_key(w) is False:\n # w = ''\n # qvec[i] = self.qdict[w]\n # cvec[i] = 0 if i == max_length - len(q_list) else 1\n \"\"\" pad on the right \"\"\"\n for i in range(len(q_list)):\n w = q_list[i]\n if self.use_embed:\n if w not in self.embed_dict:\n self.embed_dict[w] = self.nlp(u'%s' % w).vector\n embed_matrix[i] = self.embed_dict[w]\n\n if w not in self.qdict:\n w = ''\n qvec[i] = self.qdict[w]\n return qvec, embed_matrix","def _embed(self):\n batch_size = tf.shape(self.p)[0]\n with tf.variable_scope(\"emb\"):\n with tf.variable_scope(\"char\"):\n pc_emb = tf.reshape(tf.nn.embedding_lookup(\n self.char_embed, self.pc), \n [batch_size * self.max_p_len, self.max_w_len, self.vocab.char_embed_dim])\n qc_emb = tf.reshape(tf.nn.embedding_lookup(\n self.char_embed, self.qc), \n [batch_size * self.max_q_len, self.max_w_len, self.vocab.char_embed_dim])\n cell_fw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\n cell_bw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, pc_emb, self.pc_length, dtype=tf.float32)\n pc_emb = tf.concat([state_fw, state_bw], axis=1)\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, qc_emb, self.qc_length, dtype=tf.float32)\n qc_emb = tf.concat([state_fw, state_bw], axis=1)\n pc_emb = tf.reshape(pc_emb, [batch_size, self.max_p_len, 2 * self.char_hidden_size])\n qc_emb = tf.reshape(qc_emb, [batch_size, self.max_q_len, 2 * self.char_hidden_size])\n\n with tf.name_scope(\"word\"):\n p_emb = tf.nn.embedding_lookup(self.word_embed, self.p)\n q_emb = tf.nn.embedding_lookup(self.word_embed, self.q)\n\n with tf.name_scope(\"pos\"):\n p_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.p_pos)\n q_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.q_pos)\n \n with tf.name_scope(\"em\"):\n sh = tf.shape(self.p_em)\n resh = [sh[0], sh[1], 1]\n p_em_feat = tf.reshape(tf.cast(self.p_em, dtype=tf.float32), shape=resh)\n\n self.p_emb = tf.concat([p_emb, pc_emb, p_pos_emb, p_em_feat], axis=2)\n self.q_emb = tf.concat([q_emb, qc_emb, q_pos_emb], axis=2)","def _find_embeddings(snlp):\n embs = None\n for proc in snlp.processors.values():\n if hasattr(proc, \"pretrain\") and isinstance(proc.pretrain, Pretrain):\n embs = proc.pretrain\n break\n return embs","def forward(self, input_sentence):\n sentence = self.word_embedding(input_sentence)\n embedding = self.encoder(sentence)\n return embedding","def get_embedding():\n\n HOST = app.config.get('EMBEDDING_HOST')\n PORT = app.config.get('EMBEDDING_PORT')\n query_params = {\n 'text' : request.args.get('text', \"\"),\n \"language\" : request.args.get('language', None)\n }\n r = requests.get(f\"http://{HOST}:{PORT}/api/v1/embeddings/create\", params=query_params)\n return jsonify(r.json())","def embed(self, x):\n if self.embedding is None:\n return x\n else:\n return self.embedding(x)","def compute_user_input_embedding(txt, model):\r\n embeddings = []\r\n tokens = txt.split(\" \")\r\n for word in tokens:\r\n embeddings.append(model.wv[word])\r\n sentence_embedding = compute_average(embeddings)\r\n return sentence_embedding","def _embed_result(self, embedding):\n # project original embedding\n project_weight = self.project.weight # (o, c)\n project_embedding = embedding.permute(0, 2, 1).unsqueeze(-1) \\\n * project_weight.permute(1, 0) # (n, e, c, 1) * (c, o) -> (n, e, c, o)\n project_embedding = project_embedding.permute(0, 3, 2, 1) # (n, o, c, e)\n # interaction\n square_of_sum = torch.sum(project_embedding, dim=2) ** 2\n sum_of_square = torch.sum(project_embedding ** 2, dim=2)\n embed_result = 0.5 * (square_of_sum - sum_of_square).sum(dim=2)\n return embed_result","def pretrained_embedding_layer(model,model2,model3, word_to_index,emb_dim_max):\n words_ignored = []\n vocab_len = len(word_to_index) + 1 \n emb_matrix = np.zeros([vocab_len,emb_dim_max])\n \n print(' Total words would be processed : '+str(vocab_len))\n for word, idx in word_to_index.items():\n if word in model:\n emb_matrix[idx,:200] = model[word]\n emb_matrix[idx,200:] = 0\n if word in model2:\n emb_matrix[idx, :100] = model2[word]\n emb_matrix[idx, 100:] = 0\n if word in model3.keys():\n emb_matrix[idx,:] = model3[word]\n else:\n words_ignored.append(word)\n print(str(len(words_ignored))+\" words ignored\")\n print(emb_matrix.shape) \n \n \n embedding_layer = Embedding(vocab_len,emb_dim_max,trainable = True)\n \n # Build the embedding layer, it is required before setting the weights of the embedding layer. \n embedding_layer.build((None,)) # Do not modify the \"None\". This line of code is complete as-is.\n # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\n embedding_layer.set_weights([emb_matrix])\n \n return embedding_layer,words_ignored","def key_value_rte(placeholders, nvocab, **options):\n\n # [batch_size, max_seq1_length]\n premise = placeholders['question']\n # [batch_size]\n premise_lengths = placeholders[\"question_lengths\"]\n # [batch_size, max_seq2_length]\n hypothesis = placeholders[\"support\"]\n # [batch_size]\n hypothesis_lengths = placeholders[\"support_lengths\"]\n # [batch_size]\n targets = placeholders[\"answers\"]\n\n output_size = options[\"repr_dim_output\"]\n\n with tf.variable_scope(\"embedders\") as varscope:\n premise_embedded = nvocab(premise)\n varscope.reuse_variables()\n hypothesis_embedded = nvocab(hypothesis)\n\n # todo: add option for attentive reader\n\n print('TRAINABLE VARIABLES (only embeddings): %d' % get_total_trainable_variables())\n\n with tf.variable_scope(\"key_value_readers\") as varscope:\n premise_outputs, _ = \\\n key_value_reader(premise_embedded, premise_lengths, output_size,\n contexts=(None, None), scope=None,\n drop_keep_prob=options[\"drop_keep_prob\"],\n project_fw_bw=True)\n varscope.reuse_variables()\n hypothesis_outputs, _ = \\\n key_value_reader(hypothesis_embedded, hypothesis_lengths, output_size,\n contexts=(None, None), scope=None,\n drop_keep_prob=options[\"drop_keep_prob\"],\n project_fw_bw=True)\n\n # Reading premise with memory of hypothesis\n #premise_outputs_processed, premise_state = mutable_attention(\n # hypothesis_outputs, premise_outputs[0], premise_lengths, output_size, scope=varscope)\n #varscope.reuse_variables()\n\n # Reading hypothesis with memory of premise and altered memory of hypothesis\n hypothesis_outputs_processed, hypothesis_state = mutable_attention(\n premise_outputs, hypothesis_outputs[0], hypothesis_lengths, output_size)\n\n # todo: read premise and hypothesis memory for inferring entailment class\n\n # fixme: last can be zero because of dynamic_rnn!\n #output = hypothesis_outputs[0][:, -1, :]\n\n output = hypothesis_state.h\n\n #targets = tf.Print(targets, [tf.shape(targets)], \"targets \")\n #output = tf.Print(output, [tf.shape(output)], \"outputs \")\n\n logits, loss, predict = predictor(output, targets, options[\"answer_size\"])\n\n print('TRAINABLE VARIABLES (embeddings + model): %d' % get_total_trainable_variables())\n print('ALL VARIABLES (embeddings + model): %d' % get_total_variables())\n\n return logits, loss, predict","def prepare_word_emb_matrices(experiment):\r\n\r\n with open(\"public_data/stats/stats_train.pkl\", 'rb') as stats:\r\n stats = pickle.load(stats)\r\n vocab = stats[\"VOCAB\"]\r\n stops = [word.lower() for word in set(stopwords.words('english'))]\r\n vocab = vocab + stops\r\n\r\n if experiment == \"RANDOM\":\r\n word_embs = np.random.uniform(low=-1.0, high=1.0, size=(len(vocab), PARAMS[\"SIZE\"])).astype(\"float32\")\r\n\r\n else:\r\n word_embs = []\r\n count_unk = 0\r\n count_kn = 0\r\n\r\n if experiment == \"5\":\r\n emb_model = KeyedVectors.load_word2vec_format(\"public_data/models/experiment_5/embeddings_5.bin\",\r\n binary=True)\r\n elif experiment == \"6\":\r\n emb_model = Word2Vec.load(\"public_data/models/experiment_6/embeddings_6\")\r\n\r\n elif experiment in [\"7\", \"8\"]:\r\n emb_model = FastText.load_fasttext_format(\"public_data/models/experiment_%s/embeddings_%s.bin\"\r\n %(experiment, experiment))\r\n for word in vocab:\r\n if word in emb_model:\r\n word_embs.append(emb_model[word])\r\n count_kn += 1\r\n else:\r\n word_embs.append(np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\"SIZE\"]))\r\n count_unk += 1\r\n\r\n word_embs = np.array(word_embs).astype(\"float32\")\r\n print(count_unk / (count_kn + count_unk))\r\n\r\n pad = np.zeros(shape=PARAMS[\"SIZE\"]).astype(\"float32\")\r\n unk = np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\"SIZE\"]).astype(\"float32\")\r\n word_embs = np.insert(word_embs, 0, unk, axis=0) #id 1\r\n word_embs = np.insert(word_embs, 0, pad, axis=0) #id 0\r\n\r\n with open(\"public_data/embeddings/word_embeddings_%s.pkl\" %experiment, 'wb') as out:\r\n pickle.dump(word_embs, out, protocol=4)\r\n\r\n return word_embs"],"string":"[\n \"def get_embed(input_data, vocab_size, embed_dim):\\n embedding = tf.Variable(tf.random_uniform((vocab_size,embed_dim), -1, 1))\\n embed = tf.nn.embedding_lookup(embedding, input_data)\\n #print (\\\"embed_dim: \\\",embed_dim) # 向量表达维度为 256\\n #print (\\\"input_data.shape: \\\",input_data.shape) # (50, 5)\\n #print (\\\"embed.shap: \\\", embed.shape) # word 的向量表达 ==特征 (50, 5, 256) ==(batch_size, num_step, embed_dim)\\n return embed # 返回input的向量表达\",\n \"def get_embed(input_data, vocab_size, embed_dim):\\n # todo 需要编程：\\n # 1、构建嵌入矩阵的查找表\\n lookup_w = tf.Variable(\\n initial_value=tf.random_uniform([vocab_size, embed_dim], -1.0, 1.0)\\n )\\n # 2、获得嵌入输出\\n embed = tf.nn.embedding_lookup(params=lookup_w, ids=input_data)\\n # [N, n_steps, embed_size]\\n return embed\",\n \"def embedded(self, word_ids, embedding_tensor, scope=\\\"embedding\\\"):\\n with tf.variable_scope(scope):\\n with tf.device(\\\"/cpu:0\\\"):\\n inputs = tf.nn.embedding_lookup(embedding_tensor, word_ids)\\n return inputs\",\n \"def embed(query: str) -> dict:\\n embedding = model.embed(query)\\n return {\\\"embedding\\\": embedding, \\\"model\\\": model_name}\",\n \"def get_embed(input_data, vocab_size, embed_dim):\\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_dim), -1, 1))\\n embed = tf.nn.embedding_lookup(embedding, input_data)\\n\\n return embed\",\n \"def get_embedding(self, resp):\\n\\n feed_dict = {self.anchor: resp}\\n embedding = self.sess.run(self.embed_anchor, feed_dict=feed_dict)\\n return embedding\",\n \"def _read_adv_embeddings(identity, target):\\n embeddings_file = os.path.join(\\n FLAGS.output_directory,\\n identity,\\n FLAGS.attack_type,\\n target\\n )\\n embeddings_file = os.path.join(FLAGS.image_directory,\\n identity,\\n 'embeddings.h5')\\n with h5py.File(embeddings_file, 'r') as f:\\n return f['embeddings'][:].astype(np.float32)\",\n \"def _get_query_vec(self, inputs):\\n if self._flags.model_type == \\\"bilstm_net\\\":\\n network = self.bilstm_net\\n elif self._flags.model_type == \\\"bow_net\\\":\\n network = self.bow_net\\n elif self._flags.model_type == \\\"cnn_net\\\":\\n network = self.cnn_net\\n elif self._flags.model_type == \\\"lstm_net\\\":\\n network = self.lstm_net\\n elif self._flags.model_type == \\\"gru_net\\\":\\n network = self.gru_net\\n else:\\n raise ValueError(\\\"Unknown network type!\\\")\\n\\n prefix_letter_pool = network(inputs[\\\"prefix_letter_id\\\"],\\n \\\"wordid_embedding\\\",\\n self._flags.vocab_size,\\n self._flags.emb_dim,\\n hid_dim=self.hid_dim,\\n fc_dim=0,\\n emb_lr=self._flags.emb_lr)\\n if isinstance(prefix_letter_pool, list):\\n #max-pooling\\n prefix_pool = _parse_raw_att(prefix_letter_pool, self, 'prefix')\\n else:\\n prefix_pool = [prefix_letter_pool]\\n\\n if self._flags.prefix_word_id:\\n prefix_word_pool = network(inputs[\\\"prefix_word_id\\\"],\\n \\\"wordid_embedding\\\",\\n self._flags.vocab_size,\\n self._flags.emb_dim,\\n hid_dim=self.hid_dim,\\n fc_dim=0,\\n emb_lr=self._flags.emb_lr)\\n if isinstance(prefix_word_pool, list):\\n #max-pooling\\n prefix_word_raw, prefix_word_att = _parse_raw_att(prefix_word_pool, self, 'prefix')\\n prefix_pool[0] = fluid.layers.concat([prefix_pool[0], prefix_word_raw], axis=1)\\n prefix_pool[1] = fluid.layers.concat([prefix_pool[1], prefix_word_att], axis=1)\\n else:\\n prefix_pool[0] = fluid.layers.concat([prefix_pool[0], prefix_word_pool], axis=1)\\n\\n prefix_vec = mlp_pool(prefix_pool, self._flags.prefix_mlp.split(','), self.hid_dim)\\n #vector layer\\n #fluid.layers.Print(inputs[\\\"prefix_letter_id\\\"])\\n #fluid.layers.Print(inputs[\\\"prefix_word_id\\\"])\\n #fluid.layers.Print(prefix_vec)\\n loc_vec = None\\n if self._flags.use_geohash:\\n loc_vec = fluid.layers.reshape(fluid.layers.cast(x=inputs['prefix_loc_geoid'],\\n dtype=\\\"float32\\\"), [-1, 40])\\n loc_vec = fluid.layers.fc(input=loc_vec, size=self.hid_dim, act=\\\"leaky_relu\\\", \\n param_attr=fluid.ParamAttr(name='loc_fc_weight'),\\n bias_attr=fluid.ParamAttr(name='loc_fc_bias'))\\n\\n # day_vec = fluid.layers.reshape(fluid.layers.cast(x=inputs['day_id'],\\n # dtype=\\\"float32\\\"), [-1, 14])\\n # day_vec = fluid.layers.fc(input=loc_vec, size=self.hid_dim, act=\\\"leaky_relu\\\", \\n # param_attr=fluid.ParamAttr(name='day_weight'),\\n # bias_attr=fluid.ParamAttr(name='day_bias'))\\n \\n context_pool = fluid.layers.concat([prefix_vec, loc_vec], axis=1) if loc_vec is not None else prefix_vec\\n context_vec = fluid.layers.fc(input=context_pool, size=self._flags.fc_dim, act=self._flags.activate,\\n param_attr=fluid.ParamAttr(name='context_fc_weight'),\\n bias_attr=fluid.ParamAttr(name='context_fc_bias'))\\n return context_vec, context_pool\",\n \"def call(self,\\n inputs: tf.Tensor,\\n **kwargs):\\n # one dim case\\n # out = self.embeddings[inputs[0]]\\n\\n # this feels like cheating, read docs for explanation\\n out = embedding_ops.embedding_lookup(self.embeddings, inputs)\\n return out\",\n \"def test_extract_embeddings():\\n with pytest.raises(OSError):\\n model = BERTopic(bert_model='not_a_model')\\n model._extract_embeddings([\\\"Some document\\\"])\\n\\n # model = BERTopic(bert_model='distilbert-base-nli-mean-tokens')\\n # embeddings = model._extract_embeddings([\\\"Some document\\\"])\\n #\\n # assert isinstance(embeddings, np.ndarray)\\n # assert embeddings.shape == (1, 768)\",\n \"def test_extract_embeddings():\\n docs = [\\\"some document\\\"]\\n model = BERTopic(embedding_model=\\\"distilbert-base-nli-stsb-mean-tokens\\\")\\n bertopic_embeddings = model._extract_embeddings(docs)\\n\\n assert isinstance(bertopic_embeddings, np.ndarray)\\n assert bertopic_embeddings.shape == (1, 768)\\n\\n sentence_embeddings = embedding_model.encode(docs, show_progress_bar=False)\\n assert np.array_equal(bertopic_embeddings, sentence_embeddings)\",\n \"def embed(self, sequence):\\n words = sequence.split(' ')\\n vecs = [self._E[self._w2i[i]] if i in self._w2i else self._E[self._w2i[\\\"UNK\\\"]]\\n for i in words]\\n return vecs\",\n \"def forward(self, input):\\n if isinstance(input, tuple):\\n check_input = input[0]\\n else:\\n check_input = input\\n in_length, in_batch, nfeat = check_input.size()\\n aeq(nfeat, len(self.emb_luts))\\n\\n emb = self.make_embedding(input)\\n\\n out_length, out_batch, emb_size = emb.size()\\n aeq(in_length, out_length)\\n aeq(in_batch, out_batch)\\n aeq(emb_size, self.embedding_size)\\n\\n return emb\",\n \"def search(self, column: str, query: Any, top_k: int) -> gp.DataFrame:\\n assert self._dataframe._db is not None\\n embdedding_info = self._dataframe._db._execute(\\n f\\\"\\\"\\\"\\n WITH indexed_col_info AS (\\n SELECT attrelid, attnum\\n FROM pg_attribute\\n WHERE \\n attrelid = '{self._dataframe._qualified_table_name}'::regclass::oid AND\\n attname = '{column}'\\n ), reloptions AS (\\n SELECT unnest(reloptions) AS option\\n FROM pg_class, indexed_col_info\\n WHERE pg_class.oid = attrelid\\n ), embedding_info_json AS (\\n SELECT split_part(option, '=', 2)::json AS val\\n FROM reloptions, indexed_col_info\\n WHERE option LIKE format('_pygp_emb_%s=%%', attnum)\\n ), embedding_info AS (\\n SELECT * \\n FROM embedding_info_json, json_to_record(val) AS (attnum int4, embedding_relid oid, model text)\\n )\\n SELECT nspname, relname, attname, model\\n FROM embedding_info, pg_class, pg_namespace, pg_attribute\\n WHERE \\n pg_class.oid = embedding_relid AND\\n relnamespace = pg_namespace.oid AND\\n embedding_relid = attrelid AND\\n pg_attribute.attnum = 2;\\n \\\"\\\"\\\"\\n )\\n row: Row = embdedding_info[0]\\n schema: str = row[\\\"nspname\\\"]\\n embedding_table_name: str = row[\\\"relname\\\"]\\n model = row[\\\"model\\\"]\\n embedding_col_name = row[\\\"attname\\\"]\\n embedding_df = self._dataframe._db.create_dataframe(\\n table_name=embedding_table_name, schema=schema\\n )\\n assert self._dataframe.unique_key is not None\\n distance = gp.operator(\\\"<->\\\") # L2 distance is the default operator class in pgvector\\n return self._dataframe.join(\\n embedding_df.assign(\\n distance=lambda t: distance(\\n embedding_df[embedding_col_name], _generate_embedding(query, model)\\n )\\n ).order_by(\\\"distance\\\")[:top_k],\\n how=\\\"inner\\\",\\n on=self._dataframe.unique_key,\\n self_columns={\\\"*\\\"},\\n other_columns={},\\n )\",\n \"def forward(self, x, mask, query_embed, pos_embed):\\n _, bs, _ = x.shape\\n query_embed = query_embed.unsqueeze(1).repeat(\\n 1, bs, 1) # [num_query, embed_dims] -> [num_query, bs, embed_dims]\\n\\n enc_mem = self.encoder(\\n query=x,\\n key=None,\\n value=None,\\n query_pos=pos_embed,\\n query_key_padding_mask=mask)\\n target = torch.zeros_like(query_embed)\\n # out_dec: [num_dec_layers, num_query, bs, embed_dims]\\n out_dec = self.decoder(\\n query=target,\\n key=enc_mem,\\n value=enc_mem,\\n key_pos=pos_embed,\\n query_pos=query_embed,\\n key_padding_mask=mask)\\n out_dec = out_dec.transpose(1, 2)\\n return out_dec, enc_mem\",\n \"def question_to_vec(question, embeddings):\\n\\n dim = embeddings['dog'].size\\n result = np.zeros((dim,))\\n\\n words = question.split(' ')\\n\\n count = 0\\n for word in words:\\n if word not in embeddings or not len(embeddings[word]):\\n continue\\n result += embeddings[word][:dim]\\n count += 1\\n\\n return result / max(count, 1)\",\n \"def search_es(es, query_embeddings, k):\\n es_query ={\\n \\\"query\\\": {\\n \\\"knn\\\": {\\n \\\"embeddings\\\": {\\n \\\"vector\\\": query_embeddings,\\n \\\"k\\\": k\\n }\\n }\\n }\\n }\\n \\n res = es.search(index=ES_INDEX, body=es_query, size=k)\\n uris = [hit['_source']['uri'] for hit in res['hits']['hits']]\\n return uris\",\n \"def QL_embeddings():\\n ql = QatarLivingCorpus(dev_file)\\n sent = []\\n for th in ql:\\n for s in ThreadParser(th).get_sentences():\\n sent.append(s)\\n # CBOW, size=100, window=5\\n w2v = Word2Vec(sent)\\n\\n # useful after training to trim unneeded model memory = use (much) less RAM\\n w2v.init_sims(replace=True)\\n w2v.save_word2vec_format('../models/ql_w2v_cbow_s100_w5', binary=True)\\n\\n # test for embeddings\\n test_embeddings(w2v)\",\n \"def _embed(self):\\n with tf.variable_scope('word_embedding'):\\n self.pretrained_word_mat = tf.get_variable(\\\"word_emb_mat\\\",\\n [self.vocab.word_size() - 2, self.vocab.word_embed_dim],\\n dtype=tf.float32,\\n initializer=tf.constant_initializer(\\n self.vocab.word_embeddings[2:],\\n dtype=tf.float32),\\n trainable=False)\\n self.word_pad_unk_mat = tf.get_variable(\\\"word_unk_pad\\\",\\n [2, self.pretrained_word_mat.get_shape()[1]],\\n dtype=tf.float32,\\n initializer=tf.constant_initializer(\\n self.vocab.word_embeddings[:2],\\n dtype=tf.float32),\\n trainable=True)\\n\\n self.word_mat = tf.concat([self.word_pad_unk_mat, self.pretrained_word_mat], axis=0)\\n self.p_emb = tf.nn.embedding_lookup(self.word_mat, self.p)\\n self.q_emb = tf.nn.embedding_lookup(self.word_mat, self.q)\",\n \"def create_embedding_matrix(self):\\n self.id2word = dict([(self.vocab[word]['id'], word) for word in self.vocab])\\n vocab_size = len(self.vocab)\\n result = np.zeros((vocab_size, self.embed_dim))\\n unknown_token_set = set()\\n\\n found_words = 0\\n avg = np.zeros(self.embed_dim)\\n for _ in range(1, vocab_size): # skip PAD embedding (initialize as zero embedding)\\n try:\\n result[_] = self.pretrained_embedding[self.id2word[_]]\\n avg += result[_]\\n found_words += 1\\n except:\\n unknown_token_set.add(_)\\n\\n avg /= found_words\\n for _ in unknown_token_set:\\n result[_] = avg\\n self.embedding = result\\n return found_words, len(self.id2word)\",\n \"def embedding(inputs,\\n vocab_dim,\\n embedding_dim,\\n reuse,\\n validate_indices=False,\\n w_init=tf.random_uniform_initializer(-1., 1.),\\n trainable=True,\\n normalize=False,\\n vocab_freqs=None,\\n name=\\\"Embedding\\\"):\\n\\n input_shape = util.get_input_shape(inputs)\\n assert len(input_shape) == 2, \\\"Input Tensor shape must be 2-D\\\"\\n\\n with tf.variable_scope(name, reuse=reuse):\\n with tf.device('/cpu:0'):\\n W = tf.get_variable(\\n \\\"W\\\", shape=[vocab_dim, embedding_dim], initializer=w_init, trainable=trainable)\\n if normalize:\\n assert vocab_freqs is not None\\n vocab_freqs = tf.constant(vocab_freqs, dtype=tf.float32, shape=(vocab_dim, 1))\\n W = _normalize(W, vocab_freqs)\\n\\n output = tf.cast(inputs, tf.int32)\\n output = tf.nn.embedding_lookup(W, output, validate_indices=validate_indices)\\n\\n shape = [-1] + output.get_shape().as_list()[1:3] + [1]\\n # seq_length = util.retrieve_seq_length(tf.reshape(inputs, shape))\\n\\n return output\",\n \"def embed(self, word: str) -> list:\\n return self.emb_matrix[self.wordmapper[word]]\",\n \"def load_embeddings(db):\\n size = db['size'].values\\n emb = db['embedding'].values\\n emb = [np.load(i).flatten() for i in emb]\\n return emb, size\",\n \"def embed(self, features, feature_name, params):\\n with tf.variable_scope(\\\"%s_embed\\\" % feature_name):\\n embed_matrix = tf.get_variable(\\\"embedding_matrix\\\",\\n [getattr(params, \\\"%s_vocab_size\\\" % feature_name), \\n getattr(params, \\\"%s_embed_size\\\" % feature_name)])\\n return tf.nn.embedding_lookup(embed_matrix, features[feature_name])\",\n \"def embed(documents, ctx_encoder, ctx_tokenizer, device):\\n input_ids = ctx_tokenizer(\\n documents[\\\"title\\\"],\\n documents[\\\"text\\\"],\\n truncation=True,\\n padding=\\\"longest\\\",\\n return_tensors=\\\"pt\\\",\\n )[\\\"input_ids\\\"]\\n embeddings = ctx_encoder(\\n input_ids.to(device=device), return_dict=True\\n ).pooler_output\\n return {\\\"embeddings\\\": embeddings.detach().cpu().numpy()}\",\n \"def word_embedding_forward(x, W):\\n out, cache = None, None\\n ##############################################################################\\n # TODO: Implement the forward pass for word embeddings. #\\n # #\\n # HINT: This should be very simple. #\\n ##############################################################################\\n out = W[x,:]\\n cache = x, W\\n\\n ##############################################################################\\n # END OF YOUR CODE #\\n ##############################################################################\\n return out, cache\",\n \"def get_word_embeddings(t, folder, lang=\\\"en\\\"):\\n vecs_url = f\\\"https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.{lang}.300.vec.gz\\\"\\n vecs_gz_filename = vecs_url.rpartition(\\\"/\\\")[2]\\n os.makedirs(folder, exist_ok=True)\\n vecs_gz_filepath = os.path.join(folder, vecs_gz_filename)\\n\\n tokenizer_vocab_size = len(t.vocab)\\n\\n if wait_for_file_stable(vecs_gz_filepath):\\n print(\\\"Using existing embeddings file\\\")\\n else:\\n print(\\\"Downloading word vectors...\\\")\\n subprocess.run([\\\" \\\".join([\\\"wget\\\", \\\"-NP\\\", folder, vecs_url])], check=True, shell=True)\\n\\n print(\\\"Loading into memory...\\\")\\n embeddings_index = dict()\\n with gzip.open(vecs_gz_filepath, \\\"rt\\\") as zipf:\\n firstline = zipf.readline()\\n emb_vocab_size, emb_d = firstline.split(\\\" \\\")\\n emb_vocab_size = int(emb_vocab_size)\\n emb_d = int(emb_d)\\n for line in zipf:\\n values = line.split()\\n word = values[0]\\n # Only load subset of the embeddings recognised by the tokenizer:\\n if word in t.vocab.stoi:\\n coefs = np.asarray(values[1:], dtype=\\\"float32\\\")\\n embeddings_index[word] = coefs\\n print(\\\"Loaded {} of {} word vectors for tokenizer vocabulary length {}\\\".format(\\n len(embeddings_index),\\n emb_vocab_size,\\n tokenizer_vocab_size,\\n ))\\n\\n # create a weight matrix for words in training docs\\n embedding_matrix = np.zeros((tokenizer_vocab_size, emb_d))\\n for word, i in t.vocab.stoi.items():\\n embedding_vector = embeddings_index.get(word)\\n if embedding_vector is not None:\\n embedding_matrix[i] = embedding_vector\\n\\n return embedding_matrix\",\n \"def link(self, input):\\n self.input = input\\n self.output = self.embeddings[self.input]\\n return self.output\",\n \"def embed_query(self, text: str) -> List[float]:\\n embedding = self._embedding_func(text, engine=self.query_model_name)\\n return embedding\",\n \"def decode_beamsearch(self, enc_inputs, memory_key_padding_mask, decode_dict):\\n k = decode_dict['k']\\n batch_size = decode_dict['batch_size']\\n time_step = decode_dict['time_step']\\n vocab_size = decode_dict['vocab_size']\\n device = decode_dict['device']\\n start_token_id = decode_dict['start_token_id']\\n stop_token_id = decode_dict['stop_token_id']\\n alpha = decode_dict['alpha']\\n length_offset = decode_dict['length_offset']\\n keypadmask_dtype = decode_dict['keypadmask_dtype']\\n\\n # create beam array & scores\\n beams = [None for _ in range(k)]\\n beam_scores = np.zeros((batch_size, k))\\n\\n # we should only feed through the encoder just once!!\\n enc_output = self.encoder(enc_inputs) # memory\\n\\n # we run the decoder time_step times (auto-regressive)\\n tgt_ids = torch.zeros((batch_size, time_step), dtype=torch.int64).to(device)\\n tgt_ids[:,0] = start_token_id\\n for i in range(k):\\n beams[i] = tgt_ids\\n\\n for t in range(time_step-1):\\n # tgt_key_padding_mask\\n row_padding_mask = [False]*(t+1) + [True]*(time_step-t-1)\\n padding_mask = [row_padding_mask for _ in range(batch_size)]\\n tgt_key_padding_mask = torch.tensor(padding_mask, dtype=keypadmask_dtype).to(device)\\n\\n decoder_output_t_array = torch.zeros((batch_size, k*vocab_size))\\n\\n for i, beam in enumerate(beams):\\n decoder_output = self.decoder(beam, enc_output,\\n tgt_mask=self.tgt_mask,\\n tgt_key_padding_mask=tgt_key_padding_mask,\\n memory_key_padding_mask=memory_key_padding_mask,\\n logsoftmax=False)\\n\\n # check if there is STOP_TOKEN emitted in the previous time step already\\n # i.e. if the input at this time step is STOP_TOKEN\\n for n_idx in range(batch_size):\\n if beam[n_idx][t] == stop_token_id: # already stop\\n decoder_output[n_idx, t, :] = float('-inf')\\n decoder_output[n_idx, t, stop_token_id] = 0.0 # to ensure STOP_TOKEN will be picked again!\\n\\n else: # need to update scores --- length norm\\n beam_scores[n_idx,i] *= (t-1+length_offset)**alpha\\n beam_scores[n_idx,i] /= (t+length_offset)**alpha\\n\\n # length_norm = 1/(length)^alpha ... alpha = 0.7\\n decoder_output_t_array[:,i*vocab_size:(i+1)*vocab_size] = decoder_output[:,t,:]/(t+length_offset)**alpha\\n\\n # add previous beam score bias\\n for n_idx in range(batch_size):\\n decoder_output_t_array[n_idx,i*vocab_size:(i+1)*vocab_size] += beam_scores[n_idx,i]\\n\\n if t == 0: break # only fill once for the first time step\\n\\n # scores, indice => (batch_size, k)\\n scores, indices = torch.topk(decoder_output_t_array, k=k, dim=-1)\\n new_beams = [torch.zeros((batch_size, time_step), dtype=torch.int64).to(device) for _ in range(k)]\\n for r_idx, row in enumerate(indices):\\n for c_idx, node in enumerate(row):\\n vocab_idx = node % vocab_size\\n beam_idx = int(node / vocab_size)\\n\\n new_beams[c_idx][r_idx,:t+1] = beams[beam_idx][r_idx,:t+1]\\n new_beams[c_idx][r_idx,t+1] = vocab_idx\\n\\n beam_scores = scores.cpu().numpy()\\n beams = new_beams\\n\\n # if (t % 10) == 0:\\n # print(\\\"{}=\\\".format(t), end=\\\"\\\")\\n # sys.stdout.flush()\\n # print(\\\"{}=#\\\".format(t))\\n\\n summaries_id = [None for _ in range(batch_size)]\\n for j in range(batch_size): summaries_id[j] = beams[0][j].cpu().numpy()\\n\\n return summaries_id\",\n \"def _get_embedding(self, data):\\n # Tensor(n, c)\\n cat = data['cat']\\n return self.one_hot_embed(cat)\",\n \"def _embed(self):\\n with tf.variable_scope('word_embedding'):\\n self.word_embeddings = tf.get_variable(\\n 'word_embeddings',\\n shape=(self.term_vocab.size(), self.term_vocab.embed_dim),\\n initializer=tf.constant_initializer(self.term_vocab.embeddings),\\n trainable=True\\n )\\n self.p_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.p)\\n self.q_word_emb = tf.nn.embedding_lookup(self.word_embeddings, self.q)\\n\\n with tf.variable_scope('char_embedding'):\\n self.char_embeddings = tf.get_variable(\\n 'char_embeddings',\\n shape=(self.char_vocab.size(), self.char_vocab.embed_dim),\\n initializer=tf.constant_initializer(self.char_vocab.embeddings),\\n trainable=True\\n )\\n self.p_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.p_char) # [batch, seqlen, max_char_num, embedding_size]\\n self.q_char_emb = tf.nn.embedding_lookup(self.char_embeddings, self.q_char)\\n\\n self.p_char_emb = self.cnn_emb(self.p_char_emb, \\\"p_emb\\\")\\n self.q_char_emb = self.cnn_emb(self.q_char_emb, \\\"q_emb\\\")\\n '''\\n self.p_char_emb = tf.reshape(self.p_char_emb, [-1, self.max_char_num, self.emb_size])\\n self.q_char_emb = tf.reshape(self.q_char_emb, [-1, self.max_char_num, self.emb_size])\\n\\n self.p_char_emb = cnn_layer.conv(self.p_char_emb, self.emb_size,\\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\\\"char_conv\\\", reuse=None)\\n self.q_char_emb = cnn_layer.conv(self.q_char_emb, self.emb_size,\\n bias=True, activation=tf.nn.relu, kernel_size=5, name=\\\"char_conv\\\", reuse=True)\\n\\n self.p_char_emb = tf.reduce_max(self.p_char_emb, axis=1) # [batch*seqlen, 1, emb_size]\\n self.q_char_emb = tf.reduce_max(self.q_char_emb, axis=1)\\n\\n batch_size = tf.shape(self.p_word_emb)[0]\\n self.p_char_emb = tf.reshape(self.p_char_emb, [batch_size, -1, self.emb_size])\\n self.q_char_emb = tf.reshape(self.q_char_emb, [batch_size, -1, self.emb_size])\\n\\n self.p_char_emb = tf.nn.dropout(self.p_char_emb, 0.95)\\n self.q_char_emb = tf.nn.dropout(self.q_char_emb, 0.95)\\n '''\\n self.p_emb = tf.concat([self.p_word_emb, self.p_char_emb], -1)\\n self.q_emb = tf.concat([self.q_word_emb, self.q_char_emb], -1)\",\n \"def compute_embeddings(model, opts, data):\\n node_embeddings = []\\n node_scores = []\\n # batch size is 1 for computing embeddings\\n dataloader = DataLoader(dataset=data, batch_size=1, shuffle=True, num_workers=16)\\n model.eval()\\n print(\\\"computing embeddings...\\\")\\n with torch.no_grad():\\n for batch in tqdm(dataloader):\\n batch.to(opts.device)\\n batch_scores, batch_embeddings = model(batch, compute_embeddings=False)\\n node_embeddings.append(batch_embeddings)\\n node_scores.append(batch_scores)\\n # input('enter for embeddings')\\n # print(node_embeddings)\\n\\n return torch.stack(node_scores), torch.stack(node_embeddings)\",\n \"def _lookup_embeddings(self, x):\\n e_s = tf.nn.embedding_lookup(self.ent_emb, x[:, 0], name='embedding_lookup_subject')\\n e_p = tf.nn.embedding_lookup(self.rel_emb, x[:, 1], name='embedding_lookup_predicate')\\n e_o = tf.nn.embedding_lookup(self.ent_emb, x[:, 2], name='embedding_lookup_object')\\n return e_s, e_p, e_o\",\n \"def getWordEmbeddingsMatrix(script_directory, embedding_file):\\n translator = str.maketrans('', '', string.punctuation)\\n all_words = []\\n print(\\\"Loading vocab from text files in:\\\")\\n for d in os.listdir(script_directory):\\n print(d)\\n for fname in os.listdir(\\\"%s/%s\\\" % (script_directory, d)):\\n with open(\\\"%s/%s/%s\\\" % (script_directory, d, fname), 'r') as f:\\n words = [w.translate(translator) for w in f.read().split() if w.translate(translator) != \\\"\\\"]\\n all_words.extend(words)\\n\\n model = KeyedVectors.load_word2vec_format(embedding_file, binary=True)\\n vocab = {\\\"PAD\\\" : 0, \\\"EOS\\\" : 1}\\n vocab.update({w : i + 2 for i,w in enumerate([w1 for w1 in set(all_words) if w1 in model]) })\\n inv_dict = vocab.keys()\\n ## Take a minute to load...\\n\\n vocab_size = len(inv_dict)\\n emb_size = 300 # or whatever the size of your embeddings\\n embeddings = np.zeros((vocab_size + 1, emb_size))\\n for k,v in vocab.items():\\n embeddings[v] = model[k]\\n vocab[\\\"UNK\\\"] = len(vocab.keys())\\n embeddings[vocab[\\\"UNK\\\"]] = np.ones(emb_size)\\n del model\\n ## Now we have a numpy matrix of embeddings...\\n # x_model = tf.placeholder(tf.int32, shape=[None, input_size])\\n # with tf.device(\\\"/cpu:0\\\"):\\n # embedded_x = tf.nn.embedding_lookup(embeddings, x_model)\\n return embeddings, vocab\",\n \"def calculate_embeddings_from_buffer(_img, _network, verbose=False):\\n \\n img_buff = Image.open(BytesIO(_img))\\n img = _reshape_image(np.array(img_buff))\\n descs = calculate_embedding(img, _network, verbose=verbose)\\n img_buff.close()\\n \\n return descs\",\n \"def __glove_embed__(sequence, model):\\n embedded = []\\n for word in sequence:\\n embedded.append(model[word])\\n return embedded\",\n \"def for_extract_embedding(maxChunk=10000, isMatrix=True):\\n def wrapper(function):\\n def _wrapper(self, input):\\n \\\"\\\"\\\"\\n @input: a 3-dimensional tensor with batch-dim=1 or [frames, feature-dim] matrix for \\n acoustic features only\\n @return: an 1-dimensional vector \\n \\\"\\\"\\\"\\n train_status = self.training\\n self.eval()\\n\\n with torch.no_grad():\\n if isMatrix:\\n input = torch.tensor(input)\\n input = torch.unsqueeze(input, dim = 0)\\n input = input.transpose(1,2)\\n\\n input = utils.to_device(self, input)\\n num_frames = input.shape[2]\\n num_split = (num_frames + maxChunk - 1) // maxChunk\\n split_size = num_frames // num_split\\n \\n offset = 0\\n embedding_stats = 0.\\n for i in range(0, num_split-1):\\n this_embedding = function(self, input[:, :, offset:offset+split_size])\\n offset += split_size\\n embedding_stats += split_size*this_embedding\\n\\n last_embedding = function(self, input[:, :, offset:])\\n\\n embedding = (embedding_stats + (num_frames-offset) * last_embedding) / num_frames\\n\\n if train_status:\\n self.train()\\n\\n return torch.squeeze(embedding.transpose(1,2)).cpu()\\n\\n return _wrapper\\n return wrapper\",\n \"def question_to_vec(question, embeddings, dim):\\r\\n\\r\\n words = question.split()\\r\\n\\r\\n counter = 0\\r\\n res = np.zeros(dim)\\r\\n for word in words:\\r\\n if word in embeddings:\\r\\n res += np.array(embeddings[word])\\r\\n counter += 1\\r\\n if counter!=0:\\r\\n return res/counter # mean of all word embeddings\\r\\n else:\\r\\n return res # vector of zeros\\r\",\n \"def extract_embeddings():\\n session, _ = session_bundle.load_session_bundle_from_path(FLAGS.model_path)\\n all_paths = FLAGS.input_path.split(',')\\n with tf.gfile.Open(FLAGS.output_path, 'w') as out:\\n for dataset, pattern in enumerate(all_paths, start=FLAGS.offset):\\n paths = tf.gfile.Glob(pattern)\\n for path in paths:\\n make_request(dataset, path, out, session)\",\n \"def get_pretrained_embeddings(source_vocab,embed_df):\\r\\n \\r\\n num_tokens = len(source_vocab)\\r\\n embedding_dim = embed_df.shape[1]\\r\\n weights = np.zeros((num_tokens,embedding_dim),dtype=np.float32)\\r\\n \\r\\n for idx in range(num_tokens):\\r\\n token = source_vocab.lookup_index(idx)\\r\\n if token in embed_df.index:\\r\\n weights[idx,:] = embed_df.loc[token]\\r\\n else:\\r\\n weights[idx,:] = np.random.randn(1,embedding_dim)\\r\\n \\r\\n embed_tensor = torch.FloatTensor(weights)\\r\\n return embed_tensor\",\n \"def _get_embedding_layer(self, input_data, doc_input_data):\\n opts = self._options\\n word_embedding = tf.Variable(tf.random_uniform((self.vocab_size, opts.embed_dim), -1.0, 1.0))\\n embed = []\\n\\n temp = tf.zeros([opts.batch_size, opts.embed_dim])\\n embed_d = []\\n for n in range(opts.sentence_sample):\\n temp = tf.add(temp, tf.nn.embedding_lookup(word_embedding, doc_input_data[:, n]))\\n embed_d.append(temp)\\n\\n if opts.concat == 'True':\\n combined_embed_vector_length = opts.embed_dim * opts.window_size + opts.embed_dim\\n for j in range(opts.window_size):\\n embed_w = tf.nn.embedding_lookup(word_embedding, input_data[:, j])\\n embed.append(embed_w)\\n embed.append(embed_d)\\n else:\\n combined_embed_vector_length = opts.embed_dim\\n embed_w = tf.zeros([opts.batch_size, opts.embed_dim])\\n for j in range(opts.window_size):\\n embed_w += tf.nn.embedding_lookup(word_embedding, input_data[:, j])\\n embed_w += embed_d\\n embed.append(embed_w)\\n\\n return tf.concat(embed, 1), word_embedding, combined_embed_vector_length\",\n \"def extract_embedding(self, from_model):\\n return from_model\",\n \"def get_embeddings(self, data):\\n raise NotImplementedError()\",\n \"def text2vec(doc_tok, model, dim=300):\\n doc_embedding = np.zeros(dim)\\n valid_words = 0\\n for word in doc_tok:\\n if word in model:\\n valid_words += 1\\n doc_embedding += model.query(word)\\n else:\\n continue\\n if valid_words > 0:\\n return doc_embedding / valid_words\\n else:\\n return doc_embedding\",\n \"def embed(self, smi_or_mol):\\n if not isinstance(smi_or_mol, Chem.Mol):\\n mol = Chem.MolFromSmiles(smi_or_mol)\\n else:\\n mol = smi_or_mol\\n wv = self.model.wv\\n sentence = self.substructure(mol)\\n vec = np.zeros(self.model.vector_size)\\n for fp in sentence:\\n if fp in wv.vocab:\\n vec += wv[fp]\\n return vec\",\n \"def evaluate_embedding(ids, sess, model, dataset, batch_size, normalize=True, rescale=None):\\n\\n nrof_images = len(ids)\\n embedding_size = model.embeddings.get_shape()[1]\\n #embedding_size should be 128\\n emb_array = np.zeros((nrof_images, embedding_size))\\n labels_array = np.zeros((nrof_images,))\\n\\n nrof_batches = int(math.ceil(1.0*nrof_images / batch_size))\\n for i in range(nrof_batches):\\n start_index = i*batch_size\\n end_index = min((i+1)*batch_size, nrof_images)\\n ids_batch = ids[start_index:end_index]\\n images, labels = dataset.load_images(ids_batch, normalize=normalize, rescale=rescale)\\n feed_dict = {model.images:images}\\n emb_array[start_index:end_index,:] = sess.run(model.embeddings, feed_dict=feed_dict)\\n labels_array[start_index:end_index] = labels\\n return emb_array, labels_array\",\n \"def get_embedding(A,B):\\n st = minion_hom_algebras(A,B,inj=True)\\n writefile('tmp.minion',st)\\n os.system('minion -noprintsols -solsout tmp.txt tmp.minion >tmpout.txt')\\n st = readfile('tmp.txt')\\n os.system('rm tmp.txt')\\n emb = st.split(\\\"\\\\n\\\")[:-1]\\n if len(emb)>1: return emb[0]\",\n \"def glove_embedding(self, word_index, padded, embedding_matrix, part='q'):\\n print(\\\"*\\\" * 50, \\\"Start Glove embedding process\\\", \\\"*\\\" * 50)\\n start_time = time()\\n\\n\\n MAX_SEQ_LEN = None\\n if part == 'q':\\n MAX_SEQ_LEN = self.MAX_Q_SEQ_LEN\\n elif part == 'a':\\n MAX_SEQ_LEN = self.MAX_A_SEQ_LEN\\n else:\\n print(f\\\"Please indicate you want embedding question part or answer part\\\")\\n\\n\\n input_layer = Input(shape=(MAX_SEQ_LEN,), dtype='int32')\\n embedding_layer = Embedding(input_dim = len(word_index) + 1,\\n output_dim = self.EMBEDDING_DIM,\\n weights=[embedding_matrix],\\n input_length=MAX_SEQ_LEN,\\n trainable=False)(input_layer)\\n # (number of sample, MAX_SEQ_LEN, EMBEDING_DIM)\\n model = Model(inputs=input_layer, outputs=embedding_layer)\\n model.compile('rmsprop', 'mse')\\n output_array = model.predict(padded)\\n\\n cost_time = round((time() - start_time), 4)\\n print(\\\"*\\\" * 40, \\\"End Glove embedding() with {} seconds\\\".format(cost_time), \\\"*\\\" * 40, end='\\\\n\\\\n')\\n\\n return output_array, embedding_layer\",\n \"def embedding(x, vocab_size, dense_size, name=None, reuse=None, multiplier=1.0):\\n with tf.variable_scope(\\n name, default_name=\\\"embedding\\\", values=[x], reuse=reuse):\\n embedding_var = tf.get_variable(\\\"kernel\\\", [vocab_size, dense_size])\\n emb_x = tf.gather(embedding_var, x)\\n if multiplier != 1.0:\\n emb_x *= multiplier\\n return emb_x\",\n \"def forward(self, input_variable):\\r\\n return self.embedding(input_variable)\",\n \"def _read_embeddings(identity):\\n embeddings_file = os.path.join(FLAGS.image_directory,\\n identity,\\n 'embeddings.h5')\\n with h5py.File(embeddings_file, 'r') as f:\\n return f['embeddings'][:].astype(np.float32)\",\n \"def get_glove_embedding():\\n embedding = {}\\n N = 400_000\\n print(\\\"Reading glove embedding...\\\")\\n with open(GLOVE_EMBD_PATH, \\\"rb\\\") as f:\\n for line in tqdm(f, total=N):\\n line = line.decode().split()\\n word = line[0].lower()\\n vector = np.array(line[1:]).astype(np.float32)\\n embedding[word] = vector\\n\\n return embedding\",\n \"def embed_with_info(self, word_batch: List[List[str]]) -> Tuple[Tuple[FloatTensor, LongTensor], Dict[str, int]]:\\n # Add words to cache\\n words = {word for sequence in word_batch for word in sequence}\\n cache_info = self._cache_words(words)\\n\\n # Convert to indices\\n index_batch = [[self.word_to_index[word] for word in sequence] for sequence in word_batch]\\n\\n return self._embed(index_batch), cache_info\",\n \"def form_cand_queries_amongvocab(self, batch_input, gram):\\n N = batch_input['pair_objects'].size(0)\\n tensor_type = batch_input['pair_objects'].long().data.type()\\n\\n M = len(self.vocab[gram])\\n cats = self.idx_to_vocab[gram].type(tensor_type)\\n queries = cats.unsqueeze(0) \\n labels = batch_input['labels_'+gram].type(queries.data.type()) #(N,M)\\n\\n return (queries, labels)\",\n \"def _use_embeddings(self, word):\\n if word == \\\"@PAD@\\\":\\n return torch.zeros(self.embeddings_dim)\\n else:\\n return self.embeddings[word]\",\n \"def embed(text: str) -> np.ndarray:\\n n = nlp(text)\\n return n.vector\",\n \"def filter_embeddings(embeddings, vocab, dim):\\n _embeddings = np.zeros([len(vocab), dim])\\n for word in vocab:\\n if word in embeddings:\\n word_idx = vocab[word]\\n _embeddings[word_idx] = embeddings[word]\\n\\n return _embeddings\",\n \"def _query_it(records_query: List[str],\\n batch_size: int,\\n metadata: Training\\n ) -> Iterator[Dict[str, np.ndarray]]:\\n dataset = predict_data(records_query, metadata, batch_size)()\\n X_tensor = dataset.make_one_shot_iterator().get_next()\\n with tf.Session() as sess:\\n while True:\\n try:\\n X = sess.run(X_tensor)\\n if \\\"con\\\" in X:\\n X[\\\"con\\\"] = _make_mask(X[\\\"con\\\"], X[\\\"con_mask\\\"])\\n if \\\"cat\\\" in X:\\n X[\\\"cat\\\"] = _make_mask(X[\\\"cat\\\"], X[\\\"cat_mask\\\"])\\n yield X\\n except tf.errors.OutOfRangeError:\\n break\\n return\",\n \"def call(self, x, *args, **kwargs):\\n with tf.name_scope(\\\"embedding\\\"):\\n # fills out of bound values with padding symbol\\n out_bound_mask = tf.cast(x > (self.vocab_size - 1), dtype=tf.int32)\\n x *= 1 - out_bound_mask\\n x += out_bound_mask * tf.cast(self.pad_sym, dtype=tf.int32)\\n\\n embeddings = tf.gather(self.shared_weights, x)\\n if self.embed_scale:\\n # Scale embedding by the sqrt of the hidden size\\n embeddings *= self.hidden_size ** 0.5\\n\\n if self.mask_paddings:\\n # Create binary array of size [batch_size, length]\\n # where 1 = padding, 0 = not padding\\n padding = get_padding(x, padding_value=self.pad_sym)\\n\\n # Set all padding embedding values to 0\\n # embeddings *= tf.expand_dims(1 - padding, -1)\\n embeddings *= tf.cast(tf.expand_dims(1.0 - padding, -1), dtype=embeddings.dtype)\\n return embeddings\",\n \"def embedding(org_input):\\n # Create the embedding list\\n for f in range(Config.num_feature):\\n num_cat_value = Config.schema[f]\\n\\n if num_cat_value == 1:\\n pass\\n elif num_cat_value > 1:\\n embed_dict[f] = tf.get_variable(\\n name=\\\"embed_\\\" + str(f),\\n shape=[num_cat_value, Config.embed_size[f]],\\n trainable=True)\\n else:\\n raise ValueError(\\\"Schema values should be positive integers!\\\")\\n\\n # Create embedded inputs\\n f_size = np.sum(Config.embed_size)\\n embedded_input = embed_events(org_input, f_size)\\n\\n return embedded_input\",\n \"def test_embedding_matrix_shape(self):\\n num_embeddings = 10\\n features = 5\\n embed = layers.Embed(num_embeddings=num_embeddings, features=features)\\n inputs = np.expand_dims(np.arange(features, dtype=np.int64), 1)\\n variables = embed.init(jax.random.PRNGKey(0), inputs)\\n embedding_matrix = variables['params']['embedding']\\n self.assertEqual((num_embeddings, features), embedding_matrix.shape)\",\n \"def get_batch(corpus, ind, vocab_size, device, emsize=300):\\r\\n batch_size = len(ind)\\r\\n data_batch = np.zeros((batch_size, vocab_size))\\r\\n\\r\\n for i, doc_id in enumerate(ind):\\r\\n doc = corpus[doc_id.data]\\r\\n L = len(doc)\\r\\n if doc_id != -1:\\r\\n for word_id in doc:\\r\\n counts = doc.count(word_id)\\r\\n data_batch[i, word_id] = counts\\r\\n data_batch = torch.from_numpy(data_batch).float().to(device)\\r\\n return data_batch\",\n \"def run_demo():\\n while True:\\n embeddings = beer_emb.embed_doc(input(\\\"Test if words are beer-related: \\\"),\\n word_filter=False)\\n for word_vec in embeddings:\\n print(is_beer_related(word_vec))\",\n \"def query(self, annotation: Annotation):\\n\\n x = [annotation.fee_raw] + annotation.sentence\\n\\n x = [[self.input_field.vocab.stoi[t]] for t in x]\\n\\n network_output = self.network.query(x)\\n _, frame = torch.max(network_output[0], 0)\\n frame = self.output_field.vocab.itos[frame.item()]\\n\\n return frame\",\n \"def add_entry(self, embeddings, labels, query_result=None):\\n n_added = embeddings.shape[0]\\n\\n if self.added_memories + n_added <= self.memory_size:\\n start = self.write_pointer + 1\\n end = start + n_added\\n self.update_ixs(range(start, end), embeddings, labels, query_result)\\n self.write_pointer += n_added\\n else:\\n capacity_remaining = max(self.memory_size - self.added_memories, 0)\\n if capacity_remaining > 0:\\n start = self.write_pointer + 1\\n self.update_ixs(range(start, self.memory_size), embeddings[:capacity_remaining], labels[:capacity_remaining],\\n query_result, global_update=False)\\n\\n n_overflow = n_added - capacity_remaining\\n # get least relevant indices\\n if self.delete_method == \\\"relevance\\\":\\n write_ixs = torch.topk(self.memory_relevance, n_overflow, largest=False).indices\\n elif self.delete_method == \\\"age\\\":\\n write_ixs = torch.topk(self.memory_age, n_overflow, largest=True).indices\\n self.update_ixs(write_ixs, embeddings[capacity_remaining:], labels[capacity_remaining:], query_result)\\n self.added_memories += n_added\",\n \"def add_embedding(self):\\n ### YOUR CODE HERE (~4-6 lines)\\n embeddingTensor = tf.Variable(self.pretrained_embeddings)\\n embeddings = tf.nn.embedding_lookup(embeddingTensor, self.input_placeholder)\\n embeddings = tf.reshape(embeddings, [-1, self.max_length, Config.n_features * Config.embed_size])\\n ### END YOUR CODE\\n return embeddings\",\n \"def get_embeddings(model, loader, device=torch.device('cpu')):\\n embeddings = []\\n labels = []\\n for item in loader:\\n data, label = item\\n data = data.view(-1, 1, data.shape[-1])\\n data = data.to(device)\\n label = label.to(device)\\n output = model(data).squeeze(1)\\n\\n embedding = output.cpu().data.numpy()\\n label = label.cpu().data.numpy()\\n embeddings.append(embedding)\\n labels.append(label)\\n\\n embeddings = np.array(embeddings)\\n labels = np.array(labels)\\n\\n return embeddings, labels\",\n \"def build_embedding_layer(inputs_, vocab_size, embed_size):\\n embedding = tf.Variable(tf.random_uniform((vocab_size, embed_size), -1, 1))\\n embed = tf.nn.embedding_lookup(embedding, inputs_)\\n \\n return embed\",\n \"def read_embeddings(embedding_file):\\r\\n print(\\\"Reading embeddings...\\\", end=\\\"\\\")\\r\\n\\r\\n embeddings = dict()\\r\\n with h5py.File(embedding_file, 'r') as f:\\r\\n for key in f.keys():\\r\\n embeddings[key] = np.array(f[key], dtype=np.float32)\\r\\n\\r\\n print(f\\\"done! Found {len(embeddings.keys())} proteins.\\\")\\r\\n\\r\\n return embeddings\",\n \"def embedd_data(training_data_text, e_arr, e_dict):\\n num_samples = len(training_data_text)\\n embedded = np.zeros([num_samples, MAX_WORDS_IN_REVIEW, EMBEDDING_SIZE])\\n for i in range(num_samples):\\n review_mat = np.zeros([MAX_WORDS_IN_REVIEW, EMBEDDING_SIZE])\\n # Iterate to either the end of the sentence of the max num of words, whichever is less\\n for w in range(min(len(training_data_text[i]), MAX_WORDS_IN_REVIEW)):\\n # assign embedding of that word or to the UNK token if that word isn't in the dict\\n review_mat[w] = e_arr[e_dict.get(training_data_text[i][w], 0)]\\n embedded[i] = review_mat\\n return embedded\",\n \"def load_embeddings(path, vocab, source_domain, target_domain, emb_name):\\n\\n pkl = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\\n if os.path.exists(pkl):\\n print(\\\"Load embeddings from existing pkl file %s...\\\" % pkl)\\n # word embeddings weights have been loaded\\n embeddings = pickle.load(open(pkl, 'rb'))\\n else:\\n print(\\\"Load embedding from %s...\\\" % path)\\n raw_embeddings = {}\\n if emb_name == 'yelp_electronics':\\n with open(path) as fp:\\n for line in fp:\\n word_vector = line.split(\\\",\\\")[:-1]\\n vector_list = []\\n for element in word_vector[len(word_vector) - 100:]:\\n vector_list.append(float(element))\\n word = ','.join(word_vector[:len(word_vector) - 100])\\n vector = np.asarray(vector_list)\\n if word in vocab:\\n raw_embeddings[word] = vector\\n else:\\n with open(path) as fp:\\n for line in fp:\\n eles = line.strip().split(' ')\\n word = eles[0]\\n if word in vocab:\\n raw_embeddings[word] = eles[1:]\\n\\n dim_w = len(raw_embeddings['the'])\\n n_words = len(vocab)\\n embeddings = np.zeros(shape=(n_words, dim_w))\\n for w in vocab:\\n wid = vocab[w]\\n if w in raw_embeddings:\\n embeddings[wid] = np.array([float(ele) for ele in raw_embeddings[w]])\\n else:\\n # for OOV words, add random initialization\\n embeddings[wid] = np.random.uniform(-0.25, 0.25, dim_w)\\n print(\\\"Find %s word embeddings...\\\" % len(embeddings))\\n if not os.path.exists('./work/embeddings'):\\n os.mkdir('./work/embeddings')\\n emb_path = './work/embeddings/%s_%s_%s.pkl' % (source_domain, target_domain, emb_name)\\n # write the embedding weights back to the disk\\n pickle.dump(embeddings, open(emb_path, 'wb'))\\n embeddings = np.array(embeddings, dtype='float32')\\n return embeddings\",\n \"def batch_inference(question,context): \\n inputs = tokenizer(question, context, \\n return_tensors='pt', \\n truncation=True, \\n padding=True)\\n \\n # Move data to GPU\\n inputs = inputs.to(device)\\n \\n # Feed data through the model\\n with torch.no_grad():\\n outputs = model(**inputs)\\n\\n # Q&A model outputs the two logit scores for each word.\\n # One for its chance of being the start of the answer\\n # and one for its chance of being the end\\n start_logits = outputs.start_logits\\n end_logits = outputs.end_logits\\n \\n # Find the words with the highest score\\n # argmax(dim=1) means argmax with each sample\\n start = start_logits.argmax(dim=1)\\n end = end_logits.argmax(dim=1)\\n \\n # Return the answers\\n # This is the point where we move the prediction back to main memory with .cpu()\\n tokens = [tokenizer.convert_ids_to_tokens(x) for x in inputs[\\\"input_ids\\\"].cpu().numpy()]\\n return [tokenizer.convert_tokens_to_string(x[start[i]:end[i]+1]) for i,x in enumerate(tokens)]\",\n \"def main():\\n logging.basicConfig(level=logging.DEBUG)\\n custom_embedding = True\\n\\n # Download embeddings'\\n if custom_embedding:\\n embedding_path = '../data/custom_embedding.pkl'\\n embedding_index_path = '../data/custom_vocab_index.pkl'\\n logging.info('Pulling custom embedding from: {}, and custom vocab from: {}'.format(embedding_path, embedding_index_path))\\n embedding_matrix = pickle.load(open(embedding_path, 'rb'))\\n embedding_index_lookup = pickle.load(open(embedding_index_path, 'rb'))\\n\\n else:\\n logging.warning('Downloading embedding. If downloading for the first time, this make take 5-10 minutes.')\\n embedding_url = 'https://s3.amazonaws.com/dl4j-distribution/GoogleNews-vectors-negative300.bin.gz'\\n embedding_path = '~/nlp_example/'\\n embedding_filename = 'GoogleNews-vectors-negative300.bin.gz'\\n lib.download_file(embedding_url, embedding_path, embedding_filename)\\n\\n # Unpack embedding\\n model = gensim.models.KeyedVectors.load_word2vec_format(embedding_path + '/' + embedding_filename, binary=True)\\n embedding_matrix = model.syn0\\n embedding_index_lookup = dict([(k, v.index) for k, v in model.vocab.items()])\\n\\n # Create thesaurus\\n thesaurus = Thesaurus(embedding_matrix, embedding_index_lookup)\\n\\n # Find nearest neighbors for examples\\n print(thesaurus.synonyms('day'))\\n print(thesaurus.synonyms('top'))\\n print(thesaurus.synonyms('bottom'))\\n print(thesaurus.synonyms('cat'))\\n print(thesaurus.synonyms('grown'))\\n\\n\\n pass\",\n \"def get_embeddings(emb_path, emb_length, vocab_size, embedding_type):\\n print(\\\"Loading {} embeddings from file: {}...\\\".format(embedding_type, emb_path))\\n\\n emb_matrix = []\\n str2id = {}\\n idx = 0\\n with open(emb_path, 'r') as fh:\\n for line in tqdm(fh, total=vocab_size):\\n line = line.lstrip().rstrip().split(\\\" \\\")\\n word = line[0]\\n vector = list(map(float, line[1:]))\\n if emb_length != len(vector):\\n raise Exception(\\n \\\"{}: Expected vector of size {}, but got vector of size {}.\\\".format(idx, emb_length, len(vector)))\\n emb_matrix.append(vector)\\n str2id[word] = idx\\n idx += 1\\n\\n emb_matrix = np.array(emb_matrix, dtype=np.float32)\\n print(\\\"Loaded {} embedding matrix with shape {}.\\\".format(embedding_type, emb_matrix.shape))\\n\\n return emb_matrix, str2id\",\n \"def _manifold_to_dataspace(self, X_embedded):\\n\\n if self.A.shape[1] != X_embedded.shape[0]:\\n X_embedded = X_embedded.T\\n\\n X_query_kd = self.A @ X_embedded[self.n_keep_dims:]\\n X_query_kd = X_query_kd.T # make X_query_kd of shape (q x d)\\n\\n # concatenate column-wise\\n if self.n_keep_dims > 0:\\n X_query = np.hstack((X_embedded[:self.n_keep_dims], X_query_kd))\\n else:\\n X_query = X_query_kd\\n\\n X_query = self._unscale(X_query)\\n return X_query\",\n \"def generate_embeddings_memory(dataset_path, classes):\\n # get embeddings not in generators\\n model = embeddings(INPUT_DIM)\\n X_train, X_test, y_train, y_test = get_train_test_lists(dataset_path, classes)\\n X_train_em = []\\n X_test_em = []\\n\\n for im in X_train:\\n img = preprocess_image(im)\\n embeds = model.predict(img)\\n embeds = np.squeeze(embeds)\\n X_train_em.append(embeds)\\n for im in X_test:\\n img = preprocess_image(im)\\n embeds = model.predict(img)\\n embeds = np.squeeze(embeds)\\n X_test_em.append(embeds)\\n return np.array(X_train_em), np.array(X_test_em), np.array(y_train), np.array(y_test)\",\n \"def embed_sent(self, x: Any) -> expression_seqs.ExpressionSequence:\\n # single mode\\n if not batchers.is_batched(x):\\n expr = expression_seqs.ExpressionSequence(expr_list=[self.embed(word) for word in x])\\n # minibatch mode\\n elif type(self) == LookupEmbedder:\\n embeddings = []\\n for word_i in range(x.sent_len()):\\n batch = batchers.mark_as_batch([single_sent[word_i] for single_sent in x])\\n embeddings.append(self.embed(batch))\\n expr = expression_seqs.ExpressionSequence(expr_list=embeddings, mask=x.mask)\\n else:\\n assert type(x[0]) == sent.SegmentedSentence, \\\"Need to use CharFromWordTextReader for non standard embeddings.\\\"\\n embeddings = []\\n all_embeddings = []\\n for sentence in x:\\n embedding = []\\n for i in range(sentence.len_unpadded()):\\n embed_word = self.embed(sentence.words[i])\\n embedding.append(embed_word)\\n all_embeddings.append(embed_word)\\n embeddings.append(embedding)\\n # Useful when using dy.autobatch\\n dy.forward(all_embeddings)\\n all_embeddings.clear()\\n # Pad the results\\n expr = batchers.pad_embedding(embeddings)\\n\\n return expr\",\n \"def predict(self, content):\\n input_x = list(content)\\n while len(input_x) < self.args.maxlen1: input_x.append('<pad>')\\n input_x = input_x[:self.args.maxlen1]\\n\\n input_x = [self.token2idx.get(s, self.token2idx['<unk>']) for s in input_x]\\n\\n memory = self.sess.run(self.memory, feed_dict={self.input_x: [input_x]})\\n\\n return self.bs.search(self.sess, input_x, memory[0])\",\n \"def learn_from_memory():\\n\\n # Get a random minibatch from the replay memory and learns from it.\\n if agent.memory.size > args.batch_size:\\n s1, a, s2, isterminal, r = agent.memory.get_sample(args.batch_size)\\n\\n q = agent.get_q_values(s2).cpu().data.numpy()\\n q2 = np.max(q, axis=1)\\n\\n target_q = agent.get_q_values(s1).cpu().data.numpy()\\n # target differs from q only for the selected action. The following means:\\n # target_Q(s,a) = r + gamma * max Q(s2,_) if isterminal else r\\n\\n target_q[np.arange(target_q.shape[0]), a] = r + args.discount_factor * (1 - isterminal) * q2\\n learn(s1, target_q)\",\n \"def in_storage(query,k,m):\\n bools = []\\n for i in range(1,k+1):\\n bools.append(bfilter[mmh3.hash(query,i)%m])\\n return np.prod(bools)\",\n \"def embed(x, phase):\\r\\n\\r\\n is_train = True if phase == 'train' else False\\r\\n\\r\\n # Input embedding: convert input vector to dimension of hp.hidden_units.\\r\\n embs = input_embedding(x, num_units=hp.hidden_units, embed_type=hp.embed_type)\\r\\n print('Size after input embedding: ', embs.get_shape())\\r\\n\\r\\n # Positional Encoding.\\r\\n embs += embedding(tf.tile(tf.expand_dims(tf.range(tf.shape(x)[1]), 0), [tf.shape(x)[0], 1]),\\r\\n vocab_size=hp.win_len, num_units=hp.hidden_units,\\r\\n zero_pad=False, scale=False, scope=\\\"enc_pe\\\")\\r\\n print(\\\"Size after positional encoding: \\\", embs.get_shape())\\r\\n\\r\\n # Attention blocks.\\r\\n for i in range(hp.num_blocks):\\r\\n with tf.variable_scope(\\\"num_blocks_{}\\\".format(i)):\\r\\n # Multi-head Attention\\r\\n embs = multihead_attention(queries=embs, keys=embs, num_units=hp.hidden_units,\\r\\n num_heads=hp.num_heads, dropout_rate=hp.dropout_rate,\\r\\n is_training=is_train, causality=False)\\r\\n\\r\\n # Feed Forward\\r\\n embs = feedforward(embs, num_units=[2 * hp.hidden_units, hp.hidden_units])\\r\\n print(\\\"Size after multi-head_attention: \\\", embs.get_shape())\\r\\n\\r\\n # Temporal pooling by averaging on the time dimension.\\r\\n embs = tf.reduce_mean(embs, axis=1)\\r\\n\\r\\n return embs\",\n \"def pass_word(word, model, input_embedding, char2idx, device, use_head=True):\\n inp = torch.LongTensor([char2idx['START']] + [char2idx[c] for c in word]).to(device)\\n inp = pack([inp])\\n out, hidden = model(input_embedding.unsqueeze(0), inp, use_head=use_head)\\n return out, hidden\",\n \"def extract_argmax_and_embed(embedding, output_projection=None):\\n def loop_function(prev, _):\\n if output_projection is not None:\\n prev = tf.matmul(prev, output_projection[0]) + output_projection[1]\\n prev_symbol = tf.argmax(prev, 1) #得到对应的INDEX\\n emb_prev = tf.gather(embedding, prev_symbol) #得到这个INDEX对应的embedding\\n return emb_prev\\n return loop_function\",\n \"def retrieve(self, query, posting_encodings=util.CompressedPostings):\\n if len(self.term_id_map) == 0 or len(self.doc_id_map) == 0:\\n self.load()\\n\\n ### Begin your code\\n words = query.split()\\n iim = ii.InvertedIndexMapper('data', directory=self.output_dir, postings_encoding=posting_encodings)\\n tid = self.term_id_map.__getitem__(words[0])\\n ans = iim.__getitem__(tid)\\n for i in range(1, len(words)):\\n tid = self.term_id_map.__getitem__(words[i])\\n ans = self.sorted_intersect(ans, iim.__getitem__(tid))\\n for i in range(0, len(ans)):\\n ans[i] = self.doc_id_map.__getitem__(ans[i])\\n return ans\\n ### End your code\",\n \"def test_embedding_attend(self):\\n features = 5\\n embed = layers.Embed(num_embeddings=10, features=features)\\n inputs = np.array([[1]], dtype=np.int64)\\n variables = embed.init(jax.random.PRNGKey(0), inputs)\\n query = np.ones(features, dtype=np.float32)\\n result = embed.apply(variables, query, method=embed.attend)\\n expected = np.sum(variables['params']['embedding'], -1)\\n np.testing.assert_array_almost_equal(result, expected)\",\n \"def embed(self,ipa_seg):\\n pre_embedded = self.to_phoible_fts(ipa_seg)\\n return np.matmul(PhonologicalEmbedding.__embedding_matrix,pre_embedded)\",\n \"def _get_embedding(self, data):\\n embedding_list = [super()._get_embedding(data)]\\n context = data['context']\\n for i in range(context.shape[1]):\\n embedding_list.append(getattr(self, f'context{i}')(context[:, i:i+1]))\\n return torch.cat(embedding_list, dim=1)\",\n \"def qlist_to_vec(self, max_length, q_list):\\n qvec = np.zeros(max_length)\\n embed_matrix = None\\n if self.use_embed:\\n embed_matrix = np.zeros((max_length, EMBEDDING_SIZE))\\n \\\"\\\"\\\" pad on the left \\\"\\\"\\\"\\n # for i in range(max_length):\\n # if i < max_length - len(q_list):\\n # cvec[i] = 0\\n # else:\\n # w = q_list[i-(max_length-len(q_list))]\\n # # is the word in the vocabulary?\\n # if self.qdict.has_key(w) is False:\\n # w = ''\\n # qvec[i] = self.qdict[w]\\n # cvec[i] = 0 if i == max_length - len(q_list) else 1\\n \\\"\\\"\\\" pad on the right \\\"\\\"\\\"\\n for i in range(len(q_list)):\\n w = q_list[i]\\n if self.use_embed:\\n if w not in self.embed_dict:\\n self.embed_dict[w] = self.nlp(u'%s' % w).vector\\n embed_matrix[i] = self.embed_dict[w]\\n\\n if w not in self.qdict:\\n w = ''\\n qvec[i] = self.qdict[w]\\n return qvec, embed_matrix\",\n \"def _embed(self):\\n batch_size = tf.shape(self.p)[0]\\n with tf.variable_scope(\\\"emb\\\"):\\n with tf.variable_scope(\\\"char\\\"):\\n pc_emb = tf.reshape(tf.nn.embedding_lookup(\\n self.char_embed, self.pc), \\n [batch_size * self.max_p_len, self.max_w_len, self.vocab.char_embed_dim])\\n qc_emb = tf.reshape(tf.nn.embedding_lookup(\\n self.char_embed, self.qc), \\n [batch_size * self.max_q_len, self.max_w_len, self.vocab.char_embed_dim])\\n cell_fw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\\n cell_bw = tf.contrib.rnn.GRUCell(self.char_hidden_size)\\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, pc_emb, self.pc_length, dtype=tf.float32)\\n pc_emb = tf.concat([state_fw, state_bw], axis=1)\\n _, (state_fw, state_bw) = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, qc_emb, self.qc_length, dtype=tf.float32)\\n qc_emb = tf.concat([state_fw, state_bw], axis=1)\\n pc_emb = tf.reshape(pc_emb, [batch_size, self.max_p_len, 2 * self.char_hidden_size])\\n qc_emb = tf.reshape(qc_emb, [batch_size, self.max_q_len, 2 * self.char_hidden_size])\\n\\n with tf.name_scope(\\\"word\\\"):\\n p_emb = tf.nn.embedding_lookup(self.word_embed, self.p)\\n q_emb = tf.nn.embedding_lookup(self.word_embed, self.q)\\n\\n with tf.name_scope(\\\"pos\\\"):\\n p_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.p_pos)\\n q_pos_emb = tf.nn.embedding_lookup(self.pos_embed, self.q_pos)\\n \\n with tf.name_scope(\\\"em\\\"):\\n sh = tf.shape(self.p_em)\\n resh = [sh[0], sh[1], 1]\\n p_em_feat = tf.reshape(tf.cast(self.p_em, dtype=tf.float32), shape=resh)\\n\\n self.p_emb = tf.concat([p_emb, pc_emb, p_pos_emb, p_em_feat], axis=2)\\n self.q_emb = tf.concat([q_emb, qc_emb, q_pos_emb], axis=2)\",\n \"def _find_embeddings(snlp):\\n embs = None\\n for proc in snlp.processors.values():\\n if hasattr(proc, \\\"pretrain\\\") and isinstance(proc.pretrain, Pretrain):\\n embs = proc.pretrain\\n break\\n return embs\",\n \"def forward(self, input_sentence):\\n sentence = self.word_embedding(input_sentence)\\n embedding = self.encoder(sentence)\\n return embedding\",\n \"def get_embedding():\\n\\n HOST = app.config.get('EMBEDDING_HOST')\\n PORT = app.config.get('EMBEDDING_PORT')\\n query_params = {\\n 'text' : request.args.get('text', \\\"\\\"),\\n \\\"language\\\" : request.args.get('language', None)\\n }\\n r = requests.get(f\\\"http://{HOST}:{PORT}/api/v1/embeddings/create\\\", params=query_params)\\n return jsonify(r.json())\",\n \"def embed(self, x):\\n if self.embedding is None:\\n return x\\n else:\\n return self.embedding(x)\",\n \"def compute_user_input_embedding(txt, model):\\r\\n embeddings = []\\r\\n tokens = txt.split(\\\" \\\")\\r\\n for word in tokens:\\r\\n embeddings.append(model.wv[word])\\r\\n sentence_embedding = compute_average(embeddings)\\r\\n return sentence_embedding\",\n \"def _embed_result(self, embedding):\\n # project original embedding\\n project_weight = self.project.weight # (o, c)\\n project_embedding = embedding.permute(0, 2, 1).unsqueeze(-1) \\\\\\n * project_weight.permute(1, 0) # (n, e, c, 1) * (c, o) -> (n, e, c, o)\\n project_embedding = project_embedding.permute(0, 3, 2, 1) # (n, o, c, e)\\n # interaction\\n square_of_sum = torch.sum(project_embedding, dim=2) ** 2\\n sum_of_square = torch.sum(project_embedding ** 2, dim=2)\\n embed_result = 0.5 * (square_of_sum - sum_of_square).sum(dim=2)\\n return embed_result\",\n \"def pretrained_embedding_layer(model,model2,model3, word_to_index,emb_dim_max):\\n words_ignored = []\\n vocab_len = len(word_to_index) + 1 \\n emb_matrix = np.zeros([vocab_len,emb_dim_max])\\n \\n print(' Total words would be processed : '+str(vocab_len))\\n for word, idx in word_to_index.items():\\n if word in model:\\n emb_matrix[idx,:200] = model[word]\\n emb_matrix[idx,200:] = 0\\n if word in model2:\\n emb_matrix[idx, :100] = model2[word]\\n emb_matrix[idx, 100:] = 0\\n if word in model3.keys():\\n emb_matrix[idx,:] = model3[word]\\n else:\\n words_ignored.append(word)\\n print(str(len(words_ignored))+\\\" words ignored\\\")\\n print(emb_matrix.shape) \\n \\n \\n embedding_layer = Embedding(vocab_len,emb_dim_max,trainable = True)\\n \\n # Build the embedding layer, it is required before setting the weights of the embedding layer. \\n embedding_layer.build((None,)) # Do not modify the \\\"None\\\". This line of code is complete as-is.\\n # Set the weights of the embedding layer to the embedding matrix. Your layer is now pretrained.\\n embedding_layer.set_weights([emb_matrix])\\n \\n return embedding_layer,words_ignored\",\n \"def key_value_rte(placeholders, nvocab, **options):\\n\\n # [batch_size, max_seq1_length]\\n premise = placeholders['question']\\n # [batch_size]\\n premise_lengths = placeholders[\\\"question_lengths\\\"]\\n # [batch_size, max_seq2_length]\\n hypothesis = placeholders[\\\"support\\\"]\\n # [batch_size]\\n hypothesis_lengths = placeholders[\\\"support_lengths\\\"]\\n # [batch_size]\\n targets = placeholders[\\\"answers\\\"]\\n\\n output_size = options[\\\"repr_dim_output\\\"]\\n\\n with tf.variable_scope(\\\"embedders\\\") as varscope:\\n premise_embedded = nvocab(premise)\\n varscope.reuse_variables()\\n hypothesis_embedded = nvocab(hypothesis)\\n\\n # todo: add option for attentive reader\\n\\n print('TRAINABLE VARIABLES (only embeddings): %d' % get_total_trainable_variables())\\n\\n with tf.variable_scope(\\\"key_value_readers\\\") as varscope:\\n premise_outputs, _ = \\\\\\n key_value_reader(premise_embedded, premise_lengths, output_size,\\n contexts=(None, None), scope=None,\\n drop_keep_prob=options[\\\"drop_keep_prob\\\"],\\n project_fw_bw=True)\\n varscope.reuse_variables()\\n hypothesis_outputs, _ = \\\\\\n key_value_reader(hypothesis_embedded, hypothesis_lengths, output_size,\\n contexts=(None, None), scope=None,\\n drop_keep_prob=options[\\\"drop_keep_prob\\\"],\\n project_fw_bw=True)\\n\\n # Reading premise with memory of hypothesis\\n #premise_outputs_processed, premise_state = mutable_attention(\\n # hypothesis_outputs, premise_outputs[0], premise_lengths, output_size, scope=varscope)\\n #varscope.reuse_variables()\\n\\n # Reading hypothesis with memory of premise and altered memory of hypothesis\\n hypothesis_outputs_processed, hypothesis_state = mutable_attention(\\n premise_outputs, hypothesis_outputs[0], hypothesis_lengths, output_size)\\n\\n # todo: read premise and hypothesis memory for inferring entailment class\\n\\n # fixme: last can be zero because of dynamic_rnn!\\n #output = hypothesis_outputs[0][:, -1, :]\\n\\n output = hypothesis_state.h\\n\\n #targets = tf.Print(targets, [tf.shape(targets)], \\\"targets \\\")\\n #output = tf.Print(output, [tf.shape(output)], \\\"outputs \\\")\\n\\n logits, loss, predict = predictor(output, targets, options[\\\"answer_size\\\"])\\n\\n print('TRAINABLE VARIABLES (embeddings + model): %d' % get_total_trainable_variables())\\n print('ALL VARIABLES (embeddings + model): %d' % get_total_variables())\\n\\n return logits, loss, predict\",\n \"def prepare_word_emb_matrices(experiment):\\r\\n\\r\\n with open(\\\"public_data/stats/stats_train.pkl\\\", 'rb') as stats:\\r\\n stats = pickle.load(stats)\\r\\n vocab = stats[\\\"VOCAB\\\"]\\r\\n stops = [word.lower() for word in set(stopwords.words('english'))]\\r\\n vocab = vocab + stops\\r\\n\\r\\n if experiment == \\\"RANDOM\\\":\\r\\n word_embs = np.random.uniform(low=-1.0, high=1.0, size=(len(vocab), PARAMS[\\\"SIZE\\\"])).astype(\\\"float32\\\")\\r\\n\\r\\n else:\\r\\n word_embs = []\\r\\n count_unk = 0\\r\\n count_kn = 0\\r\\n\\r\\n if experiment == \\\"5\\\":\\r\\n emb_model = KeyedVectors.load_word2vec_format(\\\"public_data/models/experiment_5/embeddings_5.bin\\\",\\r\\n binary=True)\\r\\n elif experiment == \\\"6\\\":\\r\\n emb_model = Word2Vec.load(\\\"public_data/models/experiment_6/embeddings_6\\\")\\r\\n\\r\\n elif experiment in [\\\"7\\\", \\\"8\\\"]:\\r\\n emb_model = FastText.load_fasttext_format(\\\"public_data/models/experiment_%s/embeddings_%s.bin\\\"\\r\\n %(experiment, experiment))\\r\\n for word in vocab:\\r\\n if word in emb_model:\\r\\n word_embs.append(emb_model[word])\\r\\n count_kn += 1\\r\\n else:\\r\\n word_embs.append(np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\\\"SIZE\\\"]))\\r\\n count_unk += 1\\r\\n\\r\\n word_embs = np.array(word_embs).astype(\\\"float32\\\")\\r\\n print(count_unk / (count_kn + count_unk))\\r\\n\\r\\n pad = np.zeros(shape=PARAMS[\\\"SIZE\\\"]).astype(\\\"float32\\\")\\r\\n unk = np.random.uniform(low=-1.0, high=1.0, size=PARAMS[\\\"SIZE\\\"]).astype(\\\"float32\\\")\\r\\n word_embs = np.insert(word_embs, 0, unk, axis=0) #id 1\\r\\n word_embs = np.insert(word_embs, 0, pad, axis=0) #id 0\\r\\n\\r\\n with open(\\\"public_data/embeddings/word_embeddings_%s.pkl\\\" %experiment, 'wb') as out:\\r\\n pickle.dump(word_embs, out, protocol=4)\\r\\n\\r\\n return word_embs\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63078344","0.63063365","0.5960762","0.5928939","0.58945125","0.58742183","0.58714825","0.5823085","0.5794332","0.5751944","0.56750214","0.5587403","0.55768526","0.557125","0.5565566","0.5550268","0.5541789","0.5470685","0.5447556","0.54236406","0.5408294","0.5406469","0.5401259","0.5401143","0.5399215","0.5390409","0.538824","0.5385703","0.53731626","0.5358136","0.53569955","0.5349093","0.53242904","0.5321162","0.53182375","0.53176296","0.53133196","0.53075445","0.5294047","0.5291328","0.5291302","0.5283683","0.5278032","0.526622","0.52629006","0.5260308","0.5257134","0.5254715","0.5242012","0.52412045","0.52362627","0.5235791","0.5233309","0.52268565","0.52212095","0.5219294","0.5215402","0.521461","0.5208321","0.5206381","0.5205729","0.52030784","0.5191762","0.5187983","0.5183975","0.51789355","0.51756006","0.51707953","0.51659125","0.51650363","0.5142958","0.5140779","0.51387936","0.51237893","0.51199746","0.5111408","0.5110101","0.5108419","0.5107285","0.5102167","0.509658","0.5095546","0.50929123","0.50882405","0.5083063","0.507573","0.5073719","0.5069717","0.5066229","0.50653565","0.5055454","0.50553954","0.5054193","0.50496876","0.5049383","0.50487447","0.5040577","0.5038215","0.5033358"],"string":"[\n \"0.63078344\",\n \"0.63063365\",\n \"0.5960762\",\n \"0.5928939\",\n \"0.58945125\",\n \"0.58742183\",\n \"0.58714825\",\n \"0.5823085\",\n \"0.5794332\",\n \"0.5751944\",\n \"0.56750214\",\n \"0.5587403\",\n \"0.55768526\",\n \"0.557125\",\n \"0.5565566\",\n \"0.5550268\",\n \"0.5541789\",\n \"0.5470685\",\n \"0.5447556\",\n \"0.54236406\",\n \"0.5408294\",\n \"0.5406469\",\n \"0.5401259\",\n \"0.5401143\",\n \"0.5399215\",\n \"0.5390409\",\n \"0.538824\",\n \"0.5385703\",\n \"0.53731626\",\n \"0.5358136\",\n \"0.53569955\",\n \"0.5349093\",\n \"0.53242904\",\n \"0.5321162\",\n \"0.53182375\",\n \"0.53176296\",\n \"0.53133196\",\n \"0.53075445\",\n \"0.5294047\",\n \"0.5291328\",\n \"0.5291302\",\n \"0.5283683\",\n \"0.5278032\",\n \"0.526622\",\n \"0.52629006\",\n \"0.5260308\",\n \"0.5257134\",\n \"0.5254715\",\n \"0.5242012\",\n \"0.52412045\",\n \"0.52362627\",\n \"0.5235791\",\n \"0.5233309\",\n \"0.52268565\",\n \"0.52212095\",\n \"0.5219294\",\n \"0.5215402\",\n \"0.521461\",\n \"0.5208321\",\n \"0.5206381\",\n \"0.5205729\",\n \"0.52030784\",\n \"0.5191762\",\n \"0.5187983\",\n \"0.5183975\",\n \"0.51789355\",\n \"0.51756006\",\n \"0.51707953\",\n \"0.51659125\",\n \"0.51650363\",\n \"0.5142958\",\n \"0.5140779\",\n \"0.51387936\",\n \"0.51237893\",\n \"0.51199746\",\n \"0.5111408\",\n \"0.5110101\",\n \"0.5108419\",\n \"0.5107285\",\n \"0.5102167\",\n \"0.509658\",\n \"0.5095546\",\n \"0.50929123\",\n \"0.50882405\",\n \"0.5083063\",\n \"0.507573\",\n \"0.5073719\",\n \"0.5069717\",\n \"0.5066229\",\n \"0.50653565\",\n \"0.5055454\",\n \"0.50553954\",\n \"0.5054193\",\n \"0.50496876\",\n \"0.5049383\",\n \"0.50487447\",\n \"0.5040577\",\n \"0.5038215\",\n \"0.5033358\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6070764"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":94494,"cells":{"query":{"kind":"string","value":"Add entries to the memory module."},"document":{"kind":"string","value":"def add_entry(self, embeddings, labels, query_result=None):\n n_added = embeddings.shape[0]\n class_discount = self.class_discount\n for embedding, label in zip(embeddings, labels):\n n = self.n_class_embeddings[label]\n if self.class_discount_method == \"mean\":\n class_discount = 1 / (n + 1)\n self.class_representations[label] = (1 - class_discount) * self.class_representations[label] \\\n + class_discount * embedding\n self.n_class_embeddings[label] += 1\n\n self.added_memories += n_added"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def add_memory(self, **kwarg):\n for name, obs in kwarg.items():\n self.buffers[name] = np.concatenate((self.buffers[name], obs), axis=0)\n # get recent memory\n return self","def record_memory_map(self):\n memory_map = self.get_memory_map()\n self._memory_map_records.append(memory_map)","def init_memory(self, address, values):\n for value in values: # writing 1 byte at a time\n self.set_memory(address, value)\n address = address + 1","def store_memory(memory, history, action, reward, next_history, dead):\n memory.append((history, action, reward, next_history, dead))","def appendProcess(self, pid: int, numberOfVariables: int, processTable, diagnostics) -> int:\n self.memory[pid] = []\n\n for _i in range(numberOfVariables):\n self.memory[pid].append(MemoryItem())\n\n return 0","def append(self, metaball):\n\n self.mbs.append(metaball)","def add_entries(self, entries):\n write_p = self._pointer\n for entry in entries:\n write_header(write_p, entry._entry_p)\n for block in entry.get_blocks():\n write_data(write_p, block, len(block))\n write_finish_entry(write_p)","def allocatememory(self):\n\n for key, value in self._dentsvertsdata.items():\n value.allocatememory()","def store_replay_memory(self, history, action, reward, next_history, dead):\n self.memory.append((history, action, reward, next_history, dead))","def __init__(self):\r\n self.__memory = []","def set_memory_map(self):\n sorted_list_tuple = sorted([(key, value) for key, value in \n self._page_map.iteritems() if value >= 0], \n key=lambda pair: pair[1])\n self._memory_map = [pair[0] for pair in sorted_list_tuple]","def set_memory_map(self):\n sorted_list_tuple = sorted([(key, value) for key, value in \n self._page_map.iteritems() if value[0] >= 0], \n key=lambda pair: pair[1])\n self._memory_map = [pair[0] for pair in sorted_list_tuple]","def add_entries(self, *entries: Entry):\n for entry in entries:\n self.add_entry(entry)","def allocatememory(self, key):\n self._dentsvertsdata[key].allocatememory()","def __init__(self):\n self.memory = {}\n self.sum_ = {}","def add_entry(self, embeddings, labels, query_result=None):\n n_added = embeddings.shape[0]\n\n if self.added_memories + n_added <= self.memory_size:\n start = self.write_pointer + 1\n end = start + n_added\n self.update_ixs(range(start, end), embeddings, labels, query_result)\n self.write_pointer += n_added\n else:\n capacity_remaining = max(self.memory_size - self.added_memories, 0)\n if capacity_remaining > 0:\n start = self.write_pointer + 1\n self.update_ixs(range(start, self.memory_size), embeddings[:capacity_remaining], labels[:capacity_remaining],\n query_result, global_update=False)\n\n n_overflow = n_added - capacity_remaining\n # get least relevant indices\n if self.delete_method == \"relevance\":\n write_ixs = torch.topk(self.memory_relevance, n_overflow, largest=False).indices\n elif self.delete_method == \"age\":\n write_ixs = torch.topk(self.memory_age, n_overflow, largest=True).indices\n self.update_ixs(write_ixs, embeddings[capacity_remaining:], labels[capacity_remaining:], query_result)\n self.added_memories += n_added","def addEntries(self, rewardPoolId, data):\n resource = '/rewardPool/%s' % str(rewardPoolId)\n for d in [data[i:i + DEFAULT_CHUNK]\n for i in range(0, len(data), DEFAULT_CHUNK)]:\n param = [('entry', x,) for x in d]\n self.post(resource, param)","def _memory(self):\n memory = {}\n memory_used = cpmCPUMemoryUsed\n varbinds = self._snmp_connection.bulk_walk(memory_used)\n for varbind in varbinds:\n # grab the last element of the index to use as the memory_id\n if self._cisco_model in self._n3k_models:\n memory_id = self._process_mib_indices_table[int(varbind.index.split('.')[-1])]\n else:\n memory_id = int(varbind.index.split('.')[-1])\n memory[memory_id] = {u'memory_used': int(varbind.value)}\n\n memory_free = cpmCPUMemoryFree\n varbinds = self._snmp_connection.bulk_walk(memory_free)\n for varbind in varbinds:\n # grab the last element of the index to use as the memory_id\n if self._cisco_model in self._n3k_models:\n memory_id = self._process_mib_indices_table[int(varbind.index.split('.')[-1])]\n else:\n memory_id = int(varbind.index.split('.')[-1])\n memory[memory_id][u'memory_free'] = int(varbind.value)\n memory[memory_id][u'memory_total'] = memory[memory_id][u'memory_used'] + int(varbind.value)\n\n for memory_id in list(memory.keys()):\n if memory_id in self._module_numbers:\n if int(self._module_numbers[memory_id]) in self._entity_physical_names:\n memory[memory_id][u'memory_type'] = u\"Module {} ({})\".format(self._module_numbers[memory_id],\n self._entity_physical_names[\n int(self._module_numbers[memory_id])])\n else:\n memory[memory_id][u'memory_type'] = u\"Module {}\".format(self._module_numbers[memory_id])\n\n if not len(memory):\n self._logger.warn(\n u'Failed to get memory enrichments on device \"%s\" with model \"%s\"' %\n (self._device_fqdn, self._cisco_model))\n\n return memory","def initiate_memory(self):\n rows = constants.WINDOW_HEIGHT / constants.GRID_TILE_LENGTH\n cols = constants.WINDOW_WIDTH / constants.GRID_TILE_LENGTH\n self.memory = [[None for x in xrange(cols)] for x in xrange(rows)]","def add_memory(self, state, action, reward, next_state, is_done):\r\n for state_i, action_i, reward_i, next_state_i, is_done_i, ER_i in zip(state, action, reward, next_state,\r\n is_done, self.ER_array):\r\n ER_i.add_memory(state_i, action_i, reward_i, next_state_i, is_done_i)","def add_to_memory(count):\n\t\tSimulation.past_attendance.append(count)\n\t\tPerson.add_to_memory(count)\n\t\tSimulation.simulation_progression.write(str(Person.recent_memory))\n\t\tSimulation.simulation_progression.write(\"\\n\")","def remember(self, memory):\n assert isinstance(memory, dict)\n\n for name in self.names:\n assert name in memory\n self.meomries[name].append(memory[name])","def allocatememory(self):\n self._numvertstotal = self._numents * self._nvet\n self._cords = VertDataSingleChannel(GLDataType.FLOAT, 3, self._numvertstotal)\n self._colors = VertDataSingleChannel(GLDataType.UBYTE, 4, self._numvertstotal)","async def cadd(self, ctx, *args: Input):\n await self.add(\n MemoryInputSet(MemoryInputSetConfig(ctx=ctx, inputs=list(args)))\n )\n return ctx","def load_mem_to_registers(self):\n register = (self.opcode & 0xFFF) >> 8\n for x in range(register+1):\n self.registers[x] = self.memory[self.I + x]\n logger.info(\n \"Loaded memory from {} to {} in registers till V{}\".format(\n hex(self.I),\n hex((self.I + register)),\n register))","async def register_system_shared_memory(\n self,\n name: str,\n key: str,\n byte_size: int,\n offset: int = ...,\n headers: dict[str, t.Any] = ...,\n ) -> None:","def pin_memory(self):\r\n\r\n self.points = [in_tensor.pin_memory() for in_tensor in self.points]\r\n self.neighbors = [in_tensor.pin_memory() for in_tensor in self.neighbors]\r\n self.pools = [in_tensor.pin_memory() for in_tensor in self.pools]\r\n self.upsamples = [in_tensor.pin_memory() for in_tensor in self.upsamples]\r\n self.lengths = [in_tensor.pin_memory() for in_tensor in self.lengths]\r\n self.features = self.features.pin_memory()\r\n\r\n return self","def memory_write(self, offset: int, data: List[int]) -> None:\n self.mem_extend(offset, len(data))\n self.memory[offset : offset + len(data)] = data","def allocatememory(self):\n pass","def add(a: int, b: int, c: int, memory: List) -> NoReturn:\n memory[c] = memory[a] + memory[b]","def add_to_buffer(self, values):\n self._buffer.extend(values)","def _add_to_memory(self, state, action, next_state, reward, done):\n if len(self.memory) >= self.size_max_memory:\n self.memory.pop(0)\n self.memory += [Transition(state, action, next_state, reward, done)]","def load_registers_in_memory(self):\n register = (self.opcode & 0xF00) >> 8\n for x in range(register+1):\n self.memory[self.I + x] = self.registers[x]\n logger.info(\"Loaded registers from V0 to V{} into {}\".format(\n register,\n hex(self.I)))","def ADD():\n global pointer, memory, registers\n registers[memory[pointer + 0x02]] += memory[pointer + 0x01]\n pointer += 0x03","def write_mem(self):\n request = 'commands/writemem'\n return self._post(request)","def _build_memorymap(self):\n\t\tmemorymap = {}\n\t\ttotalsize = 0\n\t\tbaserva = self.liststream64.DirectoryData.BaseRva\n\t\tmmdscrptr64 = self.liststream64.DirectoryData.MINIDUMP_MEMORY_DESCRIPTOR64\n\t\tnumberofmemoryranges = self.liststream64.DirectoryData.NumberOfMemoryRanges\n\t\tfor i in range(numberofmemoryranges):\n\t\t\tmemorymap[mmdscrptr64[i].StartOfMemoryRange] = ((baserva + totalsize),mmdscrptr64[i].DataSize)\n\t\t\ttotalsize += mmdscrptr64[i].DataSize\n\t\treturn memorymap","def appendedEntries(self):\n self.contact_list.append({\"name\": self.first_name.title() + \" \" + self.last_name.title(), \"phone number\": self.phone_number, \"phone number type\": self.phone_number_type})","def add(self, states, all_state, action, all_actions, reward, next_state, all_next_state, done):\n e = self.experience(states, all_state, action, all_actions, reward, next_state, all_next_state, done)\n self.memory.append(e)","def add_entry(self, entry): # Hashmap.add_entry\n\n if entry.hexdigest in self.contentHash:\n self.contentHash[entry.hexdigest].append(entry)\n else:\n self.contentHash[entry.hexdigest] = [ entry ]\n\n if entry.depth < self.minDepth:\n self.minDepth = entry.depth","def reset_memory(self):\n self.memory = []","def allocate(self, memo):\r\n raise NotImplementedError","def addChunk(self, direction):\n pass\n\n ## get size of actual map\n ## create array of fitting size\n ## stack created array to map","def restore_program(memory_updates: Dict[int, int], memory: List[int]) -> List[int]:\n for (index, new_value) in memory_updates.items():\n memory[index] = new_value\n return memory","def add(self, key, value):\n self._data.append(self._Item(key, value))\n self._upheap(len(self._data) - 1) # upheap newly added position","def addEntry(self, symbol, address):\n self.table[symbol] = address","def add(self, key, value):\n self._data.append(self._Item(key, value))\n self._upheap(len(self._data) - 1) # upheap newly added position","def append(self, data):\n if self._expand_mode:\n new_keys = set(data.keys()) - self.keys & self._keys\n self._expand(new_keys)\n self._cubas = None\n self._append(data)\n self._number_of_items += 1","def memory_plan(self, feed_shapes):\n assert (self.ctx is not None)\n self.node_to_arr_map = {}\n for node, shape in self.node_to_shape_map.items():\n self.node_to_arr_map[node] = ndarray.empty(shape, ctx=self.ctx)","def add(self, key, value):\n self._data.append(self._Item(key, value))\n self._up_heap(len(self) - 1)","def add_datamap(self, ctx, datamap):\n zing_state = self._get_zing_tx_state()\n zing_state.datamaps.append((ctx.device(), datamap))","def post(self):\n try:\n memory = parse_memory_from_request()\n self.logger.info(\"Adding memory for %s on %s\", memory.user_id, memory.memory_date)\n ds.add_memory(memory)\n\n # re-fetch the memory and return it in the response body\n added_memory = ds.get_memory(memory.user_id, memory.memory_date)\n return added_memory.to_dict(), 201\n except MyDeticMemoryAlreadyExists, mdmae:\n self.logger.info(\"Memory already exists on add (%s : %s)\", memory.user_id, memory.memory_date)\n return generate_error_json(mdmae)\n except MyDeticInvalidMemoryString, mdims:\n self.logger.info(\"Invalid memory string on add (%s)\" % mdims.msg)\n return generate_error_json(mdims)\n except MyDeticException, mde:\n return generate_error_json(mde)","def memory(self, memory):\n\n self._memory = memory","def populate_mem():\n global MemListing\n for item in memList:\n mem = \"%s\" % item[0]\n price = \"%s\" % item[1]\n \n try:\n MemListing.objects.get(memList = mem, memPrice = price)\n \n except MemListing.DoesNotExist:\n print mem\n mydb = MemListing.objects.create(memList = mem, memPrice = price)\n print mydb\n mydb.save()","def memory(kdump_memory):\n config_db = ConfigDBConnector()\n if config_db is not None:\n config_db.connect()\n config_db.mod_entry(\"KDUMP\", \"config\", {\"memory\": kdump_memory})","def add(self, record):\n self._hist_records[record.uid] = record","def store(self, state, action, reward, next_state, done):\n self.replay_memory.append((state, action, reward, next_state, done))","def _initialize_mem_buffs():\r\n args = get_args()\r\n\r\n # Initialize memory for checkpointed activations.\r\n if args.distribute_checkpointed_activations:\r\n mpu.init_checkpointed_activations_memory_buffer()\r\n mpu.init_workspace_memory_buffer()\r\n # mpu.init_forward_buffer()\r\n mpu.init_QKV_forward_buffer()\r\n mpu.init_QKV_dense_buffer()\r\n mpu.init_h4h_forward_buffer()\r\n mpu.init_fhh_forward_buffer()\r\n mpu.init_backward_buffer()\r\n mpu.init_parameter_gradient_buffer()\r\n mpu.init_conjunction_gradient_buffer()\r\n # if not args.ParallelTransformer_only:\r\n # mpu.init_lmhead_dense_buffer()","def update_memory(self, target, clues, guesses, winlose):\n immediate_rewards = self.get_trajectory_immediate_rewards(target, \n clues,\n guesses)\n \n self.memory.append((target, \n clues, \n guesses, \n winlose, \n immediate_rewards))","def build_and_add(self,*args):\n lattice = lattice_class.lattice(*args)\n self.lattices.append()\n self.meshfns.append(['in_memory'])","def appenddictitemsize(self, key, numents):\n self._dentsvertsdata[key].appendsize(numents * self._multFactor)","def remember(self, item):\n self.memory.append(item)","def load_mem_to_registers_quirk(self):\n register = (self.opcode & 0xFFF) >> 8\n for x in range(register+1):\n self.registers[x] = self.memory[self.I + x]\n self.I += register + 1\n logger.info(\n \"Loaded memory from {} to {} in registers till V{}\".format(\n hex(self.I),\n hex((self.I + register)),\n register))","def allocate(self, memo):\r\n for input in self.kit.sinputs:\r\n r = input.variable\r\n if r not in memo:\r\n input = copy(input)\r\n input.value = Container(r, storage = [None])\r\n memo[r] = input","def update_replay_memory(self, transition: Tuple[np.array, int, int,\r\n np.array, bool]) -> None:\r\n self.replay_memory.append(transition)","def add(self, datasetName, rows):\r\n\r\n rows = np.vstack(rows)\r\n\r\n\t\t# Add the sample into the buffer\r\n try:\r\n self.datasetBuffer[datasetName].extend(rows)\r\n except:\r\n # Initialize the buffer\r\n self.datasetBuffer[datasetName] = []\r\n self.datasetBuffer[datasetName].extend(rows)\r\n\r\n # Create the dataset\r\n self._createDatasets(datasetName)\r\n\r\n # Initiliaze dataset index count\r\n self.idxs[datasetName] = 0\r\n\r\n # Update the number of samples in the buffer\r\n self.totalFeatures += len(rows)\r\n\r\n\t\t# Check to see if we have reached the maximum buffer size\r\n if self.totalFeatures >= self.maxBufferSize:\r\n\r\n\t\t\t# write the buffers to file\r\n self._writeBuffers()","def handle_memory_reads(self, instr):\n reading_export_address = 0\n number_of_exports_read = 0\n dyn_import_pair = set()\n stat_import_pair = set()\n if self.use_trace_file == True:\n dynamic_values_read = self.get_dynamic_memory_reads(instr)\n for value in dynamic_values_read:\n if self.exported_modules.contains_address(value) == True:\n dll_name, function_name = self.exported_modules.get_dll_and_function(value)\n dyn_import_pair.add((dll_name, function_name, value))\n\n static_values_read = list(self.get_static_memory_read(instr))\n for value in static_values_read:\n if self.exported_modules.contains_address(value) == True:\n dll_name, function_name = self.exported_modules.get_dll_and_function(value)\n stat_import_pair.add((dll_name, function_name, value))\n\n combined_pairs = dyn_import_pair.union(stat_import_pair)\n if len(combined_pairs) == 1:\n if len(dyn_import_pair) == 1:\n for dll_name, function_name, value in dyn_import_pair:\n self.import_table.add_function(dll_name, function_name, 1, instr)\n instr.add_values_read(value)\n reading_export_address = 1\n\n if len(stat_import_pair) == 1:\n for dll_name, function_name, value in stat_import_pair:\n self.import_table.add_function(dll_name, function_name, 0, instr)\n instr.add_values_read(value)\n reading_export_address = 1\n\n if reading_export_address == 1:\n self.instructions_to_relocate.append(instr.address)","def feed(self, entry):\r\n if entry.name not in self.names:\r\n self.names[entry.name] = list()\r\n self.names[entry.name].append(entry)","def add(self, batch_size=10000):\n if self.N <= batch_size:\n self.index.add(self.database)\n else:\n [self.index.add(self.database[i:i + batch_size])\n for i in tqdm(range(0, len(self.database), batch_size),\n desc='[index] add')]","def __init__(self):\n super(MemoryPersistence, self).__init__(descriptor)","def MEM (self,n):","def update_memory(self, result):\r\n if (len(self.memory) >= self.memory_capacity):\r\n self.memory.pop(0)\r\n self.memory.append(result)\r\n else:\r\n self.memory.append(result)","def add_file_from_memory(\n self, entry_path, entry_size, entry_data,\n filetype=REGULAR_FILE,\n permission=DEFAULT_UNIX_PERMISSION\n ):\n archive_pointer = self._pointer\n\n with new_archive_entry() as archive_entry_pointer:\n archive_entry = ArchiveEntry(None, archive_entry_pointer)\n\n archive_entry.pathname = entry_path\n entry_set_size(archive_entry_pointer, entry_size)\n entry_set_filetype(archive_entry_pointer, filetype)\n entry_set_perm(archive_entry_pointer, permission)\n write_header(archive_pointer, archive_entry_pointer)\n\n for chunk in entry_data:\n if not chunk:\n break\n write_data(archive_pointer, chunk, len(chunk))\n\n write_finish_entry(archive_pointer)\n entry_clear(archive_entry_pointer)","def load_history_entries(self, *entries):\n # Simplified version:\n for entry in entries:\n try:\n self[entry.url.host] += [entry]\n except KeyError:\n self[entry.url.host] = [entry]\n \n \n temp_dict = {entry.url.host: [] for entry in entries} \n for entry in entries:\n temp_dict[entry.url.host] += [entry]\n\n # Update the dictionary\n # self.update(temp_dict) # Will override any lists with the same host name\n for host, entry in temp_dict.items():\n #try:\n self[host] += [entry]\n #except IndexError:\n #self[host] = [entry]","def buffer(self, entry):\n # TODO\n print(\"Storing {} in Redis.\".format(entry))\n\n # Redis list to store all ids of entities\n self._pipeline.rpush(\n self._list_name,\n '{}'.format(entry.id)\n )\n\n # Redis hash to store all attributes of entities\n hash_name = '{}:{}'.format(self._list_name, entry.id)\n hash_dict = {}\n field_names = list(entry.__all__)\n field_names.remove('id')\n for field_name in field_names:\n hash_dict[field_name] = getattr(entry, field_name)\n\n self._pipeline.hmset(hash_name, hash_dict)","def append(self, *items: BOSminer) -> None:\n for item in items:\n self.miners[item.ip] = item","def devClearAdd(self):\n #l = [0, 1, 2, 3, 4, 5, 6, 15, 47]\n l = [0, 1, 2, 3, 4, 5, 47]\n tTree, tHeap, tHash = 0, 0, 0\n self.devClearStores()\n for i in l:\n movie = Movie()\n movie.importFromString(self._data[i])\n print \"Adding movie '%s'...\" % ( movie.title )\n start = time.clock() * 1000000\n self.storeTree.insert(movie)\n end = time.clock() * 1000000\n tTree += end - start\n start = time.clock() * 1000000\n self.storeHeap.insert(movie)\n end = time.clock() * 1000000\n tHeap += end - start\n start = time.clock() * 1000000\n self.storeHash.insert(movie)\n end = time.clock() * 1000000\n tHash += end - start\n self.benchmarkDisplay.binarySearchTree.set(tTree)\n self.benchmarkDisplay.binaryHeap.set(tHeap)\n self.benchmarkDisplay.hashTable.set(tHash)\n self.benchmarkDisplay.binarySearchTreeDepth.set(self.storeTree.getDepth())\n self.benchmarkDisplay.binaryHeapDepth.set(self.storeHeap.getDepth())","def bookkeeping(episode_memory, reward_per_episode):\n\n states, actions, new_states, rewards, done = zip(*episode_memory)\n reward_per_episode.append(np.sum(rewards))","def offset_list(self):\n self.nodes.append(None)\n self.formulas.append(None)\n self.node_memory.append(None)\n self.formulas_memory.append(None)","def add_array(self, attr_name, data, dtype=None):\n if attr_name in self._shm_attr_names:\n raise ValueError(f'A Shared Memory array with the name {attr_name}\\\n is already in this ShmManager')\n _shm = SharedMemArrayManager(\n data=data, dtype=dtype)\n self._shm_attr_names.append(attr_name)\n setattr(self, attr_name, _shm)","def add(self,key,value):\r\n try:\r\n self._data.append(self.Item(key,value)) # insert as Item class object with key value.\r\n self._heapify_after_add(len(self._data) - 1 )\r\n return self._data\r\n except Exception, e:\r\n print \"Error occurred in HeapDistance: add method\", e","def allocate_tensors(self):\n self.tensors = {}","def add_metadata(self, metdatadata_list):\n self._metadata.append((metdatadata_list, ))","def add_metadata(self, metdatadata_list):\n self._metadata.append((metdatadata_list, ))","def add_records(self, data: dict, execution_context: dict):","def to_memory(self, key):\n if key in self.keys('dict'):\n logger.debug(f'{key} already exist in dict (memory)')\n\n elif key in self.keys('shelve'):\n value = copy.copy(self[key])\n del self[key]\n self.add(key, value, 'dict')\n\n else:\n raise ValueError(f'{key} does not exist in shelve')","def insert(self, key, value):\n\n # Map key to an index in main_array\n item_index = self._key_hash(key)\n\n # Turn input key, value pair into a HashEntry object\n data = HashEntry(key, value)\n\n # Append key, value pair to end of appropriate linked list\n self.main_array[item_index].append(data)","def _extend(self, other):\n for key, value in list(other.entries.items()):\n self._add_entry(key, value)","def add(self, value):\n self.heap.append(value)\n self.heapify_up()","def addChildren(self, values):\r\n for i, value in enumerate(values):\r\n newScope = copy(self.scope)\r\n newScope.index = i\r\n setattr(newScope, self.entryName, value)\r\n self.componentsLoader.loadAll(self.tokens, scope=newScope, onto=self.widget)","def load_program(self, program):\n for idx, val in enumerate(program):\n self.memory[idx] = val","def initialize_memory(self, pretrain_length, env):\n\n if self.memlen >= pretrain_length:\n print(\"Memory already filled, length: {}\".format(len(self.memory)))\n return\n interval = max(10, int(pretrain_length/25))\n print(\"Initializing memory buffer.\")\n obs = env.states\n while self.memlen < pretrain_length:\n actions = np.random.uniform(-1, 1, (self.agent_count,\n self.action_size))\n next_obs, rewards, dones = env.step(actions)\n self.store((obs, next_obs, actions, rewards, dones))\n obs = next_obs\n if np.any(dones):\n env.reset()\n obs = env.states\n self.memory.init_n_step()\n if self.memlen % interval == 1 or self.memlen >= pretrain_length:\n print(\"...memory filled: {}/{}\".format(self.memlen,\n pretrain_length))\n print(\"Done!\")","def add_descriptors(self, mapping):\n for key, desc in mapping.iteritems():\n self.descriptors[int(key, 16)] = desc","def add_descriptors(self, mapping):\n for key, desc in mapping.iteritems():\n self.descriptors[int(key, 16)] = desc","def load_registers_in_memory_quirk(self):\n register = (self.opcode & 0xF00) >> 8\n for x in range(register+1):\n self.memory[self.I + x] = self.registers[x]\n self.I += register + 1\n logger.info(\"Loaded registers from V0 to V{} into {}\".format(\n register,\n hex(self.I)))","def _allocate_buffer_memory(self):\n for channel in self._channels_dict.values():\n if channel.enabled:\n channel.allocate(self._num_captures, self._num_samples)","def allocate(self, memo):\r\n deprecation_warning()\r\n for member in self.components():\r\n member.allocate(memo)","def mem_extend(self, start: int, size: int) -> None:\n if self.memory_size > start + size:\n return\n m_extend = start + size - self.memory_size\n self.memory.extend(bytearray(m_extend))","def add(self, state, action, reward, next_state, done):\r\n e = self.experience(state, action, reward, next_state, done)\r\n self.memory.append(e)","def add(self,**kwargs):\n if self._extract:\n raise RuntimeError('This archive is write-only!')\n\n items = kwargs.iteritems() if PY2 else kwargs.items()\n for key,value in items:\n self._setitem(key,value)","def __init__(self, contents=()):\n self._data = [self._Item(k, v) for k,v in contents] # empty by default\n if len(self._data) > 1:\n self._heapify()","def __init__(self,entries=None,memoized=False):\n if entries is not None:\n self.entries = entries[:]\n else:\n self.entries = []\n self.memoized = memoized"],"string":"[\n \"def add_memory(self, **kwarg):\\n for name, obs in kwarg.items():\\n self.buffers[name] = np.concatenate((self.buffers[name], obs), axis=0)\\n # get recent memory\\n return self\",\n \"def record_memory_map(self):\\n memory_map = self.get_memory_map()\\n self._memory_map_records.append(memory_map)\",\n \"def init_memory(self, address, values):\\n for value in values: # writing 1 byte at a time\\n self.set_memory(address, value)\\n address = address + 1\",\n \"def store_memory(memory, history, action, reward, next_history, dead):\\n memory.append((history, action, reward, next_history, dead))\",\n \"def appendProcess(self, pid: int, numberOfVariables: int, processTable, diagnostics) -> int:\\n self.memory[pid] = []\\n\\n for _i in range(numberOfVariables):\\n self.memory[pid].append(MemoryItem())\\n\\n return 0\",\n \"def append(self, metaball):\\n\\n self.mbs.append(metaball)\",\n \"def add_entries(self, entries):\\n write_p = self._pointer\\n for entry in entries:\\n write_header(write_p, entry._entry_p)\\n for block in entry.get_blocks():\\n write_data(write_p, block, len(block))\\n write_finish_entry(write_p)\",\n \"def allocatememory(self):\\n\\n for key, value in self._dentsvertsdata.items():\\n value.allocatememory()\",\n \"def store_replay_memory(self, history, action, reward, next_history, dead):\\n self.memory.append((history, action, reward, next_history, dead))\",\n \"def __init__(self):\\r\\n self.__memory = []\",\n \"def set_memory_map(self):\\n sorted_list_tuple = sorted([(key, value) for key, value in \\n self._page_map.iteritems() if value >= 0], \\n key=lambda pair: pair[1])\\n self._memory_map = [pair[0] for pair in sorted_list_tuple]\",\n \"def set_memory_map(self):\\n sorted_list_tuple = sorted([(key, value) for key, value in \\n self._page_map.iteritems() if value[0] >= 0], \\n key=lambda pair: pair[1])\\n self._memory_map = [pair[0] for pair in sorted_list_tuple]\",\n \"def add_entries(self, *entries: Entry):\\n for entry in entries:\\n self.add_entry(entry)\",\n \"def allocatememory(self, key):\\n self._dentsvertsdata[key].allocatememory()\",\n \"def __init__(self):\\n self.memory = {}\\n self.sum_ = {}\",\n \"def add_entry(self, embeddings, labels, query_result=None):\\n n_added = embeddings.shape[0]\\n\\n if self.added_memories + n_added <= self.memory_size:\\n start = self.write_pointer + 1\\n end = start + n_added\\n self.update_ixs(range(start, end), embeddings, labels, query_result)\\n self.write_pointer += n_added\\n else:\\n capacity_remaining = max(self.memory_size - self.added_memories, 0)\\n if capacity_remaining > 0:\\n start = self.write_pointer + 1\\n self.update_ixs(range(start, self.memory_size), embeddings[:capacity_remaining], labels[:capacity_remaining],\\n query_result, global_update=False)\\n\\n n_overflow = n_added - capacity_remaining\\n # get least relevant indices\\n if self.delete_method == \\\"relevance\\\":\\n write_ixs = torch.topk(self.memory_relevance, n_overflow, largest=False).indices\\n elif self.delete_method == \\\"age\\\":\\n write_ixs = torch.topk(self.memory_age, n_overflow, largest=True).indices\\n self.update_ixs(write_ixs, embeddings[capacity_remaining:], labels[capacity_remaining:], query_result)\\n self.added_memories += n_added\",\n \"def addEntries(self, rewardPoolId, data):\\n resource = '/rewardPool/%s' % str(rewardPoolId)\\n for d in [data[i:i + DEFAULT_CHUNK]\\n for i in range(0, len(data), DEFAULT_CHUNK)]:\\n param = [('entry', x,) for x in d]\\n self.post(resource, param)\",\n \"def _memory(self):\\n memory = {}\\n memory_used = cpmCPUMemoryUsed\\n varbinds = self._snmp_connection.bulk_walk(memory_used)\\n for varbind in varbinds:\\n # grab the last element of the index to use as the memory_id\\n if self._cisco_model in self._n3k_models:\\n memory_id = self._process_mib_indices_table[int(varbind.index.split('.')[-1])]\\n else:\\n memory_id = int(varbind.index.split('.')[-1])\\n memory[memory_id] = {u'memory_used': int(varbind.value)}\\n\\n memory_free = cpmCPUMemoryFree\\n varbinds = self._snmp_connection.bulk_walk(memory_free)\\n for varbind in varbinds:\\n # grab the last element of the index to use as the memory_id\\n if self._cisco_model in self._n3k_models:\\n memory_id = self._process_mib_indices_table[int(varbind.index.split('.')[-1])]\\n else:\\n memory_id = int(varbind.index.split('.')[-1])\\n memory[memory_id][u'memory_free'] = int(varbind.value)\\n memory[memory_id][u'memory_total'] = memory[memory_id][u'memory_used'] + int(varbind.value)\\n\\n for memory_id in list(memory.keys()):\\n if memory_id in self._module_numbers:\\n if int(self._module_numbers[memory_id]) in self._entity_physical_names:\\n memory[memory_id][u'memory_type'] = u\\\"Module {} ({})\\\".format(self._module_numbers[memory_id],\\n self._entity_physical_names[\\n int(self._module_numbers[memory_id])])\\n else:\\n memory[memory_id][u'memory_type'] = u\\\"Module {}\\\".format(self._module_numbers[memory_id])\\n\\n if not len(memory):\\n self._logger.warn(\\n u'Failed to get memory enrichments on device \\\"%s\\\" with model \\\"%s\\\"' %\\n (self._device_fqdn, self._cisco_model))\\n\\n return memory\",\n \"def initiate_memory(self):\\n rows = constants.WINDOW_HEIGHT / constants.GRID_TILE_LENGTH\\n cols = constants.WINDOW_WIDTH / constants.GRID_TILE_LENGTH\\n self.memory = [[None for x in xrange(cols)] for x in xrange(rows)]\",\n \"def add_memory(self, state, action, reward, next_state, is_done):\\r\\n for state_i, action_i, reward_i, next_state_i, is_done_i, ER_i in zip(state, action, reward, next_state,\\r\\n is_done, self.ER_array):\\r\\n ER_i.add_memory(state_i, action_i, reward_i, next_state_i, is_done_i)\",\n \"def add_to_memory(count):\\n\\t\\tSimulation.past_attendance.append(count)\\n\\t\\tPerson.add_to_memory(count)\\n\\t\\tSimulation.simulation_progression.write(str(Person.recent_memory))\\n\\t\\tSimulation.simulation_progression.write(\\\"\\\\n\\\")\",\n \"def remember(self, memory):\\n assert isinstance(memory, dict)\\n\\n for name in self.names:\\n assert name in memory\\n self.meomries[name].append(memory[name])\",\n \"def allocatememory(self):\\n self._numvertstotal = self._numents * self._nvet\\n self._cords = VertDataSingleChannel(GLDataType.FLOAT, 3, self._numvertstotal)\\n self._colors = VertDataSingleChannel(GLDataType.UBYTE, 4, self._numvertstotal)\",\n \"async def cadd(self, ctx, *args: Input):\\n await self.add(\\n MemoryInputSet(MemoryInputSetConfig(ctx=ctx, inputs=list(args)))\\n )\\n return ctx\",\n \"def load_mem_to_registers(self):\\n register = (self.opcode & 0xFFF) >> 8\\n for x in range(register+1):\\n self.registers[x] = self.memory[self.I + x]\\n logger.info(\\n \\\"Loaded memory from {} to {} in registers till V{}\\\".format(\\n hex(self.I),\\n hex((self.I + register)),\\n register))\",\n \"async def register_system_shared_memory(\\n self,\\n name: str,\\n key: str,\\n byte_size: int,\\n offset: int = ...,\\n headers: dict[str, t.Any] = ...,\\n ) -> None:\",\n \"def pin_memory(self):\\r\\n\\r\\n self.points = [in_tensor.pin_memory() for in_tensor in self.points]\\r\\n self.neighbors = [in_tensor.pin_memory() for in_tensor in self.neighbors]\\r\\n self.pools = [in_tensor.pin_memory() for in_tensor in self.pools]\\r\\n self.upsamples = [in_tensor.pin_memory() for in_tensor in self.upsamples]\\r\\n self.lengths = [in_tensor.pin_memory() for in_tensor in self.lengths]\\r\\n self.features = self.features.pin_memory()\\r\\n\\r\\n return self\",\n \"def memory_write(self, offset: int, data: List[int]) -> None:\\n self.mem_extend(offset, len(data))\\n self.memory[offset : offset + len(data)] = data\",\n \"def allocatememory(self):\\n pass\",\n \"def add(a: int, b: int, c: int, memory: List) -> NoReturn:\\n memory[c] = memory[a] + memory[b]\",\n \"def add_to_buffer(self, values):\\n self._buffer.extend(values)\",\n \"def _add_to_memory(self, state, action, next_state, reward, done):\\n if len(self.memory) >= self.size_max_memory:\\n self.memory.pop(0)\\n self.memory += [Transition(state, action, next_state, reward, done)]\",\n \"def load_registers_in_memory(self):\\n register = (self.opcode & 0xF00) >> 8\\n for x in range(register+1):\\n self.memory[self.I + x] = self.registers[x]\\n logger.info(\\\"Loaded registers from V0 to V{} into {}\\\".format(\\n register,\\n hex(self.I)))\",\n \"def ADD():\\n global pointer, memory, registers\\n registers[memory[pointer + 0x02]] += memory[pointer + 0x01]\\n pointer += 0x03\",\n \"def write_mem(self):\\n request = 'commands/writemem'\\n return self._post(request)\",\n \"def _build_memorymap(self):\\n\\t\\tmemorymap = {}\\n\\t\\ttotalsize = 0\\n\\t\\tbaserva = self.liststream64.DirectoryData.BaseRva\\n\\t\\tmmdscrptr64 = self.liststream64.DirectoryData.MINIDUMP_MEMORY_DESCRIPTOR64\\n\\t\\tnumberofmemoryranges = self.liststream64.DirectoryData.NumberOfMemoryRanges\\n\\t\\tfor i in range(numberofmemoryranges):\\n\\t\\t\\tmemorymap[mmdscrptr64[i].StartOfMemoryRange] = ((baserva + totalsize),mmdscrptr64[i].DataSize)\\n\\t\\t\\ttotalsize += mmdscrptr64[i].DataSize\\n\\t\\treturn memorymap\",\n \"def appendedEntries(self):\\n self.contact_list.append({\\\"name\\\": self.first_name.title() + \\\" \\\" + self.last_name.title(), \\\"phone number\\\": self.phone_number, \\\"phone number type\\\": self.phone_number_type})\",\n \"def add(self, states, all_state, action, all_actions, reward, next_state, all_next_state, done):\\n e = self.experience(states, all_state, action, all_actions, reward, next_state, all_next_state, done)\\n self.memory.append(e)\",\n \"def add_entry(self, entry): # Hashmap.add_entry\\n\\n if entry.hexdigest in self.contentHash:\\n self.contentHash[entry.hexdigest].append(entry)\\n else:\\n self.contentHash[entry.hexdigest] = [ entry ]\\n\\n if entry.depth < self.minDepth:\\n self.minDepth = entry.depth\",\n \"def reset_memory(self):\\n self.memory = []\",\n \"def allocate(self, memo):\\r\\n raise NotImplementedError\",\n \"def addChunk(self, direction):\\n pass\\n\\n ## get size of actual map\\n ## create array of fitting size\\n ## stack created array to map\",\n \"def restore_program(memory_updates: Dict[int, int], memory: List[int]) -> List[int]:\\n for (index, new_value) in memory_updates.items():\\n memory[index] = new_value\\n return memory\",\n \"def add(self, key, value):\\n self._data.append(self._Item(key, value))\\n self._upheap(len(self._data) - 1) # upheap newly added position\",\n \"def addEntry(self, symbol, address):\\n self.table[symbol] = address\",\n \"def add(self, key, value):\\n self._data.append(self._Item(key, value))\\n self._upheap(len(self._data) - 1) # upheap newly added position\",\n \"def append(self, data):\\n if self._expand_mode:\\n new_keys = set(data.keys()) - self.keys & self._keys\\n self._expand(new_keys)\\n self._cubas = None\\n self._append(data)\\n self._number_of_items += 1\",\n \"def memory_plan(self, feed_shapes):\\n assert (self.ctx is not None)\\n self.node_to_arr_map = {}\\n for node, shape in self.node_to_shape_map.items():\\n self.node_to_arr_map[node] = ndarray.empty(shape, ctx=self.ctx)\",\n \"def add(self, key, value):\\n self._data.append(self._Item(key, value))\\n self._up_heap(len(self) - 1)\",\n \"def add_datamap(self, ctx, datamap):\\n zing_state = self._get_zing_tx_state()\\n zing_state.datamaps.append((ctx.device(), datamap))\",\n \"def post(self):\\n try:\\n memory = parse_memory_from_request()\\n self.logger.info(\\\"Adding memory for %s on %s\\\", memory.user_id, memory.memory_date)\\n ds.add_memory(memory)\\n\\n # re-fetch the memory and return it in the response body\\n added_memory = ds.get_memory(memory.user_id, memory.memory_date)\\n return added_memory.to_dict(), 201\\n except MyDeticMemoryAlreadyExists, mdmae:\\n self.logger.info(\\\"Memory already exists on add (%s : %s)\\\", memory.user_id, memory.memory_date)\\n return generate_error_json(mdmae)\\n except MyDeticInvalidMemoryString, mdims:\\n self.logger.info(\\\"Invalid memory string on add (%s)\\\" % mdims.msg)\\n return generate_error_json(mdims)\\n except MyDeticException, mde:\\n return generate_error_json(mde)\",\n \"def memory(self, memory):\\n\\n self._memory = memory\",\n \"def populate_mem():\\n global MemListing\\n for item in memList:\\n mem = \\\"%s\\\" % item[0]\\n price = \\\"%s\\\" % item[1]\\n \\n try:\\n MemListing.objects.get(memList = mem, memPrice = price)\\n \\n except MemListing.DoesNotExist:\\n print mem\\n mydb = MemListing.objects.create(memList = mem, memPrice = price)\\n print mydb\\n mydb.save()\",\n \"def memory(kdump_memory):\\n config_db = ConfigDBConnector()\\n if config_db is not None:\\n config_db.connect()\\n config_db.mod_entry(\\\"KDUMP\\\", \\\"config\\\", {\\\"memory\\\": kdump_memory})\",\n \"def add(self, record):\\n self._hist_records[record.uid] = record\",\n \"def store(self, state, action, reward, next_state, done):\\n self.replay_memory.append((state, action, reward, next_state, done))\",\n \"def _initialize_mem_buffs():\\r\\n args = get_args()\\r\\n\\r\\n # Initialize memory for checkpointed activations.\\r\\n if args.distribute_checkpointed_activations:\\r\\n mpu.init_checkpointed_activations_memory_buffer()\\r\\n mpu.init_workspace_memory_buffer()\\r\\n # mpu.init_forward_buffer()\\r\\n mpu.init_QKV_forward_buffer()\\r\\n mpu.init_QKV_dense_buffer()\\r\\n mpu.init_h4h_forward_buffer()\\r\\n mpu.init_fhh_forward_buffer()\\r\\n mpu.init_backward_buffer()\\r\\n mpu.init_parameter_gradient_buffer()\\r\\n mpu.init_conjunction_gradient_buffer()\\r\\n # if not args.ParallelTransformer_only:\\r\\n # mpu.init_lmhead_dense_buffer()\",\n \"def update_memory(self, target, clues, guesses, winlose):\\n immediate_rewards = self.get_trajectory_immediate_rewards(target, \\n clues,\\n guesses)\\n \\n self.memory.append((target, \\n clues, \\n guesses, \\n winlose, \\n immediate_rewards))\",\n \"def build_and_add(self,*args):\\n lattice = lattice_class.lattice(*args)\\n self.lattices.append()\\n self.meshfns.append(['in_memory'])\",\n \"def appenddictitemsize(self, key, numents):\\n self._dentsvertsdata[key].appendsize(numents * self._multFactor)\",\n \"def remember(self, item):\\n self.memory.append(item)\",\n \"def load_mem_to_registers_quirk(self):\\n register = (self.opcode & 0xFFF) >> 8\\n for x in range(register+1):\\n self.registers[x] = self.memory[self.I + x]\\n self.I += register + 1\\n logger.info(\\n \\\"Loaded memory from {} to {} in registers till V{}\\\".format(\\n hex(self.I),\\n hex((self.I + register)),\\n register))\",\n \"def allocate(self, memo):\\r\\n for input in self.kit.sinputs:\\r\\n r = input.variable\\r\\n if r not in memo:\\r\\n input = copy(input)\\r\\n input.value = Container(r, storage = [None])\\r\\n memo[r] = input\",\n \"def update_replay_memory(self, transition: Tuple[np.array, int, int,\\r\\n np.array, bool]) -> None:\\r\\n self.replay_memory.append(transition)\",\n \"def add(self, datasetName, rows):\\r\\n\\r\\n rows = np.vstack(rows)\\r\\n\\r\\n\\t\\t# Add the sample into the buffer\\r\\n try:\\r\\n self.datasetBuffer[datasetName].extend(rows)\\r\\n except:\\r\\n # Initialize the buffer\\r\\n self.datasetBuffer[datasetName] = []\\r\\n self.datasetBuffer[datasetName].extend(rows)\\r\\n\\r\\n # Create the dataset\\r\\n self._createDatasets(datasetName)\\r\\n\\r\\n # Initiliaze dataset index count\\r\\n self.idxs[datasetName] = 0\\r\\n\\r\\n # Update the number of samples in the buffer\\r\\n self.totalFeatures += len(rows)\\r\\n\\r\\n\\t\\t# Check to see if we have reached the maximum buffer size\\r\\n if self.totalFeatures >= self.maxBufferSize:\\r\\n\\r\\n\\t\\t\\t# write the buffers to file\\r\\n self._writeBuffers()\",\n \"def handle_memory_reads(self, instr):\\n reading_export_address = 0\\n number_of_exports_read = 0\\n dyn_import_pair = set()\\n stat_import_pair = set()\\n if self.use_trace_file == True:\\n dynamic_values_read = self.get_dynamic_memory_reads(instr)\\n for value in dynamic_values_read:\\n if self.exported_modules.contains_address(value) == True:\\n dll_name, function_name = self.exported_modules.get_dll_and_function(value)\\n dyn_import_pair.add((dll_name, function_name, value))\\n\\n static_values_read = list(self.get_static_memory_read(instr))\\n for value in static_values_read:\\n if self.exported_modules.contains_address(value) == True:\\n dll_name, function_name = self.exported_modules.get_dll_and_function(value)\\n stat_import_pair.add((dll_name, function_name, value))\\n\\n combined_pairs = dyn_import_pair.union(stat_import_pair)\\n if len(combined_pairs) == 1:\\n if len(dyn_import_pair) == 1:\\n for dll_name, function_name, value in dyn_import_pair:\\n self.import_table.add_function(dll_name, function_name, 1, instr)\\n instr.add_values_read(value)\\n reading_export_address = 1\\n\\n if len(stat_import_pair) == 1:\\n for dll_name, function_name, value in stat_import_pair:\\n self.import_table.add_function(dll_name, function_name, 0, instr)\\n instr.add_values_read(value)\\n reading_export_address = 1\\n\\n if reading_export_address == 1:\\n self.instructions_to_relocate.append(instr.address)\",\n \"def feed(self, entry):\\r\\n if entry.name not in self.names:\\r\\n self.names[entry.name] = list()\\r\\n self.names[entry.name].append(entry)\",\n \"def add(self, batch_size=10000):\\n if self.N <= batch_size:\\n self.index.add(self.database)\\n else:\\n [self.index.add(self.database[i:i + batch_size])\\n for i in tqdm(range(0, len(self.database), batch_size),\\n desc='[index] add')]\",\n \"def __init__(self):\\n super(MemoryPersistence, self).__init__(descriptor)\",\n \"def MEM (self,n):\",\n \"def update_memory(self, result):\\r\\n if (len(self.memory) >= self.memory_capacity):\\r\\n self.memory.pop(0)\\r\\n self.memory.append(result)\\r\\n else:\\r\\n self.memory.append(result)\",\n \"def add_file_from_memory(\\n self, entry_path, entry_size, entry_data,\\n filetype=REGULAR_FILE,\\n permission=DEFAULT_UNIX_PERMISSION\\n ):\\n archive_pointer = self._pointer\\n\\n with new_archive_entry() as archive_entry_pointer:\\n archive_entry = ArchiveEntry(None, archive_entry_pointer)\\n\\n archive_entry.pathname = entry_path\\n entry_set_size(archive_entry_pointer, entry_size)\\n entry_set_filetype(archive_entry_pointer, filetype)\\n entry_set_perm(archive_entry_pointer, permission)\\n write_header(archive_pointer, archive_entry_pointer)\\n\\n for chunk in entry_data:\\n if not chunk:\\n break\\n write_data(archive_pointer, chunk, len(chunk))\\n\\n write_finish_entry(archive_pointer)\\n entry_clear(archive_entry_pointer)\",\n \"def load_history_entries(self, *entries):\\n # Simplified version:\\n for entry in entries:\\n try:\\n self[entry.url.host] += [entry]\\n except KeyError:\\n self[entry.url.host] = [entry]\\n \\n \\n temp_dict = {entry.url.host: [] for entry in entries} \\n for entry in entries:\\n temp_dict[entry.url.host] += [entry]\\n\\n # Update the dictionary\\n # self.update(temp_dict) # Will override any lists with the same host name\\n for host, entry in temp_dict.items():\\n #try:\\n self[host] += [entry]\\n #except IndexError:\\n #self[host] = [entry]\",\n \"def buffer(self, entry):\\n # TODO\\n print(\\\"Storing {} in Redis.\\\".format(entry))\\n\\n # Redis list to store all ids of entities\\n self._pipeline.rpush(\\n self._list_name,\\n '{}'.format(entry.id)\\n )\\n\\n # Redis hash to store all attributes of entities\\n hash_name = '{}:{}'.format(self._list_name, entry.id)\\n hash_dict = {}\\n field_names = list(entry.__all__)\\n field_names.remove('id')\\n for field_name in field_names:\\n hash_dict[field_name] = getattr(entry, field_name)\\n\\n self._pipeline.hmset(hash_name, hash_dict)\",\n \"def append(self, *items: BOSminer) -> None:\\n for item in items:\\n self.miners[item.ip] = item\",\n \"def devClearAdd(self):\\n #l = [0, 1, 2, 3, 4, 5, 6, 15, 47]\\n l = [0, 1, 2, 3, 4, 5, 47]\\n tTree, tHeap, tHash = 0, 0, 0\\n self.devClearStores()\\n for i in l:\\n movie = Movie()\\n movie.importFromString(self._data[i])\\n print \\\"Adding movie '%s'...\\\" % ( movie.title )\\n start = time.clock() * 1000000\\n self.storeTree.insert(movie)\\n end = time.clock() * 1000000\\n tTree += end - start\\n start = time.clock() * 1000000\\n self.storeHeap.insert(movie)\\n end = time.clock() * 1000000\\n tHeap += end - start\\n start = time.clock() * 1000000\\n self.storeHash.insert(movie)\\n end = time.clock() * 1000000\\n tHash += end - start\\n self.benchmarkDisplay.binarySearchTree.set(tTree)\\n self.benchmarkDisplay.binaryHeap.set(tHeap)\\n self.benchmarkDisplay.hashTable.set(tHash)\\n self.benchmarkDisplay.binarySearchTreeDepth.set(self.storeTree.getDepth())\\n self.benchmarkDisplay.binaryHeapDepth.set(self.storeHeap.getDepth())\",\n \"def bookkeeping(episode_memory, reward_per_episode):\\n\\n states, actions, new_states, rewards, done = zip(*episode_memory)\\n reward_per_episode.append(np.sum(rewards))\",\n \"def offset_list(self):\\n self.nodes.append(None)\\n self.formulas.append(None)\\n self.node_memory.append(None)\\n self.formulas_memory.append(None)\",\n \"def add_array(self, attr_name, data, dtype=None):\\n if attr_name in self._shm_attr_names:\\n raise ValueError(f'A Shared Memory array with the name {attr_name}\\\\\\n is already in this ShmManager')\\n _shm = SharedMemArrayManager(\\n data=data, dtype=dtype)\\n self._shm_attr_names.append(attr_name)\\n setattr(self, attr_name, _shm)\",\n \"def add(self,key,value):\\r\\n try:\\r\\n self._data.append(self.Item(key,value)) # insert as Item class object with key value.\\r\\n self._heapify_after_add(len(self._data) - 1 )\\r\\n return self._data\\r\\n except Exception, e:\\r\\n print \\\"Error occurred in HeapDistance: add method\\\", e\",\n \"def allocate_tensors(self):\\n self.tensors = {}\",\n \"def add_metadata(self, metdatadata_list):\\n self._metadata.append((metdatadata_list, ))\",\n \"def add_metadata(self, metdatadata_list):\\n self._metadata.append((metdatadata_list, ))\",\n \"def add_records(self, data: dict, execution_context: dict):\",\n \"def to_memory(self, key):\\n if key in self.keys('dict'):\\n logger.debug(f'{key} already exist in dict (memory)')\\n\\n elif key in self.keys('shelve'):\\n value = copy.copy(self[key])\\n del self[key]\\n self.add(key, value, 'dict')\\n\\n else:\\n raise ValueError(f'{key} does not exist in shelve')\",\n \"def insert(self, key, value):\\n\\n # Map key to an index in main_array\\n item_index = self._key_hash(key)\\n\\n # Turn input key, value pair into a HashEntry object\\n data = HashEntry(key, value)\\n\\n # Append key, value pair to end of appropriate linked list\\n self.main_array[item_index].append(data)\",\n \"def _extend(self, other):\\n for key, value in list(other.entries.items()):\\n self._add_entry(key, value)\",\n \"def add(self, value):\\n self.heap.append(value)\\n self.heapify_up()\",\n \"def addChildren(self, values):\\r\\n for i, value in enumerate(values):\\r\\n newScope = copy(self.scope)\\r\\n newScope.index = i\\r\\n setattr(newScope, self.entryName, value)\\r\\n self.componentsLoader.loadAll(self.tokens, scope=newScope, onto=self.widget)\",\n \"def load_program(self, program):\\n for idx, val in enumerate(program):\\n self.memory[idx] = val\",\n \"def initialize_memory(self, pretrain_length, env):\\n\\n if self.memlen >= pretrain_length:\\n print(\\\"Memory already filled, length: {}\\\".format(len(self.memory)))\\n return\\n interval = max(10, int(pretrain_length/25))\\n print(\\\"Initializing memory buffer.\\\")\\n obs = env.states\\n while self.memlen < pretrain_length:\\n actions = np.random.uniform(-1, 1, (self.agent_count,\\n self.action_size))\\n next_obs, rewards, dones = env.step(actions)\\n self.store((obs, next_obs, actions, rewards, dones))\\n obs = next_obs\\n if np.any(dones):\\n env.reset()\\n obs = env.states\\n self.memory.init_n_step()\\n if self.memlen % interval == 1 or self.memlen >= pretrain_length:\\n print(\\\"...memory filled: {}/{}\\\".format(self.memlen,\\n pretrain_length))\\n print(\\\"Done!\\\")\",\n \"def add_descriptors(self, mapping):\\n for key, desc in mapping.iteritems():\\n self.descriptors[int(key, 16)] = desc\",\n \"def add_descriptors(self, mapping):\\n for key, desc in mapping.iteritems():\\n self.descriptors[int(key, 16)] = desc\",\n \"def load_registers_in_memory_quirk(self):\\n register = (self.opcode & 0xF00) >> 8\\n for x in range(register+1):\\n self.memory[self.I + x] = self.registers[x]\\n self.I += register + 1\\n logger.info(\\\"Loaded registers from V0 to V{} into {}\\\".format(\\n register,\\n hex(self.I)))\",\n \"def _allocate_buffer_memory(self):\\n for channel in self._channels_dict.values():\\n if channel.enabled:\\n channel.allocate(self._num_captures, self._num_samples)\",\n \"def allocate(self, memo):\\r\\n deprecation_warning()\\r\\n for member in self.components():\\r\\n member.allocate(memo)\",\n \"def mem_extend(self, start: int, size: int) -> None:\\n if self.memory_size > start + size:\\n return\\n m_extend = start + size - self.memory_size\\n self.memory.extend(bytearray(m_extend))\",\n \"def add(self, state, action, reward, next_state, done):\\r\\n e = self.experience(state, action, reward, next_state, done)\\r\\n self.memory.append(e)\",\n \"def add(self,**kwargs):\\n if self._extract:\\n raise RuntimeError('This archive is write-only!')\\n\\n items = kwargs.iteritems() if PY2 else kwargs.items()\\n for key,value in items:\\n self._setitem(key,value)\",\n \"def __init__(self, contents=()):\\n self._data = [self._Item(k, v) for k,v in contents] # empty by default\\n if len(self._data) > 1:\\n self._heapify()\",\n \"def __init__(self,entries=None,memoized=False):\\n if entries is not None:\\n self.entries = entries[:]\\n else:\\n self.entries = []\\n self.memoized = memoized\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65852726","0.6368498","0.62108815","0.62035614","0.6151291","0.6102449","0.60953045","0.6070591","0.58292973","0.580414","0.5742335","0.57391006","0.5659953","0.56543183","0.5636044","0.5632198","0.56220376","0.56029516","0.55805933","0.55668706","0.5543858","0.55356157","0.55350626","0.550956","0.5500705","0.5461388","0.54523534","0.5445837","0.54378724","0.5406094","0.54034364","0.53894305","0.5380181","0.5364969","0.53581005","0.53496724","0.53301305","0.53261703","0.5321016","0.5320756","0.53005695","0.5294957","0.5280996","0.5279753","0.5274282","0.5222746","0.52127326","0.5201223","0.51926273","0.51832914","0.517924","0.5177621","0.5161435","0.5155637","0.5153967","0.515199","0.51518655","0.51490885","0.51427233","0.5141583","0.5139402","0.513647","0.51350635","0.5134913","0.51331407","0.5101498","0.5098753","0.5090971","0.5089082","0.5088649","0.5087578","0.50838906","0.5073908","0.50727385","0.5067062","0.50662047","0.50589335","0.5053074","0.5050259","0.5043738","0.5039912","0.503614","0.503614","0.50289327","0.50277525","0.50246704","0.5012701","0.5011998","0.5010643","0.500378","0.5001688","0.5000886","0.5000886","0.49942732","0.49917966","0.49888888","0.49876076","0.4981407","0.49799514","0.49733937","0.49731153"],"string":"[\n \"0.65852726\",\n \"0.6368498\",\n \"0.62108815\",\n \"0.62035614\",\n \"0.6151291\",\n \"0.6102449\",\n \"0.60953045\",\n \"0.6070591\",\n \"0.58292973\",\n \"0.580414\",\n \"0.5742335\",\n \"0.57391006\",\n \"0.5659953\",\n \"0.56543183\",\n \"0.5636044\",\n \"0.5632198\",\n \"0.56220376\",\n \"0.56029516\",\n \"0.55805933\",\n \"0.55668706\",\n \"0.5543858\",\n \"0.55356157\",\n \"0.55350626\",\n \"0.550956\",\n \"0.5500705\",\n \"0.5461388\",\n \"0.54523534\",\n \"0.5445837\",\n \"0.54378724\",\n \"0.5406094\",\n \"0.54034364\",\n \"0.53894305\",\n \"0.5380181\",\n \"0.5364969\",\n \"0.53581005\",\n \"0.53496724\",\n \"0.53301305\",\n \"0.53261703\",\n \"0.5321016\",\n \"0.5320756\",\n \"0.53005695\",\n \"0.5294957\",\n \"0.5280996\",\n \"0.5279753\",\n \"0.5274282\",\n \"0.5222746\",\n \"0.52127326\",\n \"0.5201223\",\n \"0.51926273\",\n \"0.51832914\",\n \"0.517924\",\n \"0.5177621\",\n \"0.5161435\",\n \"0.5155637\",\n \"0.5153967\",\n \"0.515199\",\n \"0.51518655\",\n \"0.51490885\",\n \"0.51427233\",\n \"0.5141583\",\n \"0.5139402\",\n \"0.513647\",\n \"0.51350635\",\n \"0.5134913\",\n \"0.51331407\",\n \"0.5101498\",\n \"0.5098753\",\n \"0.5090971\",\n \"0.5089082\",\n \"0.5088649\",\n \"0.5087578\",\n \"0.50838906\",\n \"0.5073908\",\n \"0.50727385\",\n \"0.5067062\",\n \"0.50662047\",\n \"0.50589335\",\n \"0.5053074\",\n \"0.5050259\",\n \"0.5043738\",\n \"0.5039912\",\n \"0.503614\",\n \"0.503614\",\n \"0.50289327\",\n \"0.50277525\",\n \"0.50246704\",\n \"0.5012701\",\n \"0.5011998\",\n \"0.5010643\",\n \"0.500378\",\n \"0.5001688\",\n \"0.5000886\",\n \"0.5000886\",\n \"0.49942732\",\n \"0.49917966\",\n \"0.49888888\",\n \"0.49876076\",\n \"0.4981407\",\n \"0.49799514\",\n \"0.49733937\",\n \"0.49731153\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94495,"cells":{"query":{"kind":"string","value":"Update class representations with new class means."},"document":{"kind":"string","value":"def update(self, class_means, unique_labels, logger=None):\n n_added = class_means.shape[0]\n class_discount = self.class_discount\n to_update = unique_labels\n normalized_class_means = None\n normalized_class_representations = None\n self.update_last_updated(unique_labels)\n\n # selection of old class representations here\n old_class_representations = self.class_representations[to_update]\n # if old class representations haven't been given values yet, don't bias towards 0 by exponential update\n n = self.n_class_embeddings[to_update]\n if self.class_discount_method == \"mean\":\n class_discount = (1 / (n + 1)).unsqueeze(-1)\n elif self.class_discount_method == \"adaptive\":\n class_means_norm = class_means.norm(dim=1).unsqueeze(-1)\n old_class_representations_norm = old_class_representations.norm(dim=1).unsqueeze(-1)\n class_means_norm[class_means_norm == 0] = 1 # avoid nans\n old_class_representations_norm[old_class_representations_norm == 0] = 1 # avoid nans\n normalized_class_means = class_means / class_means_norm\n normalized_class_representations = old_class_representations / old_class_representations_norm \n \n # class_dists = euclidean_dist(class_means, old_class_representations).diag()\n normalized_class_dists = euclidean_dist(normalized_class_means, normalized_class_representations).diag()\n\n b = 1.3\n class_discount = (2 / (2 ** b) * normalized_class_dists ** b).unsqueeze(-1)\n class_discount = torch.clamp_max(class_discount, 1)\n if logger is not None:\n logger.debug(f\"Normalized Dists: {normalized_class_dists}\")\n # memory update rule here\n # classes of which prototypes haven't been updated yet\n uninitialized_vector_classes = (old_class_representations == 0).bool().all(dim=1)\n if uninitialized_vector_classes.all():\n class_discount = 1\n elif not isinstance(class_discount, float):\n # otherwise it is a tensor\n class_discount[uninitialized_vector_classes] = 1\n new_class_representations = (1 - class_discount) * old_class_representations + class_discount * class_means\n self.n_class_embeddings[to_update] += 1\n if logger is not None:\n logger.debug(f\"Labels: {unique_labels}\")\n logger.debug(f\"Uninitialized Classes: {unique_labels[uninitialized_vector_classes]}\")\n logger.debug(f\"Class discount: {class_discount}\")\n logger.debug(f\"Updating class representations for classes {unique_labels}.\\n\"\n f\"Distance old class representations and class means: {[round(z, 2) for z in (old_class_representations - class_means).norm(dim=1).tolist()]}\\n\"\n f\"Distance old and new class representations: {[round(z, 2) for z in (new_class_representations - old_class_representations).norm(dim=1).tolist()]}\"\n )\n # for returning new class representations while keeping gradients intact\n result = torch.clone(self.class_representations)\n result[to_update] = new_class_representations\n # update memory\n self.class_representations[to_update] = new_class_representations.detach()\n\n self.added_memories += n_added\n return {\"new_class_representations\": result, \"class_discount\": class_discount}"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def update_class_records():\n logger.info('Fetching class ids and labels for '\n 'classes with direct instances')\n timestamp = statistics.get_current_timestamp()\n results = sparql.sparql_query(queries.QUERY_CLASSES,\n fallback=queries.QUERY_CLASSSES_FALLBACK)\n\n if 'error' in results:\n logger.error('Got no SPARQL results.')\n return\n\n updated = {}\n\n def value(binding, key):\n return binding[key]['value']\n\n for binding in results['results']['bindings']:\n uri = value(binding, 'cl')\n if not sparql.is_wikidata_entity(uri):\n continue\n\n qid = sparql.wikidata_entity_id(uri)\n label = value(binding, 'clLabel')\n record = {'l': label, }\n\n if 'c' in binding:\n record['i'] = int(value(binding, 'c'))\n updated[qid] = record\n\n logger.info('Augmenting current classes data ...')\n data = statistics.get_json_data('classes')\n merged = statistics.merge(data, updated, default_others={'i': 0})\n statistics.update_json_data('classes', merged, timestamp)","def update_class(self, class_info):\n SchemaValidator(self.schema_extension_only, self.schema_nx).validate_class_schema(class_info)\n self.schema[\"@graph\"].append(class_info)\n self.load_schema(self.schema)\n print(\"Updated the class {} successfully!\".format(class_info[\"rdfs:label\"]))","def class_adjustment(self):\n self.ABILITIES_ORDER = fetch_data.get_abilities_order(self.ch_class)\n\n for key in self.SAVES_LVLS:\n self.SAVES_LVLS[key] = fetch_data.get_class_saves(key, self.ch_class)\n\n self.CLASS_SKILLS = fetch_data.get_class_skills(self.ch_class)\n self.SKILL_POINTS_MOD = fetch_data.get_skillp_modifier(self.ch_class)\n self.HIT_DIE = fetch_data.get_hit_die(self.ch_class)\n self.BASE_ATTACK_LVLS = fetch_data.get_class_base_attack(self.ch_class)","def update_class(self):\n neighbors_set = list(set(self.neighbors))\n counts = np.array([self.neighbors.count(n) for n in neighbors_set])\n probs = (counts / counts.sum()) * (1-self.mutation_prob)\n probs = np.append(probs, self.mutation_prob)\n neighbors_set.append(np.random.choice(np.arange(1, self.board.classes))) \n\n self.cell_class = np.random.choice(neighbors_set, p=probs)","def update_derived_class_records():\n derive_class_hierarchy()","def update(cls, recommender, instance_changes):","def do_update(self, *args):\n if len(args) == 1:\n args = [ele for ele in args[0].split(' ')]\n if args[0] == '':\n print(\"** class name missing **\")\n return\n if args[0] not in self.list_classes:\n print(\"** class doesn't exist **\")\n return\n if len(args) < 2:\n print(\"** instance id missing **\")\n return\n elif len(args) < 3:\n print(\"** attribute name missing **\")\n return\n elif len(args) < 4:\n print(\"** value missing **\")\n return\n\n storage.reload()\n dict_objs = storage.all()\n if dict_objs is None or dict_objs == []:\n print(\"** no instance found **\")\n return\n\n key = \"{}.{}\".format(args[0], args[1])\n if key in dict_objs.keys():\n obj = dict_objs[key]\n if args[2] in obj.__class__.__dict__:\n obj.__dict__[args[2]] =\\\n type(obj.__class__.__dict__[args[2]])(args[3])\n else:\n obj.__dict__[args[2]] = args[3]\n storage.save()\n else:\n print(\"** no instance found **\")","def apply_class_changes(self, old_class, new_class):\n new_class.id = old_class.id\n if old_class.json() == new_class.json():\n logger.info(\"No differences detected for %s\", old_class)\n return old_class\n\n class_rename = bool(old_class.name != new_class.name)\n _, modified_attributes, deleted_attrs = compare_fixture_classes(old_class, new_class)\n if any([modified_attributes, deleted_attrs, class_rename]):\n mutation = {}\n if class_rename:\n logger.info(\"Fixture class renamed from %s -> %s\", old_class.name, new_class.name)\n mutation['$set'] = {'mtime' : int(time.time() * 1e6)}\n mutation['$set']['class_name'] = new_class.name\n\n for attr_name in modified_attributes:\n new_attr_def = new_class.attributes[attr_name]\n old_attr_def = old_class.attributes[attr_name]\n old_is_array = 'array' in old_attr_def.get('flags', '')\n new_is_array = 'array' in new_attr_def.get('flags', '')\n if old_attr_def['type'] != new_attr_def['type'] or old_is_array != new_is_array:\n logger.warning(\"Data type of %s changed (%s -> %s) (array: %s -> %s). Dropping old column values\",\n attr_name, old_attr_def['type'], new_attr_def['type'], old_is_array, new_is_array)\n deleted_attrs.append(attr_name)\n\n if deleted_attrs:\n mutation['$unset'] = {}\n mutation['$set'] = {'mtime' : int(time.time() * 1e6)}\n for attr_name in deleted_attrs:\n logger.info(\"Deleting class attribute: %s.%s\", new_class.name, attr_name)\n mutation['$unset']['attributes.{}'.format(attr_name)] = \"\"\n\n if mutation:\n # update all active fixtures with the change (don't touch deleted instances)\n query = {'class_id' : old_class.id, 'deleted': False}\n self._batch_update(query, mutation)\n else:\n logger.info(\"No instance updates to apply\")\n\n self.axdb_client.update_fixture_class(new_class.axdbdoc())\n logger.info(\"%s updated:\\n%s\", new_class, pretty_json(new_class.json()))\n self.reqproc.trigger_processor()\n return new_class","def finalize_class_set(self) -> None:\n logger.info(\"We have {} distinct classes, let's cluster it!\", len(self.classes))\n\n logger.debug(\"Created a cluster instance {} and this will cluster {} samples\", self.cluster, self.classes)\n try:\n assigned_clusters = self.cluster.cluster(vectors=[self.convert_str_list_to_vector(c) for c in self.classes],\n assign_clusters=True, trace=not execute_on_ssh_compute)\n except Exception:\n logger.exception(\"Failed to cluster the actual class set ({} samples)\", len(self.classes))\n return\n\n self.classes_to_one_hot_encode_dict.clear()\n for i in range(len(self.classes)):\n self.classes_to_one_hot_encode_dict[self.classes[i]] = assigned_clusters[i]","def update(cls) -> None:\n raise NotImplementedError","def update_classes(class_list_, champions_list_, class_counters_):\n logging.debug(\"Function update_classes() called\")\n\n class_counters_value_list = [0] * len(class_list_)\n for i, class_ in enumerate(class_list_): # looping over counters for every class\n logging.info(\"Current class: %s\", class_)\n for (\n champ\n ) in (\n champions_list_\n ): # for loop to assign how much champions are nonzero in class\n if champ.ChampCounter.get() >= 1:\n logging.info(\"Current champ with counter >=1: %s\", champ.name)\n if class_ in (champ.class_prim, champ.class_sec):\n logging.info(\n \"Current champ with counter >=1 match class Prim or Sec \\\n : %s or %s\",\n champ.class_prim,\n champ.class_sec,\n )\n class_counters_value_list[i] = class_counters_value_list[i] + 1\n logging.info(\n \"Number of nonzero champions in this class = %s\",\n class_counters_value_list[i],\n )\n class_counters_[i].set(class_counters_value_list[i])\n\n logging.debug(\"Function update_classes() end\")","def update(self) -> None:\n self.faithful = self.is_faithful()\n if self.faithful:\n old_class_names = self.class_names\n old_training_image_names = self.training_image_names\n self.class_names = self.find_class_names()\n self.training_image_names = self.find_training_image_names()\n self.extracted_features = list()\n if old_class_names != self.class_names or old_training_image_names != self.training_image_names:\n self.generate_csv_dictionary()\n return","def load_classes(self):\n super().load_classes()\n from scipy.io import loadmat\n mat_path = os.path.join(self.input_data_path, \"index_ade20k.mat\")\n object_names = loadmat(mat_path)['index']['objectnames'][0][0][0]\n self.ADE20K_CLASSES = {}\n self.ADE20K_CLASSES_reverse = {}\n for i in range(len(object_names)):\n self.ADE20K_CLASSES[object_names[i][0]] = i+1\n self.ADE20K_CLASSES_reverse[i+1] = object_names[i][0]\n if i == 3:\n logger.debug(f\"ADE20K_CLASSES: {self.ADE20K_CLASSES}\")\n logger.debug(f\"ADE20K_CLASSES_reverse: {self.ADE20K_CLASSES_reverse}\")","def process_class(self, parent, cls):\n if cls.typemap.flat_name in self.class_map:\n raise RuntimeError(\"process_class: class {} already exists in class_map\"\n .format(cls.typemap.flat_name))\n self.class_map[cls.typemap.flat_name] = cls\n for var in cls.variables:\n self.add_var_getter_setter(parent, cls, var)\n cls.functions = self.define_function_suffix(cls.functions)","def add_class(wire_version, cls, members):\n memid = 0\n\n sig = loxi_utils.class_signature(members)\n if cls in of_g.unified:\n uc = of_g.unified[cls]\n if wire_version in uc:\n debug(\"Error adding %s to unified. Wire ver %d exists\" %\n (cls, wire_version))\n sys.exit(1)\n uc[wire_version] = {}\n # Check for a matching signature\n for wver in uc:\n if type(wver) != type(0): continue\n if wver == wire_version: continue\n if not \"use_version\" in uc[wver]:\n if sig == loxi_utils.class_signature(uc[wver][\"members\"]):\n log(\"Matched %s, ver %d to ver %d\" % \n (cls, wire_version, wver))\n # have a match with existing version\n uc[wire_version][\"use_version\"] = wver\n # What else to do?\n return\n else: # Haven't seen this entry before\n log(\"Adding %s to unified list, ver %d\" % (cls, wire_version))\n of_g.unified[cls] = dict(union={})\n uc = of_g.unified[cls]\n\n # At this point, need to add members for this version\n uc[wire_version] = dict(members = members)\n\n # Per member processing:\n # Add to union list (I'm sure there's a better way)\n # Check if it's a list\n union = uc[\"union\"]\n if not cls in of_g.ordered_members:\n of_g.ordered_members[cls] = []\n for member in members:\n m_name = member[\"name\"]\n m_type = member[\"m_type\"]\n if m_name.find(\"pad\") == 0:\n continue\n if m_name in union:\n if not m_type == union[m_name][\"m_type\"]:\n debug(\"ERROR: CLASS: %s. VERSION %d. MEMBER: %s. TYPE: %s\" %\n (cls, wire_version, m_name, m_type))\n debug(\" Type conflict adding member to unified set.\")\n debug(\" Current union[%s]:\" % m_name)\n debug(union[m_name])\n sys.exit(1)\n else:\n union[m_name] = dict(m_type=m_type, memid=memid)\n memid += 1\n if not m_name in of_g.ordered_members[cls]:\n of_g.ordered_members[cls].append(m_name)","def update_class_info(self):\n\n for eachModule in self.package_info.module_info:\n if eachModule.use_all_classes:\n classes = self.source_ns.classes(allow_empty=True)\n for eachClass in classes:\n if eachModule.is_decl_in_source_path(eachClass):\n class_info = CppClassInfo(eachClass.name)\n class_info.module_info = eachModule\n class_info.decl = eachClass\n eachModule.class_info.append(class_info)\n else:\n for eachClass in eachModule.class_info:\n classes = self.source_ns.classes(eachClass.name,\n allow_empty=True)\n if len(classes) == 1:\n eachClass.decl = classes[0]","def class_to_db(self):","def add_class(self, new_class):\n index = self._counter\n self._counter += 1\n for element in new_class:\n self._class_names[element] = index\n node = self.part[index].append(element)\n self._place[element] = node","def do_update(self, arg):\n if len(arg) == 0:\n print(\"** class name missing **\")\n return\n coms = tuple(arg.split())\n if coms[0] not in self.cls:\n print(\"** class doesn't exist **\")\n elif len(coms) < 2:\n print(\"** instance id missing **\")\n return\n obj = coms[0] + \".\" + coms[1]\n if obj not in storage.all().keys():\n print(\"** no instance found **\")\n elif len(coms) < 3:\n print(\"** attribute name missing **\")\n elif len(coms) < 4:\n print(\"** value missing **\")\n else:\n typecast = type(eval(coms[3]))\n form = coms[3].strip('\"')\n form = form.strip(\"'\")\n setattr(storage.all()[obj], coms[2], typecast(form))","def save_class_representation(self):\n class_dict = {}\n for key, value in self.class_dict.items():\n class_dict['-'.join(key)] = list(value)\n with open('data/class_vectors.txt', 'w') as file:\n json.dump(class_dict, file)\n return class_dict","def _class(self, _class):\n\n self.__class = _class","def _class(self, _class):\n\n self.__class = _class","def updateData(self, *args):\n # if self.move_next_option == \"R\":\n # self.restSampling()\n # elif self.move_next_option == \"A\":\n # self.addExtra()\n # else:\n # self.continueReview()\n for name, value in self.parameter_inputs.items():\n self.parameters[name] = value.value\n # directly change the value of class variables\n logMsg((\"update settings: \", self.ml_classifier_cls, name, value.value))\n setattr(self.ml_classifier_cls, name, value.value)\n\n pass","def increment_classes(self, num_classes):\n # Record number of input and output features for existing network\n in_features = self.model.fc.in_features\n out_features = self.model.fc.out_features\n # Record weight and bias values\n weight = self.model.fc.weight.data\n bias = self.model.fc.bias.data\n\n # If first task\n if self.seen_classes == 0:\n new_out_features = num_classes\n else:\n # Extend fc layer by number of new classes\n new_out_features = out_features + num_classes\n\n # Create new fc layer for the network\n self.model.fc = nn.Linear(in_features, new_out_features)\n\n # Init as per LwF paper\n kaiming_normal_init(self.model.fc.weight)\n # Reassign recorded weight and bias values to new layer\n self.model.fc.weight.data[:out_features] = weight\n self.model.fc.bias.data[:out_features] = bias\n # Increment number of classes\n self.n_classes += num_classes","def reset_class(self, classes):\r\n self._clear_cached_op()\r\n self._classes = classes\r\n if self._pos_iou_thresh >= 1:\r\n self._target_generator = YOLOV3TargetMerger(len(classes), self._ignore_iou_thresh)\r\n for outputs in self.yolo_outputs:\r\n outputs.reset_class(classes)","def update(\n self, outputs: torch.Tensor, targets: torch.Tensor\n ) -> Tuple[Any, Any, Any, Any]:\n tn, fp, fn, tp, support, num_classes = super().update(\n outputs=outputs, targets=targets\n )\n per_class, micro, macro, weighted = get_aggregated_metrics(\n tp=tp, fp=fp, fn=fn, support=support, zero_division=self.zero_division\n )\n if self.num_classes is None:\n self.num_classes = num_classes\n\n return per_class, micro, macro, weighted","def update(\n self, outputs: torch.Tensor, targets: torch.Tensor\n ) -> Tuple[Any, Any, Any, Any]:\n tn, fp, fn, tp, support, num_classes = super().update(\n outputs=outputs, targets=targets\n )\n per_class, micro, macro, weighted = get_aggregated_metrics(\n tp=tp, fp=fp, fn=fn, support=support, zero_division=self.zero_division\n )\n if self.num_classes is None:\n self.num_classes = num_classes\n\n return per_class, micro, macro, weighted","def update(self, class_name, **kwargs):\n\n class_obj = self.get(class_name)\n class_obj.update(kwargs)\n response = self.client.post(Classes.PATH_CLASS_TEMPLATE.format(class_name=class_name), body=class_obj)\n return response","def changeClass(self, newClass):\n\t\turl = \"https://habitica.com/api/v3/user/change-class?class=\" + newClass\n\t\treturn(postUrl(url, self.credentials))","def update(self, class_name, args, stored_objects):\n id_list = [k.split(\".\")[1] for k in stored_objects]\n instance = \"{}.{}\".format(class_name, args[0])\n obj = stored_objects[instance]\n '''convert to the right attribute value type'''\n setattr(obj, args[1], args[2])\n models.storage.save()","def AddClassWithInitialMean(self, mean: 'double') -> \"void\":\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIUC2IUC2_AddClassWithInitialMean(self, mean)","def change_class_labels_back(classes,given):\n classes=np.asarray(classes)\n classes_new=np.zeros(classes.shape,dtype=object)\n for i in range(len(given)):\n classes_new[classes==i]=given[i]\n return classes_new","def update(self):\n\n pass","def update(self):\n self.data.update()\n\n sensor_type = self.entity_description.key\n if sensor_type == \"light\":\n self._attr_native_value = self.data.light\n elif sensor_type == \"light_red\":\n self._attr_native_value = self.data.light_red\n elif sensor_type == \"light_green\":\n self._attr_native_value = self.data.light_green\n elif sensor_type == \"light_blue\":\n self._attr_native_value = self.data.light_blue\n elif sensor_type == \"accelerometer_x\":\n self._attr_native_value = self.data.accelerometer_x\n elif sensor_type == \"accelerometer_y\":\n self._attr_native_value = self.data.accelerometer_y\n elif sensor_type == \"accelerometer_z\":\n self._attr_native_value = self.data.accelerometer_z\n elif sensor_type == \"magnetometer_x\":\n self._attr_native_value = self.data.magnetometer_x\n elif sensor_type == \"magnetometer_y\":\n self._attr_native_value = self.data.magnetometer_y\n elif sensor_type == \"magnetometer_z\":\n self._attr_native_value = self.data.magnetometer_z\n elif sensor_type == \"temperature\":\n self._attr_native_value = self.data.temperature\n elif sensor_type == \"pressure\":\n self._attr_native_value = self.data.pressure\n elif sensor_type == \"voltage_0\":\n self._attr_native_value = self.data.voltage_0\n elif sensor_type == \"voltage_1\":\n self._attr_native_value = self.data.voltage_1\n elif sensor_type == \"voltage_2\":\n self._attr_native_value = self.data.voltage_2\n elif sensor_type == \"voltage_3\":\n self._attr_native_value = self.data.voltage_3","def process_class_list(self, module, classes):","def update(self):\n raise NotImplementedError","def update(self):\n\n raise NotImplementedError('Must be implemented by subclasses')","def unify_input():\n\n global versions\n\n # Add classes to unified in wire-format order so that it is easier \n # to generate things later\n keys = versions.keys()\n keys.sort(reverse=True)\n for version in keys:\n wire_version = versions[version][\"wire_version\"]\n classes = versions[version][\"classes\"]\n for cls in of_g.ordered_classes[wire_version]:\n add_class(wire_version, cls, classes[cls])","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update_classifiers(self, multiclass=True, binary_classifier=False):\n try:\n self.clf_builder.initialize_classification_models(multiclass, binary_classifier)\n response = \"\"\n if multiclass:\n response += \"Multiclass classifiers updated.\"\n if binary_classifier:\n response += \"Binary_classifiers updated\"\n return response\n except ClassificationModelError as error:\n raise UpdaterError(error.value)","def AddClassWithInitialMean(self, mean: 'double') -> \"void\":\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIUS2IUC2_AddClassWithInitialMean(self, mean)","def quotient(self, classes):\n new = self.empty_copy()\n state_mapping = {}\n\n # Create new states and build state_mapping\n for c in classes:\n new_label = tuple(c)\n new_state = c[0].relabeled(new_label)\n new.add_state(new_state)\n for state in c:\n state_mapping[state] = new_state\n\n # Copy data from old transducer\n for c in classes:\n new_state = state_mapping[c[0]]\n sorted_transitions = sorted(\n [(state_mapping[t.to_state], t.word_in, t.word_out)\n for t in c[0].transitions])\n for transition in self.iter_transitions(c[0]):\n new.add_transition(\n from_state = new_state,\n to_state = state_mapping[transition.to_state],\n word_in = transition.word_in,\n word_out = transition.word_out)\n\n # check that all class members have the same information (modulo classes)\n for state in c:\n new_state.is_initial = new_state.is_initial or state.is_initial\n assert new_state.is_final == state.is_final, \\\n \"Class %s mixes final and non-final states\" % (c,)\n assert new_state.word_out == state.word_out, \\\n \"Class %s mixes different word_out\" % (c,)\n assert new_state.color == state.color, \\\n \"Class %s mixes different colors\" % (c,)\n assert sorted_transitions == sorted(\n [(state_mapping[t.to_state], t.word_in, t.word_out)\n for t in state.transitions]), \\\n \"Transitions of state %s and %s are incompatible.\" % (c[0], state)\n assert new_state.final_word_out == state.final_word_out, \\\n \"Class %s mixes final states with different \" \\\n \"final output words.\" % (c,)\n return new","def AddClassWithInitialMean(self, mean: 'double') -> \"void\":\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIUC2IUS2_AddClassWithInitialMean(self, mean)","def update(self):\n raise NotImplementedError()","def AddClassWithInitialMean(self, mean: 'double') -> \"void\":\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIUS2IUS2_AddClassWithInitialMean(self, mean)","def update(self):\r\n pass","def do_update(self, args):\n args = args.split()\n if len(args) == 0:\n print(\"** class name missing **\")\n return\n if len(args) == 1:\n print(\"** instance id missing **\")\n return\n if len(args) == 2:\n print(\"** attribute name missing **\")\n return\n if len(args) == 3:\n print(\"** value missing **\")\n return\n if args[0] not in HBNBCommand.valid_classes.keys():\n print(\"** class doesn't exist **\")\n return\n all_objs = storage.all(args[0])\n for k, v in all_objs.items():\n if k == args[1]:\n setattr(v, args[2], args[3])\n storage.save()\n return\n print(\"** no instance found **\")","def AddClassWithInitialMean(self, mean: 'double') -> \"void\":\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIF2IUC2_AddClassWithInitialMean(self, mean)","def update_attributes_map(klass):\n\n return {\n 'name': '',\n 'default_locale': ''\n }","def AddClassWithInitialMean(self, mean: 'double') -> \"void\":\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIF2IUS2_AddClassWithInitialMean(self, mean)","def __init__(self):\r\n self.unique_classes = []\r\n self.total_classes_number = 0\r\n self.class_number_dict = {}\r\n self.unique_word_number = 0\r\n self.class_word_number_dict = {}\r\n self.class_total_words_dict = {}","def __setstate__(self, state):\r\n\r\n \"\"\"# Support adding a new member not previously defined in the class\r\n if 'new_member' not in state:\r\n self.new_member = \"new value\"\r\n self.__dict__.update(state)\"\"\"\r\n\r\n \"\"\" # Support removing old members not in new version of class\r\n if 'old_member' in state:\r\n # If you want: do something with the old member\r\n del state['old_member']\r\n self.__dict__.update(state) \"\"\"\r\n\r\n del state['_background_image']\r\n\r\n if '_background_image_data' not in state:\r\n print \"Detected old version of saved file!\"\r\n self._background_image_data = QtCore.QByteArray()\r\n\r\n\r\n if isinstance(state['_features'], list):\r\n for feature in state['_features']:\r\n self._append_feature(feature)\r\n del state['_features']\r\n\r\n self.__init__()\r\n self.__dict__.update(state)\r\n\r\n if isinstance(state['_features'], dict):\r\n\r\n for _id, feature in state['_features'].iteritems():\r\n if feature.get_feature_type() == 'Fuse':\r\n self._fuse_tree_item_model.addChild(feature, None)","def do_update(self, args):\n args = shlex.split(args)\n if len(args) == 0:\n print(\"** class name missing **\")\n elif not args[0] in class_type:\n print(\"** class doesn't exist **\")\n elif len(args) == 1:\n print(\"** instance id missing **\")\n elif (\"{}.{}\".format(args[0], args[1]) not in storage.all().keys()):\n print(\"** no instance found **\")\n elif len(args) == 2:\n print(\"** attribute name missing **\")\n elif len(args) == 3:\n print(\"** value missing **\")\n else:\n new_dict = models.storage.all()\n tmp = \"{}.{}\".format(args[0], args[1])\n if tmp in new_dict.keys():\n attr = getattr(new_dict[tmp], args[2], \"\")\n setattr(new_dict[tmp], args[2], type(attr)(args[3]))\n new_dict[tmp].save()","def _update(self):\n pass","def update(self, example, hypercubes_coords=None):\n hypercubes_coords = tuple(\n [int(example.coords[i] / self.hypercube_measurements[i]) for i in range(self.dims - 1, -1, -1)])\n new_class = self.hypercubes[hypercubes_coords].update_basic(example_list=[example])\n print(\"Update. Changed class of \" + str(hypercubes_coords) + \" to: \" + str(new_class))\n if self.child_grid:\n self.child_grid.update(example=example, hypercubes_coords=hypercubes_coords)","def do_update(self, line):\n try:\n tokens = split(line)\n except ValueError:\n return None\n if len(tokens) < 1:\n print(\"** class name missing **\")\n else:\n objects = models.storage.all()\n cls = models.getmodel(tokens[0])\n if cls is None:\n print(\"** class doesn't exist **\")\n elif len(tokens) < 2:\n print(\"** instance id missing **\")\n elif \".\".join(tokens[:2]) not in objects:\n print(\"** no instance found **\")\n elif len(tokens) < 3:\n print(\"** attribute name missing **\")\n elif len(tokens) < 4:\n print(\"** value missing **\")\n else:\n obj = objects[\".\".join(tokens[:2])]\n for key, value in zip(tokens[2::2], tokens[3::2]):\n try:\n setattr(obj, key, int(value))\n except ValueError:\n try:\n setattr(obj, key, float(value))\n except ValueError:\n try:\n setattr(obj, key, str(value))\n except ValueError:\n pass\n obj.save()","def _set_attributes(self):","def AddClassWithInitialMean(self, mean: 'double') -> \"void\":\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterISS2IUC2_AddClassWithInitialMean(self, mean)","def update(self, example, hypercubes_coords):\n hypercubes_coords = tuple([int(x / 2) for x in hypercubes_coords])\n new_class = self.hypercubes[hypercubes_coords].update_lower_level(example_class=example.class_id, example_count=1, threshold=self.threshold)\n print(\"Update. Changed class of \" + str(hypercubes_coords) + \" to: \" + str(new_class))\n if self.child_grid:\n self.child_grid.update(example=example, hypercubes_coords=hypercubes_coords)","def update(self, loss, pred_classes, gold_classes, pred_probas=None,\n gold_probas=None):\n self.loss += loss\n self.nb_batches += 1\n # unmask & flatten predictions and gold labels before storing them\n mask = gold_classes != constants.TARGET_PAD_ID\n self.pred_classes.extend(unroll(unmask(pred_classes, mask)))\n self.gold_classes.extend(unroll(unmask(gold_classes, mask)))\n if pred_probas is not None and gold_probas is not None:\n self.pred_probas.extend(unroll(unmask(pred_probas, mask)))\n self.gold_probas.extend(unroll(unmask(gold_probas, mask)))","def AddClassWithInitialMean(self, mean: 'double') -> \"void\":\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterISS2IUS2_AddClassWithInitialMean(self, mean)","def update(self, container, representation):\n pass","def _set_class_weight(self, class_weight, classes, y):\n if class_weight is None:\n class_weight = self.class_weight\n if class_weight is None or len(class_weight) == 0:\n weight = np.ones(classes.shape[0], dtype=np.float64, order='C')\n elif class_weight == 'auto':\n weight = np.array([1.0 / np.sum(y == i) for i in classes],\n dtype=np.float64, order='C')\n weight *= classes.shape[0] / np.sum(weight)\n else:\n weight = np.ones(classes.shape[0], dtype=np.float64, order='C')\n if not isinstance(class_weight, dict):\n raise ValueError(\"class_weight must be dict, 'auto', or None,\"\n \" got: %r\" % class_weight)\n for c in class_weight:\n i = np.searchsorted(classes, c)\n if classes[i] != c:\n raise ValueError(\"Class label %d not present.\" % c)\n else:\n weight[i] = class_weight[c]\n\n self._expanded_class_weight = weight","def update_classes_and_origins(\n origin_list_, champions_list_, origin_counters_, class_list_, class_counters_\n):\n logging.debug(\"Function update_classes_and_origins() called\")\n\n update_origins(origin_list_, champions_list_, origin_counters_)\n update_classes(class_list_, champions_list_, class_counters_)\n\n logging.debug(\"Function update_classes_and_origins() end\")","def updateClusterInfo(self):\n self.nPoints = len(self.labels)\n self.n = len(np.unique(self.labels))\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]","def update(self):","def update(self):","def update(self):","def AddClassWithInitialMean(self, mean: 'double') -> \"void\":\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIUS2ISS2_AddClassWithInitialMean(self, mean)","def AddClassWithInitialMean(self, mean: 'double') -> \"void\":\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIUC2ISS2_AddClassWithInitialMean(self, mean)","def change_class_labels(classes):\n u,indices=np.unique(classes,return_inverse=True)\n return u,indices","def update_weights(self):\n\t\tpass","def AddClassWithInitialMean(self, mean: 'double') -> \"void\":\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIF2ISS2_AddClassWithInitialMean(self, mean)","def AddClassWithInitialMean(self, mean: 'double') -> \"void\":\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIUC3IUC3_AddClassWithInitialMean(self, mean)","def annihilate(cls):\n pass","def update_entities(self):\n raise NotImplementedError()","def calc_class_weights(self):\n y = self.train_eval_data[\"sentiment\"]\n self.class_weights = {}\n classes = np.unique(y)\n for cls in classes:\n self.class_weights[cls] = len(y) / (len(classes) * (y == cls).sum())","def record_class_examined(self, cls):\n serialized = self.serialize_type(cls)\n if serialized is not None:\n self.classes_examined.add(serialized)","def __init__(self, classes, alpha=1.0):\n self.alpha_ = alpha\n self.classes_ = classes.tolist()\n self.class_counts_ = self.alpha_*np.ones(len(self.classes_))\n self.features_ = []","def AddClassWithInitialMean(self, mean: 'double') -> \"void\":\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterISS2ISS2_AddClassWithInitialMean(self, mean)","def sync_attributes(self, sync_imported=False):\n for cls in itertools.chain(self.classes(), self.object_properties(),\n self.individuals()):\n if not cls.label:\n try:\n cls.label.append(cls.__name__)\n except:\n cls.label.append(cls._name)\n if not cls.comment and cls.__doc__:\n cls.comment.append(inspect.cleandoc(cls.__doc__))\n if sync_imported:\n for onto in self.imported_ontologies:\n onto.sync_attributes()","def __init__(self):\n self.classes = {}","def _update_mask_attributes(self, sitk_im=None):\n if sitk_im is None:\n sitk_im = self.sitk_image\n np_type = IMTYPE_2_NP[self.type]\n array = self.get_array(sitk_im, np_type, isotropic=False)\n unique, counts = np.unique(array, return_counts=True)\n \n num_classes = len(unique)\n msg = (f'Given {self.num_classes} classes, but this mask has '\n f'{num_classes} unique values!')\n assert len(self._class_names) >= num_classes, msg\n \n # check if unique values match up with associated class values\n given_vals = self._given_class_values\n if given_vals is None or len(given_vals) == 0:\n pre_msg = (f'During mask init, you gave no class_values, so it was '\n f'defaulted to {self._class_values}. ')\n else:\n pre_msg = (f'During mask init, you gave these class_values: '\n f'{self._class_values}.')\n post_msg = (f'When loading the image, it contained values '\n f'({unique}) that were not defined in \"class_values\".')\n msg = pre_msg + post_msg\n for unique_val in unique:\n assert unique_val in self._class_values, msg\n \n class_counts = np.array([0] * self.num_classes)\n for u, c in zip(unique, counts):\n cid = self.class_values.index(u)\n class_counts[cid] = c\n self._class_counts = class_counts\n \n self._unique_values = unique","def make_classdict(self):\n\t\ttarget_names = self.fetched[\"train\"].target_names\n\t\tself.classdict = {target_names[idx]: idx for idx in range(len(target_names))}","def update(self) -> None:\n pass","def update(self) -> None:\n pass"],"string":"[\n \"def update_class_records():\\n logger.info('Fetching class ids and labels for '\\n 'classes with direct instances')\\n timestamp = statistics.get_current_timestamp()\\n results = sparql.sparql_query(queries.QUERY_CLASSES,\\n fallback=queries.QUERY_CLASSSES_FALLBACK)\\n\\n if 'error' in results:\\n logger.error('Got no SPARQL results.')\\n return\\n\\n updated = {}\\n\\n def value(binding, key):\\n return binding[key]['value']\\n\\n for binding in results['results']['bindings']:\\n uri = value(binding, 'cl')\\n if not sparql.is_wikidata_entity(uri):\\n continue\\n\\n qid = sparql.wikidata_entity_id(uri)\\n label = value(binding, 'clLabel')\\n record = {'l': label, }\\n\\n if 'c' in binding:\\n record['i'] = int(value(binding, 'c'))\\n updated[qid] = record\\n\\n logger.info('Augmenting current classes data ...')\\n data = statistics.get_json_data('classes')\\n merged = statistics.merge(data, updated, default_others={'i': 0})\\n statistics.update_json_data('classes', merged, timestamp)\",\n \"def update_class(self, class_info):\\n SchemaValidator(self.schema_extension_only, self.schema_nx).validate_class_schema(class_info)\\n self.schema[\\\"@graph\\\"].append(class_info)\\n self.load_schema(self.schema)\\n print(\\\"Updated the class {} successfully!\\\".format(class_info[\\\"rdfs:label\\\"]))\",\n \"def class_adjustment(self):\\n self.ABILITIES_ORDER = fetch_data.get_abilities_order(self.ch_class)\\n\\n for key in self.SAVES_LVLS:\\n self.SAVES_LVLS[key] = fetch_data.get_class_saves(key, self.ch_class)\\n\\n self.CLASS_SKILLS = fetch_data.get_class_skills(self.ch_class)\\n self.SKILL_POINTS_MOD = fetch_data.get_skillp_modifier(self.ch_class)\\n self.HIT_DIE = fetch_data.get_hit_die(self.ch_class)\\n self.BASE_ATTACK_LVLS = fetch_data.get_class_base_attack(self.ch_class)\",\n \"def update_class(self):\\n neighbors_set = list(set(self.neighbors))\\n counts = np.array([self.neighbors.count(n) for n in neighbors_set])\\n probs = (counts / counts.sum()) * (1-self.mutation_prob)\\n probs = np.append(probs, self.mutation_prob)\\n neighbors_set.append(np.random.choice(np.arange(1, self.board.classes))) \\n\\n self.cell_class = np.random.choice(neighbors_set, p=probs)\",\n \"def update_derived_class_records():\\n derive_class_hierarchy()\",\n \"def update(cls, recommender, instance_changes):\",\n \"def do_update(self, *args):\\n if len(args) == 1:\\n args = [ele for ele in args[0].split(' ')]\\n if args[0] == '':\\n print(\\\"** class name missing **\\\")\\n return\\n if args[0] not in self.list_classes:\\n print(\\\"** class doesn't exist **\\\")\\n return\\n if len(args) < 2:\\n print(\\\"** instance id missing **\\\")\\n return\\n elif len(args) < 3:\\n print(\\\"** attribute name missing **\\\")\\n return\\n elif len(args) < 4:\\n print(\\\"** value missing **\\\")\\n return\\n\\n storage.reload()\\n dict_objs = storage.all()\\n if dict_objs is None or dict_objs == []:\\n print(\\\"** no instance found **\\\")\\n return\\n\\n key = \\\"{}.{}\\\".format(args[0], args[1])\\n if key in dict_objs.keys():\\n obj = dict_objs[key]\\n if args[2] in obj.__class__.__dict__:\\n obj.__dict__[args[2]] =\\\\\\n type(obj.__class__.__dict__[args[2]])(args[3])\\n else:\\n obj.__dict__[args[2]] = args[3]\\n storage.save()\\n else:\\n print(\\\"** no instance found **\\\")\",\n \"def apply_class_changes(self, old_class, new_class):\\n new_class.id = old_class.id\\n if old_class.json() == new_class.json():\\n logger.info(\\\"No differences detected for %s\\\", old_class)\\n return old_class\\n\\n class_rename = bool(old_class.name != new_class.name)\\n _, modified_attributes, deleted_attrs = compare_fixture_classes(old_class, new_class)\\n if any([modified_attributes, deleted_attrs, class_rename]):\\n mutation = {}\\n if class_rename:\\n logger.info(\\\"Fixture class renamed from %s -> %s\\\", old_class.name, new_class.name)\\n mutation['$set'] = {'mtime' : int(time.time() * 1e6)}\\n mutation['$set']['class_name'] = new_class.name\\n\\n for attr_name in modified_attributes:\\n new_attr_def = new_class.attributes[attr_name]\\n old_attr_def = old_class.attributes[attr_name]\\n old_is_array = 'array' in old_attr_def.get('flags', '')\\n new_is_array = 'array' in new_attr_def.get('flags', '')\\n if old_attr_def['type'] != new_attr_def['type'] or old_is_array != new_is_array:\\n logger.warning(\\\"Data type of %s changed (%s -> %s) (array: %s -> %s). Dropping old column values\\\",\\n attr_name, old_attr_def['type'], new_attr_def['type'], old_is_array, new_is_array)\\n deleted_attrs.append(attr_name)\\n\\n if deleted_attrs:\\n mutation['$unset'] = {}\\n mutation['$set'] = {'mtime' : int(time.time() * 1e6)}\\n for attr_name in deleted_attrs:\\n logger.info(\\\"Deleting class attribute: %s.%s\\\", new_class.name, attr_name)\\n mutation['$unset']['attributes.{}'.format(attr_name)] = \\\"\\\"\\n\\n if mutation:\\n # update all active fixtures with the change (don't touch deleted instances)\\n query = {'class_id' : old_class.id, 'deleted': False}\\n self._batch_update(query, mutation)\\n else:\\n logger.info(\\\"No instance updates to apply\\\")\\n\\n self.axdb_client.update_fixture_class(new_class.axdbdoc())\\n logger.info(\\\"%s updated:\\\\n%s\\\", new_class, pretty_json(new_class.json()))\\n self.reqproc.trigger_processor()\\n return new_class\",\n \"def finalize_class_set(self) -> None:\\n logger.info(\\\"We have {} distinct classes, let's cluster it!\\\", len(self.classes))\\n\\n logger.debug(\\\"Created a cluster instance {} and this will cluster {} samples\\\", self.cluster, self.classes)\\n try:\\n assigned_clusters = self.cluster.cluster(vectors=[self.convert_str_list_to_vector(c) for c in self.classes],\\n assign_clusters=True, trace=not execute_on_ssh_compute)\\n except Exception:\\n logger.exception(\\\"Failed to cluster the actual class set ({} samples)\\\", len(self.classes))\\n return\\n\\n self.classes_to_one_hot_encode_dict.clear()\\n for i in range(len(self.classes)):\\n self.classes_to_one_hot_encode_dict[self.classes[i]] = assigned_clusters[i]\",\n \"def update(cls) -> None:\\n raise NotImplementedError\",\n \"def update_classes(class_list_, champions_list_, class_counters_):\\n logging.debug(\\\"Function update_classes() called\\\")\\n\\n class_counters_value_list = [0] * len(class_list_)\\n for i, class_ in enumerate(class_list_): # looping over counters for every class\\n logging.info(\\\"Current class: %s\\\", class_)\\n for (\\n champ\\n ) in (\\n champions_list_\\n ): # for loop to assign how much champions are nonzero in class\\n if champ.ChampCounter.get() >= 1:\\n logging.info(\\\"Current champ with counter >=1: %s\\\", champ.name)\\n if class_ in (champ.class_prim, champ.class_sec):\\n logging.info(\\n \\\"Current champ with counter >=1 match class Prim or Sec \\\\\\n : %s or %s\\\",\\n champ.class_prim,\\n champ.class_sec,\\n )\\n class_counters_value_list[i] = class_counters_value_list[i] + 1\\n logging.info(\\n \\\"Number of nonzero champions in this class = %s\\\",\\n class_counters_value_list[i],\\n )\\n class_counters_[i].set(class_counters_value_list[i])\\n\\n logging.debug(\\\"Function update_classes() end\\\")\",\n \"def update(self) -> None:\\n self.faithful = self.is_faithful()\\n if self.faithful:\\n old_class_names = self.class_names\\n old_training_image_names = self.training_image_names\\n self.class_names = self.find_class_names()\\n self.training_image_names = self.find_training_image_names()\\n self.extracted_features = list()\\n if old_class_names != self.class_names or old_training_image_names != self.training_image_names:\\n self.generate_csv_dictionary()\\n return\",\n \"def load_classes(self):\\n super().load_classes()\\n from scipy.io import loadmat\\n mat_path = os.path.join(self.input_data_path, \\\"index_ade20k.mat\\\")\\n object_names = loadmat(mat_path)['index']['objectnames'][0][0][0]\\n self.ADE20K_CLASSES = {}\\n self.ADE20K_CLASSES_reverse = {}\\n for i in range(len(object_names)):\\n self.ADE20K_CLASSES[object_names[i][0]] = i+1\\n self.ADE20K_CLASSES_reverse[i+1] = object_names[i][0]\\n if i == 3:\\n logger.debug(f\\\"ADE20K_CLASSES: {self.ADE20K_CLASSES}\\\")\\n logger.debug(f\\\"ADE20K_CLASSES_reverse: {self.ADE20K_CLASSES_reverse}\\\")\",\n \"def process_class(self, parent, cls):\\n if cls.typemap.flat_name in self.class_map:\\n raise RuntimeError(\\\"process_class: class {} already exists in class_map\\\"\\n .format(cls.typemap.flat_name))\\n self.class_map[cls.typemap.flat_name] = cls\\n for var in cls.variables:\\n self.add_var_getter_setter(parent, cls, var)\\n cls.functions = self.define_function_suffix(cls.functions)\",\n \"def add_class(wire_version, cls, members):\\n memid = 0\\n\\n sig = loxi_utils.class_signature(members)\\n if cls in of_g.unified:\\n uc = of_g.unified[cls]\\n if wire_version in uc:\\n debug(\\\"Error adding %s to unified. Wire ver %d exists\\\" %\\n (cls, wire_version))\\n sys.exit(1)\\n uc[wire_version] = {}\\n # Check for a matching signature\\n for wver in uc:\\n if type(wver) != type(0): continue\\n if wver == wire_version: continue\\n if not \\\"use_version\\\" in uc[wver]:\\n if sig == loxi_utils.class_signature(uc[wver][\\\"members\\\"]):\\n log(\\\"Matched %s, ver %d to ver %d\\\" % \\n (cls, wire_version, wver))\\n # have a match with existing version\\n uc[wire_version][\\\"use_version\\\"] = wver\\n # What else to do?\\n return\\n else: # Haven't seen this entry before\\n log(\\\"Adding %s to unified list, ver %d\\\" % (cls, wire_version))\\n of_g.unified[cls] = dict(union={})\\n uc = of_g.unified[cls]\\n\\n # At this point, need to add members for this version\\n uc[wire_version] = dict(members = members)\\n\\n # Per member processing:\\n # Add to union list (I'm sure there's a better way)\\n # Check if it's a list\\n union = uc[\\\"union\\\"]\\n if not cls in of_g.ordered_members:\\n of_g.ordered_members[cls] = []\\n for member in members:\\n m_name = member[\\\"name\\\"]\\n m_type = member[\\\"m_type\\\"]\\n if m_name.find(\\\"pad\\\") == 0:\\n continue\\n if m_name in union:\\n if not m_type == union[m_name][\\\"m_type\\\"]:\\n debug(\\\"ERROR: CLASS: %s. VERSION %d. MEMBER: %s. TYPE: %s\\\" %\\n (cls, wire_version, m_name, m_type))\\n debug(\\\" Type conflict adding member to unified set.\\\")\\n debug(\\\" Current union[%s]:\\\" % m_name)\\n debug(union[m_name])\\n sys.exit(1)\\n else:\\n union[m_name] = dict(m_type=m_type, memid=memid)\\n memid += 1\\n if not m_name in of_g.ordered_members[cls]:\\n of_g.ordered_members[cls].append(m_name)\",\n \"def update_class_info(self):\\n\\n for eachModule in self.package_info.module_info:\\n if eachModule.use_all_classes:\\n classes = self.source_ns.classes(allow_empty=True)\\n for eachClass in classes:\\n if eachModule.is_decl_in_source_path(eachClass):\\n class_info = CppClassInfo(eachClass.name)\\n class_info.module_info = eachModule\\n class_info.decl = eachClass\\n eachModule.class_info.append(class_info)\\n else:\\n for eachClass in eachModule.class_info:\\n classes = self.source_ns.classes(eachClass.name,\\n allow_empty=True)\\n if len(classes) == 1:\\n eachClass.decl = classes[0]\",\n \"def class_to_db(self):\",\n \"def add_class(self, new_class):\\n index = self._counter\\n self._counter += 1\\n for element in new_class:\\n self._class_names[element] = index\\n node = self.part[index].append(element)\\n self._place[element] = node\",\n \"def do_update(self, arg):\\n if len(arg) == 0:\\n print(\\\"** class name missing **\\\")\\n return\\n coms = tuple(arg.split())\\n if coms[0] not in self.cls:\\n print(\\\"** class doesn't exist **\\\")\\n elif len(coms) < 2:\\n print(\\\"** instance id missing **\\\")\\n return\\n obj = coms[0] + \\\".\\\" + coms[1]\\n if obj not in storage.all().keys():\\n print(\\\"** no instance found **\\\")\\n elif len(coms) < 3:\\n print(\\\"** attribute name missing **\\\")\\n elif len(coms) < 4:\\n print(\\\"** value missing **\\\")\\n else:\\n typecast = type(eval(coms[3]))\\n form = coms[3].strip('\\\"')\\n form = form.strip(\\\"'\\\")\\n setattr(storage.all()[obj], coms[2], typecast(form))\",\n \"def save_class_representation(self):\\n class_dict = {}\\n for key, value in self.class_dict.items():\\n class_dict['-'.join(key)] = list(value)\\n with open('data/class_vectors.txt', 'w') as file:\\n json.dump(class_dict, file)\\n return class_dict\",\n \"def _class(self, _class):\\n\\n self.__class = _class\",\n \"def _class(self, _class):\\n\\n self.__class = _class\",\n \"def updateData(self, *args):\\n # if self.move_next_option == \\\"R\\\":\\n # self.restSampling()\\n # elif self.move_next_option == \\\"A\\\":\\n # self.addExtra()\\n # else:\\n # self.continueReview()\\n for name, value in self.parameter_inputs.items():\\n self.parameters[name] = value.value\\n # directly change the value of class variables\\n logMsg((\\\"update settings: \\\", self.ml_classifier_cls, name, value.value))\\n setattr(self.ml_classifier_cls, name, value.value)\\n\\n pass\",\n \"def increment_classes(self, num_classes):\\n # Record number of input and output features for existing network\\n in_features = self.model.fc.in_features\\n out_features = self.model.fc.out_features\\n # Record weight and bias values\\n weight = self.model.fc.weight.data\\n bias = self.model.fc.bias.data\\n\\n # If first task\\n if self.seen_classes == 0:\\n new_out_features = num_classes\\n else:\\n # Extend fc layer by number of new classes\\n new_out_features = out_features + num_classes\\n\\n # Create new fc layer for the network\\n self.model.fc = nn.Linear(in_features, new_out_features)\\n\\n # Init as per LwF paper\\n kaiming_normal_init(self.model.fc.weight)\\n # Reassign recorded weight and bias values to new layer\\n self.model.fc.weight.data[:out_features] = weight\\n self.model.fc.bias.data[:out_features] = bias\\n # Increment number of classes\\n self.n_classes += num_classes\",\n \"def reset_class(self, classes):\\r\\n self._clear_cached_op()\\r\\n self._classes = classes\\r\\n if self._pos_iou_thresh >= 1:\\r\\n self._target_generator = YOLOV3TargetMerger(len(classes), self._ignore_iou_thresh)\\r\\n for outputs in self.yolo_outputs:\\r\\n outputs.reset_class(classes)\",\n \"def update(\\n self, outputs: torch.Tensor, targets: torch.Tensor\\n ) -> Tuple[Any, Any, Any, Any]:\\n tn, fp, fn, tp, support, num_classes = super().update(\\n outputs=outputs, targets=targets\\n )\\n per_class, micro, macro, weighted = get_aggregated_metrics(\\n tp=tp, fp=fp, fn=fn, support=support, zero_division=self.zero_division\\n )\\n if self.num_classes is None:\\n self.num_classes = num_classes\\n\\n return per_class, micro, macro, weighted\",\n \"def update(\\n self, outputs: torch.Tensor, targets: torch.Tensor\\n ) -> Tuple[Any, Any, Any, Any]:\\n tn, fp, fn, tp, support, num_classes = super().update(\\n outputs=outputs, targets=targets\\n )\\n per_class, micro, macro, weighted = get_aggregated_metrics(\\n tp=tp, fp=fp, fn=fn, support=support, zero_division=self.zero_division\\n )\\n if self.num_classes is None:\\n self.num_classes = num_classes\\n\\n return per_class, micro, macro, weighted\",\n \"def update(self, class_name, **kwargs):\\n\\n class_obj = self.get(class_name)\\n class_obj.update(kwargs)\\n response = self.client.post(Classes.PATH_CLASS_TEMPLATE.format(class_name=class_name), body=class_obj)\\n return response\",\n \"def changeClass(self, newClass):\\n\\t\\turl = \\\"https://habitica.com/api/v3/user/change-class?class=\\\" + newClass\\n\\t\\treturn(postUrl(url, self.credentials))\",\n \"def update(self, class_name, args, stored_objects):\\n id_list = [k.split(\\\".\\\")[1] for k in stored_objects]\\n instance = \\\"{}.{}\\\".format(class_name, args[0])\\n obj = stored_objects[instance]\\n '''convert to the right attribute value type'''\\n setattr(obj, args[1], args[2])\\n models.storage.save()\",\n \"def AddClassWithInitialMean(self, mean: 'double') -> \\\"void\\\":\\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIUC2IUC2_AddClassWithInitialMean(self, mean)\",\n \"def change_class_labels_back(classes,given):\\n classes=np.asarray(classes)\\n classes_new=np.zeros(classes.shape,dtype=object)\\n for i in range(len(given)):\\n classes_new[classes==i]=given[i]\\n return classes_new\",\n \"def update(self):\\n\\n pass\",\n \"def update(self):\\n self.data.update()\\n\\n sensor_type = self.entity_description.key\\n if sensor_type == \\\"light\\\":\\n self._attr_native_value = self.data.light\\n elif sensor_type == \\\"light_red\\\":\\n self._attr_native_value = self.data.light_red\\n elif sensor_type == \\\"light_green\\\":\\n self._attr_native_value = self.data.light_green\\n elif sensor_type == \\\"light_blue\\\":\\n self._attr_native_value = self.data.light_blue\\n elif sensor_type == \\\"accelerometer_x\\\":\\n self._attr_native_value = self.data.accelerometer_x\\n elif sensor_type == \\\"accelerometer_y\\\":\\n self._attr_native_value = self.data.accelerometer_y\\n elif sensor_type == \\\"accelerometer_z\\\":\\n self._attr_native_value = self.data.accelerometer_z\\n elif sensor_type == \\\"magnetometer_x\\\":\\n self._attr_native_value = self.data.magnetometer_x\\n elif sensor_type == \\\"magnetometer_y\\\":\\n self._attr_native_value = self.data.magnetometer_y\\n elif sensor_type == \\\"magnetometer_z\\\":\\n self._attr_native_value = self.data.magnetometer_z\\n elif sensor_type == \\\"temperature\\\":\\n self._attr_native_value = self.data.temperature\\n elif sensor_type == \\\"pressure\\\":\\n self._attr_native_value = self.data.pressure\\n elif sensor_type == \\\"voltage_0\\\":\\n self._attr_native_value = self.data.voltage_0\\n elif sensor_type == \\\"voltage_1\\\":\\n self._attr_native_value = self.data.voltage_1\\n elif sensor_type == \\\"voltage_2\\\":\\n self._attr_native_value = self.data.voltage_2\\n elif sensor_type == \\\"voltage_3\\\":\\n self._attr_native_value = self.data.voltage_3\",\n \"def process_class_list(self, module, classes):\",\n \"def update(self):\\n raise NotImplementedError\",\n \"def update(self):\\n\\n raise NotImplementedError('Must be implemented by subclasses')\",\n \"def unify_input():\\n\\n global versions\\n\\n # Add classes to unified in wire-format order so that it is easier \\n # to generate things later\\n keys = versions.keys()\\n keys.sort(reverse=True)\\n for version in keys:\\n wire_version = versions[version][\\\"wire_version\\\"]\\n classes = versions[version][\\\"classes\\\"]\\n for cls in of_g.ordered_classes[wire_version]:\\n add_class(wire_version, cls, classes[cls])\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update_classifiers(self, multiclass=True, binary_classifier=False):\\n try:\\n self.clf_builder.initialize_classification_models(multiclass, binary_classifier)\\n response = \\\"\\\"\\n if multiclass:\\n response += \\\"Multiclass classifiers updated.\\\"\\n if binary_classifier:\\n response += \\\"Binary_classifiers updated\\\"\\n return response\\n except ClassificationModelError as error:\\n raise UpdaterError(error.value)\",\n \"def AddClassWithInitialMean(self, mean: 'double') -> \\\"void\\\":\\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIUS2IUC2_AddClassWithInitialMean(self, mean)\",\n \"def quotient(self, classes):\\n new = self.empty_copy()\\n state_mapping = {}\\n\\n # Create new states and build state_mapping\\n for c in classes:\\n new_label = tuple(c)\\n new_state = c[0].relabeled(new_label)\\n new.add_state(new_state)\\n for state in c:\\n state_mapping[state] = new_state\\n\\n # Copy data from old transducer\\n for c in classes:\\n new_state = state_mapping[c[0]]\\n sorted_transitions = sorted(\\n [(state_mapping[t.to_state], t.word_in, t.word_out)\\n for t in c[0].transitions])\\n for transition in self.iter_transitions(c[0]):\\n new.add_transition(\\n from_state = new_state,\\n to_state = state_mapping[transition.to_state],\\n word_in = transition.word_in,\\n word_out = transition.word_out)\\n\\n # check that all class members have the same information (modulo classes)\\n for state in c:\\n new_state.is_initial = new_state.is_initial or state.is_initial\\n assert new_state.is_final == state.is_final, \\\\\\n \\\"Class %s mixes final and non-final states\\\" % (c,)\\n assert new_state.word_out == state.word_out, \\\\\\n \\\"Class %s mixes different word_out\\\" % (c,)\\n assert new_state.color == state.color, \\\\\\n \\\"Class %s mixes different colors\\\" % (c,)\\n assert sorted_transitions == sorted(\\n [(state_mapping[t.to_state], t.word_in, t.word_out)\\n for t in state.transitions]), \\\\\\n \\\"Transitions of state %s and %s are incompatible.\\\" % (c[0], state)\\n assert new_state.final_word_out == state.final_word_out, \\\\\\n \\\"Class %s mixes final states with different \\\" \\\\\\n \\\"final output words.\\\" % (c,)\\n return new\",\n \"def AddClassWithInitialMean(self, mean: 'double') -> \\\"void\\\":\\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIUC2IUS2_AddClassWithInitialMean(self, mean)\",\n \"def update(self):\\n raise NotImplementedError()\",\n \"def AddClassWithInitialMean(self, mean: 'double') -> \\\"void\\\":\\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIUS2IUS2_AddClassWithInitialMean(self, mean)\",\n \"def update(self):\\r\\n pass\",\n \"def do_update(self, args):\\n args = args.split()\\n if len(args) == 0:\\n print(\\\"** class name missing **\\\")\\n return\\n if len(args) == 1:\\n print(\\\"** instance id missing **\\\")\\n return\\n if len(args) == 2:\\n print(\\\"** attribute name missing **\\\")\\n return\\n if len(args) == 3:\\n print(\\\"** value missing **\\\")\\n return\\n if args[0] not in HBNBCommand.valid_classes.keys():\\n print(\\\"** class doesn't exist **\\\")\\n return\\n all_objs = storage.all(args[0])\\n for k, v in all_objs.items():\\n if k == args[1]:\\n setattr(v, args[2], args[3])\\n storage.save()\\n return\\n print(\\\"** no instance found **\\\")\",\n \"def AddClassWithInitialMean(self, mean: 'double') -> \\\"void\\\":\\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIF2IUC2_AddClassWithInitialMean(self, mean)\",\n \"def update_attributes_map(klass):\\n\\n return {\\n 'name': '',\\n 'default_locale': ''\\n }\",\n \"def AddClassWithInitialMean(self, mean: 'double') -> \\\"void\\\":\\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIF2IUS2_AddClassWithInitialMean(self, mean)\",\n \"def __init__(self):\\r\\n self.unique_classes = []\\r\\n self.total_classes_number = 0\\r\\n self.class_number_dict = {}\\r\\n self.unique_word_number = 0\\r\\n self.class_word_number_dict = {}\\r\\n self.class_total_words_dict = {}\",\n \"def __setstate__(self, state):\\r\\n\\r\\n \\\"\\\"\\\"# Support adding a new member not previously defined in the class\\r\\n if 'new_member' not in state:\\r\\n self.new_member = \\\"new value\\\"\\r\\n self.__dict__.update(state)\\\"\\\"\\\"\\r\\n\\r\\n \\\"\\\"\\\" # Support removing old members not in new version of class\\r\\n if 'old_member' in state:\\r\\n # If you want: do something with the old member\\r\\n del state['old_member']\\r\\n self.__dict__.update(state) \\\"\\\"\\\"\\r\\n\\r\\n del state['_background_image']\\r\\n\\r\\n if '_background_image_data' not in state:\\r\\n print \\\"Detected old version of saved file!\\\"\\r\\n self._background_image_data = QtCore.QByteArray()\\r\\n\\r\\n\\r\\n if isinstance(state['_features'], list):\\r\\n for feature in state['_features']:\\r\\n self._append_feature(feature)\\r\\n del state['_features']\\r\\n\\r\\n self.__init__()\\r\\n self.__dict__.update(state)\\r\\n\\r\\n if isinstance(state['_features'], dict):\\r\\n\\r\\n for _id, feature in state['_features'].iteritems():\\r\\n if feature.get_feature_type() == 'Fuse':\\r\\n self._fuse_tree_item_model.addChild(feature, None)\",\n \"def do_update(self, args):\\n args = shlex.split(args)\\n if len(args) == 0:\\n print(\\\"** class name missing **\\\")\\n elif not args[0] in class_type:\\n print(\\\"** class doesn't exist **\\\")\\n elif len(args) == 1:\\n print(\\\"** instance id missing **\\\")\\n elif (\\\"{}.{}\\\".format(args[0], args[1]) not in storage.all().keys()):\\n print(\\\"** no instance found **\\\")\\n elif len(args) == 2:\\n print(\\\"** attribute name missing **\\\")\\n elif len(args) == 3:\\n print(\\\"** value missing **\\\")\\n else:\\n new_dict = models.storage.all()\\n tmp = \\\"{}.{}\\\".format(args[0], args[1])\\n if tmp in new_dict.keys():\\n attr = getattr(new_dict[tmp], args[2], \\\"\\\")\\n setattr(new_dict[tmp], args[2], type(attr)(args[3]))\\n new_dict[tmp].save()\",\n \"def _update(self):\\n pass\",\n \"def update(self, example, hypercubes_coords=None):\\n hypercubes_coords = tuple(\\n [int(example.coords[i] / self.hypercube_measurements[i]) for i in range(self.dims - 1, -1, -1)])\\n new_class = self.hypercubes[hypercubes_coords].update_basic(example_list=[example])\\n print(\\\"Update. Changed class of \\\" + str(hypercubes_coords) + \\\" to: \\\" + str(new_class))\\n if self.child_grid:\\n self.child_grid.update(example=example, hypercubes_coords=hypercubes_coords)\",\n \"def do_update(self, line):\\n try:\\n tokens = split(line)\\n except ValueError:\\n return None\\n if len(tokens) < 1:\\n print(\\\"** class name missing **\\\")\\n else:\\n objects = models.storage.all()\\n cls = models.getmodel(tokens[0])\\n if cls is None:\\n print(\\\"** class doesn't exist **\\\")\\n elif len(tokens) < 2:\\n print(\\\"** instance id missing **\\\")\\n elif \\\".\\\".join(tokens[:2]) not in objects:\\n print(\\\"** no instance found **\\\")\\n elif len(tokens) < 3:\\n print(\\\"** attribute name missing **\\\")\\n elif len(tokens) < 4:\\n print(\\\"** value missing **\\\")\\n else:\\n obj = objects[\\\".\\\".join(tokens[:2])]\\n for key, value in zip(tokens[2::2], tokens[3::2]):\\n try:\\n setattr(obj, key, int(value))\\n except ValueError:\\n try:\\n setattr(obj, key, float(value))\\n except ValueError:\\n try:\\n setattr(obj, key, str(value))\\n except ValueError:\\n pass\\n obj.save()\",\n \"def _set_attributes(self):\",\n \"def AddClassWithInitialMean(self, mean: 'double') -> \\\"void\\\":\\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterISS2IUC2_AddClassWithInitialMean(self, mean)\",\n \"def update(self, example, hypercubes_coords):\\n hypercubes_coords = tuple([int(x / 2) for x in hypercubes_coords])\\n new_class = self.hypercubes[hypercubes_coords].update_lower_level(example_class=example.class_id, example_count=1, threshold=self.threshold)\\n print(\\\"Update. Changed class of \\\" + str(hypercubes_coords) + \\\" to: \\\" + str(new_class))\\n if self.child_grid:\\n self.child_grid.update(example=example, hypercubes_coords=hypercubes_coords)\",\n \"def update(self, loss, pred_classes, gold_classes, pred_probas=None,\\n gold_probas=None):\\n self.loss += loss\\n self.nb_batches += 1\\n # unmask & flatten predictions and gold labels before storing them\\n mask = gold_classes != constants.TARGET_PAD_ID\\n self.pred_classes.extend(unroll(unmask(pred_classes, mask)))\\n self.gold_classes.extend(unroll(unmask(gold_classes, mask)))\\n if pred_probas is not None and gold_probas is not None:\\n self.pred_probas.extend(unroll(unmask(pred_probas, mask)))\\n self.gold_probas.extend(unroll(unmask(gold_probas, mask)))\",\n \"def AddClassWithInitialMean(self, mean: 'double') -> \\\"void\\\":\\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterISS2IUS2_AddClassWithInitialMean(self, mean)\",\n \"def update(self, container, representation):\\n pass\",\n \"def _set_class_weight(self, class_weight, classes, y):\\n if class_weight is None:\\n class_weight = self.class_weight\\n if class_weight is None or len(class_weight) == 0:\\n weight = np.ones(classes.shape[0], dtype=np.float64, order='C')\\n elif class_weight == 'auto':\\n weight = np.array([1.0 / np.sum(y == i) for i in classes],\\n dtype=np.float64, order='C')\\n weight *= classes.shape[0] / np.sum(weight)\\n else:\\n weight = np.ones(classes.shape[0], dtype=np.float64, order='C')\\n if not isinstance(class_weight, dict):\\n raise ValueError(\\\"class_weight must be dict, 'auto', or None,\\\"\\n \\\" got: %r\\\" % class_weight)\\n for c in class_weight:\\n i = np.searchsorted(classes, c)\\n if classes[i] != c:\\n raise ValueError(\\\"Class label %d not present.\\\" % c)\\n else:\\n weight[i] = class_weight[c]\\n\\n self._expanded_class_weight = weight\",\n \"def update_classes_and_origins(\\n origin_list_, champions_list_, origin_counters_, class_list_, class_counters_\\n):\\n logging.debug(\\\"Function update_classes_and_origins() called\\\")\\n\\n update_origins(origin_list_, champions_list_, origin_counters_)\\n update_classes(class_list_, champions_list_, class_counters_)\\n\\n logging.debug(\\\"Function update_classes_and_origins() end\\\")\",\n \"def updateClusterInfo(self):\\n self.nPoints = len(self.labels)\\n self.n = len(np.unique(self.labels))\\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]\",\n \"def update(self):\",\n \"def update(self):\",\n \"def update(self):\",\n \"def AddClassWithInitialMean(self, mean: 'double') -> \\\"void\\\":\\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIUS2ISS2_AddClassWithInitialMean(self, mean)\",\n \"def AddClassWithInitialMean(self, mean: 'double') -> \\\"void\\\":\\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIUC2ISS2_AddClassWithInitialMean(self, mean)\",\n \"def change_class_labels(classes):\\n u,indices=np.unique(classes,return_inverse=True)\\n return u,indices\",\n \"def update_weights(self):\\n\\t\\tpass\",\n \"def AddClassWithInitialMean(self, mean: 'double') -> \\\"void\\\":\\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIF2ISS2_AddClassWithInitialMean(self, mean)\",\n \"def AddClassWithInitialMean(self, mean: 'double') -> \\\"void\\\":\\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterIUC3IUC3_AddClassWithInitialMean(self, mean)\",\n \"def annihilate(cls):\\n pass\",\n \"def update_entities(self):\\n raise NotImplementedError()\",\n \"def calc_class_weights(self):\\n y = self.train_eval_data[\\\"sentiment\\\"]\\n self.class_weights = {}\\n classes = np.unique(y)\\n for cls in classes:\\n self.class_weights[cls] = len(y) / (len(classes) * (y == cls).sum())\",\n \"def record_class_examined(self, cls):\\n serialized = self.serialize_type(cls)\\n if serialized is not None:\\n self.classes_examined.add(serialized)\",\n \"def __init__(self, classes, alpha=1.0):\\n self.alpha_ = alpha\\n self.classes_ = classes.tolist()\\n self.class_counts_ = self.alpha_*np.ones(len(self.classes_))\\n self.features_ = []\",\n \"def AddClassWithInitialMean(self, mean: 'double') -> \\\"void\\\":\\n return _itkScalarImageKmeansImageFilterPython.itkScalarImageKmeansImageFilterISS2ISS2_AddClassWithInitialMean(self, mean)\",\n \"def sync_attributes(self, sync_imported=False):\\n for cls in itertools.chain(self.classes(), self.object_properties(),\\n self.individuals()):\\n if not cls.label:\\n try:\\n cls.label.append(cls.__name__)\\n except:\\n cls.label.append(cls._name)\\n if not cls.comment and cls.__doc__:\\n cls.comment.append(inspect.cleandoc(cls.__doc__))\\n if sync_imported:\\n for onto in self.imported_ontologies:\\n onto.sync_attributes()\",\n \"def __init__(self):\\n self.classes = {}\",\n \"def _update_mask_attributes(self, sitk_im=None):\\n if sitk_im is None:\\n sitk_im = self.sitk_image\\n np_type = IMTYPE_2_NP[self.type]\\n array = self.get_array(sitk_im, np_type, isotropic=False)\\n unique, counts = np.unique(array, return_counts=True)\\n \\n num_classes = len(unique)\\n msg = (f'Given {self.num_classes} classes, but this mask has '\\n f'{num_classes} unique values!')\\n assert len(self._class_names) >= num_classes, msg\\n \\n # check if unique values match up with associated class values\\n given_vals = self._given_class_values\\n if given_vals is None or len(given_vals) == 0:\\n pre_msg = (f'During mask init, you gave no class_values, so it was '\\n f'defaulted to {self._class_values}. ')\\n else:\\n pre_msg = (f'During mask init, you gave these class_values: '\\n f'{self._class_values}.')\\n post_msg = (f'When loading the image, it contained values '\\n f'({unique}) that were not defined in \\\"class_values\\\".')\\n msg = pre_msg + post_msg\\n for unique_val in unique:\\n assert unique_val in self._class_values, msg\\n \\n class_counts = np.array([0] * self.num_classes)\\n for u, c in zip(unique, counts):\\n cid = self.class_values.index(u)\\n class_counts[cid] = c\\n self._class_counts = class_counts\\n \\n self._unique_values = unique\",\n \"def make_classdict(self):\\n\\t\\ttarget_names = self.fetched[\\\"train\\\"].target_names\\n\\t\\tself.classdict = {target_names[idx]: idx for idx in range(len(target_names))}\",\n \"def update(self) -> None:\\n pass\",\n \"def update(self) -> None:\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6709953","0.61785007","0.6076284","0.595551","0.58957285","0.5783457","0.5720336","0.57154924","0.5688674","0.56453985","0.5566248","0.5520287","0.55193","0.5472117","0.5463804","0.5440467","0.541637","0.53849554","0.53834957","0.53764176","0.53638923","0.53638923","0.53622353","0.5355253","0.53226334","0.5318466","0.5318466","0.5312096","0.5308441","0.53036094","0.5287526","0.5284387","0.52764505","0.5260769","0.5232849","0.52212167","0.52151304","0.52141863","0.5210804","0.5210804","0.5210804","0.5210804","0.5210804","0.5210804","0.5210804","0.5210804","0.5210804","0.5210804","0.5210804","0.5210804","0.5210804","0.5210804","0.5210804","0.51895624","0.51839817","0.5181816","0.5180064","0.5179116","0.51739293","0.51651734","0.51625055","0.5157864","0.51501715","0.51264423","0.51108265","0.5107778","0.5097906","0.50959414","0.5095496","0.5094083","0.50887984","0.50880104","0.5086512","0.5084192","0.5079071","0.5078548","0.5072454","0.5070059","0.506555","0.50596315","0.50596315","0.50596315","0.50501966","0.5048502","0.5046806","0.5040259","0.5020329","0.50159484","0.5004237","0.4985327","0.49846792","0.49823928","0.49812585","0.4978196","0.49759173","0.49694172","0.49590588","0.49469116","0.4946768","0.4946768"],"string":"[\n \"0.6709953\",\n \"0.61785007\",\n \"0.6076284\",\n \"0.595551\",\n \"0.58957285\",\n \"0.5783457\",\n \"0.5720336\",\n \"0.57154924\",\n \"0.5688674\",\n \"0.56453985\",\n \"0.5566248\",\n \"0.5520287\",\n \"0.55193\",\n \"0.5472117\",\n \"0.5463804\",\n \"0.5440467\",\n \"0.541637\",\n \"0.53849554\",\n \"0.53834957\",\n \"0.53764176\",\n \"0.53638923\",\n \"0.53638923\",\n \"0.53622353\",\n \"0.5355253\",\n \"0.53226334\",\n \"0.5318466\",\n \"0.5318466\",\n \"0.5312096\",\n \"0.5308441\",\n \"0.53036094\",\n \"0.5287526\",\n \"0.5284387\",\n \"0.52764505\",\n \"0.5260769\",\n \"0.5232849\",\n \"0.52212167\",\n \"0.52151304\",\n \"0.52141863\",\n \"0.5210804\",\n \"0.5210804\",\n \"0.5210804\",\n \"0.5210804\",\n \"0.5210804\",\n \"0.5210804\",\n \"0.5210804\",\n \"0.5210804\",\n \"0.5210804\",\n \"0.5210804\",\n \"0.5210804\",\n \"0.5210804\",\n \"0.5210804\",\n \"0.5210804\",\n \"0.5210804\",\n \"0.51895624\",\n \"0.51839817\",\n \"0.5181816\",\n \"0.5180064\",\n \"0.5179116\",\n \"0.51739293\",\n \"0.51651734\",\n \"0.51625055\",\n \"0.5157864\",\n \"0.51501715\",\n \"0.51264423\",\n \"0.51108265\",\n \"0.5107778\",\n \"0.5097906\",\n \"0.50959414\",\n \"0.5095496\",\n \"0.5094083\",\n \"0.50887984\",\n \"0.50880104\",\n \"0.5086512\",\n \"0.5084192\",\n \"0.5079071\",\n \"0.5078548\",\n \"0.5072454\",\n \"0.5070059\",\n \"0.506555\",\n \"0.50596315\",\n \"0.50596315\",\n \"0.50596315\",\n \"0.50501966\",\n \"0.5048502\",\n \"0.5046806\",\n \"0.5040259\",\n \"0.5020329\",\n \"0.50159484\",\n \"0.5004237\",\n \"0.4985327\",\n \"0.49846792\",\n \"0.49823928\",\n \"0.49812585\",\n \"0.4978196\",\n \"0.49759173\",\n \"0.49694172\",\n \"0.49590588\",\n \"0.49469116\",\n \"0.4946768\",\n \"0.4946768\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76716536"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94496,"cells":{"query":{"kind":"string","value":"Update specific memory slots If query_result is not supplied, relevance scores are not updated."},"document":{"kind":"string","value":"def update_ixs(self, ixs, embeddings, labels, query_result=None, global_update=True):\n self.memory_embeddings[ixs] = embeddings\n self.memory_labels[ixs] = labels\n self.memory_age[ixs] = 0\n self.memory_relevance[ixs] = 0\n if global_update:\n self.memory_age[self.memory_age != -1] += 1\n if query_result is not None:\n # relevance mask indicates which samples are deemed relevant based on the query results\n # here this is simply which queries were closest to the query embedding, as well as the query itself\n relevance_mask = torch.zeros_like(self.memory_relevance)\n ix_counts = Counter(query_result[\"ix\"].flatten().tolist())\n for ix, count in ix_counts.items():\n relevance_mask[ix] = count\n relevance_mask[ixs] = 1 # assign a relevance of 1 to newly added entries as well\n # keep exponential moving average\n self.memory_relevance = self.relevance_discount * self.memory_relevance + relevance_mask"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _update(self, nbrs, nbrs_y, query, query_y):\n\n # Set up the graph for our shared memory variables\n new_K, new_A, new_V = self.K, self.A, self.V\n\n # Condition (1): First returned neighbour shares the same query label\n correct_query = T.eq(nbrs_y[:, 0], query_y).nonzero()[0]\n correct_mem = nbrs[correct_query, 0] # Idx to memory keys\n\n normed_keys = tensor_norm(query[correct_query] + new_K[correct_mem])\n new_K = T.set_subtensor(new_K[correct_mem], normed_keys)\n new_A = T.set_subtensor(new_A[correct_mem], 0.)\n\n # Condition (2): First returned neighbour does not share query label.\n # Add the key and label from query to memory\n incorrect_mask = T.neq(nbrs_y[:, 0], query_y)\n incorrect_query = incorrect_mask.nonzero()[0]\n\n # We need to find len(incorrect_query) locations in memory to write to.\n # Noise is added to randomize selection.\n age_mask = T.ge(new_A, T.max(new_A) - self.C) #1d\n oldest_idx = tensor_choose_k(age_mask, self.rng,\n k=T.sum(incorrect_mask),\n random=True).flatten()\n\n new_K = T.set_subtensor(new_K[oldest_idx], query[incorrect_query])\n new_V = T.set_subtensor(new_V[oldest_idx], query_y[incorrect_query])\n new_A = T.set_subtensor(new_A[oldest_idx], 0.)\n\n # Increment the age of all non-updated indices by 1\n new_A = new_A + 1.\n new_A = T.inc_subtensor(new_A[correct_mem], -1.)\n new_A = T.inc_subtensor(new_A[oldest_idx], -1.)\n\n return OrderedDict({(self.K, new_K), (self.V, new_V), (self.A, new_A)})","def update_memory(self, result):\r\n if (len(self.memory) >= self.memory_capacity):\r\n self.memory.pop(0)\r\n self.memory.append(result)\r\n else:\r\n self.memory.append(result)","def update_search_space(self, search_space):\n raise NotImplementedError('Tuner: update_search_space not implemented')","def update_results(self, results):\n pass","def update_vm_result(self, context, msg):\n args = jsonutils.loads(msg)\n agent = context.get('agent')\n port_id = args.get('port_uuid')\n result = args.get('result')\n LOG.debug('update_vm_result received from %(agent)s: '\n '%(port_id)s %(result)s', {'agent': agent,\n 'port_id': port_id,\n 'result': result})\n\n # Add the request into queue for processing.\n event_type = 'agent.vm_result.update'\n payload = {'port_id': port_id, 'result': result}\n timestamp = time.ctime()\n data = (event_type, payload)\n # TODO(nlahouti) use value defined in constants\n pri = self.obj.PRI_LOW_START + 10\n self.obj.pqueue.put((pri, timestamp, data))\n LOG.debug('Added request vm result update into queue.')\n\n return 0","def update_score(self, concept: _Concept, result: _Result) -> None:\n\n score = self.make_score(concept, result)\n if score is None:\n pass\n else:\n self._vector.append(score)","def UpdateNode(self, result, actions):\n self.visits += 1\n self.wins += (result > 0)\n self.losses += (result < 0)\n self.draws += (result == 0)\n self.Q = self.Q + (result - self.Q)/self.visits\n \n # update rave values\n for a in actions:\n self.N_AMAF[a] += 1\n if not a in self.Q_AMAF:\n self.Q_AMAF[a] = 0.5\n self.Q_AMAF[a] = self.Q_AMAF[a] + (result - self.Q_AMAF[a])/self.N_AMAF[a]\n else:\n self.Q_AMAF[a] = self.Q_AMAF[a] + (result - self.Q_AMAF[a])/self.N_AMAF[a]","def update_qvals(self, state, action, reward):\n self.qvals[(state, action)] = 0","def updateQTable( self, reward, current_state ):","def _update_memory(key, cur, target, common_mem):\n mod_swap = {\"G\": \"M\", \"g\": \"m\"}\n cur_mem, orig_mod = _get_cur_mem(key, cur)\n if cur_mem >= common_mem * 1.5:\n return cur\n else:\n new_val = \"%s%s\" % (target, mod_swap.get(orig_mod, orig_mod))\n if key == \"jvm_opts\":\n out = cur\n out[-1] = \"-Xmx%s\" % new_val\n else:\n out = new_val\n return out","def update_Qfunction(self, result):\n if result == \"won\":\n final_value = WIN_VALUE\n elif result == \"draw\":\n final_value = DRAW_VALUE\n elif result == \"lost\":\n final_value = LOSS_VALUE\n \n self.move_history.reverse()\n next_max = -1.0\n \n for h in self.move_history:\n qvals = self.get_q(h[0])\n m = h[1]\n \n if next_max < 0:\n qvals[m] = final_value\n else:\n qvals[m] = qvals[m] * (1.0 - self.learning_rate) + self.learning_rate * self.value_discount * next_max\n \n self.q[h[0]] = qvals \n next_max = max(qvals)","def update_q_value(q_table: np.ndarray, state: int, action: int,\n learning_rate: float, current_reward: float,\n new_state: int, discount_rate: float) -> None:\n q_table[state, action] = new_q_value(q_table, state, action, learning_rate,\n current_reward, new_state,\n discount_rate)","def set_result(self, params, result, id=0):\n for i in range(len(self.result), id + 1):\n self.result.append(None)\n print \"List index %d does not exist, should not happen\" % i\n self.result[id] = result\n if self.best_score is None or result < self.best_score:\n self.best_score = result\n self.best_params = params\n return params, result","def update(self, result):\n\n runs_scored = 0\n outs_recorded = 0\n\n if result == 'single':\n # Runners from 2b or 3b score first\n if self.occupied_2b and self.occupied_3b:\n self.occupied_2b = False\n self.occupied_3b = False\n runs_scored += 2\n elif self.occupied_2b or self.occupied_3b:\n self.occupied_2b = False\n self.occupied_3b = False\n runs_scored += 1\n # Runners from first advance\n if self.occupied_1b:\n self.occupied_2b = True\n # First base now occupied\n self.occupied_1b = True\n\n if result == 'double':\n # Runners from 2b or 3b score\n if self.occupied_2b and self.occupied_3b:\n self.occupied_2b = False\n self.occupied_3b = False\n runs_scored += 2\n elif self.occupied_2b or self.occupied_3b:\n self.occupied_2b = False\n self.occupied_3b = False\n runs_scored += 1\n # Runner on 1st (see notes)\n if self.occupied_1b:\n rand = random.uniform(0,1)\n if rand < 0.4:\n runs_scored +=1\n else:\n self.occupied_3b = True\n self.occupied_1b = False\n \n if result == 'triple':\n # Everyone on base scores\n number_bases_occupied = self.occupied_1b + self.occupied_2b + self.occupied_3b\n runs_scored += number_bases_occupied\n # New runner on 3b\n self.occupied_3b = True\n\n if result == 'home run':\n number_bases_occupied = self.occupied_1b + self.occupied_2b + self.occupied_3b\n runs_scored += number_bases_occupied + 1\n\n if result == 'foul out' or result == 'fly out' or result == 'out at 1st' or result == 'strike out':\n outs_recorded += 1\n\n if result == 'double play':\n # This is weird, since dps aren't always possible. See notes.\n \n if self.occupied_1b + self.occupied_2b + self.occupied_3b == 0:\n # If nobody on base, just a normal out\n outs_recorded +=1\n \n ## 1 existing Baserunner scenario\n elif self.occupied_1b and not self.occupied_2b and not self.occupied_3b:\n # If on first, outs at 1b and 2b\n self.occupied_1b = False\n outs_recorded += 2\n elif (not self.occupied_1b and self.occupied_2b and not self.occupied_3b):\n # If baserunner on second, no force outs, just add an out\n outs_recorded += 1\n elif (not self.occupied_1b and not self.occupied_2b and self.occupied_3b):\n # If baserunner on third, same\n outs_recorded += 1\n\n ## 2 existing Baserunner scenario\n elif self.occupied_1b and self.occupied_2b and not self.occupied_3b:\n # If on 1st and 2nd, outs at 3rd and 2nd\n self.occupied_1b = True\n self.occupied_2b = False\n outs_recorded += 2\n elif self.occupied_1b and not self.occupied_2b and self.occupied_3b:\n # If on 1st and 3nd, outs at 2rd and 1st\n self.occupied_1b = False\n outs_recorded += 2\n elif not self.occupied_1b and self.occupied_2b and self.occupied_3b: \n # If 2b and 3b occupied, only force out at 1b, so base/out doesn't change\n outs_recorded += 1\n\n ## 3 existing Baserunner scneario\n elif self.occupied_1b and self.occupied_2b and self.occupied_3b: \n # If bases loaded, outs at home and 3b. 2b and 1b stay occupied\n self.occupied_3b = False\n outs_recorded += 2\n\n\n if result == 'base on error':\n # Everyone advances\n if self.occupied_3b:\n runs_scored += 1\n self.occupied_3b = False\n if self.occupied_2b:\n self.occupied_3b = True\n self.occupied_2b = False\n if self.occupied_1b:\n self.occupied_2b = True\n self.occupied_1b = False\n self.occupied_1b = True\n\n\n if result == 'base on balls':\n if self.occupied_3b and self.occupied_2b and self.occupied_1b:\n runs_scored += 1\n if self.occupied_2b and self.occupied_1b:\n self.occupied_3b = True\n if self.occupied_1b:\n self.occupied_2b = True\n self.occupied_1b = True \n\n return runs_scored, outs_recorded","def update(self, rank):\n # calculate MR and MRR\n self.mr += rank\n self.mrr += 1 / rank\n # calculate Hits@k\n if rank <= 1:\n self.hits1 += 1\n self.hits3 += 1\n self.hits5 += 1\n self.hits10 += 1\n elif rank <= 3:\n self.hits3 += 1\n self.hits5 += 1\n self.hits10 += 1\n elif rank <= 5:\n self.hits5 += 1\n self.hits10 += 1\n elif rank <= 10:\n self.hits10 += 1","def update_used_query_range(\n self,\n write_cursor: 'DBCursor',\n location_string: str,\n queried_ranges: list[tuple[Timestamp, Timestamp]],\n ) -> None:\n if len(queried_ranges) == 0:\n return\n\n starts = [x[0] for x in queried_ranges]\n ends = [x[1] for x in queried_ranges]\n saved_range = self.db.get_used_query_range(write_cursor, location_string)\n if saved_range is not None:\n starts.append(saved_range[0])\n ends.append(saved_range[1])\n\n self.db.update_used_query_range(\n write_cursor=write_cursor,\n name=location_string,\n start_ts=min(starts),\n end_ts=max(ends),\n )","def update(self, result):\n #print(\"updating node result = \" + str(result))\n self.visits += 1\n self.wins += result","def _adjust_memory(self, neighbour, neighbour_choice):\n if neighbour in self._memory:\n self.get_memory_of(neighbour).add_choice_to_memory(\n neighbour_choice, self.get_gene().get_mem_size())\n else:\n print (\"err: getMemory: no memory of subjectID \"\n + str(neighbour.get_id()))","def update_cache(self, query, results, expire):\n self.logger.info(\"DASMemcache::result(%s) store to cache\" % query)\n if not results:\n return\n key = genkey(query)\n rowdict = {}\n rowid = 0\n for row in results:\n if type(row) is dict:\n row['id'] = rowid\n rowdict[rowid] = row\n rowid += 1\n if len(rowdict.keys()) == self.chunk_size:\n self.memcache.set_multi(rowdict, time=expire, key_prefix=key)\n rowdict = {}\n yield row\n self.memcache.set_multi(rowdict, time=expire, key_prefix=key)\n self.memcache.set(key, rowid, expire)","def update_q(self,action,reward):\n #print('')\n #print('Action index is: ' + str(action))\n #print('Provided reward is: ' + str(reward))\n \n # Read from disk before updating\n try:\n pickle_in = open(\"static/data/values.pickle\",\"rb\")\n values = pickle.load(pickle_in)\n #print(values)\n self.values = values\n pickle_in = open(\"static/data/counts.pickle\",\"rb\")\n self.counts = pickle.load(pickle_in)\n pickle_in = open(\"static/data/actions_taken.pickle\",\"rb\")\n actions_taken = pickle.load(pickle_in)\n pickle_in = open(\"static/data/reward_list.pickle\",\"rb\")\n reward_list = pickle.load(pickle_in)\n except:\n actions_taken = []\n reward_list = []\n pass\n \n self.counts[action] += 1\n n = self.counts[action]\n value = self.values[action]\n actions_taken.append(action)\n reward_list.append(reward)\n \n # Running product\n new_value = value + (1/n) * (reward - value)\n self.values[action] = new_value\n \n \n # Save to disk before exiting\n pickle_out = open('static/data/values.pickle','wb')\n pickle.dump(self.values, pickle_out)\n pickle_out.close()\n pickle_out = open('static/data/counts.pickle','wb')\n pickle.dump(self.counts, pickle_out)\n pickle_out.close()\n pickle_out = open('static/data/actions_taken.pickle','wb')\n pickle.dump(actions_taken, pickle_out)\n pickle_out.close()\n pickle_out = open('static/data/reward_list.pickle','wb')\n pickle.dump(reward_list, pickle_out)\n pickle_out.close()","def _fill_query_slots(self, queries: List[Query]) -> None:\n while queries and self.query_slots > 0:\n logger.debug(\n f\"{self.query_slots} available query slots, creating query task\"\n )\n query = queries.pop(0)\n query_task_id = self.client.create_query_task(query.query_id)\n self.query_slots -= 1\n query.query_task_id = query_task_id\n self._query_by_task_id[query_task_id] = query\n self._running_queries.append(query)","def update_memory(self, target, clues, guesses, winlose):\n immediate_rewards = self.get_trajectory_immediate_rewards(target, \n clues,\n guesses)\n \n self.memory.append((target, \n clues, \n guesses, \n winlose, \n immediate_rewards))","def update(self, FlowStatistics=None, MatchIpAddressInArpPackets=None, PortStatistics=None, QueueStatistics=None, ReassambleIpFragments=None, Reserved=None, SpanningTree=None, TableStatistics=None):\n self._update(locals())","def update(self, state, action, nextState, reward):\n \"\"\"Description:\n Use Q-Learning algoritm in slide 58 of MDP\n \"\"\"\n \"\"\" YOUR CODE HERE \"\"\"\n maxQns = self.getValue(nextState) # get max q-value of next state\n if maxQns == None:\n maxQns = 0\n Qsa = self.getQValue(state, action) #self.qValues[(state, action)]\n difference = reward + self.discountRate * maxQns - Qsa\n self.qValues[(state, action)] += self.alpha * difference\n \n self.vitCount[(state, action)] += 1\n \"\"\" END CODE \"\"\"","def update(self, arm, reward):\n raise NotImplementedError","def _update_q_value(self, start_state, to_state, reward, iteration):\n if start_state.as_tuple() not in self.qstore.q:\n self.enum.enumerate_state(start_state, self.qstore.q)\n if to_state.as_tuple() not in self.qstore.q:\n self.enum.enumerate_state(to_state, self.qstore.q)\n\n actions = self.qstore.q[start_state.as_tuple()]['actions']\n values = self.qstore.q[start_state.as_tuple()]['utilities']\n\n max_over_next_states = max(self.qstore.q[to_state.as_tuple()]['utilities']) if to_state.terminate != 1 else 0\n\n action_between_states = to_state.as_tuple()\n\n action_index = actions.index(action_between_states)\n learning_rate_alpha = 1 / (iteration ** self.state_space_parameters.learning_rate_omega)\n\n # Q_Learning update rule\n values[action_index] = ( # Q_t+1(s_i,𝑢) =\n values[action_index] + # Q_t(s_i,𝑢)\n learning_rate_alpha * ( # α\n reward # r_t\n + self.state_space_parameters.discount_factor # γ\n * max_over_next_states # max_{𝑢'∈ 𝒰(s_j)} Q_t(s_j,𝑢')\n - values[action_index] # -Q_t(s_i,𝑢)\n )\n )\n\n self.qstore.q[start_state.as_tuple()] = {'actions': actions, 'utilities': values}","def update(self, reward):\n raise NotImplementedError","def update_results_score(self, edge, regions):\r\n if self.results_file is None:\r\n return # No update\r\n \r\n pln = self.get_player_num()\r\n self.results_file.results_update(player_num=pln, nsquare=len(regions))","def vm_result_update(self, payload):\n\n port_id = payload.get('port_id')\n result = payload.get('result')\n\n if port_id and result:\n # Update the VM's result field.\n params = dict(columns=dict(result=result))\n self.update_vm_db(port_id, **params)","def update_q_table(self, state, action, reward):\n\n q_key = self.q_key(state, action)\n inputs = self.env.sense(self)\n self.next_waypoint = self.planner.next_waypoint()\n new_state = self.set_current_state(inputs)\n\n #update q_value in q_table according to learning formula\n x = self.q_value(state, action)\n V = reward + (self.gamma * self.max_q_value(new_state))\n new_q_value = x + (self.alpha * (V - x))\n self.q_table[q_key] = new_q_value","def update_Qtable(self, r, action, next_state):\n if self.learning:\n # 8. When learning, update the q table according\n # to the given rules\n\n # The reward the turkey get after doing the action\n reward_t1 = r\n\n # Code Review1: Replace the following code\n '''\n # Get the key & value which enables the max Q value in State(t+1)\n max_Q_St1_info = max(self.Qtable[next_state].items(), key=operator.itemgetter(1))\n\n # The action which enables the max Q value in State(t+1)\n max_Q_St1_action = max_Q_St1_info[0]\n\n # The max Q value in State(t+1)\n max_Q_St1 = max_Q_St1_info[1]\n '''\n max_Q_St1 = max(self.Qtable[next_state].values())\n\n Q_old = self.Qtable[self.state][action]\n Q_new = reward_t1 + self.gamma * max_Q_St1\n\n self.Qtable[self.state][action] = (\n 1 - self.alpha) * Q_old + self.alpha * Q_new","def updateQValue(self, state, action, old_q, reward, future_rewards):\n self.q[(tuple(state), action)] = old_q + self.alpha * (reward + future_rewards - old_q)","def update(self, arm, reward, context):","def update(self, result: int):\n self.wins += result\n self.visits += 1","def process_query(self, query):\n query._cache_region = self","def restore_program(memory_updates: Dict[int, int], memory: List[int]) -> List[int]:\n for (index, new_value) in memory_updates.items():\n memory[index] = new_value\n return memory","def add_result(self, result):\n if len(self.results) == self.max_size:\n del self.results[0]\n self.results.append(result)","def update_Q(self, reward):\n old_estimate = self.q_estimates[self.prev_action]\n self.q_estimates[self.prev_action] = old_estimate + 1/self.N[self.prev_action] * (reward - old_estimate)","def update(self, state, action, nextState, reward):\n \"*** YOUR CODE HERE ***\"\n self.qValues[(state, action)] = ((1 - self.alpha) * self.getQValue(state, action)) + self.alpha \\\n * (reward + self.discount * self.computeValueFromQValues(nextState))","def update_quality():\n global items, converted_items\n if not converted_items:\n items = convert_items(items)\n converted_items = True\n for item in items:\n item.update_q()","def update(self, state, action, nextState, reward):\n self.qvals[(state, action)] = self.qvals[(state, action)] + self.alpha * (\n reward + self.discount * self.computevaluefromqvalues(nextState) - self.qvals[(state, action)])","def update(self, state, action, nextState, reward):\n \"*** YOUR CODE HERE ***\"\n best_action = self.computeActionFromQValues(nextState)\n self.QValueCounter[(state, action)] = ((1 - self.alpha) * self.getQValue(state, action) +\n self.alpha * (reward + self.discount * self.getQValue(nextState,\n best_action)))","def update_Q(self, state, action, new_state, reward):\n \n self.Q[(state, action)] = self.Q[(state, action)] + self.alpha*(reward + self.gamma * self.max_value(new_state) - self.Q[(state, action)])","def update_q_values(self, s_current, action, r_next, s_next, action_next):\n action = actions_indexes[action]\n action_next = actions_indexes[action_next]\n self.q_values[s_current, action] += self.alpha * (\n r_next + self.gamma * self.q_values[s_next, action_next] - self.q_values[s_current, action])","def update_query(self):\n text = self.lineedit.text()\n self.results = self.lookup(text)\n self.update_ui()\n self.copy_entry(self.table.currentRow(), self.table.currentColumn())","def update(self, arm, context, reward):\n raise NotImplementedError","def update(self, arm, context, reward):\n raise NotImplementedError","def update_Q(self, state, action, new_state, new_action, reward):\n \n self.Q[(state, action)] = float(self.Q[(state, action)] + self.alpha*(reward + self.gamma * self.Q[new_state, new_action] - self.Q[(state, action)]))","def update_scores(read_scores, result):\n\n\t# check that there are some results for this read\n\tassert len(result) > 0\n\t# write this read to output\n\tfor sim_match in result.keys():\n\n\t\t# get type (discordant or chimeric)\n\t\tjunc_type = sim_match.split('_')[2]\n\n\t\tfor analysis_match in result[sim_match]:\n\t\t\t\n\t\t\t# get each score type\n\t\t\tfor score_type in read_scores:\n\t\t\t\tscore = analysis_match[score_type]\n\t\t\t\tread_scores[score_type][junc_type][score] += 1","def update_scores(self, score):\n self.result_list.append(score)\n\n if self.best_score == 0 and self.worst_score == 0:\n self.best_score = score\n self.worst_score = score\n\n if score < self.best_score:\n self.best_score = score\n\n if score > self.worst_score:\n self.worst_score = score","def _update_scoreboard(self, result):\n if result == Moveresult.KEY:\n self.current_turn.keys_collected += 1\n elif result == Moveresult.EXIT:\n self.current_turn.successful_exits += 1","def update(self, state, action, nextState, reward):\n \"*** YOUR CODE HERE ***\"\n Q_Value = self.Q #calling constructor\n\n learning_rate = self.alpha #gives us the learning rate\n\n temporary_QValue = self.getQValue(state,action) #to get the Q value of the state\n\n nextState_QValue = self.getValue(nextState) #to get the Q value of the landing state when taken action a and state s\n\n discount_factor = self.discount #to get the gamma/ discount factor\n\n\n Q_Value[(state,action)] = ((1-learning_rate) * temporary_QValue) + (learning_rate * (reward + discount_factor * nextState_QValue)) #for formula go to README_Reinforcement.txt at line 8\n\n #util.raiseNotDefined()","def update_reward(self, observation, action, reward):\n self.q_table[observation,action] = (1 - self.count(observation,action)) * self.q_table[observation,action] + self.count(observation,action) * reward # Canonical Q-update\n self.increment_count(observation,action)","def Update(self, result):\n self.visits += 1\n self.wins += result","def Update(self, result):\n self.visits += 1\n self.wins += result","def update(self, old_state, action, new_state, reward):\r\n \r\n old = self.get_q_value(old_state, action)\r\n best_future = self.best_future_reward(new_state)\r\n self.update_q_value(old_state,action, old, reward, best_future)","def update_Q(self):","def update(self, result):\n self.visits += 1\n self.wins += result","def update_unsampled_queries(self, remaining_indices):\n remaining_queries_ids = [\n self.unsampled_queries.elements[i] for i in remaining_indices\n ]\n self.unsampled_queries = ProcessedQueryList(\n cache=self.resource_loader.query_cache, elements=remaining_queries_ids\n )","def update(self):\r\n self.data = [self.make_item_tuple(i) for i in self.query]\r\n self._fetched = True\r\n query_cache.set(self.iden, self.data)","def update(self, x_dict, y_dict, weight):\n assert len(x_dict) == len(y_dict), \"invalid # of qids\"\n \n qids = self.__get_shuffled_qids(x_dict, y_dict, weight.epoch)\n w = weight.get_dense_weight()\n for qid in tqdm(qids):\n w = approx_ap(x_dict[qid].toarray(), y_dict[qid], w, self.eta, self.alpha, self.beta)\n weight.set_weight(sp.csr_matrix(w.reshape((1, weight.dims))))\n weight.epoch += 1","def update_score(self):\n self.score = TurboMQ.calculate_fitness(self.result, self.graph)","def update_individuals(individuals, eval_results):\n for ind, res in zip(individuals, eval_results):\n ind.fitness.values = res[0]\n ind.matching_node_pairs = res[1]\n ind.gtp_precisions = res[2]","def update(self, state, action, nextState, reward):\n \"*** YOUR CODE HERE ***\"\n # print \"update\"\n oldValue = self.getQValue(state, action)\n sample = reward + self.discount*self.computeValueFromQValues(nextState)\n self.qValues[(state, action)] = (1-self.alpha)*oldValue + self.alpha*(sample)","def put(self, search_query, page_number, search_results):\n timestamp = int(time.time())\n with self.get_conn() as conn:\n c = conn.cursor()\n insert = \"\"\"INSERT OR REPLACE INTO movies\n (search_query, page_number, timestamp, search_results)\n VALUES (?, ?, ?, ?)\"\"\"\n\n c.execute(insert, (search_query, page_number, timestamp, search_results,))\n conn.commit()","def update_q_values(self, state, action, next_state, reward, done):\n # Following the Q-Learning update rule\n if done:\n self.Q_values[state,action] = (1 - self.alpha) * self.Q_values[state,action] + self.alpha * (reward)\n else:\n self.Q_values[state,action] = (1 - self.alpha) * self.Q_values[state,action] + self.alpha * (reward + self.gamma * np.amax(self.Q_values[next_state]))","def update_result(result):\n invader = result['invader'] \n countryOfInvader = result['countryOfInvader'] \n defender = result['defender'] \n countryOfdefender = result['countryOfdefender'] \n invasionHistory = InvasionHistory(\n invader ,\n countryOfInvader,\n defender,\n countryOfdefender,\n datetime.datetime.now() )\n\n #update territory info\n t_record = Territory.get_by_key_name(countryOfdefender)\n t_record.occupier = invader\n t_record.put() \n\n db.put([invasionHistory])","def mult_operation(self):\n arg1 = self.memory[self.memory[self._cursor + 1]]\n arg2 = self.memory[self.memory[self._cursor + 2]]\n arg3 = self.memory[self._cursor + 3]\n self.memory[arg3] = arg1 * arg2\n print(f'Cursor: {self._cursor}\\tAssigning position {arg3} with value {arg1 * arg2}')\n self._cursor += 4\n return","def update_a_result(self, idblock, sib):\n self.resultPanel.update_item(idblock, sib)","def __on_query_edited(self):\n self.__refresh_search_results()","def update(self, target, query):\n node = self._data[target]\n name = \"%s node %.8s\" % (node['type'], target)\n\n query.update({\n 'type': node['type'],\n 'model': node['model']\n })\n\n logger.info(\"Validating query\")\n NodeValidator.validate(query)\n\n self._data[target] = dict_update(node, query, name)\n logger.info(\"Updated parameters above of %s\" % name)\n\n return {target: self._data[target]}","def update_state(self, result):\n for i,k in enumerate(self._current_state.keys()):\n self._current_state[k] = result[i]","def _update_result(self, results, clf_numbers):\n # ToDo make results of scoring values dynamic\n names_results = ['Accuracy']\n for number in clf_numbers:\n for name in names_results:\n if name not in self.results:\n self.results[name] = [results[number][name + \"_test_score_\" + str(number)]]\n else:\n self.results[name].append(results[number][name + \"_test_score_\" + str(number)])","def increment_rank(self, rank, result):\n if result not in VALID_RESULTS:\n raise ValueError('Invalid result: %s' % result)\n self.counts[rank][result] += 1\n self.total_items += 1","def update(self, timestep, action, reward, is_optimal):\r\n\t\t# Increments the Player's selected action index by 1.\r\n\t\tself.player_selected_actions[action] += 1\r\n\r\n\t\t# Sets the Player reward for the particular timestep to the reward\r\n\t\t# obtained.\r\n\t\tself.player_reward[timestep] = reward\r\n\r\n\t\t# Sets the Player optimum for the particular timestep to the is_optimal\r\n\t\t# obtained.\r\n\t\tself.player_optimum[timestep] = is_optimal","def update(self, state, action, nextState, reward):\n oldComponent = (1-self.alpha) * self.getQValue(state, action)\n nextValue = self.computeValueFromQValues(nextState)\n sample = reward + self.discount * nextValue\n newComponent = self.alpha * sample\n self.qValues[(state, action)] = oldComponent + newComponent","def _run(self): # pylint: disable=too-many-locals.too-many-branches,too-many-statements\n num_of_stored_commands_before = len(self._stored_commands)\n if not self.current_mapping:\n self.current_mapping = {}\n else:\n self._send_possible_commands()\n if len(self._stored_commands) == 0:\n return\n new_row_major_mapping = self._return_new_mapping()\n # Find permutation of matchings with lowest cost\n swaps = None\n lowest_cost = None\n matchings_numbers = list(range(self.num_rows))\n if self.num_optimization_steps <= math.factorial(self.num_rows):\n permutations = itertools.permutations(matchings_numbers, self.num_rows)\n else:\n permutations = []\n for _ in range(self.num_optimization_steps):\n permutations.append(self._rng.sample(matchings_numbers, self.num_rows))\n for permutation in permutations:\n trial_swaps = self.return_swaps(\n old_mapping=self._current_row_major_mapping,\n new_mapping=new_row_major_mapping,\n permutation=permutation,\n )\n if swaps is None:\n swaps = trial_swaps\n lowest_cost = self.optimization_function(trial_swaps)\n elif lowest_cost > self.optimization_function(trial_swaps):\n swaps = trial_swaps\n lowest_cost = self.optimization_function(trial_swaps)\n if swaps: # first mapping requires no swaps\n # Allocate all mapped qubit ids (which are not already allocated,\n # i.e., contained in self._currently_allocated_ids)\n mapped_ids_used = set()\n for logical_id in self._currently_allocated_ids:\n mapped_ids_used.add(self._current_row_major_mapping[logical_id])\n not_allocated_ids = set(range(self.num_qubits)).difference(mapped_ids_used)\n for mapped_id in not_allocated_ids:\n qb = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[mapped_id])\n cmd = Command(engine=self, gate=AllocateQubitGate(), qubits=([qb],))\n self.send([cmd])\n # Send swap operations to arrive at new_mapping:\n for qubit_id0, qubit_id1 in swaps:\n qb0 = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[qubit_id0])\n qb1 = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[qubit_id1])\n cmd = Command(engine=self, gate=Swap, qubits=([qb0], [qb1]))\n self.send([cmd])\n # Register statistics:\n self.num_mappings += 1\n depth = return_swap_depth(swaps)\n if depth not in self.depth_of_swaps:\n self.depth_of_swaps[depth] = 1\n else:\n self.depth_of_swaps[depth] += 1\n if len(swaps) not in self.num_of_swaps_per_mapping:\n self.num_of_swaps_per_mapping[len(swaps)] = 1\n else:\n self.num_of_swaps_per_mapping[len(swaps)] += 1\n # Deallocate all previously mapped ids which we only needed for the\n # swaps:\n mapped_ids_used = set()\n for logical_id in self._currently_allocated_ids:\n mapped_ids_used.add(new_row_major_mapping[logical_id])\n not_needed_anymore = set(range(self.num_qubits)).difference(mapped_ids_used)\n for mapped_id in not_needed_anymore:\n qb = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[mapped_id])\n cmd = Command(engine=self, gate=DeallocateQubitGate(), qubits=([qb],))\n self.send([cmd])\n # Change to new map:\n self._current_row_major_mapping = new_row_major_mapping\n new_mapping = {}\n for logical_id, mapped_id in new_row_major_mapping.items():\n new_mapping[logical_id] = self._mapped_ids_to_backend_ids[mapped_id]\n self.current_mapping = new_mapping\n # Send possible gates:\n self._send_possible_commands()\n # Check that mapper actually made progress\n if len(self._stored_commands) == num_of_stored_commands_before:\n raise RuntimeError(\n \"Mapper is potentially in an infinite loop. It is likely that the algorithm requires too\"\n \"many qubits. Increase the number of qubits for this mapper.\"\n )","def update_optimization_results(output, model, result, runtime):\n\n data_path = output['Input_Data']\n\n result['Optimized_Model'] = [model]\n result['Optimized_Likelihood'] = [float(\n result['Optimized_Likelihood'])]\n\n if isinstance(data_path, list):\n result['Dataset'] = []\n for data in data_path:\n result['Dataset'].append(os.path.basename(data))\n else:\n result['Dataset'] = [os.path.basename(data_path)]\n\n result['Runtime'] = runtime\n\n if output['Kernel_Transform'] is not False:\n result['Kernel_Transform'] = str(output['Kernel_Transform'][0]) + \\\n '_' + str(output['Kernel_Transform'][1])\n else:\n result['Kernel_Transform'] = output['Kernel_Transform']\n\n for key, value in result.iteritems():\n output[key] = value\n\n return output","def update(self, result, action_taken):\n self.visits += 1\n self.wins += result\n\n if self.parent is None:\n return\n\n for key in self.parent.children:\n p = self.parent.children[key].player\n for a in action_taken[p]:\n if a == key:\n self.parent.children[key].visits_amaf += 1\n self.parent.children[key].wins_amaf += result","def mem_update(ops, x, mem, spike):\n #print(ops(x).size())\n #print(spike.size())\n mem = mem * decay * (1. - spike) + ops(x)\n spike = act_fun(mem) # act_fun : approximation firing function\n return mem, spike","def update(self, state, action, nextState, reward):\n candidateQ = reward + self.discount * \\\n self.computeValueFromQValues(nextState)\n candidateQ_vec = np.array([[candidateQ]])\n features = self.featExtractor.getFeatures(state, action)\n features_as_list = [features[feat] for feat in self.allFeats]\n features_vec = np.array([features_as_list])\n self.train_step.run(feed_dict={self.x: features_vec,\n self.y_: candidateQ_vec}, session=self.sess)","def updateNode(self, result):\n self.visits += 1\n self.wins += result","def update(self, attribute: str, result: ProcessorResult) -> None:\n pass","def tweak_q(self, q):\n self._q = q\n self.reset()","def update_score():\n pass","def update1(self, state, action, nextState, reward):\n #print \"update1 in ApproximateQAgent\"\n \"*** YOUR CODE HERE ***\"\n ##################################################################################################################################Eric Did Stuff\n actionList = nextState.getLegalActions(self.index)\n\n\n #print \"Action List\", actionList\n\n\n\n\n weights = self.getWeights()\n\n features = self.featExtractor.getFeatures(state, action, self)\n #self.myFeats = features\n if self.index == 0:\n print \"FEATURES: \",features\n value = self.computeValueFromQValues(nextState)\n qValue = self.getQValue(state,action)\n #print \"value\", value, \"qValue\", qValue\n for feature in features:\n if len(actionList) != 0:\n weights[feature] = weights[feature] + self.alpha * (reward + self.discount * value - qValue) * features[feature]\n else:\n weights[feature] = weights[feature] + self.alpha * (reward - qValue) * features[feature]\n #print \"feature\", feature, \"weights\", weights[feature]\n #print \"weights\", weights\n\n #util.raiseNotDefined()","def update_dev_scores(self, results):\n for metric in results:\n print(\"Validation {} -> {} | lr: {}\".format(self.vctr, metric, self.optimizer.param_groups[0]['lr']), flush=True)\n self.val_scores[metric.name].append(metric)\n self.cur_bests[metric.name] = self.best_score(self.val_scores[metric.name])\n\n self.tensorboard_writter.add_scalar(\n f\"/dev/{metric.name}\", metric.score, self.vctr\n )\n\n # Decrease learning rate according to the scheduler policy\n if self.opti_scheduler and metric.name == self.early_metric:\n mode = \"max\" if metric.higher_better else \"min\"\n self.opti_scheduler._init_is_better(mode,\n self.opti_scheduler.threshold,\n self.opti_scheduler.threshold_mode)\n\n self.opti_scheduler.step(metric.score)","def update_Q(self, state, action, reward, new_state = None):\n Q_val = self.Q[state][action]\n \n # Look at the best action from the next state.\n Qp_val = 0\n if new_state is not None:\n Qp_val = max(self.Q[new_state].values())\n \n # The famous formula:\n Q_val = Q_val + self.alpha * (reward + self.gamma * Qp_val - Q_val)\n #print self.alpha\n #print state, 'action: ', action\n #print 'Q[%s]: %s' % (state, self.Q[state])\n #print 'Q val: ', Q_val\n \n self.Q[state][action] = Q_val\n \n return None","def update_usage(user_size):\n\n cnx = create_connection()\n cursor = cnx.cursor()\n\n update_query = (\n \"UPDATE \" + USAGE_TABLE['name'] + \" \"\n \" SET \" + USAGE_TABLE['size_column'] + \"=\" + str(user_size[1]) + \" \"\n \" WHERE \" + USAGE_TABLE['relational_column'] + \"='\" + user_size[0] + \"'\"\n )\n\n try:\n cursor.execute(update_query)\n except mysql.connector.Error as e:\n cursor.close()\n cnx.close()\n print(e)\n return\n\n cursor.close()\n cnx.close()","def update(self):\n result = [], 0, False\n\n if self.t % self.t_train_freq == 0:\n result = self.q_learning_minibatch()\n\n if self.t % self.t_target_q_update_freq == self.t_target_q_update_freq - 1:\n # Copy \n self.update_target_q_network()\n\n return result","def update_memory(self, vm):\n try:\n memory_spec = self.client.get_memory(vm.backend_id)\n if memory_spec['size_MiB'] != vm.ram:\n self.client.update_memory(vm.backend_id, {'size_MiB': vm.ram})\n except VMwareError as e:\n raise VMwareBackendError(e)","def run_query(**kwargs):\n logging.info(\n \"Running query: \"\n + kwargs[\"query\"][\"name\"]\n + \" iterations: \"\n + str(kwargs[\"iterations\"])\n )\n query_id = kwargs[\"query\"][\"name\"].rsplit(\".\")[\n 0\n ] # Query ID = filename without extention\n query_results = {\n \"query_name\": kwargs[\"query\"][\"name\"],\n \"query_mapdql\": kwargs[\"query\"][\"mapdql\"],\n \"query_id\": query_id,\n \"query_succeeded\": True,\n \"query_error_info\": \"\",\n \"initial_iteration_results\": {},\n \"noninitial_iteration_results\": [],\n \"query_total_elapsed_time\": 0,\n }\n query_total_start_time = timeit.default_timer()\n # Run iterations of query\n for iteration in range(kwargs[\"iterations\"]):\n # Gather memory before running query iteration\n logging.debug(\"Getting pre-query memory usage on CPU\")\n pre_query_cpu_mem_usage = get_mem_usage(\n con=kwargs[\"con\"], mem_type=\"cpu\"\n )\n logging.debug(\"Getting pre-query memory usage on GPU\")\n pre_query_gpu_mem_usage = get_mem_usage(\n con=kwargs[\"con\"], mem_type=\"gpu\"\n )\n # Run query iteration\n logging.debug(\n \"Running iteration \"\n + str(iteration)\n + \" of query \"\n + kwargs[\"query\"][\"name\"]\n )\n query_result = execute_query(\n query_name=kwargs[\"query\"][\"name\"],\n query_mapdql=kwargs[\"query\"][\"mapdql\"],\n iteration=iteration,\n con=kwargs[\"con\"],\n arrow_cpu_output=kwargs[\"arrow_cpu_output\"],\n \n )\n # Gather memory after running query iteration\n logging.debug(\"Getting post-query memory usage on CPU\")\n post_query_cpu_mem_usage = get_mem_usage(\n con=kwargs[\"con\"], mem_type=\"cpu\"\n )\n logging.debug(\"Getting post-query memory usage on GPU\")\n post_query_gpu_mem_usage = get_mem_usage(\n con=kwargs[\"con\"], mem_type=\"gpu\"\n )\n # Calculate total (post minus pre) memory usage after query iteration\n query_cpu_mem_usage = round(\n post_query_cpu_mem_usage[\"usedram\"]\n - pre_query_cpu_mem_usage[\"usedram\"],\n 1,\n )\n query_gpu_mem_usage = round(\n post_query_gpu_mem_usage[\"usedram\"]\n - pre_query_gpu_mem_usage[\"usedram\"],\n 1,\n )\n if query_result:\n query_results.update(\n query_error_info=\"\" # TODO - interpret query error info\n )\n # Assign first query iteration times\n if iteration == 0:\n first_execution_time = round(query_result[\"execution_time\"], 1)\n first_connect_time = round(query_result[\"connect_time\"], 1)\n first_total_time = (\n first_execution_time\n + first_connect_time\n )\n query_results.update(\n initial_iteration_results={\n \"first_execution_time\": first_execution_time,\n \"first_connect_time\": first_connect_time,\n \"first_total_time\": first_total_time,\n \"first_cpu_mem_usage\": query_cpu_mem_usage,\n \"first_gpu_mem_usage\": query_gpu_mem_usage,\n }\n )\n else:\n # Put noninitial iterations into query_result list\n query_results[\"noninitial_iteration_results\"].append(\n query_result\n )\n # Verify no change in memory for noninitial iterations\n if query_cpu_mem_usage != 0.0:\n logging.error(\n (\n \"Noninitial iteration ({0}) of query ({1}) \"\n + \"shows non-zero CPU memory usage: {2}\"\n ).format(\n iteration,\n kwargs[\"query\"][\"name\"],\n query_cpu_mem_usage,\n )\n )\n if query_gpu_mem_usage != 0.0:\n logging.error(\n (\n \"Noninitial iteration ({0}) of query ({1}) \"\n + \"shows non-zero GPU memory usage: {2}\"\n ).format(\n iteration,\n kwargs[\"query\"][\"name\"],\n query_gpu_mem_usage,\n )\n )\n else:\n logging.warning(\n \"Error detected during execution of query: \"\n + kwargs[\"query\"][\"name\"]\n + \". This query will be skipped and \"\n + \"times will not reported\"\n )\n query_results.update(query_succeeded=False)\n break\n # Calculate time for all iterations to run\n query_total_elapsed_time = round(\n ((timeit.default_timer() - query_total_start_time) * 1000), 1\n )\n query_results.update(query_total_elapsed_time=query_total_elapsed_time)\n logging.info(\n \"Completed all iterations of query \" + kwargs[\"query\"][\"name\"]\n )\n return query_results","def update_resources_for_this_host(cache, db):\n free_cpu, free_mem = get_resources()\n my_ip = cache[\"ip\"]\n\n logger.info(\"UPDATING\", extra = {\"cpu\": free_cpu, \"mem\": free_mem, \"ip\": my_ip})\n try:\n db.hset(my_ip, mapping={\"cpu\": free_cpu, \"mem\": free_mem})\n except Exception as e:\n logger.error(e)\n raise e","def _problem_update_history(self, _):\n self._update_reward_values()\n self.history.curr_reward.append(self.curr_reward)\n self.history.curr_best_reward.append(self.curr_best_reward)","def update(self, arm, reward):\n\n # Increate pulls by one\n self.pulls[arm] += 1\n\n # New number of pull\n n = self.pulls[arm]\n\n # Old value\n old_val = self.values[arm]\n\n # New value (online weighted average)\n new_val = ((n - 1) / n) * old_val + (1 / n) * reward\n\n # Update value\n self.values[arm] = new_val\n\n # Update epsilon\n self.t += 1\n self.epsilon = self.calc_dynamic_epsilon()","def update(self):\n\n self._pre_calc_mb()","def add(self, result, next_item):\n self.test += self.length\n self.hit += len(set(next_item) & set(result[:self.length].index))","def update_q_table(self, cur_state, action, reward, next_state):\n new_max_q = max(self.q_val_table[next_state])\n new_value = reward + self.gamma * new_max_q\n\n old_value = self.q_val_table[cur_state][action]\n self.q_val_table[cur_state][action] = old_value + self.alpha * (new_value - old_value)\n\n # Decay epsilon_greedy\n self.e_greedy_prob = self.exp_decay(self.e_greedy_prob)","def update(self, action, reward):\n # like puseudo count\n a, b = self.ActionValue[action]\n #print(f\"UPDATE {action}: ({a}, {b})\")\n a = a + self.huber(reward) # The larger the reward, the easier it is to select\n b = b + 1 - self.huber(reward) # It becomes easy to be selected as the reward becomes larger, and it becomes difficult to be selected as the reward becomes smaller\n a = 0.001 if a <= 0 else a\n b = 0.001 if b <= 0 else b\n \n self.ActionValue[action] = (a, b)\n\n #print(f\"=> ({a}, {b})\")\n\n # Update nearby action candidates\n around_update_rate = 0.3 # Parameter to adjust the degree of change according to the distance; [0, 1]\n radius = np.sqrt(self.action_resolution**2 + self.action_resolution**2 + 1e-9) # 1e-9 is for safety to caluculate the small number \n for action_around in self.actions:\n if action_around == action:\n continue\n x = action_around[0] - action[0]\n y = action_around[1] - action[1]\n distance = np.sqrt(x**2 + y**2)\n if distance <= radius:\n a, b = self.ActionValue[action_around]\n #print(f\"UPDATE {action_around}: ({a}, {b})\")\n a = a + self.huber(reward) * around_update_rate * (1 - distance)\n b = b + (1 - self.huber(reward)) * around_update_rate * (1 - distance) # To adjust the update, weight 1-r. If normal update is 1, it will be the update of around_update_rate * (1-distance) for adjacent actions.\n a = 0.001 if a <= 0 else a\n b = 0.001 if b <= 0 else b\n\n #print(f\"=> ({a}, {b})\")\n\n self.ActionValue[action_around] = (a, b)"],"string":"[\n \"def _update(self, nbrs, nbrs_y, query, query_y):\\n\\n # Set up the graph for our shared memory variables\\n new_K, new_A, new_V = self.K, self.A, self.V\\n\\n # Condition (1): First returned neighbour shares the same query label\\n correct_query = T.eq(nbrs_y[:, 0], query_y).nonzero()[0]\\n correct_mem = nbrs[correct_query, 0] # Idx to memory keys\\n\\n normed_keys = tensor_norm(query[correct_query] + new_K[correct_mem])\\n new_K = T.set_subtensor(new_K[correct_mem], normed_keys)\\n new_A = T.set_subtensor(new_A[correct_mem], 0.)\\n\\n # Condition (2): First returned neighbour does not share query label.\\n # Add the key and label from query to memory\\n incorrect_mask = T.neq(nbrs_y[:, 0], query_y)\\n incorrect_query = incorrect_mask.nonzero()[0]\\n\\n # We need to find len(incorrect_query) locations in memory to write to.\\n # Noise is added to randomize selection.\\n age_mask = T.ge(new_A, T.max(new_A) - self.C) #1d\\n oldest_idx = tensor_choose_k(age_mask, self.rng,\\n k=T.sum(incorrect_mask),\\n random=True).flatten()\\n\\n new_K = T.set_subtensor(new_K[oldest_idx], query[incorrect_query])\\n new_V = T.set_subtensor(new_V[oldest_idx], query_y[incorrect_query])\\n new_A = T.set_subtensor(new_A[oldest_idx], 0.)\\n\\n # Increment the age of all non-updated indices by 1\\n new_A = new_A + 1.\\n new_A = T.inc_subtensor(new_A[correct_mem], -1.)\\n new_A = T.inc_subtensor(new_A[oldest_idx], -1.)\\n\\n return OrderedDict({(self.K, new_K), (self.V, new_V), (self.A, new_A)})\",\n \"def update_memory(self, result):\\r\\n if (len(self.memory) >= self.memory_capacity):\\r\\n self.memory.pop(0)\\r\\n self.memory.append(result)\\r\\n else:\\r\\n self.memory.append(result)\",\n \"def update_search_space(self, search_space):\\n raise NotImplementedError('Tuner: update_search_space not implemented')\",\n \"def update_results(self, results):\\n pass\",\n \"def update_vm_result(self, context, msg):\\n args = jsonutils.loads(msg)\\n agent = context.get('agent')\\n port_id = args.get('port_uuid')\\n result = args.get('result')\\n LOG.debug('update_vm_result received from %(agent)s: '\\n '%(port_id)s %(result)s', {'agent': agent,\\n 'port_id': port_id,\\n 'result': result})\\n\\n # Add the request into queue for processing.\\n event_type = 'agent.vm_result.update'\\n payload = {'port_id': port_id, 'result': result}\\n timestamp = time.ctime()\\n data = (event_type, payload)\\n # TODO(nlahouti) use value defined in constants\\n pri = self.obj.PRI_LOW_START + 10\\n self.obj.pqueue.put((pri, timestamp, data))\\n LOG.debug('Added request vm result update into queue.')\\n\\n return 0\",\n \"def update_score(self, concept: _Concept, result: _Result) -> None:\\n\\n score = self.make_score(concept, result)\\n if score is None:\\n pass\\n else:\\n self._vector.append(score)\",\n \"def UpdateNode(self, result, actions):\\n self.visits += 1\\n self.wins += (result > 0)\\n self.losses += (result < 0)\\n self.draws += (result == 0)\\n self.Q = self.Q + (result - self.Q)/self.visits\\n \\n # update rave values\\n for a in actions:\\n self.N_AMAF[a] += 1\\n if not a in self.Q_AMAF:\\n self.Q_AMAF[a] = 0.5\\n self.Q_AMAF[a] = self.Q_AMAF[a] + (result - self.Q_AMAF[a])/self.N_AMAF[a]\\n else:\\n self.Q_AMAF[a] = self.Q_AMAF[a] + (result - self.Q_AMAF[a])/self.N_AMAF[a]\",\n \"def update_qvals(self, state, action, reward):\\n self.qvals[(state, action)] = 0\",\n \"def updateQTable( self, reward, current_state ):\",\n \"def _update_memory(key, cur, target, common_mem):\\n mod_swap = {\\\"G\\\": \\\"M\\\", \\\"g\\\": \\\"m\\\"}\\n cur_mem, orig_mod = _get_cur_mem(key, cur)\\n if cur_mem >= common_mem * 1.5:\\n return cur\\n else:\\n new_val = \\\"%s%s\\\" % (target, mod_swap.get(orig_mod, orig_mod))\\n if key == \\\"jvm_opts\\\":\\n out = cur\\n out[-1] = \\\"-Xmx%s\\\" % new_val\\n else:\\n out = new_val\\n return out\",\n \"def update_Qfunction(self, result):\\n if result == \\\"won\\\":\\n final_value = WIN_VALUE\\n elif result == \\\"draw\\\":\\n final_value = DRAW_VALUE\\n elif result == \\\"lost\\\":\\n final_value = LOSS_VALUE\\n \\n self.move_history.reverse()\\n next_max = -1.0\\n \\n for h in self.move_history:\\n qvals = self.get_q(h[0])\\n m = h[1]\\n \\n if next_max < 0:\\n qvals[m] = final_value\\n else:\\n qvals[m] = qvals[m] * (1.0 - self.learning_rate) + self.learning_rate * self.value_discount * next_max\\n \\n self.q[h[0]] = qvals \\n next_max = max(qvals)\",\n \"def update_q_value(q_table: np.ndarray, state: int, action: int,\\n learning_rate: float, current_reward: float,\\n new_state: int, discount_rate: float) -> None:\\n q_table[state, action] = new_q_value(q_table, state, action, learning_rate,\\n current_reward, new_state,\\n discount_rate)\",\n \"def set_result(self, params, result, id=0):\\n for i in range(len(self.result), id + 1):\\n self.result.append(None)\\n print \\\"List index %d does not exist, should not happen\\\" % i\\n self.result[id] = result\\n if self.best_score is None or result < self.best_score:\\n self.best_score = result\\n self.best_params = params\\n return params, result\",\n \"def update(self, result):\\n\\n runs_scored = 0\\n outs_recorded = 0\\n\\n if result == 'single':\\n # Runners from 2b or 3b score first\\n if self.occupied_2b and self.occupied_3b:\\n self.occupied_2b = False\\n self.occupied_3b = False\\n runs_scored += 2\\n elif self.occupied_2b or self.occupied_3b:\\n self.occupied_2b = False\\n self.occupied_3b = False\\n runs_scored += 1\\n # Runners from first advance\\n if self.occupied_1b:\\n self.occupied_2b = True\\n # First base now occupied\\n self.occupied_1b = True\\n\\n if result == 'double':\\n # Runners from 2b or 3b score\\n if self.occupied_2b and self.occupied_3b:\\n self.occupied_2b = False\\n self.occupied_3b = False\\n runs_scored += 2\\n elif self.occupied_2b or self.occupied_3b:\\n self.occupied_2b = False\\n self.occupied_3b = False\\n runs_scored += 1\\n # Runner on 1st (see notes)\\n if self.occupied_1b:\\n rand = random.uniform(0,1)\\n if rand < 0.4:\\n runs_scored +=1\\n else:\\n self.occupied_3b = True\\n self.occupied_1b = False\\n \\n if result == 'triple':\\n # Everyone on base scores\\n number_bases_occupied = self.occupied_1b + self.occupied_2b + self.occupied_3b\\n runs_scored += number_bases_occupied\\n # New runner on 3b\\n self.occupied_3b = True\\n\\n if result == 'home run':\\n number_bases_occupied = self.occupied_1b + self.occupied_2b + self.occupied_3b\\n runs_scored += number_bases_occupied + 1\\n\\n if result == 'foul out' or result == 'fly out' or result == 'out at 1st' or result == 'strike out':\\n outs_recorded += 1\\n\\n if result == 'double play':\\n # This is weird, since dps aren't always possible. See notes.\\n \\n if self.occupied_1b + self.occupied_2b + self.occupied_3b == 0:\\n # If nobody on base, just a normal out\\n outs_recorded +=1\\n \\n ## 1 existing Baserunner scenario\\n elif self.occupied_1b and not self.occupied_2b and not self.occupied_3b:\\n # If on first, outs at 1b and 2b\\n self.occupied_1b = False\\n outs_recorded += 2\\n elif (not self.occupied_1b and self.occupied_2b and not self.occupied_3b):\\n # If baserunner on second, no force outs, just add an out\\n outs_recorded += 1\\n elif (not self.occupied_1b and not self.occupied_2b and self.occupied_3b):\\n # If baserunner on third, same\\n outs_recorded += 1\\n\\n ## 2 existing Baserunner scenario\\n elif self.occupied_1b and self.occupied_2b and not self.occupied_3b:\\n # If on 1st and 2nd, outs at 3rd and 2nd\\n self.occupied_1b = True\\n self.occupied_2b = False\\n outs_recorded += 2\\n elif self.occupied_1b and not self.occupied_2b and self.occupied_3b:\\n # If on 1st and 3nd, outs at 2rd and 1st\\n self.occupied_1b = False\\n outs_recorded += 2\\n elif not self.occupied_1b and self.occupied_2b and self.occupied_3b: \\n # If 2b and 3b occupied, only force out at 1b, so base/out doesn't change\\n outs_recorded += 1\\n\\n ## 3 existing Baserunner scneario\\n elif self.occupied_1b and self.occupied_2b and self.occupied_3b: \\n # If bases loaded, outs at home and 3b. 2b and 1b stay occupied\\n self.occupied_3b = False\\n outs_recorded += 2\\n\\n\\n if result == 'base on error':\\n # Everyone advances\\n if self.occupied_3b:\\n runs_scored += 1\\n self.occupied_3b = False\\n if self.occupied_2b:\\n self.occupied_3b = True\\n self.occupied_2b = False\\n if self.occupied_1b:\\n self.occupied_2b = True\\n self.occupied_1b = False\\n self.occupied_1b = True\\n\\n\\n if result == 'base on balls':\\n if self.occupied_3b and self.occupied_2b and self.occupied_1b:\\n runs_scored += 1\\n if self.occupied_2b and self.occupied_1b:\\n self.occupied_3b = True\\n if self.occupied_1b:\\n self.occupied_2b = True\\n self.occupied_1b = True \\n\\n return runs_scored, outs_recorded\",\n \"def update(self, rank):\\n # calculate MR and MRR\\n self.mr += rank\\n self.mrr += 1 / rank\\n # calculate Hits@k\\n if rank <= 1:\\n self.hits1 += 1\\n self.hits3 += 1\\n self.hits5 += 1\\n self.hits10 += 1\\n elif rank <= 3:\\n self.hits3 += 1\\n self.hits5 += 1\\n self.hits10 += 1\\n elif rank <= 5:\\n self.hits5 += 1\\n self.hits10 += 1\\n elif rank <= 10:\\n self.hits10 += 1\",\n \"def update_used_query_range(\\n self,\\n write_cursor: 'DBCursor',\\n location_string: str,\\n queried_ranges: list[tuple[Timestamp, Timestamp]],\\n ) -> None:\\n if len(queried_ranges) == 0:\\n return\\n\\n starts = [x[0] for x in queried_ranges]\\n ends = [x[1] for x in queried_ranges]\\n saved_range = self.db.get_used_query_range(write_cursor, location_string)\\n if saved_range is not None:\\n starts.append(saved_range[0])\\n ends.append(saved_range[1])\\n\\n self.db.update_used_query_range(\\n write_cursor=write_cursor,\\n name=location_string,\\n start_ts=min(starts),\\n end_ts=max(ends),\\n )\",\n \"def update(self, result):\\n #print(\\\"updating node result = \\\" + str(result))\\n self.visits += 1\\n self.wins += result\",\n \"def _adjust_memory(self, neighbour, neighbour_choice):\\n if neighbour in self._memory:\\n self.get_memory_of(neighbour).add_choice_to_memory(\\n neighbour_choice, self.get_gene().get_mem_size())\\n else:\\n print (\\\"err: getMemory: no memory of subjectID \\\"\\n + str(neighbour.get_id()))\",\n \"def update_cache(self, query, results, expire):\\n self.logger.info(\\\"DASMemcache::result(%s) store to cache\\\" % query)\\n if not results:\\n return\\n key = genkey(query)\\n rowdict = {}\\n rowid = 0\\n for row in results:\\n if type(row) is dict:\\n row['id'] = rowid\\n rowdict[rowid] = row\\n rowid += 1\\n if len(rowdict.keys()) == self.chunk_size:\\n self.memcache.set_multi(rowdict, time=expire, key_prefix=key)\\n rowdict = {}\\n yield row\\n self.memcache.set_multi(rowdict, time=expire, key_prefix=key)\\n self.memcache.set(key, rowid, expire)\",\n \"def update_q(self,action,reward):\\n #print('')\\n #print('Action index is: ' + str(action))\\n #print('Provided reward is: ' + str(reward))\\n \\n # Read from disk before updating\\n try:\\n pickle_in = open(\\\"static/data/values.pickle\\\",\\\"rb\\\")\\n values = pickle.load(pickle_in)\\n #print(values)\\n self.values = values\\n pickle_in = open(\\\"static/data/counts.pickle\\\",\\\"rb\\\")\\n self.counts = pickle.load(pickle_in)\\n pickle_in = open(\\\"static/data/actions_taken.pickle\\\",\\\"rb\\\")\\n actions_taken = pickle.load(pickle_in)\\n pickle_in = open(\\\"static/data/reward_list.pickle\\\",\\\"rb\\\")\\n reward_list = pickle.load(pickle_in)\\n except:\\n actions_taken = []\\n reward_list = []\\n pass\\n \\n self.counts[action] += 1\\n n = self.counts[action]\\n value = self.values[action]\\n actions_taken.append(action)\\n reward_list.append(reward)\\n \\n # Running product\\n new_value = value + (1/n) * (reward - value)\\n self.values[action] = new_value\\n \\n \\n # Save to disk before exiting\\n pickle_out = open('static/data/values.pickle','wb')\\n pickle.dump(self.values, pickle_out)\\n pickle_out.close()\\n pickle_out = open('static/data/counts.pickle','wb')\\n pickle.dump(self.counts, pickle_out)\\n pickle_out.close()\\n pickle_out = open('static/data/actions_taken.pickle','wb')\\n pickle.dump(actions_taken, pickle_out)\\n pickle_out.close()\\n pickle_out = open('static/data/reward_list.pickle','wb')\\n pickle.dump(reward_list, pickle_out)\\n pickle_out.close()\",\n \"def _fill_query_slots(self, queries: List[Query]) -> None:\\n while queries and self.query_slots > 0:\\n logger.debug(\\n f\\\"{self.query_slots} available query slots, creating query task\\\"\\n )\\n query = queries.pop(0)\\n query_task_id = self.client.create_query_task(query.query_id)\\n self.query_slots -= 1\\n query.query_task_id = query_task_id\\n self._query_by_task_id[query_task_id] = query\\n self._running_queries.append(query)\",\n \"def update_memory(self, target, clues, guesses, winlose):\\n immediate_rewards = self.get_trajectory_immediate_rewards(target, \\n clues,\\n guesses)\\n \\n self.memory.append((target, \\n clues, \\n guesses, \\n winlose, \\n immediate_rewards))\",\n \"def update(self, FlowStatistics=None, MatchIpAddressInArpPackets=None, PortStatistics=None, QueueStatistics=None, ReassambleIpFragments=None, Reserved=None, SpanningTree=None, TableStatistics=None):\\n self._update(locals())\",\n \"def update(self, state, action, nextState, reward):\\n \\\"\\\"\\\"Description:\\n Use Q-Learning algoritm in slide 58 of MDP\\n \\\"\\\"\\\"\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n maxQns = self.getValue(nextState) # get max q-value of next state\\n if maxQns == None:\\n maxQns = 0\\n Qsa = self.getQValue(state, action) #self.qValues[(state, action)]\\n difference = reward + self.discountRate * maxQns - Qsa\\n self.qValues[(state, action)] += self.alpha * difference\\n \\n self.vitCount[(state, action)] += 1\\n \\\"\\\"\\\" END CODE \\\"\\\"\\\"\",\n \"def update(self, arm, reward):\\n raise NotImplementedError\",\n \"def _update_q_value(self, start_state, to_state, reward, iteration):\\n if start_state.as_tuple() not in self.qstore.q:\\n self.enum.enumerate_state(start_state, self.qstore.q)\\n if to_state.as_tuple() not in self.qstore.q:\\n self.enum.enumerate_state(to_state, self.qstore.q)\\n\\n actions = self.qstore.q[start_state.as_tuple()]['actions']\\n values = self.qstore.q[start_state.as_tuple()]['utilities']\\n\\n max_over_next_states = max(self.qstore.q[to_state.as_tuple()]['utilities']) if to_state.terminate != 1 else 0\\n\\n action_between_states = to_state.as_tuple()\\n\\n action_index = actions.index(action_between_states)\\n learning_rate_alpha = 1 / (iteration ** self.state_space_parameters.learning_rate_omega)\\n\\n # Q_Learning update rule\\n values[action_index] = ( # Q_t+1(s_i,𝑢) =\\n values[action_index] + # Q_t(s_i,𝑢)\\n learning_rate_alpha * ( # α\\n reward # r_t\\n + self.state_space_parameters.discount_factor # γ\\n * max_over_next_states # max_{𝑢'∈ 𝒰(s_j)} Q_t(s_j,𝑢')\\n - values[action_index] # -Q_t(s_i,𝑢)\\n )\\n )\\n\\n self.qstore.q[start_state.as_tuple()] = {'actions': actions, 'utilities': values}\",\n \"def update(self, reward):\\n raise NotImplementedError\",\n \"def update_results_score(self, edge, regions):\\r\\n if self.results_file is None:\\r\\n return # No update\\r\\n \\r\\n pln = self.get_player_num()\\r\\n self.results_file.results_update(player_num=pln, nsquare=len(regions))\",\n \"def vm_result_update(self, payload):\\n\\n port_id = payload.get('port_id')\\n result = payload.get('result')\\n\\n if port_id and result:\\n # Update the VM's result field.\\n params = dict(columns=dict(result=result))\\n self.update_vm_db(port_id, **params)\",\n \"def update_q_table(self, state, action, reward):\\n\\n q_key = self.q_key(state, action)\\n inputs = self.env.sense(self)\\n self.next_waypoint = self.planner.next_waypoint()\\n new_state = self.set_current_state(inputs)\\n\\n #update q_value in q_table according to learning formula\\n x = self.q_value(state, action)\\n V = reward + (self.gamma * self.max_q_value(new_state))\\n new_q_value = x + (self.alpha * (V - x))\\n self.q_table[q_key] = new_q_value\",\n \"def update_Qtable(self, r, action, next_state):\\n if self.learning:\\n # 8. When learning, update the q table according\\n # to the given rules\\n\\n # The reward the turkey get after doing the action\\n reward_t1 = r\\n\\n # Code Review1: Replace the following code\\n '''\\n # Get the key & value which enables the max Q value in State(t+1)\\n max_Q_St1_info = max(self.Qtable[next_state].items(), key=operator.itemgetter(1))\\n\\n # The action which enables the max Q value in State(t+1)\\n max_Q_St1_action = max_Q_St1_info[0]\\n\\n # The max Q value in State(t+1)\\n max_Q_St1 = max_Q_St1_info[1]\\n '''\\n max_Q_St1 = max(self.Qtable[next_state].values())\\n\\n Q_old = self.Qtable[self.state][action]\\n Q_new = reward_t1 + self.gamma * max_Q_St1\\n\\n self.Qtable[self.state][action] = (\\n 1 - self.alpha) * Q_old + self.alpha * Q_new\",\n \"def updateQValue(self, state, action, old_q, reward, future_rewards):\\n self.q[(tuple(state), action)] = old_q + self.alpha * (reward + future_rewards - old_q)\",\n \"def update(self, arm, reward, context):\",\n \"def update(self, result: int):\\n self.wins += result\\n self.visits += 1\",\n \"def process_query(self, query):\\n query._cache_region = self\",\n \"def restore_program(memory_updates: Dict[int, int], memory: List[int]) -> List[int]:\\n for (index, new_value) in memory_updates.items():\\n memory[index] = new_value\\n return memory\",\n \"def add_result(self, result):\\n if len(self.results) == self.max_size:\\n del self.results[0]\\n self.results.append(result)\",\n \"def update_Q(self, reward):\\n old_estimate = self.q_estimates[self.prev_action]\\n self.q_estimates[self.prev_action] = old_estimate + 1/self.N[self.prev_action] * (reward - old_estimate)\",\n \"def update(self, state, action, nextState, reward):\\n \\\"*** YOUR CODE HERE ***\\\"\\n self.qValues[(state, action)] = ((1 - self.alpha) * self.getQValue(state, action)) + self.alpha \\\\\\n * (reward + self.discount * self.computeValueFromQValues(nextState))\",\n \"def update_quality():\\n global items, converted_items\\n if not converted_items:\\n items = convert_items(items)\\n converted_items = True\\n for item in items:\\n item.update_q()\",\n \"def update(self, state, action, nextState, reward):\\n self.qvals[(state, action)] = self.qvals[(state, action)] + self.alpha * (\\n reward + self.discount * self.computevaluefromqvalues(nextState) - self.qvals[(state, action)])\",\n \"def update(self, state, action, nextState, reward):\\n \\\"*** YOUR CODE HERE ***\\\"\\n best_action = self.computeActionFromQValues(nextState)\\n self.QValueCounter[(state, action)] = ((1 - self.alpha) * self.getQValue(state, action) +\\n self.alpha * (reward + self.discount * self.getQValue(nextState,\\n best_action)))\",\n \"def update_Q(self, state, action, new_state, reward):\\n \\n self.Q[(state, action)] = self.Q[(state, action)] + self.alpha*(reward + self.gamma * self.max_value(new_state) - self.Q[(state, action)])\",\n \"def update_q_values(self, s_current, action, r_next, s_next, action_next):\\n action = actions_indexes[action]\\n action_next = actions_indexes[action_next]\\n self.q_values[s_current, action] += self.alpha * (\\n r_next + self.gamma * self.q_values[s_next, action_next] - self.q_values[s_current, action])\",\n \"def update_query(self):\\n text = self.lineedit.text()\\n self.results = self.lookup(text)\\n self.update_ui()\\n self.copy_entry(self.table.currentRow(), self.table.currentColumn())\",\n \"def update(self, arm, context, reward):\\n raise NotImplementedError\",\n \"def update(self, arm, context, reward):\\n raise NotImplementedError\",\n \"def update_Q(self, state, action, new_state, new_action, reward):\\n \\n self.Q[(state, action)] = float(self.Q[(state, action)] + self.alpha*(reward + self.gamma * self.Q[new_state, new_action] - self.Q[(state, action)]))\",\n \"def update_scores(read_scores, result):\\n\\n\\t# check that there are some results for this read\\n\\tassert len(result) > 0\\n\\t# write this read to output\\n\\tfor sim_match in result.keys():\\n\\n\\t\\t# get type (discordant or chimeric)\\n\\t\\tjunc_type = sim_match.split('_')[2]\\n\\n\\t\\tfor analysis_match in result[sim_match]:\\n\\t\\t\\t\\n\\t\\t\\t# get each score type\\n\\t\\t\\tfor score_type in read_scores:\\n\\t\\t\\t\\tscore = analysis_match[score_type]\\n\\t\\t\\t\\tread_scores[score_type][junc_type][score] += 1\",\n \"def update_scores(self, score):\\n self.result_list.append(score)\\n\\n if self.best_score == 0 and self.worst_score == 0:\\n self.best_score = score\\n self.worst_score = score\\n\\n if score < self.best_score:\\n self.best_score = score\\n\\n if score > self.worst_score:\\n self.worst_score = score\",\n \"def _update_scoreboard(self, result):\\n if result == Moveresult.KEY:\\n self.current_turn.keys_collected += 1\\n elif result == Moveresult.EXIT:\\n self.current_turn.successful_exits += 1\",\n \"def update(self, state, action, nextState, reward):\\n \\\"*** YOUR CODE HERE ***\\\"\\n Q_Value = self.Q #calling constructor\\n\\n learning_rate = self.alpha #gives us the learning rate\\n\\n temporary_QValue = self.getQValue(state,action) #to get the Q value of the state\\n\\n nextState_QValue = self.getValue(nextState) #to get the Q value of the landing state when taken action a and state s\\n\\n discount_factor = self.discount #to get the gamma/ discount factor\\n\\n\\n Q_Value[(state,action)] = ((1-learning_rate) * temporary_QValue) + (learning_rate * (reward + discount_factor * nextState_QValue)) #for formula go to README_Reinforcement.txt at line 8\\n\\n #util.raiseNotDefined()\",\n \"def update_reward(self, observation, action, reward):\\n self.q_table[observation,action] = (1 - self.count(observation,action)) * self.q_table[observation,action] + self.count(observation,action) * reward # Canonical Q-update\\n self.increment_count(observation,action)\",\n \"def Update(self, result):\\n self.visits += 1\\n self.wins += result\",\n \"def Update(self, result):\\n self.visits += 1\\n self.wins += result\",\n \"def update(self, old_state, action, new_state, reward):\\r\\n \\r\\n old = self.get_q_value(old_state, action)\\r\\n best_future = self.best_future_reward(new_state)\\r\\n self.update_q_value(old_state,action, old, reward, best_future)\",\n \"def update_Q(self):\",\n \"def update(self, result):\\n self.visits += 1\\n self.wins += result\",\n \"def update_unsampled_queries(self, remaining_indices):\\n remaining_queries_ids = [\\n self.unsampled_queries.elements[i] for i in remaining_indices\\n ]\\n self.unsampled_queries = ProcessedQueryList(\\n cache=self.resource_loader.query_cache, elements=remaining_queries_ids\\n )\",\n \"def update(self):\\r\\n self.data = [self.make_item_tuple(i) for i in self.query]\\r\\n self._fetched = True\\r\\n query_cache.set(self.iden, self.data)\",\n \"def update(self, x_dict, y_dict, weight):\\n assert len(x_dict) == len(y_dict), \\\"invalid # of qids\\\"\\n \\n qids = self.__get_shuffled_qids(x_dict, y_dict, weight.epoch)\\n w = weight.get_dense_weight()\\n for qid in tqdm(qids):\\n w = approx_ap(x_dict[qid].toarray(), y_dict[qid], w, self.eta, self.alpha, self.beta)\\n weight.set_weight(sp.csr_matrix(w.reshape((1, weight.dims))))\\n weight.epoch += 1\",\n \"def update_score(self):\\n self.score = TurboMQ.calculate_fitness(self.result, self.graph)\",\n \"def update_individuals(individuals, eval_results):\\n for ind, res in zip(individuals, eval_results):\\n ind.fitness.values = res[0]\\n ind.matching_node_pairs = res[1]\\n ind.gtp_precisions = res[2]\",\n \"def update(self, state, action, nextState, reward):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # print \\\"update\\\"\\n oldValue = self.getQValue(state, action)\\n sample = reward + self.discount*self.computeValueFromQValues(nextState)\\n self.qValues[(state, action)] = (1-self.alpha)*oldValue + self.alpha*(sample)\",\n \"def put(self, search_query, page_number, search_results):\\n timestamp = int(time.time())\\n with self.get_conn() as conn:\\n c = conn.cursor()\\n insert = \\\"\\\"\\\"INSERT OR REPLACE INTO movies\\n (search_query, page_number, timestamp, search_results)\\n VALUES (?, ?, ?, ?)\\\"\\\"\\\"\\n\\n c.execute(insert, (search_query, page_number, timestamp, search_results,))\\n conn.commit()\",\n \"def update_q_values(self, state, action, next_state, reward, done):\\n # Following the Q-Learning update rule\\n if done:\\n self.Q_values[state,action] = (1 - self.alpha) * self.Q_values[state,action] + self.alpha * (reward)\\n else:\\n self.Q_values[state,action] = (1 - self.alpha) * self.Q_values[state,action] + self.alpha * (reward + self.gamma * np.amax(self.Q_values[next_state]))\",\n \"def update_result(result):\\n invader = result['invader'] \\n countryOfInvader = result['countryOfInvader'] \\n defender = result['defender'] \\n countryOfdefender = result['countryOfdefender'] \\n invasionHistory = InvasionHistory(\\n invader ,\\n countryOfInvader,\\n defender,\\n countryOfdefender,\\n datetime.datetime.now() )\\n\\n #update territory info\\n t_record = Territory.get_by_key_name(countryOfdefender)\\n t_record.occupier = invader\\n t_record.put() \\n\\n db.put([invasionHistory])\",\n \"def mult_operation(self):\\n arg1 = self.memory[self.memory[self._cursor + 1]]\\n arg2 = self.memory[self.memory[self._cursor + 2]]\\n arg3 = self.memory[self._cursor + 3]\\n self.memory[arg3] = arg1 * arg2\\n print(f'Cursor: {self._cursor}\\\\tAssigning position {arg3} with value {arg1 * arg2}')\\n self._cursor += 4\\n return\",\n \"def update_a_result(self, idblock, sib):\\n self.resultPanel.update_item(idblock, sib)\",\n \"def __on_query_edited(self):\\n self.__refresh_search_results()\",\n \"def update(self, target, query):\\n node = self._data[target]\\n name = \\\"%s node %.8s\\\" % (node['type'], target)\\n\\n query.update({\\n 'type': node['type'],\\n 'model': node['model']\\n })\\n\\n logger.info(\\\"Validating query\\\")\\n NodeValidator.validate(query)\\n\\n self._data[target] = dict_update(node, query, name)\\n logger.info(\\\"Updated parameters above of %s\\\" % name)\\n\\n return {target: self._data[target]}\",\n \"def update_state(self, result):\\n for i,k in enumerate(self._current_state.keys()):\\n self._current_state[k] = result[i]\",\n \"def _update_result(self, results, clf_numbers):\\n # ToDo make results of scoring values dynamic\\n names_results = ['Accuracy']\\n for number in clf_numbers:\\n for name in names_results:\\n if name not in self.results:\\n self.results[name] = [results[number][name + \\\"_test_score_\\\" + str(number)]]\\n else:\\n self.results[name].append(results[number][name + \\\"_test_score_\\\" + str(number)])\",\n \"def increment_rank(self, rank, result):\\n if result not in VALID_RESULTS:\\n raise ValueError('Invalid result: %s' % result)\\n self.counts[rank][result] += 1\\n self.total_items += 1\",\n \"def update(self, timestep, action, reward, is_optimal):\\r\\n\\t\\t# Increments the Player's selected action index by 1.\\r\\n\\t\\tself.player_selected_actions[action] += 1\\r\\n\\r\\n\\t\\t# Sets the Player reward for the particular timestep to the reward\\r\\n\\t\\t# obtained.\\r\\n\\t\\tself.player_reward[timestep] = reward\\r\\n\\r\\n\\t\\t# Sets the Player optimum for the particular timestep to the is_optimal\\r\\n\\t\\t# obtained.\\r\\n\\t\\tself.player_optimum[timestep] = is_optimal\",\n \"def update(self, state, action, nextState, reward):\\n oldComponent = (1-self.alpha) * self.getQValue(state, action)\\n nextValue = self.computeValueFromQValues(nextState)\\n sample = reward + self.discount * nextValue\\n newComponent = self.alpha * sample\\n self.qValues[(state, action)] = oldComponent + newComponent\",\n \"def _run(self): # pylint: disable=too-many-locals.too-many-branches,too-many-statements\\n num_of_stored_commands_before = len(self._stored_commands)\\n if not self.current_mapping:\\n self.current_mapping = {}\\n else:\\n self._send_possible_commands()\\n if len(self._stored_commands) == 0:\\n return\\n new_row_major_mapping = self._return_new_mapping()\\n # Find permutation of matchings with lowest cost\\n swaps = None\\n lowest_cost = None\\n matchings_numbers = list(range(self.num_rows))\\n if self.num_optimization_steps <= math.factorial(self.num_rows):\\n permutations = itertools.permutations(matchings_numbers, self.num_rows)\\n else:\\n permutations = []\\n for _ in range(self.num_optimization_steps):\\n permutations.append(self._rng.sample(matchings_numbers, self.num_rows))\\n for permutation in permutations:\\n trial_swaps = self.return_swaps(\\n old_mapping=self._current_row_major_mapping,\\n new_mapping=new_row_major_mapping,\\n permutation=permutation,\\n )\\n if swaps is None:\\n swaps = trial_swaps\\n lowest_cost = self.optimization_function(trial_swaps)\\n elif lowest_cost > self.optimization_function(trial_swaps):\\n swaps = trial_swaps\\n lowest_cost = self.optimization_function(trial_swaps)\\n if swaps: # first mapping requires no swaps\\n # Allocate all mapped qubit ids (which are not already allocated,\\n # i.e., contained in self._currently_allocated_ids)\\n mapped_ids_used = set()\\n for logical_id in self._currently_allocated_ids:\\n mapped_ids_used.add(self._current_row_major_mapping[logical_id])\\n not_allocated_ids = set(range(self.num_qubits)).difference(mapped_ids_used)\\n for mapped_id in not_allocated_ids:\\n qb = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[mapped_id])\\n cmd = Command(engine=self, gate=AllocateQubitGate(), qubits=([qb],))\\n self.send([cmd])\\n # Send swap operations to arrive at new_mapping:\\n for qubit_id0, qubit_id1 in swaps:\\n qb0 = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[qubit_id0])\\n qb1 = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[qubit_id1])\\n cmd = Command(engine=self, gate=Swap, qubits=([qb0], [qb1]))\\n self.send([cmd])\\n # Register statistics:\\n self.num_mappings += 1\\n depth = return_swap_depth(swaps)\\n if depth not in self.depth_of_swaps:\\n self.depth_of_swaps[depth] = 1\\n else:\\n self.depth_of_swaps[depth] += 1\\n if len(swaps) not in self.num_of_swaps_per_mapping:\\n self.num_of_swaps_per_mapping[len(swaps)] = 1\\n else:\\n self.num_of_swaps_per_mapping[len(swaps)] += 1\\n # Deallocate all previously mapped ids which we only needed for the\\n # swaps:\\n mapped_ids_used = set()\\n for logical_id in self._currently_allocated_ids:\\n mapped_ids_used.add(new_row_major_mapping[logical_id])\\n not_needed_anymore = set(range(self.num_qubits)).difference(mapped_ids_used)\\n for mapped_id in not_needed_anymore:\\n qb = WeakQubitRef(engine=self, idx=self._mapped_ids_to_backend_ids[mapped_id])\\n cmd = Command(engine=self, gate=DeallocateQubitGate(), qubits=([qb],))\\n self.send([cmd])\\n # Change to new map:\\n self._current_row_major_mapping = new_row_major_mapping\\n new_mapping = {}\\n for logical_id, mapped_id in new_row_major_mapping.items():\\n new_mapping[logical_id] = self._mapped_ids_to_backend_ids[mapped_id]\\n self.current_mapping = new_mapping\\n # Send possible gates:\\n self._send_possible_commands()\\n # Check that mapper actually made progress\\n if len(self._stored_commands) == num_of_stored_commands_before:\\n raise RuntimeError(\\n \\\"Mapper is potentially in an infinite loop. It is likely that the algorithm requires too\\\"\\n \\\"many qubits. Increase the number of qubits for this mapper.\\\"\\n )\",\n \"def update_optimization_results(output, model, result, runtime):\\n\\n data_path = output['Input_Data']\\n\\n result['Optimized_Model'] = [model]\\n result['Optimized_Likelihood'] = [float(\\n result['Optimized_Likelihood'])]\\n\\n if isinstance(data_path, list):\\n result['Dataset'] = []\\n for data in data_path:\\n result['Dataset'].append(os.path.basename(data))\\n else:\\n result['Dataset'] = [os.path.basename(data_path)]\\n\\n result['Runtime'] = runtime\\n\\n if output['Kernel_Transform'] is not False:\\n result['Kernel_Transform'] = str(output['Kernel_Transform'][0]) + \\\\\\n '_' + str(output['Kernel_Transform'][1])\\n else:\\n result['Kernel_Transform'] = output['Kernel_Transform']\\n\\n for key, value in result.iteritems():\\n output[key] = value\\n\\n return output\",\n \"def update(self, result, action_taken):\\n self.visits += 1\\n self.wins += result\\n\\n if self.parent is None:\\n return\\n\\n for key in self.parent.children:\\n p = self.parent.children[key].player\\n for a in action_taken[p]:\\n if a == key:\\n self.parent.children[key].visits_amaf += 1\\n self.parent.children[key].wins_amaf += result\",\n \"def mem_update(ops, x, mem, spike):\\n #print(ops(x).size())\\n #print(spike.size())\\n mem = mem * decay * (1. - spike) + ops(x)\\n spike = act_fun(mem) # act_fun : approximation firing function\\n return mem, spike\",\n \"def update(self, state, action, nextState, reward):\\n candidateQ = reward + self.discount * \\\\\\n self.computeValueFromQValues(nextState)\\n candidateQ_vec = np.array([[candidateQ]])\\n features = self.featExtractor.getFeatures(state, action)\\n features_as_list = [features[feat] for feat in self.allFeats]\\n features_vec = np.array([features_as_list])\\n self.train_step.run(feed_dict={self.x: features_vec,\\n self.y_: candidateQ_vec}, session=self.sess)\",\n \"def updateNode(self, result):\\n self.visits += 1\\n self.wins += result\",\n \"def update(self, attribute: str, result: ProcessorResult) -> None:\\n pass\",\n \"def tweak_q(self, q):\\n self._q = q\\n self.reset()\",\n \"def update_score():\\n pass\",\n \"def update1(self, state, action, nextState, reward):\\n #print \\\"update1 in ApproximateQAgent\\\"\\n \\\"*** YOUR CODE HERE ***\\\"\\n ##################################################################################################################################Eric Did Stuff\\n actionList = nextState.getLegalActions(self.index)\\n\\n\\n #print \\\"Action List\\\", actionList\\n\\n\\n\\n\\n weights = self.getWeights()\\n\\n features = self.featExtractor.getFeatures(state, action, self)\\n #self.myFeats = features\\n if self.index == 0:\\n print \\\"FEATURES: \\\",features\\n value = self.computeValueFromQValues(nextState)\\n qValue = self.getQValue(state,action)\\n #print \\\"value\\\", value, \\\"qValue\\\", qValue\\n for feature in features:\\n if len(actionList) != 0:\\n weights[feature] = weights[feature] + self.alpha * (reward + self.discount * value - qValue) * features[feature]\\n else:\\n weights[feature] = weights[feature] + self.alpha * (reward - qValue) * features[feature]\\n #print \\\"feature\\\", feature, \\\"weights\\\", weights[feature]\\n #print \\\"weights\\\", weights\\n\\n #util.raiseNotDefined()\",\n \"def update_dev_scores(self, results):\\n for metric in results:\\n print(\\\"Validation {} -> {} | lr: {}\\\".format(self.vctr, metric, self.optimizer.param_groups[0]['lr']), flush=True)\\n self.val_scores[metric.name].append(metric)\\n self.cur_bests[metric.name] = self.best_score(self.val_scores[metric.name])\\n\\n self.tensorboard_writter.add_scalar(\\n f\\\"/dev/{metric.name}\\\", metric.score, self.vctr\\n )\\n\\n # Decrease learning rate according to the scheduler policy\\n if self.opti_scheduler and metric.name == self.early_metric:\\n mode = \\\"max\\\" if metric.higher_better else \\\"min\\\"\\n self.opti_scheduler._init_is_better(mode,\\n self.opti_scheduler.threshold,\\n self.opti_scheduler.threshold_mode)\\n\\n self.opti_scheduler.step(metric.score)\",\n \"def update_Q(self, state, action, reward, new_state = None):\\n Q_val = self.Q[state][action]\\n \\n # Look at the best action from the next state.\\n Qp_val = 0\\n if new_state is not None:\\n Qp_val = max(self.Q[new_state].values())\\n \\n # The famous formula:\\n Q_val = Q_val + self.alpha * (reward + self.gamma * Qp_val - Q_val)\\n #print self.alpha\\n #print state, 'action: ', action\\n #print 'Q[%s]: %s' % (state, self.Q[state])\\n #print 'Q val: ', Q_val\\n \\n self.Q[state][action] = Q_val\\n \\n return None\",\n \"def update_usage(user_size):\\n\\n cnx = create_connection()\\n cursor = cnx.cursor()\\n\\n update_query = (\\n \\\"UPDATE \\\" + USAGE_TABLE['name'] + \\\" \\\"\\n \\\" SET \\\" + USAGE_TABLE['size_column'] + \\\"=\\\" + str(user_size[1]) + \\\" \\\"\\n \\\" WHERE \\\" + USAGE_TABLE['relational_column'] + \\\"='\\\" + user_size[0] + \\\"'\\\"\\n )\\n\\n try:\\n cursor.execute(update_query)\\n except mysql.connector.Error as e:\\n cursor.close()\\n cnx.close()\\n print(e)\\n return\\n\\n cursor.close()\\n cnx.close()\",\n \"def update(self):\\n result = [], 0, False\\n\\n if self.t % self.t_train_freq == 0:\\n result = self.q_learning_minibatch()\\n\\n if self.t % self.t_target_q_update_freq == self.t_target_q_update_freq - 1:\\n # Copy \\n self.update_target_q_network()\\n\\n return result\",\n \"def update_memory(self, vm):\\n try:\\n memory_spec = self.client.get_memory(vm.backend_id)\\n if memory_spec['size_MiB'] != vm.ram:\\n self.client.update_memory(vm.backend_id, {'size_MiB': vm.ram})\\n except VMwareError as e:\\n raise VMwareBackendError(e)\",\n \"def run_query(**kwargs):\\n logging.info(\\n \\\"Running query: \\\"\\n + kwargs[\\\"query\\\"][\\\"name\\\"]\\n + \\\" iterations: \\\"\\n + str(kwargs[\\\"iterations\\\"])\\n )\\n query_id = kwargs[\\\"query\\\"][\\\"name\\\"].rsplit(\\\".\\\")[\\n 0\\n ] # Query ID = filename without extention\\n query_results = {\\n \\\"query_name\\\": kwargs[\\\"query\\\"][\\\"name\\\"],\\n \\\"query_mapdql\\\": kwargs[\\\"query\\\"][\\\"mapdql\\\"],\\n \\\"query_id\\\": query_id,\\n \\\"query_succeeded\\\": True,\\n \\\"query_error_info\\\": \\\"\\\",\\n \\\"initial_iteration_results\\\": {},\\n \\\"noninitial_iteration_results\\\": [],\\n \\\"query_total_elapsed_time\\\": 0,\\n }\\n query_total_start_time = timeit.default_timer()\\n # Run iterations of query\\n for iteration in range(kwargs[\\\"iterations\\\"]):\\n # Gather memory before running query iteration\\n logging.debug(\\\"Getting pre-query memory usage on CPU\\\")\\n pre_query_cpu_mem_usage = get_mem_usage(\\n con=kwargs[\\\"con\\\"], mem_type=\\\"cpu\\\"\\n )\\n logging.debug(\\\"Getting pre-query memory usage on GPU\\\")\\n pre_query_gpu_mem_usage = get_mem_usage(\\n con=kwargs[\\\"con\\\"], mem_type=\\\"gpu\\\"\\n )\\n # Run query iteration\\n logging.debug(\\n \\\"Running iteration \\\"\\n + str(iteration)\\n + \\\" of query \\\"\\n + kwargs[\\\"query\\\"][\\\"name\\\"]\\n )\\n query_result = execute_query(\\n query_name=kwargs[\\\"query\\\"][\\\"name\\\"],\\n query_mapdql=kwargs[\\\"query\\\"][\\\"mapdql\\\"],\\n iteration=iteration,\\n con=kwargs[\\\"con\\\"],\\n arrow_cpu_output=kwargs[\\\"arrow_cpu_output\\\"],\\n \\n )\\n # Gather memory after running query iteration\\n logging.debug(\\\"Getting post-query memory usage on CPU\\\")\\n post_query_cpu_mem_usage = get_mem_usage(\\n con=kwargs[\\\"con\\\"], mem_type=\\\"cpu\\\"\\n )\\n logging.debug(\\\"Getting post-query memory usage on GPU\\\")\\n post_query_gpu_mem_usage = get_mem_usage(\\n con=kwargs[\\\"con\\\"], mem_type=\\\"gpu\\\"\\n )\\n # Calculate total (post minus pre) memory usage after query iteration\\n query_cpu_mem_usage = round(\\n post_query_cpu_mem_usage[\\\"usedram\\\"]\\n - pre_query_cpu_mem_usage[\\\"usedram\\\"],\\n 1,\\n )\\n query_gpu_mem_usage = round(\\n post_query_gpu_mem_usage[\\\"usedram\\\"]\\n - pre_query_gpu_mem_usage[\\\"usedram\\\"],\\n 1,\\n )\\n if query_result:\\n query_results.update(\\n query_error_info=\\\"\\\" # TODO - interpret query error info\\n )\\n # Assign first query iteration times\\n if iteration == 0:\\n first_execution_time = round(query_result[\\\"execution_time\\\"], 1)\\n first_connect_time = round(query_result[\\\"connect_time\\\"], 1)\\n first_total_time = (\\n first_execution_time\\n + first_connect_time\\n )\\n query_results.update(\\n initial_iteration_results={\\n \\\"first_execution_time\\\": first_execution_time,\\n \\\"first_connect_time\\\": first_connect_time,\\n \\\"first_total_time\\\": first_total_time,\\n \\\"first_cpu_mem_usage\\\": query_cpu_mem_usage,\\n \\\"first_gpu_mem_usage\\\": query_gpu_mem_usage,\\n }\\n )\\n else:\\n # Put noninitial iterations into query_result list\\n query_results[\\\"noninitial_iteration_results\\\"].append(\\n query_result\\n )\\n # Verify no change in memory for noninitial iterations\\n if query_cpu_mem_usage != 0.0:\\n logging.error(\\n (\\n \\\"Noninitial iteration ({0}) of query ({1}) \\\"\\n + \\\"shows non-zero CPU memory usage: {2}\\\"\\n ).format(\\n iteration,\\n kwargs[\\\"query\\\"][\\\"name\\\"],\\n query_cpu_mem_usage,\\n )\\n )\\n if query_gpu_mem_usage != 0.0:\\n logging.error(\\n (\\n \\\"Noninitial iteration ({0}) of query ({1}) \\\"\\n + \\\"shows non-zero GPU memory usage: {2}\\\"\\n ).format(\\n iteration,\\n kwargs[\\\"query\\\"][\\\"name\\\"],\\n query_gpu_mem_usage,\\n )\\n )\\n else:\\n logging.warning(\\n \\\"Error detected during execution of query: \\\"\\n + kwargs[\\\"query\\\"][\\\"name\\\"]\\n + \\\". This query will be skipped and \\\"\\n + \\\"times will not reported\\\"\\n )\\n query_results.update(query_succeeded=False)\\n break\\n # Calculate time for all iterations to run\\n query_total_elapsed_time = round(\\n ((timeit.default_timer() - query_total_start_time) * 1000), 1\\n )\\n query_results.update(query_total_elapsed_time=query_total_elapsed_time)\\n logging.info(\\n \\\"Completed all iterations of query \\\" + kwargs[\\\"query\\\"][\\\"name\\\"]\\n )\\n return query_results\",\n \"def update_resources_for_this_host(cache, db):\\n free_cpu, free_mem = get_resources()\\n my_ip = cache[\\\"ip\\\"]\\n\\n logger.info(\\\"UPDATING\\\", extra = {\\\"cpu\\\": free_cpu, \\\"mem\\\": free_mem, \\\"ip\\\": my_ip})\\n try:\\n db.hset(my_ip, mapping={\\\"cpu\\\": free_cpu, \\\"mem\\\": free_mem})\\n except Exception as e:\\n logger.error(e)\\n raise e\",\n \"def _problem_update_history(self, _):\\n self._update_reward_values()\\n self.history.curr_reward.append(self.curr_reward)\\n self.history.curr_best_reward.append(self.curr_best_reward)\",\n \"def update(self, arm, reward):\\n\\n # Increate pulls by one\\n self.pulls[arm] += 1\\n\\n # New number of pull\\n n = self.pulls[arm]\\n\\n # Old value\\n old_val = self.values[arm]\\n\\n # New value (online weighted average)\\n new_val = ((n - 1) / n) * old_val + (1 / n) * reward\\n\\n # Update value\\n self.values[arm] = new_val\\n\\n # Update epsilon\\n self.t += 1\\n self.epsilon = self.calc_dynamic_epsilon()\",\n \"def update(self):\\n\\n self._pre_calc_mb()\",\n \"def add(self, result, next_item):\\n self.test += self.length\\n self.hit += len(set(next_item) & set(result[:self.length].index))\",\n \"def update_q_table(self, cur_state, action, reward, next_state):\\n new_max_q = max(self.q_val_table[next_state])\\n new_value = reward + self.gamma * new_max_q\\n\\n old_value = self.q_val_table[cur_state][action]\\n self.q_val_table[cur_state][action] = old_value + self.alpha * (new_value - old_value)\\n\\n # Decay epsilon_greedy\\n self.e_greedy_prob = self.exp_decay(self.e_greedy_prob)\",\n \"def update(self, action, reward):\\n # like puseudo count\\n a, b = self.ActionValue[action]\\n #print(f\\\"UPDATE {action}: ({a}, {b})\\\")\\n a = a + self.huber(reward) # The larger the reward, the easier it is to select\\n b = b + 1 - self.huber(reward) # It becomes easy to be selected as the reward becomes larger, and it becomes difficult to be selected as the reward becomes smaller\\n a = 0.001 if a <= 0 else a\\n b = 0.001 if b <= 0 else b\\n \\n self.ActionValue[action] = (a, b)\\n\\n #print(f\\\"=> ({a}, {b})\\\")\\n\\n # Update nearby action candidates\\n around_update_rate = 0.3 # Parameter to adjust the degree of change according to the distance; [0, 1]\\n radius = np.sqrt(self.action_resolution**2 + self.action_resolution**2 + 1e-9) # 1e-9 is for safety to caluculate the small number \\n for action_around in self.actions:\\n if action_around == action:\\n continue\\n x = action_around[0] - action[0]\\n y = action_around[1] - action[1]\\n distance = np.sqrt(x**2 + y**2)\\n if distance <= radius:\\n a, b = self.ActionValue[action_around]\\n #print(f\\\"UPDATE {action_around}: ({a}, {b})\\\")\\n a = a + self.huber(reward) * around_update_rate * (1 - distance)\\n b = b + (1 - self.huber(reward)) * around_update_rate * (1 - distance) # To adjust the update, weight 1-r. If normal update is 1, it will be the update of around_update_rate * (1-distance) for adjacent actions.\\n a = 0.001 if a <= 0 else a\\n b = 0.001 if b <= 0 else b\\n\\n #print(f\\\"=> ({a}, {b})\\\")\\n\\n self.ActionValue[action_around] = (a, b)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61297095","0.5953453","0.5922591","0.5553142","0.544283","0.5403002","0.5356434","0.5338803","0.5331692","0.5323351","0.5294844","0.5292601","0.5231745","0.52154356","0.51240927","0.50593865","0.5058139","0.5054779","0.50533724","0.5042255","0.50057137","0.49620408","0.49591643","0.49553424","0.49470666","0.4946317","0.4943538","0.49367395","0.49194118","0.49133572","0.48974988","0.48968318","0.48944542","0.48638144","0.48472401","0.48407757","0.4835095","0.48257715","0.48234743","0.48208898","0.48208302","0.4819813","0.48165497","0.47992852","0.47939855","0.47786528","0.47786528","0.47485945","0.47453958","0.4742625","0.47289956","0.47288293","0.47279444","0.47227702","0.47227702","0.4721271","0.47174302","0.471647","0.471424","0.47086188","0.46990263","0.46983698","0.46962738","0.46902838","0.46872067","0.46766284","0.46690276","0.46614206","0.4655487","0.46478528","0.46410438","0.46364823","0.46358693","0.46345556","0.46338007","0.46319574","0.4627141","0.46199504","0.46159473","0.4611362","0.46082613","0.46059117","0.46049142","0.46006358","0.45947817","0.45909673","0.4587312","0.45859835","0.4576236","0.45750403","0.457269","0.45670936","0.45531917","0.45436624","0.4540992","0.4540538","0.4538863","0.4537903","0.45348418"],"string":"[\n \"0.61297095\",\n \"0.5953453\",\n \"0.5922591\",\n \"0.5553142\",\n \"0.544283\",\n \"0.5403002\",\n \"0.5356434\",\n \"0.5338803\",\n \"0.5331692\",\n \"0.5323351\",\n \"0.5294844\",\n \"0.5292601\",\n \"0.5231745\",\n \"0.52154356\",\n \"0.51240927\",\n \"0.50593865\",\n \"0.5058139\",\n \"0.5054779\",\n \"0.50533724\",\n \"0.5042255\",\n \"0.50057137\",\n \"0.49620408\",\n \"0.49591643\",\n \"0.49553424\",\n \"0.49470666\",\n \"0.4946317\",\n \"0.4943538\",\n \"0.49367395\",\n \"0.49194118\",\n \"0.49133572\",\n \"0.48974988\",\n \"0.48968318\",\n \"0.48944542\",\n \"0.48638144\",\n \"0.48472401\",\n \"0.48407757\",\n \"0.4835095\",\n \"0.48257715\",\n \"0.48234743\",\n \"0.48208898\",\n \"0.48208302\",\n \"0.4819813\",\n \"0.48165497\",\n \"0.47992852\",\n \"0.47939855\",\n \"0.47786528\",\n \"0.47786528\",\n \"0.47485945\",\n \"0.47453958\",\n \"0.4742625\",\n \"0.47289956\",\n \"0.47288293\",\n \"0.47279444\",\n \"0.47227702\",\n \"0.47227702\",\n \"0.4721271\",\n \"0.47174302\",\n \"0.471647\",\n \"0.471424\",\n \"0.47086188\",\n \"0.46990263\",\n \"0.46983698\",\n \"0.46962738\",\n \"0.46902838\",\n \"0.46872067\",\n \"0.46766284\",\n \"0.46690276\",\n \"0.46614206\",\n \"0.4655487\",\n \"0.46478528\",\n \"0.46410438\",\n \"0.46364823\",\n \"0.46358693\",\n \"0.46345556\",\n \"0.46338007\",\n \"0.46319574\",\n \"0.4627141\",\n \"0.46199504\",\n \"0.46159473\",\n \"0.4611362\",\n \"0.46082613\",\n \"0.46059117\",\n \"0.46049142\",\n \"0.46006358\",\n \"0.45947817\",\n \"0.45909673\",\n \"0.4587312\",\n \"0.45859835\",\n \"0.4576236\",\n \"0.45750403\",\n \"0.457269\",\n \"0.45670936\",\n \"0.45531917\",\n \"0.45436624\",\n \"0.4540992\",\n \"0.4540538\",\n \"0.4538863\",\n \"0.4537903\",\n \"0.45348418\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.620225"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":94497,"cells":{"query":{"kind":"string","value":"a decorator to add backing off retry symantics to any a method that does a database transaction. When using this decorator, it is vital that any exception within the 'exceptions_eligible_for_retry' tuple above must not be handled within the wrapped function. This means that exception handlers that handle 'Exception' must also have a clause for 'exceptions_eligible_for_retry' that reraises the exception."},"document":{"kind":"string","value":"def db_transaction_retry_wrapper(fn):\n @ft.wraps(fn)\n def f(self, *args, **kwargs):\n backoffGenerator = util.backoffSecondsGenerator()\n try:\n while True:\n try:\n result = fn(self, *args, **kwargs)\n return result\n except exceptions_eligible_for_retry:\n waitInSeconds = backoffGenerator.next()\n try:\n self.logger.critical('server failure in db transaction - '\n 'retry in %s seconds',\n waitInSeconds)\n except AttributeError:\n pass\n try:\n self.responsiveSleep(waitInSeconds,\n 10,\n \"waiting for retry after failure in db \"\n \"transaction\")\n except AttributeError:\n time.sleep(waitInSeconds)\n except KeyboardInterrupt:\n return\n return f"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def retry(func, *args, **kwargs):\n @functools.wraps(func)\n def wrapper(*w_args, **w_kwargs):\n w_kwargs.update(kwargs)\n return retry_function_on_deadlock(func, *w_args, **w_kwargs)\n\n return wrapper","def _retry(func):\n @wraps(func)\n def _retry_wrapper(self, *args, **kwargs):\n error_message = \"\"\n for retry in range(self.retries + 1):\n try:\n return func(self, *args, **kwargs)\n except ValueError as err:\n error_message = str(err)\n raise ValueError(str(error_message))\n return _retry_wrapper","def retryable(func):\n\n @wraps(func)\n def wrapper(*args, **kwargs):\n retries = 0\n max_retries = kwargs.get(\"max_retries\", DEFAULT_RETRIES)\n backoff = kwargs.get(\"backoff\", default_backoff)\n while retries <= max_retries:\n try:\n return func(*args, **kwargs)\n except IntegrityError:\n logging.debug(\n \"Race-condition caught? ({}/{} retries)\".format(retries, max_retries)\n )\n if retries >= max_retries:\n logging.error(f\"Unable to execute {func}, max retries exceeded\")\n raise\n retries += 1\n backoff(retries, max_retries)\n\n return wrapper","def exceptdecorator(method):\n def wrapper(*args, **kwargs):\n \"\"\"\n Try function, handle sqlite3.Error, optionally pass sqlite3.IntegrityError.\n \"\"\"\n return sql_exceptwrapper(method, integrity, *args, **kwargs)\n return wrapper","def smart_retry(f):\n # type: (Callable) -> CallableT\n\n @functools.wraps(f)\n def wrapper(api_instance, *args, **kwargs):\n # type: (UnifiAPI, *Any, **Any) -> Any\n try:\n return f(api_instance, *args, **kwargs)\n except Unauthorized as e:\n\n api_instance.log.debug(\n \"An exception occurred when executing %s: %s. Refreshing the connection to the Controller and retrying\",\n f.__name__,\n e,\n )\n api_instance.connect()\n return f(api_instance, *args, **kwargs)\n\n except Exception:\n raise\n\n return cast(CallableT, wrapper)","def wrap_db_error(f):\n def _wrap(*args, **kwargs):\n try:\n return f(*args, **kwargs)\n except sqlalchemy.exc.OperationalError, e:\n if not is_db_connection_error(e.args[0]):\n raise\n\n remaining_attempts = _MAX_RETRIES\n while True:\n LOG.warning(_('SQL connection failed. %d attempts left.'),\n remaining_attempts)\n remaining_attempts -= 1\n time.sleep(_RETRY_INTERVAL)\n try:\n return f(*args, **kwargs)\n except sqlalchemy.exc.OperationalError, e:\n if (remaining_attempts == 0 or\n not is_db_connection_error(e.args[0])):\n raise\n except sqlalchemy.exc.DBAPIError:\n raise\n except sqlalchemy.exc.DBAPIError:\n raise\n _wrap.func_name = f.func_name\n return _wrap","def retry(maxRetries, *exceptions):\n def _doDecoration(fn):\n def _doRetry(*args, **kwargs):\n retries = 0\n while retries <= maxRetries:\n try:\n return fn(*args, **kwargs)\n except tuple(exceptions):\n retries +=1\n if retries > maxRetries:\n raise\n \n return _doRetry\n return _doDecoration","def _retryProtect(m):\n\tdef f(self, *args, **kwargs):\n\t\ttry:\n\t\t\treturn m(self, *args, **kwargs)\n\t\texcept:\n\t\t\tself.reset()\n\t\t\treturn m(self, *args, **kwargs)\n\n\treturn functools.update_wrapper(f, m)","def wrap(fn):\n\n def wrapped_fn(*args, **kwargs):\n \"\"\"The actual wrapper function that applies the retry logic.\"\"\"\n for delay in delays():\n try:\n return fn(*args, **kwargs)\n except Exception as e: # pylint: disable=broad-except)\n if is_retriable is None:\n continue\n\n if is_retriable(e):\n time.sleep(delay)\n else:\n raise\n return fn(*args, **kwargs)\n\n return wrapped_fn","def retry(tries, delay=3, backoff=2, except_on=(Exception, )):\n\n tries = math.floor(tries)\n\n def decorator(f):\n def f_retry(*args, **kwargs):\n return function_retry(\n tries, delay, backoff, except_on, f, *args, **kwargs)\n return f_retry # true decorator -> decorated function\n return decorator # @retry(arg[, ...]) -> true decorator","def retry(times: int, on_exceptions: List[Exception]):\n def decorator(function: Callable):\n @wraps(function)\n def wrapper(*args, **kwargs):\n raised = []\n for _ in range(times):\n try:\n return function(*args, **kwargs)\n except Exception as ex:\n raised.append(ex)\n if type(ex) not in on_exceptions:\n raise RetryError(\n 'An unexpected error occurred while calling the function '+\n f'{function.__name__}.'\n ) from ex\n raise raised.pop()\n return wrapper\n return decorator","def test_retry_raises_error_on_negative_retries(self):\n\n @retry(Exception, max_retries=-1)\n def f():\n raise Exception(\"Faulty function\")\n\n self.assertRaises(ValueError, f)","def retry_on_deadlock(func):\n @functools.wraps(func)\n def decorate(*args, **kw):\n # We can't use RetryDecorator from oslo_service directly because\n # it runs a decorated function in a different thread and hence\n # the function doesn't have access to authentication context\n # set as a thread local variable.\n # The solution is to reuse RetryDecorator but explicitly set\n # auth context in the new thread that RetryDecorator spawns.\n # In order to do that we need an additional helper function.\n\n auth_ctx = ctx.ctx() if ctx.has_ctx() else None\n\n return _with_auth_context(auth_ctx, func, *args, **kw)\n\n return decorate","def retry(func):\n # ... retry MAX_RETRIES times\n # ...\n # make sure you include this for testing:\n # except Exception as exc:\n # print(exc)\n # ...\n # and use wraps to preserve docstring\n #\n @wraps(func)\n def wrapper(*args, **kwargs):\n\n tries = MAX_RETRIES\n while tries > 0:\n try:\n return func(*args, **kwargs)\n except Exception as err:\n print(err)\n\n tries -= 1\n\n raise MaxRetriesException\n\n return wrapper","def retrying(cls, fn, retries_allowed=None, wait_seconds=None, wait_increment=None, wait_multiplier=None):\n # A special name_key of 'anonymous' is the default, which causes there not to be a name key.\n # This cannot work in conjunction with RetryManager because different calls may result in different\n # function values at the same point in code. -kmp 8-Jul-2020\n decorator_function = Retry.retry_allowed(\n name_key='anonymous', retries_allowed=retries_allowed, wait_seconds=wait_seconds,\n wait_increment=wait_increment, wait_multiplier=wait_multiplier\n )\n return decorator_function(fn)","def retry_if_dropped(func):\n\n def wrapper(*args, **kwargs):\n n_tries = 0\n max_tries = 2\n err = None\n\n while n_tries < max_tries:\n n_tries += 1\n\n try:\n return func(*args, **kwargs)\n except OperationalError as e:\n err = e\n\n # This needs to be a local import\n from django.db import connection\n\n connection.close()\n\n raise err\n\n return wrapper","def retry(retries=5):\n\n def decorator(fn):\n @wraps(fn)\n def wrapper(*args, **kwargs):\n count = 0\n while True:\n try:\n return fn(*args, **kwargs)\n except (\n BadRequest,\n BadResponseException,\n ReadTimeout,\n RequestException,\n TraktBadGateway,\n TraktUnavailable,\n TraktInternalException,\n ) as e:\n if count == retries:\n logger.error(f\"Error: {e}\")\n\n if isinstance(e, BadResponseException):\n logger.error(f\"Details: {e.details}\")\n if isinstance(e, TraktInternalException):\n logger.error(f\"Error message: {e.error_message}\")\n\n logger.error(\n \"API didn't respond properly, script will abort now. Please try again later.\"\n )\n logger.error(\n f\"Last call: {fn.__module__}.{fn.__name__}({args[1:]}, {kwargs})\"\n )\n exit(1)\n\n seconds = 1 + count\n count += 1\n logger.warning(\n f\"{e} for {fn.__module__}.{fn.__name__}(), retrying after {seconds} seconds (try: {count}/{retries})\"\n )\n sleep(seconds)\n\n return wrapper\n\n return decorator","def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):\n\tdef deco_retry(f):\n\t\t@wraps(f)\n\t\tdef f_retry(*args, **kwargs):\n\t\t\tmtries, mdelay = tries, delay\n\t\t\twhile mtries > 1:\n\t\t\t\ttry:\n\t\t\t\t\treturn f(*args, **kwargs)\n\t\t\t\texcept ExceptionToCheck, e:\n\t\t\t\t\tmsg = \"func: '{}' > exc: {}, Retrying in {} seconds...\".format(str(f.__name__), str(e), mdelay)\n\t\t\t\t\tif logger:\n\t\t\t\t\t\tlogger.warning(msg)\n\t\t\t\t\telse:\n\t\t\t\t\t\tprint msg\n\t\t\t\t\ttime.sleep(mdelay)\n\t\t\t\t\tmtries -= 1\n\t\t\t\t\tmdelay *= backoff\n\t\t\treturn f(*args, **kwargs)\n\t\treturn f_retry\t# true decorator\n\treturn deco_retry","def reprovision_and_retry(func):\n @functools.wraps(func)\n def wrapper(*a, **kw):\n errback = kw.get('errback', None)\n if errback is None:\n def errback(e):\n raise e\n def errback_wrapper(e):\n if isinstance(e, UnknownAppID) and 'INITIAL' in OPTIONS:\n try:\n for initial in OPTIONS['INITIAL']:\n provision(*initial) # retry provisioning the initial setup\n func(*a, **kw) # and try the function once more\n except Exception(new_exc):\n errback(new_exc) # throwing the new exception\n else:\n errback(e) # not an instance of UnknownAppID - nothing we can do here\n kw['errback'] = errback_wrapper\n return func(*a, **kw)\n return wrapper","def retry_task(func):\n\n @wraps(func)\n def wrapper(task, *args, **kwargs):\n retries = task.request.retries\n exponential = 2 ** retries\n exponential_backoff = random.randint(exponential, exponential * 2)\n try:\n result = func(task, *args, **kwargs)\n except Exception as e:\n logger.error(\n f\"Retriying {task.request.id} after {exponential_backoff} seconds\"\n )\n raise task.retry(countdown=exponential_backoff, exc=e, max_retries=5)\n\n return result\n\n return wrapper","def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):\n def deco_retry(f):\n def f_retry(*args, **kwargs):\n mtries, mdelay = tries, delay\n try_one_last_time = True\n while mtries > 1:\n try:\n return f(*args, **kwargs)\n try_one_last_time = False\n break\n except ExceptionToCheck, e:\n if logger:\n msg = getMessage(\"en\", \"retrying-notification\").format(str(e), mdelay)\n logger.warning(msg)\n time.sleep(mdelay)\n mtries -= 1\n mdelay *= backoff\n if try_one_last_time:\n return f(*args, **kwargs)\n return\n return f_retry # true decorator\n return deco_retry","def decorated(instance, *args, **kwargs):\n cfg = instance._retry_config\n remaining_tries = cfg.retry_attempts\n current_wait = cfg.retry_wait\n retry_backoff = cfg.retry_backoff\n last_error = None\n\n while remaining_tries >= 0:\n try:\n return fun(instance, *args, **kwargs)\n except socket.error as e:\n last_error = e\n instance._retry_logger.warning('Connection failed: %s', e)\n\n remaining_tries -= 1\n if remaining_tries == 0:\n # Last attempt\n break\n\n # Wait a bit\n time.sleep(current_wait)\n current_wait *= retry_backoff\n\n # All attempts failed, let's raise the last error.\n raise last_error","def _retry_provider_call(self, func):\n\n @functools.wraps(func)\n def decorated(*args, **kwargs):\n max_retries = 29\n attempts = 0\n while attempts < max_retries:\n try:\n return func(*args, **kwargs)\n except ClientError as e:\n attempts += 1\n raise RetryLimitExceededError(\n \"Exceeded request limit {} times. Aborting.\".format(max_retries)\n )\n return decorated","def retrying(func, *retry_args, **retry_kwargs):\n yield retriable(*retry_args, **retry_kwargs)(func)","def on_error_rollback(func):\n @functools.wraps(func)\n def db_safe_exec(*args, **kwargs):\n try:\n return func(*args, **kwargs)\n except Exception as e:\n logger.error('Error ({!s}) - rolling back'.format(e))\n session.rollback()\n raise\n return db_safe_exec","def test_retry(self):\n retries = [0]\n max_tries = 5\n\n @retry(Exception, max_retries=5)\n def f():\n retries[0] += 1\n raise Exception(\"Faulty function\")\n\n with self.assertRaises(Exception):\n f()\n\n self.assertEqual(max_tries, retries[0])","def retry(exceptions=Exception, tries=3, delay=1):\n\n def retry_decorator(func):\n def func_wrapper(*args, **kwargs):\n _tries = tries\n while _tries:\n try:\n return func(*args, **kwargs)\n except exceptions as e:\n _tries -= 1\n if not _tries:\n raise\n\n time.sleep(delay)\n\n return func_wrapper\n\n return retry_decorator","def retry(exceptions, tries=3, delay=2, _logger=logger()):\n\n def deco_retry(f):\n @wraps(f)\n def f_retry(*args, **kwargs):\n mtries, mdelay = tries, delay\n while mtries > 1:\n try:\n return f(*args, **kwargs)\n except exceptions as e:\n msg = '{}, Retrying in {} seconds...'.format(e, mdelay)\n _logger.warning(msg)\n time.sleep(mdelay)\n mtries -= 1\n return f(*args, **kwargs)\n\n return f_retry # true decorator\n\n return deco_retry","def _retry_on_deadlock(f):\n @functools.wraps(f)\n def wrapped(*args, **kwargs):\n while True:\n try:\n return f(*args, **kwargs)\n except db_exc.DBDeadlock:\n LOG.warning(\"Deadlock detected when running \"\n \"'%(func_name)s': Retrying...\",\n dict(func_name=f.__name__))\n # Retry!\n time.sleep(0.5)\n continue\n functools.update_wrapper(wrapped, f)\n return wrapped","def retriable(*retry_args, **retry_kwargs):\n def _retriable_factory(func):\n @wraps(func)\n def _retriable_wrapper(*args, **kwargs):\n return retry(func, args=args, kwargs=kwargs, *retry_args,\n **retry_kwargs)\n return _retriable_wrapper\n return _retriable_factory","def retry(ExceptionToCheck, tries=3, delay=3, backoff=2):\n\n def deco_retry(f):\n @wraps(f)\n def f_retry(*args, **kwargs):\n mtries, mdelay = tries, delay\n while mtries > 1:\n try:\n return f(*args, **kwargs)\n except ExceptionToCheck as e:\n logging.warning('%s, Retrying in %d seconds...', str(e), mdelay)\n time.sleep(mdelay)\n mtries -= 1\n mdelay *= backoff\n return f(*args, **kwargs)\n\n return f_retry\n\n return deco_retry","def _retry_on_deadlock(f):\n @functools.wraps(f)\n def wrapped(*args, **kwargs):\n while True:\n try:\n return f(*args, **kwargs)\n except db_exc.DBDeadlock:\n LOG.warning(_LW(\"Deadlock detected when running \"\n \"'%(func_name)s': Retrying...\"),\n dict(func_name=f.__name__))\n # Retry!\n time.sleep(0.5)\n continue\n functools.update_wrapper(wrapped, f)\n return wrapped","def _retry_on_deadlock(f):\n @functools.wraps(f)\n def wrapped(*args, **kwargs):\n while True:\n try:\n return f(*args, **kwargs)\n except db_exc.DBDeadlock:\n LOG.warn(_(\"Deadlock detected when running \"\n \"'%(func_name)s': Retrying...\"),\n dict(func_name=f.__name__))\n # Retry!\n time.sleep(0.5)\n continue\n functools.update_wrapper(wrapped, f)\n return wrapped","def _Retry(func, *args, **kwargs):\n retries = _RETRIES\n while True:\n try:\n return func(*args, **kwargs)\n except Exception as e: # pylint: disable=broad-except\n retries -= 1\n if retries > 0:\n log.info('Exception {e} thrown in {func}. Retrying.'.format(\n e=e, func=func.__name__))\n time.sleep(1)\n else:\n raise e","def retry(tries, delay=3, backoff=2):\n tries = math.floor(tries)\n if tries < 0:\n raise ValueError(\"tries must be 0 or greater\")\n\n\n def deco_retry(f):\n @wraps(f)\n def f_retry(*args, **kwargs):\n mtries, mdelay = tries, delay # make mutable\n err = None\n while mtries > 0:\n print(\"Trial Number:\" + str(mtries))\n try:\n rv = f(*args, **kwargs)\n except DBException as e:\n print(\"Retry..\")\n mtries -= 1 # consume an attempt\n time.sleep(mdelay) # wait...\n mdelay += backoff # make future wait longer\n err = e\n\n # except Exception as e:\n # print(str(e))\n # mtries -= 1 # consume an attempt\n # time.sleep(mdelay) # wait...\n # mdelay += backoff # make future wait longer\n # err = e\n else:\n return rv\n raise err\n\n return f_retry # true decorator -> decorated function\n\n return deco_retry # @retry(arg[, ...]) -> true decorator","def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):\n def deco_retry(f):\n\n @wraps(f)\n def f_retry(*args, **kwargs):\n mtries, mdelay = tries, delay\n while mtries > 1:\n try:\n return f(*args, **kwargs)\n except ExceptionToCheck, e:\n msg = \"%s, Retrying in %d seconds...\" % (str(e), mdelay)\n if logger:\n logger.warning(msg)\n else:\n print msg\n time.sleep(mdelay)\n mtries -= 1\n mdelay *= backoff\n return f(*args, **kwargs)\n\n return f_retry # true decorator\n\n return deco_retry","def transaction(self, retries=0):\n def decorator(func):\n @wraps(func)\n def wrapper(*args, **kwargs):\n attempts = 0\n with self.get_pool().connection() as conn:\n proxy = ConnectionProxy(conn)\n while True:\n try:\n retval = func(proxy, *args, **kwargs)\n conn.commit()\n except IntegrityError:\n attempts += 1\n if attempts > retries:\n raise\n conn.rollback()\n except Exception:\n conn.rollback()\n raise\n else:\n return retval\n return wrapper\n return decorator","def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):\n def deco_retry(f):\n\n @wraps(f)\n def f_retry(*args, **kwargs):\n mtries, mdelay = tries, delay\n while mtries > 1:\n try:\n return f(*args, **kwargs)\n except ExceptionToCheck, e:\n msg = \"%s, Retrying in %d seconds...\" % (str(e), mdelay)\n if logger:\n logger.warning(msg)\n else:\n print(msg)\n time.sleep(mdelay)\n mtries -= 1\n mdelay *= backoff\n return f(*args, **kwargs)\n\n return f_retry # true decorator\n\n return deco_retry","def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):\n def deco_retry(f):\n\n @wraps(f)\n def f_retry(*args, **kwargs):\n mtries, mdelay = tries, delay\n while mtries > 1:\n try:\n return f(*args, **kwargs)\n except ExceptionToCheck as e:\n msg = \"%s, Retrying in %d seconds...\" % (str(e), mdelay)\n if logger:\n logger.warning(msg)\n else:\n print(msg)\n sleep(mdelay)\n mtries -= 1\n mdelay *= backoff\n return f(*args, **kwargs)\n\n return f_retry # true decorator\n\n return deco_retry","def retry(ExceptionToCheck, tries=3, delay=3, backoff=2, logger=None):\n def deco_retry(f):\n\n @wraps(f)\n def f_retry(*args, **kwargs):\n mtries, mdelay = tries, delay\n while mtries > 1:\n try:\n return f(*args, **kwargs)\n except ExceptionToCheck, e:\n msg = \"%s, Retrying in %d seconds...\" % (str(e), mdelay)\n if logger:\n logger.warning(msg)\n else:\n print msg\n time.sleep(mdelay)\n mtries -= 1\n mdelay *= backoff\n return f(*args, **kwargs)\n\n return f_retry # true decorator\n\n return deco_retry","def wrapper(*args, **kwargs):\n return sql_exceptwrapper(method, integrity, *args, **kwargs)","def sql_excepthandler(integrity):\n def exceptdecorator(method):\n \"\"\"\n Call function in sqlite3.Error try/except block.\n\n :param method: Method to use.\n :type method: function\n \"\"\"\n def wrapper(*args, **kwargs):\n \"\"\"\n Try function, handle sqlite3.Error, optionally pass sqlite3.IntegrityError.\n \"\"\"\n return sql_exceptwrapper(method, integrity, *args, **kwargs)\n return wrapper\n return exceptdecorator","def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):\r\n def deco_retry(f):\r\n\r\n @wraps(f)\r\n def f_retry(*args, **kwargs):\r\n mtries, mdelay = tries, delay\r\n while mtries > 1:\r\n try:\r\n return f(*args, **kwargs)\r\n except ExceptionToCheck, e:\r\n msg = \"%s, Retrying in %d seconds...\" % (str(e), mdelay)\r\n if logger:\r\n logger.warning(msg)\r\n else:\r\n print msg\r\n time.sleep(mdelay)\r\n mtries -= 1\r\n mdelay *= backoff\r\n return f(*args, **kwargs)\r\n\r\n return f_retry # true decorator\r\n\r\n return deco_retry","def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):\r\n def deco_retry(f):\r\n\r\n @wraps(f)\r\n def f_retry(*args, **kwargs):\r\n mtries, mdelay = tries, delay\r\n while mtries > 1:\r\n try:\r\n return f(*args, **kwargs)\r\n except ExceptionToCheck as e:\r\n msg = \"%s, Retrying in %d seconds...\" % (str(e), mdelay)\r\n if logger:\r\n logger.warning(msg)\r\n else:\r\n print (msg)\r\n time.sleep(mdelay)\r\n mtries -= 1\r\n mdelay *= backoff\r\n return f(*args, **kwargs)\r\n return f_retry # true decorator\r\n return deco_retry","def test_retry_other_exception():\n\n exceptions_in = [\n RuntimeError(\"what?\"),\n NotImplementedError(\"how?\"),\n RuntimeError(\"no!\"),\n ]\n actual = []\n expected = [1.0, 1.5, 2.25]\n\n def sleep(wait: float):\n actual.append(wait)\n\n @retry(\n (NotImplementedError, RuntimeError),\n retries=4,\n delay=1.0,\n backoff=1.5,\n sleep=sleep,\n )\n def explode():\n raise exceptions_in.pop()\n\n try:\n explode()\n raise AssertionError(\"IndexError expected\")\n except IndexError:\n assert actual == expected","def auto_retry(fun):\n\n @functools.wraps(fun)\n def decorated(instance, *args, **kwargs):\n \"\"\"Wrapper around a decorated function.\"\"\"\n cfg = instance._retry_config\n remaining_tries = cfg.retry_attempts\n current_wait = cfg.retry_wait\n retry_backoff = cfg.retry_backoff\n last_error = None\n\n while remaining_tries >= 0:\n try:\n return fun(instance, *args, **kwargs)\n except socket.error as e:\n last_error = e\n instance._retry_logger.warning('Connection failed: %s', e)\n\n remaining_tries -= 1\n if remaining_tries == 0:\n # Last attempt\n break\n\n # Wait a bit\n time.sleep(current_wait)\n current_wait *= retry_backoff\n\n # All attempts failed, let's raise the last error.\n raise last_error\n\n return decorated","def retry_allowed(cls, name_key=None, retries_allowed=None, wait_seconds=None,\n wait_increment=None, wait_multiplier=None):\n\n def _decorator(function):\n function_name = name_key or function.__name__\n function_profile = cls.RetryOptions(\n retries_allowed=cls._defaulted(retries_allowed, cls.DEFAULT_RETRIES_ALLOWED),\n wait_seconds=cls._defaulted(wait_seconds, cls.DEFAULT_WAIT_SECONDS),\n wait_increment=cls._defaulted(wait_increment, cls.DEFAULT_WAIT_INCREMENT),\n wait_multiplier=cls._defaulted(wait_multiplier, cls.DEFAULT_WAIT_MULTIPLIER),\n )\n\n check_true(isinstance(retries_allowed, int) and retries_allowed >= 0,\n \"The retries_allowed must be a non-negative integer.\",\n error_class=ValueError)\n\n # See the 'retrying' method to understand what this is about. -kmp 8-Jul-2020\n if function_name != 'anonymous':\n cls._RETRY_OPTIONS_CATALOG[function_name] = function_profile # Only for debugging.\n\n @functools.wraps(function)\n def wrapped_function(*args, **kwargs):\n tries_allowed = function_profile.tries_allowed\n wait_seconds = function_profile.wait_seconds or 0\n last_error = None\n for i in range(tries_allowed):\n if i > 0:\n if i > 1:\n wait_seconds = function_profile.wait_adjustor(wait_seconds)\n if wait_seconds > 0:\n time.sleep(wait_seconds)\n try:\n success = function(*args, **kwargs)\n return success\n except Exception as e:\n last_error = e\n if last_error is not None:\n raise last_error\n\n return wrapped_function\n\n return _decorator","def retry(\n action_type: ActionType,\n default_return: Any,\n) -> Callable:\n\n def decorator(func: Callable) -> Callable:\n @wraps(func)\n def result(*args: Any, **kwargs: Any) -> List[Optional[Row]]:\n func_delay = config.execution.TASK_RETRY_DELAY\n method_name = func.__name__\n self = args[0]\n\n raised_ex = None\n for attempt in range(config.execution.TASK_RETRY_COUNT + 1):\n try:\n # Create ExecutionLog with status in_processing or retrying\n if attempt:\n self.log_retry(action_type)\n else:\n self.log_start(action_type)\n # Run access or erasure request\n return func(*args, **kwargs)\n except BaseException as ex: # pylint: disable=W0703\n func_delay *= config.execution.TASK_RETRY_BACKOFF\n logger.warning(\n f\"Retrying {method_name} {self.traversal_node.address} in {func_delay} seconds...\"\n )\n sleep(func_delay)\n raised_ex = ex\n self.log_end(action_type, raised_ex)\n return default_return\n\n return result\n\n return decorator","def retry(exception, tries=10, delay=1, backoff=2, max_delay=30):\n def deco_retry(f):\n @wraps(f)\n def f_retry(*args, **kwargs):\n m_tries, m_delay = tries, delay\n while m_tries > 1:\n try:\n return f(*args, **kwargs)\n except exception:\n time.sleep(min(m_delay, max_delay))\n m_tries -= 1\n m_delay *= backoff\n return f(*args, **kwargs)\n return f_retry # true decorator\n return deco_retry","def make_wrapped_function(self):\n decorator = self.decorator()\n\n @decorator\n def passthrough(argument):\n if isinstance(argument, Exception):\n raise argument\n return argument\n\n return passthrough","def _CatchExceptionDecorator(method):\n @functools.wraps(method)\n def Wrap(*args, **kwargs):\n try:\n return method(*args, **kwargs)\n except Exception:\n logging.warning(\n '%s Exception: %s.', name,\n '\\n'.join(traceback.format_exception_only(\n *sys.exc_info()[:2])).strip())\n return Wrap if enable else method","def handleExceptionsDecorator(object):\n\n\t\t@functools.wraps(object)\n\t\tdef handleExceptionsWrapper(*args, **kwargs):\n\t\t\t\"\"\"\n\t\t\tThis decorator is used for exceptions handling.\n\n\t\t\t:param \\*args: Arguments. ( \\* )\n\t\t\t:param \\*\\*kwargs: Keywords arguments. ( \\*\\* )\n\t\t\t\"\"\"\n\n\t\t\t_exceptions__frame__ = True\n\n\t\t\ttry:\n\t\t\t\treturn object(*args, **kwargs)\n\t\t\texcept exceptions as error:\n\t\t\t\tfor handler in handlers:\n\t\t\t\t\thandler(error)\n\n\t\treturn handleExceptionsWrapper","def retry(nattempts, exception=None):\n \n def tryIt(func):\n def wrapper(*args, **kwargs):\n attempts = 0\n while attempts < nattempts - 1:\n try:\n return func(*args, **kwargs)\n except (exception if exception is not None else Exception):\n attempts += 1\n return func(*args, **kwargs)\n return wrapper\n return tryIt","def omit_exception(method):\r\n\r\n @functools.wraps(method)\r\n def _decorator(self, *args, **kwargs):\r\n if self._ignore_exceptions:\r\n try:\r\n return method(self, *args, **kwargs)\r\n except ConnectionInterrupted:\r\n return None\r\n else:\r\n return method(self, *args, **kwargs)\r\n\r\n return _decorator","def retry(retry_times=3, interval=0.5, exceptions=Exception):\n def _decorator(func):\n @wraps(func)\n def _wrapped_func(*args, **kwargs):\n for attempt in range(1, retry_times + 1):\n try:\n return func(*args, **kwargs)\n except exceptions: # pylint: disable=broad-except\n if attempt < retry_times:\n logger.debug(\"%s failed in No. %d attempt\", func, attempt)\n import traceback\n import time\n logger.debug(traceback.format_exc())\n time.sleep(interval)\n else:\n raise # End of retry. Re-raise the exception as-is.\n return _wrapped_func\n return _decorator","def retry(exception, tries=10, delay=3, backoff=0.1):\n def deco_retry(f):\n @wraps(f)\n def f_retry(*args, **kwargs):\n mtries, mdelay = tries, delay\n while mtries > 1:\n try:\n return f(*args, **kwargs)\n except exception as ex:\n print \"{0}, Retrying in {1} seconds...\".format(ex, mdelay)\n time.sleep(mdelay)\n mtries -= 1\n mdelay *= backoff\n return f(*args, **kwargs)\n return f_retry # true decorator\n return deco_retry","def _retry_refresh(wrapper, *a3, **k3):\n return func(wrapper, *a3, **k3)","def retry(exception_to_check, tries=4, delay=0.5, backoff=2):\n\n def deco_retry(f):\n def f_retry(*args, **kwargs):\n mtries, mdelay = tries, delay\n try_one_last_time = True\n while mtries > 1:\n try:\n return f(*args, **kwargs)\n try_one_last_time = False\n break\n except exception_to_check, e:\n msg = \"%s, Retrying in %d seconds...\" % (str(e), mdelay)\n logging.warning(msg)\n time.sleep(mdelay)\n mtries -= 1\n mdelay *= backoff\n if try_one_last_time:\n return f(*args, **kwargs)\n return\n return f_retry\n return deco_retry","def _raise_ex(fn):\n\n def _decorated(*args, **kwargs):\n v = fn(*args, **kwargs)\n if isinstance(v, Exception): raise v\n return v\n\n return _decorated","def _retry_on_exception(\n exception: Union[Exception, Tuple[Exception]],\n regex: Optional[str] = None,\n max_retries: int = MAX_POLLS,\n retry_interval_s: int = POLL_INTERVAL,\n):\n\n def dec(func):\n @wraps(func)\n def wrapper(*args, **kwargs):\n def try_catch_exc():\n try:\n value = func(*args, **kwargs)\n return value\n except Exception as e:\n if not isinstance(e, exception) or (\n regex and not re.search(regex, str(e))\n ):\n raise e\n return e\n\n for _ in range(max_retries):\n ret = try_catch_exc()\n if not isinstance(ret, Exception):\n break\n time.sleep(retry_interval_s)\n if isinstance(ret, Exception):\n raise ret\n return ret\n\n return wrapper\n\n return dec","def retry(attempts_number, delay=0, step=0, max_delay=-1,\n retry_on=Exception, logger=None):\n\n def decorator(func):\n\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n current_logger = logger\n\n attempts = 1\n retry_delay = delay\n\n try:\n if isinstance(args[0], object):\n current_logger = args[0].get_logger()\n except (AttributeError, IndexError):\n pass\n\n if isinstance(retry_on, (types.FunctionType,\n types.MethodType,)):\n catch_strategy = CatchFunctionStrategy(retry_on)\n else:\n catch_strategy = CatchExceptionStrategy(retry_on)\n\n while attempts <= attempts_number or attempts_number < 0:\n try:\n return func(*args, **kwargs)\n except Exception as e:\n if catch_strategy.need_to_retry(e):\n if attempts >= attempts_number >= 0:\n raise\n elif current_logger:\n retry_count = \"inf\" if attempts_number < 0 \\\n else attempts_number - 1\n\n current_logger.warning(\n \"Retry: Call to %(fn)s failed due to \"\n \"%(exc_class)s: %(exc)s, retry \"\n \"attempt #%(retry_no)s/\"\n \"%(retry_count)s after %(delay)ss\",\n dict(fn=func.__name__,\n exc=str(e),\n retry_no=attempts,\n exc_class=e.__class__.__name__,\n retry_count=retry_count,\n delay=retry_delay))\n time.sleep(retry_delay)\n attempts += 1\n retry_delay += step\n if 0 <= max_delay < retry_delay:\n retry_delay = max_delay\n else:\n raise\n return wrapper\n return decorator","def attach_exception_handler(func):\n @wraps(func)\n def exception_handler(*args, **kwargs):\n try:\n return func(*args, **kwargs)\n except BotoClientError as e:\n raise ClientError.from_boto(e) from None\n return exception_handler","def try_decorator(func):\n\n @wraps(func)\n def wrap(*args, **kwargs):\n try:\n return func(*args, **kwargs)\n except Exception:\n logging.exception('%r with %r and %r', func.__name__, args, kwargs)\n\n return wrap","def try_decorator(func):\n @wraps(func)\n def wrap(*args, **kwargs):\n try:\n return func(*args, **kwargs)\n except Exception:\n logging.exception('%r with %r and %r', func.__name__, args, kwargs)\n return wrap","def retry_on_bad_auth(func):\n @wraps(func)\n def retry_version(self, *args, **kwargs):\n while True:\n try:\n return func(self, *args, **kwargs)\n except trolly.ResourceUnavailable:\n sys.stderr.write('bad request (refresh board id)\\n')\n self._board_id = None\n self.save_key('board_id', None)\n except trolly.Unauthorised:\n sys.stderr.write('bad permissions (refresh token)\\n')\n self._client = None\n self._token = None\n self.save_key('token', None)\n return retry_version","def _handle_exceptions(f):\n\n @wraps(f)\n def wrapper(self, *args, **kwargs):\n try:\n return f(self, *args, **kwargs)\n except Exception as err:\n logger.exception(\n f\"{type(self).__name__}.{f.__name__}(*{args!r}, **{kwargs!r}) failed\"\n )\n content = self.message.content\n self.reply(f\"Oops, the {content} command encountered a problem: {err!r}\")\n\n wrapper._handle_exceptions = True\n return wrapper","def wrap_exception(service, binary):\n def inner(f):\n def wrapped(self, context, *args, **kw):\n # Don't store self or context in the payload, it now seems to\n # contain confidential information.\n try:\n return f(self, context, *args, **kw)\n except Exception as exc:\n with excutils.save_and_reraise_exception():\n call_dict = _get_call_dict(f, self, context, *args, **kw)\n function_name = f.__name__\n\n _emit_legacy_exception_notification(\n context, exc, service, function_name, call_dict)\n _emit_versioned_exception_notification(\n context, exc, binary)\n return functools.wraps(f)(wrapped)\n return inner","def ensure_redis_call(f, *args, **kwargs):\n attempts = kwargs.pop('attempts', 5)\n\n for i in six.moves.range(attempts + 1):\n try:\n return f(*args, **kwargs)\n\n except (ConnectionError, TimeoutError) as e:\n if i == attempts:\n raise\n else:\n wait = 2 ** i\n msg = (\n 'Will reattempt to execute {} with args={} kwargs={} '\n 'after {} seconds due to exception {}: {}'\n ''.format(f, args, kwargs, wait, type(e).__name__, e)\n )\n print(msg)\n time.sleep(wait)","def auto_failover(method):\r\n\r\n @functools.wraps(method)\r\n def _decorator(self, *args, **kwargs):\r\n if self._in_fallback:\r\n pass_seconds = (datetime_now() - self._in_fallback_date).total_seconds()\r\n if pass_seconds > self._options.get(\"FAILOVER_TIME\", 30):\r\n print(\"Go to default connection\")\r\n self._client = self._old_client\r\n\r\n self._in_fallback = False\r\n self._in_fallback_date = None\r\n del self.fallback_client\r\n else:\r\n print(\"Mantain fallback connection\")\r\n\r\n try:\r\n print(\"Executing {0}\".format(method.__name__))\r\n return method(self, *args, **kwargs)\r\n except ConnectionInterrumped:\r\n if self._fallback and not self._in_fallback:\r\n print(\"raised ConnectionInterrumped\")\r\n print(\"Switching to fallback conection\")\r\n self._old_client = self._client\r\n self._client = self.fallback_client\r\n\r\n self._in_fallback = True\r\n self._in_fallback_date = timezone.now()\r\n\r\n return method(self, *args, **kwargs)\r\n return _decorator","def DatabaseSafe(method):\n @defer.inlineCallbacks\n @functools.wraps(method)\n def run(self, *args, **kwargs):\n try:\n r = yield defer.maybeDeferred(method, self, *args, **kwargs)\n except cyclone.redis.ConnectionError, e:\n m = \"redis.ConnectionError: %s\" % e\n log.msg(m)\n raise cyclone.web.HTTPError(503, m) # Service Unavailable\n except (MySQLdb.InterfaceError, MySQLdb.OperationalError), e:\n m = \"mysql.Error: %s\" % e\n log.msg(m)\n raise cyclone.web.HTTPError(503, m) # Service Unavailable\n else:\n defer.returnValue(r)\n\n return run","def reconnect(func):\n\n @wraps(func)\n def _reconnect(self, *args, **kwargs):\n \"\"\"\n Inner wrap function to reconnect on failure\n \"\"\"\n try:\n return func(self, *args, **kwargs)\n except ldap.LDAPError:\n self.connect()\n return func(self, *args, **kwargs)\n\n return _reconnect","def _retry(method, max_tries=5, backoff_s=1):\n\n @wraps(method)\n def method_with_retries(self, *args, **kwargs):\n try_count = 0\n while try_count < max_tries:\n try:\n return method(self, *args, **kwargs)\n except BrokenPipeError:\n logger.warning(\"Caught a BrokenPipeError. Retrying.\")\n try_count += 1\n if try_count < max_tries:\n self._construct_clients()\n time.sleep(backoff_s)\n else:\n raise\n\n return method_with_retries","def wrapped_fn(*args, **kwargs):\n for delay in delays():\n try:\n return fn(*args, **kwargs)\n except Exception as e: # pylint: disable=broad-except)\n if is_retriable is None:\n continue\n\n if is_retriable(e):\n time.sleep(delay)\n else:\n raise\n return fn(*args, **kwargs)","def catch_gracefully():\n def _outer(func):\n\n @functools.wraps(func)\n def _inner(*args, **kwargs):\n try:\n return func(*args, **kwargs)\n except Exception as e:\n if isinstance(e, IGNORE_EXCEPTIONS):\n raise\n else:\n logger.error(\"Catched exception %s when running %s\", e, func)\n logger.exception(e)\n\n return _inner\n\n return _outer","def _wrap_for_resource_exhausted(func):\n\n def wrapper(*args, **kwargs):\n while True:\n try:\n return func(*args, **kwargs)\n except Exception as ex:\n if \"RESOURCE_EXHAUSTED\" in str(ex):\n _debug_print(ex)\n _handle_resource_exhausted_error()\n continue\n raise\n\n return wrapper","def retry(times: int, except_callback: Optional[Callable[..., Any]] = None):\n\n def wrap(func):\n @wraps(func)\n def retry_it(*args, **kwargs):\n nonlocal times\n if times < 0: # forever\n times = 1 << 32\n\n for i in range(1, times + 1):\n try:\n r = func(*args, **kwargs)\n return r\n except Exception as err:\n if except_callback is not None:\n except_callback(err, i)\n\n if i == times:\n raise err\n\n return retry_it\n\n return wrap","def on_exception(self):\n\n def decorator(coro):\n self._hooks.append((\"exception\", coro))\n return coro\n\n return decorator","def roku_exception_handler(\n ignore_timeout: bool = False,\n) -> Callable[[_FuncType[_RokuEntityT, _P]], _ReturnFuncType[_RokuEntityT, _P]]:\n\n def decorator(\n func: _FuncType[_RokuEntityT, _P]\n ) -> _ReturnFuncType[_RokuEntityT, _P]:\n @wraps(func)\n async def wrapper(\n self: _RokuEntityT, *args: _P.args, **kwargs: _P.kwargs\n ) -> None:\n try:\n await func(self, *args, **kwargs)\n except RokuConnectionTimeoutError as error:\n if not ignore_timeout:\n raise HomeAssistantError(\n \"Timeout communicating with Roku API\"\n ) from error\n except RokuConnectionError as error:\n raise HomeAssistantError(\"Error communicating with Roku API\") from error\n except RokuError as error:\n raise HomeAssistantError(\"Invalid response from Roku API\") from error\n\n return wrapper\n\n return decorator","def errors_wrapped(func):\n\n async def wrapped(self, *args, **kwargs):\n try:\n return await func(self, *args, **kwargs)\n except AuthenticationRequiredError as ex:\n logger.warning(f\"Trying to use unauth access: {ex}\")\n add_message(self.request, \"LogIn to continue.\")\n redirect(self.request, \"sign_in\")\n\n except BaseApplicationError as ex:\n message = getattr(ex, \"message\", None) or str(ex)\n details = getattr(ex, \"details\", None)\n if details:\n message = f\"{message}: {details}\"\n\n add_message(self.request, message, kind=\"error\")\n raise web.HTTPFound(self.request.path)\n\n return wrapped","def _ShouldRetry(self, type_, value_, traceback):\n return True","def intercept(\n decorated,\n catch=Exception,\n reraise=None,\n handler=None,\n err_msg=None,\n include_context=False,\n):\n try:\n return decorated(*decorated.args, **decorated.kwargs)\n\n except catch as exc:\n if handler is not None:\n handler(exc)\n\n if isinstance(reraise, bool):\n if reraise:\n raise\n\n elif reraise is not None:\n\n if err_msg is not None:\n new_exc = reraise(err_msg)\n else:\n new_exc = reraise(str(exc))\n\n context = exc if include_context else None\n raise_from(new_exc, context)","def _timeout_retry(func, *args, **kwargs):\n tried = kwargs.pop('_____retires', 0)\n try:\n q = func(*args, **kwargs)\n except (TimeoutError, TableParseError) as exc:\n if tried >= MAX_RETRIES_TIMEOUT:\n raise TimeoutError(f'TimeOut obtained in {MAX_RETRIES_TIMEOUT}'\n ' tries, aborting.') from exc\n return _timeout_retry(func, *args, **kwargs, _____retires=tried+1)\n return q","def secure_communication(max_iter=3):\n def decorator(method):\n\n @wraps(method)\n def wrapper(self, *args, **kwargs):\n\n i = 0\n # Try at most `max_iter` times to excute method\n while i < max_iter + 1:\n self.lock.acquire()\n try:\n return method(self, *args, **kwargs)\n\n # Catch all the exception specified by the driver\n except self.secure_com_exceptions as e:\n if i == max_iter:\n raise\n else:\n logger = logging.getLogger(__name__)\n logger.error(e)\n self.reopen_connection()\n i += 1\n finally:\n self.lock.release()\n\n wrapper.__wrapped__ = method\n return wrapper\n\n return decorator","def retry(exception_to_check=AssertionError, tries=100, delay=.1):\n def deco_retry(f):\n def f_retry(*args, **kwargs):\n mtries, mdelay = tries, delay\n while mtries > 0:\n try:\n return f(*args, **kwargs)\n except exception_to_check, e:\n log.info('%s, Retrying in %s seconds...' % (str(e), mdelay))\n time.sleep(mdelay)\n mtries -= 1\n try_time = float(tries*delay)\n raise exception_to_check('tried for %1.1f seconds, gave up' % try_time)\n return f_retry\n return deco_retry","def exception(logger):\n def decorator(func):\n \n def wrapper(*args, **kwargs):\n try:\n return func(*args, **kwargs)\n except:\n # log the exception\n err = \"There was an exception in \"\n err += func.__name__\n logger.exception(err)\n \n # re-raise the exception\n raise\n return wrapper\n return decorator","def try_except(fn):\n def wrapped(*args, **kwargs):\n try:\n return fn(*args, **kwargs)\n except Exception, e:\n et, ei, tb = sys.exc_info()\n raise SerialException, \"Failed to '%s': %s\" % (fn.__name__, SerialException(e)), tb\n return wrapped","def WrapNonExceptionThrows(self) -> bool:","def retry_multi(max_retries=5):\n\n def retry(func):\n @wraps(func)\n def wrapper(*args, **kwargs):\n num_retries = 0\n ret = None\n while num_retries <= max_retries:\n try:\n ret = func(*args, **kwargs)\n break\n except Exception as e:\n logger.exception(e)\n if num_retries == max_retries:\n raise\n num_retries += 1\n time.sleep(5)\n return ret\n\n return wrapper\n\n return retry","def _retry(*, task, signature_kwargs, retries):\n if retries < MAX_RETRIES:\n step = task.signature(**signature_kwargs)\n queue = step.options.get(\"queue\", task.queue)\n step.options[\"queue\"] = f\"{queue}-delay\"\n step.kwargs[\"retries\"] = retries + 1\n on_commit(step.apply_async)\n else:\n raise MaxRetriesExceededError","def _retry_occurred(self):","def handle_db_lock(func):\n @wraps(func)\n def wrapper(request, *args, **kwargs):\n try:\n return func(request, *args, **kwargs)\n except OperationalError as ex:\n # sqlite3 cannot handle concurrent transactions.\n # This should be very rare with just a few users.\n # If it happens often, switch to mysql or postgres.\n if str(ex) == 'database is locked':\n messages.error(request, u'The database is busy. Please try again.')\n return redirect(index)\n raise ex\n return wrapper","def _retry(self, f):\n count = 0\n while True:\n try:\n return f()\n # http://initd.org/psycopg/docs/module.html#psycopg2.DatabaseError\n # handle operational error - memory allocation, unexpected disconnect\n except psycopg2.OperationalError, oe:\n count += 1\n if count < self._max_retries:\n LOGGER.warn(\"Transient Error Received %s \", oe)\n time.sleep(self._retry_period)\n else:\n LOGGER.error(\"Unrecoverable Error %s\", oe)\n raise oe\n # other database errors - integrity, internal, programming error etc\n except psycopg2.DatabaseError, de:\n LOGGER.error(\"Database Error %s\", de)\n raise de\n # interface errors\n except psycopg2.Error, e:\n raise e","def raises_conn_error(func):\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n try:\n return func(*args, **kwargs)\n except exc.InvalidRequestError:\n LOG.exception('Connection error:')\n raise errors.ConnectionError()\n\n return wrapper","def RunInTransactionCustomRetries(retries, function, *args, **kwargs):\n\n if _CurrentTransactionKey():\n raise datastore_errors.BadRequestError(\n 'Nested transactions are not supported.')\n\n if retries < 0:\n raise datastore_errors.BadRequestError(\n 'Number of retries should be non-negative number.')\n\n tx_key = None\n\n try:\n tx_key = _NewTransactionKey()\n\n for i in range(0, retries + 1):\n handle = datastore_pb.Transaction()\n try:\n apiproxy_stub_map.MakeSyncCall('datastore_v3', 'BeginTransaction',\n api_base_pb.VoidProto(), handle)\n except apiproxy_errors.ApplicationError, err:\n raise _ToDatastoreError(err)\n\n tx = _Transaction(handle)\n _txes[tx_key] = tx\n\n try:\n result = function(*args, **kwargs)\n except:\n original_exception = sys.exc_info()\n\n try:\n resp = api_base_pb.VoidProto()\n apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Rollback',\n tx.handle, resp)\n except:\n exc_info = sys.exc_info()\n logging.info('Exception sending Rollback:\\n' +\n ''.join(traceback.format_exception(*exc_info)))\n\n type, value, trace = original_exception\n if type is datastore_errors.Rollback:\n return\n else:\n raise type, value, trace\n\n try:\n resp = datastore_pb.CommitResponse()\n apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Commit',\n tx.handle, resp)\n except apiproxy_errors.ApplicationError, err:\n if (err.application_error ==\n datastore_pb.Error.CONCURRENT_TRANSACTION):\n logging.warning('Transaction collision for entity group with '\n 'key %r. Retrying...', tx.entity_group)\n tx.handle = None\n tx.entity_group = None\n continue\n else:\n raise _ToDatastoreError(err)\n\n return result\n\n raise datastore_errors.TransactionFailedError(\n 'The transaction could not be committed. Please try again.')\n\n finally:\n if tx_key in _txes:\n del _txes[tx_key]\n del tx_key","def catch_network_exception(func):\n\n @wraps(func)\n def wrapper(self, *args, **kwargs):\n \"\"\"Wrapper function.\"\"\"\n try:\n if (\n isinstance(self, (Connection, PooledConnection))\n and self.is_server_disconnected()\n ):\n raise InterfaceError(*self.get_disconnected_reason())\n result = func(self, *args, **kwargs)\n if isinstance(result, BaseResult):\n warns = result.get_warnings()\n for warn in warns:\n if warn[\"code\"] in CONNECTION_CLOSED_ERROR:\n error_msg = CONNECTION_CLOSED_ERROR[warn[\"code\"]]\n reason = (\n f\"Connection close: {warn['msg']}: {error_msg}\",\n warn[\"code\"],\n )\n if isinstance(self, (Connection, PooledConnection)):\n self.set_server_disconnected(reason)\n break\n return result\n except (InterfaceError, OSError, RuntimeError, TimeoutError) as err:\n if (\n func.__name__ == \"get_column_metadata\"\n and args\n and isinstance(args[0], SqlResult)\n ):\n warns = args[0].get_warnings()\n if warns:\n warn = warns[0]\n error_msg = CONNECTION_CLOSED_ERROR[warn[\"code\"]]\n reason = (\n f\"Connection close: {warn['msg']}: {error_msg}\",\n warn[\"code\"],\n )\n if isinstance(self, PooledConnection):\n self.pool.remove_connections()\n # pool must be listed as faulty if server is shutting down\n if warn[\"code\"] == 1053:\n PoolsManager().set_pool_unavailable(\n self.pool, InterfaceError(*reason)\n )\n if isinstance(self, (Connection, PooledConnection)):\n self.set_server_disconnected(reason)\n self.disconnect()\n raise InterfaceError(*reason) from err\n self.disconnect()\n raise\n\n return wrapper","def wrap_exceptions(callable):\r\n def wrapper(self, *args, **kwargs):\r\n try:\r\n return callable(self, *args, **kwargs)\r\n except EnvironmentError:\r\n # ENOENT (no such file or directory) gets raised on open().\r\n # ESRCH (no such process) can get raised on read() if\r\n # process is gone in meantime.\r\n err = sys.exc_info()[1]\r\n if err.errno in (errno.ENOENT, errno.ESRCH):\r\n raise NoSuchProcess(self.pid, self._process_name)\r\n if err.errno in (errno.EPERM, errno.EACCES):\r\n raise AccessDenied(self.pid, self._process_name)\r\n raise\r\n return wrapper","def rate_limiting(func):\n\n @wraps(func)\n def func_wrapper(*args, **kwargs):\n # Retry counter for rate limiting\n number_of_attempts = 0\n while True:\n try:\n return func(*args, **kwargs)\n except FacebookRequestError as e:\n # Deal with rate limiting error\n # https://developers.facebook.com/docs/marketing-api/api-rate-limiting\n if e.api_error_code() == 17 and number_of_attempts < 7:\n duration = 60 * 2 ** number_of_attempts\n logging.warning('Hit rate limiting. Retry #{attempt} in {duration} seconds'\n .format(attempt=number_of_attempts,\n duration=duration))\n time.sleep(duration)\n number_of_attempts += 1\n else:\n raise\n\n return func_wrapper","def _disable_decorator(msg):\n def decorator(func):\n @functools.wraps(func)\n def _wrapper(self, *args, **kwargs):\n raise RuntimeError(msg.format(func.__name__))\n _wrapper.__doc__ = None\n return _wrapper\n return decorator","def exception(function):\n @functools.wraps(function)\n def wrapper(*args, **kwargs):\n try:\n return function(*args, **kwargs)\n except requests.exceptions.HTTPError as e:\n log.error(e)\n except requests.exceptions.RequestException as e: \n log.error(e)\n return wrapper","def picklable_exception_safe_function(function):\n if is_testing():\n setattr(function, _ATTRIBUTE_EXCEPTION_SAFE, True)\n\n return update_wrapper_extended(functools.partial(_safe_function, function), function)"],"string":"[\n \"def retry(func, *args, **kwargs):\\n @functools.wraps(func)\\n def wrapper(*w_args, **w_kwargs):\\n w_kwargs.update(kwargs)\\n return retry_function_on_deadlock(func, *w_args, **w_kwargs)\\n\\n return wrapper\",\n \"def _retry(func):\\n @wraps(func)\\n def _retry_wrapper(self, *args, **kwargs):\\n error_message = \\\"\\\"\\n for retry in range(self.retries + 1):\\n try:\\n return func(self, *args, **kwargs)\\n except ValueError as err:\\n error_message = str(err)\\n raise ValueError(str(error_message))\\n return _retry_wrapper\",\n \"def retryable(func):\\n\\n @wraps(func)\\n def wrapper(*args, **kwargs):\\n retries = 0\\n max_retries = kwargs.get(\\\"max_retries\\\", DEFAULT_RETRIES)\\n backoff = kwargs.get(\\\"backoff\\\", default_backoff)\\n while retries <= max_retries:\\n try:\\n return func(*args, **kwargs)\\n except IntegrityError:\\n logging.debug(\\n \\\"Race-condition caught? ({}/{} retries)\\\".format(retries, max_retries)\\n )\\n if retries >= max_retries:\\n logging.error(f\\\"Unable to execute {func}, max retries exceeded\\\")\\n raise\\n retries += 1\\n backoff(retries, max_retries)\\n\\n return wrapper\",\n \"def exceptdecorator(method):\\n def wrapper(*args, **kwargs):\\n \\\"\\\"\\\"\\n Try function, handle sqlite3.Error, optionally pass sqlite3.IntegrityError.\\n \\\"\\\"\\\"\\n return sql_exceptwrapper(method, integrity, *args, **kwargs)\\n return wrapper\",\n \"def smart_retry(f):\\n # type: (Callable) -> CallableT\\n\\n @functools.wraps(f)\\n def wrapper(api_instance, *args, **kwargs):\\n # type: (UnifiAPI, *Any, **Any) -> Any\\n try:\\n return f(api_instance, *args, **kwargs)\\n except Unauthorized as e:\\n\\n api_instance.log.debug(\\n \\\"An exception occurred when executing %s: %s. Refreshing the connection to the Controller and retrying\\\",\\n f.__name__,\\n e,\\n )\\n api_instance.connect()\\n return f(api_instance, *args, **kwargs)\\n\\n except Exception:\\n raise\\n\\n return cast(CallableT, wrapper)\",\n \"def wrap_db_error(f):\\n def _wrap(*args, **kwargs):\\n try:\\n return f(*args, **kwargs)\\n except sqlalchemy.exc.OperationalError, e:\\n if not is_db_connection_error(e.args[0]):\\n raise\\n\\n remaining_attempts = _MAX_RETRIES\\n while True:\\n LOG.warning(_('SQL connection failed. %d attempts left.'),\\n remaining_attempts)\\n remaining_attempts -= 1\\n time.sleep(_RETRY_INTERVAL)\\n try:\\n return f(*args, **kwargs)\\n except sqlalchemy.exc.OperationalError, e:\\n if (remaining_attempts == 0 or\\n not is_db_connection_error(e.args[0])):\\n raise\\n except sqlalchemy.exc.DBAPIError:\\n raise\\n except sqlalchemy.exc.DBAPIError:\\n raise\\n _wrap.func_name = f.func_name\\n return _wrap\",\n \"def retry(maxRetries, *exceptions):\\n def _doDecoration(fn):\\n def _doRetry(*args, **kwargs):\\n retries = 0\\n while retries <= maxRetries:\\n try:\\n return fn(*args, **kwargs)\\n except tuple(exceptions):\\n retries +=1\\n if retries > maxRetries:\\n raise\\n \\n return _doRetry\\n return _doDecoration\",\n \"def _retryProtect(m):\\n\\tdef f(self, *args, **kwargs):\\n\\t\\ttry:\\n\\t\\t\\treturn m(self, *args, **kwargs)\\n\\t\\texcept:\\n\\t\\t\\tself.reset()\\n\\t\\t\\treturn m(self, *args, **kwargs)\\n\\n\\treturn functools.update_wrapper(f, m)\",\n \"def wrap(fn):\\n\\n def wrapped_fn(*args, **kwargs):\\n \\\"\\\"\\\"The actual wrapper function that applies the retry logic.\\\"\\\"\\\"\\n for delay in delays():\\n try:\\n return fn(*args, **kwargs)\\n except Exception as e: # pylint: disable=broad-except)\\n if is_retriable is None:\\n continue\\n\\n if is_retriable(e):\\n time.sleep(delay)\\n else:\\n raise\\n return fn(*args, **kwargs)\\n\\n return wrapped_fn\",\n \"def retry(tries, delay=3, backoff=2, except_on=(Exception, )):\\n\\n tries = math.floor(tries)\\n\\n def decorator(f):\\n def f_retry(*args, **kwargs):\\n return function_retry(\\n tries, delay, backoff, except_on, f, *args, **kwargs)\\n return f_retry # true decorator -> decorated function\\n return decorator # @retry(arg[, ...]) -> true decorator\",\n \"def retry(times: int, on_exceptions: List[Exception]):\\n def decorator(function: Callable):\\n @wraps(function)\\n def wrapper(*args, **kwargs):\\n raised = []\\n for _ in range(times):\\n try:\\n return function(*args, **kwargs)\\n except Exception as ex:\\n raised.append(ex)\\n if type(ex) not in on_exceptions:\\n raise RetryError(\\n 'An unexpected error occurred while calling the function '+\\n f'{function.__name__}.'\\n ) from ex\\n raise raised.pop()\\n return wrapper\\n return decorator\",\n \"def test_retry_raises_error_on_negative_retries(self):\\n\\n @retry(Exception, max_retries=-1)\\n def f():\\n raise Exception(\\\"Faulty function\\\")\\n\\n self.assertRaises(ValueError, f)\",\n \"def retry_on_deadlock(func):\\n @functools.wraps(func)\\n def decorate(*args, **kw):\\n # We can't use RetryDecorator from oslo_service directly because\\n # it runs a decorated function in a different thread and hence\\n # the function doesn't have access to authentication context\\n # set as a thread local variable.\\n # The solution is to reuse RetryDecorator but explicitly set\\n # auth context in the new thread that RetryDecorator spawns.\\n # In order to do that we need an additional helper function.\\n\\n auth_ctx = ctx.ctx() if ctx.has_ctx() else None\\n\\n return _with_auth_context(auth_ctx, func, *args, **kw)\\n\\n return decorate\",\n \"def retry(func):\\n # ... retry MAX_RETRIES times\\n # ...\\n # make sure you include this for testing:\\n # except Exception as exc:\\n # print(exc)\\n # ...\\n # and use wraps to preserve docstring\\n #\\n @wraps(func)\\n def wrapper(*args, **kwargs):\\n\\n tries = MAX_RETRIES\\n while tries > 0:\\n try:\\n return func(*args, **kwargs)\\n except Exception as err:\\n print(err)\\n\\n tries -= 1\\n\\n raise MaxRetriesException\\n\\n return wrapper\",\n \"def retrying(cls, fn, retries_allowed=None, wait_seconds=None, wait_increment=None, wait_multiplier=None):\\n # A special name_key of 'anonymous' is the default, which causes there not to be a name key.\\n # This cannot work in conjunction with RetryManager because different calls may result in different\\n # function values at the same point in code. -kmp 8-Jul-2020\\n decorator_function = Retry.retry_allowed(\\n name_key='anonymous', retries_allowed=retries_allowed, wait_seconds=wait_seconds,\\n wait_increment=wait_increment, wait_multiplier=wait_multiplier\\n )\\n return decorator_function(fn)\",\n \"def retry_if_dropped(func):\\n\\n def wrapper(*args, **kwargs):\\n n_tries = 0\\n max_tries = 2\\n err = None\\n\\n while n_tries < max_tries:\\n n_tries += 1\\n\\n try:\\n return func(*args, **kwargs)\\n except OperationalError as e:\\n err = e\\n\\n # This needs to be a local import\\n from django.db import connection\\n\\n connection.close()\\n\\n raise err\\n\\n return wrapper\",\n \"def retry(retries=5):\\n\\n def decorator(fn):\\n @wraps(fn)\\n def wrapper(*args, **kwargs):\\n count = 0\\n while True:\\n try:\\n return fn(*args, **kwargs)\\n except (\\n BadRequest,\\n BadResponseException,\\n ReadTimeout,\\n RequestException,\\n TraktBadGateway,\\n TraktUnavailable,\\n TraktInternalException,\\n ) as e:\\n if count == retries:\\n logger.error(f\\\"Error: {e}\\\")\\n\\n if isinstance(e, BadResponseException):\\n logger.error(f\\\"Details: {e.details}\\\")\\n if isinstance(e, TraktInternalException):\\n logger.error(f\\\"Error message: {e.error_message}\\\")\\n\\n logger.error(\\n \\\"API didn't respond properly, script will abort now. Please try again later.\\\"\\n )\\n logger.error(\\n f\\\"Last call: {fn.__module__}.{fn.__name__}({args[1:]}, {kwargs})\\\"\\n )\\n exit(1)\\n\\n seconds = 1 + count\\n count += 1\\n logger.warning(\\n f\\\"{e} for {fn.__module__}.{fn.__name__}(), retrying after {seconds} seconds (try: {count}/{retries})\\\"\\n )\\n sleep(seconds)\\n\\n return wrapper\\n\\n return decorator\",\n \"def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):\\n\\tdef deco_retry(f):\\n\\t\\t@wraps(f)\\n\\t\\tdef f_retry(*args, **kwargs):\\n\\t\\t\\tmtries, mdelay = tries, delay\\n\\t\\t\\twhile mtries > 1:\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\treturn f(*args, **kwargs)\\n\\t\\t\\t\\texcept ExceptionToCheck, e:\\n\\t\\t\\t\\t\\tmsg = \\\"func: '{}' > exc: {}, Retrying in {} seconds...\\\".format(str(f.__name__), str(e), mdelay)\\n\\t\\t\\t\\t\\tif logger:\\n\\t\\t\\t\\t\\t\\tlogger.warning(msg)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tprint msg\\n\\t\\t\\t\\t\\ttime.sleep(mdelay)\\n\\t\\t\\t\\t\\tmtries -= 1\\n\\t\\t\\t\\t\\tmdelay *= backoff\\n\\t\\t\\treturn f(*args, **kwargs)\\n\\t\\treturn f_retry\\t# true decorator\\n\\treturn deco_retry\",\n \"def reprovision_and_retry(func):\\n @functools.wraps(func)\\n def wrapper(*a, **kw):\\n errback = kw.get('errback', None)\\n if errback is None:\\n def errback(e):\\n raise e\\n def errback_wrapper(e):\\n if isinstance(e, UnknownAppID) and 'INITIAL' in OPTIONS:\\n try:\\n for initial in OPTIONS['INITIAL']:\\n provision(*initial) # retry provisioning the initial setup\\n func(*a, **kw) # and try the function once more\\n except Exception(new_exc):\\n errback(new_exc) # throwing the new exception\\n else:\\n errback(e) # not an instance of UnknownAppID - nothing we can do here\\n kw['errback'] = errback_wrapper\\n return func(*a, **kw)\\n return wrapper\",\n \"def retry_task(func):\\n\\n @wraps(func)\\n def wrapper(task, *args, **kwargs):\\n retries = task.request.retries\\n exponential = 2 ** retries\\n exponential_backoff = random.randint(exponential, exponential * 2)\\n try:\\n result = func(task, *args, **kwargs)\\n except Exception as e:\\n logger.error(\\n f\\\"Retriying {task.request.id} after {exponential_backoff} seconds\\\"\\n )\\n raise task.retry(countdown=exponential_backoff, exc=e, max_retries=5)\\n\\n return result\\n\\n return wrapper\",\n \"def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):\\n def deco_retry(f):\\n def f_retry(*args, **kwargs):\\n mtries, mdelay = tries, delay\\n try_one_last_time = True\\n while mtries > 1:\\n try:\\n return f(*args, **kwargs)\\n try_one_last_time = False\\n break\\n except ExceptionToCheck, e:\\n if logger:\\n msg = getMessage(\\\"en\\\", \\\"retrying-notification\\\").format(str(e), mdelay)\\n logger.warning(msg)\\n time.sleep(mdelay)\\n mtries -= 1\\n mdelay *= backoff\\n if try_one_last_time:\\n return f(*args, **kwargs)\\n return\\n return f_retry # true decorator\\n return deco_retry\",\n \"def decorated(instance, *args, **kwargs):\\n cfg = instance._retry_config\\n remaining_tries = cfg.retry_attempts\\n current_wait = cfg.retry_wait\\n retry_backoff = cfg.retry_backoff\\n last_error = None\\n\\n while remaining_tries >= 0:\\n try:\\n return fun(instance, *args, **kwargs)\\n except socket.error as e:\\n last_error = e\\n instance._retry_logger.warning('Connection failed: %s', e)\\n\\n remaining_tries -= 1\\n if remaining_tries == 0:\\n # Last attempt\\n break\\n\\n # Wait a bit\\n time.sleep(current_wait)\\n current_wait *= retry_backoff\\n\\n # All attempts failed, let's raise the last error.\\n raise last_error\",\n \"def _retry_provider_call(self, func):\\n\\n @functools.wraps(func)\\n def decorated(*args, **kwargs):\\n max_retries = 29\\n attempts = 0\\n while attempts < max_retries:\\n try:\\n return func(*args, **kwargs)\\n except ClientError as e:\\n attempts += 1\\n raise RetryLimitExceededError(\\n \\\"Exceeded request limit {} times. Aborting.\\\".format(max_retries)\\n )\\n return decorated\",\n \"def retrying(func, *retry_args, **retry_kwargs):\\n yield retriable(*retry_args, **retry_kwargs)(func)\",\n \"def on_error_rollback(func):\\n @functools.wraps(func)\\n def db_safe_exec(*args, **kwargs):\\n try:\\n return func(*args, **kwargs)\\n except Exception as e:\\n logger.error('Error ({!s}) - rolling back'.format(e))\\n session.rollback()\\n raise\\n return db_safe_exec\",\n \"def test_retry(self):\\n retries = [0]\\n max_tries = 5\\n\\n @retry(Exception, max_retries=5)\\n def f():\\n retries[0] += 1\\n raise Exception(\\\"Faulty function\\\")\\n\\n with self.assertRaises(Exception):\\n f()\\n\\n self.assertEqual(max_tries, retries[0])\",\n \"def retry(exceptions=Exception, tries=3, delay=1):\\n\\n def retry_decorator(func):\\n def func_wrapper(*args, **kwargs):\\n _tries = tries\\n while _tries:\\n try:\\n return func(*args, **kwargs)\\n except exceptions as e:\\n _tries -= 1\\n if not _tries:\\n raise\\n\\n time.sleep(delay)\\n\\n return func_wrapper\\n\\n return retry_decorator\",\n \"def retry(exceptions, tries=3, delay=2, _logger=logger()):\\n\\n def deco_retry(f):\\n @wraps(f)\\n def f_retry(*args, **kwargs):\\n mtries, mdelay = tries, delay\\n while mtries > 1:\\n try:\\n return f(*args, **kwargs)\\n except exceptions as e:\\n msg = '{}, Retrying in {} seconds...'.format(e, mdelay)\\n _logger.warning(msg)\\n time.sleep(mdelay)\\n mtries -= 1\\n return f(*args, **kwargs)\\n\\n return f_retry # true decorator\\n\\n return deco_retry\",\n \"def _retry_on_deadlock(f):\\n @functools.wraps(f)\\n def wrapped(*args, **kwargs):\\n while True:\\n try:\\n return f(*args, **kwargs)\\n except db_exc.DBDeadlock:\\n LOG.warning(\\\"Deadlock detected when running \\\"\\n \\\"'%(func_name)s': Retrying...\\\",\\n dict(func_name=f.__name__))\\n # Retry!\\n time.sleep(0.5)\\n continue\\n functools.update_wrapper(wrapped, f)\\n return wrapped\",\n \"def retriable(*retry_args, **retry_kwargs):\\n def _retriable_factory(func):\\n @wraps(func)\\n def _retriable_wrapper(*args, **kwargs):\\n return retry(func, args=args, kwargs=kwargs, *retry_args,\\n **retry_kwargs)\\n return _retriable_wrapper\\n return _retriable_factory\",\n \"def retry(ExceptionToCheck, tries=3, delay=3, backoff=2):\\n\\n def deco_retry(f):\\n @wraps(f)\\n def f_retry(*args, **kwargs):\\n mtries, mdelay = tries, delay\\n while mtries > 1:\\n try:\\n return f(*args, **kwargs)\\n except ExceptionToCheck as e:\\n logging.warning('%s, Retrying in %d seconds...', str(e), mdelay)\\n time.sleep(mdelay)\\n mtries -= 1\\n mdelay *= backoff\\n return f(*args, **kwargs)\\n\\n return f_retry\\n\\n return deco_retry\",\n \"def _retry_on_deadlock(f):\\n @functools.wraps(f)\\n def wrapped(*args, **kwargs):\\n while True:\\n try:\\n return f(*args, **kwargs)\\n except db_exc.DBDeadlock:\\n LOG.warning(_LW(\\\"Deadlock detected when running \\\"\\n \\\"'%(func_name)s': Retrying...\\\"),\\n dict(func_name=f.__name__))\\n # Retry!\\n time.sleep(0.5)\\n continue\\n functools.update_wrapper(wrapped, f)\\n return wrapped\",\n \"def _retry_on_deadlock(f):\\n @functools.wraps(f)\\n def wrapped(*args, **kwargs):\\n while True:\\n try:\\n return f(*args, **kwargs)\\n except db_exc.DBDeadlock:\\n LOG.warn(_(\\\"Deadlock detected when running \\\"\\n \\\"'%(func_name)s': Retrying...\\\"),\\n dict(func_name=f.__name__))\\n # Retry!\\n time.sleep(0.5)\\n continue\\n functools.update_wrapper(wrapped, f)\\n return wrapped\",\n \"def _Retry(func, *args, **kwargs):\\n retries = _RETRIES\\n while True:\\n try:\\n return func(*args, **kwargs)\\n except Exception as e: # pylint: disable=broad-except\\n retries -= 1\\n if retries > 0:\\n log.info('Exception {e} thrown in {func}. Retrying.'.format(\\n e=e, func=func.__name__))\\n time.sleep(1)\\n else:\\n raise e\",\n \"def retry(tries, delay=3, backoff=2):\\n tries = math.floor(tries)\\n if tries < 0:\\n raise ValueError(\\\"tries must be 0 or greater\\\")\\n\\n\\n def deco_retry(f):\\n @wraps(f)\\n def f_retry(*args, **kwargs):\\n mtries, mdelay = tries, delay # make mutable\\n err = None\\n while mtries > 0:\\n print(\\\"Trial Number:\\\" + str(mtries))\\n try:\\n rv = f(*args, **kwargs)\\n except DBException as e:\\n print(\\\"Retry..\\\")\\n mtries -= 1 # consume an attempt\\n time.sleep(mdelay) # wait...\\n mdelay += backoff # make future wait longer\\n err = e\\n\\n # except Exception as e:\\n # print(str(e))\\n # mtries -= 1 # consume an attempt\\n # time.sleep(mdelay) # wait...\\n # mdelay += backoff # make future wait longer\\n # err = e\\n else:\\n return rv\\n raise err\\n\\n return f_retry # true decorator -> decorated function\\n\\n return deco_retry # @retry(arg[, ...]) -> true decorator\",\n \"def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):\\n def deco_retry(f):\\n\\n @wraps(f)\\n def f_retry(*args, **kwargs):\\n mtries, mdelay = tries, delay\\n while mtries > 1:\\n try:\\n return f(*args, **kwargs)\\n except ExceptionToCheck, e:\\n msg = \\\"%s, Retrying in %d seconds...\\\" % (str(e), mdelay)\\n if logger:\\n logger.warning(msg)\\n else:\\n print msg\\n time.sleep(mdelay)\\n mtries -= 1\\n mdelay *= backoff\\n return f(*args, **kwargs)\\n\\n return f_retry # true decorator\\n\\n return deco_retry\",\n \"def transaction(self, retries=0):\\n def decorator(func):\\n @wraps(func)\\n def wrapper(*args, **kwargs):\\n attempts = 0\\n with self.get_pool().connection() as conn:\\n proxy = ConnectionProxy(conn)\\n while True:\\n try:\\n retval = func(proxy, *args, **kwargs)\\n conn.commit()\\n except IntegrityError:\\n attempts += 1\\n if attempts > retries:\\n raise\\n conn.rollback()\\n except Exception:\\n conn.rollback()\\n raise\\n else:\\n return retval\\n return wrapper\\n return decorator\",\n \"def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):\\n def deco_retry(f):\\n\\n @wraps(f)\\n def f_retry(*args, **kwargs):\\n mtries, mdelay = tries, delay\\n while mtries > 1:\\n try:\\n return f(*args, **kwargs)\\n except ExceptionToCheck, e:\\n msg = \\\"%s, Retrying in %d seconds...\\\" % (str(e), mdelay)\\n if logger:\\n logger.warning(msg)\\n else:\\n print(msg)\\n time.sleep(mdelay)\\n mtries -= 1\\n mdelay *= backoff\\n return f(*args, **kwargs)\\n\\n return f_retry # true decorator\\n\\n return deco_retry\",\n \"def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):\\n def deco_retry(f):\\n\\n @wraps(f)\\n def f_retry(*args, **kwargs):\\n mtries, mdelay = tries, delay\\n while mtries > 1:\\n try:\\n return f(*args, **kwargs)\\n except ExceptionToCheck as e:\\n msg = \\\"%s, Retrying in %d seconds...\\\" % (str(e), mdelay)\\n if logger:\\n logger.warning(msg)\\n else:\\n print(msg)\\n sleep(mdelay)\\n mtries -= 1\\n mdelay *= backoff\\n return f(*args, **kwargs)\\n\\n return f_retry # true decorator\\n\\n return deco_retry\",\n \"def retry(ExceptionToCheck, tries=3, delay=3, backoff=2, logger=None):\\n def deco_retry(f):\\n\\n @wraps(f)\\n def f_retry(*args, **kwargs):\\n mtries, mdelay = tries, delay\\n while mtries > 1:\\n try:\\n return f(*args, **kwargs)\\n except ExceptionToCheck, e:\\n msg = \\\"%s, Retrying in %d seconds...\\\" % (str(e), mdelay)\\n if logger:\\n logger.warning(msg)\\n else:\\n print msg\\n time.sleep(mdelay)\\n mtries -= 1\\n mdelay *= backoff\\n return f(*args, **kwargs)\\n\\n return f_retry # true decorator\\n\\n return deco_retry\",\n \"def wrapper(*args, **kwargs):\\n return sql_exceptwrapper(method, integrity, *args, **kwargs)\",\n \"def sql_excepthandler(integrity):\\n def exceptdecorator(method):\\n \\\"\\\"\\\"\\n Call function in sqlite3.Error try/except block.\\n\\n :param method: Method to use.\\n :type method: function\\n \\\"\\\"\\\"\\n def wrapper(*args, **kwargs):\\n \\\"\\\"\\\"\\n Try function, handle sqlite3.Error, optionally pass sqlite3.IntegrityError.\\n \\\"\\\"\\\"\\n return sql_exceptwrapper(method, integrity, *args, **kwargs)\\n return wrapper\\n return exceptdecorator\",\n \"def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):\\r\\n def deco_retry(f):\\r\\n\\r\\n @wraps(f)\\r\\n def f_retry(*args, **kwargs):\\r\\n mtries, mdelay = tries, delay\\r\\n while mtries > 1:\\r\\n try:\\r\\n return f(*args, **kwargs)\\r\\n except ExceptionToCheck, e:\\r\\n msg = \\\"%s, Retrying in %d seconds...\\\" % (str(e), mdelay)\\r\\n if logger:\\r\\n logger.warning(msg)\\r\\n else:\\r\\n print msg\\r\\n time.sleep(mdelay)\\r\\n mtries -= 1\\r\\n mdelay *= backoff\\r\\n return f(*args, **kwargs)\\r\\n\\r\\n return f_retry # true decorator\\r\\n\\r\\n return deco_retry\",\n \"def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):\\r\\n def deco_retry(f):\\r\\n\\r\\n @wraps(f)\\r\\n def f_retry(*args, **kwargs):\\r\\n mtries, mdelay = tries, delay\\r\\n while mtries > 1:\\r\\n try:\\r\\n return f(*args, **kwargs)\\r\\n except ExceptionToCheck as e:\\r\\n msg = \\\"%s, Retrying in %d seconds...\\\" % (str(e), mdelay)\\r\\n if logger:\\r\\n logger.warning(msg)\\r\\n else:\\r\\n print (msg)\\r\\n time.sleep(mdelay)\\r\\n mtries -= 1\\r\\n mdelay *= backoff\\r\\n return f(*args, **kwargs)\\r\\n return f_retry # true decorator\\r\\n return deco_retry\",\n \"def test_retry_other_exception():\\n\\n exceptions_in = [\\n RuntimeError(\\\"what?\\\"),\\n NotImplementedError(\\\"how?\\\"),\\n RuntimeError(\\\"no!\\\"),\\n ]\\n actual = []\\n expected = [1.0, 1.5, 2.25]\\n\\n def sleep(wait: float):\\n actual.append(wait)\\n\\n @retry(\\n (NotImplementedError, RuntimeError),\\n retries=4,\\n delay=1.0,\\n backoff=1.5,\\n sleep=sleep,\\n )\\n def explode():\\n raise exceptions_in.pop()\\n\\n try:\\n explode()\\n raise AssertionError(\\\"IndexError expected\\\")\\n except IndexError:\\n assert actual == expected\",\n \"def auto_retry(fun):\\n\\n @functools.wraps(fun)\\n def decorated(instance, *args, **kwargs):\\n \\\"\\\"\\\"Wrapper around a decorated function.\\\"\\\"\\\"\\n cfg = instance._retry_config\\n remaining_tries = cfg.retry_attempts\\n current_wait = cfg.retry_wait\\n retry_backoff = cfg.retry_backoff\\n last_error = None\\n\\n while remaining_tries >= 0:\\n try:\\n return fun(instance, *args, **kwargs)\\n except socket.error as e:\\n last_error = e\\n instance._retry_logger.warning('Connection failed: %s', e)\\n\\n remaining_tries -= 1\\n if remaining_tries == 0:\\n # Last attempt\\n break\\n\\n # Wait a bit\\n time.sleep(current_wait)\\n current_wait *= retry_backoff\\n\\n # All attempts failed, let's raise the last error.\\n raise last_error\\n\\n return decorated\",\n \"def retry_allowed(cls, name_key=None, retries_allowed=None, wait_seconds=None,\\n wait_increment=None, wait_multiplier=None):\\n\\n def _decorator(function):\\n function_name = name_key or function.__name__\\n function_profile = cls.RetryOptions(\\n retries_allowed=cls._defaulted(retries_allowed, cls.DEFAULT_RETRIES_ALLOWED),\\n wait_seconds=cls._defaulted(wait_seconds, cls.DEFAULT_WAIT_SECONDS),\\n wait_increment=cls._defaulted(wait_increment, cls.DEFAULT_WAIT_INCREMENT),\\n wait_multiplier=cls._defaulted(wait_multiplier, cls.DEFAULT_WAIT_MULTIPLIER),\\n )\\n\\n check_true(isinstance(retries_allowed, int) and retries_allowed >= 0,\\n \\\"The retries_allowed must be a non-negative integer.\\\",\\n error_class=ValueError)\\n\\n # See the 'retrying' method to understand what this is about. -kmp 8-Jul-2020\\n if function_name != 'anonymous':\\n cls._RETRY_OPTIONS_CATALOG[function_name] = function_profile # Only for debugging.\\n\\n @functools.wraps(function)\\n def wrapped_function(*args, **kwargs):\\n tries_allowed = function_profile.tries_allowed\\n wait_seconds = function_profile.wait_seconds or 0\\n last_error = None\\n for i in range(tries_allowed):\\n if i > 0:\\n if i > 1:\\n wait_seconds = function_profile.wait_adjustor(wait_seconds)\\n if wait_seconds > 0:\\n time.sleep(wait_seconds)\\n try:\\n success = function(*args, **kwargs)\\n return success\\n except Exception as e:\\n last_error = e\\n if last_error is not None:\\n raise last_error\\n\\n return wrapped_function\\n\\n return _decorator\",\n \"def retry(\\n action_type: ActionType,\\n default_return: Any,\\n) -> Callable:\\n\\n def decorator(func: Callable) -> Callable:\\n @wraps(func)\\n def result(*args: Any, **kwargs: Any) -> List[Optional[Row]]:\\n func_delay = config.execution.TASK_RETRY_DELAY\\n method_name = func.__name__\\n self = args[0]\\n\\n raised_ex = None\\n for attempt in range(config.execution.TASK_RETRY_COUNT + 1):\\n try:\\n # Create ExecutionLog with status in_processing or retrying\\n if attempt:\\n self.log_retry(action_type)\\n else:\\n self.log_start(action_type)\\n # Run access or erasure request\\n return func(*args, **kwargs)\\n except BaseException as ex: # pylint: disable=W0703\\n func_delay *= config.execution.TASK_RETRY_BACKOFF\\n logger.warning(\\n f\\\"Retrying {method_name} {self.traversal_node.address} in {func_delay} seconds...\\\"\\n )\\n sleep(func_delay)\\n raised_ex = ex\\n self.log_end(action_type, raised_ex)\\n return default_return\\n\\n return result\\n\\n return decorator\",\n \"def retry(exception, tries=10, delay=1, backoff=2, max_delay=30):\\n def deco_retry(f):\\n @wraps(f)\\n def f_retry(*args, **kwargs):\\n m_tries, m_delay = tries, delay\\n while m_tries > 1:\\n try:\\n return f(*args, **kwargs)\\n except exception:\\n time.sleep(min(m_delay, max_delay))\\n m_tries -= 1\\n m_delay *= backoff\\n return f(*args, **kwargs)\\n return f_retry # true decorator\\n return deco_retry\",\n \"def make_wrapped_function(self):\\n decorator = self.decorator()\\n\\n @decorator\\n def passthrough(argument):\\n if isinstance(argument, Exception):\\n raise argument\\n return argument\\n\\n return passthrough\",\n \"def _CatchExceptionDecorator(method):\\n @functools.wraps(method)\\n def Wrap(*args, **kwargs):\\n try:\\n return method(*args, **kwargs)\\n except Exception:\\n logging.warning(\\n '%s Exception: %s.', name,\\n '\\\\n'.join(traceback.format_exception_only(\\n *sys.exc_info()[:2])).strip())\\n return Wrap if enable else method\",\n \"def handleExceptionsDecorator(object):\\n\\n\\t\\t@functools.wraps(object)\\n\\t\\tdef handleExceptionsWrapper(*args, **kwargs):\\n\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\tThis decorator is used for exceptions handling.\\n\\n\\t\\t\\t:param \\\\*args: Arguments. ( \\\\* )\\n\\t\\t\\t:param \\\\*\\\\*kwargs: Keywords arguments. ( \\\\*\\\\* )\\n\\t\\t\\t\\\"\\\"\\\"\\n\\n\\t\\t\\t_exceptions__frame__ = True\\n\\n\\t\\t\\ttry:\\n\\t\\t\\t\\treturn object(*args, **kwargs)\\n\\t\\t\\texcept exceptions as error:\\n\\t\\t\\t\\tfor handler in handlers:\\n\\t\\t\\t\\t\\thandler(error)\\n\\n\\t\\treturn handleExceptionsWrapper\",\n \"def retry(nattempts, exception=None):\\n \\n def tryIt(func):\\n def wrapper(*args, **kwargs):\\n attempts = 0\\n while attempts < nattempts - 1:\\n try:\\n return func(*args, **kwargs)\\n except (exception if exception is not None else Exception):\\n attempts += 1\\n return func(*args, **kwargs)\\n return wrapper\\n return tryIt\",\n \"def omit_exception(method):\\r\\n\\r\\n @functools.wraps(method)\\r\\n def _decorator(self, *args, **kwargs):\\r\\n if self._ignore_exceptions:\\r\\n try:\\r\\n return method(self, *args, **kwargs)\\r\\n except ConnectionInterrupted:\\r\\n return None\\r\\n else:\\r\\n return method(self, *args, **kwargs)\\r\\n\\r\\n return _decorator\",\n \"def retry(retry_times=3, interval=0.5, exceptions=Exception):\\n def _decorator(func):\\n @wraps(func)\\n def _wrapped_func(*args, **kwargs):\\n for attempt in range(1, retry_times + 1):\\n try:\\n return func(*args, **kwargs)\\n except exceptions: # pylint: disable=broad-except\\n if attempt < retry_times:\\n logger.debug(\\\"%s failed in No. %d attempt\\\", func, attempt)\\n import traceback\\n import time\\n logger.debug(traceback.format_exc())\\n time.sleep(interval)\\n else:\\n raise # End of retry. Re-raise the exception as-is.\\n return _wrapped_func\\n return _decorator\",\n \"def retry(exception, tries=10, delay=3, backoff=0.1):\\n def deco_retry(f):\\n @wraps(f)\\n def f_retry(*args, **kwargs):\\n mtries, mdelay = tries, delay\\n while mtries > 1:\\n try:\\n return f(*args, **kwargs)\\n except exception as ex:\\n print \\\"{0}, Retrying in {1} seconds...\\\".format(ex, mdelay)\\n time.sleep(mdelay)\\n mtries -= 1\\n mdelay *= backoff\\n return f(*args, **kwargs)\\n return f_retry # true decorator\\n return deco_retry\",\n \"def _retry_refresh(wrapper, *a3, **k3):\\n return func(wrapper, *a3, **k3)\",\n \"def retry(exception_to_check, tries=4, delay=0.5, backoff=2):\\n\\n def deco_retry(f):\\n def f_retry(*args, **kwargs):\\n mtries, mdelay = tries, delay\\n try_one_last_time = True\\n while mtries > 1:\\n try:\\n return f(*args, **kwargs)\\n try_one_last_time = False\\n break\\n except exception_to_check, e:\\n msg = \\\"%s, Retrying in %d seconds...\\\" % (str(e), mdelay)\\n logging.warning(msg)\\n time.sleep(mdelay)\\n mtries -= 1\\n mdelay *= backoff\\n if try_one_last_time:\\n return f(*args, **kwargs)\\n return\\n return f_retry\\n return deco_retry\",\n \"def _raise_ex(fn):\\n\\n def _decorated(*args, **kwargs):\\n v = fn(*args, **kwargs)\\n if isinstance(v, Exception): raise v\\n return v\\n\\n return _decorated\",\n \"def _retry_on_exception(\\n exception: Union[Exception, Tuple[Exception]],\\n regex: Optional[str] = None,\\n max_retries: int = MAX_POLLS,\\n retry_interval_s: int = POLL_INTERVAL,\\n):\\n\\n def dec(func):\\n @wraps(func)\\n def wrapper(*args, **kwargs):\\n def try_catch_exc():\\n try:\\n value = func(*args, **kwargs)\\n return value\\n except Exception as e:\\n if not isinstance(e, exception) or (\\n regex and not re.search(regex, str(e))\\n ):\\n raise e\\n return e\\n\\n for _ in range(max_retries):\\n ret = try_catch_exc()\\n if not isinstance(ret, Exception):\\n break\\n time.sleep(retry_interval_s)\\n if isinstance(ret, Exception):\\n raise ret\\n return ret\\n\\n return wrapper\\n\\n return dec\",\n \"def retry(attempts_number, delay=0, step=0, max_delay=-1,\\n retry_on=Exception, logger=None):\\n\\n def decorator(func):\\n\\n @functools.wraps(func)\\n def wrapper(*args, **kwargs):\\n current_logger = logger\\n\\n attempts = 1\\n retry_delay = delay\\n\\n try:\\n if isinstance(args[0], object):\\n current_logger = args[0].get_logger()\\n except (AttributeError, IndexError):\\n pass\\n\\n if isinstance(retry_on, (types.FunctionType,\\n types.MethodType,)):\\n catch_strategy = CatchFunctionStrategy(retry_on)\\n else:\\n catch_strategy = CatchExceptionStrategy(retry_on)\\n\\n while attempts <= attempts_number or attempts_number < 0:\\n try:\\n return func(*args, **kwargs)\\n except Exception as e:\\n if catch_strategy.need_to_retry(e):\\n if attempts >= attempts_number >= 0:\\n raise\\n elif current_logger:\\n retry_count = \\\"inf\\\" if attempts_number < 0 \\\\\\n else attempts_number - 1\\n\\n current_logger.warning(\\n \\\"Retry: Call to %(fn)s failed due to \\\"\\n \\\"%(exc_class)s: %(exc)s, retry \\\"\\n \\\"attempt #%(retry_no)s/\\\"\\n \\\"%(retry_count)s after %(delay)ss\\\",\\n dict(fn=func.__name__,\\n exc=str(e),\\n retry_no=attempts,\\n exc_class=e.__class__.__name__,\\n retry_count=retry_count,\\n delay=retry_delay))\\n time.sleep(retry_delay)\\n attempts += 1\\n retry_delay += step\\n if 0 <= max_delay < retry_delay:\\n retry_delay = max_delay\\n else:\\n raise\\n return wrapper\\n return decorator\",\n \"def attach_exception_handler(func):\\n @wraps(func)\\n def exception_handler(*args, **kwargs):\\n try:\\n return func(*args, **kwargs)\\n except BotoClientError as e:\\n raise ClientError.from_boto(e) from None\\n return exception_handler\",\n \"def try_decorator(func):\\n\\n @wraps(func)\\n def wrap(*args, **kwargs):\\n try:\\n return func(*args, **kwargs)\\n except Exception:\\n logging.exception('%r with %r and %r', func.__name__, args, kwargs)\\n\\n return wrap\",\n \"def try_decorator(func):\\n @wraps(func)\\n def wrap(*args, **kwargs):\\n try:\\n return func(*args, **kwargs)\\n except Exception:\\n logging.exception('%r with %r and %r', func.__name__, args, kwargs)\\n return wrap\",\n \"def retry_on_bad_auth(func):\\n @wraps(func)\\n def retry_version(self, *args, **kwargs):\\n while True:\\n try:\\n return func(self, *args, **kwargs)\\n except trolly.ResourceUnavailable:\\n sys.stderr.write('bad request (refresh board id)\\\\n')\\n self._board_id = None\\n self.save_key('board_id', None)\\n except trolly.Unauthorised:\\n sys.stderr.write('bad permissions (refresh token)\\\\n')\\n self._client = None\\n self._token = None\\n self.save_key('token', None)\\n return retry_version\",\n \"def _handle_exceptions(f):\\n\\n @wraps(f)\\n def wrapper(self, *args, **kwargs):\\n try:\\n return f(self, *args, **kwargs)\\n except Exception as err:\\n logger.exception(\\n f\\\"{type(self).__name__}.{f.__name__}(*{args!r}, **{kwargs!r}) failed\\\"\\n )\\n content = self.message.content\\n self.reply(f\\\"Oops, the {content} command encountered a problem: {err!r}\\\")\\n\\n wrapper._handle_exceptions = True\\n return wrapper\",\n \"def wrap_exception(service, binary):\\n def inner(f):\\n def wrapped(self, context, *args, **kw):\\n # Don't store self or context in the payload, it now seems to\\n # contain confidential information.\\n try:\\n return f(self, context, *args, **kw)\\n except Exception as exc:\\n with excutils.save_and_reraise_exception():\\n call_dict = _get_call_dict(f, self, context, *args, **kw)\\n function_name = f.__name__\\n\\n _emit_legacy_exception_notification(\\n context, exc, service, function_name, call_dict)\\n _emit_versioned_exception_notification(\\n context, exc, binary)\\n return functools.wraps(f)(wrapped)\\n return inner\",\n \"def ensure_redis_call(f, *args, **kwargs):\\n attempts = kwargs.pop('attempts', 5)\\n\\n for i in six.moves.range(attempts + 1):\\n try:\\n return f(*args, **kwargs)\\n\\n except (ConnectionError, TimeoutError) as e:\\n if i == attempts:\\n raise\\n else:\\n wait = 2 ** i\\n msg = (\\n 'Will reattempt to execute {} with args={} kwargs={} '\\n 'after {} seconds due to exception {}: {}'\\n ''.format(f, args, kwargs, wait, type(e).__name__, e)\\n )\\n print(msg)\\n time.sleep(wait)\",\n \"def auto_failover(method):\\r\\n\\r\\n @functools.wraps(method)\\r\\n def _decorator(self, *args, **kwargs):\\r\\n if self._in_fallback:\\r\\n pass_seconds = (datetime_now() - self._in_fallback_date).total_seconds()\\r\\n if pass_seconds > self._options.get(\\\"FAILOVER_TIME\\\", 30):\\r\\n print(\\\"Go to default connection\\\")\\r\\n self._client = self._old_client\\r\\n\\r\\n self._in_fallback = False\\r\\n self._in_fallback_date = None\\r\\n del self.fallback_client\\r\\n else:\\r\\n print(\\\"Mantain fallback connection\\\")\\r\\n\\r\\n try:\\r\\n print(\\\"Executing {0}\\\".format(method.__name__))\\r\\n return method(self, *args, **kwargs)\\r\\n except ConnectionInterrumped:\\r\\n if self._fallback and not self._in_fallback:\\r\\n print(\\\"raised ConnectionInterrumped\\\")\\r\\n print(\\\"Switching to fallback conection\\\")\\r\\n self._old_client = self._client\\r\\n self._client = self.fallback_client\\r\\n\\r\\n self._in_fallback = True\\r\\n self._in_fallback_date = timezone.now()\\r\\n\\r\\n return method(self, *args, **kwargs)\\r\\n return _decorator\",\n \"def DatabaseSafe(method):\\n @defer.inlineCallbacks\\n @functools.wraps(method)\\n def run(self, *args, **kwargs):\\n try:\\n r = yield defer.maybeDeferred(method, self, *args, **kwargs)\\n except cyclone.redis.ConnectionError, e:\\n m = \\\"redis.ConnectionError: %s\\\" % e\\n log.msg(m)\\n raise cyclone.web.HTTPError(503, m) # Service Unavailable\\n except (MySQLdb.InterfaceError, MySQLdb.OperationalError), e:\\n m = \\\"mysql.Error: %s\\\" % e\\n log.msg(m)\\n raise cyclone.web.HTTPError(503, m) # Service Unavailable\\n else:\\n defer.returnValue(r)\\n\\n return run\",\n \"def reconnect(func):\\n\\n @wraps(func)\\n def _reconnect(self, *args, **kwargs):\\n \\\"\\\"\\\"\\n Inner wrap function to reconnect on failure\\n \\\"\\\"\\\"\\n try:\\n return func(self, *args, **kwargs)\\n except ldap.LDAPError:\\n self.connect()\\n return func(self, *args, **kwargs)\\n\\n return _reconnect\",\n \"def _retry(method, max_tries=5, backoff_s=1):\\n\\n @wraps(method)\\n def method_with_retries(self, *args, **kwargs):\\n try_count = 0\\n while try_count < max_tries:\\n try:\\n return method(self, *args, **kwargs)\\n except BrokenPipeError:\\n logger.warning(\\\"Caught a BrokenPipeError. Retrying.\\\")\\n try_count += 1\\n if try_count < max_tries:\\n self._construct_clients()\\n time.sleep(backoff_s)\\n else:\\n raise\\n\\n return method_with_retries\",\n \"def wrapped_fn(*args, **kwargs):\\n for delay in delays():\\n try:\\n return fn(*args, **kwargs)\\n except Exception as e: # pylint: disable=broad-except)\\n if is_retriable is None:\\n continue\\n\\n if is_retriable(e):\\n time.sleep(delay)\\n else:\\n raise\\n return fn(*args, **kwargs)\",\n \"def catch_gracefully():\\n def _outer(func):\\n\\n @functools.wraps(func)\\n def _inner(*args, **kwargs):\\n try:\\n return func(*args, **kwargs)\\n except Exception as e:\\n if isinstance(e, IGNORE_EXCEPTIONS):\\n raise\\n else:\\n logger.error(\\\"Catched exception %s when running %s\\\", e, func)\\n logger.exception(e)\\n\\n return _inner\\n\\n return _outer\",\n \"def _wrap_for_resource_exhausted(func):\\n\\n def wrapper(*args, **kwargs):\\n while True:\\n try:\\n return func(*args, **kwargs)\\n except Exception as ex:\\n if \\\"RESOURCE_EXHAUSTED\\\" in str(ex):\\n _debug_print(ex)\\n _handle_resource_exhausted_error()\\n continue\\n raise\\n\\n return wrapper\",\n \"def retry(times: int, except_callback: Optional[Callable[..., Any]] = None):\\n\\n def wrap(func):\\n @wraps(func)\\n def retry_it(*args, **kwargs):\\n nonlocal times\\n if times < 0: # forever\\n times = 1 << 32\\n\\n for i in range(1, times + 1):\\n try:\\n r = func(*args, **kwargs)\\n return r\\n except Exception as err:\\n if except_callback is not None:\\n except_callback(err, i)\\n\\n if i == times:\\n raise err\\n\\n return retry_it\\n\\n return wrap\",\n \"def on_exception(self):\\n\\n def decorator(coro):\\n self._hooks.append((\\\"exception\\\", coro))\\n return coro\\n\\n return decorator\",\n \"def roku_exception_handler(\\n ignore_timeout: bool = False,\\n) -> Callable[[_FuncType[_RokuEntityT, _P]], _ReturnFuncType[_RokuEntityT, _P]]:\\n\\n def decorator(\\n func: _FuncType[_RokuEntityT, _P]\\n ) -> _ReturnFuncType[_RokuEntityT, _P]:\\n @wraps(func)\\n async def wrapper(\\n self: _RokuEntityT, *args: _P.args, **kwargs: _P.kwargs\\n ) -> None:\\n try:\\n await func(self, *args, **kwargs)\\n except RokuConnectionTimeoutError as error:\\n if not ignore_timeout:\\n raise HomeAssistantError(\\n \\\"Timeout communicating with Roku API\\\"\\n ) from error\\n except RokuConnectionError as error:\\n raise HomeAssistantError(\\\"Error communicating with Roku API\\\") from error\\n except RokuError as error:\\n raise HomeAssistantError(\\\"Invalid response from Roku API\\\") from error\\n\\n return wrapper\\n\\n return decorator\",\n \"def errors_wrapped(func):\\n\\n async def wrapped(self, *args, **kwargs):\\n try:\\n return await func(self, *args, **kwargs)\\n except AuthenticationRequiredError as ex:\\n logger.warning(f\\\"Trying to use unauth access: {ex}\\\")\\n add_message(self.request, \\\"LogIn to continue.\\\")\\n redirect(self.request, \\\"sign_in\\\")\\n\\n except BaseApplicationError as ex:\\n message = getattr(ex, \\\"message\\\", None) or str(ex)\\n details = getattr(ex, \\\"details\\\", None)\\n if details:\\n message = f\\\"{message}: {details}\\\"\\n\\n add_message(self.request, message, kind=\\\"error\\\")\\n raise web.HTTPFound(self.request.path)\\n\\n return wrapped\",\n \"def _ShouldRetry(self, type_, value_, traceback):\\n return True\",\n \"def intercept(\\n decorated,\\n catch=Exception,\\n reraise=None,\\n handler=None,\\n err_msg=None,\\n include_context=False,\\n):\\n try:\\n return decorated(*decorated.args, **decorated.kwargs)\\n\\n except catch as exc:\\n if handler is not None:\\n handler(exc)\\n\\n if isinstance(reraise, bool):\\n if reraise:\\n raise\\n\\n elif reraise is not None:\\n\\n if err_msg is not None:\\n new_exc = reraise(err_msg)\\n else:\\n new_exc = reraise(str(exc))\\n\\n context = exc if include_context else None\\n raise_from(new_exc, context)\",\n \"def _timeout_retry(func, *args, **kwargs):\\n tried = kwargs.pop('_____retires', 0)\\n try:\\n q = func(*args, **kwargs)\\n except (TimeoutError, TableParseError) as exc:\\n if tried >= MAX_RETRIES_TIMEOUT:\\n raise TimeoutError(f'TimeOut obtained in {MAX_RETRIES_TIMEOUT}'\\n ' tries, aborting.') from exc\\n return _timeout_retry(func, *args, **kwargs, _____retires=tried+1)\\n return q\",\n \"def secure_communication(max_iter=3):\\n def decorator(method):\\n\\n @wraps(method)\\n def wrapper(self, *args, **kwargs):\\n\\n i = 0\\n # Try at most `max_iter` times to excute method\\n while i < max_iter + 1:\\n self.lock.acquire()\\n try:\\n return method(self, *args, **kwargs)\\n\\n # Catch all the exception specified by the driver\\n except self.secure_com_exceptions as e:\\n if i == max_iter:\\n raise\\n else:\\n logger = logging.getLogger(__name__)\\n logger.error(e)\\n self.reopen_connection()\\n i += 1\\n finally:\\n self.lock.release()\\n\\n wrapper.__wrapped__ = method\\n return wrapper\\n\\n return decorator\",\n \"def retry(exception_to_check=AssertionError, tries=100, delay=.1):\\n def deco_retry(f):\\n def f_retry(*args, **kwargs):\\n mtries, mdelay = tries, delay\\n while mtries > 0:\\n try:\\n return f(*args, **kwargs)\\n except exception_to_check, e:\\n log.info('%s, Retrying in %s seconds...' % (str(e), mdelay))\\n time.sleep(mdelay)\\n mtries -= 1\\n try_time = float(tries*delay)\\n raise exception_to_check('tried for %1.1f seconds, gave up' % try_time)\\n return f_retry\\n return deco_retry\",\n \"def exception(logger):\\n def decorator(func):\\n \\n def wrapper(*args, **kwargs):\\n try:\\n return func(*args, **kwargs)\\n except:\\n # log the exception\\n err = \\\"There was an exception in \\\"\\n err += func.__name__\\n logger.exception(err)\\n \\n # re-raise the exception\\n raise\\n return wrapper\\n return decorator\",\n \"def try_except(fn):\\n def wrapped(*args, **kwargs):\\n try:\\n return fn(*args, **kwargs)\\n except Exception, e:\\n et, ei, tb = sys.exc_info()\\n raise SerialException, \\\"Failed to '%s': %s\\\" % (fn.__name__, SerialException(e)), tb\\n return wrapped\",\n \"def WrapNonExceptionThrows(self) -> bool:\",\n \"def retry_multi(max_retries=5):\\n\\n def retry(func):\\n @wraps(func)\\n def wrapper(*args, **kwargs):\\n num_retries = 0\\n ret = None\\n while num_retries <= max_retries:\\n try:\\n ret = func(*args, **kwargs)\\n break\\n except Exception as e:\\n logger.exception(e)\\n if num_retries == max_retries:\\n raise\\n num_retries += 1\\n time.sleep(5)\\n return ret\\n\\n return wrapper\\n\\n return retry\",\n \"def _retry(*, task, signature_kwargs, retries):\\n if retries < MAX_RETRIES:\\n step = task.signature(**signature_kwargs)\\n queue = step.options.get(\\\"queue\\\", task.queue)\\n step.options[\\\"queue\\\"] = f\\\"{queue}-delay\\\"\\n step.kwargs[\\\"retries\\\"] = retries + 1\\n on_commit(step.apply_async)\\n else:\\n raise MaxRetriesExceededError\",\n \"def _retry_occurred(self):\",\n \"def handle_db_lock(func):\\n @wraps(func)\\n def wrapper(request, *args, **kwargs):\\n try:\\n return func(request, *args, **kwargs)\\n except OperationalError as ex:\\n # sqlite3 cannot handle concurrent transactions.\\n # This should be very rare with just a few users.\\n # If it happens often, switch to mysql or postgres.\\n if str(ex) == 'database is locked':\\n messages.error(request, u'The database is busy. Please try again.')\\n return redirect(index)\\n raise ex\\n return wrapper\",\n \"def _retry(self, f):\\n count = 0\\n while True:\\n try:\\n return f()\\n # http://initd.org/psycopg/docs/module.html#psycopg2.DatabaseError\\n # handle operational error - memory allocation, unexpected disconnect\\n except psycopg2.OperationalError, oe:\\n count += 1\\n if count < self._max_retries:\\n LOGGER.warn(\\\"Transient Error Received %s \\\", oe)\\n time.sleep(self._retry_period)\\n else:\\n LOGGER.error(\\\"Unrecoverable Error %s\\\", oe)\\n raise oe\\n # other database errors - integrity, internal, programming error etc\\n except psycopg2.DatabaseError, de:\\n LOGGER.error(\\\"Database Error %s\\\", de)\\n raise de\\n # interface errors\\n except psycopg2.Error, e:\\n raise e\",\n \"def raises_conn_error(func):\\n @functools.wraps(func)\\n def wrapper(*args, **kwargs):\\n try:\\n return func(*args, **kwargs)\\n except exc.InvalidRequestError:\\n LOG.exception('Connection error:')\\n raise errors.ConnectionError()\\n\\n return wrapper\",\n \"def RunInTransactionCustomRetries(retries, function, *args, **kwargs):\\n\\n if _CurrentTransactionKey():\\n raise datastore_errors.BadRequestError(\\n 'Nested transactions are not supported.')\\n\\n if retries < 0:\\n raise datastore_errors.BadRequestError(\\n 'Number of retries should be non-negative number.')\\n\\n tx_key = None\\n\\n try:\\n tx_key = _NewTransactionKey()\\n\\n for i in range(0, retries + 1):\\n handle = datastore_pb.Transaction()\\n try:\\n apiproxy_stub_map.MakeSyncCall('datastore_v3', 'BeginTransaction',\\n api_base_pb.VoidProto(), handle)\\n except apiproxy_errors.ApplicationError, err:\\n raise _ToDatastoreError(err)\\n\\n tx = _Transaction(handle)\\n _txes[tx_key] = tx\\n\\n try:\\n result = function(*args, **kwargs)\\n except:\\n original_exception = sys.exc_info()\\n\\n try:\\n resp = api_base_pb.VoidProto()\\n apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Rollback',\\n tx.handle, resp)\\n except:\\n exc_info = sys.exc_info()\\n logging.info('Exception sending Rollback:\\\\n' +\\n ''.join(traceback.format_exception(*exc_info)))\\n\\n type, value, trace = original_exception\\n if type is datastore_errors.Rollback:\\n return\\n else:\\n raise type, value, trace\\n\\n try:\\n resp = datastore_pb.CommitResponse()\\n apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Commit',\\n tx.handle, resp)\\n except apiproxy_errors.ApplicationError, err:\\n if (err.application_error ==\\n datastore_pb.Error.CONCURRENT_TRANSACTION):\\n logging.warning('Transaction collision for entity group with '\\n 'key %r. Retrying...', tx.entity_group)\\n tx.handle = None\\n tx.entity_group = None\\n continue\\n else:\\n raise _ToDatastoreError(err)\\n\\n return result\\n\\n raise datastore_errors.TransactionFailedError(\\n 'The transaction could not be committed. Please try again.')\\n\\n finally:\\n if tx_key in _txes:\\n del _txes[tx_key]\\n del tx_key\",\n \"def catch_network_exception(func):\\n\\n @wraps(func)\\n def wrapper(self, *args, **kwargs):\\n \\\"\\\"\\\"Wrapper function.\\\"\\\"\\\"\\n try:\\n if (\\n isinstance(self, (Connection, PooledConnection))\\n and self.is_server_disconnected()\\n ):\\n raise InterfaceError(*self.get_disconnected_reason())\\n result = func(self, *args, **kwargs)\\n if isinstance(result, BaseResult):\\n warns = result.get_warnings()\\n for warn in warns:\\n if warn[\\\"code\\\"] in CONNECTION_CLOSED_ERROR:\\n error_msg = CONNECTION_CLOSED_ERROR[warn[\\\"code\\\"]]\\n reason = (\\n f\\\"Connection close: {warn['msg']}: {error_msg}\\\",\\n warn[\\\"code\\\"],\\n )\\n if isinstance(self, (Connection, PooledConnection)):\\n self.set_server_disconnected(reason)\\n break\\n return result\\n except (InterfaceError, OSError, RuntimeError, TimeoutError) as err:\\n if (\\n func.__name__ == \\\"get_column_metadata\\\"\\n and args\\n and isinstance(args[0], SqlResult)\\n ):\\n warns = args[0].get_warnings()\\n if warns:\\n warn = warns[0]\\n error_msg = CONNECTION_CLOSED_ERROR[warn[\\\"code\\\"]]\\n reason = (\\n f\\\"Connection close: {warn['msg']}: {error_msg}\\\",\\n warn[\\\"code\\\"],\\n )\\n if isinstance(self, PooledConnection):\\n self.pool.remove_connections()\\n # pool must be listed as faulty if server is shutting down\\n if warn[\\\"code\\\"] == 1053:\\n PoolsManager().set_pool_unavailable(\\n self.pool, InterfaceError(*reason)\\n )\\n if isinstance(self, (Connection, PooledConnection)):\\n self.set_server_disconnected(reason)\\n self.disconnect()\\n raise InterfaceError(*reason) from err\\n self.disconnect()\\n raise\\n\\n return wrapper\",\n \"def wrap_exceptions(callable):\\r\\n def wrapper(self, *args, **kwargs):\\r\\n try:\\r\\n return callable(self, *args, **kwargs)\\r\\n except EnvironmentError:\\r\\n # ENOENT (no such file or directory) gets raised on open().\\r\\n # ESRCH (no such process) can get raised on read() if\\r\\n # process is gone in meantime.\\r\\n err = sys.exc_info()[1]\\r\\n if err.errno in (errno.ENOENT, errno.ESRCH):\\r\\n raise NoSuchProcess(self.pid, self._process_name)\\r\\n if err.errno in (errno.EPERM, errno.EACCES):\\r\\n raise AccessDenied(self.pid, self._process_name)\\r\\n raise\\r\\n return wrapper\",\n \"def rate_limiting(func):\\n\\n @wraps(func)\\n def func_wrapper(*args, **kwargs):\\n # Retry counter for rate limiting\\n number_of_attempts = 0\\n while True:\\n try:\\n return func(*args, **kwargs)\\n except FacebookRequestError as e:\\n # Deal with rate limiting error\\n # https://developers.facebook.com/docs/marketing-api/api-rate-limiting\\n if e.api_error_code() == 17 and number_of_attempts < 7:\\n duration = 60 * 2 ** number_of_attempts\\n logging.warning('Hit rate limiting. Retry #{attempt} in {duration} seconds'\\n .format(attempt=number_of_attempts,\\n duration=duration))\\n time.sleep(duration)\\n number_of_attempts += 1\\n else:\\n raise\\n\\n return func_wrapper\",\n \"def _disable_decorator(msg):\\n def decorator(func):\\n @functools.wraps(func)\\n def _wrapper(self, *args, **kwargs):\\n raise RuntimeError(msg.format(func.__name__))\\n _wrapper.__doc__ = None\\n return _wrapper\\n return decorator\",\n \"def exception(function):\\n @functools.wraps(function)\\n def wrapper(*args, **kwargs):\\n try:\\n return function(*args, **kwargs)\\n except requests.exceptions.HTTPError as e:\\n log.error(e)\\n except requests.exceptions.RequestException as e: \\n log.error(e)\\n return wrapper\",\n \"def picklable_exception_safe_function(function):\\n if is_testing():\\n setattr(function, _ATTRIBUTE_EXCEPTION_SAFE, True)\\n\\n return update_wrapper_extended(functools.partial(_safe_function, function), function)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67783445","0.6644641","0.6623299","0.6539066","0.6512475","0.6476035","0.6465493","0.64365405","0.6360299","0.6348828","0.6344524","0.6313005","0.62655896","0.6242453","0.6222092","0.62088233","0.6180234","0.6120076","0.60964835","0.6095427","0.60853565","0.6084996","0.60768694","0.60660344","0.6051874","0.60455084","0.6043904","0.60379016","0.60295296","0.600914","0.5999316","0.59935653","0.59909254","0.59875053","0.59799904","0.5969322","0.5967069","0.5962783","0.5957822","0.59536076","0.5951632","0.5945232","0.59444666","0.5920916","0.59209085","0.5881785","0.5868831","0.58525425","0.5851855","0.5830888","0.5827073","0.5826868","0.5816415","0.5801919","0.57966816","0.57931626","0.57711697","0.57539374","0.5750701","0.57497174","0.5740843","0.567166","0.5671021","0.565052","0.56423813","0.5636692","0.563579","0.5634943","0.5622451","0.5618033","0.5602235","0.5576324","0.5565069","0.5564883","0.5542241","0.5533577","0.5530778","0.5525022","0.5518603","0.55183434","0.551558","0.5504094","0.55008","0.5483318","0.5478592","0.5476002","0.5447075","0.5425196","0.5413916","0.54044646","0.5398993","0.53954446","0.5388095","0.53880006","0.5383492","0.53817827","0.5377638","0.5374806","0.52910936","0.5290009"],"string":"[\n \"0.67783445\",\n \"0.6644641\",\n \"0.6623299\",\n \"0.6539066\",\n \"0.6512475\",\n \"0.6476035\",\n \"0.6465493\",\n \"0.64365405\",\n \"0.6360299\",\n \"0.6348828\",\n \"0.6344524\",\n \"0.6313005\",\n \"0.62655896\",\n \"0.6242453\",\n \"0.6222092\",\n \"0.62088233\",\n \"0.6180234\",\n \"0.6120076\",\n \"0.60964835\",\n \"0.6095427\",\n \"0.60853565\",\n \"0.6084996\",\n \"0.60768694\",\n \"0.60660344\",\n \"0.6051874\",\n \"0.60455084\",\n \"0.6043904\",\n \"0.60379016\",\n \"0.60295296\",\n \"0.600914\",\n \"0.5999316\",\n \"0.59935653\",\n \"0.59909254\",\n \"0.59875053\",\n \"0.59799904\",\n \"0.5969322\",\n \"0.5967069\",\n \"0.5962783\",\n \"0.5957822\",\n \"0.59536076\",\n \"0.5951632\",\n \"0.5945232\",\n \"0.59444666\",\n \"0.5920916\",\n \"0.59209085\",\n \"0.5881785\",\n \"0.5868831\",\n \"0.58525425\",\n \"0.5851855\",\n \"0.5830888\",\n \"0.5827073\",\n \"0.5826868\",\n \"0.5816415\",\n \"0.5801919\",\n \"0.57966816\",\n \"0.57931626\",\n \"0.57711697\",\n \"0.57539374\",\n \"0.5750701\",\n \"0.57497174\",\n \"0.5740843\",\n \"0.567166\",\n \"0.5671021\",\n \"0.565052\",\n \"0.56423813\",\n \"0.5636692\",\n \"0.563579\",\n \"0.5634943\",\n \"0.5622451\",\n \"0.5618033\",\n \"0.5602235\",\n \"0.5576324\",\n \"0.5565069\",\n \"0.5564883\",\n \"0.5542241\",\n \"0.5533577\",\n \"0.5530778\",\n \"0.5525022\",\n \"0.5518603\",\n \"0.55183434\",\n \"0.551558\",\n \"0.5504094\",\n \"0.55008\",\n \"0.5483318\",\n \"0.5478592\",\n \"0.5476002\",\n \"0.5447075\",\n \"0.5425196\",\n \"0.5413916\",\n \"0.54044646\",\n \"0.5398993\",\n \"0.53954446\",\n \"0.5388095\",\n \"0.53880006\",\n \"0.5383492\",\n \"0.53817827\",\n \"0.5377638\",\n \"0.5374806\",\n \"0.52910936\",\n \"0.5290009\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7249463"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94498,"cells":{"query":{"kind":"string","value":"Try to reuse this named connection, else create one and use that"},"document":{"kind":"string","value":"def connection(self, name=None):\n if not name:\n name = threading.currentThread().getName()\n if name in self:\n return self[name]\n self[name] = self.database.connection()\n return self[name]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __get_database_connection(self, reuse=True):\n if not self.__database_connection or not reuse:\n if self.__database_connection:\n self.__database_connection.close()\n self.__database_connection = None\n\n self.__database_connection = http.client.HTTPConnection(self.__DATABASE_HOST,\n port=self.__DATABASE_PORT,\n timeout=self.__TIMEOUT)\n\n return self.__database_connection","def create_connection(self, db_name=None, raw=False):\n connected = False\n max_tries = 10\n\n # if db_name is not defined, let it be empty string\n if db_name is None:\n db_name = \"\"\n\n # Reconnect until max_tries exceeded\n while not connected and max_tries > 0:\n try:\n # create engine from db settings\n engine = self.get_engine(db_name)\n\n # Create connection for query\n connection = engine.connect() if raw == False else engine.raw_connection()\n\n connected = True\n\n return engine, connection\n except Exception as e:\n print(\"Database Connection Error: {}\".format(e))\n print(\"Network is unreachable. Retrying to connect to database in 10 seconds...\")\n time.sleep(10)\n max_tries -= 1","def reconect(self):\n self.connection.reset_connection()\n return self.connection","def reconect(self):\n self.connection = DataPostgres.connect(**self.options)\n return self.connection","def _connect(self, **kwargs):\n global _connection\n if self.reuse and _connection:\n self.connection = _connection\n else:\n if pymongo.version_tuple[0] < 3:\n try:\n self.connection = Connection(host=self.host,\n port=self.port, **kwargs)\n # pymongo >= 3.0 does not raise this error\n except PyMongoError:\n if self.fail_silently:\n return\n else:\n raise\n else:\n self.connection = Connection(host=self.host, port=self.port,\n **kwargs)\n try:\n self.connection.is_locked\n except ServerSelectionTimeoutError:\n if self.fail_silently:\n return\n else:\n raise\n _connection = self.connection\n\n self.db = self.connection[self.database_name]\n if self.username is not None and self.password is not None:\n auth_db = self.connection[self.authentication_database_name]\n self.authenticated = auth_db.authenticate(self.username,\n self.password)\n\n if self.capped:\n #\n # We don't want to override the capped collection\n # (and it throws an error anyway)\n try:\n self.collection = Collection(self.db, self.collection_name,\n capped=True, max=self.capped_max,\n size=self.capped_size)\n except OperationFailure:\n # Capped collection exists, so get it.\n self.collection = self.db[self.collection_name]\n else:\n self.collection = self.db[self.collection_name]","def test_connection_duplication():","def make_connection(self):\n if self._created_connections() >= self.max_connections:\n raise ConnPoolException(\"Too many connections.\")\n connection = self.connection_class(**self.connection_kwargs)\n connection.connect()\n return connection","def _get_cached_db_connection(name='ace'):\n if name is None:\n name = 'ace'\n\n config_section = 'database_{}'.format(name)\n\n if config_section not in saq.CONFIG:\n raise ValueError(\"invalid database {}\".format(name))\n\n try:\n db_identifier = _get_cached_db_identifier(name)\n with _global_db_cache_lock:\n logging.debug(\"aquiring existing cached database connection {}\".format(db_identifier))\n db = _global_db_cache[db_identifier]\n\n try:\n db.rollback()\n #logging.debug(\"acquired cached database connection to {}\".format(name))\n return db\n\n except Exception as e:\n logging.info(\"possibly lost cached connection to database {}: {} ({})\".format(name, e, type(e)))\n try:\n db.close()\n except Exception as e:\n logging.error(\"unable to close cached database connection to {}: {}\".format(name, e))\n\n try:\n with _global_db_cache_lock:\n del _global_db_cache[db_identifier]\n except Exception as e:\n logging.error(\"unable to delete cached db {}: {}\".format(db_identifier, e))\n\n #return _get_db_connection(name)\n\n except KeyError:\n pass\n\n try:\n logging.info(\"opening new cached database connection to {}\".format(name))\n\n with _global_db_cache_lock:\n _global_db_cache[db_identifier] = _get_db_connection(name)\n\n logging.debug(\"opened cached database connection {}\".format(db_identifier))\n return _global_db_cache[db_identifier]\n\n except Exception as e:\n logging.error(\"unable to connect to database {}: {}\".format(name, e))\n report_exception()\n raise e","def __enter__(self):\n fp = os.path.abspath(self.db_name)\n if self.read_only:\n self.conn = sqlite3.connect('file:/{}?mode=ro'.format(fp), uri=True)\n else:\n self.conn = sqlite3.connect(fp)\n return self.conn","def create_connection():\r\n try:\r\n conn = sq.connect(DBClass.db_name)\r\n except sq.Error as e:\r\n raise e\r\n \r\n return conn","def new_connection(name, user, password, host=None, database=None):\n if QtSql.QSqlDatabase.database(name).open():\n db = QtSql.QSqlDatabase.database(name)\n return db, True\n else:\n if host is None or database is None:\n host, database = read_settings(name)\n db = QtSql.QSqlDatabase.addDatabase(\"QMYSQL\", name)\n db.setUserName(user)\n db.setHostName(host)\n db.setDatabaseName(database)\n db.setPassword(password)\n if db.open():\n dbt = threading.Timer(600, close_connection, args=[name])\n dbt.start()\n return db, True\n else:\n db_err(db)\n return None, False","def __enter__(self) -> cx_Oracle.connect:\n self.db_connection = cx_Oracle.connect(\n self.config['oracle']['ora_user'],\n self.config['oracle']['ora_pass'],\n f\"{self.config['oracle']['ora_host']}/{self.config['oracle']['ora_sid']}\")\n return self.db_connection","def reconnect(self):\n self.conn.close()\n self.conn = sqlite3.connect(self.db_file, check_same_thread=False)\n self.conn.row_factory = DB.namedtuple_factory\n # self.conn.row_factory = DB.dict_factory","def connect(self):\n if self.connection is not None:\n logger.info(\" connection: %s \" % (self.connection is not None))\n if not self.connection.opened():\n logger.info(\"connection is closed\")\n return self.reconect()\n\n if self.connection.opened():\n return self.connection\n try:\n self.connection = connect(**self.options)\n except Exception as e:\n logger.critical(\"Unable to connect to DB: {0}\".format(e.message))\n raise\n\n return self.connection","def connect(self):\n if self.connection:\n if self.connection_load_balance or self.connection.closed():\n self.log.debug(\"Recreate the connection\")\n self.connection.close()\n self.connection = vertica.connect(**exclude_undefined_keys(self.options))\n else:\n self.connection = vertica.connect(**exclude_undefined_keys(self.options))\n\n return self.connection","def _get_connection(self) -> Connection:\n # TODO(101) is there a problem with having just one db connection?\n # Will this cause bugs with failed commits?\n curr_thread = threading.get_ident()\n if curr_thread not in self.conn or self.conn[curr_thread] is None:\n try:\n conn = sqlite3.connect(self.db_path)\n conn.row_factory = StringIDRow\n self.conn[curr_thread] = conn\n except sqlite3.Error as e:\n raise MephistoDBException(e)\n return self.conn[curr_thread]","def get_new_connection(self, conn_params):\r\n self.__connection_string = conn_params.get('connection_string', '')\r\n conn = Database.connect(**conn_params)\r\n return conn","def __enter__(self):\n self.conn = sqlite3.connect(self.db_name)\n return self.conn","def reconnect(self):\n # This is the old connection IOLoop instance, stop its ioloop\n self._connection.ioloop.stop()\n\n if not self._closing:\n # Create a new connection\n self._connection = self.connect()\n # There is now a new connection, needs a new ioloop to run\n self._connection.ioloop.start()","def reconnect(self):\n # This is the old connection IOLoop instance, stop its ioloop\n self._connection.ioloop.stop()\n\n if not self._closing:\n # Create a new connection\n self._connection = self.connect()\n\n # There is now a new connection, needs a new ioloop to run\n self._connection.ioloop.start()","def reconnect(self):\n self.close()\n self._db = self._pool.get_connection()","def get_connection(self):\n # self.class_logger.info(\"Try to get connection...\")\n for i in range(1, self.retry_count + 1):\n\n if len(self._available_connections) > 0:\n connection, last_time = self._available_connections.pop()\n if (last_time + self.time_to_live) < time.time():\n try:\n self.class_logger.debug(\"Time to leave is exceeded. Destroy connection and try to make new one.\")\n connection.disconnect()\n except Exception as err:\n self.class_logger.warning(\"Error occurred while disconnecting connection: %s\" % (err, ))\n finally:\n del connection\n\n # If connection is not created/got on previous step\n if \"connection\" not in locals():\n self.class_logger.debug(\"Connection is not available. Making one...\")\n try:\n connection = self.make_connection()\n self.class_logger.debug(\"...completed.\")\n except Exception as err:\n self.class_logger.debug(\"...failed: %s.\" % (err, ))\n\n try:\n if \"connection\" in locals():\n if not connection.check_connection():\n raise ConnPoolException(\"Connection is dead.\")\n self._in_use_connections.add(connection)\n self.class_logger.debug(\"Connection check passed.\")\n return connection\n\n except Exception as err:\n self.class_logger.warning(\"Error occurred: %s\" % (err, ))\n try:\n self.class_logger.debug(\"Deleting connection since it's not OK...\")\n # self.del_connection_in_use(connection)\n connection.disconnect()\n self.class_logger.debug(\"...Deletion succeeded.\")\n except Exception as err:\n self.class_logger.warning(\"Broken connection deletion failed: %s.\" % (err, ))\n\n sleep_time = i ** 2\n self.class_logger.debug(\"Connection check failed. Sleeping for %s secs before retry.\" % (sleep_time, ))\n time.sleep(sleep_time)\n\n message = \"ERROR: Cannot create connection after %s attempts.\" % (self.retry_count, )\n self.class_logger.error(message)\n raise ConnPoolException(message)","def _unthreadsafe_get_connection(self):\n return PooledDBConnection(self, self._queue.get())","def newConn():\n g = sql.connect('user.db')\n e = g.cursor()\n return {\n \"close\": g.close,\n \"commit\": g.commit,\n \"cursor\": e\n }","def __init__(self):\r\n self.conn = create_connection(DATABASE_PATH)","def real_conn(self) -> Connection:\n return self._real_conn","def _create_new_socket(self):\n sock = socket()\n sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, True)\n return sock","def create_temp_connection() -> sqlite3.Connection:\n database = Path(calc_path)\n conn = __check_existence(database)\n with conn:\n return conn","def __getattr__(self, name):\n return self.connection(name)","def _GetNewConnection(self):\n l_logger.debug(\"Creating a db connection\")\n return mdb.connect(host=self.host,\n user=self.user, \n password=self.passwd, \n database=self.db_name,\n port=self.port\n )","def before_request():\n engine = cache['engine']\n try:\n g.conn = engine.connect()\n except:\n print \"error creating temporary connection to the db\"\n import traceback; traceback.print_exc()\n g.conn = None","def _get_connection(self) -> sqlite3.Connection:\n curr_thread = threading.get_ident()\n if curr_thread not in self.conn or self.conn[curr_thread] is None:\n conn = sqlite3.connect(self.db_path, check_same_thread=False)\n conn.row_factory = sqlite3.Row\n self.conn[curr_thread] = conn\n return self.conn[curr_thread]","def __make_connection(self):\n return self.euca.make_connection()","def _create_connection(self):\n if not self.connection:\n log.info(\"{}: Creating connection with address={}\".format(\n self.container_id, self.address.geturl()))\n self.connection = Connection(\n self.address.hostname,\n self.auth,\n container_id=self.container_id,\n properties=self._create_properties(),\n debug=self.debug)","def establish_connection(self):\n conninfo = self.client\n for name, default_value in items(self.default_connection_params):\n if not getattr(conninfo, name, None):\n setattr(conninfo, name, default_value)\n if conninfo.hostname == 'localhost':\n conninfo.hostname = '127.0.0.1'\n conn = self.Connection(host=conninfo.host,\n userid=conninfo.userid,\n password=conninfo.password,\n login_method=conninfo.login_method,\n virtual_host=conninfo.virtual_host,\n insist=conninfo.insist,\n ssl=conninfo.ssl,\n connect_timeout=conninfo.connect_timeout)\n conn.client = self.client\n return conn","def _connect(self):\n try: \n self.r = redis.StrictRedis(host=self.host, port=self.port, db=self.db)\n except:\n raise","def renew_connection(self, timeout=45):\n self.new_connection(timeout=timeout)","def get_connection(self, *args, **kwargs):\n conn = super(SSLHTTPAdapter, self).get_connection(*args, **kwargs)\n if conn.assert_hostname != self.assert_hostname:\n conn.assert_hostname = self.assert_hostname\n return conn","def _connect(self):\n self.connection = RedisConnection(self.host, self.port, self.dbname)","def _get_connection(reconnect=False):\n global _connection\n identity = get_identity()\n # Connect to the database if not already connected\n if _connection.get(identity) is None or reconnect:\n try:\n _connection[identity] = Connection(**_connection_settings)\n except Exception, e:\n raise ConnectionError(\"Cannot connect to the database:\\n%s\" % e)\n return _connection[identity]","def getconn(self):\n #hdbport = int('3%s15' % Settings.hdbinstancenum)\n con = dbapi.connect(address = self.host, \\\n port = self.port, \\\n user = self.username, \\\n password = self.password, \\\n autocommit = True)\n if self.schema:\n cur = con.cursor()\n try:\n cur.execute('ALTER SESSION SET CURRENT_SCHEMA = %s' % self.schema)\n return con\n except dbapi.Error, err:\n cur.close()\n con.close()\n cur = None\n raise err\n finally:\n if cur:\n cur.close()\n else:\n return con","def create_master_connection(self):\n self.cwd = os.getcwd()\n self.pullerdir = self.cwd + \"\\\\Puller Data\\\\\"\n self.inputloc = self.pullerdir + self.iteration_input\n try:\n self.conn_master = sqlite3.connect(self.inputloc)\n return self.conn_master\n except Error as e:\n print(e)\n\n return None","def _db_connection(self):\n pass","def make_connection(self):\n if self._created_connections[self._pattern_idx] >= self.max_connections_per_pattern:\n raise ConnectionError(\"Too many connections\")\n self._created_connections[self._pattern_idx] += 1\n conn = self.connection_class(**self.patterns[self._pattern_idx])\n conn._pattern_idx = self._pattern_idx\n return conn","def _get_db_connection(name='ace'):\n\n if name is None:\n name = 'ace'\n\n #if _cached_db_connections_enabled():\n #return _get_cached_db_connection(name)\n\n config_section = 'ace'\n if name:\n config_section = 'database_{}'.format(name)\n\n if config_section not in saq.CONFIG:\n raise ValueError(\"invalid database {}\".format(name))\n\n _section = saq.CONFIG[config_section]\n kwargs = {\n 'db': _section['database'],\n 'user': _section['username'],\n 'passwd': _section['password'],\n 'charset': 'utf8'\n }\n\n if 'hostname' in _section:\n kwargs['host'] = _section['hostname']\n\n if 'port' in _section:\n kwargs['port'] = _section.getint('port')\n \n if 'unix_socket' in _section:\n kwargs['unix_socket'] = _section['unix_socket']\n\n if 'ssl_ca' in _section or 'ssl_key' in _section or 'ssl_cert' in _section:\n kwargs['ssl'] = {}\n\n if 'ssl_ca' in _section and _section['ssl_ca']:\n path = abs_path(_section['ssl_ca'])\n if not os.path.exists(path):\n logging.error(\"ssl_ca file {} does not exist (specified in {})\".format(path, config_section))\n else:\n kwargs['ssl']['ca'] = path\n\n if 'ssl_key' in _section and _section['ssl_key']:\n path = abs_path(_section['ssl_key'])\n if not os.path.exists(path):\n logging.error(\"ssl_key file {} does not exist (specified in {})\".format(path, config_section))\n else:\n kwargs['ssl']['key'] = path\n\n if 'ssl_cert' in _section and _section['ssl_cert']:\n path = _section['ssl_cert']\n if not os.path.exists(path):\n logging.error(\"ssl_cert file {} does not exist (specified in {})\".format(path, config_section))\n else:\n kwargs['ssl']['cert'] = path\n\n logging.debug(\"opening database connection {}\".format(name))\n return pymysql.connect(**kwargs)\n #return pymysql.connect(host=_section['hostname'] if 'hostname' in _section else None,\n #port=3306 if 'port' not in _section else _section.getint('port'),\n #unix_socket=_section['unix_socket'] if 'unix_socket' in _section else None,\n #db=_section['database'],\n #user=_section['username'],\n #passwd=_section['password'],\n #charset='utf8')","def __make_connection(self, path):\n try:\n connection = sqlite3.connect(path)\n return connection\n except sqlite3.Error as e:\n pass\n return None","def __get_open_connection(self, connection_hash):\n db = MySQLdb.connect(\n host=connection_hash[\"host\"],\n user=connection_hash[\"user\"],\n passwd=connection_hash[\"password\"],\n db=connection_hash[\"dbname\"]\n )\n return db","def find(self, host, auth):\n key = (host, auth)\n if key not in self.conns:\n conn = None\n hooks = self._conn_hooks or self._default_hooks\n for hook in hooks:\n conn = hook.connect(host, auth)\n if conn:\n logger.info(\"Established new connection to '%s' via '%s'\" %\n (host, hook))\n break\n if conn is None:\n raise ConnectionError(\n 'Failed to establish a connection to %s' % host)\n self.add(host, auth, conn)\n else:\n conn = self.conns[key]\n logger.debug(\"Reusing existing connection to '%s'\" % (host))\n return conn","def get(self, conn_alias: str) -> \"BaseDBAsyncClient\":\n storage: Dict[str, \"BaseDBAsyncClient\"] = self._get_storage()\n try:\n return storage[conn_alias]\n except KeyError:\n connection: BaseDBAsyncClient = self._create_connection(conn_alias)\n storage[conn_alias] = connection\n return connection","def get_conn(cls):\n\n if not cls.conn or not cls.conn.open:\n cls.connect()\n\n try:\n cls.conn.ping() # ping to test if the current conn is working\n except MySQLdb.OperationalError:\n cls.connect()\n\n return cls.conn","def _threadsafe_return_connection(self, con):\n # we don't need to do anything here","def _threadsafe_get_connection(self):\n with self._lock:\n next_con = self._nextConnection\n con = PooledDBConnection(self, self._connections[next_con])\n next_con += 1\n if next_con >= len(self._connections):\n next_con = 0\n self._nextConnection = next_con\n return con","def reconnect(self):\n self.close()\n self._db = pymysql.connect(**self._db_args)","def create_connection():\n try:\n with open('connection_string', 'rt') as f:\n connection_string = f.read()\n conn = connect(connection_string)\n print(\"Conn : \", conn)\n return conn\n except Error as e:\n print(e)\n\n return None","def __get_lucene_connection(self, reuse=True):\n if not self.__lucene_connection or not reuse:\n if self.__lucene_connection:\n self.__lucene_connection.close()\n\n self.__lucene_connection = http.client.HTTPConnection(self.__LUCENE_HOST,\n port=self.__LUCENE_PORT,\n timeout=self.__TIMEOUT)\n\n return self.__lucene_connection","def _get_pool(self, *args, **kwargs):\n\n pool_name = '_pool_%s' % getattr(self, 'alias', 'common')\n\n if not hasattr (self.__class__, pool_name):\n lock = thread.allocate_lock()\n lock.acquire()\n\n try:\n pool = cx_Oracle.SessionPool(\n user=self.user,\n password=self.password,\n dsn=self.tns,\n min=CX_POOL_SESSION_MIN,\n max=CX_POOL_SESSION_MAX,\n increment=CX_POOL_SESSION_INCREMENT,\n connectiontype=cx_Oracle.Connection,\n threaded=CX_POOL_THREADED,\n getmode=cx_Oracle.SPOOL_ATTRVAL_NOWAIT,\n homogeneous=True)\n except Exception as err:\n pool = None\n\n if pool:\n pool.timeout = CX_POOL_CONNECT_TIMEOUT\n setattr(self.__class__, pool_name, pool)\n else:\n msg = \"\"\" ### Database login failed or database not found ### \"\"\"\n raise self.Database_Error, ('%s') %(msg)\n\n lock.release()\n\n return getattr(self.__class__, pool_name)","def __call__(self, account, db_name=None, pool_recycle=None):\n assert account and db_name,\"Must provide an account and a db\"\n pool_recycle = pool_recycle or 3600\n if account not in self._db_account.get(db_name, []):\n if db_name == \"PARENT\":\n engine = MySQLdb.connect(host=account.host, user=account.user,\n passwd=account.passwd, port=account.port)\n else:\n engine = sql.create_engine(\"mysql://%s/%s\" % (account, \n db_name), pool_recycle=pool_recycle)\n if db_name not in self._db_account:\n self._db_account[db_name] = {}\n self._db_account[db_name][account] = engine\n return self._db_account[db_name][account]","def reconnect(self):\n raise NotImplementedError()","def open_connection(self):\n self.conn = pymysql.connect(host=self.host, user=self.user, passwd=self.passwd, db=self.db)","def create_connection(self) -> None:\n try:\n self.create_folder(self.folder_config)\n self.connection = sqlite3.connect(self.name_db, check_same_thread=False)\n self.cursor = self.connection.cursor()\n except Exception as e:\n msg = f'We faced problems with the connection. Reason: {e}'\n self.proceed_error(msg)","def with_connection(func):\n def wrapped(self,*args,**kwargs):\n if self.connection is None:\n try:\n self.connection = self.connect()\n self.cursor = self.connection.cursor()\n except Exception as error:\n self.cursor = None\n logger.warn(str(error))\n else:\n self.connection.ping(True)\n func(self,*args,**kwargs)\n return wrapped","def connect(self,schema_name = ''):\n\t\tif schema_name == '':\n\t\t\tif self.__schema_name=='':\n\t\t\t\tprint('Specify name of the schema/db first')\n\t\t\t\treturn\n\t\t\telse:\n\t\t\t\tprint('Use the previous schema_name %s'%self.__schema_name)\n\t\telse:\n\t\t\tif self.__schema_name == schema_name:\n\t\t\t\t\tprint('Seem to be the same engine')\n\t\t\tself.__schema_name = schema_name\n\t\t\t\n\t\tif self.connected:\n\t\t\tself.close()\n\t\ttry:\n#\t\t\t self.__db = pymysql.connect(host = \"rm-j6cluj4576jdi6n6oo.mysql.rds.aliyuncs.com\",\\\n#\t\t\t\t\t\t\t\t database = schema_name, user='cognitiveleap', password= 'QWE@123456')\n\t\t\t#self.__cursor = self.__db.cursor()\n\t\t\tself.__engine = create_engine(\"mysql+pymysql://cognitiveleap:QWE@123456@rm-j6cluj4576jdi6n6oo.mysql.rds.aliyuncs.com/%s\"%self.__schema_name)\n\t\texcept Exception as e:\n\t\t\traise Exception (3)\n\t\tself.connected = True","def expand(self):\n try:\n self.create_connection()\n except Exception as excpt:\n print(excpt)","def as_dummy_conn(self) -> DummyPgConn:\n return DummyPgConn(self._conn, self._lock, self._transaction_lock)","def _create_connection(self):\r\n if not self._hosts:\r\n raise CQLConnectionError(\"At least one host required\")\r\n\r\n hosts = copy(self._hosts)\r\n random.shuffle(hosts)\r\n\r\n for host in hosts:\r\n try:\r\n transport = self._create_transport(host)\r\n new_conn = cql.connect(\r\n host.name,\r\n host.port,\r\n user=self._username,\r\n password=self._password,\r\n consistency_level=self._consistency,\r\n transport=transport\r\n )\r\n new_conn.set_cql_version('3.0.0')\r\n return new_conn\r\n except Exception as exc:\r\n logging.debug(\"Could not establish connection to\"\r\n \" {}:{} ({!r})\".format(host.name, host.port, exc))\r\n\r\n raise CQLConnectionError(\"Could not connect to any server in cluster\")","def __create_connection():\n connection = None\n try:\n connection = sqlite3.connect(Database.filepath)\n return connection\n except Error as e:\n print(e)\n\n return connection","def __getitem__(self, name):\n return self.connection(name)","def open_connection(self, connection):\n pass","def newconnection(self, path):\n conn = sqlite3.connect(path)\n return conn","def __init__(self,schema_name = 'null'):\n\t\tself.connected = False\n\t\tself.__schema_name = ''\n\t\tself.__db = ''\n\t\tself.__cursor = ''\n\t\tself.__engine = ''\n\t\tif schema_name != 'null':\n\t\t\tself.connect(schema_name)","def __enter__(self):\n return self.connection.__enter__","def connect(self):\n if self.connection is not None:\n logger.info(\" connection: %s \" % (self.connection is not None))\n return self.connection\n try:\n self.connection = DataPostgres.connect(**self.options)\n except Exception as e:\n logger.critical(\"Unable to connect to DB: {0}\".format(e.message))\n raise\n\n return self.connection","def __enter__(self) -> \"Connection\":\n\n if (not self.connected):\n self.connect()\n \n return self","def connect_to_database(self, database_name):\n\n original_config = self.config['mysql'][database_name]\n\n db_config = dict()\n db_config['host'] = original_config['host']\n db_config['user'] = original_config['user']\n db_config['db'] = original_config['db']\n db_config['password'] = original_config['password']\n db_config['charset'] = 'utf8mb4'\n db_config['cursorclass'] = pymysql.cursors.DictCursor\n\n new_connection = pymysql.connect(**db_config)\n\n self.connections[database_name] = new_connection\n return new_connection","def db_connection():\n global dbconnection\n try:\n conn = dbconnection\n except:\n dbconnection = psycopg2.connect(user = dbuser,\n password = dbpass,\n host = dbserver,\n port = \"5432\",\n database = dbname)\n conn = dbconnection\n return conn","def connect(name='tstp'):\n global DB_HANDLE\n try:\n if not name in DB_HANDLES:\n db = DBS[name]\n DB_HANDLES[name] = sql.connect(\n host=db['host'],\n user=db['user'],\n passwd=db['password'],\n db=db['db'],\n use_unicode=True,\n charset=\"utf8\",\n )\n except Exception as ex:\n log.error(\"ERROR: Unable to connect to \\\"%s\\\":\\n%s\" % (name, str(ex)))\n raise ex\n DB_HANDLE = DB_HANDLES[name]","def __init__(self):\n self._connection = get_db_connection()","def set_connection(self, **kwargs):\n if self.schema is None:\n self.conn = psycopg2.connect(\n host=self.host,\n port=self.port,\n user=self.user,\n password=self.password,\n dbname=self.db_name,\n **self.kwargs)\n else:\n self.conn = psycopg2.connect(\n host=self.host,\n port=self.port,\n user=self.user,\n password=self.password,\n dbname=self.db_name,\n options=f'--search_path={self.schema}',\n **self.kwargs)","def __get_connection():\n # 根据配置文件创建连接池\n if not Mysql.__mysql_pool:\n Mysql.__mysql_pool = PooledDB(\n creator=MySQLdb,\n use_unicode=False,\n cursorclass=DictCursor,\n db=sqlconf.MysqlConfig['db'],\n host=sqlconf.MysqlConfig['host'],\n port=sqlconf.MysqlConfig['port'],\n user=sqlconf.MysqlConfig['user'],\n passwd=sqlconf.MysqlConfig['passwd'],\n charset=sqlconf.MysqlConfig['charset'],\n mincached=sqlconf.MysqlConfig['mincached'],\n maxcached=sqlconf.MysqlConfig['maxcached'],\n maxconnections=sqlconf.MysqlConfig['maxconnections'])\n # 返回连接池中连接对象\n return Mysql.__mysql_pool.connection()","def create_connection(self):\r\n dbname = \"dbname = \"+\"'\"+self.dbname+\"' \"\r\n user = \"user = \"+\"'\"+self.user+\"' \"\r\n host = \"host = \"+\"'\"+self.host+\"' \"\r\n password = \"password = \"+\"'\"+self.password+\"' \"\r\n connection_info = dbname + user + host + password\r\n try:\r\n conn = psycopg2.connect(connection_info)\r\n except psycopg2.Error:\r\n print(\"Unable to connect to DB\")\r\n return conn","def __connect(host):\n global pg_pool\n pg_config['host'] = host\n pg_pool = SimpleConnectionPool(1, 1, **pg_config)","def acquire_direct(self, address):\n if self.closed():\n raise ServiceUnavailable(\"Connection pool closed\")\n with self.lock:\n try:\n connections = self.connections[address]\n except KeyError:\n connections = self.connections[address] = deque()\n\n connection_acquisition_start_timestamp = perf_counter()\n while True:\n # try to find a free connection in pool\n for connection in list(connections):\n if connection.closed() or connection.defunct() or connection.timedout():\n connections.remove(connection)\n continue\n if not connection.in_use:\n connection.in_use = True\n return connection\n # all connections in pool are in-use\n can_create_new_connection = self._max_connection_pool_size == INFINITE or len(connections) < self._max_connection_pool_size\n if can_create_new_connection:\n try:\n connection = self.connector(address, self.connection_error_handler)\n except ServiceUnavailable:\n self.remove(address)\n raise\n else:\n connection.pool = self\n connection.in_use = True\n connections.append(connection)\n return connection\n\n # failed to obtain a connection from pool because the pool is full and no free connection in the pool\n span_timeout = self._connection_acquisition_timeout - (perf_counter() - connection_acquisition_start_timestamp)\n if span_timeout > 0:\n self.cond.wait(span_timeout)\n # if timed out, then we throw error. This time computation is needed, as with python 2.7, we cannot\n # tell if the condition is notified or timed out when we come to this line\n if self._connection_acquisition_timeout <= (perf_counter() - connection_acquisition_start_timestamp):\n raise ClientError(\"Failed to obtain a connection from pool within {!r}s\".format(\n self._connection_acquisition_timeout))\n else:\n raise ClientError(\"Failed to obtain a connection from pool within {!r}s\".format(self._connection_acquisition_timeout))","def create_connection(self, *args_to_use, **kwargs_to_use):\n return pysftp.Connection(*args_to_use, **kwargs_to_use)","def __connect_to_database(self, database_name: str) -> sqlite3.Connection:\n conn = sqlite3.connect(database_name)\n conn.row_factory = sqlite3.Row\n\n return conn","def set_connection(self, service_name, to_cache):\n self.services.setdefault(service_name, {})\n self.services[service_name]['connection'] = to_cache","def nopool(self, *args, **kwargs):\n nopool = None\n try:\n nopool = cx_Oracle.connect('{0}/{1}@{2}'.format(self.user, self.password, self.tns))\n except cx_Oracle.DatabaseError, exception:\n error, = exception\n\n # Check if code return (ORA-12154 TNS:could not resolve the connect identifier specified)\n tns_notresolve = 12154\n\n if error.code == tns_notresolve:\n raise self.Database_Error, ('%s More details http://ora-%s.ora-code.com/' %(error.message, error.code) )\n else:\n raise self.Database_Error, ('%s More details http://ora-%s.ora-code.com/' %(error.message, error.code) )\n\n return nopool","def __enter__(self):\n self.connection = MongoClient(self.host, self.port)\n return self","def __enter__(self) -> sqlite3.Connection:\n self.conn = sqlite3.connect(self.path_db)\n return self.conn","def connect_to_database(name, settings):\n if name == 'mongodb':\n import models.mongodb\n database = models.mongodb.Database(settings)\n if database.check_connection():\n return database\n else:\n name = 'memory'\n\n if name == 'memory':\n import models.memory\n database = models.memory.Database(settings)\n return database\n\n raise ValueError('Unknown database.')","def alter_connection(self, conn, new_conn):\n conn = copy.copy(self.parser.comms[new_conn])\n return conn","def _get_outer_connection(self):\n if self._data['data_fetch_method'] == 'sql':\n if not self._data['source_database_connection_id']:\n raise Exception(\"No source_database_connection_id specified\")\n res = self._db.Query(\"\"\"SELECT source_database_connection.*, jdbc_driver.current_time_sql_stmt\n FROM source_database_connection\n LEFT JOIN jdbc_driver ON jdbc_driver.jdbc_driver_id = source_database_connection.jdbc_driver_id \n WHERE \n `source_database_connection_id`=%s\"\"\",(self._data['source_database_connection_id']))\n if not res:\n raise Exception(\"No source database record for source_database_connection_id=%s\", (self._data['source_database_connection_id']))\n outer_connection = self._db.record[0]\n conn = JCollectorConn(outer_connection)\n return conn\n\n elif self._data['data_fetch_method'] == 'web service':\n res = self._db.Query(\"\"\"SELECT web_service_credentials.*\n FROM web_service_credentials\n WHERE\n `web_service_credentials_id`=%s\"\"\",(self._data['web_service_credentials_id']))\n if not res:\n raise Exception(\"no source web service record\")\n self.web_service = self._db.record[0]\n self.web_service['url'] = self._data['data_fetch_command']\n conn = WebServiceConn(self.web_service)\n return conn\n\n return False","def monkeypatch_connections(self):\n \n def create_test_db(self, verbosity=1, autoclobber=False):\n \"\"\"\n Creates a test database, prompting the user for confirmation if the\n database already exists. Returns the name of the test database created.\n \"\"\"\n # Don't import django.core.management if it isn't needed.\n test_database_name = self._get_test_db_name()\n \n if self.connection.settings_dict.get('ENGINE', '').endswith('.sqlite3')\\\n and test_database_name != ':memory:':\n if os.access(test_database_name, os.F_OK):\n print \"sqlite test database found !\"\n \n #self._create_test_db(verbosity, autoclobber)\n \n self.connection.close()\n self.connection.settings_dict[\"NAME\"] = test_database_name\n \n # Confirm the feature set of the test database\n self.connection.features.confirm()\n \n # Get a cursor (even though we don't need one yet). This has\n # the side effect of initializing the test database.\n self.connection.cursor()\n\n return test_database_name\n \n def destroy_test_db(self, old_database_name, verbosity=1):\n \"\"\"\n Destroy a test database, prompting the user for confirmation if the\n database already exists.\n \"\"\"\n self.connection.close()\n test_database_name = self.connection.settings_dict['NAME']\n if verbosity >= 1:\n test_db_repr = ''\n if verbosity >= 2:\n test_db_repr = \" ('%s')\" % test_database_name\n print \"Ignore the test database for alias '%s'%s...\" % (\n self.connection.alias, test_db_repr)\n \n # Temporarily use a new connection and a copy of the settings dict.\n # This prevents the production database from being exposed to potential\n # child threads while (or after) the test database is destroyed.\n # Refs #10868 and #17786.\n settings_dict = self.connection.settings_dict.copy()\n settings_dict['NAME'] = old_database_name \n \n def _destroy_test_db(self, test_database_name, verbosity):\n print \"Keep the test database !\" #%test_database_name\n self.connection.close()\n \n \n for alias in connections:\n \"\"\"\n django.test.simple.DjangoTestSuiteRunner\n django.db.backends.creation\n django.db.backends.mysql.base\n \"\"\"\n connection = connections[alias]\n #if connection.settings_dict.get('ENGINE', '').endswith('.sqlite3'):\n \n if not self.options['setupdbs']:\n f1 = types.MethodType(create_test_db, connection.creation, DatabaseCreation)\n connection.creation.create_test_db = f1\n \n if not self.options['teardowndbs']:\n f2 = types.MethodType(destroy_test_db, connection.creation, DatabaseCreation)\n connection.creation.destroy_test_db = f2","def __connect(self):\n session, metadata, connection = db(dbhost=getattr(self, \"host\"),\n dbuser=getattr(self, \"user\"),\n dbpass=getattr(self, \"password\"),\n dbname=getattr(self, \"dbname\"))\n return session, metadata, connection","def create_connection(self):\r\n\r\n try:\r\n self.conn = sqlite3.connect(self.database_name)\r\n\r\n except sqlite3.Error:\r\n print('Error connecting to database')","def conn(self):\n if self._sentinel:\n return self._sentinel.master_for(self._sentinel_name)\n if not self._conn:\n self._conn = self.__redis_mod.StrictRedis(\n host=self._host, port=self._port, **self._conn_kwargs\n )\n return self._conn","def _get_connection(self, conf):\n return get_session()","def create_connection(db_file):\n conn = None\n try:\n conn = connect(db_file)\n except Error as e:\n print(e)\n\n return conn","def get_connection(self, params):\r\n return Redis(connection_pool=self.get_or_create_connection_pool(params))","def get_connection(self, settings):\n\n def set_mysqlx_wait_timeout(cnx):\n ver = cnx.sql(_SELECT_VERSION_QUERY).execute().fetch_all()[0][0]\n # mysqlx_wait_timeout is only available on MySQL 8\n if tuple(int(n) for n in ver.split(\"-\")[0].split(\".\")) > (\n 8,\n 0,\n 10,\n ):\n cnx.sql(f\"set mysqlx_wait_timeout = {pool.max_idle_time}\").execute()\n\n pools = self._get_pools(settings)\n cur_priority = settings.get(\"cur_priority\", None)\n error_list = []\n self._check_unavailable_pools(settings)\n cur_priority = self._get_next_priority(pools, cur_priority)\n if cur_priority is None:\n raise PoolError(\n \"Unable to connect to any of the target hosts. No pool is available\"\n )\n settings[\"cur_priority\"] = cur_priority\n pool = self._get_next_pool(pools, cur_priority)\n lock = threading.RLock()\n while pool is not None:\n try:\n # Check connections aviability in this pool\n if pool.qsize() > 0:\n # We have connections in pool, try to return a working one\n with lock:\n try:\n cnx = pool.get(block=True, timeout=pool.queue_timeout)\n except queue.Empty:\n raise PoolError(\n \"Failed getting connection; pool exhausted\"\n ) from None\n try:\n if cnx.is_server_disconnected():\n pool.remove_connections()\n # Only reset the connection by re-authentification\n # if the connection was unable to keep open by the\n # server\n if not cnx.keep_open:\n cnx.reset()\n set_mysqlx_wait_timeout(cnx)\n except (RuntimeError, OSError, InterfaceError):\n # Unable to reset connection, close and remove\n try:\n cnx.close_connection()\n except (RuntimeError, OSError, InterfaceError):\n pass\n finally:\n pool.remove_connection(cnx)\n # By WL#13222 all idle sessions that connect to the\n # same endpoint should be removed from the pool.\n while pool.qsize() > 0:\n try:\n cnx = pool.get(\n block=True, timeout=pool.queue_timeout\n )\n except queue.Empty:\n pass\n else:\n try:\n cnx.close_connection()\n except (RuntimeError, OSError, InterfaceError):\n pass\n finally:\n pool.remove_connection(cnx)\n # Connection was closed by the server, create new\n try:\n cnx = PooledConnection(pool)\n pool.track_connection(cnx)\n cnx.connect()\n set_mysqlx_wait_timeout(cnx)\n except (RuntimeError, OSError, InterfaceError):\n pass\n finally:\n # Server must be down, take down idle\n # connections from this pool\n while pool.qsize() > 0:\n try:\n cnx = pool.get(\n block=True,\n timeout=pool.queue_timeout,\n )\n cnx.close_connection()\n pool.remove_connection(cnx)\n except (RuntimeError, OSError, InterfaceError):\n pass\n return cnx\n elif pool.open_connections < pool.pool_max_size:\n # No connections in pool, but we can open a new one\n cnx = PooledConnection(pool)\n pool.track_connection(cnx)\n cnx.connect()\n set_mysqlx_wait_timeout(cnx)\n return cnx\n else:\n # Pool is exaust so the client needs to wait\n with lock:\n try:\n cnx = pool.get(block=True, timeout=pool.queue_timeout)\n cnx.reset()\n set_mysqlx_wait_timeout(cnx)\n return cnx\n except queue.Empty:\n raise PoolError(\"pool max size has been reached\") from None\n except (InterfaceError, TimeoutError, PoolError) as err:\n error_list.append(f\"pool: {pool} error: {err}\")\n if isinstance(err, PoolError):\n # Pool can be exhaust now but can be ready again in no time,\n # e.g a connection is returned to the pool.\n pool.set_unavailable(2)\n else:\n self.set_pool_unavailable(pool, err)\n\n self._check_unavailable_pools(settings)\n # Try next pool with the same priority\n pool = self._get_next_pool(pools, cur_priority)\n\n if pool is None:\n cur_priority = self._get_next_priority(pools, cur_priority)\n settings[\"cur_priority\"] = cur_priority\n pool = self._get_next_pool(pools, cur_priority)\n if pool is None:\n msg = \"\\n \".join(error_list)\n raise PoolError(\n \"Unable to connect to any of the target hosts: \"\n f\"[\\n {msg}\\n]\"\n ) from err\n continue\n\n raise PoolError(\"Unable to connect to any of the target hosts\")","def new_connection(self, transport):\n assert transport not in self.clients\n self.clients[transport] = Client(transport, self)"],"string":"[\n \"def __get_database_connection(self, reuse=True):\\n if not self.__database_connection or not reuse:\\n if self.__database_connection:\\n self.__database_connection.close()\\n self.__database_connection = None\\n\\n self.__database_connection = http.client.HTTPConnection(self.__DATABASE_HOST,\\n port=self.__DATABASE_PORT,\\n timeout=self.__TIMEOUT)\\n\\n return self.__database_connection\",\n \"def create_connection(self, db_name=None, raw=False):\\n connected = False\\n max_tries = 10\\n\\n # if db_name is not defined, let it be empty string\\n if db_name is None:\\n db_name = \\\"\\\"\\n\\n # Reconnect until max_tries exceeded\\n while not connected and max_tries > 0:\\n try:\\n # create engine from db settings\\n engine = self.get_engine(db_name)\\n\\n # Create connection for query\\n connection = engine.connect() if raw == False else engine.raw_connection()\\n\\n connected = True\\n\\n return engine, connection\\n except Exception as e:\\n print(\\\"Database Connection Error: {}\\\".format(e))\\n print(\\\"Network is unreachable. Retrying to connect to database in 10 seconds...\\\")\\n time.sleep(10)\\n max_tries -= 1\",\n \"def reconect(self):\\n self.connection.reset_connection()\\n return self.connection\",\n \"def reconect(self):\\n self.connection = DataPostgres.connect(**self.options)\\n return self.connection\",\n \"def _connect(self, **kwargs):\\n global _connection\\n if self.reuse and _connection:\\n self.connection = _connection\\n else:\\n if pymongo.version_tuple[0] < 3:\\n try:\\n self.connection = Connection(host=self.host,\\n port=self.port, **kwargs)\\n # pymongo >= 3.0 does not raise this error\\n except PyMongoError:\\n if self.fail_silently:\\n return\\n else:\\n raise\\n else:\\n self.connection = Connection(host=self.host, port=self.port,\\n **kwargs)\\n try:\\n self.connection.is_locked\\n except ServerSelectionTimeoutError:\\n if self.fail_silently:\\n return\\n else:\\n raise\\n _connection = self.connection\\n\\n self.db = self.connection[self.database_name]\\n if self.username is not None and self.password is not None:\\n auth_db = self.connection[self.authentication_database_name]\\n self.authenticated = auth_db.authenticate(self.username,\\n self.password)\\n\\n if self.capped:\\n #\\n # We don't want to override the capped collection\\n # (and it throws an error anyway)\\n try:\\n self.collection = Collection(self.db, self.collection_name,\\n capped=True, max=self.capped_max,\\n size=self.capped_size)\\n except OperationFailure:\\n # Capped collection exists, so get it.\\n self.collection = self.db[self.collection_name]\\n else:\\n self.collection = self.db[self.collection_name]\",\n \"def test_connection_duplication():\",\n \"def make_connection(self):\\n if self._created_connections() >= self.max_connections:\\n raise ConnPoolException(\\\"Too many connections.\\\")\\n connection = self.connection_class(**self.connection_kwargs)\\n connection.connect()\\n return connection\",\n \"def _get_cached_db_connection(name='ace'):\\n if name is None:\\n name = 'ace'\\n\\n config_section = 'database_{}'.format(name)\\n\\n if config_section not in saq.CONFIG:\\n raise ValueError(\\\"invalid database {}\\\".format(name))\\n\\n try:\\n db_identifier = _get_cached_db_identifier(name)\\n with _global_db_cache_lock:\\n logging.debug(\\\"aquiring existing cached database connection {}\\\".format(db_identifier))\\n db = _global_db_cache[db_identifier]\\n\\n try:\\n db.rollback()\\n #logging.debug(\\\"acquired cached database connection to {}\\\".format(name))\\n return db\\n\\n except Exception as e:\\n logging.info(\\\"possibly lost cached connection to database {}: {} ({})\\\".format(name, e, type(e)))\\n try:\\n db.close()\\n except Exception as e:\\n logging.error(\\\"unable to close cached database connection to {}: {}\\\".format(name, e))\\n\\n try:\\n with _global_db_cache_lock:\\n del _global_db_cache[db_identifier]\\n except Exception as e:\\n logging.error(\\\"unable to delete cached db {}: {}\\\".format(db_identifier, e))\\n\\n #return _get_db_connection(name)\\n\\n except KeyError:\\n pass\\n\\n try:\\n logging.info(\\\"opening new cached database connection to {}\\\".format(name))\\n\\n with _global_db_cache_lock:\\n _global_db_cache[db_identifier] = _get_db_connection(name)\\n\\n logging.debug(\\\"opened cached database connection {}\\\".format(db_identifier))\\n return _global_db_cache[db_identifier]\\n\\n except Exception as e:\\n logging.error(\\\"unable to connect to database {}: {}\\\".format(name, e))\\n report_exception()\\n raise e\",\n \"def __enter__(self):\\n fp = os.path.abspath(self.db_name)\\n if self.read_only:\\n self.conn = sqlite3.connect('file:/{}?mode=ro'.format(fp), uri=True)\\n else:\\n self.conn = sqlite3.connect(fp)\\n return self.conn\",\n \"def create_connection():\\r\\n try:\\r\\n conn = sq.connect(DBClass.db_name)\\r\\n except sq.Error as e:\\r\\n raise e\\r\\n \\r\\n return conn\",\n \"def new_connection(name, user, password, host=None, database=None):\\n if QtSql.QSqlDatabase.database(name).open():\\n db = QtSql.QSqlDatabase.database(name)\\n return db, True\\n else:\\n if host is None or database is None:\\n host, database = read_settings(name)\\n db = QtSql.QSqlDatabase.addDatabase(\\\"QMYSQL\\\", name)\\n db.setUserName(user)\\n db.setHostName(host)\\n db.setDatabaseName(database)\\n db.setPassword(password)\\n if db.open():\\n dbt = threading.Timer(600, close_connection, args=[name])\\n dbt.start()\\n return db, True\\n else:\\n db_err(db)\\n return None, False\",\n \"def __enter__(self) -> cx_Oracle.connect:\\n self.db_connection = cx_Oracle.connect(\\n self.config['oracle']['ora_user'],\\n self.config['oracle']['ora_pass'],\\n f\\\"{self.config['oracle']['ora_host']}/{self.config['oracle']['ora_sid']}\\\")\\n return self.db_connection\",\n \"def reconnect(self):\\n self.conn.close()\\n self.conn = sqlite3.connect(self.db_file, check_same_thread=False)\\n self.conn.row_factory = DB.namedtuple_factory\\n # self.conn.row_factory = DB.dict_factory\",\n \"def connect(self):\\n if self.connection is not None:\\n logger.info(\\\" connection: %s \\\" % (self.connection is not None))\\n if not self.connection.opened():\\n logger.info(\\\"connection is closed\\\")\\n return self.reconect()\\n\\n if self.connection.opened():\\n return self.connection\\n try:\\n self.connection = connect(**self.options)\\n except Exception as e:\\n logger.critical(\\\"Unable to connect to DB: {0}\\\".format(e.message))\\n raise\\n\\n return self.connection\",\n \"def connect(self):\\n if self.connection:\\n if self.connection_load_balance or self.connection.closed():\\n self.log.debug(\\\"Recreate the connection\\\")\\n self.connection.close()\\n self.connection = vertica.connect(**exclude_undefined_keys(self.options))\\n else:\\n self.connection = vertica.connect(**exclude_undefined_keys(self.options))\\n\\n return self.connection\",\n \"def _get_connection(self) -> Connection:\\n # TODO(101) is there a problem with having just one db connection?\\n # Will this cause bugs with failed commits?\\n curr_thread = threading.get_ident()\\n if curr_thread not in self.conn or self.conn[curr_thread] is None:\\n try:\\n conn = sqlite3.connect(self.db_path)\\n conn.row_factory = StringIDRow\\n self.conn[curr_thread] = conn\\n except sqlite3.Error as e:\\n raise MephistoDBException(e)\\n return self.conn[curr_thread]\",\n \"def get_new_connection(self, conn_params):\\r\\n self.__connection_string = conn_params.get('connection_string', '')\\r\\n conn = Database.connect(**conn_params)\\r\\n return conn\",\n \"def __enter__(self):\\n self.conn = sqlite3.connect(self.db_name)\\n return self.conn\",\n \"def reconnect(self):\\n # This is the old connection IOLoop instance, stop its ioloop\\n self._connection.ioloop.stop()\\n\\n if not self._closing:\\n # Create a new connection\\n self._connection = self.connect()\\n # There is now a new connection, needs a new ioloop to run\\n self._connection.ioloop.start()\",\n \"def reconnect(self):\\n # This is the old connection IOLoop instance, stop its ioloop\\n self._connection.ioloop.stop()\\n\\n if not self._closing:\\n # Create a new connection\\n self._connection = self.connect()\\n\\n # There is now a new connection, needs a new ioloop to run\\n self._connection.ioloop.start()\",\n \"def reconnect(self):\\n self.close()\\n self._db = self._pool.get_connection()\",\n \"def get_connection(self):\\n # self.class_logger.info(\\\"Try to get connection...\\\")\\n for i in range(1, self.retry_count + 1):\\n\\n if len(self._available_connections) > 0:\\n connection, last_time = self._available_connections.pop()\\n if (last_time + self.time_to_live) < time.time():\\n try:\\n self.class_logger.debug(\\\"Time to leave is exceeded. Destroy connection and try to make new one.\\\")\\n connection.disconnect()\\n except Exception as err:\\n self.class_logger.warning(\\\"Error occurred while disconnecting connection: %s\\\" % (err, ))\\n finally:\\n del connection\\n\\n # If connection is not created/got on previous step\\n if \\\"connection\\\" not in locals():\\n self.class_logger.debug(\\\"Connection is not available. Making one...\\\")\\n try:\\n connection = self.make_connection()\\n self.class_logger.debug(\\\"...completed.\\\")\\n except Exception as err:\\n self.class_logger.debug(\\\"...failed: %s.\\\" % (err, ))\\n\\n try:\\n if \\\"connection\\\" in locals():\\n if not connection.check_connection():\\n raise ConnPoolException(\\\"Connection is dead.\\\")\\n self._in_use_connections.add(connection)\\n self.class_logger.debug(\\\"Connection check passed.\\\")\\n return connection\\n\\n except Exception as err:\\n self.class_logger.warning(\\\"Error occurred: %s\\\" % (err, ))\\n try:\\n self.class_logger.debug(\\\"Deleting connection since it's not OK...\\\")\\n # self.del_connection_in_use(connection)\\n connection.disconnect()\\n self.class_logger.debug(\\\"...Deletion succeeded.\\\")\\n except Exception as err:\\n self.class_logger.warning(\\\"Broken connection deletion failed: %s.\\\" % (err, ))\\n\\n sleep_time = i ** 2\\n self.class_logger.debug(\\\"Connection check failed. Sleeping for %s secs before retry.\\\" % (sleep_time, ))\\n time.sleep(sleep_time)\\n\\n message = \\\"ERROR: Cannot create connection after %s attempts.\\\" % (self.retry_count, )\\n self.class_logger.error(message)\\n raise ConnPoolException(message)\",\n \"def _unthreadsafe_get_connection(self):\\n return PooledDBConnection(self, self._queue.get())\",\n \"def newConn():\\n g = sql.connect('user.db')\\n e = g.cursor()\\n return {\\n \\\"close\\\": g.close,\\n \\\"commit\\\": g.commit,\\n \\\"cursor\\\": e\\n }\",\n \"def __init__(self):\\r\\n self.conn = create_connection(DATABASE_PATH)\",\n \"def real_conn(self) -> Connection:\\n return self._real_conn\",\n \"def _create_new_socket(self):\\n sock = socket()\\n sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, True)\\n return sock\",\n \"def create_temp_connection() -> sqlite3.Connection:\\n database = Path(calc_path)\\n conn = __check_existence(database)\\n with conn:\\n return conn\",\n \"def __getattr__(self, name):\\n return self.connection(name)\",\n \"def _GetNewConnection(self):\\n l_logger.debug(\\\"Creating a db connection\\\")\\n return mdb.connect(host=self.host,\\n user=self.user, \\n password=self.passwd, \\n database=self.db_name,\\n port=self.port\\n )\",\n \"def before_request():\\n engine = cache['engine']\\n try:\\n g.conn = engine.connect()\\n except:\\n print \\\"error creating temporary connection to the db\\\"\\n import traceback; traceback.print_exc()\\n g.conn = None\",\n \"def _get_connection(self) -> sqlite3.Connection:\\n curr_thread = threading.get_ident()\\n if curr_thread not in self.conn or self.conn[curr_thread] is None:\\n conn = sqlite3.connect(self.db_path, check_same_thread=False)\\n conn.row_factory = sqlite3.Row\\n self.conn[curr_thread] = conn\\n return self.conn[curr_thread]\",\n \"def __make_connection(self):\\n return self.euca.make_connection()\",\n \"def _create_connection(self):\\n if not self.connection:\\n log.info(\\\"{}: Creating connection with address={}\\\".format(\\n self.container_id, self.address.geturl()))\\n self.connection = Connection(\\n self.address.hostname,\\n self.auth,\\n container_id=self.container_id,\\n properties=self._create_properties(),\\n debug=self.debug)\",\n \"def establish_connection(self):\\n conninfo = self.client\\n for name, default_value in items(self.default_connection_params):\\n if not getattr(conninfo, name, None):\\n setattr(conninfo, name, default_value)\\n if conninfo.hostname == 'localhost':\\n conninfo.hostname = '127.0.0.1'\\n conn = self.Connection(host=conninfo.host,\\n userid=conninfo.userid,\\n password=conninfo.password,\\n login_method=conninfo.login_method,\\n virtual_host=conninfo.virtual_host,\\n insist=conninfo.insist,\\n ssl=conninfo.ssl,\\n connect_timeout=conninfo.connect_timeout)\\n conn.client = self.client\\n return conn\",\n \"def _connect(self):\\n try: \\n self.r = redis.StrictRedis(host=self.host, port=self.port, db=self.db)\\n except:\\n raise\",\n \"def renew_connection(self, timeout=45):\\n self.new_connection(timeout=timeout)\",\n \"def get_connection(self, *args, **kwargs):\\n conn = super(SSLHTTPAdapter, self).get_connection(*args, **kwargs)\\n if conn.assert_hostname != self.assert_hostname:\\n conn.assert_hostname = self.assert_hostname\\n return conn\",\n \"def _connect(self):\\n self.connection = RedisConnection(self.host, self.port, self.dbname)\",\n \"def _get_connection(reconnect=False):\\n global _connection\\n identity = get_identity()\\n # Connect to the database if not already connected\\n if _connection.get(identity) is None or reconnect:\\n try:\\n _connection[identity] = Connection(**_connection_settings)\\n except Exception, e:\\n raise ConnectionError(\\\"Cannot connect to the database:\\\\n%s\\\" % e)\\n return _connection[identity]\",\n \"def getconn(self):\\n #hdbport = int('3%s15' % Settings.hdbinstancenum)\\n con = dbapi.connect(address = self.host, \\\\\\n port = self.port, \\\\\\n user = self.username, \\\\\\n password = self.password, \\\\\\n autocommit = True)\\n if self.schema:\\n cur = con.cursor()\\n try:\\n cur.execute('ALTER SESSION SET CURRENT_SCHEMA = %s' % self.schema)\\n return con\\n except dbapi.Error, err:\\n cur.close()\\n con.close()\\n cur = None\\n raise err\\n finally:\\n if cur:\\n cur.close()\\n else:\\n return con\",\n \"def create_master_connection(self):\\n self.cwd = os.getcwd()\\n self.pullerdir = self.cwd + \\\"\\\\\\\\Puller Data\\\\\\\\\\\"\\n self.inputloc = self.pullerdir + self.iteration_input\\n try:\\n self.conn_master = sqlite3.connect(self.inputloc)\\n return self.conn_master\\n except Error as e:\\n print(e)\\n\\n return None\",\n \"def _db_connection(self):\\n pass\",\n \"def make_connection(self):\\n if self._created_connections[self._pattern_idx] >= self.max_connections_per_pattern:\\n raise ConnectionError(\\\"Too many connections\\\")\\n self._created_connections[self._pattern_idx] += 1\\n conn = self.connection_class(**self.patterns[self._pattern_idx])\\n conn._pattern_idx = self._pattern_idx\\n return conn\",\n \"def _get_db_connection(name='ace'):\\n\\n if name is None:\\n name = 'ace'\\n\\n #if _cached_db_connections_enabled():\\n #return _get_cached_db_connection(name)\\n\\n config_section = 'ace'\\n if name:\\n config_section = 'database_{}'.format(name)\\n\\n if config_section not in saq.CONFIG:\\n raise ValueError(\\\"invalid database {}\\\".format(name))\\n\\n _section = saq.CONFIG[config_section]\\n kwargs = {\\n 'db': _section['database'],\\n 'user': _section['username'],\\n 'passwd': _section['password'],\\n 'charset': 'utf8'\\n }\\n\\n if 'hostname' in _section:\\n kwargs['host'] = _section['hostname']\\n\\n if 'port' in _section:\\n kwargs['port'] = _section.getint('port')\\n \\n if 'unix_socket' in _section:\\n kwargs['unix_socket'] = _section['unix_socket']\\n\\n if 'ssl_ca' in _section or 'ssl_key' in _section or 'ssl_cert' in _section:\\n kwargs['ssl'] = {}\\n\\n if 'ssl_ca' in _section and _section['ssl_ca']:\\n path = abs_path(_section['ssl_ca'])\\n if not os.path.exists(path):\\n logging.error(\\\"ssl_ca file {} does not exist (specified in {})\\\".format(path, config_section))\\n else:\\n kwargs['ssl']['ca'] = path\\n\\n if 'ssl_key' in _section and _section['ssl_key']:\\n path = abs_path(_section['ssl_key'])\\n if not os.path.exists(path):\\n logging.error(\\\"ssl_key file {} does not exist (specified in {})\\\".format(path, config_section))\\n else:\\n kwargs['ssl']['key'] = path\\n\\n if 'ssl_cert' in _section and _section['ssl_cert']:\\n path = _section['ssl_cert']\\n if not os.path.exists(path):\\n logging.error(\\\"ssl_cert file {} does not exist (specified in {})\\\".format(path, config_section))\\n else:\\n kwargs['ssl']['cert'] = path\\n\\n logging.debug(\\\"opening database connection {}\\\".format(name))\\n return pymysql.connect(**kwargs)\\n #return pymysql.connect(host=_section['hostname'] if 'hostname' in _section else None,\\n #port=3306 if 'port' not in _section else _section.getint('port'),\\n #unix_socket=_section['unix_socket'] if 'unix_socket' in _section else None,\\n #db=_section['database'],\\n #user=_section['username'],\\n #passwd=_section['password'],\\n #charset='utf8')\",\n \"def __make_connection(self, path):\\n try:\\n connection = sqlite3.connect(path)\\n return connection\\n except sqlite3.Error as e:\\n pass\\n return None\",\n \"def __get_open_connection(self, connection_hash):\\n db = MySQLdb.connect(\\n host=connection_hash[\\\"host\\\"],\\n user=connection_hash[\\\"user\\\"],\\n passwd=connection_hash[\\\"password\\\"],\\n db=connection_hash[\\\"dbname\\\"]\\n )\\n return db\",\n \"def find(self, host, auth):\\n key = (host, auth)\\n if key not in self.conns:\\n conn = None\\n hooks = self._conn_hooks or self._default_hooks\\n for hook in hooks:\\n conn = hook.connect(host, auth)\\n if conn:\\n logger.info(\\\"Established new connection to '%s' via '%s'\\\" %\\n (host, hook))\\n break\\n if conn is None:\\n raise ConnectionError(\\n 'Failed to establish a connection to %s' % host)\\n self.add(host, auth, conn)\\n else:\\n conn = self.conns[key]\\n logger.debug(\\\"Reusing existing connection to '%s'\\\" % (host))\\n return conn\",\n \"def get(self, conn_alias: str) -> \\\"BaseDBAsyncClient\\\":\\n storage: Dict[str, \\\"BaseDBAsyncClient\\\"] = self._get_storage()\\n try:\\n return storage[conn_alias]\\n except KeyError:\\n connection: BaseDBAsyncClient = self._create_connection(conn_alias)\\n storage[conn_alias] = connection\\n return connection\",\n \"def get_conn(cls):\\n\\n if not cls.conn or not cls.conn.open:\\n cls.connect()\\n\\n try:\\n cls.conn.ping() # ping to test if the current conn is working\\n except MySQLdb.OperationalError:\\n cls.connect()\\n\\n return cls.conn\",\n \"def _threadsafe_return_connection(self, con):\\n # we don't need to do anything here\",\n \"def _threadsafe_get_connection(self):\\n with self._lock:\\n next_con = self._nextConnection\\n con = PooledDBConnection(self, self._connections[next_con])\\n next_con += 1\\n if next_con >= len(self._connections):\\n next_con = 0\\n self._nextConnection = next_con\\n return con\",\n \"def reconnect(self):\\n self.close()\\n self._db = pymysql.connect(**self._db_args)\",\n \"def create_connection():\\n try:\\n with open('connection_string', 'rt') as f:\\n connection_string = f.read()\\n conn = connect(connection_string)\\n print(\\\"Conn : \\\", conn)\\n return conn\\n except Error as e:\\n print(e)\\n\\n return None\",\n \"def __get_lucene_connection(self, reuse=True):\\n if not self.__lucene_connection or not reuse:\\n if self.__lucene_connection:\\n self.__lucene_connection.close()\\n\\n self.__lucene_connection = http.client.HTTPConnection(self.__LUCENE_HOST,\\n port=self.__LUCENE_PORT,\\n timeout=self.__TIMEOUT)\\n\\n return self.__lucene_connection\",\n \"def _get_pool(self, *args, **kwargs):\\n\\n pool_name = '_pool_%s' % getattr(self, 'alias', 'common')\\n\\n if not hasattr (self.__class__, pool_name):\\n lock = thread.allocate_lock()\\n lock.acquire()\\n\\n try:\\n pool = cx_Oracle.SessionPool(\\n user=self.user,\\n password=self.password,\\n dsn=self.tns,\\n min=CX_POOL_SESSION_MIN,\\n max=CX_POOL_SESSION_MAX,\\n increment=CX_POOL_SESSION_INCREMENT,\\n connectiontype=cx_Oracle.Connection,\\n threaded=CX_POOL_THREADED,\\n getmode=cx_Oracle.SPOOL_ATTRVAL_NOWAIT,\\n homogeneous=True)\\n except Exception as err:\\n pool = None\\n\\n if pool:\\n pool.timeout = CX_POOL_CONNECT_TIMEOUT\\n setattr(self.__class__, pool_name, pool)\\n else:\\n msg = \\\"\\\"\\\" ### Database login failed or database not found ### \\\"\\\"\\\"\\n raise self.Database_Error, ('%s') %(msg)\\n\\n lock.release()\\n\\n return getattr(self.__class__, pool_name)\",\n \"def __call__(self, account, db_name=None, pool_recycle=None):\\n assert account and db_name,\\\"Must provide an account and a db\\\"\\n pool_recycle = pool_recycle or 3600\\n if account not in self._db_account.get(db_name, []):\\n if db_name == \\\"PARENT\\\":\\n engine = MySQLdb.connect(host=account.host, user=account.user,\\n passwd=account.passwd, port=account.port)\\n else:\\n engine = sql.create_engine(\\\"mysql://%s/%s\\\" % (account, \\n db_name), pool_recycle=pool_recycle)\\n if db_name not in self._db_account:\\n self._db_account[db_name] = {}\\n self._db_account[db_name][account] = engine\\n return self._db_account[db_name][account]\",\n \"def reconnect(self):\\n raise NotImplementedError()\",\n \"def open_connection(self):\\n self.conn = pymysql.connect(host=self.host, user=self.user, passwd=self.passwd, db=self.db)\",\n \"def create_connection(self) -> None:\\n try:\\n self.create_folder(self.folder_config)\\n self.connection = sqlite3.connect(self.name_db, check_same_thread=False)\\n self.cursor = self.connection.cursor()\\n except Exception as e:\\n msg = f'We faced problems with the connection. Reason: {e}'\\n self.proceed_error(msg)\",\n \"def with_connection(func):\\n def wrapped(self,*args,**kwargs):\\n if self.connection is None:\\n try:\\n self.connection = self.connect()\\n self.cursor = self.connection.cursor()\\n except Exception as error:\\n self.cursor = None\\n logger.warn(str(error))\\n else:\\n self.connection.ping(True)\\n func(self,*args,**kwargs)\\n return wrapped\",\n \"def connect(self,schema_name = ''):\\n\\t\\tif schema_name == '':\\n\\t\\t\\tif self.__schema_name=='':\\n\\t\\t\\t\\tprint('Specify name of the schema/db first')\\n\\t\\t\\t\\treturn\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprint('Use the previous schema_name %s'%self.__schema_name)\\n\\t\\telse:\\n\\t\\t\\tif self.__schema_name == schema_name:\\n\\t\\t\\t\\t\\tprint('Seem to be the same engine')\\n\\t\\t\\tself.__schema_name = schema_name\\n\\t\\t\\t\\n\\t\\tif self.connected:\\n\\t\\t\\tself.close()\\n\\t\\ttry:\\n#\\t\\t\\t self.__db = pymysql.connect(host = \\\"rm-j6cluj4576jdi6n6oo.mysql.rds.aliyuncs.com\\\",\\\\\\n#\\t\\t\\t\\t\\t\\t\\t\\t database = schema_name, user='cognitiveleap', password= 'QWE@123456')\\n\\t\\t\\t#self.__cursor = self.__db.cursor()\\n\\t\\t\\tself.__engine = create_engine(\\\"mysql+pymysql://cognitiveleap:QWE@123456@rm-j6cluj4576jdi6n6oo.mysql.rds.aliyuncs.com/%s\\\"%self.__schema_name)\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise Exception (3)\\n\\t\\tself.connected = True\",\n \"def expand(self):\\n try:\\n self.create_connection()\\n except Exception as excpt:\\n print(excpt)\",\n \"def as_dummy_conn(self) -> DummyPgConn:\\n return DummyPgConn(self._conn, self._lock, self._transaction_lock)\",\n \"def _create_connection(self):\\r\\n if not self._hosts:\\r\\n raise CQLConnectionError(\\\"At least one host required\\\")\\r\\n\\r\\n hosts = copy(self._hosts)\\r\\n random.shuffle(hosts)\\r\\n\\r\\n for host in hosts:\\r\\n try:\\r\\n transport = self._create_transport(host)\\r\\n new_conn = cql.connect(\\r\\n host.name,\\r\\n host.port,\\r\\n user=self._username,\\r\\n password=self._password,\\r\\n consistency_level=self._consistency,\\r\\n transport=transport\\r\\n )\\r\\n new_conn.set_cql_version('3.0.0')\\r\\n return new_conn\\r\\n except Exception as exc:\\r\\n logging.debug(\\\"Could not establish connection to\\\"\\r\\n \\\" {}:{} ({!r})\\\".format(host.name, host.port, exc))\\r\\n\\r\\n raise CQLConnectionError(\\\"Could not connect to any server in cluster\\\")\",\n \"def __create_connection():\\n connection = None\\n try:\\n connection = sqlite3.connect(Database.filepath)\\n return connection\\n except Error as e:\\n print(e)\\n\\n return connection\",\n \"def __getitem__(self, name):\\n return self.connection(name)\",\n \"def open_connection(self, connection):\\n pass\",\n \"def newconnection(self, path):\\n conn = sqlite3.connect(path)\\n return conn\",\n \"def __init__(self,schema_name = 'null'):\\n\\t\\tself.connected = False\\n\\t\\tself.__schema_name = ''\\n\\t\\tself.__db = ''\\n\\t\\tself.__cursor = ''\\n\\t\\tself.__engine = ''\\n\\t\\tif schema_name != 'null':\\n\\t\\t\\tself.connect(schema_name)\",\n \"def __enter__(self):\\n return self.connection.__enter__\",\n \"def connect(self):\\n if self.connection is not None:\\n logger.info(\\\" connection: %s \\\" % (self.connection is not None))\\n return self.connection\\n try:\\n self.connection = DataPostgres.connect(**self.options)\\n except Exception as e:\\n logger.critical(\\\"Unable to connect to DB: {0}\\\".format(e.message))\\n raise\\n\\n return self.connection\",\n \"def __enter__(self) -> \\\"Connection\\\":\\n\\n if (not self.connected):\\n self.connect()\\n \\n return self\",\n \"def connect_to_database(self, database_name):\\n\\n original_config = self.config['mysql'][database_name]\\n\\n db_config = dict()\\n db_config['host'] = original_config['host']\\n db_config['user'] = original_config['user']\\n db_config['db'] = original_config['db']\\n db_config['password'] = original_config['password']\\n db_config['charset'] = 'utf8mb4'\\n db_config['cursorclass'] = pymysql.cursors.DictCursor\\n\\n new_connection = pymysql.connect(**db_config)\\n\\n self.connections[database_name] = new_connection\\n return new_connection\",\n \"def db_connection():\\n global dbconnection\\n try:\\n conn = dbconnection\\n except:\\n dbconnection = psycopg2.connect(user = dbuser,\\n password = dbpass,\\n host = dbserver,\\n port = \\\"5432\\\",\\n database = dbname)\\n conn = dbconnection\\n return conn\",\n \"def connect(name='tstp'):\\n global DB_HANDLE\\n try:\\n if not name in DB_HANDLES:\\n db = DBS[name]\\n DB_HANDLES[name] = sql.connect(\\n host=db['host'],\\n user=db['user'],\\n passwd=db['password'],\\n db=db['db'],\\n use_unicode=True,\\n charset=\\\"utf8\\\",\\n )\\n except Exception as ex:\\n log.error(\\\"ERROR: Unable to connect to \\\\\\\"%s\\\\\\\":\\\\n%s\\\" % (name, str(ex)))\\n raise ex\\n DB_HANDLE = DB_HANDLES[name]\",\n \"def __init__(self):\\n self._connection = get_db_connection()\",\n \"def set_connection(self, **kwargs):\\n if self.schema is None:\\n self.conn = psycopg2.connect(\\n host=self.host,\\n port=self.port,\\n user=self.user,\\n password=self.password,\\n dbname=self.db_name,\\n **self.kwargs)\\n else:\\n self.conn = psycopg2.connect(\\n host=self.host,\\n port=self.port,\\n user=self.user,\\n password=self.password,\\n dbname=self.db_name,\\n options=f'--search_path={self.schema}',\\n **self.kwargs)\",\n \"def __get_connection():\\n # 根据配置文件创建连接池\\n if not Mysql.__mysql_pool:\\n Mysql.__mysql_pool = PooledDB(\\n creator=MySQLdb,\\n use_unicode=False,\\n cursorclass=DictCursor,\\n db=sqlconf.MysqlConfig['db'],\\n host=sqlconf.MysqlConfig['host'],\\n port=sqlconf.MysqlConfig['port'],\\n user=sqlconf.MysqlConfig['user'],\\n passwd=sqlconf.MysqlConfig['passwd'],\\n charset=sqlconf.MysqlConfig['charset'],\\n mincached=sqlconf.MysqlConfig['mincached'],\\n maxcached=sqlconf.MysqlConfig['maxcached'],\\n maxconnections=sqlconf.MysqlConfig['maxconnections'])\\n # 返回连接池中连接对象\\n return Mysql.__mysql_pool.connection()\",\n \"def create_connection(self):\\r\\n dbname = \\\"dbname = \\\"+\\\"'\\\"+self.dbname+\\\"' \\\"\\r\\n user = \\\"user = \\\"+\\\"'\\\"+self.user+\\\"' \\\"\\r\\n host = \\\"host = \\\"+\\\"'\\\"+self.host+\\\"' \\\"\\r\\n password = \\\"password = \\\"+\\\"'\\\"+self.password+\\\"' \\\"\\r\\n connection_info = dbname + user + host + password\\r\\n try:\\r\\n conn = psycopg2.connect(connection_info)\\r\\n except psycopg2.Error:\\r\\n print(\\\"Unable to connect to DB\\\")\\r\\n return conn\",\n \"def __connect(host):\\n global pg_pool\\n pg_config['host'] = host\\n pg_pool = SimpleConnectionPool(1, 1, **pg_config)\",\n \"def acquire_direct(self, address):\\n if self.closed():\\n raise ServiceUnavailable(\\\"Connection pool closed\\\")\\n with self.lock:\\n try:\\n connections = self.connections[address]\\n except KeyError:\\n connections = self.connections[address] = deque()\\n\\n connection_acquisition_start_timestamp = perf_counter()\\n while True:\\n # try to find a free connection in pool\\n for connection in list(connections):\\n if connection.closed() or connection.defunct() or connection.timedout():\\n connections.remove(connection)\\n continue\\n if not connection.in_use:\\n connection.in_use = True\\n return connection\\n # all connections in pool are in-use\\n can_create_new_connection = self._max_connection_pool_size == INFINITE or len(connections) < self._max_connection_pool_size\\n if can_create_new_connection:\\n try:\\n connection = self.connector(address, self.connection_error_handler)\\n except ServiceUnavailable:\\n self.remove(address)\\n raise\\n else:\\n connection.pool = self\\n connection.in_use = True\\n connections.append(connection)\\n return connection\\n\\n # failed to obtain a connection from pool because the pool is full and no free connection in the pool\\n span_timeout = self._connection_acquisition_timeout - (perf_counter() - connection_acquisition_start_timestamp)\\n if span_timeout > 0:\\n self.cond.wait(span_timeout)\\n # if timed out, then we throw error. This time computation is needed, as with python 2.7, we cannot\\n # tell if the condition is notified or timed out when we come to this line\\n if self._connection_acquisition_timeout <= (perf_counter() - connection_acquisition_start_timestamp):\\n raise ClientError(\\\"Failed to obtain a connection from pool within {!r}s\\\".format(\\n self._connection_acquisition_timeout))\\n else:\\n raise ClientError(\\\"Failed to obtain a connection from pool within {!r}s\\\".format(self._connection_acquisition_timeout))\",\n \"def create_connection(self, *args_to_use, **kwargs_to_use):\\n return pysftp.Connection(*args_to_use, **kwargs_to_use)\",\n \"def __connect_to_database(self, database_name: str) -> sqlite3.Connection:\\n conn = sqlite3.connect(database_name)\\n conn.row_factory = sqlite3.Row\\n\\n return conn\",\n \"def set_connection(self, service_name, to_cache):\\n self.services.setdefault(service_name, {})\\n self.services[service_name]['connection'] = to_cache\",\n \"def nopool(self, *args, **kwargs):\\n nopool = None\\n try:\\n nopool = cx_Oracle.connect('{0}/{1}@{2}'.format(self.user, self.password, self.tns))\\n except cx_Oracle.DatabaseError, exception:\\n error, = exception\\n\\n # Check if code return (ORA-12154 TNS:could not resolve the connect identifier specified)\\n tns_notresolve = 12154\\n\\n if error.code == tns_notresolve:\\n raise self.Database_Error, ('%s More details http://ora-%s.ora-code.com/' %(error.message, error.code) )\\n else:\\n raise self.Database_Error, ('%s More details http://ora-%s.ora-code.com/' %(error.message, error.code) )\\n\\n return nopool\",\n \"def __enter__(self):\\n self.connection = MongoClient(self.host, self.port)\\n return self\",\n \"def __enter__(self) -> sqlite3.Connection:\\n self.conn = sqlite3.connect(self.path_db)\\n return self.conn\",\n \"def connect_to_database(name, settings):\\n if name == 'mongodb':\\n import models.mongodb\\n database = models.mongodb.Database(settings)\\n if database.check_connection():\\n return database\\n else:\\n name = 'memory'\\n\\n if name == 'memory':\\n import models.memory\\n database = models.memory.Database(settings)\\n return database\\n\\n raise ValueError('Unknown database.')\",\n \"def alter_connection(self, conn, new_conn):\\n conn = copy.copy(self.parser.comms[new_conn])\\n return conn\",\n \"def _get_outer_connection(self):\\n if self._data['data_fetch_method'] == 'sql':\\n if not self._data['source_database_connection_id']:\\n raise Exception(\\\"No source_database_connection_id specified\\\")\\n res = self._db.Query(\\\"\\\"\\\"SELECT source_database_connection.*, jdbc_driver.current_time_sql_stmt\\n FROM source_database_connection\\n LEFT JOIN jdbc_driver ON jdbc_driver.jdbc_driver_id = source_database_connection.jdbc_driver_id \\n WHERE \\n `source_database_connection_id`=%s\\\"\\\"\\\",(self._data['source_database_connection_id']))\\n if not res:\\n raise Exception(\\\"No source database record for source_database_connection_id=%s\\\", (self._data['source_database_connection_id']))\\n outer_connection = self._db.record[0]\\n conn = JCollectorConn(outer_connection)\\n return conn\\n\\n elif self._data['data_fetch_method'] == 'web service':\\n res = self._db.Query(\\\"\\\"\\\"SELECT web_service_credentials.*\\n FROM web_service_credentials\\n WHERE\\n `web_service_credentials_id`=%s\\\"\\\"\\\",(self._data['web_service_credentials_id']))\\n if not res:\\n raise Exception(\\\"no source web service record\\\")\\n self.web_service = self._db.record[0]\\n self.web_service['url'] = self._data['data_fetch_command']\\n conn = WebServiceConn(self.web_service)\\n return conn\\n\\n return False\",\n \"def monkeypatch_connections(self):\\n \\n def create_test_db(self, verbosity=1, autoclobber=False):\\n \\\"\\\"\\\"\\n Creates a test database, prompting the user for confirmation if the\\n database already exists. Returns the name of the test database created.\\n \\\"\\\"\\\"\\n # Don't import django.core.management if it isn't needed.\\n test_database_name = self._get_test_db_name()\\n \\n if self.connection.settings_dict.get('ENGINE', '').endswith('.sqlite3')\\\\\\n and test_database_name != ':memory:':\\n if os.access(test_database_name, os.F_OK):\\n print \\\"sqlite test database found !\\\"\\n \\n #self._create_test_db(verbosity, autoclobber)\\n \\n self.connection.close()\\n self.connection.settings_dict[\\\"NAME\\\"] = test_database_name\\n \\n # Confirm the feature set of the test database\\n self.connection.features.confirm()\\n \\n # Get a cursor (even though we don't need one yet). This has\\n # the side effect of initializing the test database.\\n self.connection.cursor()\\n\\n return test_database_name\\n \\n def destroy_test_db(self, old_database_name, verbosity=1):\\n \\\"\\\"\\\"\\n Destroy a test database, prompting the user for confirmation if the\\n database already exists.\\n \\\"\\\"\\\"\\n self.connection.close()\\n test_database_name = self.connection.settings_dict['NAME']\\n if verbosity >= 1:\\n test_db_repr = ''\\n if verbosity >= 2:\\n test_db_repr = \\\" ('%s')\\\" % test_database_name\\n print \\\"Ignore the test database for alias '%s'%s...\\\" % (\\n self.connection.alias, test_db_repr)\\n \\n # Temporarily use a new connection and a copy of the settings dict.\\n # This prevents the production database from being exposed to potential\\n # child threads while (or after) the test database is destroyed.\\n # Refs #10868 and #17786.\\n settings_dict = self.connection.settings_dict.copy()\\n settings_dict['NAME'] = old_database_name \\n \\n def _destroy_test_db(self, test_database_name, verbosity):\\n print \\\"Keep the test database !\\\" #%test_database_name\\n self.connection.close()\\n \\n \\n for alias in connections:\\n \\\"\\\"\\\"\\n django.test.simple.DjangoTestSuiteRunner\\n django.db.backends.creation\\n django.db.backends.mysql.base\\n \\\"\\\"\\\"\\n connection = connections[alias]\\n #if connection.settings_dict.get('ENGINE', '').endswith('.sqlite3'):\\n \\n if not self.options['setupdbs']:\\n f1 = types.MethodType(create_test_db, connection.creation, DatabaseCreation)\\n connection.creation.create_test_db = f1\\n \\n if not self.options['teardowndbs']:\\n f2 = types.MethodType(destroy_test_db, connection.creation, DatabaseCreation)\\n connection.creation.destroy_test_db = f2\",\n \"def __connect(self):\\n session, metadata, connection = db(dbhost=getattr(self, \\\"host\\\"),\\n dbuser=getattr(self, \\\"user\\\"),\\n dbpass=getattr(self, \\\"password\\\"),\\n dbname=getattr(self, \\\"dbname\\\"))\\n return session, metadata, connection\",\n \"def create_connection(self):\\r\\n\\r\\n try:\\r\\n self.conn = sqlite3.connect(self.database_name)\\r\\n\\r\\n except sqlite3.Error:\\r\\n print('Error connecting to database')\",\n \"def conn(self):\\n if self._sentinel:\\n return self._sentinel.master_for(self._sentinel_name)\\n if not self._conn:\\n self._conn = self.__redis_mod.StrictRedis(\\n host=self._host, port=self._port, **self._conn_kwargs\\n )\\n return self._conn\",\n \"def _get_connection(self, conf):\\n return get_session()\",\n \"def create_connection(db_file):\\n conn = None\\n try:\\n conn = connect(db_file)\\n except Error as e:\\n print(e)\\n\\n return conn\",\n \"def get_connection(self, params):\\r\\n return Redis(connection_pool=self.get_or_create_connection_pool(params))\",\n \"def get_connection(self, settings):\\n\\n def set_mysqlx_wait_timeout(cnx):\\n ver = cnx.sql(_SELECT_VERSION_QUERY).execute().fetch_all()[0][0]\\n # mysqlx_wait_timeout is only available on MySQL 8\\n if tuple(int(n) for n in ver.split(\\\"-\\\")[0].split(\\\".\\\")) > (\\n 8,\\n 0,\\n 10,\\n ):\\n cnx.sql(f\\\"set mysqlx_wait_timeout = {pool.max_idle_time}\\\").execute()\\n\\n pools = self._get_pools(settings)\\n cur_priority = settings.get(\\\"cur_priority\\\", None)\\n error_list = []\\n self._check_unavailable_pools(settings)\\n cur_priority = self._get_next_priority(pools, cur_priority)\\n if cur_priority is None:\\n raise PoolError(\\n \\\"Unable to connect to any of the target hosts. No pool is available\\\"\\n )\\n settings[\\\"cur_priority\\\"] = cur_priority\\n pool = self._get_next_pool(pools, cur_priority)\\n lock = threading.RLock()\\n while pool is not None:\\n try:\\n # Check connections aviability in this pool\\n if pool.qsize() > 0:\\n # We have connections in pool, try to return a working one\\n with lock:\\n try:\\n cnx = pool.get(block=True, timeout=pool.queue_timeout)\\n except queue.Empty:\\n raise PoolError(\\n \\\"Failed getting connection; pool exhausted\\\"\\n ) from None\\n try:\\n if cnx.is_server_disconnected():\\n pool.remove_connections()\\n # Only reset the connection by re-authentification\\n # if the connection was unable to keep open by the\\n # server\\n if not cnx.keep_open:\\n cnx.reset()\\n set_mysqlx_wait_timeout(cnx)\\n except (RuntimeError, OSError, InterfaceError):\\n # Unable to reset connection, close and remove\\n try:\\n cnx.close_connection()\\n except (RuntimeError, OSError, InterfaceError):\\n pass\\n finally:\\n pool.remove_connection(cnx)\\n # By WL#13222 all idle sessions that connect to the\\n # same endpoint should be removed from the pool.\\n while pool.qsize() > 0:\\n try:\\n cnx = pool.get(\\n block=True, timeout=pool.queue_timeout\\n )\\n except queue.Empty:\\n pass\\n else:\\n try:\\n cnx.close_connection()\\n except (RuntimeError, OSError, InterfaceError):\\n pass\\n finally:\\n pool.remove_connection(cnx)\\n # Connection was closed by the server, create new\\n try:\\n cnx = PooledConnection(pool)\\n pool.track_connection(cnx)\\n cnx.connect()\\n set_mysqlx_wait_timeout(cnx)\\n except (RuntimeError, OSError, InterfaceError):\\n pass\\n finally:\\n # Server must be down, take down idle\\n # connections from this pool\\n while pool.qsize() > 0:\\n try:\\n cnx = pool.get(\\n block=True,\\n timeout=pool.queue_timeout,\\n )\\n cnx.close_connection()\\n pool.remove_connection(cnx)\\n except (RuntimeError, OSError, InterfaceError):\\n pass\\n return cnx\\n elif pool.open_connections < pool.pool_max_size:\\n # No connections in pool, but we can open a new one\\n cnx = PooledConnection(pool)\\n pool.track_connection(cnx)\\n cnx.connect()\\n set_mysqlx_wait_timeout(cnx)\\n return cnx\\n else:\\n # Pool is exaust so the client needs to wait\\n with lock:\\n try:\\n cnx = pool.get(block=True, timeout=pool.queue_timeout)\\n cnx.reset()\\n set_mysqlx_wait_timeout(cnx)\\n return cnx\\n except queue.Empty:\\n raise PoolError(\\\"pool max size has been reached\\\") from None\\n except (InterfaceError, TimeoutError, PoolError) as err:\\n error_list.append(f\\\"pool: {pool} error: {err}\\\")\\n if isinstance(err, PoolError):\\n # Pool can be exhaust now but can be ready again in no time,\\n # e.g a connection is returned to the pool.\\n pool.set_unavailable(2)\\n else:\\n self.set_pool_unavailable(pool, err)\\n\\n self._check_unavailable_pools(settings)\\n # Try next pool with the same priority\\n pool = self._get_next_pool(pools, cur_priority)\\n\\n if pool is None:\\n cur_priority = self._get_next_priority(pools, cur_priority)\\n settings[\\\"cur_priority\\\"] = cur_priority\\n pool = self._get_next_pool(pools, cur_priority)\\n if pool is None:\\n msg = \\\"\\\\n \\\".join(error_list)\\n raise PoolError(\\n \\\"Unable to connect to any of the target hosts: \\\"\\n f\\\"[\\\\n {msg}\\\\n]\\\"\\n ) from err\\n continue\\n\\n raise PoolError(\\\"Unable to connect to any of the target hosts\\\")\",\n \"def new_connection(self, transport):\\n assert transport not in self.clients\\n self.clients[transport] = Client(transport, self)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6629559","0.6570917","0.6535228","0.6433502","0.6412028","0.63429385","0.6253376","0.62532514","0.6220175","0.6215806","0.6163777","0.6153525","0.6101365","0.60986865","0.6085492","0.6082639","0.60321325","0.6022872","0.6020028","0.60199386","0.60167944","0.6006047","0.59890467","0.59516644","0.5941077","0.59404624","0.59235156","0.5913177","0.5895725","0.5890192","0.58861935","0.5875251","0.5847373","0.5839724","0.58365697","0.58203983","0.5808671","0.5804265","0.5780873","0.5751662","0.57491064","0.574842","0.5740722","0.57365906","0.5721425","0.5719345","0.571577","0.5705293","0.57042813","0.56954044","0.5692466","0.5685604","0.56851655","0.56692946","0.56548965","0.5653738","0.5653033","0.56522804","0.56440675","0.5644041","0.56412506","0.5639435","0.5639027","0.56379","0.562907","0.56157047","0.56083685","0.5600093","0.55909985","0.5577723","0.5574844","0.5571555","0.55682987","0.555974","0.55571723","0.555293","0.5551421","0.5549388","0.55491245","0.55467904","0.554554","0.55438876","0.55376196","0.5537277","0.5536556","0.55217344","0.5519845","0.5519393","0.55190617","0.55190396","0.55153716","0.5514638","0.550928","0.55022734","0.54974395","0.54922986","0.5491469","0.5491064","0.5485658","0.548533"],"string":"[\n \"0.6629559\",\n \"0.6570917\",\n \"0.6535228\",\n \"0.6433502\",\n \"0.6412028\",\n \"0.63429385\",\n \"0.6253376\",\n \"0.62532514\",\n \"0.6220175\",\n \"0.6215806\",\n \"0.6163777\",\n \"0.6153525\",\n \"0.6101365\",\n \"0.60986865\",\n \"0.6085492\",\n \"0.6082639\",\n \"0.60321325\",\n \"0.6022872\",\n \"0.6020028\",\n \"0.60199386\",\n \"0.60167944\",\n \"0.6006047\",\n \"0.59890467\",\n \"0.59516644\",\n \"0.5941077\",\n \"0.59404624\",\n \"0.59235156\",\n \"0.5913177\",\n \"0.5895725\",\n \"0.5890192\",\n \"0.58861935\",\n \"0.5875251\",\n \"0.5847373\",\n \"0.5839724\",\n \"0.58365697\",\n \"0.58203983\",\n \"0.5808671\",\n \"0.5804265\",\n \"0.5780873\",\n \"0.5751662\",\n \"0.57491064\",\n \"0.574842\",\n \"0.5740722\",\n \"0.57365906\",\n \"0.5721425\",\n \"0.5719345\",\n \"0.571577\",\n \"0.5705293\",\n \"0.57042813\",\n \"0.56954044\",\n \"0.5692466\",\n \"0.5685604\",\n \"0.56851655\",\n \"0.56692946\",\n \"0.56548965\",\n \"0.5653738\",\n \"0.5653033\",\n \"0.56522804\",\n \"0.56440675\",\n \"0.5644041\",\n \"0.56412506\",\n \"0.5639435\",\n \"0.5639027\",\n \"0.56379\",\n \"0.562907\",\n \"0.56157047\",\n \"0.56083685\",\n \"0.5600093\",\n \"0.55909985\",\n \"0.5577723\",\n \"0.5574844\",\n \"0.5571555\",\n \"0.55682987\",\n \"0.555974\",\n \"0.55571723\",\n \"0.555293\",\n \"0.5551421\",\n \"0.5549388\",\n \"0.55491245\",\n \"0.55467904\",\n \"0.554554\",\n \"0.55438876\",\n \"0.55376196\",\n \"0.5537277\",\n \"0.5536556\",\n \"0.55217344\",\n \"0.5519845\",\n \"0.5519393\",\n \"0.55190617\",\n \"0.55190396\",\n \"0.55153716\",\n \"0.5514638\",\n \"0.550928\",\n \"0.55022734\",\n \"0.54974395\",\n \"0.54922986\",\n \"0.5491469\",\n \"0.5491064\",\n \"0.5485658\",\n \"0.548533\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6910743"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94499,"cells":{"query":{"kind":"string","value":"Just like connection, but returns a tuple with a connection and a cursor"},"document":{"kind":"string","value":"def connectionCursorPair(self, name=None):\n connection = self.connection(name)\n return (connection, connection.cursor())"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def conn_curs():\n dbname = \"abcdefgh\"\n password = \"Acka-1jfue4-snYmkall\"\n host = \"db.elephantsql.com\"\n\n connection = psycopg2.connect(dbname=dbname, user=dbname,\n password=password, host=host)\n cursor = connection.cursor()\n return connection, cursor","def get_connection(db: str=None) -> Tuple[connection, cursor]:\n if not db:\n db = DB_NAME\n conn = psycopg2.connect(f\"host={DB_HOST} dbname={db} user={DB_USER} password={DB_PASSWORD}\")\n conn.set_session(autocommit=True)\n cur = conn.cursor()\n\n return conn, cur","def get_cursor():\n cur = conn.cursor(cursor_factory=DictCursor)\n return cur","def get_cursor():\n return _thread_local.connection.cursor()","def _getConnection():\n db = sqlite.connect(db_path)\n db.row_factory = sqlite.Row\n cursor = db.cursor()\n return cursor, db","def cursor(self) -> NamedTupleCursor:\n return self.connection.cursor","def get_postgres_conn_and_cursor(user, password, host):\n\n conn = psycopg2.connect(user=user, password=password, host=host, connect_timeout=10)\n cursor = conn.cursor()\n\n return conn, cursor","def cursor(self):\n return self._conn.cursor()","def cursor():\n dbh = handle()\n return dbh.cursor()","def get_database_conn_and_cursor(database: str) -> None:\n # Connect to DB (or create if does not exist)\n conn = sqlite3.connect(database)\n cursor = conn.cursor()\n return conn, cursor","def __get_cursor():\n try:\n return mysql_conn.cursor()\n except OperationalError:\n mysql_conn.ping(reconnect=True)\n return mysql_conn.cursor()","def __get_cursor():\n try:\n return mysql_conn.cursor()\n except OperationalError:\n mysql_conn.ping(reconnect=True)\n return mysql_conn.cursor()","def cursor(self):\n if self.__connection is None:\n self.connect()\n return self.__connection.cursor()","def connect():\n conn = psycopg2.connect(\"dbname=tournament\")\n cursor = conn.cursor()\n return conn, cursor","def _get_cursor(self):\n conn = self._connect()\n conn.autocommit = True\n cursor = conn.cursor()\n return cursor","def _cursor(self):\n cursor = self.conn.cursor()\n\n return cursor","def get_database_cursor(conn=None):\n\n if not conn:\n conn = get_database_connection()\n\n return conn.cursor()","def get_db_conn_and_cursor():\n parse.uses_netloc.append(\"postgres\")\n\n url = parse.urlparse(os.environ[\"DATABASE_URL\"])\n conn = psycopg2.connect(\n database=url.path[1:],\n user=url.username,\n password=url.password,\n host=url.hostname,\n port=url.port\n )\n cur = conn.cursor()\n\n return conn, cur","def get_connection(self):\n self._logger.info(ME + '.get_connection()')\n #self._logger.debug(str(CONNECTION_VALUES))\n tmp_connection = mysql.connector.connect(\n user =CONNECTION_VALUES['user'],\n password=CONNECTION_VALUES['passwd'],\n database=CONNECTION_VALUES['schema'],\n host =CONNECTION_VALUES['host'],\n port =CONNECTION_VALUES['port']\n )\n tmp_cursor = tmp_connection.cursor()\n\n return tmp_connection, tmp_cursor","def cursor():\n return get_dbconn(\"nldn\").cursor()","def database_connection():\n conn = psycopg2.connect(\n host=server,\n database=database,\n user=postgres_username,\n password=postgres_password,\n port=port)\n cursor = conn.cursor()\n return conn, cursor","def cursor(self):\n return self.conn.cursor()","def __enter__(self) -> 'cursor':\n self.conn = pymysql.connect(self.configuration)\n #self.conn = pyodbc.connect(self.configuration)\n self.cursor = self.conn.cursor()\n return self.cursor","def cursor(self):\n with self.conn as c:\n yield c.cursor()","def cursor(self):\n with self.conn as c:\n yield c.cursor()","def __enter__(self) -> 'DBcursor':\n self.conn = connector.connect(**self.dbconfig)\n self.cursor = self.conn.cursor()\n return self.cursor","def get_cursor(self):\n return self.connection.cursor()","def connect():\n try:\n conn = psycopg2.connect(\"dbname=tournament\")\n cursor = conn.cursor()\n return conn, cursor\n except:\n print(\"Cannot connect to database!\")","def get_cursor(self):\n try:\n self.cursor = self.connection.cursor()\n logging.getLogger(__name__).info(\"Cursor was created.\")\n except Error as er:\n logging.getLogger(__name__).error(\"Something went wrong with cursor creating. %s\" %er)\n finally:\n return self.cursor","def create_cursor(self):\r\n cursor = self.connection.cursor()\r\n return cursor","def execute_command_get_connection(self, sql_command, args):\n connection = sqlite3.connect(DATABASE_PATH.format(self.bot.root))\n cursor = connection.cursor()\n cursor.execute(sql_command, args)\n connection.commit()\n return cursor, connection","def get_cursor():\n db = getattr(g, '_database', None)\n if db is None:\n db = g._database = connect_db()\n return db.cursor()","def __enter__(self) -> 'cursor':\n self.conn = cx_Oracle.connect(self.configuration)\n self.cursor = self.conn.cursor()\n return self.cursor","def cur(self):\n return self.conn.cursor()","def openConn():\n\t#abstract the user,passwd,db,host fields in a config file next\n\tconnection = sql.connect(user=\"root\",passwd=\"sct\",db=\"sct\")\n\tcursor = connection.cursor()\n\treturn connection,cursor","def _solve_conn_curs(conn_or_curs):\n if conn_or_curs is None:\n raise psycopg2.ProgrammingError(\"no connection or cursor provided\")\n\n if hasattr(conn_or_curs, 'execute'):\n conn = conn_or_curs.connection\n curs = conn.cursor(cursor_factory=ext.cursor)\n\n # Django wrapper\n mod = sys.modules.get('django.db.backends.utils')\n if mod is not None:\n if isinstance(conn_or_curs, mod.CursorWrapper):\n conn_or_curs = conn_or_curs.cursor\n else:\n conn = conn_or_curs\n curs = conn.cursor(cursor_factory=ext.cursor)\n conn_or_curs = curs.connection\n\n return conn, curs, conn_or_curs","def get_cursor(self):\n self.cur = self.dbcon.cursor()\n return self.cur","def cursor(self):\n with self.connection() as conn:\n cursor = conn.cursor(prepared=True)\n try:\n yield cursor\n finally:\n cursor.close()","def connect(dbname=\"news\"):\r\n try:\r\n conn = psycopg2.connect(\"dbname={}\".format(dbname))\r\n cur = conn.cursor()\r\n return conn, cur\r\n except (Exception, psycopg2.DatabaseError) as error:\r\n print(error)","def __cursor(cls):\n print('|-- Richiesta cursore da:'+str(cls.__dbCon))\n return cls.__dbCon.cursor( cursor_factory = psycopg2.extras.DictCursor )","def get_cursor(self):\n return self.conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)","def get_cursor(self, *args, **kwargs):","def connect():\n conn = sqlite3.connect(\"tournament.db\")\n c = conn.cursor()\n return conn, c","def _get_db_connection():\n conn = sqlite3.connect(str(DB_FILE_PATH))\n c = conn.cursor()\n\n return conn, c","def get_cursor(file_name):\n con = lite.connect(file_name)\n con.row_factory = lite.Row\n return con.cursor()","def query(cursor, query):\n out = []\n c = cursor.execute(query)\n out.append(c.fetchall())\n # will return list of tuples for each query\n return out","def connect(sql, query, conn):\n cursor = conn.cursor() # Return the cursor and use it to perform queries.\n\n # Execute the query.\n if query == 'no_query': # If we're just running an SQL query without a variable, only execute the sql\n cursor.execute(sql)\n else:\n cursor.execute(sql, query) # If we have a variable (e.g. an FBgn) be sure to include it in the execute command.\n \n records = cursor.fetchall() # Grab the results.\n cursor.close() # Close the cursor.\n return records # Return a list of tuples.","def getCursor(self) -> sqlite3:\n return self.cursor","def connect(db_name=\"tournament\"):\n try:\n conn = psycopg2.connect(\"dbname={}\".format(db_name))\n cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)\n return conn, cur\n except:\n print(\"Error connecting to the \" + db_name + \" database.\")","def get_conn(args):\n\n if args == 'localhost':\n conn = pymysql.connect(\"localhost\", \"root\", \"\", \"song_identifier\")\n elif args == 'remote':\n conn = pymysql.connect(\n host=MYSQL_HOST,\n port=MYSQL_PORT,\n user=MYSQL_USER,\n password=MYSQL_PASSWORD,\n db=MYSQL_DB\n )\n\n return [conn, conn.cursor()]","def connect():\n try:\n conn = psycopg2.connect(\"dbname = score_it\")\n except psycopg2.DatabaseError:\n print \"The program could not connect to the database!\"\n sys.exit(1)\n except psycopg2.InterfaceError:\n print (\"The program could not connect to the database because of \"\\\n \"a connection.\")\n sys.exit(1)\n else:\n cursor = conn.cursor()\n return conn, cursor","def get_cursor(self, commit=True):\n\t\tconnection = pg8000.connect(**self._dsn)\n\t\tcursor = RigorCursor(connection.cursor())\n\t\ttry:\n\t\t\tyield cursor\n\t\texcept pg8000.IntegrityError as error:\n\t\t\texc_info = sys.exc_info()\n\t\t\tself.rollback(cursor)\n\t\t\traise rigor.database.IntegrityError, exc_info[1], exc_info[2]\n\t\texcept pg8000.DatabaseError as error:\n\t\t\texc_info = sys.exc_info()\n\t\t\tself.rollback(cursor)\n\t\t\traise rigor.database.DatabaseError, exc_info[1], exc_info[2]\n\t\texcept:\n\t\t\texc_info = sys.exc_info()\n\t\t\tself.rollback(cursor)\n\t\t\traise exc_info[0], exc_info[1], exc_info[2]\n\t\telse:\n\t\t\tif commit:\n\t\t\t\tself.commit(cursor)\n\t\t\telse:\n\t\t\t\tself.rollback(cursor)","def connect():\n try:\n db = psycopg2.connect(\"dbname=tournament\")\n cursor = db.cursor()\n return db, cursor\n except:\n print \"Can not connect to the tournament database\"","def connect_to_database(database_connection):\n conn = psycopg2.connect(database_connection)\n return conn, conn.cursor()","def connect(db_name='news'):\n try:\n db = psycopg2.connect(dbname=\"{}\".format(db_name))\n cursor = db.cursor()\n return db, cursor\n except psycopg2.DatabaseError as e:\n print('Error connecting to the database: {}'.format(e.pgerror))","def lite_connect(path):\n\n con = sqlite3.connect(path)\n cur = con.cursor()\n\n return con, cur","def connection_database(db_name, host, user, password, local, ssl_ca):\r\n if local:\r\n conn = mysql.connector.connect(\r\n host=host,\r\n user=user,\r\n passwd=password,\r\n database=db_name\r\n )\r\n else:\r\n conn = mysql.connector.connect(\r\n host=host,\r\n user=user,\r\n passwd=password,\r\n database=db_name,\r\n ssl_ca=ssl_ca\r\n )\r\n\r\n cursor = conn.cursor()\r\n return conn, cursor","def connect(database_name):\n try:\n db = psycopg2.connect(\"dbname={}\".format(database_name))\n except psycopg2.Error as err:\n print(\"Unable to connect!\")\n print(err)\n sys.exit(1) # Then perhaps exit the program -- The easier method\n else:\n print(\"Connected!\")\n cursor = db.cursor()\n return db, cursor\n \"\"\"\n db, cursor : is a tuple.\n The first element (db) is a connection to the database.\n The second element (cursor) is a cursor for the database.\n \"\"\"","def connect():\n\tconn = sqlite3.connect('data\\\\strmr.db')\n\tc = conn.cursor()\n\treturn c, conn","def cursor(self):\r\n if self._closed:\r\n raise Error('The connection to the database has been closed.')\r\n return Cursor(self)","def open_conn ():\n\n try:\n conn = pymysql.connect(host = _host,\n port = _port,\n user = _usr,\n passwd = _pwd,\n db = _db)\n conn.autocommit(True)\n\n except Exception as ex:\n print(\"Error - open_conn: {0}\".format(ex))\n rc_err = ex.args[0]\n return rc_err\n\n return rc_ok, conn","def newConn():\n g = sql.connect('user.db')\n e = g.cursor()\n return {\n \"close\": g.close,\n \"commit\": g.commit,\n \"cursor\": e\n }","def _connect_db():\n try:\n conn = connect()\n cur = conn.cursor() \n yield conn, cur\n\n finally:\n cur.close()\n conn.close()","def connect(database_name=\"tournament\"):\n try: \n db = psycopg2.connect(\"dbname={}\".format(database_name))\n cursor = db.cursor()\n return db, cursor\n except:\n print \"Error Connecting to Database\"","def oracle_cursor(query):\n conf_file_dir = os.path.dirname(os.path.realpath(__file__))\n conf_file = conf_file_dir + os.sep + '.setup.conf'\n (username, password, host, port, sid) = credential_setup(conf_file)\n dsn_tns = cx_Oracle.makedsn(host, port, sid)\n connection = cx_Oracle.connect(username, password, dsn_tns)\n cursor = connection.cursor()\n cursor.execute(query)\n\n return cursor","def yield_db_cursor(connect_params=DB_PARAMS, cursor_type=DictCursor):\n\n with psycopg2.connect(**connect_params) as con:\n with con.cursor(cursor_factory=cursor_type) as cur:\n yield cur","def exec_get_cur(self, request, params={}, extra_params = None):\n con = self.create_connection()\n cur = con.cursor()\n cur_exec(cur, request, params)\n return cur","def connect(sqlite_file):\n conn = sqlite3.connect(sqlite_file)\n c = conn.cursor()\n return conn, c","def db_create_cursor(self, database_name):\n\n cursor = self.connections[database_name].cursor()\n return cursor","def connect_and_execute(self, fun: Callable[[Cursor], list]) -> Tuple[bool, list]:\n\t\tcursor = None\n\t\tconnection = None\n\t\tsuccess = True\n\t\tret = []\n\t\t\n\t\ttry:\n\t\t\tconnection = pg.connect(user=self.username,\n\t\t\t password=self.password,\n\t\t\t host=self.host,\n\t\t\t port=self.port,\n\t\t\t database=self.database)\n\t\t\tconnection.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)\n\t\t\tcursor = connection.cursor(cursor_factory=DictCursor)\n\n\t\t\tret = fun(cursor)\n\t\texcept pg.Error as error:\n\t\t\tslog.error(f\"Error accessing database: {error}\")\n\t\t\tsuccess = False\n\t\tfinally:\n\t\t\tif cursor:\n\t\t\t\tcursor.close()\n\t\t\t\t\n\t\t\tif connection:\n\t\t\t\tconnection.close()\n\t\t\t\n\t\treturn success, ret","def conn(self):\n self.cnx = psycopg2.connect(**self.dbConfig) \n self.cur = self.cnx.cursor()","def db_connect(db):\n logger.debug(\"Connecting to %s on %s\", db['name'], db['host'])\n try:\n conn = MySQLdb.connect(host=db['host'], user=db['user'],\n passwd=db['password'], db=db['name'])\n except MySQLdb.Error as err:\n sql_error(err)\n try:\n cursor = conn.cursor()\n return(conn, cursor)\n except MySQLdb.Error as err:\n sql_error(err)","def db_connect(db):\n logger.debug(\"Connecting to %s on %s\", db['name'], db['host'])\n try:\n conn = MySQLdb.connect(host=db['host'], user=db['user'],\n passwd=db['password'], db=db['name'])\n except MySQLdb.Error as err:\n sql_error(err)\n try:\n cursor = conn.cursor()\n return(conn, cursor)\n except MySQLdb.Error as err:\n sql_error(err)","def cdr_cursor(self):\n\n if not hasattr(self, \"_cdr_cursor\"):\n opts = dict(tier=self.tier, user=\"CdrGuest\")\n self._cdr_cursor = db.connect(**opts).cursor()\n return self._cdr_cursor","def cursor(self):\n return self._adapter.cursor()","def db_connection(query):\n db = psycopg2.connect(database=DBNAME)\n c = db.cursor()\n c.execute(query)\n return c.fetchall()\n db.close()","def establishConnection():\r\n global USER\r\n global PW\r\n global HOST\r\n global DB\r\n try:\r\n cnx = mysql.connector.connect(user=USER, password=PW, host=HOST, database=DB)\r\n cursor = cnx.cursor()\r\n return cnx, cursor\r\n except mysql.connector.Error as err:\r\n if err.errno == mysql.connector.errorcode.ER_ACCESS_DENIED_ERROR:\r\n print(\"Something is wrong with your user name or password\")\r\n elif err.errno == mysql.connector.errorcode.ER_BAD_DB_ERROR:\r\n print(\"Database does not exist\")\r\n else:\r\n print(\"Could not establish connection\")\r\n print(err)\r\n sys.exit(1)\r\n except:\r\n print(\"Could not establish connection\")\r\n sys.exit(1)","def connect_database(db_name):\n global CON\n if not CON:\n CON = psycopg2.connect(\"dbname ='%s' user='%s' host=/tmp/\" % (db_name, USER))\n cur = CON.cursor()\n return CON, cur","def connect():\n conn = None\n try:\n # read connection parameters\n params = config()\n \n # connect to the PostgreSQL server\n print('Connecting to the PostgreSQL database...')\n conn = psycopg2.connect(**params)\n \n # create a cursor\n cur = conn.cursor()\n \n # execute a statement\n print('PostgreSQL database version:')\n cur.execute('SELECT version()')\n \n # display the PostgreSQL database server version\n db_version = cur.fetchone()\n print(db_version)\n \n return conn, cur\n # close the communication with the PostgreSQL\n cur.close()\n except (Exception, psycopg2.DatabaseError) as error:\n print(error)\n finally:\n if conn is not None:\n conn.close()\n print('Database connection closed.')","def database_connect():\n try:\n connector = sqlite3.connect(\"data/swapi.dat\")\n connector.row_factory = sqlite3.Row\n cursor = connector.cursor()\n except Exception as e:\n raise Exception(\"An error occurred while opening the database : %s\" % e)\n\n return connector, cursor","async def get(self):\n if self._connect_kwargs == None:\n raise IllegalAccessError(\"DB connection parameters not set yet\")\n\n if not hasattr(self._tl, \"conn\"):\n self._tl.conn = await r.connect(**self._connect_kwargs)\n\n return self._tl.conn","def cursor_with_rows(condition, database, table):\n connection = sqlite3.connect(database)\n connection.row_factory = sqlite3.Row\n cursor = connection.cursor()\n cursor.execute('SELECT * FROM ' + table + ' WHERE ' + condition)\n return cursor, connection","def cursor(cls) -> Iterator[sqlite3.Cursor]:\n with closing(cls.db.cursor()) as cur:\n yield cur","def open_db(filename: str) -> Tuple[sqlite3.Connection, sqlite3.Cursor]:\n db_connection = sqlite3.connect(filename) # Create or connect to DB\n cursor = db_connection.cursor() # Read/write data\n return db_connection, cursor","def con(database):\r\n \r\n conn = sqlite3.connect(database)\r\n db = conn.cursor()\r\n return [conn, db]","def connect(self) -> ContextManager[Connection]:","def get_conn(self, *args, **kwargs):\n connections = self.__connections_for('get_conn', args=args, kwargs=kwargs)\n\n if len(connections) == 1:\n return connections[0]\n else:\n return connections","def dbcursor(self):\n return self.__dbcursor","def getconnection(self):\n\n # If we were able to create the affix_tcpsocket, then we attempt to call\n # getconnection() on the affix tcp server socket first. If we were unable \n # to create it or get a SocketWouldBlockError, we default to the basic\n # repy getconnection() call. The reason for this is to ensure that even\n # if the affixstack breaks down, we are able to revert to the default repy\n # connection.\n if self.tcpserversocket_dict['affix_tcpsocket']:\n try:\n rip, rport, sockobj = self.tcpserversocket_dict['affix_tcpsocket'].getconnection()\n return (rip, rport, AffixSocket(sockobj, self.affix_object)) \n except SocketWouldBlockError:\n pass\n\n return self.tcpserversocket_dict['repy_tcpsocket'].getconnection()","def _get_connection(self) -> Connection:\n # TODO(101) is there a problem with having just one db connection?\n # Will this cause bugs with failed commits?\n curr_thread = threading.get_ident()\n if curr_thread not in self.conn or self.conn[curr_thread] is None:\n try:\n conn = sqlite3.connect(self.db_path)\n conn.row_factory = StringIDRow\n self.conn[curr_thread] = conn\n except sqlite3.Error as e:\n raise MephistoDBException(e)\n return self.conn[curr_thread]","def cursor(file_name):\n con = sql.connect(file_name)\n con.row_factory = sql.Row\n return con.cursor()","def managed_cursor(self, cursor_factory=None):\n\n self.conn_url = (f'postgresql://{self.user}:{self.password}@{self.host}:{self.port}/{self.db}')\n self.conn = psycopg2.connect(self.conn_url)\n self.conn.autocommit = True\n self.curr = self.conn.cursor(cursor_factory=cursor_factory)\n try:\n yield self.curr\n finally:\n self.curr.close()\n self.conn.close()","def __connect(self):\n session, metadata, connection = db(dbhost=getattr(self, \"host\"),\n dbuser=getattr(self, \"user\"),\n dbpass=getattr(self, \"password\"),\n dbname=getattr(self, \"dbname\"))\n return session, metadata, connection","def connect_to_data_base():\n try:\n connection = psycopg2.connect(**DATA_CONNECTION)\n\n cursor = connection.cursor()\n\n cursor.execute(\"SELECT version();\")\n #record = cursor.fetchone()\n \n print(\"{} \\t Conexión Base de datos realizada con éxito\".format(datetime.now()))\n \n return connection, cursor\n\n except (Exception, psycopg2.Error) as error:\n print(\"{} \\t Error en el método connect_to_data_base\".format(datetime.now()))\n print(\"Error en la conexión a la base de datos\", error)\n \n return None","def get_cursor(self):\n return self.cursor","def Database_Connection(self):\n # Database connection\n try: \n # Connect to DB- mysql.connector\n connection = mysql.connector.connect(\n user=self.user,\n password=self.password,\n host=self.host,\n database=self.database\n )\n # Create cursor\n cursor = connection.cursor(prepared=True)\n except mysql.connector.Error as error:\n return print(\"Failed to execute stored procedure: {}\".format(error))\n \n finally:\n if (connection.is_connected()):\n cursor.close()\n return [\"Connection Established\", connection]","def reconnect():\n\tcnx = mysql.connector.connect(pool_name= \"mypool\", pool_size=6, user=MYSQL_USER, password=MYSQL_PW, host=MYSQL_HOST, database='test',charset='utf8mb4', collation='utf8mb4_general_ci', get_warnings=True, connection_timeout=3600)\n\treturn (cnx.cursor(), cnx)","def connect_to_db(query=None):\n conn = None\n cursor = None\n DB_URL = app.config[\"DATABASE_URI\"]\n try:\n # connect to db\n conn = psycopg2.connect(DB_URL)\n print(\"\\n\\nConnected {}\\n\".format(conn.get_dsn_parameters()))\n cursor = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)\n\n if query:\n # Execute query\n cursor.execute(query)\n # Commit changes\n conn.commit()\n\n except(Exception,\n psycopg2.DatabaseError,\n psycopg2.ProgrammingError) as error:\n print(\"DB ERROR: {}\".format(error))\n return conn, cursor","def __enter__(self):\n return self.cursor","def __enter__(self):\n try:\n self.conn = sqlite3.connect(self.database_configuration)\n self.cursor = self.conn.cursor()\n\n return self.cursor\n except Exception as error:\n print(f\"DBCM::__enter__::{error}\")"],"string":"[\n \"def conn_curs():\\n dbname = \\\"abcdefgh\\\"\\n password = \\\"Acka-1jfue4-snYmkall\\\"\\n host = \\\"db.elephantsql.com\\\"\\n\\n connection = psycopg2.connect(dbname=dbname, user=dbname,\\n password=password, host=host)\\n cursor = connection.cursor()\\n return connection, cursor\",\n \"def get_connection(db: str=None) -> Tuple[connection, cursor]:\\n if not db:\\n db = DB_NAME\\n conn = psycopg2.connect(f\\\"host={DB_HOST} dbname={db} user={DB_USER} password={DB_PASSWORD}\\\")\\n conn.set_session(autocommit=True)\\n cur = conn.cursor()\\n\\n return conn, cur\",\n \"def get_cursor():\\n cur = conn.cursor(cursor_factory=DictCursor)\\n return cur\",\n \"def get_cursor():\\n return _thread_local.connection.cursor()\",\n \"def _getConnection():\\n db = sqlite.connect(db_path)\\n db.row_factory = sqlite.Row\\n cursor = db.cursor()\\n return cursor, db\",\n \"def cursor(self) -> NamedTupleCursor:\\n return self.connection.cursor\",\n \"def get_postgres_conn_and_cursor(user, password, host):\\n\\n conn = psycopg2.connect(user=user, password=password, host=host, connect_timeout=10)\\n cursor = conn.cursor()\\n\\n return conn, cursor\",\n \"def cursor(self):\\n return self._conn.cursor()\",\n \"def cursor():\\n dbh = handle()\\n return dbh.cursor()\",\n \"def get_database_conn_and_cursor(database: str) -> None:\\n # Connect to DB (or create if does not exist)\\n conn = sqlite3.connect(database)\\n cursor = conn.cursor()\\n return conn, cursor\",\n \"def __get_cursor():\\n try:\\n return mysql_conn.cursor()\\n except OperationalError:\\n mysql_conn.ping(reconnect=True)\\n return mysql_conn.cursor()\",\n \"def __get_cursor():\\n try:\\n return mysql_conn.cursor()\\n except OperationalError:\\n mysql_conn.ping(reconnect=True)\\n return mysql_conn.cursor()\",\n \"def cursor(self):\\n if self.__connection is None:\\n self.connect()\\n return self.__connection.cursor()\",\n \"def connect():\\n conn = psycopg2.connect(\\\"dbname=tournament\\\")\\n cursor = conn.cursor()\\n return conn, cursor\",\n \"def _get_cursor(self):\\n conn = self._connect()\\n conn.autocommit = True\\n cursor = conn.cursor()\\n return cursor\",\n \"def _cursor(self):\\n cursor = self.conn.cursor()\\n\\n return cursor\",\n \"def get_database_cursor(conn=None):\\n\\n if not conn:\\n conn = get_database_connection()\\n\\n return conn.cursor()\",\n \"def get_db_conn_and_cursor():\\n parse.uses_netloc.append(\\\"postgres\\\")\\n\\n url = parse.urlparse(os.environ[\\\"DATABASE_URL\\\"])\\n conn = psycopg2.connect(\\n database=url.path[1:],\\n user=url.username,\\n password=url.password,\\n host=url.hostname,\\n port=url.port\\n )\\n cur = conn.cursor()\\n\\n return conn, cur\",\n \"def get_connection(self):\\n self._logger.info(ME + '.get_connection()')\\n #self._logger.debug(str(CONNECTION_VALUES))\\n tmp_connection = mysql.connector.connect(\\n user =CONNECTION_VALUES['user'],\\n password=CONNECTION_VALUES['passwd'],\\n database=CONNECTION_VALUES['schema'],\\n host =CONNECTION_VALUES['host'],\\n port =CONNECTION_VALUES['port']\\n )\\n tmp_cursor = tmp_connection.cursor()\\n\\n return tmp_connection, tmp_cursor\",\n \"def cursor():\\n return get_dbconn(\\\"nldn\\\").cursor()\",\n \"def database_connection():\\n conn = psycopg2.connect(\\n host=server,\\n database=database,\\n user=postgres_username,\\n password=postgres_password,\\n port=port)\\n cursor = conn.cursor()\\n return conn, cursor\",\n \"def cursor(self):\\n return self.conn.cursor()\",\n \"def __enter__(self) -> 'cursor':\\n self.conn = pymysql.connect(self.configuration)\\n #self.conn = pyodbc.connect(self.configuration)\\n self.cursor = self.conn.cursor()\\n return self.cursor\",\n \"def cursor(self):\\n with self.conn as c:\\n yield c.cursor()\",\n \"def cursor(self):\\n with self.conn as c:\\n yield c.cursor()\",\n \"def __enter__(self) -> 'DBcursor':\\n self.conn = connector.connect(**self.dbconfig)\\n self.cursor = self.conn.cursor()\\n return self.cursor\",\n \"def get_cursor(self):\\n return self.connection.cursor()\",\n \"def connect():\\n try:\\n conn = psycopg2.connect(\\\"dbname=tournament\\\")\\n cursor = conn.cursor()\\n return conn, cursor\\n except:\\n print(\\\"Cannot connect to database!\\\")\",\n \"def get_cursor(self):\\n try:\\n self.cursor = self.connection.cursor()\\n logging.getLogger(__name__).info(\\\"Cursor was created.\\\")\\n except Error as er:\\n logging.getLogger(__name__).error(\\\"Something went wrong with cursor creating. %s\\\" %er)\\n finally:\\n return self.cursor\",\n \"def create_cursor(self):\\r\\n cursor = self.connection.cursor()\\r\\n return cursor\",\n \"def execute_command_get_connection(self, sql_command, args):\\n connection = sqlite3.connect(DATABASE_PATH.format(self.bot.root))\\n cursor = connection.cursor()\\n cursor.execute(sql_command, args)\\n connection.commit()\\n return cursor, connection\",\n \"def get_cursor():\\n db = getattr(g, '_database', None)\\n if db is None:\\n db = g._database = connect_db()\\n return db.cursor()\",\n \"def __enter__(self) -> 'cursor':\\n self.conn = cx_Oracle.connect(self.configuration)\\n self.cursor = self.conn.cursor()\\n return self.cursor\",\n \"def cur(self):\\n return self.conn.cursor()\",\n \"def openConn():\\n\\t#abstract the user,passwd,db,host fields in a config file next\\n\\tconnection = sql.connect(user=\\\"root\\\",passwd=\\\"sct\\\",db=\\\"sct\\\")\\n\\tcursor = connection.cursor()\\n\\treturn connection,cursor\",\n \"def _solve_conn_curs(conn_or_curs):\\n if conn_or_curs is None:\\n raise psycopg2.ProgrammingError(\\\"no connection or cursor provided\\\")\\n\\n if hasattr(conn_or_curs, 'execute'):\\n conn = conn_or_curs.connection\\n curs = conn.cursor(cursor_factory=ext.cursor)\\n\\n # Django wrapper\\n mod = sys.modules.get('django.db.backends.utils')\\n if mod is not None:\\n if isinstance(conn_or_curs, mod.CursorWrapper):\\n conn_or_curs = conn_or_curs.cursor\\n else:\\n conn = conn_or_curs\\n curs = conn.cursor(cursor_factory=ext.cursor)\\n conn_or_curs = curs.connection\\n\\n return conn, curs, conn_or_curs\",\n \"def get_cursor(self):\\n self.cur = self.dbcon.cursor()\\n return self.cur\",\n \"def cursor(self):\\n with self.connection() as conn:\\n cursor = conn.cursor(prepared=True)\\n try:\\n yield cursor\\n finally:\\n cursor.close()\",\n \"def connect(dbname=\\\"news\\\"):\\r\\n try:\\r\\n conn = psycopg2.connect(\\\"dbname={}\\\".format(dbname))\\r\\n cur = conn.cursor()\\r\\n return conn, cur\\r\\n except (Exception, psycopg2.DatabaseError) as error:\\r\\n print(error)\",\n \"def __cursor(cls):\\n print('|-- Richiesta cursore da:'+str(cls.__dbCon))\\n return cls.__dbCon.cursor( cursor_factory = psycopg2.extras.DictCursor )\",\n \"def get_cursor(self):\\n return self.conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)\",\n \"def get_cursor(self, *args, **kwargs):\",\n \"def connect():\\n conn = sqlite3.connect(\\\"tournament.db\\\")\\n c = conn.cursor()\\n return conn, c\",\n \"def _get_db_connection():\\n conn = sqlite3.connect(str(DB_FILE_PATH))\\n c = conn.cursor()\\n\\n return conn, c\",\n \"def get_cursor(file_name):\\n con = lite.connect(file_name)\\n con.row_factory = lite.Row\\n return con.cursor()\",\n \"def query(cursor, query):\\n out = []\\n c = cursor.execute(query)\\n out.append(c.fetchall())\\n # will return list of tuples for each query\\n return out\",\n \"def connect(sql, query, conn):\\n cursor = conn.cursor() # Return the cursor and use it to perform queries.\\n\\n # Execute the query.\\n if query == 'no_query': # If we're just running an SQL query without a variable, only execute the sql\\n cursor.execute(sql)\\n else:\\n cursor.execute(sql, query) # If we have a variable (e.g. an FBgn) be sure to include it in the execute command.\\n \\n records = cursor.fetchall() # Grab the results.\\n cursor.close() # Close the cursor.\\n return records # Return a list of tuples.\",\n \"def getCursor(self) -> sqlite3:\\n return self.cursor\",\n \"def connect(db_name=\\\"tournament\\\"):\\n try:\\n conn = psycopg2.connect(\\\"dbname={}\\\".format(db_name))\\n cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)\\n return conn, cur\\n except:\\n print(\\\"Error connecting to the \\\" + db_name + \\\" database.\\\")\",\n \"def get_conn(args):\\n\\n if args == 'localhost':\\n conn = pymysql.connect(\\\"localhost\\\", \\\"root\\\", \\\"\\\", \\\"song_identifier\\\")\\n elif args == 'remote':\\n conn = pymysql.connect(\\n host=MYSQL_HOST,\\n port=MYSQL_PORT,\\n user=MYSQL_USER,\\n password=MYSQL_PASSWORD,\\n db=MYSQL_DB\\n )\\n\\n return [conn, conn.cursor()]\",\n \"def connect():\\n try:\\n conn = psycopg2.connect(\\\"dbname = score_it\\\")\\n except psycopg2.DatabaseError:\\n print \\\"The program could not connect to the database!\\\"\\n sys.exit(1)\\n except psycopg2.InterfaceError:\\n print (\\\"The program could not connect to the database because of \\\"\\\\\\n \\\"a connection.\\\")\\n sys.exit(1)\\n else:\\n cursor = conn.cursor()\\n return conn, cursor\",\n \"def get_cursor(self, commit=True):\\n\\t\\tconnection = pg8000.connect(**self._dsn)\\n\\t\\tcursor = RigorCursor(connection.cursor())\\n\\t\\ttry:\\n\\t\\t\\tyield cursor\\n\\t\\texcept pg8000.IntegrityError as error:\\n\\t\\t\\texc_info = sys.exc_info()\\n\\t\\t\\tself.rollback(cursor)\\n\\t\\t\\traise rigor.database.IntegrityError, exc_info[1], exc_info[2]\\n\\t\\texcept pg8000.DatabaseError as error:\\n\\t\\t\\texc_info = sys.exc_info()\\n\\t\\t\\tself.rollback(cursor)\\n\\t\\t\\traise rigor.database.DatabaseError, exc_info[1], exc_info[2]\\n\\t\\texcept:\\n\\t\\t\\texc_info = sys.exc_info()\\n\\t\\t\\tself.rollback(cursor)\\n\\t\\t\\traise exc_info[0], exc_info[1], exc_info[2]\\n\\t\\telse:\\n\\t\\t\\tif commit:\\n\\t\\t\\t\\tself.commit(cursor)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.rollback(cursor)\",\n \"def connect():\\n try:\\n db = psycopg2.connect(\\\"dbname=tournament\\\")\\n cursor = db.cursor()\\n return db, cursor\\n except:\\n print \\\"Can not connect to the tournament database\\\"\",\n \"def connect_to_database(database_connection):\\n conn = psycopg2.connect(database_connection)\\n return conn, conn.cursor()\",\n \"def connect(db_name='news'):\\n try:\\n db = psycopg2.connect(dbname=\\\"{}\\\".format(db_name))\\n cursor = db.cursor()\\n return db, cursor\\n except psycopg2.DatabaseError as e:\\n print('Error connecting to the database: {}'.format(e.pgerror))\",\n \"def lite_connect(path):\\n\\n con = sqlite3.connect(path)\\n cur = con.cursor()\\n\\n return con, cur\",\n \"def connection_database(db_name, host, user, password, local, ssl_ca):\\r\\n if local:\\r\\n conn = mysql.connector.connect(\\r\\n host=host,\\r\\n user=user,\\r\\n passwd=password,\\r\\n database=db_name\\r\\n )\\r\\n else:\\r\\n conn = mysql.connector.connect(\\r\\n host=host,\\r\\n user=user,\\r\\n passwd=password,\\r\\n database=db_name,\\r\\n ssl_ca=ssl_ca\\r\\n )\\r\\n\\r\\n cursor = conn.cursor()\\r\\n return conn, cursor\",\n \"def connect(database_name):\\n try:\\n db = psycopg2.connect(\\\"dbname={}\\\".format(database_name))\\n except psycopg2.Error as err:\\n print(\\\"Unable to connect!\\\")\\n print(err)\\n sys.exit(1) # Then perhaps exit the program -- The easier method\\n else:\\n print(\\\"Connected!\\\")\\n cursor = db.cursor()\\n return db, cursor\\n \\\"\\\"\\\"\\n db, cursor : is a tuple.\\n The first element (db) is a connection to the database.\\n The second element (cursor) is a cursor for the database.\\n \\\"\\\"\\\"\",\n \"def connect():\\n\\tconn = sqlite3.connect('data\\\\\\\\strmr.db')\\n\\tc = conn.cursor()\\n\\treturn c, conn\",\n \"def cursor(self):\\r\\n if self._closed:\\r\\n raise Error('The connection to the database has been closed.')\\r\\n return Cursor(self)\",\n \"def open_conn ():\\n\\n try:\\n conn = pymysql.connect(host = _host,\\n port = _port,\\n user = _usr,\\n passwd = _pwd,\\n db = _db)\\n conn.autocommit(True)\\n\\n except Exception as ex:\\n print(\\\"Error - open_conn: {0}\\\".format(ex))\\n rc_err = ex.args[0]\\n return rc_err\\n\\n return rc_ok, conn\",\n \"def newConn():\\n g = sql.connect('user.db')\\n e = g.cursor()\\n return {\\n \\\"close\\\": g.close,\\n \\\"commit\\\": g.commit,\\n \\\"cursor\\\": e\\n }\",\n \"def _connect_db():\\n try:\\n conn = connect()\\n cur = conn.cursor() \\n yield conn, cur\\n\\n finally:\\n cur.close()\\n conn.close()\",\n \"def connect(database_name=\\\"tournament\\\"):\\n try: \\n db = psycopg2.connect(\\\"dbname={}\\\".format(database_name))\\n cursor = db.cursor()\\n return db, cursor\\n except:\\n print \\\"Error Connecting to Database\\\"\",\n \"def oracle_cursor(query):\\n conf_file_dir = os.path.dirname(os.path.realpath(__file__))\\n conf_file = conf_file_dir + os.sep + '.setup.conf'\\n (username, password, host, port, sid) = credential_setup(conf_file)\\n dsn_tns = cx_Oracle.makedsn(host, port, sid)\\n connection = cx_Oracle.connect(username, password, dsn_tns)\\n cursor = connection.cursor()\\n cursor.execute(query)\\n\\n return cursor\",\n \"def yield_db_cursor(connect_params=DB_PARAMS, cursor_type=DictCursor):\\n\\n with psycopg2.connect(**connect_params) as con:\\n with con.cursor(cursor_factory=cursor_type) as cur:\\n yield cur\",\n \"def exec_get_cur(self, request, params={}, extra_params = None):\\n con = self.create_connection()\\n cur = con.cursor()\\n cur_exec(cur, request, params)\\n return cur\",\n \"def connect(sqlite_file):\\n conn = sqlite3.connect(sqlite_file)\\n c = conn.cursor()\\n return conn, c\",\n \"def db_create_cursor(self, database_name):\\n\\n cursor = self.connections[database_name].cursor()\\n return cursor\",\n \"def connect_and_execute(self, fun: Callable[[Cursor], list]) -> Tuple[bool, list]:\\n\\t\\tcursor = None\\n\\t\\tconnection = None\\n\\t\\tsuccess = True\\n\\t\\tret = []\\n\\t\\t\\n\\t\\ttry:\\n\\t\\t\\tconnection = pg.connect(user=self.username,\\n\\t\\t\\t password=self.password,\\n\\t\\t\\t host=self.host,\\n\\t\\t\\t port=self.port,\\n\\t\\t\\t database=self.database)\\n\\t\\t\\tconnection.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)\\n\\t\\t\\tcursor = connection.cursor(cursor_factory=DictCursor)\\n\\n\\t\\t\\tret = fun(cursor)\\n\\t\\texcept pg.Error as error:\\n\\t\\t\\tslog.error(f\\\"Error accessing database: {error}\\\")\\n\\t\\t\\tsuccess = False\\n\\t\\tfinally:\\n\\t\\t\\tif cursor:\\n\\t\\t\\t\\tcursor.close()\\n\\t\\t\\t\\t\\n\\t\\t\\tif connection:\\n\\t\\t\\t\\tconnection.close()\\n\\t\\t\\t\\n\\t\\treturn success, ret\",\n \"def conn(self):\\n self.cnx = psycopg2.connect(**self.dbConfig) \\n self.cur = self.cnx.cursor()\",\n \"def db_connect(db):\\n logger.debug(\\\"Connecting to %s on %s\\\", db['name'], db['host'])\\n try:\\n conn = MySQLdb.connect(host=db['host'], user=db['user'],\\n passwd=db['password'], db=db['name'])\\n except MySQLdb.Error as err:\\n sql_error(err)\\n try:\\n cursor = conn.cursor()\\n return(conn, cursor)\\n except MySQLdb.Error as err:\\n sql_error(err)\",\n \"def db_connect(db):\\n logger.debug(\\\"Connecting to %s on %s\\\", db['name'], db['host'])\\n try:\\n conn = MySQLdb.connect(host=db['host'], user=db['user'],\\n passwd=db['password'], db=db['name'])\\n except MySQLdb.Error as err:\\n sql_error(err)\\n try:\\n cursor = conn.cursor()\\n return(conn, cursor)\\n except MySQLdb.Error as err:\\n sql_error(err)\",\n \"def cdr_cursor(self):\\n\\n if not hasattr(self, \\\"_cdr_cursor\\\"):\\n opts = dict(tier=self.tier, user=\\\"CdrGuest\\\")\\n self._cdr_cursor = db.connect(**opts).cursor()\\n return self._cdr_cursor\",\n \"def cursor(self):\\n return self._adapter.cursor()\",\n \"def db_connection(query):\\n db = psycopg2.connect(database=DBNAME)\\n c = db.cursor()\\n c.execute(query)\\n return c.fetchall()\\n db.close()\",\n \"def establishConnection():\\r\\n global USER\\r\\n global PW\\r\\n global HOST\\r\\n global DB\\r\\n try:\\r\\n cnx = mysql.connector.connect(user=USER, password=PW, host=HOST, database=DB)\\r\\n cursor = cnx.cursor()\\r\\n return cnx, cursor\\r\\n except mysql.connector.Error as err:\\r\\n if err.errno == mysql.connector.errorcode.ER_ACCESS_DENIED_ERROR:\\r\\n print(\\\"Something is wrong with your user name or password\\\")\\r\\n elif err.errno == mysql.connector.errorcode.ER_BAD_DB_ERROR:\\r\\n print(\\\"Database does not exist\\\")\\r\\n else:\\r\\n print(\\\"Could not establish connection\\\")\\r\\n print(err)\\r\\n sys.exit(1)\\r\\n except:\\r\\n print(\\\"Could not establish connection\\\")\\r\\n sys.exit(1)\",\n \"def connect_database(db_name):\\n global CON\\n if not CON:\\n CON = psycopg2.connect(\\\"dbname ='%s' user='%s' host=/tmp/\\\" % (db_name, USER))\\n cur = CON.cursor()\\n return CON, cur\",\n \"def connect():\\n conn = None\\n try:\\n # read connection parameters\\n params = config()\\n \\n # connect to the PostgreSQL server\\n print('Connecting to the PostgreSQL database...')\\n conn = psycopg2.connect(**params)\\n \\n # create a cursor\\n cur = conn.cursor()\\n \\n # execute a statement\\n print('PostgreSQL database version:')\\n cur.execute('SELECT version()')\\n \\n # display the PostgreSQL database server version\\n db_version = cur.fetchone()\\n print(db_version)\\n \\n return conn, cur\\n # close the communication with the PostgreSQL\\n cur.close()\\n except (Exception, psycopg2.DatabaseError) as error:\\n print(error)\\n finally:\\n if conn is not None:\\n conn.close()\\n print('Database connection closed.')\",\n \"def database_connect():\\n try:\\n connector = sqlite3.connect(\\\"data/swapi.dat\\\")\\n connector.row_factory = sqlite3.Row\\n cursor = connector.cursor()\\n except Exception as e:\\n raise Exception(\\\"An error occurred while opening the database : %s\\\" % e)\\n\\n return connector, cursor\",\n \"async def get(self):\\n if self._connect_kwargs == None:\\n raise IllegalAccessError(\\\"DB connection parameters not set yet\\\")\\n\\n if not hasattr(self._tl, \\\"conn\\\"):\\n self._tl.conn = await r.connect(**self._connect_kwargs)\\n\\n return self._tl.conn\",\n \"def cursor_with_rows(condition, database, table):\\n connection = sqlite3.connect(database)\\n connection.row_factory = sqlite3.Row\\n cursor = connection.cursor()\\n cursor.execute('SELECT * FROM ' + table + ' WHERE ' + condition)\\n return cursor, connection\",\n \"def cursor(cls) -> Iterator[sqlite3.Cursor]:\\n with closing(cls.db.cursor()) as cur:\\n yield cur\",\n \"def open_db(filename: str) -> Tuple[sqlite3.Connection, sqlite3.Cursor]:\\n db_connection = sqlite3.connect(filename) # Create or connect to DB\\n cursor = db_connection.cursor() # Read/write data\\n return db_connection, cursor\",\n \"def con(database):\\r\\n \\r\\n conn = sqlite3.connect(database)\\r\\n db = conn.cursor()\\r\\n return [conn, db]\",\n \"def connect(self) -> ContextManager[Connection]:\",\n \"def get_conn(self, *args, **kwargs):\\n connections = self.__connections_for('get_conn', args=args, kwargs=kwargs)\\n\\n if len(connections) == 1:\\n return connections[0]\\n else:\\n return connections\",\n \"def dbcursor(self):\\n return self.__dbcursor\",\n \"def getconnection(self):\\n\\n # If we were able to create the affix_tcpsocket, then we attempt to call\\n # getconnection() on the affix tcp server socket first. If we were unable \\n # to create it or get a SocketWouldBlockError, we default to the basic\\n # repy getconnection() call. The reason for this is to ensure that even\\n # if the affixstack breaks down, we are able to revert to the default repy\\n # connection.\\n if self.tcpserversocket_dict['affix_tcpsocket']:\\n try:\\n rip, rport, sockobj = self.tcpserversocket_dict['affix_tcpsocket'].getconnection()\\n return (rip, rport, AffixSocket(sockobj, self.affix_object)) \\n except SocketWouldBlockError:\\n pass\\n\\n return self.tcpserversocket_dict['repy_tcpsocket'].getconnection()\",\n \"def _get_connection(self) -> Connection:\\n # TODO(101) is there a problem with having just one db connection?\\n # Will this cause bugs with failed commits?\\n curr_thread = threading.get_ident()\\n if curr_thread not in self.conn or self.conn[curr_thread] is None:\\n try:\\n conn = sqlite3.connect(self.db_path)\\n conn.row_factory = StringIDRow\\n self.conn[curr_thread] = conn\\n except sqlite3.Error as e:\\n raise MephistoDBException(e)\\n return self.conn[curr_thread]\",\n \"def cursor(file_name):\\n con = sql.connect(file_name)\\n con.row_factory = sql.Row\\n return con.cursor()\",\n \"def managed_cursor(self, cursor_factory=None):\\n\\n self.conn_url = (f'postgresql://{self.user}:{self.password}@{self.host}:{self.port}/{self.db}')\\n self.conn = psycopg2.connect(self.conn_url)\\n self.conn.autocommit = True\\n self.curr = self.conn.cursor(cursor_factory=cursor_factory)\\n try:\\n yield self.curr\\n finally:\\n self.curr.close()\\n self.conn.close()\",\n \"def __connect(self):\\n session, metadata, connection = db(dbhost=getattr(self, \\\"host\\\"),\\n dbuser=getattr(self, \\\"user\\\"),\\n dbpass=getattr(self, \\\"password\\\"),\\n dbname=getattr(self, \\\"dbname\\\"))\\n return session, metadata, connection\",\n \"def connect_to_data_base():\\n try:\\n connection = psycopg2.connect(**DATA_CONNECTION)\\n\\n cursor = connection.cursor()\\n\\n cursor.execute(\\\"SELECT version();\\\")\\n #record = cursor.fetchone()\\n \\n print(\\\"{} \\\\t Conexión Base de datos realizada con éxito\\\".format(datetime.now()))\\n \\n return connection, cursor\\n\\n except (Exception, psycopg2.Error) as error:\\n print(\\\"{} \\\\t Error en el método connect_to_data_base\\\".format(datetime.now()))\\n print(\\\"Error en la conexión a la base de datos\\\", error)\\n \\n return None\",\n \"def get_cursor(self):\\n return self.cursor\",\n \"def Database_Connection(self):\\n # Database connection\\n try: \\n # Connect to DB- mysql.connector\\n connection = mysql.connector.connect(\\n user=self.user,\\n password=self.password,\\n host=self.host,\\n database=self.database\\n )\\n # Create cursor\\n cursor = connection.cursor(prepared=True)\\n except mysql.connector.Error as error:\\n return print(\\\"Failed to execute stored procedure: {}\\\".format(error))\\n \\n finally:\\n if (connection.is_connected()):\\n cursor.close()\\n return [\\\"Connection Established\\\", connection]\",\n \"def reconnect():\\n\\tcnx = mysql.connector.connect(pool_name= \\\"mypool\\\", pool_size=6, user=MYSQL_USER, password=MYSQL_PW, host=MYSQL_HOST, database='test',charset='utf8mb4', collation='utf8mb4_general_ci', get_warnings=True, connection_timeout=3600)\\n\\treturn (cnx.cursor(), cnx)\",\n \"def connect_to_db(query=None):\\n conn = None\\n cursor = None\\n DB_URL = app.config[\\\"DATABASE_URI\\\"]\\n try:\\n # connect to db\\n conn = psycopg2.connect(DB_URL)\\n print(\\\"\\\\n\\\\nConnected {}\\\\n\\\".format(conn.get_dsn_parameters()))\\n cursor = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)\\n\\n if query:\\n # Execute query\\n cursor.execute(query)\\n # Commit changes\\n conn.commit()\\n\\n except(Exception,\\n psycopg2.DatabaseError,\\n psycopg2.ProgrammingError) as error:\\n print(\\\"DB ERROR: {}\\\".format(error))\\n return conn, cursor\",\n \"def __enter__(self):\\n return self.cursor\",\n \"def __enter__(self):\\n try:\\n self.conn = sqlite3.connect(self.database_configuration)\\n self.cursor = self.conn.cursor()\\n\\n return self.cursor\\n except Exception as error:\\n print(f\\\"DBCM::__enter__::{error}\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.782685","0.74926525","0.7455024","0.7442478","0.7405349","0.73643297","0.7351544","0.73470646","0.73046917","0.72976387","0.7228983","0.7228983","0.72195446","0.7198042","0.7187905","0.71860284","0.71206516","0.70670146","0.70400053","0.700089","0.6969644","0.6957887","0.69361895","0.69332105","0.69332105","0.693161","0.69285685","0.6921353","0.6892348","0.68737084","0.6837959","0.6810987","0.67883295","0.6779637","0.67361724","0.67348325","0.6725115","0.6699735","0.6694126","0.667905","0.664971","0.6639599","0.6613032","0.6582531","0.6573772","0.6573758","0.6572378","0.65677077","0.6558373","0.64900917","0.6450563","0.64467865","0.6401456","0.64002347","0.63846314","0.6378521","0.6357954","0.6340498","0.63400465","0.6327523","0.6311116","0.6306806","0.62848526","0.62677646","0.6260896","0.625898","0.62354225","0.6200104","0.6196281","0.6172133","0.6149286","0.6146511","0.6146511","0.6146032","0.61429816","0.61212945","0.6118619","0.61176485","0.6093662","0.60910755","0.6087561","0.6079957","0.6079521","0.6076415","0.60627687","0.605914","0.6058136","0.6043035","0.60420674","0.60372204","0.6036675","0.6035058","0.6024748","0.6015237","0.6001908","0.5995711","0.59784675","0.5975578","0.5972118","0.5946901"],"string":"[\n \"0.782685\",\n \"0.74926525\",\n \"0.7455024\",\n \"0.7442478\",\n \"0.7405349\",\n \"0.73643297\",\n \"0.7351544\",\n \"0.73470646\",\n \"0.73046917\",\n \"0.72976387\",\n \"0.7228983\",\n \"0.7228983\",\n \"0.72195446\",\n \"0.7198042\",\n \"0.7187905\",\n \"0.71860284\",\n \"0.71206516\",\n \"0.70670146\",\n \"0.70400053\",\n \"0.700089\",\n \"0.6969644\",\n \"0.6957887\",\n \"0.69361895\",\n \"0.69332105\",\n \"0.69332105\",\n \"0.693161\",\n \"0.69285685\",\n \"0.6921353\",\n \"0.6892348\",\n \"0.68737084\",\n \"0.6837959\",\n \"0.6810987\",\n \"0.67883295\",\n \"0.6779637\",\n \"0.67361724\",\n \"0.67348325\",\n \"0.6725115\",\n \"0.6699735\",\n \"0.6694126\",\n \"0.667905\",\n \"0.664971\",\n \"0.6639599\",\n \"0.6613032\",\n \"0.6582531\",\n \"0.6573772\",\n \"0.6573758\",\n \"0.6572378\",\n \"0.65677077\",\n \"0.6558373\",\n \"0.64900917\",\n \"0.6450563\",\n \"0.64467865\",\n \"0.6401456\",\n \"0.64002347\",\n \"0.63846314\",\n \"0.6378521\",\n \"0.6357954\",\n \"0.6340498\",\n \"0.63400465\",\n \"0.6327523\",\n \"0.6311116\",\n \"0.6306806\",\n \"0.62848526\",\n \"0.62677646\",\n \"0.6260896\",\n \"0.625898\",\n \"0.62354225\",\n \"0.6200104\",\n \"0.6196281\",\n \"0.6172133\",\n \"0.6149286\",\n \"0.6146511\",\n \"0.6146511\",\n \"0.6146032\",\n \"0.61429816\",\n \"0.61212945\",\n \"0.6118619\",\n \"0.61176485\",\n \"0.6093662\",\n \"0.60910755\",\n \"0.6087561\",\n \"0.6079957\",\n \"0.6079521\",\n \"0.6076415\",\n \"0.60627687\",\n \"0.605914\",\n \"0.6058136\",\n \"0.6043035\",\n \"0.60420674\",\n \"0.60372204\",\n \"0.6036675\",\n \"0.6035058\",\n \"0.6024748\",\n \"0.6015237\",\n \"0.6001908\",\n \"0.5995711\",\n \"0.59784675\",\n \"0.5975578\",\n \"0.5972118\",\n \"0.5946901\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81536436"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":944,"numItemsPerPage":100,"numTotalItems":95772,"offset":94400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTUwNTg2MSwianRpIjoiMmVhZDAwM2EtYzc3NS00NmQ1LTg1MmUtMDNhM2U3NTAyMzA0Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU1MDk0NjEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.70emDR7ALjH7YNGsUjle_afLrXKNpXuS1zJl-Lrwou1atpFdTOhjZYLCMj1k5mHcHwrAmNzm5xDUOwog-T2KAA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Make smooth animations as predictions are only generated at 500 ms interval | def interpolate(self, interp):
x = np.linspace(0, 29, len(self.ya))
f_ya = interpolate.interp1d(x, self.ya)
f_yv = interpolate.interp1d(x, self.yv)
f_pa = interpolate.interp1d(x, np.reshape(self.pa, [-1]))
f_pv = interpolate.interp1d(x, np.reshape(self.pv, [-1]))
x_inter... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_sim(self):\n self.anim = animation.FuncAnimation(self.fig, self.anim_func, frames = self.timesteps, interval = 1, blit=True)\n plt.show()",
"def do_animations(self):\n self.animate_bloop(700, 160, 50)",
"def animate(frames):\n plt.grid('on')\n ax = plt.gca()\n ax.set_xti... | [
"0.6428782",
"0.6333642",
"0.60175997",
"0.5979958",
"0.59758747",
"0.5957836",
"0.5927737",
"0.5871824",
"0.5776904",
"0.5766929",
"0.5740155",
"0.5687559",
"0.5678273",
"0.5677279",
"0.5654695",
"0.56387275",
"0.5606893",
"0.5543152",
"0.55242366",
"0.5513519",
"0.5459959",... | 0.0 | -1 |
Get frames for the animations | def frame_generator(self, frame_size, frame_step):
num_frames = frame_size
while self.ya:
ya = self.ya[:num_frames]
del self.ya[:frame_step]
yv = self.yv[:num_frames]
del self.yv[:frame_step]
pa = self.pa[:num_frames]
del self.pa[:f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def frames(self):\n return self._frames",
"def getFrames():\n\t\tfor cam in Camera.CAMERAS: cam.getFrame()",
"def frames(self):\n return list(self._frames)",
"def get_frames(self):\n\n log(\"Getting frames for {} at {}\".format(self._location, self._t0))\n fn_get = lambda time_str... | [
"0.7557698",
"0.7542063",
"0.73664993",
"0.7355739",
"0.73070145",
"0.72645676",
"0.70264816",
"0.70152026",
"0.68886703",
"0.6870058",
"0.68352693",
"0.6816862",
"0.6776024",
"0.6679148",
"0.6611184",
"0.643768",
"0.64125896",
"0.6412472",
"0.6395641",
"0.637194",
"0.6355288... | 0.0 | -1 |
create a background with | def __init__(self, map_file, wall, floor, size_img):
# initialize a available positions and size window
dict.__init__(self)
self.available_positions = []
# read the .txt with the background
with open(map_file, "r") as bg_file:
# Initialize position and number of line... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def background_maker():\n background = GRect(window.width, window.height)\n background.filled = True\n background.fill_color = '0xFFFCEC'\n background.color = '0xFFFCEC'\n return background",
"def _build_background(self, name=None):\n if self._background is None:\n self._backgrou... | [
"0.7908",
"0.75448",
"0.7480981",
"0.73289603",
"0.7325924",
"0.72652113",
"0.721995",
"0.71516335",
"0.7125712",
"0.7105341",
"0.7103702",
"0.6967297",
"0.6961718",
"0.6961718",
"0.6940961",
"0.69393766",
"0.69023347",
"0.68646824",
"0.6857636",
"0.68528235",
"0.68311",
"0... | 0.0 | -1 |
Concatenates the cells from the header and footer notebooks to the given cells. | def preprocess(self, nb: NotebookNode, resources: ResourcesDict) -> Tuple[NotebookNode, ResourcesDict]:
new_cells = []
# header
if self.header:
with io.open(self.header, encoding='utf-8') as fh:
header_nb = read_nb(fh, as_version=current_nbformat)
new_cel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def join_markdown_cells(cells: List[Dict]) -> str:\n src = []\n for c in cells:\n cell_src = []\n if c['type'] == 'markdown':\n if 'class' in c:\n cell_src.append(f':begin_tab:{c[\"class\"]}')\n cell_src.append(c['source'])\n if 'class' in c:\n ... | [
"0.6018911",
"0.5785152",
"0.573992",
"0.56964177",
"0.5338453",
"0.5302862",
"0.5278419",
"0.5244307",
"0.52227336",
"0.51981604",
"0.50574815",
"0.50387275",
"0.5030273",
"0.49325353",
"0.49148065",
"0.48783618",
"0.48736855",
"0.48300564",
"0.47832954",
"0.4761173",
"0.475... | 0.55830485 | 4 |
Returns the age stratified population used for case detection testing. Use state denominator for testing rates for the Victorian health cluster models and temporarily use Philippines regional pops for all the Philippines subregions | def get_testing_pop(agegroup_strata: List[str], country: Country, pop: Population):
testing_region = "Victoria" if country.iso3 == "AUS" else pop.region
testing_year = 2020 if country.iso3 == "AUS" else pop.year
testing_pop = inputs.get_population_by_agegroup(
agegroup_strata, country.iso3, testing_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getPopulation(self):\n\n return self.p",
"def test_state(self):\n states = self.geographies.find({ 'geoid': config.SUMLEV_STATE })\n\n self.assertEqual(states.count(), 1)\n\n state = states[0]\n\n self.assertEqual(state['sumlev'], config.SUMLEV_STATE)\n self.assertEq... | [
"0.5675838",
"0.5655509",
"0.5640945",
"0.55368376",
"0.5536563",
"0.55261403",
"0.5399596",
"0.53897786",
"0.53655875",
"0.52701634",
"0.52652085",
"0.5259422",
"0.52373123",
"0.5232317",
"0.5202828",
"0.51550114",
"0.5124957",
"0.51231694",
"0.5122542",
"0.5077461",
"0.5061... | 0.66339207 | 0 |
Returns a time varying function that gives us the proportion of cases detected. | def build_detected_proportion_func(
agegroup_strata: List[str],
country: Country,
pop: Population,
testing: TestingToDetection,
case_detection: CaseDetection,
):
if testing is not None:
# More empiric approach based on per capita testing rates
assumed_tests_parameter = testing.as... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process(self, compartment_values, computed_values, time):\n return self.detected_proportion_func(time)",
"def cond_prob(self, event, context):\n count = self.table[event, context] + self.prior\n norm = self.margin[context] + (self.prior * len(self.alphabet))\n return count / norm"... | [
"0.56486714",
"0.5399324",
"0.53938836",
"0.5349418",
"0.53207636",
"0.52834475",
"0.527038",
"0.5253039",
"0.51995337",
"0.5193554",
"0.5186247",
"0.5145516",
"0.51392543",
"0.5114639",
"0.5083481",
"0.50816566",
"0.50375867",
"0.5034541",
"0.50288093",
"0.50219774",
"0.5019... | 0.64043784 | 0 |
Calculate the actual prevalence during runtime | def process(self, compartment_values, computed_values, time):
return self.detected_proportion_func(time) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def precalculate():\n pass",
"def precalculate():\n pass",
"def precompute_scoring():\n global volume_void_inclusion\n global attract_point_distances\n global perlin_values\n \n volume_void_inclusion = []\n for i,void in enumerate(volumes_void):\n inclusion = gh.PointInBrep(void,... | [
"0.70535856",
"0.70535856",
"0.7031411",
"0.67749435",
"0.6493947",
"0.6482302",
"0.6269704",
"0.62223643",
"0.61939234",
"0.6182415",
"0.6175716",
"0.6152258",
"0.61377895",
"0.609314",
"0.6075508",
"0.6069201",
"0.60471123",
"0.60425705",
"0.6015367",
"0.59943706",
"0.59916... | 0.55898887 | 62 |
Computes the modular exponent of a number | def expMod(b,n,m):
"""returns (b^n mod m)"""
if n==0:
return 1
elif n%2==0:
return expMod((b*b)%m, n/2, m)
else:
return(b*expMod(b,n-1,m))%m | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def myExp(base,exponent,modulus):\n result = 1\n while exponent > 0:\n if exponent & 1 == 1:\n result = (result * base) % modulus\n exponent = exponent >> 1\n base = (base * base) % modulus\n return result",
"def modExponent(self, base, power):\n result = 1\n ... | [
"0.8157817",
"0.8092614",
"0.8023704",
"0.8023351",
"0.7755564",
"0.77176094",
"0.7643725",
"0.75809604",
"0.7468588",
"0.742563",
"0.734927",
"0.72572875",
"0.72372055",
"0.7221869",
"0.7214778",
"0.7206781",
"0.71085316",
"0.7105926",
"0.7104239",
"0.7095651",
"0.7094623",
... | 0.7284228 | 11 |
Encryption side of RSA | def RSAencrypt(m, e, n):
# Fill in the code to do RSA encryption..............
c = expMod(m, e, n)
return c | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encryptRSA(e, n , text):\r\n\r\n cyphertext = pow(text, e, n)\r\n return cyphertext",
"def RSAencrypt(m, e, n):\n # Fill in the code to do RSA encryption\n cipher = expMod(m,e,n)\n return cipher",
"def encrypt(string,pub):\r\n string = livingDead.utfE(string)\r\n crypto... | [
"0.7821584",
"0.7661074",
"0.73714435",
"0.73482984",
"0.6953182",
"0.6909501",
"0.68847466",
"0.6855016",
"0.6800743",
"0.67874444",
"0.6680838",
"0.6637164",
"0.6524958",
"0.6489339",
"0.64674616",
"0.642839",
"0.6427356",
"0.64025027",
"0.63709706",
"0.63231283",
"0.631747... | 0.76464295 | 2 |
Decryption side of RSA | def RSAdecrypt(c, d, n):
# Fill in the code to do RSA decryption....................
c = expMod(c, d, n)
return c | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rsa_decrypt(cypher, privatekey):\r\n \r\n # A key object is created to interact with the PyCrypto\r\n # encryption suite. The object contains key data and\r\n # the necessary rsa functions.\r\n temp_key_obj = _rsa_keydict_to_keyobj(privatekey = privatekey) \r\n \r\n return _rsa_gluechops(cypher, temp... | [
"0.76538956",
"0.7415473",
"0.73781157",
"0.72886574",
"0.7264294",
"0.71205086",
"0.701326",
"0.6951223",
"0.6870579",
"0.6856573",
"0.67939925",
"0.6748481",
"0.6723374",
"0.6700977",
"0.65705913",
"0.6508196",
"0.64509195",
"0.6379471",
"0.6374649",
"0.63507134",
"0.627083... | 0.7362476 | 3 |
This method returns a 16bit random integer derived from hashing the current time. This is used to test for liveness | def generateNonce():
hash = hashlib.sha1()
hash.update(str(time.time()).encode('utf-8'))
return int.from_bytes(hash.digest()[:2], byteorder=sys.byteorder) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def now():\n return int(time.time() * 1000)",
"def GenerateTime(self):\n return str(bin(int(round(time.time() * 1000))))[2:]",
"def now():\r\n return time.time()",
"def generate_random_num():\n return (long(hexlify(urandom(7)), 16) >> 3) * 2**(-53)",
"def generate_timer_id():\n\treturn bas... | [
"0.6658087",
"0.6516331",
"0.64356923",
"0.6401894",
"0.6385596",
"0.63273597",
"0.62852365",
"0.627362",
"0.6248737",
"0.6239527",
"0.62356806",
"0.62165534",
"0.6201011",
"0.61924225",
"0.6190664",
"0.6166084",
"0.6160676",
"0.6158578",
"0.61437804",
"0.6139684",
"0.6138843... | 0.5744526 | 59 |
Generate n, phi(n), e, and d. | def genKeys(p, q):
# Fill in code to generate the server's public and private keys.
# Make sure to use the Extended Euclidean algorithm...............................
n = p * q
phi = (p-1)*(q-1)
#e = e_finder(n, phi)
while True:
e = random.randint(1, phi)
if gcd_iter(e, phi) == 1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eulerphi(n):\n\treturn euler_phi(n)",
"def eulerphi(n):\r\n\treturn euler_phi(n)",
"def phi(x,n):\n return 1/(np.sqrt(2**n*np.math.factorial(n))) * (1/np.pi)**0.25 * \\\n np.exp(-x**2/2)*sp.special.eval_hermite(n,x)",
"def euler_phi(n):\n\n if n == 1:\n return 1\n\n phi = n\n ... | [
"0.7230467",
"0.72119355",
"0.7163619",
"0.70690507",
"0.6940538",
"0.674169",
"0.6737629",
"0.665743",
"0.66033924",
"0.6571762",
"0.6441839",
"0.63934433",
"0.63900155",
"0.6371469",
"0.63675463",
"0.63340646",
"0.61868167",
"0.6121966",
"0.60412896",
"0.6009271",
"0.599962... | 0.56430006 | 50 |
Responds to client's hello message with modulus and exponent | def clientHelloResp(n, e):
status = "105 Hello "+ str(n) + " " + str(e)
return status | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clientHello():\r\n status = \"100 Hello message\"\r\n return status",
"def clientHello():\r\n status = \"100 Hello\"\r\n return status",
"def hello_command(chat, message, args):\n resp = \" , \".join( list(global_coin_dct.keys())[:10] )\n chat.send ( resp )",
"def greetting(self):\n ... | [
"0.6479198",
"0.6302376",
"0.6201765",
"0.6080746",
"0.59467787",
"0.59077334",
"0.57898474",
"0.57415533",
"0.5655386",
"0.5647336",
"0.5623555",
"0.5618372",
"0.55751806",
"0.5560137",
"0.5546643",
"0.5518849",
"0.55178034",
"0.54985315",
"0.54746735",
"0.5465453",
"0.54600... | 0.6584107 | 1 |
Responds to session key with nonce | def SessionKeyResp(nonce):
status = "113 Nonce "+ str(nonce)
return status | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ns_authentication(conn):\n # get RSA key of Bob for decrypting\n rsa_key = rsa.import_key(\"RsaKey.asc\")\n\n # A -- {N_A, A}(K_PB) --> B\n request = rsa.decrypt(rsa_key, conn.recv(1024))\n client_nonce, client_name = request.split(',')\n print(\"Bob: recieved nonce {} from client {}\".format... | [
"0.5793612",
"0.5780483",
"0.5770326",
"0.57409924",
"0.57409924",
"0.57370645",
"0.5552399",
"0.55310404",
"0.5527948",
"0.54812276",
"0.5478223",
"0.5460246",
"0.54412866",
"0.54359895",
"0.5398782",
"0.53968924",
"0.5381679",
"0.5344254",
"0.5343409",
"0.5310444",
"0.53012... | 0.77256626 | 1 |
Verifies that the transmitted nonce matches that received from the client. | def nonceVerification(nonce, decryptedNonce):
#Enter code to compare the nonce and the decryptedNonce. This method
# should return a string of "200 OK" if the parameters match otherwise
# it should return "400 Error Detected"
if nonce == decryptedNonce:
return "200 OK"
else:
return "... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nonceVerification(nonce, decryptedNonce):\r\n if (nonce == decryptedNonce):\r\n status = \"150 OK\"\r\n else:\r\n status = \"400 Error\"\r\n return status",
"def nonceVerification(nonce, decryptedNonce):\n if nonce == decryptedNonce:\n return \"200 OK\"\n else:\n re... | [
"0.73665047",
"0.73254204",
"0.7015631",
"0.6736863",
"0.64736456",
"0.64222115",
"0.64045054",
"0.64045054",
"0.63911307",
"0.61404437",
"0.6129229",
"0.61064225",
"0.60114044",
"0.59985316",
"0.5985546",
"0.596006",
"0.5935649",
"0.5932109",
"0.59176725",
"0.59117854",
"0.5... | 0.72356075 | 2 |
Get and parse HTML from url to return a BeautifulSoup object | def get_soup_for_page(url: str) -> BeautifulSoup:
return BeautifulSoup(get_html(url), 'html.parser') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_html_parser(url):\n response = requests.get(url)\n return BeautifulSoup(response.content, 'html.parser')",
"def getSoup(url):\n return BeautifulSoup(getHtml(url), 'lxml')",
"def get_soup(url):\n return BeautifulSoup(requests.get(url).content, 'lxml')",
"def get_soup(url):\n\tresponse = ur... | [
"0.85314804",
"0.8485308",
"0.8195754",
"0.812122",
"0.81066984",
"0.8082718",
"0.80745155",
"0.80275524",
"0.7982905",
"0.7975306",
"0.7965569",
"0.79574174",
"0.7951553",
"0.78745633",
"0.7869404",
"0.78641176",
"0.78237176",
"0.7798591",
"0.7773363",
"0.7760482",
"0.773167... | 0.80104625 | 8 |
Crawl, parse and index IMDB to populate movies database | def get_imdb_movies(max_movies: int):
from imdb.database import index_movie_to_database
movie_count = 0
for url in crawl_imdb_listing_page(TOP_PAGE):
if movie_count == max_movies:
break
movie_data = parse_movie_page(url)
if index_movie_to_database(movie_data):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def movie_spider(self, movieTag):\n index = 0\n logging.info(\"Start crawling tag: %s\" % movieTag)\n while index < self.MAX_NUM:\n root = \"https://movie.douban.com/tag/%s?start=%d&type=T\" % (movieTag, index)\n result = {}\n try:\n html = reque... | [
"0.6891619",
"0.6704189",
"0.6427405",
"0.6412079",
"0.6192585",
"0.61624694",
"0.6147366",
"0.6041188",
"0.603387",
"0.6014648",
"0.59659547",
"0.5929169",
"0.5887383",
"0.5861849",
"0.58480793",
"0.58408755",
"0.58000845",
"0.5786631",
"0.57839924",
"0.5770788",
"0.57546777... | 0.61675996 | 5 |
Generator function to keep crawling the listing pages, yielding the found movies urls. | def crawl_imdb_listing_page(url: str) -> Generator:
next_url = url
while next_url:
print(f"CRAWLING URL {next_url}")
listing_page = get_soup_for_page(next_url)
for movies_element in listing_page.find_all("div", class_="lister-item mode-simple"):
a_link = movies_element.find("... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _paginate(self) -> Iterable[List[str]]:\n req = self.html\n videos_lens = self._extractor(req)\n yield videos_lens # yielding doesn't mean that is the end\n\n # The above only returns 100 or fewer links\n # as Youtube loads 100 videos at a time\n # Simulating a browser... | [
"0.68248665",
"0.65488493",
"0.64052033",
"0.63932663",
"0.63698214",
"0.6351879",
"0.6219682",
"0.61537457",
"0.6130862",
"0.60967785",
"0.606942",
"0.6053288",
"0.6021266",
"0.60047364",
"0.5937592",
"0.59219736",
"0.5912077",
"0.59039587",
"0.5858203",
"0.5830659",
"0.5826... | 0.76492673 | 0 |
Extract movie information from a imdb movie page | def parse_movie_page(movie_url: str) -> Dict[str, str]:
movie_page = get_soup_for_page(movie_url)
# title and id
movie_id = movie_url.split("/")[-2]
title = movie_page.find("div", class_="title_wrapper").find("h1").get_text(";", strip=True).split(";")[0]
# director and stars
credit_summary_ele... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_movie_info(page: str, verbose:bool = True):\n\n def add_scoreInfo(pattern, raw_text, keyName):\n \"\"\"inner helper function to help add score information\n :param pattern: pattern to match\n :param raw_text: html text\n :param keyName: key name to be append to the dict\n ... | [
"0.76029146",
"0.72262806",
"0.7224131",
"0.7172252",
"0.7171272",
"0.6969435",
"0.68959147",
"0.68874156",
"0.68652445",
"0.67160463",
"0.66835207",
"0.6683043",
"0.6645961",
"0.66407657",
"0.6620011",
"0.6615919",
"0.66005063",
"0.657424",
"0.65602005",
"0.6502864",
"0.6491... | 0.7012838 | 5 |
Try to update existing line entrie, insert on fail. | def line_put(self, line):
resp = None
url = '{}line/'.format(self.epoint)
body_json = json.dumps(self.fillter_dct(self.line_attrs_allowed, line))
try:
resp = requests.put(url, timeout=self.to, headers=self.headers,
data=body_json)
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insert_or_update(self, table, connection, row):\n\n # find line, if it exist\n dbrow = self.find(connection, table, row)\n\n # TODO XXX use actual database function instead of this stupid thing\n now = datetime.datetime.now()\n\n column_names = table.columns.keys()\n\n ... | [
"0.6385364",
"0.62758267",
"0.6274342",
"0.58512753",
"0.57817584",
"0.5751034",
"0.5662429",
"0.5631501",
"0.56202906",
"0.5594066",
"0.5534586",
"0.5456755",
"0.54238886",
"0.5394362",
"0.53629255",
"0.5361207",
"0.5347761",
"0.5325351",
"0.5315772",
"0.5314964",
"0.5313587... | 0.57922137 | 4 |
Calculate methylation frequency at genomic CpG sites from the output of nanopolish callmethylation input_fn Path to a nanopolish call_methylation tsv output file fasta_index fasta index file obtained with samtools faidx. Required for coordinate sorting output_bed_fn Path to write a summary result file in BED format out... | def __init__ (self,
input_fn:"str",
fasta_index:"str"="",
output_bed_fn:"str"="",
output_tsv_fn:"str"="",
min_depth:"int"=10,
sample_id:"str"="",
strand_specific:"bool"=False,
min_llr:"float"=2,
verbose:"bool"=False,
quiet:"bool"=False):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n # files\n summary_file = sys.argv[1]\n pwms_to_tfs_file = sys.argv[2]\n expressed_tfs_file = sys.argv[3] # TODO\n\n # TODO pull in num regions to resize things? but complicated with overlaps etc\n # TODO edit edges with type of interaction\n # TODO may want to color by trajectory... | [
"0.5693103",
"0.55067265",
"0.5399869",
"0.5296353",
"0.52888024",
"0.5262818",
"0.5224499",
"0.52202576",
"0.5129552",
"0.5099409",
"0.5049172",
"0.50478584",
"0.5046293",
"0.49877012",
"0.49782598",
"0.49623838",
"0.495393",
"0.49416703",
"0.49218166",
"0.49082747",
"0.4904... | 0.6483332 | 0 |
Use Dijkstra's algorithm on the given graph This constructor assumes the graph's edges are { GWeightedEdge}s. If not, you will likely encounter a { ClassCastException}. graph the graph | def __init__(self, graph: ghidra.graph.GImplicitDirectedGraph):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, graph):\n self.graph = graph\n self.distances = graph.distance\n self.links = graph.links\n self.weighted_edge_list = graph.weighted_edge_list\n self.G = graph.G\n self.sort = sorted(self.weighted_edge_list, key=lambda x: x[2])\n self.ordered_dist... | [
"0.6976169",
"0.6888074",
"0.66871184",
"0.664122",
"0.65760803",
"0.65578073",
"0.6497716",
"0.6435038",
"0.6405883",
"0.6312871",
"0.62896526",
"0.6256009",
"0.6212545",
"0.6147363",
"0.61346835",
"0.6112303",
"0.6074155",
"0.60559005",
"0.600402",
"0.5996436",
"0.5994674",... | 0.60467774 | 18 |
Use Dijkstra's algorithm on the given graph with the given maximum distance This constructor assumes the graph's edges are { GWeightedEdge}s. If not, you will likely encounter a { ClassCastException}. graph the graph maxDistance the maximum distance, or null for no maximum | def __init__(self, graph: ghidra.graph.GImplicitDirectedGraph, maxDistance: float):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, graph: ghidra.graph.GImplicitDirectedGraph, maxDistance: float, metric: ghidra.graph.GEdgeWeightMetric):\n ...",
"def max_dist(graph, source):\r\n q = queue.Queue()\r\n found = {}\r\n distance = {}\r\n for vertex in graph: \r\n found[vertex] = 0\r\n distance[ve... | [
"0.7105622",
"0.65459585",
"0.62205803",
"0.6163052",
"0.60579824",
"0.59286",
"0.5803024",
"0.57847154",
"0.5700605",
"0.5692679",
"0.5679294",
"0.56565255",
"0.5653247",
"0.5653056",
"0.5608242",
"0.5604511",
"0.55991817",
"0.55969554",
"0.55812794",
"0.55636895",
"0.555433... | 0.71439725 | 0 |
Use Dijstra's algorithm on the given graph with a custom edge weight metric graph the graph metric the function to compute the weight of an edge | def __init__(self, graph: ghidra.graph.GImplicitDirectedGraph, metric: ghidra.graph.GEdgeWeightMetric):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_weight_func(G, weight):\n\n def weight_func(u, v):\n edge = G[u][v]\n\n if G.is_multigraph():\n return min(att.get(weight, 1) for att in edge.values())\n\n return edge.get(weight, 1)\n\n return weight_func",
"def __djikstra(graph, node_name):\n predecessor... | [
"0.6703957",
"0.66605234",
"0.6631161",
"0.652215",
"0.6499373",
"0.6461656",
"0.64207816",
"0.6279059",
"0.61951953",
"0.61626434",
"0.6158406",
"0.61564386",
"0.6105164",
"0.606558",
"0.6053947",
"0.6033951",
"0.60229975",
"0.59964764",
"0.5994979",
"0.5991522",
"0.5975728"... | 0.59975505 | 17 |
Use Dijstra's algorithm on the given graph with the given maximum distance and a custom edge weight metric graph the graph maxDistance the maximum distance, or null for no maximum metric the function to compute the weight of an edge | def __init__(self, graph: ghidra.graph.GImplicitDirectedGraph, maxDistance: float, metric: ghidra.graph.GEdgeWeightMetric):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __djikstra(graph, node_name):\n predecessors = {key: None for key in graph.keys()}\n distances = {key: inf for key in graph.keys()}\n distances[node_name] = 0\n nodes_set = set(graph.values()) # type : Set[Node]\n while len(nodes_set) != 0:\n min_node = min(nodes_... | [
"0.648706",
"0.62402046",
"0.62161565",
"0.6197095",
"0.6175136",
"0.6040108",
"0.59882283",
"0.59803706",
"0.59314615",
"0.5915369",
"0.59046775",
"0.5885905",
"0.58851326",
"0.5882774",
"0.58602697",
"0.5838277",
"0.58381146",
"0.58340716",
"0.58335596",
"0.5828926",
"0.581... | 0.6478836 | 1 |
Returns an list of available location tuples neighboring an given position location. | def check_location(position: tuple,
all_sites: np.matrix,
busy_locations: List[tuple]) -> List[tuple]:
N, M = all_sites.shape
potential_sites = [(position[0], position[1] + 1),
(position[0], position[1] - 1),
(position[0] + 1, p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def locations_adjacent_to(loc):\n return [(loc[0] + direction[0], loc[1] + direction[1]) for direction in [(0,-1),(0,1),(-1,0),(1,0)]]",
"def get_neighbors(loc):\n dim = len(loc)\n offsets = product((-1, 0, 1), repeat=dim)\n neighbors = set()\n for offset in offsets:\n if offset == (0,) * d... | [
"0.7041809",
"0.7023418",
"0.6892644",
"0.6800793",
"0.66838336",
"0.66631275",
"0.6643647",
"0.6508145",
"0.64983076",
"0.6488335",
"0.64640033",
"0.63975555",
"0.637684",
"0.6343168",
"0.62820834",
"0.6256937",
"0.6250964",
"0.62331253",
"0.6231511",
"0.620172",
"0.6126907"... | 0.5996912 | 38 |
Gets an random free location neighboring an position. Returns False if there aren't any location available. | def get_free_location(position: tuple,
all_sites: np.matrix,
used_sites: List[tuple]) -> tuple:
available_locations = check_location(position, all_sites, used_sites)
if len(available_locations) > 0:
return random.choice(available_locations)
else:
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def random_location(self):\r\n\r\n while True:\r\n pt = (random.uniform(self.worldbox.tl[0], self.worldbox.br[0]),\r\n random.uniform(self.worldbox.tl[1], self.worldbox.br[1]))\r\n if not self.is_wall(pt) and not self.is_target(pt):\r\n return pt",
"de... | [
"0.7155066",
"0.68745834",
"0.6822648",
"0.6772478",
"0.67044556",
"0.667298",
"0.65802073",
"0.6535938",
"0.62133676",
"0.6199547",
"0.6172247",
"0.6147595",
"0.61029494",
"0.60941947",
"0.60829973",
"0.6078855",
"0.6075617",
"0.6019359",
"0.60065395",
"0.60025245",
"0.60017... | 0.7684889 | 0 |
Filter the nonnearby agents. | def nearby_agents(location: tuple, agents: Dict[str, dict]) -> Dict[str, dict]:
neighbors = {label: agent for label, agent in agents.items()
if is_neighbor(agent['location'], location)}
return neighbors | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_func(self, agents):\n return [\n agent for agent in agents\n if agent.energy < self.model.energy_threshold and not agent.pack\n ]",
"def filter_wolves(self, agents):\n return [\n agent for agent in agents\n if agent.energy < self.model.e... | [
"0.7159476",
"0.69750136",
"0.5750282",
"0.5655772",
"0.5614072",
"0.55095285",
"0.5485843",
"0.5468839",
"0.54196733",
"0.54196733",
"0.5391832",
"0.5282351",
"0.5278059",
"0.52467644",
"0.5214163",
"0.5196809",
"0.51801443",
"0.5167936",
"0.5160934",
"0.5160934",
"0.5159122... | 0.0 | -1 |
This function posts data in order to get cookies and then get the results | def __init__(self, query, subcorpus='nkjp300', tag=False, write=False,
kwic=True, occurrences=10):
self.query = query
self.tag = tag
self.subcorpus = subcorpus
self.page = None
self.occurrences = occurrences
self.write = write
self.kwic = kwic | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_post(self, values, url, send_header):\n # Get the cookie into the urllib\n ckjar = self.mycookie.get_cookie()\n ckproc = urllib2.HTTPCookieProcessor(ckjar)\n opener = urllib2.build_opener(ckproc)\n \n # Post data and get return result\n post_data = urllib.u... | [
"0.663909",
"0.64892554",
"0.63949543",
"0.6384258",
"0.6377764",
"0.6324452",
"0.6231552",
"0.61990243",
"0.60470724",
"0.6032849",
"0.59616464",
"0.5923095",
"0.57920897",
"0.57327276",
"0.57303137",
"0.57169217",
"0.5696751",
"0.56575346",
"0.5654921",
"0.56475824",
"0.562... | 0.0 | -1 |
Select olny columns that are used in this hypohesis testing. | def chose_only_hypothesis_colums(df):
lst = ['abv', 'ibu', 'gravity', 'abv_min', 'abv_max', 'ibu_min',
'ibu_max', 'srm_min', 'srm_max', 'og_min', 'fg_min', 'fg_max']
return df[lst] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_non_feature_columns():\n return ['teamid', 'op_teamid', 'matchid', 'competitionid', 'seasonid',\n 'goals', 'op_goals', 'points', 'timestamp', 'team_name', \n 'op_team_name']",
"def _these_columns_cannot_annotate_exp_cons(self):\n _cols = set([]) #\n for param_name,... | [
"0.6092054",
"0.5817742",
"0.58053917",
"0.57627535",
"0.57148385",
"0.5707492",
"0.56815207",
"0.5610355",
"0.56015986",
"0.559424",
"0.5496665",
"0.5475164",
"0.54533297",
"0.54247004",
"0.5415999",
"0.5400429",
"0.538975",
"0.53685564",
"0.5365411",
"0.535745",
"0.5348751"... | 0.6582166 | 0 |
Return the three beer vital stats. | def beer_vital_stats(beers):
lst = ['abv', 'ibu', 'gravity']
beer_vital_stats = beers[lst]
print('Dataset before removing null records:', beer_vital_stats.shape)
idx = (beer_vital_stats.notnull()).all(axis=1)
beer_vital = beer_vital_stats[idx]
print('Dataset after removing all the null records:'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_top_weapons(self):\n try:\n top_weapon = self.page.find(\"div\", {\"class\": \"weapon\"}).text.split(\" \")\n\n top_weapon_informations = {\"Weapon\": top_weapon[1], \"Headshots\": top_weapon[-5],\"Bodyshot\": top_weapon[-4],\n \"Leg_shot\"... | [
"0.6124897",
"0.6050427",
"0.5764262",
"0.57420075",
"0.5681347",
"0.56677866",
"0.5628358",
"0.5612648",
"0.549786",
"0.5495417",
"0.54840124",
"0.54730195",
"0.5469649",
"0.5461091",
"0.5458093",
"0.54551136",
"0.5442368",
"0.5427474",
"0.5425743",
"0.5402553",
"0.5400585",... | 0.5661414 | 6 |
check if the text contains "nonlatin" characters. If have non start char then return true. | def is_ascii_chars(text):
is_ascii = True
try:
text.encode(encoding='utf-8').decode('ascii')
except UnicodeDecodeError:
is_ascii = False
return is_ascii | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __contains_nonascii_characters(string):\n for c in string:\n if not ord(c) < 128:\n return True\n return False",
"def isValid(text):\n return bool(re.search(r'\\bneustart\\b', text, re.IGNORECASE))",
"def _has_non_ascii_characters(data_string):\r\n try:\r\n ... | [
"0.7155685",
"0.69999903",
"0.69006544",
"0.6706573",
"0.6596651",
"0.6532213",
"0.6509879",
"0.64290476",
"0.62984395",
"0.6293036",
"0.6249571",
"0.61959845",
"0.61623156",
"0.6139",
"0.61274207",
"0.610891",
"0.61056674",
"0.6090147",
"0.6076324",
"0.60291994",
"0.5996482"... | 0.6273175 | 10 |
get the affiliate link or base url | def get_broker_affiliate_link(broker, what):
return_data = ''
affiliate_link = ''
baseurl = ''
connection = pymysql.connect(host=DB_SRV,
user=DB_USR,
password=DB_PWD,
db=DB_NAME,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def link(self) -> Optional[str]:\n return pulumi.get(self, \"link\")",
"def link(self) -> Optional[str]:\n return pulumi.get(self, \"link\")",
"def get_full_url(self):\n full_url = home_page + self.source_link\n return full_url",
"def getLink(self):",
"def get_randori_base_url(s... | [
"0.6439041",
"0.6439041",
"0.64389956",
"0.6433766",
"0.6302267",
"0.627821",
"0.62526745",
"0.622451",
"0.6220857",
"0.619734",
"0.61872107",
"0.6180173",
"0.61750776",
"0.6134218",
"0.61053306",
"0.604682",
"0.6042037",
"0.60369056",
"0.6023366",
"0.6022755",
"0.6021405",
... | 0.63485336 | 4 |
Encode a 'Default' message into bytes. | def encode(msg: Message) -> bytes:
msg = cast(DefaultMessage, msg)
default_msg = default_pb2.DefaultMessage()
default_msg.message_id = msg.message_id
dialogue_reference = msg.dialogue_reference
default_msg.dialogue_starter_reference = dialogue_reference[0]
default_msg.dia... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _encode(self, messages, encode_empty=False):\n serialized_messages = MessagePartSerializer().dumps(messages)\n return self._encode_parts(serialized_messages, encode_empty=encode_empty)",
"def encode(self, message):\n return message.encode()",
"def _encode_message(cls, message):\n ... | [
"0.59400874",
"0.5875511",
"0.5675387",
"0.5622664",
"0.5536103",
"0.54758316",
"0.54612595",
"0.54244334",
"0.5410007",
"0.53619623",
"0.53439385",
"0.5328481",
"0.53255683",
"0.5325061",
"0.5304176",
"0.5303249",
"0.5303249",
"0.53005177",
"0.52999735",
"0.52936417",
"0.528... | 0.7586231 | 0 |
Decode bytes into a 'Default' message. | def decode(obj: bytes) -> Message:
default_pb = default_pb2.DefaultMessage()
default_pb.ParseFromString(obj)
message_id = default_pb.message_id
dialogue_reference = (
default_pb.dialogue_starter_reference,
default_pb.dialogue_responder_reference,
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decode_message(self, raw):\n return raw.decode('utf-8')",
"def parse_and_decode(cls, data: bytes) -> \"Message\":\n if len(data) < cls.calc_size() + 1:\n raise NotEnoughData()\n if data[0] != cls.type:\n raise InvalidType()\n\n return cls(*unpack('<' + cls.fm... | [
"0.6460779",
"0.62275463",
"0.60233516",
"0.5910059",
"0.59061134",
"0.58505297",
"0.5774515",
"0.57674026",
"0.5714803",
"0.56986344",
"0.5683915",
"0.5680897",
"0.5660629",
"0.5643898",
"0.56417495",
"0.5614412",
"0.55841964",
"0.55837613",
"0.5563051",
"0.55579466",
"0.553... | 0.6873543 | 0 |
Enabled types in a Collage as list of dicts. | def listEnabledTypes(self):
actual_type = self.request.get('portal_type', None)
collage_options = getCollageSiteOptions()
ttool = getToolByName(self.context, 'portal_types', None)
if ttool is None:
return None
return [
{
'id': pt.getId(),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_group_types(self):\r\n pass",
"def etypes(self): # -> list[None]:\n ...",
"def etypes(self): # -> list[str]:\n ...",
"def listFeaturableContentTypes():",
"def type_list():\n for type_ in orm.DataFlagType.select():\n click.echo(type_.name)",
"def getFeatureDicts(self... | [
"0.56451094",
"0.5577261",
"0.555166",
"0.5539778",
"0.5523393",
"0.5469926",
"0.5433368",
"0.5389394",
"0.53685445",
"0.53110236",
"0.530126",
"0.5217573",
"0.5199076",
"0.51909196",
"0.5184929",
"0.5160728",
"0.51568127",
"0.5147065",
"0.51458454",
"0.5136423",
"0.51267034"... | 0.6831915 | 0 |
Runs a corouting in the default event loop and retuns it result. | def run_coro(coro):
return asyncio.get_event_loop().run_until_complete(coro) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _run(self, coro):\n return self.loop.run_until_complete(coro)",
"def run(coroutine):\n\n return asyncio.get_event_loop().run_until_complete(coroutine)",
"def _run(coro):\r\n return asyncio.get_event_loop().run_until_complete(coro)",
"def _run(coro):\n return asyncio.get_event_loop().run_u... | [
"0.7456809",
"0.7332577",
"0.7127579",
"0.7030047",
"0.69046736",
"0.67248267",
"0.6559589",
"0.6559589",
"0.6548279",
"0.64458126",
"0.64395374",
"0.64395374",
"0.6435958",
"0.6394516",
"0.63917077",
"0.63644034",
"0.6340163",
"0.6335593",
"0.6296401",
"0.6296183",
"0.618239... | 0.6475103 | 9 |
Helper method to get fixed set of nodes for integration tests. | def get_nodes():
return conf.config.get_nodes(RELATIVE_PATH_FIXTURES_HOST) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_nodes():\n nodes_config_file = Settings.CONF_NODES_FILE\n current_nodes = load_node_names(nodes_config_file)\n\n return current_nodes",
"def get_nodes(self):\n pass",
"def get_all_nodes(self):\n # NOTE: return copy, so no one will screw\n # our list?\n return self.n... | [
"0.68265736",
"0.6614423",
"0.6519299",
"0.6489987",
"0.64040446",
"0.6392586",
"0.6377646",
"0.63355374",
"0.6334925",
"0.63303435",
"0.6282876",
"0.62619257",
"0.62289566",
"0.62216836",
"0.6215375",
"0.6202686",
"0.62020046",
"0.61830145",
"0.61665314",
"0.60890484",
"0.60... | 0.7349392 | 0 |
Sets up a HTTP session with a retry policy. | def session():
s = requests.Session()
retries = Retry(total=5, backoff_factor=0.5)
s.mount("http://", HTTPAdapter(max_retries=retries))
return s | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(\n self,\n retries=3,\n backoff_factor=0.3,\n status_forcelist=(500, 502, 504),\n **session_options,\n ):\n super().__init__(**session_options)\n retries = retries or 0\n\n self.retry_ = Retry(\n total=retries,\n read=ret... | [
"0.6857141",
"0.66478163",
"0.6571058",
"0.6445937",
"0.6355491",
"0.6263917",
"0.62212396",
"0.612338",
"0.61004585",
"0.60772103",
"0.6003747",
"0.5973167",
"0.5882813",
"0.5876081",
"0.58389",
"0.5739965",
"0.56961465",
"0.5695593",
"0.56927025",
"0.5690914",
"0.5681083",
... | 0.6280598 | 5 |
GETs data from a nodes and returns the result to the caller. | async def GET(node_id, path):
r = session().get(f"{HOST}:{BASE_PORT + node_id}{path}")
if r.status_code != 200:
raise ValueError(f"Got bad response {r.status_code} from " +
f"node {node_id} on {path}.")
return {"status_code": r.status_code, "data": r.json()} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data(node):\n return node['data']",
"def getNodes(self):\n data = self.connect('get','nodes',None)\n return data",
"def getData(graph, request):\r\n results = list(graph.query(request))\r\n return results",
"def callapi(uri: str, data=None):\n if data is not None:\n d... | [
"0.69283056",
"0.670028",
"0.64256525",
"0.6367985",
"0.6361035",
"0.62616485",
"0.62616485",
"0.62616485",
"0.6198814",
"0.6081884",
"0.60235053",
"0.5962023",
"0.59224427",
"0.591304",
"0.5902234",
"0.5900502",
"0.5876176",
"0.584111",
"0.5796484",
"0.5789404",
"0.5739313",... | 0.62030166 | 8 |
Generates the hosts file to be used in the test. | def generate_hosts_file(n, path="./tests/fixtures"):
if not os.path.isdir(path):
os.mkdir(path)
with open(f"{path}/hosts.txt", "w") as f:
for i in range(n):
f.write(f"{i},localhost,127.0.0.1,{5000+i}\n") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inject_hosts_files(self):\n self.log.info(\"Injecting host files\")\n hosts = dict()\n for i in self.all_nodes:\n hosts[i.name] = i.get_public_addr()\n #add the host names to etc/hosts\n orchestrator.inject_hostnames(hosts, delete=self.cluster_name)\n for i ... | [
"0.6459292",
"0.6404605",
"0.6283201",
"0.6240932",
"0.59802336",
"0.5889246",
"0.58163095",
"0.5757817",
"0.5732513",
"0.5702952",
"0.5698817",
"0.5661061",
"0.56472224",
"0.56410384",
"0.56334525",
"0.56244177",
"0.55663335",
"0.5537021",
"0.54996186",
"0.5496365",
"0.54960... | 0.77438474 | 0 |
Launches BFTList for integration testing. | async def launch_bftlist(test_name="unknown test", n=N, f=F, args={}):
generate_hosts_file(n)
nodes = get_nodes()
cmd = ". env/bin/activate && python3.7 main.py"
cwd = os.path.abspath(".")
pids = []
for node_id in nodes.keys():
env = os.environ.copy()
env["ID"] = str(node_id)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n self.tp.launch_list()\n self.tp = None",
"def run_datalab_fbs():\n\n appctxt = ApplicationContext()\n win = DataLab()\n # debug_setup(win)\n win.show()\n exit_code = appctxt.app.exec_()\n sys.exit(exit_code)",
"def test_fixture_list_runs(tmp_sample_project):\n ... | [
"0.6644642",
"0.59429514",
"0.57962817",
"0.57052195",
"0.5684194",
"0.5662194",
"0.559709",
"0.5505819",
"0.5502295",
"0.5478227",
"0.5450164",
"0.5444739",
"0.5444739",
"0.540122",
"0.5357159",
"0.53484774",
"0.5345491",
"0.5273711",
"0.52669984",
"0.526251",
"0.5246604",
... | 0.7411596 | 0 |
Kills all processes in the supplied list containing PIDs. | def kill(pids):
for pid in pids:
process = psutil.Process(pid)
for proc in process.children(recursive=True):
proc.kill()
process.kill()
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kill(self,process_list,signal = 'TERM'):\n res = []\n pids = {}\n for process in process_list:\n if hasattr(process,'machine'):\n try:\n worker = self.worker_by_name[process.machine]\n except KeyError:\n worker ... | [
"0.71561825",
"0.7016703",
"0.69786996",
"0.69770545",
"0.68164593",
"0.6671434",
"0.66706276",
"0.6646426",
"0.65671927",
"0.6468347",
"0.64572406",
"0.6416643",
"0.6387647",
"0.6351313",
"0.6312249",
"0.6208457",
"0.61944294",
"0.61545175",
"0.61286503",
"0.61021495",
"0.60... | 0.7777778 | 0 |
Removes all generated state files after test and cleans up. | def cleanup():
try:
os.remove(start_state_file_path)
except FileNotFoundError:
pass
time.sleep(1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tearDown():\n for output_file_path in Path(output_dir).glob(\"test_voting_learner_cross_validate*\"):\n output_file_path.unlink()\n\n for output_file_path in Path(\".\").glob(\"test_voting_learner_cross_validate*\"):\n output_file_path.unlink()\n\n config_file_path = Path(config_dir) / \... | [
"0.7663158",
"0.7661129",
"0.76429653",
"0.76376575",
"0.75846446",
"0.7534873",
"0.7493232",
"0.74643505",
"0.7433635",
"0.74254453",
"0.7356978",
"0.73564607",
"0.73222697",
"0.7321115",
"0.72945124",
"0.7292109",
"0.72868603",
"0.72769874",
"0.72742134",
"0.7268443",
"0.72... | 0.7735382 | 0 |
Dumps a dict to a json file used to inject state to modules. | def write_state_conf_file(state):
with open(f"{start_state_file_path}", "w") as outfile:
outfile.write(jsonpickle.encode(state)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_to_json(dict, file):\n with open(file, 'w') as f:\n json.dump(dict, f, indent=2)\n return file",
"def save_dict_as_json(dict, output_path):\n with open(output_path, \"w\") as f:\n json.dump(dict, f)",
"def store(my_dict, filename):\n my_json = json.dumps(my_dict)\n f = ope... | [
"0.7407459",
"0.7298913",
"0.72519094",
"0.72142816",
"0.7062763",
"0.7019053",
"0.69570297",
"0.69448113",
"0.69421196",
"0.69389653",
"0.6888327",
"0.68440145",
"0.6828989",
"0.68166786",
"0.6766787",
"0.6751799",
"0.67456377",
"0.67402554",
"0.6674093",
"0.6652525",
"0.663... | 0.63367057 | 45 |
Returns a dict used to match r_log entries returned through API. | def get_json_for_r_log_entry(req, x_set):
return {
"request": req.to_dct(),
"x_set": x_set
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_logs(self) -> Dict[str, Any]:\n return self.maps[0]",
"def getLogs():",
"def getLogs():",
"def _parse_logs_for_results(self, logs):\n results = {}\n for line in logs.split(\"\\n\"):\n split_line = line.split(\":\")\n if len(split_line) == 2:\n ... | [
"0.6572739",
"0.6426629",
"0.6426629",
"0.6405125",
"0.63875765",
"0.63137525",
"0.6173358",
"0.6084505",
"0.6070966",
"0.60625744",
"0.60134137",
"0.59859174",
"0.5974191",
"0.591907",
"0.59110576",
"0.58960515",
"0.5849622",
"0.58303064",
"0.5689816",
"0.5686662",
"0.568454... | 0.5978461 | 12 |
numerotation arbitraire zero correspond a Y63, puis sens des aiguilles d'une montre jusqu'a 127 (X1) | def channelSelect (i):
# assert(0<=i<128, "channel {} does not exist in [0-127]".format(i))
assert(0<=i<128)
closeAll() #<== close all relays
if i< 1*8 :# bank1
mask=shift8(i, 1) ; bus.write_byte_data(R1,off,mask)
elif i< 2*8 :
mask=shift8(i, 1) ; bus.write_byte_data(R1,mask,off)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def yy_int(self):\n return np.int32(np.round(self.yy))",
"def normalize_m11(x):\n return x / 127.5 - 1",
"def y(self) -> int:",
"def NACA4digitsSym(self):\n self.ytu = self.NacaEquation(self.xu,self.t)\n self.ytl = -self.NacaEquation(self.xl,self.t)\n # Done for estitic reason... | [
"0.59162384",
"0.5893357",
"0.58206284",
"0.58180404",
"0.5816376",
"0.5816376",
"0.5804368",
"0.5796267",
"0.5787254",
"0.57349116",
"0.57158196",
"0.5673351",
"0.56491387",
"0.564224",
"0.56049657",
"0.55999506",
"0.55820304",
"0.55820304",
"0.5554622",
"0.5536786",
"0.5534... | 0.0 | -1 |
This function downloads data from a url | def downloadData(url):
data = urllib2.urlopen(url)
csvdata = data.read() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def downloadData(url):\n \n content = urllib2.urlopen(url)\n return content",
"def download_from_url(url, output_path):\n\n print('Pulling data from {} to {}'.format(url, output_path))\n wget.download(url, output_path)\n print('done')",
"def downloadData(url):\n response = urllib2.urlopen(url)\n... | [
"0.83661413",
"0.7470643",
"0.74026155",
"0.7390855",
"0.7340116",
"0.7306004",
"0.73024845",
"0.7276593",
"0.7246603",
"0.72268397",
"0.72114456",
"0.7168293",
"0.7165007",
"0.7136254",
"0.7117887",
"0.70797074",
"0.70289284",
"0.70003897",
"0.6997957",
"0.698888",
"0.698299... | 0.74508363 | 2 |
Process the csv data | def parse_csv(csvdata):
count_img = 0
count_rows = 0
reader = csv.reader(StringIO(csvdata))
count_msie = 0
count_safari = 0
count_firefox = 0
for row in reader:
count_rows += 1
if re.search("jpg|png|gif", row[0], re.I):
count_img += 1
if re.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_csv(self):\n try:\n reader = csv.reader(open(self.options.datafile, 'r'))\n except IOError:\n errormsg(_('Cannot read \"{}\"'.format(self.options.datafile)))\n raise Exception(_('Cannot read \"{}\"'.format(self.options.datafile)))\n if self.options.v... | [
"0.7532891",
"0.7180946",
"0.7067634",
"0.69640505",
"0.68721133",
"0.6856139",
"0.6799568",
"0.6795377",
"0.679071",
"0.677996",
"0.67743444",
"0.6575626",
"0.6555505",
"0.652285",
"0.65009964",
"0.64762956",
"0.6387756",
"0.63765186",
"0.63480973",
"0.63436574",
"0.6339822"... | 0.57782686 | 63 |
Here we return the ContentType set to multipart/post, including the boundary. | def get_headers(self):
return [('Content-Type', self.MULTIPART_HEADER % self.boundary)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_upload_content_type(self):\n if not hasattr(self, '_upload_content_type'):\n with self.get_storage().open(self.get_upload_path()) as upload:\n content_type = Magic(mime=True).from_buffer(upload.read(1024))\n self._upload_content_type = content_type\n retur... | [
"0.6813985",
"0.6347326",
"0.63283366",
"0.6309365",
"0.6252459",
"0.6238954",
"0.6197196",
"0.61837476",
"0.6173514",
"0.6098867",
"0.60858727",
"0.60638916",
"0.6038287",
"0.6030141",
"0.5975976",
"0.59727657",
"0.59586275",
"0.5926298",
"0.592216",
"0.5911623",
"0.58917755... | 0.6207143 | 6 |
Boundaries in different instances make a trivial string comparison | def __eq__(self, other):
return self.items() == other.items() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compare(self, p_str, p_str_1): # real signature unknown; restored from __doc__\n return 0",
"def robust_string_compare(a, b):\n return a.strip().lower() == b.strip().lower()",
"def test_strings_are_equal(self):\n string1 = 'this is the first string'\n string2 = 'this is the first st... | [
"0.7397645",
"0.7271199",
"0.72672033",
"0.70249873",
"0.7017144",
"0.6887826",
"0.67547894",
"0.6682517",
"0.66788507",
"0.66543406",
"0.66453964",
"0.6640099",
"0.66366297",
"0.66350824",
"0.6602779",
"0.6599443",
"0.65927",
"0.65630746",
"0.6548104",
"0.6514335",
"0.649689... | 0.0 | -1 |
Decode with custom models that implements ScorerInterface. | def recog_v2(args):
logging.warning("experimental API for custom LMs is selected by --api v2")
if args.batchsize > 1:
raise NotImplementedError("multi-utt batch decoding is not implemented")
if args.streaming_mode is not None:
raise NotImplementedError("streaming mode is not implemented")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dinamic_decode(self):\n raise NotImplementedError",
"def decode(data):\n raise NotImplementedError",
"def decoder(self):\n pass",
"def decode(self, encoded):",
"def decode(self, coded_set):",
"def _decode(self, input_dict):\n pass",
"def decode(self,m):\n raise N... | [
"0.57454574",
"0.5658464",
"0.56545657",
"0.5621851",
"0.53665817",
"0.53629136",
"0.5345945",
"0.53054076",
"0.52464706",
"0.52410626",
"0.5228534",
"0.51994413",
"0.51882124",
"0.5154847",
"0.5143546",
"0.51136965",
"0.50817126",
"0.5078946",
"0.50688785",
"0.5066824",
"0.5... | 0.4764447 | 54 |
Decode with custom models that implements ScorerInterface. | def recog_ctconly_mask(args):
logging.warning(f'RECOGCTCONLY')
logging.warning("experimental API for custom LMs is selected by --api v2")
if args.batchsize > 1:
raise NotImplementedError("multi-utt batch decoding is not implemented")
if args.streaming_mode is not None:
raise NotImplemen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dinamic_decode(self):\n raise NotImplementedError",
"def decode(data):\n raise NotImplementedError",
"def decoder(self):\n pass",
"def decode(self, encoded):",
"def decode(self, coded_set):",
"def _decode(self, input_dict):\n pass",
"def decode(self,m):\n raise N... | [
"0.5745083",
"0.56577194",
"0.56540185",
"0.5620804",
"0.53662676",
"0.53617454",
"0.53452384",
"0.53048366",
"0.5246182",
"0.5241065",
"0.5227346",
"0.51992446",
"0.51879555",
"0.5154097",
"0.5142348",
"0.5112504",
"0.5081071",
"0.50781465",
"0.5067879",
"0.50665134",
"0.506... | 0.0 | -1 |
Decode with custom models that implements ScorerInterface. | def recog_ctconly(args):
logging.warning(f'RECOGCTCONLY')
logging.warning("experimental API for custom LMs is selected by --api v2")
if args.batchsize > 1:
raise NotImplementedError("multi-utt batch decoding is not implemented")
if args.streaming_mode is not None:
raise NotImplementedEr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dinamic_decode(self):\n raise NotImplementedError",
"def decode(data):\n raise NotImplementedError",
"def decoder(self):\n pass",
"def decode(self, encoded):",
"def decode(self, coded_set):",
"def _decode(self, input_dict):\n pass",
"def decode(self,m):\n raise N... | [
"0.5747375",
"0.56597084",
"0.5655909",
"0.56236535",
"0.5367864",
"0.536351",
"0.53476655",
"0.5307059",
"0.5246623",
"0.52407634",
"0.5230552",
"0.5200018",
"0.5190512",
"0.5155592",
"0.5144635",
"0.5112429",
"0.50815314",
"0.50798166",
"0.50691396",
"0.5068332",
"0.5067991... | 0.0 | -1 |
Decode with custom models that implements ScorerInterface. | def recog_ctconly_lang(args):
logging.warning(f'RECOGCTCONLYLANG')
logging.warning(f'all_langs {args.train_langs}')
logging.warning("experimental API for custom LMs is selected by --api v2")
if args.batchsize > 1:
raise NotImplementedError("multi-utt batch decoding is not implemented")
if a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dinamic_decode(self):\n raise NotImplementedError",
"def decode(data):\n raise NotImplementedError",
"def decoder(self):\n pass",
"def decode(self, encoded):",
"def decode(self, coded_set):",
"def _decode(self, input_dict):\n pass",
"def decode(self,m):\n raise N... | [
"0.57490647",
"0.56625557",
"0.565776",
"0.56256276",
"0.5369684",
"0.53667426",
"0.534932",
"0.5308202",
"0.5245853",
"0.524281",
"0.52324843",
"0.52029294",
"0.5190814",
"0.5156386",
"0.5142517",
"0.51143783",
"0.50833166",
"0.5082138",
"0.5071095",
"0.5070238",
"0.50698984... | 0.0 | -1 |
Decode with custom models that implements ScorerInterface. | def recog_seg(args):
logging.warning(f'RECOGSEG')
logging.warning("experimental API for custom LMs is selected by --api v2")
if args.batchsize > 1:
raise NotImplementedError("multi-utt batch decoding is not implemented")
if args.streaming_mode is not None:
raise NotImplementedError("str... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dinamic_decode(self):\n raise NotImplementedError",
"def decode(data):\n raise NotImplementedError",
"def decoder(self):\n pass",
"def decode(self, encoded):",
"def decode(self, coded_set):",
"def _decode(self, input_dict):\n pass",
"def decode(self,m):\n raise N... | [
"0.57454574",
"0.5658464",
"0.56545657",
"0.5621851",
"0.53665817",
"0.53629136",
"0.5345945",
"0.53054076",
"0.52464706",
"0.52410626",
"0.5228534",
"0.51994413",
"0.51882124",
"0.5154847",
"0.5143546",
"0.51136965",
"0.50817126",
"0.5078946",
"0.50688785",
"0.5066824",
"0.5... | 0.0 | -1 |
Sends an HTTP request to 'player/status/' | def testSimple(self):
self.getPage("player/status/", method = "GET")
self.assertStatus(status = 200)
print 'http headers:'
for header in self.headers.items():
print header
print 'body:'
print simplejson.dumps(self.body,indent=1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_status():\n data = {\n 'status': 'up',\n }\n jsn = json.dumps(data)\n\n resp = Response(jsn, status=200, mimetype='application/json')\n\n return resp",
"def get_player_status(self, player):\n # (title) : Song title\n # Requested Information\n # a (artist): Art... | [
"0.6598885",
"0.65778875",
"0.64045924",
"0.6403228",
"0.61674875",
"0.6140377",
"0.61286503",
"0.6126103",
"0.6078466",
"0.60375863",
"0.6030848",
"0.5961892",
"0.59506136",
"0.5911843",
"0.5906268",
"0.58982503",
"0.5829051",
"0.58256584",
"0.5812865",
"0.5810653",
"0.57865... | 0.66533524 | 0 |
to print the dictionary | def print_dict(self):
print(self.__dict__) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_dict(data):\n print data",
"def printDict(self):\n print str(self)",
"def print_dd_dict( self, ):\n print( self._dd_dict )",
"def pprint(self):\r\n for i in self.items():\r\n print '%s => %r'%i",
"def print(self):\n for fiction in self.fictions:\n ... | [
"0.83672595",
"0.8356495",
"0.81431854",
"0.77898806",
"0.7726312",
"0.7603272",
"0.75941074",
"0.7590774",
"0.74340075",
"0.74219483",
"0.74219483",
"0.74031407",
"0.73473185",
"0.73427135",
"0.7194816",
"0.71855396",
"0.71855396",
"0.70921296",
"0.70680887",
"0.70650184",
"... | 0.76588094 | 5 |
convert class in a dictionary | def to_dict(self):
return self.__dict__ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def class_hook(dct):\n if len(dct) == 1:\n class_name, value = next(iter(dct.items()))\n class_name = class_name.strip('_')\n if class_name == 'Dictionary':\n return Dictionary(*value)\n return dct",
"def classToDict(obj=None):\n\tif obj == None:\n\t\treturn {}\n\n\t_obj = {... | [
"0.6955489",
"0.6860669",
"0.67955244",
"0.664205",
"0.65622425",
"0.6513592",
"0.648857",
"0.647291",
"0.6455078",
"0.64094526",
"0.639815",
"0.6396973",
"0.63957334",
"0.6393332",
"0.6371379",
"0.6364921",
"0.6351631",
"0.63222235",
"0.6319581",
"0.63126314",
"0.6300084",
... | 0.0 | -1 |
Ingresa una pareja llave,valor. Si la llave ya existe, se reemplaza el valor. | def put(rbt, key, value):
try:
rbt['root'] = insertNode(rbt['root'], key, value, rbt['cmpfunction'])
rbt['root']['color'] = node.BLACK
return rbt
except Exception as exp:
error.reraise(exp, 'Bst:Put') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def uvozi_vloge(cur):\n cur.execute(\"DELETE FROM nastopa;\")\n cur.execute(\"DELETE FROM vloga;\")\n vloge = {}\n with open('podatki/vloge.csv') as datoteka:\n podatki = csv.reader(datoteka)\n stolpci = next(podatki)\n v = stolpci.index('vloga')\n poizvedba = \"\"\"\n ... | [
"0.5734998",
"0.5284927",
"0.5232269",
"0.50278807",
"0.50093645",
"0.49711245",
"0.49478197",
"0.492433",
"0.48967597",
"0.48840693",
"0.48563296",
"0.485054",
"0.4845613",
"0.48376054",
"0.48344535",
"0.47956264",
"0.47834414",
"0.4780183",
"0.47569022",
"0.47529238",
"0.47... | 0.0 | -1 |
Retorna una lista con todas las llaves de la tabla | def keySet(rbt):
try:
klist = lt.newList('SINGLE_LINKED', rbt['cmpfunction'])
klist = keySetTree(rbt['root'], klist)
return klist
except Exception as exp:
error.reraise(exp, 'RBT:KeySet') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def edges(self):\n table = []\n edge_index = self.lofted_car.edges\n edge_radius = np.array([0.04166667, 0., 0.01041667, 0., 0.04166667,\n 0.02083333, 0.01041667, 0.02083333, 0.02083333,\n 0.02083333,\n ... | [
"0.6086962",
"0.58893",
"0.5810594",
"0.580533",
"0.5781291",
"0.566528",
"0.5639058",
"0.56260157",
"0.553218",
"0.55098706",
"0.5497589",
"0.5375082",
"0.5357068",
"0.53537947",
"0.53397906",
"0.5326713",
"0.5291013",
"0.528224",
"0.5276992",
"0.5270633",
"0.52701193",
"0... | 0.0 | -1 |
Construye una lista con los valores de la tabla | def valueSet(rbt):
try:
vlist = lt.newList('SINGLE_LINKED', rbt['cmpfunction'])
vlist = valueSetTree(rbt['root'], vlist)
return vlist
except Exception as exp:
error.reraise(exp, 'RBT:valueSet') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def values(self):\n return [entry.value for entry in self.table if entry.value is not None]",
"def get_value_list(self, insupdel=0):\n #NOTE: statement = [record, {...}]\n result = []\n if insupdel == StatementType.INSERT:\n statements = self.statements_insert\n elif... | [
"0.67610854",
"0.6587979",
"0.6507621",
"0.63637394",
"0.6242996",
"0.6207197",
"0.61351895",
"0.6094284",
"0.60926175",
"0.60862446",
"0.60511637",
"0.6019586",
"0.6011023",
"0.59827095",
"0.5976031",
"0.5965172",
"0.59622747",
"0.59427965",
"0.59256226",
"0.5921408",
"0.591... | 0.0 | -1 |
Retorna la altura del arbol | def height(rbt):
try:
return heightTree(rbt['root'])
except Exception as exp:
error.reraise(exp, 'RBT:height') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_alt(self):\n p = self._get_sub_text('alt')\n if not p:\n return None\n else:\n try:\n return int(p)\n except ValueError:\n return None",
"def getRestricaoPlacaFinal(self):\n import ast\n restricao_placa_fina... | [
"0.64514583",
"0.6033798",
"0.6007864",
"0.5769737",
"0.5769737",
"0.5764125",
"0.5623761",
"0.5560028",
"0.5551233",
"0.55263346",
"0.55175483",
"0.54674464",
"0.54409194",
"0.5424623",
"0.53518784",
"0.53320485",
"0.5271793",
"0.52638614",
"0.52592796",
"0.52513933",
"0.520... | 0.0 | -1 |
Retorna todas las llaves del arbol que se encuentren entre [keylo, keyhi] | def keys(rbt, keylo, keyhi):
try:
lstkeys = lt.newList('SINGLELINKED', rbt['cmpfunction'])
lstkeys = keysRange(rbt['root'], keylo, keyhi, lstkeys,
rbt['cmpfunction'])
return lstkeys
except Exception as exp:
error.reraise(exp, 'RBT:keys') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def caesuras(k):\n caesuras = []\n for idx, i in enumerate(k):\n if i in k[idx + 1:]:\n caesuras.append(idx)\n return caesuras",
"def keys():",
"def keysAll():",
"def triangulos_rectangulos(opcion,b,h):\n x1 =[0,0]\n ... | [
"0.54930055",
"0.5466304",
"0.54661936",
"0.5365569",
"0.53530455",
"0.534807",
"0.53398854",
"0.53104085",
"0.5282643",
"0.5281222",
"0.50924355",
"0.50345254",
"0.50326174",
"0.5031676",
"0.49859047",
"0.49760678",
"0.49699897",
"0.49666688",
"0.49497998",
"0.49482527",
"0.... | 0.56539536 | 0 |
Retorna todas los valores del arbol que se encuentren entre [keylo, keyhi] | def values(rbt, keylo, keyhi):
try:
lstvalues = lt.newList('SINGLELINKED', rbt['cmpfunction'])
lstvalues = valuesRange(rbt['root'], keylo, keyhi, lstvalues,
rbt['cmpfunction'])
return lstvalues
except Exception as exp:
error.reraise(exp, 'RBT:Value... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getall(self, key):\n return self.values.get(key, [])",
"def get_values():\n a1 = insert_data(\"a1\")\n r = insert_data(\"r\")\n n = insert_data(\"n\")\n return a1, r, n",
"def get(con,key):\n # yy=atpic.log.setname(xx,'get')\n thecommand=\"get {key}\\r\\n\".format(key=key)\n # a... | [
"0.59552354",
"0.5820003",
"0.5759505",
"0.5744926",
"0.5744926",
"0.5709699",
"0.5685493",
"0.5685493",
"0.5669403",
"0.5668395",
"0.55271715",
"0.55146015",
"0.55090475",
"0.54791063",
"0.5465725",
"0.5443579",
"0.5428568",
"0.5414096",
"0.5408089",
"0.5369653",
"0.53522706... | 0.6228335 | 0 |
Construye una lista con los valorers de la tabla | def valueSetTree(root, klist):
try:
if (root is not None):
valueSetTree(root['left'], klist)
lt.addLast(klist, root['value'])
valueSetTree(root['right'], klist)
return klist
except Exception as exp:
error.reraise(exp, 'RBT:valueSetTree') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def values(self):\n return [entry.value for entry in self.table if entry.value is not None]",
"def values(self) -> List:\n pass",
"def rows(self):\n return list(self)",
"def values(self):\n return [row.values for row in self]",
"def get_value_list(self, insupdel=0):\n #NOTE: ... | [
"0.6495255",
"0.6341016",
"0.62423235",
"0.6214849",
"0.6172965",
"0.61069995",
"0.6105375",
"0.59903044",
"0.5985913",
"0.5955074",
"0.5912254",
"0.59120584",
"0.5893518",
"0.58875644",
"0.5830432",
"0.58080864",
"0.579894",
"0.578962",
"0.5760287",
"0.57566446",
"0.5750182"... | 0.0 | -1 |
Construye una lista con las llaves de la tabla | def keySetTree(root, klist):
try:
if (root is not None):
keySetTree(root['left'], klist)
lt.addLast(klist, root['key'])
keySetTree(root['right'], klist)
return klist
except Exception as exp:
error.reraise(exp, 'BST:keySetTree') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def creaLados(vertices):\n\tlados = []\n\tfor i in range(len(vertices)-1):\n\t\tlados.append((i, i+1))\n\tlados.append((i+1,0))\n\treturn lados",
"def edges(self):\n table = []\n edge_index = self.lofted_car.edges\n edge_radius = np.array([0.04166667, 0., 0.01041667, 0., 0.04166667,\n ... | [
"0.5661952",
"0.5641655",
"0.5280575",
"0.5262452",
"0.52430177",
"0.52399147",
"0.5239519",
"0.52204",
"0.52175784",
"0.5199818",
"0.5191856",
"0.51906866",
"0.5174329",
"0.5166817",
"0.51569086",
"0.5131866",
"0.5119306",
"0.5115338",
"0.5114313",
"0.5112016",
"0.5104501",
... | 0.0 | -1 |
Cambia el color de un nodo | def flipNodeColor(rbnode):
try:
if (rbnode is not None):
if (rbnode['color'] == node.RED):
rbnode['color'] = node.BLACK
else:
rbnode['color'] = node.RED
except Exception as exp:
error.reraise(exp, 'RBT:flipNodeColors') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _color(self, args):",
"def changeColor( self ):\n\t\t\n\t\tx, y = self.position.xy\n\t\tself.color = ( int((x / WINDOW_X) * 128), int((x / WINDOW_X) * 128) + int((y / WINDOW_Y) * 128 ), int((y / WINDOW_Y) * 128))",
"def get_color(self):\n return \"yellow\"",
"def setColor(self,value):\n\t\tself.po... | [
"0.682446",
"0.65651417",
"0.6545235",
"0.6535278",
"0.6474425",
"0.6446628",
"0.6444653",
"0.6423879",
"0.641201",
"0.640824",
"0.6393506",
"0.6391409",
"0.63702685",
"0.6338181",
"0.6337946",
"0.63358945",
"0.63351315",
"0.63111734",
"0.63094306",
"0.629957",
"0.62433887",
... | 0.0 | -1 |
Indica si un nodo del arbol es rojo | def isRed(rbnode):
try:
if (rbnode is None):
return False
else:
return (rbnode['color'] == node.RED)
except Exception as exp:
error.reraise(exp, 'RBT:isRed') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def posicion_libre(posicion, tablero):\n i, j = posiciones[posicion]\n return tablero[i][j] not in [\"X\", \"O\"]",
"def larceny(x): \n for elem in x:\n if elem == 'Larceny':\n return 1\n return 0",
"def rellena(self):\r\n for nodo in range(0, self.red['n']):\r\n ... | [
"0.575324",
"0.5393571",
"0.53649163",
"0.534711",
"0.52205145",
"0.52030355",
"0.5183418",
"0.51602805",
"0.5151644",
"0.5145168",
"0.51417536",
"0.5134104",
"0.5129342",
"0.51212126",
"0.511644",
"0.50979215",
"0.50649536",
"0.5041791",
"0.50302386",
"0.5003249",
"0.49886",... | 0.0 | -1 |
Retorna la altura del arbol | def heightTree(root):
try:
if (root is None):
return -1
else:
return 1 + max(heightTree(root['left']), heightTree(root['right']))
except Exception as exp:
error.reraise(exp, 'RBT:heightTree') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_alt(self):\n p = self._get_sub_text('alt')\n if not p:\n return None\n else:\n try:\n return int(p)\n except ValueError:\n return None",
"def getRestricaoPlacaFinal(self):\n import ast\n restricao_placa_fina... | [
"0.64514583",
"0.6033798",
"0.6007864",
"0.5769737",
"0.5769737",
"0.5764125",
"0.5623761",
"0.5560028",
"0.5551233",
"0.55263346",
"0.55175483",
"0.54674464",
"0.54409194",
"0.5424623",
"0.53518784",
"0.53320485",
"0.5271793",
"0.52638614",
"0.52592796",
"0.52513933",
"0.520... | 0.0 | -1 |
Retorna la menor llave de la tabla de simbolos | def minKeyTree(root):
try:
min = None
if (root is not None):
if (root['left'] is None):
min = root
else:
min = minKeyTree(root['left'])
return min
except Exception as exp:
error.reraise(exp, 'BST:minKeyNode') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def db_table(self):",
"def _get_table(self):\n\t\treturn self._table",
"def table(self):\n return self.t",
"def table(self):\n return self.generator.table",
"def table(self):\r\n return self._table",
"def table(self):\n return self._table",
"def table(self):\n return self... | [
"0.6278391",
"0.62468314",
"0.61417526",
"0.59707",
"0.5962698",
"0.5889534",
"0.5889534",
"0.5727264",
"0.56463814",
"0.5611516",
"0.55952156",
"0.5588092",
"0.5582471",
"0.55522346",
"0.5552013",
"0.5538822",
"0.5531865",
"0.5525017",
"0.5522536",
"0.55203056",
"0.5493766",... | 0.0 | -1 |
Retorna todas las llaves del arbol en un rango dado | def keysRange(root, keylo, keyhi, lstkeys, cmpfunction):
try:
if (root is not None):
complo = cmpfunction(keylo, root['key'])
comphi = cmpfunction(keyhi, root['key'])
if (complo < 0):
keysRange(root['left'], keylo, keyhi, lstkeys, cmpfunction)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSlaves():",
"def reemplaza_tildes(palabra):",
"def arroba_letras(cadena, long_palabra, costo_palabra_corta, costo_palabra_larga):\n palabras = cadena.split(\" \")\n frase_final = \"\"\n costo_total = 0\n for i in range(len(palabras)):\n if len(palabras[i]) > long_palabra:#verificio si... | [
"0.61546427",
"0.6092891",
"0.60230464",
"0.58362556",
"0.5798641",
"0.57370836",
"0.5722869",
"0.571663",
"0.5704517",
"0.5677203",
"0.56217366",
"0.5610547",
"0.55886686",
"0.557021",
"0.5499204",
"0.54892117",
"0.548844",
"0.5463902",
"0.54591924",
"0.5431312",
"0.54289955... | 0.0 | -1 |
Retorna todas los valores del arbol en un rango dado por [keylo, keyhi] | def valuesRange(root, keylo, keyhi, lstvalues, cmpfunction):
try:
if (root is not None):
complo = cmpfunction(keylo, root['key'])
comphi = cmpfunction(keyhi, root['key'])
if (complo < 0):
valuesRange(root['left'], keylo, keyhi, lstvalues,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_values():\n a1 = insert_data(\"a1\")\n r = insert_data(\"r\")\n n = insert_data(\"n\")\n return a1, r, n",
"def get(con,key):\n # yy=atpic.log.setname(xx,'get')\n thecommand=\"get {key}\\r\\n\".format(key=key)\n # atpic.log.debug(yy,'get command:',thecommand)\n con.send(thecommand... | [
"0.62296665",
"0.60632324",
"0.5898418",
"0.5852337",
"0.5796931",
"0.56805223",
"0.56805223",
"0.5639313",
"0.5617256",
"0.5608096",
"0.5608096",
"0.56026095",
"0.5602499",
"0.5451546",
"0.544361",
"0.54403853",
"0.54006344",
"0.53979206",
"0.5394816",
"0.53846955",
"0.53236... | 0.0 | -1 |
Encuentra y remueve la menor llave de la tabla de simbolos y su valor asociado | def deleteMinTree(root):
try:
if (root['left'] is None):
return None
if ((not isRed(root['left'])) and ((not isRed(root['left']['left'])))):
root = moveRedLeft(root)
root['left'] = deleteMinTree(root['left'])
root = balance(root)
return root
excep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def modificar_tablero(tablero, simbolo, posicion):\n i, j = posiciones[posicion]\n tablero[i][j] = simbolo\n return tablero",
"def nuevaClave( self ) :\r\n liActual = [ columna.clave for columna in self.liColumnas if columna.siFormula ]\r\n numero = 1\r\n while True :\r\n ... | [
"0.6143716",
"0.58006257",
"0.5797941",
"0.5714387",
"0.5518073",
"0.5369162",
"0.52869046",
"0.5189154",
"0.5173144",
"0.5153922",
"0.51478547",
"0.51395077",
"0.51072294",
"0.5099724",
"0.50643224",
"0.50595075",
"0.503407",
"0.5029785",
"0.5025654",
"0.5010453",
"0.5002896... | 0.0 | -1 |
Encuentra y remueve la mayor llave de la tabla de simbolos y su valor asociado | def deleteMaxTree(root):
try:
if (isRed(root['left'])):
root = rotateRight(root)
if (root['right'] is None):
return None
if ((not isRed(root['right'])) and
((not isRed(root['right']['left'])))):
root = moveRedRight(root)
root['right'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def modificar_tablero(tablero, simbolo, posicion):\n i, j = posiciones[posicion]\n tablero[i][j] = simbolo\n return tablero",
"def nuevaClave( self ) :\r\n liActual = [ columna.clave for columna in self.liColumnas if columna.siFormula ]\r\n numero = 1\r\n while True :\r\n ... | [
"0.589483",
"0.57015175",
"0.55293685",
"0.5401105",
"0.53825414",
"0.53142506",
"0.52072495",
"0.51530755",
"0.5059754",
"0.50572884",
"0.50099957",
"0.49965996",
"0.4982538",
"0.49711207",
"0.49506447",
"0.4936919",
"0.48996902",
"0.488858",
"0.48815435",
"0.48732385",
"0.4... | 0.0 | -1 |
Cambio de color durante el proceso de eliminacion | def moveRedRight(root):
try:
flipColors(root)
if (isRed(root['left']['left'])):
root = rotateRight(root)
flipColors(root)
return root
except Exception as exp:
error.reraise(exp, 'RBT:moveRedLeft') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gradationredWipe(strip, wait_ms=10):\n color=Color(0,255,0)\n for i in range(strip.numPixels()/2):\n strip.setPixelColor(strip.numPixels()/2-i-1, color+256*256*7*i)\n strip.setPixelColor(i+strip.numPixels()/2, color+256*256*7*i)\n #print(color)\n strip.show()\n time.sle... | [
"0.6761813",
"0.67576456",
"0.67344",
"0.67042047",
"0.6687209",
"0.6645029",
"0.66438633",
"0.6641287",
"0.6637732",
"0.6637732",
"0.6611666",
"0.66003597",
"0.655025",
"0.65240425",
"0.6520002",
"0.6475826",
"0.64448905",
"0.6416703",
"0.635901",
"0.62895775",
"0.6284867",
... | 0.0 | -1 |
Cambio de color durante el proceso de eliminacion | def moveRedLeft(root):
try:
flipColors(root)
if (isRed(root['right']['left'])):
root['right'] = rotateRight(root['right'])
root = rotateLeft(root)
flipColors(root)
return root
except Exception as exp:
error.reraise(exp, 'RBT:moveRedLeft') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gradationredWipe(strip, wait_ms=10):\n color=Color(0,255,0)\n for i in range(strip.numPixels()/2):\n strip.setPixelColor(strip.numPixels()/2-i-1, color+256*256*7*i)\n strip.setPixelColor(i+strip.numPixels()/2, color+256*256*7*i)\n #print(color)\n strip.show()\n time.sle... | [
"0.67647237",
"0.6760774",
"0.67350554",
"0.6705116",
"0.66866803",
"0.6648157",
"0.6644682",
"0.6642168",
"0.6638548",
"0.6638548",
"0.66126376",
"0.6601241",
"0.65508455",
"0.6524975",
"0.6522062",
"0.64751035",
"0.6446706",
"0.6417296",
"0.6358701",
"0.6290268",
"0.6286963... | 0.0 | -1 |
Computes Bjs matrix for a defect in a given anisotropic medium | def bjs(l, c):
if len(l) == 4:
l = mbvector(l)
elif len(l) == 3:
pass
else:
return 0
v = np.array([1, pi, e])
r = l / np.linalg.norm(l)
m = np.cross(r, v)
n = np.cross(r, m)
m = m / np.linalg.norm(m)
n = n / np.linalg.norm(n)
w = np.arange(0, 2 * pi, 0.001... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _getBMat(self):\n\n \"\"\"B matrix is just a mass matrix, can be easily assembled\n through fenics. However, the ordering in Fenics is not the\n mesh ordering. So we build a temp matrix and then use the\n vertex to dof map to get the right ordering interms of our\n mesh nodes... | [
"0.6278779",
"0.5816178",
"0.5799315",
"0.57437575",
"0.565044",
"0.55140615",
"0.5501549",
"0.5437091",
"0.53895843",
"0.53818303",
"0.5353231",
"0.5322105",
"0.5305896",
"0.529486",
"0.5269439",
"0.52539384",
"0.525364",
"0.5223441",
"0.5220368",
"0.5218853",
"0.51902485",
... | 0.53015864 | 13 |
Populates 4D elastic tensor from 6x6 elastic tensor | def Cijkl(C):
c = np.zeros(shape=(3, 3, 3, 3))
CC = np.zeros(shape=(9, 9))
CC[0:6, 0:6] = C[0:6, 0:6]
CC[6:9, 6:9] = C[3:6, 3:6]
CC[0:6, 6:9] = C[0:6, 3:6]
CC[6:9, 0:6] = C[3:6, 0:6]
c[0, 0, 0, 0] = CC[0, 0]
c[0, 0, 1, 1] = CC[0, 1]
c[0, 0, 2, 2] = CC[0, 2]
c[0, 0, 1, 2] = CC[0,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _4d_tensor(self, name, tensor, **kwargs):\r\n h, w, c, num_tensor = tensor.shape.as_list()\r\n\r\n # Try to visualise convolutional filters or feature maps\r\n # See: https://gist.github.com/kukuruza/03731dc494603ceab0c5\r\n # input shape: (Y, X, C, N)\r\n if c != 1 and c != ... | [
"0.645886",
"0.56280047",
"0.55941963",
"0.55898535",
"0.55519897",
"0.55153",
"0.54828554",
"0.5457415",
"0.5443727",
"0.5424891",
"0.5404391",
"0.53744656",
"0.53711516",
"0.53519404",
"0.5349043",
"0.53421223",
"0.53419113",
"0.53325886",
"0.53046644",
"0.5291646",
"0.5277... | 0.0 | -1 |
Populates 6x6 elastic tensor for cubic crystals | def cubeCij(c11, c13, c44):
C = np.zeros(shape=(6, 6))
C[0, 0] = C[1, 1] = C[2, 2] = c11
C[0, 1] = C[0, 2] = C[1, 0] = C[1, 2] = C[2, 0] = C[2, 1] = c13
C[3, 3] = C[4, 4] = C[5, 5] = c44
S = np.linalg.inv(C)
return {"C": C, "S": S} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_sc(self):\n sc = []\n a = np.array([1, 0, 0], dtype=np.float32)\n b = np.array([0, 1, 0], dtype=np.float32)\n c = np.array([0, 0, 1], dtype=np.float32)\n # order z -> y -> x\n for i, j, k in itertools.product(*itertools.repeat(range(-(self.nsc//2),self.nsc//2+1), 3... | [
"0.6207161",
"0.6204961",
"0.5940996",
"0.5841021",
"0.5796941",
"0.56329495",
"0.56159425",
"0.56084204",
"0.5568752",
"0.5554606",
"0.55243033",
"0.55191934",
"0.5518823",
"0.5498849",
"0.5498104",
"0.54870147",
"0.54841",
"0.54828954",
"0.5440627",
"0.54392284",
"0.5436503... | 0.0 | -1 |
Converts MillerBravais plane indices to cartesian normal vectors | def mbplane(A, c=sqrt(8 / 3)):
# for Sun Mg Potential: c=1.6281689374348
if A[0] == 0 and A[1] == 0 and A[2] == 0:
B = np.array([0, 0, 1])
else:
if A[0] == 0:
p1 = np.array([-0.5 / A[1], 0.5 * sqrt(3) / A[1], 0])
p2 = np.array([-0.5 / A[2], -0.5 * sqrt(3) / A[2], 0])... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plane_equation(point_a, point_b, point_c):\n v1 = np.subtract(point_a, point_c)\n v2 = np.subtract(point_a, point_b)\n normal = np.cross(v1, v2)\n # print 'b4 norm', normal\n unit_normal = norm_vect(normal)\n # print 'unityyy', unit_normal\n return unit_normal",
"def get_normal_vector_of... | [
"0.65218204",
"0.6503691",
"0.645618",
"0.640167",
"0.6362043",
"0.633903",
"0.6333386",
"0.62251955",
"0.61807",
"0.5980656",
"0.5965315",
"0.58766127",
"0.5865005",
"0.5738643",
"0.5692937",
"0.5692491",
"0.5678418",
"0.5664199",
"0.5654711",
"0.5653635",
"0.5626195",
"0.... | 0.0 | -1 |
Converts noncubic crystal indices to cartesiancoordinate vectors whilst preserving vector length. | def mbvector(A, c=sqrt(8 / 3)):
la = len(A)
sa = A.size
if la == sa:
B = np.array([0.0, 0.0, 0.0])
a1 = A[0] * np.array([1.0, 0.0])
a2 = A[1] * np.array([-0.5, 0.5 * sqrt(3)])
a3 = A[2] * np.array([-0.5, -0.5 * sqrt(3)])
B[0] = a1[0] + a2[0] + a3[0]
B[1] = a1[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cxvec(self):\n return np.array([self.cx, self.cy])",
"def get_cartesian_coords(self):\n r = 1\n dec = self.dec + 90\n x = r * math.sin(np.deg2rad(dec)) * math.cos(np.deg2rad(self.ra))\n y = r * math.sin(np.deg2rad(dec)) * math.sin(np.deg2rad(self.ra))\n z = r * math.cos(... | [
"0.64601624",
"0.6313934",
"0.6292211",
"0.618065",
"0.61797065",
"0.6153555",
"0.6128813",
"0.6096424",
"0.60606337",
"0.5981715",
"0.5911841",
"0.5836146",
"0.5835889",
"0.5830214",
"0.5827372",
"0.58222485",
"0.5816691",
"0.58102924",
"0.5799981",
"0.5760489",
"0.5751354",... | 0.0 | -1 |
Converts cartesian normal vectors into MillerBravais plane indices | def mvector(B, c):
# for Sun Mg Potential: c=1.6281689374348
A = np.zeros(shape=4)
A[0] = (2 / 3) * B[0]
A[1] = 0.5 * ((2 / sqrt(3)) * B[1] - A[0])
A[2] = -A[0] - A[1]
A[3] = B[2] / c
return A | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plane_equation(point_a, point_b, point_c):\n v1 = np.subtract(point_a, point_c)\n v2 = np.subtract(point_a, point_b)\n normal = np.cross(v1, v2)\n # print 'b4 norm', normal\n unit_normal = norm_vect(normal)\n # print 'unityyy', unit_normal\n return unit_normal",
"def normal_vector(origin... | [
"0.6565002",
"0.65067965",
"0.64226294",
"0.62855655",
"0.6252082",
"0.6249797",
"0.62446517",
"0.6125102",
"0.60917956",
"0.5859786",
"0.58306587",
"0.57857585",
"0.5702033",
"0.5697134",
"0.5696204",
"0.56910414",
"0.56821984",
"0.5681735",
"0.5674337",
"0.56567013",
"0.565... | 0.5339138 | 68 |
Converts cartesian vectors into MillerBravais vector indices | def mplane(B, c):
# for Sun Mg Potential: c=1.6281689374348
A = np.zeros(shape=4)
s = A.shape
phi = 0
l = 0
b = 0
for i in range(s[0]):
A[0] = (2 / 3) * B[0]
A[1] = 0.5 * ((2 / sqrt(3)) * B[1] - A[0])
A[2] = -A[0] - A[1]
phi = atan(B[1] / B[0])
b = 0.5... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cartesian2bary(self, x):\n lam = np.zeros((x.shape[0], 3))\n lam[:,:2] = np.einsum('ij,kj->ki', self.Tinv, x - self.xv[2])\n lam[:,2] = 1. - lam[:,0] - lam[:,1]\n return lam",
"def project_vectors(self, vectors):\n return np.dot(vectors, self.components.T)",
"def cxvec(se... | [
"0.60982597",
"0.6096606",
"0.5928866",
"0.5878671",
"0.5862804",
"0.5852861",
"0.57384753",
"0.5711407",
"0.56912196",
"0.5668883",
"0.5655643",
"0.56316304",
"0.55861735",
"0.5576225",
"0.5573143",
"0.5563656",
"0.5560922",
"0.5555036",
"0.5547608",
"0.55325174",
"0.5528160... | 0.0 | -1 |
Rotates coordinate system from x1,z1 to x2,z2 | def rotation(x1, z1, x2, z2):
e1 = np.zeros(shape=(3, 3))
e2 = np.zeros(shape=(3, 3))
e1[0, :] = x1 / np.linalg.norm(x1)
e1[2, :] = z1 / np.linalg.norm(z1)
e1[1, :] = np.cross(e1[2, :], e1[0, :])
e2[0, :] = x2 / np.linalg.norm(x2)
e2[2, :] = z2 / np.linalg.norm(z2)
e2[1, :] = np.cross(e2... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rotateZ(self, *args, **kwargs):\n ...",
"def rotation(x,y,z):\r\n phi = np.arctan(z/sqrt(x**2+y**2))\r\n lamb = np.arctan2(y,x)\r\n G = np.array([[-sin(lamb), cos(lamb), 0],\r\n [-sin(phi) * cos(lamb), -sin(phi) * sin(lamb), cos(phi)],\r\n [cos(phi) * cos(lam... | [
"0.72137934",
"0.6789719",
"0.66737",
"0.6606905",
"0.6600858",
"0.65760684",
"0.65532327",
"0.65532327",
"0.65532327",
"0.65532327",
"0.6507178",
"0.64992857",
"0.64870286",
"0.6475885",
"0.6472012",
"0.6458319",
"0.6445637",
"0.6438456",
"0.6432099",
"0.643071",
"0.6415745"... | 0.77712363 | 0 |
Converts strain state to displacements With the convention that ux=f(x,y), uy=f(y,z), uz=f(z,x) | def strain2disp(e, A):
l = A.shape
u = np.zeros(shape=l)
for i in range(l[0]):
u[i, 0] = e[0, 0] * A[i, 0] + e[0, 1] * A[i, 1]
u[i, 1] = e[1, 1] * A[i, 1] + e[1, 2] * A[i, 2]
u[i, 2] = e[2, 2] * A[i, 2] + e[0, 2] * A[i, 0]
return u | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reverse_state(self):\n state = np.array(self.get_reverse_state_arr())\n om = utils.build_occupancy_maps(utils.build_humans(state))\n # print(\"OM: \", om.size())\n # We only have a batch of one so just get the first element of\n # transform and rotate\n state = utils.t... | [
"0.5913096",
"0.574097",
"0.5734477",
"0.5705467",
"0.5608403",
"0.55807066",
"0.5495976",
"0.5495976",
"0.5495976",
"0.5444154",
"0.53824127",
"0.53726685",
"0.53664255",
"0.5356983",
"0.53183407",
"0.5317279",
"0.53069645",
"0.52513015",
"0.5239924",
"0.5210715",
"0.5183561... | 0.0 | -1 |
Converts stress state to strain state | def stress2strain(sigma, S):
s6 = voigt(sigma)
e6 = np.dot(S, s6)
e6[3] = 0.5 * e6[3]
e6[4] = 0.5 * e6[4]
e6[5] = 0.5 * e6[5]
e = unvoigt(e6)
return e | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize_state(self):\n self.state = 2 * (self.state - 0.5)",
"def get_state_s(self, lower = True):\r\n\r\n state_s = STATE_STRINGS[self._state - 1]\r\n state_s = state_s.lower() if lower else state_s\r\n return state_s",
"def _state_convert(self, raw_state):\n variables... | [
"0.6264138",
"0.59735096",
"0.5917664",
"0.5915843",
"0.58080965",
"0.57078695",
"0.5452941",
"0.544726",
"0.5424653",
"0.53956044",
"0.5375939",
"0.53561866",
"0.5349646",
"0.5337765",
"0.5305472",
"0.52900547",
"0.5284307",
"0.52565426",
"0.52550626",
"0.5244411",
"0.523709... | 0.5284506 | 16 |
Converts from 6x1 to 3x3 | def unvoigt(A):
a = np.zeros(shape=(3, 3))
a[0, 0] = A[0]
a[0, 1] = A[5]
a[0, 2] = A[4]
a[1, 0] = A[5]
a[1, 1] = A[1]
a[1, 2] = A[3]
a[2, 0] = A[4]
a[2, 1] = A[3]
a[2, 2] = A[2]
return a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make8UC3(mat):\n mat_8UC = make8UC(mat)\n mat_8UC3 = np.stack((mat_8UC,)*3, axis = -1)\n \n return mat_8UC3",
"def dti6to33(dt6):\n dt33 = numpy.zeros(dt6.shape[:-1] + (3, 3), dtype=dt6.dtype)\n dt33[..., 0, 0] = dt6[..., 5] # dxx\n dt33[..., 0, 1] = dt33[..., 1, 0] = dt6[..., 4] / 2 #... | [
"0.6342387",
"0.62157285",
"0.61090064",
"0.6037838",
"0.58831704",
"0.5652443",
"0.5637152",
"0.5616307",
"0.5598152",
"0.5570862",
"0.554038",
"0.552032",
"0.550749",
"0.5502176",
"0.5461463",
"0.5430975",
"0.542803",
"0.54076666",
"0.54068506",
"0.54068506",
"0.54051447",
... | 0.49841478 | 95 |
Performs vector contraction in the form of m C n | def vect_contract(m, c, n):
a = np.tensordot(m, c, (0, 0))
mn = np.tensordot(a, n, (2, 0))
return mn | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getVector(c1, c2):\n return [c1[0] - c2[0], c1[1] - c2[1], c1[2] - c2[2]]",
"def mvector(B, c):\n # for Sun Mg Potential: c=1.6281689374348\n A = np.zeros(shape=4)\n A[0] = (2 / 3) * B[0]\n A[1] = 0.5 * ((2 / sqrt(3)) * B[1] - A[0])\n A[2] = -A[0] - A[1]\n A[3] = B[2] / c\n return A",... | [
"0.6204063",
"0.6118313",
"0.6027351",
"0.59437466",
"0.5920729",
"0.58891094",
"0.58567584",
"0.58476985",
"0.58374596",
"0.58282095",
"0.5810846",
"0.5797152",
"0.5795684",
"0.5795684",
"0.5795684",
"0.5773497",
"0.5768829",
"0.56864727",
"0.5681027",
"0.56669194",
"0.56448... | 0.709335 | 0 |
Converts from 3x3 to 6x1 | def voigt(a):
A = np.zeros(shape=(6, 1))
A[0] = a[0, 0]
A[1] = a[1, 1]
A[2] = a[2, 2]
A[3] = a[1, 2]
A[4] = a[0, 2]
A[5] = a[0, 1]
return A | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make8UC3(mat):\n mat_8UC = make8UC(mat)\n mat_8UC3 = np.stack((mat_8UC,)*3, axis = -1)\n \n return mat_8UC3",
"def dti6to33(dt6):\n dt33 = numpy.zeros(dt6.shape[:-1] + (3, 3), dtype=dt6.dtype)\n dt33[..., 0, 0] = dt6[..., 5] # dxx\n dt33[..., 0, 1] = dt33[..., 1, 0] = dt6[..., 4] / 2 #... | [
"0.61705595",
"0.59333605",
"0.56910497",
"0.56123316",
"0.5608155",
"0.55314213",
"0.5478484",
"0.5430528",
"0.54113424",
"0.5405368",
"0.5405368",
"0.5388583",
"0.5362073",
"0.5334513",
"0.53329366",
"0.53061944",
"0.5296388",
"0.5294149",
"0.52797616",
"0.5278745",
"0.5270... | 0.54071677 | 9 |
Query memory given an input embedding | def query(self, query, n_neighbours):
if self.added_memories == 0:
return None
# TODO: possibly L2-normalize query vector?
# allow single queries as well, not only batches
if query.dim() == 1:
query.unsqueeze_(0)
idx, distances = self.get_nearest_entries_i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_embed(input_data, vocab_size, embed_dim):\n embedding = tf.Variable(tf.random_uniform((vocab_size,embed_dim), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, input_data)\n #print (\"embed_dim: \",embed_dim) # 向量表达维度为 256\n #print (\"input_data.shape: \",input_data.shape) # (50, 5)\n #p... | [
"0.63078344",
"0.63063365",
"0.5960762",
"0.5928939",
"0.58945125",
"0.58742183",
"0.58714825",
"0.5823085",
"0.5794332",
"0.5751944",
"0.56750214",
"0.5587403",
"0.55768526",
"0.557125",
"0.5565566",
"0.5550268",
"0.5541789",
"0.5470685",
"0.5447556",
"0.54236406",
"0.540829... | 0.6070764 | 3 |
Add entries to the memory module. | def add_entry(self, embeddings, labels, query_result=None):
n_added = embeddings.shape[0]
if self.added_memories + n_added <= self.memory_size:
start = self.write_pointer + 1
end = start + n_added
self.update_ixs(range(start, end), embeddings, labels, query_result)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_memory(self, **kwarg):\n for name, obs in kwarg.items():\n self.buffers[name] = np.concatenate((self.buffers[name], obs), axis=0)\n # get recent memory\n return self",
"def record_memory_map(self):\n memory_map = self.get_memory_map()\n self._memory_map_r... | [
"0.65852726",
"0.6368498",
"0.62108815",
"0.62035614",
"0.6151291",
"0.6102449",
"0.60953045",
"0.6070591",
"0.58292973",
"0.580414",
"0.5742335",
"0.57391006",
"0.5659953",
"0.56543183",
"0.5636044",
"0.56220376",
"0.56029516",
"0.55805933",
"0.55668706",
"0.5543858",
"0.553... | 0.5632198 | 15 |
Update specific memory slots If query_result is not supplied, relevance scores are not updated. | def update_ixs(self, ixs, embeddings, labels, query_result=None, global_update=True):
self.memory_embeddings[ixs] = embeddings
self.memory_labels[ixs] = labels
self.memory_age[ixs] = 0
self.memory_relevance[ixs] = 0
if global_update:
self.memory_age[self.memory_age !=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _update(self, nbrs, nbrs_y, query, query_y):\n\n # Set up the graph for our shared memory variables\n new_K, new_A, new_V = self.K, self.A, self.V\n\n # Condition (1): First returned neighbour shares the same query label\n correct_query = T.eq(nbrs_y[:, 0], query_y).nonzero()[0]\n ... | [
"0.61297095",
"0.5953453",
"0.5922591",
"0.5553142",
"0.544283",
"0.5403002",
"0.5356434",
"0.5338803",
"0.5331692",
"0.5323351",
"0.5294844",
"0.5292601",
"0.5231745",
"0.52154356",
"0.51240927",
"0.50593865",
"0.5058139",
"0.5054779",
"0.50533724",
"0.5042255",
"0.50057137"... | 0.620225 | 0 |
Query memory given an input embedding | def query(self, query, n_neighbours):
if self.added_memories == 0:
return None
# TODO: possibly L2-normalize query vector?
# allow single queries as well, not only batches
if query.dim() == 1:
query.unsqueeze_(0)
idx, distances = self.get_nearest_entries_i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_embed(input_data, vocab_size, embed_dim):\n embedding = tf.Variable(tf.random_uniform((vocab_size,embed_dim), -1, 1))\n embed = tf.nn.embedding_lookup(embedding, input_data)\n #print (\"embed_dim: \",embed_dim) # 向量表达维度为 256\n #print (\"input_data.shape: \",input_data.shape) # (50, 5)\n #p... | [
"0.63078344",
"0.63063365",
"0.5960762",
"0.5928939",
"0.58945125",
"0.58742183",
"0.58714825",
"0.5823085",
"0.5794332",
"0.5751944",
"0.56750214",
"0.5587403",
"0.55768526",
"0.557125",
"0.5565566",
"0.5550268",
"0.5541789",
"0.5470685",
"0.5447556",
"0.54236406",
"0.540829... | 0.6070764 | 2 |
Add entries to the memory module. | def add_entry(self, embeddings, labels, query_result=None):
n_added = embeddings.shape[0]
class_discount = self.class_discount
for embedding, label in zip(embeddings, labels):
n = self.n_class_embeddings[label]
if self.class_discount_method == "mean":
clas... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_memory(self, **kwarg):\n for name, obs in kwarg.items():\n self.buffers[name] = np.concatenate((self.buffers[name], obs), axis=0)\n # get recent memory\n return self",
"def record_memory_map(self):\n memory_map = self.get_memory_map()\n self._memory_map_r... | [
"0.65852726",
"0.6368498",
"0.62108815",
"0.62035614",
"0.6151291",
"0.6102449",
"0.60953045",
"0.6070591",
"0.58292973",
"0.580414",
"0.5742335",
"0.57391006",
"0.5659953",
"0.56543183",
"0.5636044",
"0.5632198",
"0.56220376",
"0.56029516",
"0.55805933",
"0.55668706",
"0.554... | 0.0 | -1 |
Update class representations with new class means. | def update(self, class_means, unique_labels, logger=None):
n_added = class_means.shape[0]
class_discount = self.class_discount
to_update = unique_labels
normalized_class_means = None
normalized_class_representations = None
self.update_last_updated(unique_labels)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_class_records():\n logger.info('Fetching class ids and labels for '\n 'classes with direct instances')\n timestamp = statistics.get_current_timestamp()\n results = sparql.sparql_query(queries.QUERY_CLASSES,\n fallback=queries.QUERY_CLASSSES_FALLBA... | [
"0.6709953",
"0.61785007",
"0.6076284",
"0.595551",
"0.58957285",
"0.5783457",
"0.5720336",
"0.57154924",
"0.5688674",
"0.56453985",
"0.5566248",
"0.5520287",
"0.55193",
"0.5472117",
"0.5463804",
"0.5440467",
"0.541637",
"0.53849554",
"0.53834957",
"0.53764176",
"0.53638923",... | 0.76716536 | 0 |
Update specific memory slots If query_result is not supplied, relevance scores are not updated. | def update_ixs(self, ixs, embeddings, labels, query_result=None, global_update=True):
self.memory_embeddings[ixs] = embeddings
self.memory_labels[ixs] = labels
self.memory_age[ixs] = 0
self.memory_relevance[ixs] = 0
if global_update:
self.memory_age[self.memory_age !=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _update(self, nbrs, nbrs_y, query, query_y):\n\n # Set up the graph for our shared memory variables\n new_K, new_A, new_V = self.K, self.A, self.V\n\n # Condition (1): First returned neighbour shares the same query label\n correct_query = T.eq(nbrs_y[:, 0], query_y).nonzero()[0]\n ... | [
"0.61297095",
"0.5953453",
"0.5922591",
"0.5553142",
"0.544283",
"0.5403002",
"0.5356434",
"0.5338803",
"0.5331692",
"0.5323351",
"0.5294844",
"0.5292601",
"0.5231745",
"0.52154356",
"0.51240927",
"0.50593865",
"0.5058139",
"0.5054779",
"0.50533724",
"0.5042255",
"0.50057137"... | 0.620225 | 1 |
a decorator to add backing off retry symantics to any a method that does a database transaction. When using this decorator, it is vital that any exception within the 'exceptions_eligible_for_retry' tuple above must not be handled within the wrapped function. This means that exception handlers that handle 'Exception' mu... | def db_transaction_retry_wrapper(fn):
@ft.wraps(fn)
def f(self, *args, **kwargs):
backoffGenerator = util.backoffSecondsGenerator()
try:
while True:
try:
result = fn(self, *args, **kwargs)
return result
except exceptions_eligible_for_retry:
waitInSeconds =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def retry(func, *args, **kwargs):\n @functools.wraps(func)\n def wrapper(*w_args, **w_kwargs):\n w_kwargs.update(kwargs)\n return retry_function_on_deadlock(func, *w_args, **w_kwargs)\n\n return wrapper",
"def _retry(func):\n @wraps(func)\n def _retry_wrapper(self, *args, **k... | [
"0.67783445",
"0.6644641",
"0.6623299",
"0.6539066",
"0.6512475",
"0.6476035",
"0.6465493",
"0.64365405",
"0.6360299",
"0.6348828",
"0.6344524",
"0.6313005",
"0.62655896",
"0.6242453",
"0.6222092",
"0.62088233",
"0.6180234",
"0.6120076",
"0.60964835",
"0.6095427",
"0.60853565... | 0.7249463 | 0 |
Try to reuse this named connection, else create one and use that | def connection(self, name=None):
if not name:
name = threading.currentThread().getName()
if name in self:
return self[name]
self[name] = self.database.connection()
return self[name] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __get_database_connection(self, reuse=True):\n if not self.__database_connection or not reuse:\n if self.__database_connection:\n self.__database_connection.close()\n self.__database_connection = None\n\n self.__database_connection = http.client.HTTPCo... | [
"0.6629559",
"0.6570917",
"0.6535228",
"0.6433502",
"0.6412028",
"0.63429385",
"0.6253376",
"0.62532514",
"0.6220175",
"0.6215806",
"0.6163777",
"0.6153525",
"0.6101365",
"0.60986865",
"0.6085492",
"0.6082639",
"0.60321325",
"0.6022872",
"0.6020028",
"0.60199386",
"0.60167944... | 0.6910743 | 0 |
Just like connection, but returns a tuple with a connection and a cursor | def connectionCursorPair(self, name=None):
connection = self.connection(name)
return (connection, connection.cursor()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conn_curs():\n dbname = \"abcdefgh\"\n password = \"Acka-1jfue4-snYmkall\"\n host = \"db.elephantsql.com\"\n\n connection = psycopg2.connect(dbname=dbname, user=dbname,\n password=password, host=host)\n cursor = connection.cursor()\n return connection, cursor"... | [
"0.782685",
"0.74926525",
"0.7455024",
"0.7442478",
"0.7405349",
"0.73643297",
"0.7351544",
"0.73470646",
"0.73046917",
"0.72976387",
"0.7228983",
"0.7228983",
"0.72195446",
"0.7198042",
"0.7187905",
"0.71860284",
"0.71206516",
"0.70670146",
"0.70400053",
"0.700089",
"0.69696... | 0.81536436 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.